diff options
| author | Seth Alves <alves@src.gnome.org> | 2000-02-18 02:02:37 +0800 |
|---|---|---|
| committer | Seth Alves <alves@src.gnome.org> | 2000-02-18 02:02:37 +0800 |
| commit | 788bcf6373185aa29f8e2f83ad48cb10bf6e8a9b (patch) | |
| tree | f5f14715c1c0aede7eb872eda7166cd3ddcd7e3b /libical/src | |
| parent | b39cda14b7678b925a6e3e645b60fb9858fdfaf6 (diff) | |
| download | gsoc2013-evolution-788bcf6373185aa29f8e2f83ad48cb10bf6e8a9b.tar.gz gsoc2013-evolution-788bcf6373185aa29f8e2f83ad48cb10bf6e8a9b.tar.zst gsoc2013-evolution-788bcf6373185aa29f8e2f83ad48cb10bf6e8a9b.zip | |
Initial revision
svn path=/trunk/; revision=1823
Diffstat (limited to 'libical/src')
71 files changed, 31159 insertions, 0 deletions
diff --git a/libical/src/Makefile b/libical/src/Makefile new file mode 100644 index 0000000000..8478bc24cc --- /dev/null +++ b/libical/src/Makefile @@ -0,0 +1,9 @@ +# Generated automatically from Makefile.in by configure. +SUBDIRS = libical libicalss test + +all depend ci clean install: + for dir in $(SUBDIRS) ; do \ + (cd $$dir ; $(MAKE) $@) || exit 1; \ + done + + diff --git a/libical/src/Makefile.in b/libical/src/Makefile.in new file mode 100644 index 0000000000..3c778954a8 --- /dev/null +++ b/libical/src/Makefile.in @@ -0,0 +1,8 @@ +SUBDIRS = libical libicalss test + +all depend ci clean install: + for dir in $(SUBDIRS) ; do \ + (cd $$dir ; $(MAKE) $@) || exit 1; \ + done + + diff --git a/libical/src/libical/.gdb_history b/libical/src/libical/.gdb_history new file mode 100644 index 0000000000..55362e9165 --- /dev/null +++ b/libical/src/libical/.gdb_history @@ -0,0 +1,457 @@ +run +ptype E +graph display E +quit +run +print E +graph display E +up +print p +graph display p +ptype p +info line 'p' +graph display p +print parameter_iterator +break icalproperty.c:182 +run +next +print p +graph display p +quit +run +up +graph display p +print parameter_iterator +graph display p +print *(p) +quit +show directories +run +run +y +list usecases.c +list test_parameters +info line 'main' +info line 'test_parameters' +info line 'icalproperty_vanew_comment' +ptype icalproperty_add_parameters +info line 'icalproperty_add_parameters' +run +up +info line 'icalproperty_vanew_comment' +info line 'icalproperty_add_parameters' +break icalproperty.c:51 +run +step +next +nexti +info line 'icalproperty_vanew_comment' +info line 'icalproperty_add_parameters' +break icalproperty.c:53 +run +next +graph display vp +break icalparameter_isa_parameter +cont +run +step +next +quit +run +break icalcomponent_get_first_property +break icalcomponent_get_next_property +break icalcomponent_new +run +next +step +next +step +next +graph display impl +up +down +next +graph display *(impl) +next +cont +next +graph display c +next +graph display *(prop) +next +step +quit +run +up +graph display p +down +print E +up +print *(prop) +graph display *(prop) +down +up +print prop +print param +down +up +print p +up +break usecases.c:522 +run +step +next +up +run +step +next +step +next +quit +run +up +quit +info line 'test_memory' +break b1 +break usecases.c:558 +run +graph display *(f) +graph display *(p) +next +run +next +step +next +print pos +print *(pos) +graph display string +graph display *(pos) +next +set variable *pos = 0x8053520 +next +step +next +print buf_size +print *(buf_size) +print *(string) +ptype string +next +run +print f +graph display f +graph display p +next +step +next +run +next +graph display bufsize +next +quit +graph display test_memory +info line 'test_memory' +break usecases.c:560 +run +graph display f +next +graph display p +print p -f +print strlen(S1) +next +print p - f +print strlen(S1) + strlen(S2) +next +break usecases.c:572 +run +cont +step +graph display *(pos) +next +step +quit +info line 'test_memory' +break usecases.c:560 +set args +run +next +graph display f +graph display p +next +graph display bufsize +run +next +set args +run +quit +info line 'test_memory' +break usecases.c:560 +graph display f +graph display p +run +graph display f +graph display p +graph display bufsize +next +down +up +quit +run +where +frame 2 +break icalmemory.c:79 +run +next +run +graph display buffer_ring +run +ont(box, font) = font(box, font); +_fontfix(box) = fontfix(box); +ont(box, font) = font(box, font); +#pragma override font +font(box, font) = _fontfix(_font(box, string(font))); +ont(box, font) = font(box, font); +ist +list +print buffer_ring[buffer_pos] +break icalmemory.c:77 +run +cont +quit +run +up +break icalmemory.c:77 +break icalmemory.c:78 +run +graph display buffer_ring +next +cont +quit +run +up +break icalmemory.c:77 +run +break icalmemory.c:78 +cont +graph display buffer_ring[buffer_pos] +quit +break usecases.c:560 +run +step +break icalmemory.c:129 +disable 2 +next +info line 'icalmemory_resize_buffer' +break icalmemory.c:79 +cont +run +cont +next +run +cont +graph display buffer_ring[buffer_pos] +graph display buffer_ring +break icalmemory.c:78 +run +graph display buffer_pos +cont +run +cont +quit +info line 'test_memory' +info line 'icalmemory_append_string' +break icalmemory.c:78 +break icalmemory.c:79 +run +graph display buffer_ring +graph display buffer_ring[buffer_pos] +graph display buffer_pos +cont +next +free( buffer_ring[2] +free( buffer_ring[2] ) +call free(buffer_ring[2] ) +call free(buffer_ring[1] ) +free(buffer_ring[1]) +run +cont +set variable buffer_pos = 2 +next +run +cont +run +cont +run +cont +next +quit +info line 'test_memory' +info line 'icalmemory_append_string' +break icalmemory.c:78 +break icalmemory.c:79 +run +graph display buffer_ring +graph display buffer_pos +graph display buffer_ring[buffer_pos] +cont +run +cont +set variable buffer_pos = 2 +next +cont +next +cont +run +next +run +quit +info line 'test_memory' +info line 'icalmemory_append_string' +break icalmemory.c:76 +break icalmemory.c:77 +run +graph display buffer_ring +graph display buffer_pos +graph display buffer_ring[buffer_pos] +cont +next +cont +next +cont +run +cont +next +cont +run +cont +next +graph display rtrn +next +run +next +cont +next +run +step +run +next +quit +run +up +print pos +graph display string +run +up +break usecases.c:572 +run +print bufsize +step +next +step +quit +run +up +graph display buf_size +graph display *(buf_size) +break icalmemory.c:136 +run +next +run +graph display *(new_buf) +quit +run +up +down +break icalmemory.c:136 +run +graph display *(new_buf) +quit +run +up +break icalmemory.c:136 +run +print *(new_buf) +next +print *buf_size +print *bu +print *buf +next +print new_buf +quit +run +up +break icalmemory.c:136 +run +print *(new_buf) +graph display *(new_buf) +graph display new_pos +graph display *(buf) +next +graph display new_buf +run +next +run +graph display *(pos) +next +quit +info line 'test_memory' +info line 'icalmemory_append_string' +break icalmemory.c:136 +run +graph display *(buf_size) +next +quit +info line 'test_memory' +break usecases.c:570 +run +step +next +delete 1 +until usecases.c:572 +step +next +graph display *(buf_size) +next +graph display *(pos) +graph display *(buf) +graph display *(new_buf) +graph display new_buf +next +graph display string +print *pos - *buf +run +break icalmemory.c:136 +run +next +set variable *pos = 0x8054993 +next +run +next +set variable *pos = 0x8054980 +set variable *pos = 0x8054700 +next +run +next +down +up +down +quit +run < ../../test-data/1.1 +up +break icalproperty.c:165 +run +next +run +info line 'icalvalue_as_ical_string' +break icalvalue.c:424 +cont +next +print value +next +run +up +cont +up +print *(prop) +graph display *(icalproperty_impl*)prop +quit + diff --git a/libical/src/libical/.gdbinit b/libical/src/libical/.gdbinit new file mode 100644 index 0000000000..19de9b8209 --- /dev/null +++ b/libical/src/libical/.gdbinit @@ -0,0 +1,3 @@ +directory /home/eric/proj/FreeAssociation/libical/src/pvl/ +path /home/eric/proj/FreeAssociation/libical/src/pvl/ + diff --git a/libical/src/libical/Makefile b/libical/src/libical/Makefile new file mode 100644 index 0000000000..90b59fbc91 --- /dev/null +++ b/libical/src/libical/Makefile @@ -0,0 +1,120 @@ +# Generated automatically from Makefile.in by configure. +DESIGNDATA = ../../design-data +SCRIPTS = ../../scripts +SOURCES = icalcomponent.c icalproperty.c icalparameter.c icalenums.c icalvalue.c icalerror.c icalmemory.c icaltypes.c icalparser.c icalrestriction.c pvl.c +OBJECTS = ${SOURCES:.c=.o} +INCLUDES = -I . -I.. +CFLAGS = -Wall -g $(INCLUDES) -DSTDC_HEADERS=1 -DHAVE_MALLOC_H=1 -DHAVE_UNISTD_H=1 -DHAVE_TIME_H=1 -DHAVE_STDIO_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_ASSERT_H=1 -DHAVE_STRDUP=1 -DICAL_ERRORS_ARE_FATAL +LIBS = +CC = gcc +AR = ar cr +RANLIB = ranlib + +prefix = /usr/local +PREFIX = ${prefix} +EXEC_PREFIX = ${prefix} +BIN_DIR = $(EXEC_PREFIX)/bin +LIB_DIR = $(EXEC_PREFIX)/lib +INCLUDE_DIR = $(PREFIX)/include + +INSTALL = /usr/bin/install -c +INSTALL_DATA = ${INSTALL} -m 644 +INSTALL_PROGRAM= ${INSTALL} -m 755 + +all: lib + +test: $(OBJECTS) usecases.o + $(CC) -o icaltest $(OBJECTS) usecases.o $(INCLUDES) $(LIBS) + icaltest + +icalitip.tab.c: icalitip.y + bison -d -v -t icalitip.y + +lex.yy.c: icalitip.l + flex -s icalitip.l + + +lib: icalitip.tab.o lex.yy.o $(OBJECTS) + $(AR) libical.a icalitip.tab.o lex.yy.o $(OBJECTS) + $(RANLIB) libical.a + + +clean: + -/bin/rm -f *.o *.a + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -f icaltest parser core output *.output + +ci: clean + ci -u *.c *.h *.l *.y Makefile.in + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + + +install: + $(INSTALL_DATA) libical.a $(LIB_DIR)/libical.a; + for i in `ls *.h`; \ + do \ + $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \ + done; + + +derived: icalproperty icalparameter icalvalue + +icalproperty: + $(SCRIPTS)/mkderivedproperties.pl -i icalproperty.h -h $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newh + mv icalproperty.newh icalproperty.h + + $(SCRIPTS)/mkderivedproperties.pl -i icalproperty.c -c $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newc + mv icalproperty.newc icalproperty.c + + +icalparameter: + $(SCRIPTS)/mkderivedparameters.pl -i icalparameter.h -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh + mv icalparameter.newh icalparameter.h + + $(SCRIPTS)/mkderivedparameters.pl -i icalparameter.c -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc + mv icalparameter.newc icalparameter.c + +icalvalue: + $(SCRIPTS)/mkderivedvalues.pl -i icalvalue.h -h $(DESIGNDATA)/value-c-types.txt > icalvalue.newh + mv icalvalue.newh icalvalue.h + + $(SCRIPTS)/mkderivedvalues.pl -i icalvalue.c -c $(DESIGNDATA)/value-c-types.txt > icalvalue.newc + mv icalvalue.newc icalvalue.c + + +#icalderivedcomponents.h: $(DESIGNDATA)/components.txt $(SCRIPTS)/mkderivedcomponents.pl +# $(SCRIPTS)/mkderivedcomponents.pl -h $(DESIGNDATA)/components.txt > icalderivedcomponents.h + +#icalderivedcomponents.inc: $(DESIGNDATA)/components.txt $(SCRIPTS)/mkderivedcomponents.pl +# $(SCRIPTS)/mkderivedcomponents.pl -c $(DESIGNDATA)/components.txt > icalderivedcomponents.inc + +# DO NOT DELETE + +icalcomponent.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalcomponent.o: icalproperty.h icalcomponent.h icalerror.h +icalcomponent.o: icalmemory.h + +icalproperty.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalproperty.o: icalproperty.h icalcomponent.h icalerror.h +icalproperty.o: icalmemory.h + +icalparameter.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalparameter.o: icalproperty.h icalcomponent.h icalerror.h icalmemory.h + +icalenums.o: icalenums.h + +icalvalue.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalvalue.o: icalproperty.h icalcomponent.h icalerror.h icalmemory.h +icalvalue.o: icalparser.h +icalerror.o: icalerror.h + +icalmemory.o: icalmemory.h icalerror.h + +icaltypes.o: icaltypes.h icalerror.h + +icalparser.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalparser.o: icalproperty.h icalcomponent.h icalparser.h +icalparser.o: icalmemory.h diff --git a/libical/src/libical/Makefile.in b/libical/src/libical/Makefile.in new file mode 100644 index 0000000000..c7281ccd59 --- /dev/null +++ b/libical/src/libical/Makefile.in @@ -0,0 +1,119 @@ +DESIGNDATA = ../../design-data +SCRIPTS = ../../scripts +SOURCES = icalcomponent.c icalproperty.c icalparameter.c icalenums.c icalvalue.c icalerror.c icalmemory.c icaltypes.c icalparser.c icalrestriction.c pvl.c +OBJECTS = ${SOURCES:.c=.o} +INCLUDES = -I . -I.. +CFLAGS = -Wall @CFLAGS@ $(INCLUDES) @DEFS@ -DICAL_ERRORS_ARE_FATAL +LIBS = +CC = @CC@ +AR = @AR@ cr +RANLIB = @RANLIB@ + +prefix = @prefix@ +PREFIX = ${prefix} +EXEC_PREFIX = @exec_prefix@ +BIN_DIR = $(EXEC_PREFIX)/bin +LIB_DIR = $(EXEC_PREFIX)/lib +INCLUDE_DIR = $(PREFIX)/include + +INSTALL = @INSTALL@ +INSTALL_DATA = ${INSTALL} -m 644 +INSTALL_PROGRAM= ${INSTALL} -m 755 + +all: lib + +test: $(OBJECTS) usecases.o + $(CC) -o icaltest $(OBJECTS) usecases.o $(INCLUDES) $(LIBS) + icaltest + +icalitip.tab.c: icalitip.y + bison -d -v -t icalitip.y + +lex.yy.c: icalitip.l + flex -s icalitip.l + + +lib: icalitip.tab.o lex.yy.o $(OBJECTS) + $(AR) libical.a icalitip.tab.o lex.yy.o $(OBJECTS) + $(RANLIB) libical.a + + +clean: + -/bin/rm -f *.o *.a + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -f icaltest parser core output *.output + +ci: clean + ci -u *.c *.h *.l *.y Makefile.in + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + + +install: + $(INSTALL_DATA) libical.a $(LIB_DIR)/libical.a; + for i in `ls *.h`; \ + do \ + $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \ + done; + + +derived: icalproperty icalparameter icalvalue + +icalproperty: + $(SCRIPTS)/mkderivedproperties.pl -i icalproperty.h -h $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newh + mv icalproperty.newh icalproperty.h + + $(SCRIPTS)/mkderivedproperties.pl -i icalproperty.c -c $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newc + mv icalproperty.newc icalproperty.c + + +icalparameter: + $(SCRIPTS)/mkderivedparameters.pl -i icalparameter.h -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh + mv icalparameter.newh icalparameter.h + + $(SCRIPTS)/mkderivedparameters.pl -i icalparameter.c -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc + mv icalparameter.newc icalparameter.c + +icalvalue: + $(SCRIPTS)/mkderivedvalues.pl -i icalvalue.h -h $(DESIGNDATA)/value-c-types.txt > icalvalue.newh + mv icalvalue.newh icalvalue.h + + $(SCRIPTS)/mkderivedvalues.pl -i icalvalue.c -c $(DESIGNDATA)/value-c-types.txt > icalvalue.newc + mv icalvalue.newc icalvalue.c + + +#icalderivedcomponents.h: $(DESIGNDATA)/components.txt $(SCRIPTS)/mkderivedcomponents.pl +# $(SCRIPTS)/mkderivedcomponents.pl -h $(DESIGNDATA)/components.txt > icalderivedcomponents.h + +#icalderivedcomponents.inc: $(DESIGNDATA)/components.txt $(SCRIPTS)/mkderivedcomponents.pl +# $(SCRIPTS)/mkderivedcomponents.pl -c $(DESIGNDATA)/components.txt > icalderivedcomponents.inc + +# DO NOT DELETE + +icalcomponent.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalcomponent.o: icalproperty.h icalcomponent.h icalerror.h +icalcomponent.o: icalmemory.h + +icalproperty.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalproperty.o: icalproperty.h icalcomponent.h icalerror.h +icalproperty.o: icalmemory.h + +icalparameter.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalparameter.o: icalproperty.h icalcomponent.h icalerror.h icalmemory.h + +icalenums.o: icalenums.h + +icalvalue.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalvalue.o: icalproperty.h icalcomponent.h icalerror.h icalmemory.h +icalvalue.o: icalparser.h +icalerror.o: icalerror.h + +icalmemory.o: icalmemory.h icalerror.h + +icaltypes.o: icaltypes.h icalerror.h + +icalparser.o: ical.h icalenums.h icalvalue.h icaltypes.h icalparameter.h +icalparser.o: icalproperty.h icalcomponent.h icalparser.h +icalparser.o: icalmemory.h diff --git a/libical/src/libical/base64.c b/libical/src/libical/base64.c new file mode 100644 index 0000000000..5925f977ac --- /dev/null +++ b/libical/src/libical/base64.c @@ -0,0 +1,323 @@ +/* + + Encode or decode file as MIME base64 (RFC 1341) + + by John Walker + http://www.fourmilab.ch/ + + This program is in the public domain. + +*/ + +#define REVDATE "11th August 1997" + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <string.h> + +#define TRUE 1 +#define FALSE 0 + +#define LINELEN 72 /* Encoded line length (max 76) */ + +typedef unsigned char byte; /* Byte type */ + +static FILE *fi = stdin; /* Input file */ +static FILE *fo = stdout; /* Output file */ +static byte iobuf[256]; /* I/O buffer */ +static int iolen = 0; /* Bytes left in I/O buffer */ +static int iocp = 256; /* Character removal pointer */ +static int ateof = FALSE; /* EOF encountered */ +static byte dtable[256]; /* Encode / decode table */ +static int linelength = 0; /* Length of encoded output line */ +static char eol[] = "\r\n"; /* End of line sequence */ +static int errcheck = TRUE; /* Check decode input for errors ? */ + +/* INBUF -- Fill input buffer with data */ + +static int inbuf(void) +{ + int l; + + if (ateof) { + return FALSE; + } + l = fread(iobuf, 1, 256, fi); /* Read input buffer */ + if (l <= 0) { + if (ferror(fi)) { + exit(1); + } + ateof = TRUE; + return FALSE; + } + iolen = l; + iocp = 0; + return TRUE; +} + +/* INCHAR -- Return next character from input */ + +static int inchar(void) +{ + if (iocp >= iolen) { + if (!inbuf()) { + return EOF; + } + } + + return iobuf[iocp++]; +} + +/* OCHAR -- Output an encoded character, inserting line breaks + where required. */ + +static void ochar(int c) +{ + if (linelength >= LINELEN) { + if (fputs(eol, fo) == EOF) { + exit(1); + } + linelength = 0; + } + if (putc(((byte) c), fo) == EOF) { + exit(1); + } + linelength++; +} + +/* ENCODE -- Encode binary file into base64. */ + +static void encode(void) +{ + int i, hiteof = FALSE; + + /* Fill dtable with character encodings. */ + + for (i = 0; i < 26; i++) { + dtable[i] = 'A' + i; + dtable[26 + i] = 'a' + i; + } + for (i = 0; i < 10; i++) { + dtable[52 + i] = '0' + i; + } + dtable[62] = '+'; + dtable[63] = '/'; + + while (!hiteof) { + byte igroup[3], ogroup[4]; + int c, n; + + igroup[0] = igroup[1] = igroup[2] = 0; + for (n = 0; n < 3; n++) { + c = inchar(); + if (c == EOF) { + hiteof = TRUE; + break; + } + igroup[n] = (byte) c; + } + if (n > 0) { + ogroup[0] = dtable[igroup[0] >> 2]; + ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)]; + ogroup[2] = dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)]; + ogroup[3] = dtable[igroup[2] & 0x3F]; + + /* Replace characters in output stream with "=" pad + characters if fewer than three characters were + read from the end of the input stream. */ + + if (n < 3) { + ogroup[3] = '='; + if (n < 2) { + ogroup[2] = '='; + } + } + for (i = 0; i < 4; i++) { + ochar(ogroup[i]); + } + } + } + if (fputs(eol, fo) == EOF) { + exit(1); + } +} + +/* INSIG -- Return next significant input */ + +static int insig(void) +{ + int c; + + /*CONSTANTCONDITION*/ + while (TRUE) { + c = inchar(); + if (c == EOF || (c > ' ')) { + return c; + } + } + /*NOTREACHED*/ +} + +/* DECODE -- Decode base64. */ + +static void decode(void) +{ + int i; + + for (i = 0; i < 255; i++) { + dtable[i] = 0x80; + } + for (i = 'A'; i <= 'Z'; i++) { + dtable[i] = 0 + (i - 'A'); + } + for (i = 'a'; i <= 'z'; i++) { + dtable[i] = 26 + (i - 'a'); + } + for (i = '0'; i <= '9'; i++) { + dtable[i] = 52 + (i - '0'); + } + dtable['+'] = 62; + dtable['/'] = 63; + dtable['='] = 0; + + /*CONSTANTCONDITION*/ + while (TRUE) { + byte a[4], b[4], o[3]; + + for (i = 0; i < 4; i++) { + int c = insig(); + + if (c == EOF) { + if (errcheck && (i > 0)) { + fprintf(stderr, "Input file incomplete.\n"); + exit(1); + } + return; + } + if (dtable[c] & 0x80) { + if (errcheck) { + fprintf(stderr, "Illegal character '%c' in input file.\n", c); + exit(1); + } + /* Ignoring errors: discard invalid character. */ + i--; + continue; + } + a[i] = (byte) c; + b[i] = (byte) dtable[c]; + } + o[0] = (b[0] << 2) | (b[1] >> 4); + o[1] = (b[1] << 4) | (b[2] >> 2); + o[2] = (b[2] << 6) | b[3]; + i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3); + if (fwrite(o, i, 1, fo) == EOF) { + exit(1); + } + if (i < 3) { + return; + } + } +} + +/* USAGE -- Print how-to-call information. */ + +static void usage(char *pname) +{ + fprintf(stderr, "%s -- Encode/decode file as base64. Call:\n", pname); + fprintf(stderr, + " %s [-e[ncode] / -d[ecode]] [-n] [infile] [outfile]\n", pname); + fprintf(stderr, "\n"); + fprintf(stderr, "Options:\n"); + fprintf(stderr, " -D Decode base64 encoded file\n"); + fprintf(stderr, " -E Encode file into base64\n"); + fprintf(stderr, " -N Ignore errors when decoding\n"); + fprintf(stderr, " -U Print this message\n"); + fprintf(stderr, "\n"); + fprintf(stderr, "by John Walker\n"); + fprintf(stderr, " WWW: http://www.fourmilab.ch/\n"); +} + +/* Main program */ + +int main(int argc, char *argv[]) +{ + int i, f = 0, decoding = FALSE; + char *cp, opt; + + for (i = 1; i < argc; i++) { + cp = argv[i]; + if (*cp == '-') { + opt = *(++cp); + if (islower(opt)) { + opt = toupper(opt); + } + switch (opt) { + + case 'D': /* -D Decode */ + decoding = TRUE; + break; + + case 'E': /* -E Encode */ + decoding = FALSE; + break; + + case 'N': /* -N Suppress error checking */ + errcheck = FALSE; + break; + + case 'U': /* -U Print how-to-call information */ + case '?': + usage(argv[0]); + return 0; + } + } else { + switch (f) { + + /** Warning! On systems which distinguish text mode and + binary I/O (MS-DOS, Macintosh, etc.) the modes in these + open statements will have to be made conditional based + upon whether an encode or decode is being done, which + will have to be specified earlier. But it's worse: if + input or output is from standard input or output, the + mode will have to be changed on the fly, which is + generally system and compiler dependent. 'Twasn't me + who couldn't conform to Unix CR/LF convention, so + don't ask me to write the code to work around + Apple and Microsoft's incompatible standards. **/ + + case 0: + if (strcmp(cp, "-") != 0) { + if ((fi = fopen(cp, "r")) == NULL) { + fprintf(stderr, "Cannot open input file %s\n", cp); + return 2; + } + } + f++; + break; + + case 1: + if (strcmp(cp, "-") != 0) { + if ((fo = fopen(cp, "w")) == NULL) { + fprintf(stderr, "Cannot open output file %s\n", cp); + return 2; + } + } + f++; + break; + + default: + fprintf(stderr, "Too many file names specified.\n"); + usage(argv[0]); + return 2; + } + } + } + + if (decoding) { + decode(); + } else { + encode(); + } + return 0; +} diff --git a/libical/src/libical/filelock.c b/libical/src/libical/filelock.c new file mode 100644 index 0000000000..0376bc2bec --- /dev/null +++ b/libical/src/libical/filelock.c @@ -0,0 +1,143 @@ + +/* + I Stole this from: + http://www.cis.temple.edu/~ingargio/old/cis307s96/readings/rwlockexample.html + + CIS 307: An example using Read/Write File Locks + [fcntl.h], [fcntl.c], [fcntlmain.c] + +In Stevens "Advanced Programming in the Unix Environment" we see ways to use +the Unix service fcntl to lock portions of a file for reading and writing in +the manner stated in the Reader and Writer problem [any number of readers at +a time, but writers must operate alone]. Here we have three files that adapt +and use the code from Stevens: + +*fcntl.h: Specification of the locking functions. +*fcntl.c: Implementation of the locking functions. +*fcntlmain.c: Driver that does a simple test of the locking functions. + +WARNING: A file lock request which is blocked can be interrupted by a +signal. In this case the lock operation returns EINTR. Thus we may think we +got a lock when we really don't. A solution is to block signals when +locking. Another solution is to test the value returned by the lock +operation and relock if the value is EINTR. Another solution, which we adopt +here, is to do nothing about it. + +/* fcntl.c -- Defines mutexes in terms of read/write locks on files. + * (code is mostly from Stevens: Advanced Programming in the + * Unix environment. See from page 367 on. + * filerwlock, filerwlockCreate, filerwlockDelete, + * filerwreadlock, filerwlongreadlock, filerwlongunlock, + * filerwlockUnlock + */ + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +int lock_reg(int, int, int, off_t, int, off_t); + +#define read_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, len) + +#define readw_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_RDLCK, offset, whence, len) + +#define write_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, len) + +#define writew_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_WRLCK, offset, whence, len) + +#define un_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_UNLCK, offset, whence, len) + +pid_t lock_test(int, int , off_t , int , off_t ); + +#define is_readlock(fd, offset, whence, len) \ + lock_test(fd, F_RDLCK, offset, whence, len) + +#define is_writelock(fd, offset, whence, len) \ + lock_test(fd, F_WRLCK, offset, whence, len) + +int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len) +{ + struct flock lock; + lock.l_type = type; /* F_RDLCK, F_WRLCK, F_UNLCK */ + lock.l_start = offset; /* byte offset relative to l_whence */ + lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */ + lock.l_len = len; /* #bytes (0 means to EOF) */ + return (fcntl(fd, cmd, &lock)); +} + +pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len) +{ + struct flock lock; + lock.l_type = type; /* F_RDLCK or F_WRLCK */ + lock.l_start = offset; /* byte offset relative to l_whence */ + lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */ + lock.l_len = len; /* #bytes (0 means to EOF) */ + if (fcntl(fd,F_GETLK,&lock) < 0){ + perror("fcntl"); exit(1);} + if (lock.l_type == F_UNLCK) + return (0); /* false, region is not locked by another process */ + return (lock.l_pid); /* true, return pid of lock owner */ +} + +typedef struct { + int fd; + int n;} filerwlock; + +/* Create N read/write locks and returns the id of this cluster of locks. */ +filerwlock * filerwlockCreate(char *filename, int n) { + filerwlock *fl = (filerwlock *)malloc(sizeof(filerwlock)); + if (((fl->fd) = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IWUSR)) < 0) { + perror("open"); + exit(1);} + fl->n = n; + return fl; + } + +/* Delete the cluster of read/write locks associated with fl. */ +int filerwlockDelete(filerwlock *fl) { + if (close(fl->fd) < 0) { + perror("close"); + exit(1);} + return free(fl); + } + +/* Given the read/write lock cluster fl, lock its ith element */ +int filerwreadlock(filerwlock *fl, int i) { + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockLock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + readw_lock(fl->fd, i, SEEK_SET, 1); + } + +int filerwwritelock(filerwlock *fl, int i) { + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockLock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + writew_lock(fl->fd, i, SEEK_SET, 1); + } + +/* Given the lock cluster fl, unlock its ith element */ +int filerwunlock(filerwlock *fl, int i){ + + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockUnlock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + un_lock(fl->fd, i, SEEK_SET, 1); + } + +/* Given the lock cluster fl, it read locks all its elements */ +int filerwlongreadlock(filerwlock *fl) { + readw_lock(fl->fd, 0, SEEK_SET, fl->n); +} + +/* Given the lock cluster fl, it unlocks all its elements */ +int filerwlongunlock(filerwlock *fl) { + un_lock(fl->fd, 0, SEEK_SET, fl->n); +} + diff --git a/libical/src/libical/filelock.h b/libical/src/libical/filelock.h new file mode 100644 index 0000000000..dbe0715cc6 --- /dev/null +++ b/libical/src/libical/filelock.h @@ -0,0 +1,57 @@ +/* + I Stole this from: + http://www.cis.temple.edu/~ingargio/old/cis307s96/readings/rwlockexample.html + + CIS 307: An example using Read/Write File Locks + [fcntl.h], [fcntl.c], [fcntlmain.c] + +In Stevens "Advanced Programming in the Unix Environment" we see ways to use +the Unix service fcntl to lock portions of a file for reading and writing in +the manner stated in the Reader and Writer problem [any number of readers at +a time, but writers must operate alone]. Here we have three files that adapt +and use the code from Stevens: + +*fcntl.h: Specification of the locking functions. +*fcntl.c: Implementation of the locking functions. +*fcntlmain.c: Driver that does a simple test of the locking functions. + +WARNING: A file lock request which is blocked can be interrupted by a +signal. In this case the lock operation returns EINTR. Thus we may think we +got a lock when we really don't. A solution is to block signals when +locking. Another solution is to test the value returned by the lock +operation and relock if the value is EINTR. Another solution, which we adopt +here, is to do nothing about it. + +fcntl.h + +*/ + +/* fcntl.h -- Defines mutexes in terms of read/write locks on files. + * filerwlock, filerwlockCreate, filerwlockDelete, + * filerwreadlock, filerwlockUnlock + */ + +typedef struct { + int fd; + int n; +} filerwlock; + +/* Create N read/write locks and returns the id of this cluster of locks. */ +filerwlock * filerwlockCreate(char *filename, int n); + +/* Delete the cluster of read/write locks associated with fl. */ +int filerwlockDelete(filerwlock *fl); + +/* Given the read/write lock cluster fl, lock its ith element */ +int filerwreadlock(filerwlock *fl, int i); + +int filerwwritelock(filerwlock *fl, int i); + +/* Given the lock cluster fl, unlock its ith element */ +int filerwunlock(filerwlock *fl, int i); + +/* Given the lock cluster fl, it read locks all its elements */ +int filerwlongreadlock(filerwlock *fl); + +/* Given the lock cluster fl, it unlocks all its elements */ +int filerwlongunlock(filerwlock *fl); diff --git a/libical/src/libical/foo b/libical/src/libical/foo new file mode 100644 index 0000000000..f46fdc7814 --- /dev/null +++ b/libical/src/libical/foo @@ -0,0 +1,1578 @@ +/* + ====================================================================== + File: icalrestriction.c + + (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. + + + ======================================================================*/ + +#include "icalenums.h" +#include "icalrestriction.h" + +/* Define the structs for the restrictions. these data are filled out +in machine generated code below */ + +typedef struct icalrestriction_property_record { + icalproperty_method method; + icalcomponent_kind component; + icalproperty_kind property; + icalrestriction_kind restriction; +} icalrestriction_property_record; + + +typedef struct icalrestriction_component_record { + icalproperty_method method; + icalcomponent_kind component; + icalcomponent_kind subcomponent; + icalrestriction_kind restriction; +} icalrestriction_component_record; + +icalrestriction_component_record icalrestriction_component_records[]; +icalrestriction_property_record icalrestriction_property_records[]; + +/* 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' */ + +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 more",/*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]; + +} + +int icalrestriction_check_component(icalproperty_method method, + icalcomponent* comp) +{ + icalproperty_kind kind; + icalcomponent_kind comp_kind; + icalrestriction_kind restr; + 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); + + restr = icalrestriction_get_property_restriction(method, + comp_kind, + kind); + + + if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ) { + /* HACK. Treat this as a 0/1 restriction */ + restr = ICAL_RESTRICTION_ZEROORONE; + compare = icalrestriction_compare(restr,count); + } else if (restr == ICAL_RESTRICTION_ONEMUTUAL ) { + /* HACK. Treat this as a 0/1 restriction */ + restr = ICAL_RESTRICTION_ZEROORONE; + compare = icalrestriction_compare(restr,count); + } else { + compare = icalrestriction_compare(restr,count); + } + + assert(compare != -1); + + + if (compare == 0){ + char temp[1024]; + + sprintf(temp, "Failed iTIP restrictions for property %s. 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)); + } + + + 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_kind +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].restriction; + } + } + + return ICAL_RESTRICTION_UNKNOWN; +} + +icalrestriction_kind +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].restriction; + } + } + + return ICAL_RESTRICTION_UNKNOWN; +} + +/* Everything below this line is machine generated. Do not edit. */ +icalrestriction_property_record icalrestriction_property_records[] = { + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_check_exclusive}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_check_exclusive}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_check_exclusive}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_check_exclusive}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE} +}; +icalrestriction_component_record icalrestriction_component_records[] = { + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE} +}; diff --git a/libical/src/libical/ical.h b/libical/src/libical/ical.h new file mode 100644 index 0000000000..a90bb551ed --- /dev/null +++ b/libical/src/libical/ical.h @@ -0,0 +1,41 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: ical.h + CREATOR: eric 20 March 1999 + + + (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 ical.h + +======================================================================*/ + +#ifndef ICAL_H +#define ICAL_H + +#include "icalenums.h" +#include "icalvalue.h" +#include "icalparameter.h" +#include "icalproperty.h" +#include "icalcomponent.h" +#include "icaltypes.h" +#include "icalparser.h" +#include "icalmemory.h" +#include "icalerror.h" + +#endif /* !ICAL_H */ + + + diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c new file mode 100644 index 0000000000..a1a2535e7a --- /dev/null +++ b/libical/src/libical/icalcomponent.c @@ -0,0 +1,700 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalcomponent.c + CREATOR: eric 28 April 1999 + + $Id$ + + + (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 icalcomponent.c + +======================================================================*/ + +#include "ical.h" +#include "pvl.h" /* "Pointer-to-void list" */ +#include <stdlib.h> /* for malloc */ +#include <stdarg.h> /* for va_list, etc */ +#include <errno.h> +#include "icalerror.h" +#include <assert.h> +#include <stdio.h> /* for fprintf */ +#include "icalmemory.h" +#include "icalenums.h" + + +/* icalproperty functions that only components get to use */ +void icalproperty_set_parent(icalproperty* property, + icalcomponent* component); + +icalcomponent* icalproperty_get_parent(icalproperty* property); + + + +struct icalcomponent_impl +{ + char id[5]; + icalcomponent_kind kind; + char* x_name; + pvl_list properties; + pvl_elem property_iterator; + pvl_list components; + pvl_elem component_iterator; + icalcomponent* parent; +}; + +void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args) +{ + void* vp; + + while((vp = va_arg(args, void*)) != 0) { + + assert (icalcomponent_isa_component(vp) != 0 || + icalproperty_isa_property(vp) != 0 ) ; + + if (icalcomponent_isa_component(vp) != 0 ){ + + icalcomponent_add_component((icalcomponent*)impl, + (icalcomponent*)vp); + + } else if (icalproperty_isa_property(vp) != 0 ){ + + icalcomponent_add_property((icalcomponent*)impl, + (icalproperty*)vp); + } + } +} + +icalcomponent* +icalcomponent_new_impl (icalcomponent_kind kind) +{ + struct icalcomponent_impl* comp; + + if ( ( comp = (struct icalcomponent_impl*) + malloc(sizeof(struct icalcomponent_impl))) == 0) { + errno = ENOMEM; + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + strcpy(comp->id,"comp"); + + comp->kind = kind; + comp->properties = pvl_newlist(); + comp->property_iterator = 0; + comp->components = pvl_newlist(); + comp->component_iterator = 0; + comp->x_name = 0; + comp->parent = 0; + + return comp; +} + +icalcomponent* +icalcomponent_new (icalcomponent_kind kind) +{ + return (icalcomponent*)icalcomponent_new_impl(kind); +} + +icalcomponent* +icalcomponent_vanew (icalcomponent_kind kind, ...) +{ + va_list args; + + struct icalcomponent_impl *impl = icalcomponent_new_impl(kind); + + if (impl == 0){ + return 0; + } + + va_start(args,kind); + icalcomponent_add_children(impl, args); + va_end(args); + + return (icalcomponent*) impl; +} + +icalcomponent* icalcomponent_new_from_string(char* str) +{ + icalcomponent_kind kind; + + icalerror_check_arg_rz( (str!=0), "str"); + + kind = icalenum_string_to_component_kind(str); + + if (kind == ICAL_NO_COMPONENT){ + return 0; + } + + return icalcomponent_new(kind); +} + +icalcomponent* icalcomponent_new_clone(icalcomponent* component) +{ + struct icalcomponent_impl *old = (struct icalcomponent_impl*)component; + struct icalcomponent_impl *new; + icalproperty *p; + icalcomponent *c; + + icalerror_check_arg_rv( (component!=0), "component"); + + new = icalcomponent_new_impl(old->kind); + + if (new == 0){ + return 0; + } + + + for(p = icalcomponent_get_first_property(old,ICAL_ANY_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(old,ICAL_ANY_PROPERTY)){ + + icalcomponent_add_property(new,icalproperty_new_clone(p)); + } + + + for(c = icalcomponent_get_first_component(old,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(old,ICAL_ANY_COMPONENT)){ + + icalcomponent_add_component(new,icalcomponent_new_clone(c)); + } + + return new; + +} + + +void +icalcomponent_free (icalcomponent* component) +{ + icalproperty* prop; + icalcomponent* comp; + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + icalerror_check_arg_rv( (component!=0), "component"); + +#ifdef ICAL_FREE_ON_LIST_IS_ERROR + icalerror_assert( (c->parent ==0),"Tried to free a component that is still attached to a parent component"); +#else + if(c->parent != 0){ + return; + } +#endif + + if(component != 0 ){ + + while( (prop=pvl_pop(c->properties)) != 0){ + assert(prop != 0); + icalproperty_set_parent(prop,0); + icalproperty_free(prop); + } + + pvl_free(c->properties); + + while( (comp=pvl_data(pvl_head(c->components))) != 0){ + assert(comp!=0); + icalcomponent_remove_component(component,comp); + icalcomponent_free(comp); + } + + pvl_free(c->components); + + if (c->x_name != 0) { + free(c->x_name); + } + + c->kind = ICAL_NO_COMPONENT; + c->properties = 0; + c->property_iterator = 0; + c->components = 0; + c->component_iterator = 0; + c->x_name = 0; + c->id[0] = 'X'; + + free(c); + } +} + +char* +icalcomponent_as_ical_string (icalcomponent* component) +{ + char* buf, *out_buf; + char* tmp_buf; + size_t buf_size = 1024; + char* buf_ptr = 0; + + icalcomponent *c; + icalproperty *p; + icalcomponent_kind kind = icalcomponent_isa(component); + + char* kind_string; + + buf = icalmemory_new_buffer(buf_size); + buf_ptr = buf; + + icalerror_check_arg_rz( (component!=0), "component"); + icalerror_check_arg_rz( (kind!=ICAL_NO_COMPONENT), "component kind is ICAL_NO_COMPONENT"); + + kind_string = icalenum_component_kind_to_string(kind); + + icalerror_check_arg_rz( (kind_string!=0),"Unknown kind of component"); + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:"); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + + for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY)){ + + tmp_buf = icalproperty_as_ical_string(p); + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf); + } + + + for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ + + tmp_buf = icalcomponent_as_ical_string(c); + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf); + + } + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:"); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, + icalenum_component_kind_to_string(kind)); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + out_buf = icalmemory_tmp_copy(buf); + free(buf); + + return out_buf; +} + + +int +icalcomponent_is_valid (icalcomponent* component) +{ + struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component; + + + if ( (strcmp(impl->id,"comp") == 0) && + impl->kind != ICAL_NO_COMPONENT){ + return 1; + } else { + return 0; + } + +} + + +icalcomponent_kind +icalcomponent_isa (icalcomponent* component) +{ + struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component; + icalerror_check_arg_rz( (component!=0), "component"); + + if(component != 0) + { + return impl->kind; + } + + return ICAL_NO_COMPONENT; +} + + +int +icalcomponent_isa_component (void* component) +{ + struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component; + + icalerror_check_arg_rz( (component!=0), "component"); + + if (strcmp(impl->id,"comp") == 0) { + return 1; + } else { + return 0; + } + +} + +int icalcomponent_property_sorter(void *a, void *b) +{ + icalproperty_kind kinda, kindb; + char *ksa, *ksb; + + kinda = icalproperty_isa((icalproperty*)a); + kindb = icalproperty_isa((icalproperty*)b); + + ksa = icalenum_property_kind_to_string(kinda); + ksb = icalenum_property_kind_to_string(kindb); + + return strcmp(ksa,ksb); +} + + +void +icalcomponent_add_property (icalcomponent* component, icalproperty* property) +{ + struct icalcomponent_impl *impl; + + icalerror_check_arg_rv( (component!=0), "component"); + icalerror_check_arg_rv( (property!=0), "property"); + + impl = (struct icalcomponent_impl*)component; + + icalerror_assert( (!icalproperty_get_parent(property)),"The property has already been added to a component. Remove the property with icalcomponent_remove_property before calling icalcomponent_add_property"); + + icalproperty_set_parent(property,component); + +#ifdef ICAL_INSERT_ORDERED + pvl_insert_ordered(impl->properties, + icalcomponent_property_sorter,property); +#else + pvl_push(impl->properties,property); +#endif + +} + + +void +icalcomponent_remove_property (icalcomponent* component, icalproperty* property) +{ + struct icalcomponent_impl *impl; + pvl_elem itr, next_itr; + struct icalproperty_impl *pimpl; + + icalerror_check_arg_rv( (component!=0), "component"); + icalerror_check_arg_rv( (property!=0), "property"); + + impl = (struct icalcomponent_impl*)component; + + pimpl = (struct icalproperty_impl*)property; + + icalerror_assert( (icalproperty_get_parent(property)),"The property is not a member of a component"); + + + for( itr = pvl_head(impl->properties); + itr != 0; + itr = next_itr) + { + next_itr = pvl_next(itr); + + if( pvl_data(itr) == (void*)property ){ + + if (impl->property_iterator == itr){ + impl->property_iterator = pvl_next(itr); + } + + pvl_remove( impl->properties, itr); + icalproperty_set_parent(property,0); + } + } +} + +int +icalcomponent_count_properties (icalcomponent* component, icalproperty_kind kind) +{ + int count=0; + icalproperty *p; + icalerror_check_arg_rz( (component!=0), "component"); + + for(p = icalcomponent_get_first_property(component,kind); + p != 0; + p = icalcomponent_get_next_property(component,kind)){ + + count++; + } + + + return count; + +} + +icalproperty* icalcomponent_get_current_property (icalcomponent* component) +{ + + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + icalerror_check_arg_rz( (component!=0),"component"); + + if ((c->property_iterator==0)){ + return 0; + } + + return (icalproperty*) pvl_data(c->property_iterator); + +} + +icalproperty* +icalcomponent_get_first_property (icalcomponent* component, icalproperty_kind kind) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + icalerror_check_arg_rz( (component!=0),"component"); + + for( c->property_iterator = pvl_head(c->properties); + c->property_iterator != 0; + c->property_iterator = pvl_next(c->property_iterator)) { + + icalproperty *p = (icalproperty*) pvl_data(c->property_iterator); + + if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) { + + return p; + } + } + return 0; +} + +icalproperty* +icalcomponent_get_next_property (icalcomponent* component, icalproperty_kind kind) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + icalerror_check_arg_rz( (component!=0),"component"); + + if (c->property_iterator == 0){ + return 0; + } + + for( c->property_iterator = pvl_next(c->property_iterator); + c->property_iterator != 0; + c->property_iterator = pvl_next(c->property_iterator)) { + + icalproperty *p = (icalproperty*) pvl_data(c->property_iterator); + + if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) { + + return p; + } + } + + return 0; +} + + +icalproperty** +icalcomponent_get_properties (icalcomponent* component, icalproperty_kind kind); + + +void +icalcomponent_add_component (icalcomponent* parent, icalcomponent* child) +{ + struct icalcomponent_impl *impl, *cimpl; + + icalerror_check_arg_rv( (parent!=0), "parent"); + icalerror_check_arg_rv( (child!=0), "child"); + + impl = (struct icalcomponent_impl*)parent; + cimpl = (struct icalcomponent_impl*)child; + + icalerror_assert( (cimpl->parent ==0),"The child component has already been added to a parent component. Remove the component with icalcomponent_remove_componenet before calling icalcomponent_add_component"); + + cimpl->parent = parent; + + pvl_push(impl->components,child); +} + + +void +icalcomponent_remove_component (icalcomponent* parent, icalcomponent* child) +{ + struct icalcomponent_impl *impl,*cimpl; + pvl_elem itr, next_itr; + + icalerror_check_arg_rv( (parent!=0), "parent"); + icalerror_check_arg_rv( (child!=0), "child"); + + impl = (struct icalcomponent_impl*)parent; + cimpl = (struct icalcomponent_impl*)child; + + for( itr = pvl_head(impl->components); + itr != 0; + itr = next_itr) + { + next_itr = pvl_next(itr); + + if( pvl_data(itr) == (void*)child ){ + + if (impl->component_iterator == itr){ + /* impl->component_iterator = pvl_next(itr);*/ + } + pvl_remove( impl->components, itr); + cimpl->parent = 0; + } + } +} + + +int +icalcomponent_count_components (icalcomponent* component, icalcomponent_kind kind) +{ + int count=0; + icalcomponent *c; + icalerror_check_arg_rz( (component!=0), "component"); + + for(c = icalcomponent_get_first_component(component,kind); + c != 0; + c = icalcomponent_get_next_component(component,kind)){ + + count++; + } + + + return count; +} + +icalcomponent* +icalcomponent_get_current_component(icalcomponent* component) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + icalerror_check_arg_rz( (component!=0),"component"); + + if (c->component_iterator == 0){ + return 0; + } + + return (icalcomponent*) pvl_data(c->component_iterator); +} + +icalcomponent* +icalcomponent_get_first_component (icalcomponent* component, + icalcomponent_kind kind) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + icalerror_check_arg_rz( (component!=0),"component"); + + for( c->component_iterator = pvl_head(c->components); + c->component_iterator != 0; + c->component_iterator = pvl_next(c->component_iterator)) { + + icalcomponent *p = (icalcomponent*) pvl_data(c->component_iterator); + + if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) { + + return p; + } + } + + return 0; +} + + +icalcomponent* +icalcomponent_get_next_component (icalcomponent* component, icalcomponent_kind kind) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + icalerror_check_arg_rz( (component!=0),"component"); + + if (c->component_iterator == 0){ + return 0; + } + + for( c->component_iterator = pvl_next(c->component_iterator); + c->component_iterator != 0; + c->component_iterator = pvl_next(c->component_iterator)) { + + icalcomponent *p = (icalcomponent*) pvl_data(c->component_iterator); + + if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) { + + return p; + } + } + + return 0; +} + + +icalproperty** +icalcomponent_get_component (icalcomponent* component, icalproperty_kind kind); + + +int icalcomponent_count_errors(icalcomponent* component) +{ + int errors = 0; + icalproperty *p; + icalcomponent *c; + + for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY)){ + + if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY) + { + errors++; + } + } + + for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ + + errors += icalcomponent_count_errors(c); + + } + + return errors; +} + + +void icalcomponent_strip_errors(icalcomponent* component) +{ + icalproperty *p, *next_p; + icalcomponent *c; + + for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); + p != 0; + p = next_p){ + + next_p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY); + + if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY) + { + icalcomponent_remove_property(component,p); + } + } + + for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ + + icalcomponent_strip_errors(c); + } + +} + +icalcomponent* icalcomponent_get_parent(icalcomponent* component) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + return c->parent; +} + +void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent) +{ + struct icalcomponent_impl *c = (struct icalcomponent_impl*)component; + + c->parent = parent; +} + + diff --git a/libical/src/libical/icalcomponent.h b/libical/src/libical/icalcomponent.h new file mode 100644 index 0000000000..9e0e9f5a9f --- /dev/null +++ b/libical/src/libical/icalcomponent.h @@ -0,0 +1,115 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalcomponent.h + CREATOR: eric 20 March 1999 + + + (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 icalcomponent.h + +======================================================================*/ + +#ifndef ICALCOMPONENT_H +#define ICALCOMPONENT_H + +#include "icalproperty.h" +#include "icalvalue.h" +#include "icalenums.h" /* defines icalcomponent_kind */ + +typedef void icalcomponent; + +icalcomponent* icalcomponent_new(icalcomponent_kind kind); +icalcomponent* icalcomponent_new_clone(icalcomponent* component); +icalcomponent* icalcomponent_new_from_string(char* str); +icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...); +void icalcomponent_free(icalcomponent* component); + +char* icalcomponent_as_ical_string(icalcomponent* component); + +int icalcomponent_is_valid(icalcomponent* component); + +icalcomponent_kind icalcomponent_isa(icalcomponent* component); + +int icalcomponent_isa_component (void* component); + +/* + * Working with properties + */ + +void icalcomponent_add_property(icalcomponent* component, + icalproperty* property); + +void icalcomponent_remove_property(icalcomponent* component, + icalproperty* property); + +int icalcomponent_count_properties(icalcomponent* component, + icalproperty_kind kind); + +/* Iterate through the properties */ +icalproperty* icalcomponent_get_current_property(icalcomponent* component); + +icalproperty* icalcomponent_get_first_property(icalcomponent* component, + icalproperty_kind kind); +icalproperty* icalcomponent_get_next_property(icalcomponent* component, + icalproperty_kind kind); + +/* Return a null-terminated array of icalproperties*/ + +icalproperty** icalcomponent_get_properties(icalcomponent* component, + icalproperty_kind kind); + + +/* + * Working with components + */ + + +void icalcomponent_add_component(icalcomponent* parent, + icalcomponent* child); + +void icalcomponent_remove_component(icalcomponent* parent, + icalcomponent* child); + +int icalcomponent_count_components(icalcomponent* component, + icalcomponent_kind kind); + +/* 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); + +/* Return a null-terminated array of icalproperties*/ +icalproperty** icalcomponent_get_component(icalcomponent* component, + icalproperty_kind kind); + +/* Working with embedded error properties */ + +int icalcomponent_count_errors(icalcomponent* component); +void icalcomponent_strip_errors(icalcomponent* component); + + +/* Internal operations. You don't see these... */ +icalcomponent* icalcomponent_get_parent(icalcomponent* component); +void icalcomponent_set_parent(icalcomponent* component, + icalcomponent* parent); + +#endif /* !ICALCOMPONENT_H */ + + + diff --git a/libical/src/libical/icalenums.c b/libical/src/libical/icalenums.c new file mode 100644 index 0000000000..70931d03d0 --- /dev/null +++ b/libical/src/libical/icalenums.c @@ -0,0 +1,547 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalenum.c + CREATOR: eric 29 April 1999 + + $Id$ + + + (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 icalenum.c + + ======================================================================*/ + +#include "icalenums.h" + +struct icalproperty_kind_map { + icalproperty_kind kind; + char name[20]; +}; + +static struct icalproperty_kind_map property_map[] = +{ + { ICAL_ACTION_PROPERTY, "ACTION"}, + { ICAL_ATTACH_PROPERTY, "ATTACH"}, + { ICAL_ATTENDEE_PROPERTY, "ATTENDEE"}, + { ICAL_CALSCALE_PROPERTY, "CALSCALE"}, + { ICAL_CATEGORIES_PROPERTY, "CATEGORIES"}, + { ICAL_CLASS_PROPERTY, "CLASS"}, + { ICAL_COMMENT_PROPERTY, "COMMENT"}, + { ICAL_COMPLETED_PROPERTY, "COMPLETED"}, + { ICAL_CONTACT_PROPERTY, "CONTACT"}, + { ICAL_CREATED_PROPERTY, "CREATED"}, + { ICAL_DESCRIPTION_PROPERTY, "DESCRIPTION"}, + { ICAL_DTEND_PROPERTY, "DTEND"}, + { ICAL_DTSTAMP_PROPERTY, "DTSTAMP"}, + { ICAL_DTSTART_PROPERTY, "DTSTART"}, + { ICAL_DUE_PROPERTY, "DUE"}, + { ICAL_DURATION_PROPERTY, "DURATION"}, + { ICAL_EXDATE_PROPERTY, "EXDATE"}, + { ICAL_EXRULE_PROPERTY, "EXRULE"}, + { ICAL_FREEBUSY_PROPERTY, "FREEBUSY"}, + { ICAL_GEO_PROPERTY, "GEO"}, + { ICAL_LASTMODIFIED_PROPERTY, "LAST-MODIFIED"}, + { ICAL_LOCATION_PROPERTY, "LOCATION"}, + { ICAL_METHOD_PROPERTY, "METHOD"}, + { ICAL_ORGANIZER_PROPERTY, "ORGANIZER"}, + { ICAL_PERCENTCOMPLETE_PROPERTY, "PERCENT-COMPLETE"}, + { ICAL_PRIORITY_PROPERTY, "PRIORITY"}, + { ICAL_PRODID_PROPERTY, "PRODID"}, + { ICAL_RDATE_PROPERTY, "RDATE"}, + { ICAL_RECURRENCEID_PROPERTY, "RECURRENCE-ID"}, + { ICAL_RELATEDTO_PROPERTY, "RELATED-TO"}, + { ICAL_REPEAT_PROPERTY, "REPEAT"}, + { ICAL_REQUESTSTATUS_PROPERTY, "REQUEST-STATUS"}, + { ICAL_RESOURCES_PROPERTY, "RESOURCES"}, + { ICAL_RRULE_PROPERTY, "RRULE"}, + { ICAL_SEQUENCE_PROPERTY, "SEQUENCE"}, + { ICAL_STATUS_PROPERTY, "STATUS"}, + { ICAL_SUMMARY_PROPERTY, "SUMMARY"}, + { ICAL_TRANSP_PROPERTY, "TRANSP"}, + { ICAL_TRIGGER_PROPERTY, "TRIGGER"}, + { ICAL_TZID_PROPERTY, "TZID"}, + { ICAL_TZNAME_PROPERTY, "TZNAME"}, + { ICAL_TZOFFSETFROM_PROPERTY, "TZOFFSETFROM"}, + { ICAL_TZOFFSETTO_PROPERTY, "TZOFFSETTO"}, + { ICAL_TZURL_PROPERTY, "TZURL"}, + { ICAL_UID_PROPERTY, "UID"}, + { ICAL_URL_PROPERTY, "URL"}, + { ICAL_VERSION_PROPERTY, "VERSION"}, + { ICAL_X_PROPERTY,"X_PROPERTY"}, + + /* CAP Object Properties */ + + { ICAL_SCOPE_PROPERTY, "SCOPE"}, + { ICAL_MAXRESULTS_PROPERTY, "MAXRESULTS"}, + { ICAL_MAXRESULTSSIZE_PROPERTY, "MAXRESULTSSIZE"}, + { ICAL_QUERY_PROPERTY, "QUERY" }, + { ICAL_QUERYNAME_PROPERTY, "QUERYNAME" }, + { ICAL_TARGET_PROPERTY, "TARGET"}, + + /* libical private properties */ + { ICAL_XLICERROR_PROPERTY,"X-LIC-ERROR"}, + { ICAL_XLICCLUSTERCOUNT_PROPERTY,"X-LIC-CLUSTERCOUNT"}, + + /* End of the list */ + { ICAL_NO_PROPERTY, ""} +}; + + +char* icalenum_property_kind_to_string(icalproperty_kind kind) +{ + int i; + + for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) { + if (property_map[i].kind == kind) { + return property_map[i].name; + } + } + + return 0; + +} + +icalproperty_kind icalenum_string_to_property_kind(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; + } + } + + return ICAL_NO_PROPERTY; +} + + + + +struct icalparameter_kind_map { + icalparameter_kind kind; + char name[20]; +}; + +static struct icalparameter_kind_map parameter_map[] = +{ + { ICAL_ALTREP_PARAMETER, "ALTREP"}, + { ICAL_CN_PARAMETER, "CN"}, + { ICAL_CUTYPE_PARAMETER, "CUTYPE"}, + { ICAL_DELEGATEDFROM_PARAMETER, "DELEGATED-FROM"}, + { ICAL_DELEGATEDTO_PARAMETER, "DELEGATED-TO"}, + { ICAL_DIR_PARAMETER, "DIR"}, + { ICAL_ENCODING_PARAMETER, "ENCODING"}, + { ICAL_FBTYPE_PARAMETER, "FBTYPE"}, + { ICAL_FMTTYPE_PARAMETER, "FMTTYPE"}, + { ICAL_LANGUAGE_PARAMETER, "LANGUAGE"}, + { ICAL_MEMBER_PARAMETER, "MEMBER"}, + { ICAL_PARTSTAT_PARAMETER, "PARTSTAT"}, + { ICAL_RANGE_PARAMETER, "RANGE"}, + { ICAL_RELATED_PARAMETER, "RELATED"}, + { ICAL_RELTYPE_PARAMETER, "RELTYPE"}, + { ICAL_ROLE_PARAMETER, "ROLE"}, + { ICAL_RSVP_PARAMETER, "RSVP"}, + { ICAL_SENTBY_PARAMETER, "SENT-BY"}, + { ICAL_TZID_PARAMETER, "TZID"}, + { ICAL_VALUE_PARAMETER, "VALUE"}, + + /* CAP parameters */ + + /* libical private parameters */ + { ICAL_XLICERRORTYPE_PARAMETER, "X-LIC-ERRORTYPE"}, + { ICAL_XLICCOMPARETYPE_PARAMETER, "X-LIC-COMPARETYPE"}, + + /* End of list */ + { ICAL_NO_PARAMETER, ""} +}; + +char* icalenum_parameter_kind_to_string(icalparameter_kind kind) +{ + int i; + + for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) { + if (parameter_map[i].kind == kind) { + return parameter_map[i].name; + } + } + + return 0; + +} + +icalparameter_kind icalenum_string_to_parameter_kind(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; + } + } + + return ICAL_NO_PARAMETER; +} + +struct icalvalue_kind_map { + icalvalue_kind kind; + char name[20]; +}; + +static struct icalvalue_kind_map value_map[] = +{ + { ICAL_BINARY_VALUE, "BINARY"}, + { ICAL_BOOLEAN_VALUE, "BOOLEAN"}, + { ICAL_CALADDRESS_VALUE, "CAL-ADDRESS"}, + { ICAL_DATE_VALUE, "DATE"}, + { ICAL_DATETIME_VALUE, "DATE-TIME"}, + { ICAL_DURATION_VALUE, "DURATION"}, + { ICAL_FLOAT_VALUE, "FLOAT"}, + { ICAL_INTEGER_VALUE, "INTEGER"}, + { ICAL_PERIOD_VALUE, "PERIOD"}, + { ICAL_RECUR_VALUE, "RECUR"}, + { ICAL_TEXT_VALUE, "TEXT"}, + { ICAL_TIME_VALUE, "TIME"}, + { ICAL_URI_VALUE, "URI"}, + { ICAL_UTCOFFSET_VALUE, "UTC-OFFSET"}, + { ICAL_GEO_VALUE, "FLOAT"}, /* Not an RFC2445 type */ + { ICAL_ATTACH_VALUE, "XATTACH"}, /* Not an RFC2445 type */ + { ICAL_DATETIMEDATE_VALUE, "XDATETIMEDATE"}, /* Not an RFC2445 type */ + { ICAL_DATETIMEPERIOD_VALUE, "XDATETIMEPERIOD"}, /* Not an RFC2445 type */ + { ICAL_QUERY_VALUE, "QUERY"}, + { ICAL_NO_VALUE, ""}, +}; + +char* icalenum_value_kind_to_string(icalvalue_kind kind) +{ + int i; + + for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) { + if (value_map[i].kind == kind) { + return value_map[i].name; + } + } + + return 0; + +} + +icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind) +{ + + return ICAL_NO_VALUE; +} + + +struct icalcomponent_kind_map { + icalcomponent_kind kind; + char name[20]; +}; + + + +static struct icalcomponent_kind_map component_map[] = +{ + { ICAL_VEVENT_COMPONENT, "VEVENT" }, + { ICAL_VTODO_COMPONENT, "VTODO" }, + { ICAL_VJOURNAL_COMPONENT, "VJOURNAL" }, + { ICAL_VCALENDAR_COMPONENT, "VCALENDAR" }, + { ICAL_VFREEBUSY_COMPONENT, "VFREEBUSY" }, + { ICAL_VTIMEZONE_COMPONENT, "VTIMEZONE" }, + { ICAL_VALARM_COMPONENT, "VALARM" }, + { ICAL_XSTANDARD_COMPONENT, "STANDARD" }, /*These are part of RFC2445 */ + { ICAL_XDAYLIGHT_COMPONENT, "DAYLIGHT" }, /*but are not really components*/ + { ICAL_X_COMPONENT, "X" }, + { ICAL_VSCHEDULE_COMPONENT, "SCHEDULE" }, + + /* CAP components */ + { ICAL_VQUERY_COMPONENT, "VQUERY" }, + { ICAL_VCAR_COMPONENT, "VCAR" }, + { ICAL_VCOMMAND_COMPONENT, "VCOMMAND" }, + + /* libical private components */ + { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" }, + { ICAL_XROOT_COMPONENT, "ROOT" }, + + /* End of list */ + { ICAL_NO_COMPONENT, "" }, +}; + +char* icalenum_component_kind_to_string(icalcomponent_kind kind) +{ + int i; + + for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) { + if (component_map[i].kind == kind) { + return component_map[i].name; + } + } + + return 0; + +} + +icalcomponent_kind icalenum_string_to_component_kind(char* string) +{ + int i; + + if (string ==0 ) { + return ICAL_NO_COMPONENT; + } + + for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) { + if (strcmp(component_map[i].name, string) == 0) { + return component_map[i].kind; + } + } + + return ICAL_NO_COMPONENT; +} + +struct icalproperty_kind_value_map { + icalproperty_kind prop; + icalvalue_kind value; +}; + +static struct icalproperty_kind_value_map propval_map[] = +{ + { ICAL_CALSCALE_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_METHOD_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_PRODID_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_VERSION_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_CATEGORIES_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_CLASS_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_COMMENT_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_DESCRIPTION_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_LOCATION_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_PERCENTCOMPLETE_PROPERTY, ICAL_INTEGER_VALUE }, + { ICAL_PRIORITY_PROPERTY, ICAL_INTEGER_VALUE }, + { ICAL_RESOURCES_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_STATUS_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_SUMMARY_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_COMPLETED_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_FREEBUSY_PROPERTY, ICAL_PERIOD_VALUE }, + { ICAL_TRANSP_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_TZNAME_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_TZOFFSETFROM_PROPERTY, ICAL_UTCOFFSET_VALUE }, + { ICAL_TZOFFSETTO_PROPERTY, ICAL_UTCOFFSET_VALUE }, + { ICAL_TZURL_PROPERTY, ICAL_URI_VALUE }, + { ICAL_TZID_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_ATTENDEE_PROPERTY, ICAL_CALADDRESS_VALUE }, + { ICAL_CONTACT_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_ORGANIZER_PROPERTY, ICAL_CALADDRESS_VALUE }, + { ICAL_RELATEDTO_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_URL_PROPERTY, ICAL_URI_VALUE }, + { ICAL_UID_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_EXRULE_PROPERTY, ICAL_RECUR_VALUE }, + { ICAL_RRULE_PROPERTY, ICAL_RECUR_VALUE }, + { ICAL_ACTION_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_REPEAT_PROPERTY, ICAL_INTEGER_VALUE }, + { ICAL_CREATED_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_DTSTAMP_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_LASTMODIFIED_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_SEQUENCE_PROPERTY, ICAL_INTEGER_VALUE }, + { ICAL_X_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_REQUESTSTATUS_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_ATTACH_PROPERTY, ICAL_URI_VALUE }, + { ICAL_GEO_PROPERTY, ICAL_GEO_VALUE }, + { ICAL_DTEND_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_DUE_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_DTSTART_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_RECURRENCEID_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_EXDATE_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_RDATE_PROPERTY, ICAL_DATETIME_VALUE }, + { ICAL_TRIGGER_PROPERTY, ICAL_DURATION_VALUE }, + { ICAL_DURATION_PROPERTY, ICAL_DURATION_VALUE }, + + /* CAP properties */ + { ICAL_SCOPE_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_MAXRESULTS_PROPERTY, ICAL_INTEGER_VALUE}, + { ICAL_MAXRESULTSSIZE_PROPERTY, ICAL_INTEGER_VALUE}, + { ICAL_QUERY_PROPERTY, ICAL_QUERY_VALUE }, + { ICAL_QUERYNAME_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_TARGET_PROPERTY, ICAL_CALADDRESS_VALUE }, + + + /* libical private properties */ + { ICAL_XLICERROR_PROPERTY,ICAL_TEXT_VALUE}, + { ICAL_XLICCLUSTERCOUNT_PROPERTY,ICAL_INTEGER_VALUE}, + + + /* End of list */ + { ICAL_NO_PROPERTY, ICAL_NO_PROPERTY} +}; + + +icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind) +{ + int i; + + for (i=0; propval_map[i].value != ICAL_NO_VALUE; i++) { + if ( propval_map[i].prop == kind ) { + return propval_map[i].value; + } + } + + return ICAL_NO_VALUE; +} + +struct {icalrecurrencetype_weekday wd; char * str; } +wd_map[] = { + {ICAL_SUNDAY_WEEKDAY,"SU"}, + {ICAL_MONDAY_WEEKDAY,"MO"}, + {ICAL_TUESDAY_WEEKDAY,"TU"}, + {ICAL_WEDNESDAY_WEEKDAY,"WE"}, + {ICAL_THURSDAY_WEEKDAY,"TH"}, + {ICAL_FRIDAY_WEEKDAY,"FR"}, + {ICAL_SATURDAY_WEEKDAY,"SA"}, + {ICAL_NO_WEEKDAY,0} +}; + +char* icalenum_weekday_to_string(icalrecurrencetype_weekday kind) +{ + int i; + + for (i=0; wd_map[i].wd != ICAL_NO_WEEKDAY; i++) { + if ( wd_map[i].wd == kind) { + return wd_map[i].str; + } + } + + return 0; +} + + +struct { + icalrecurrencetype_frequency kind; + char* str; +} freq_map[] = { + {ICAL_SECONDLY_RECURRENCE,"SECONDLY"}, + {ICAL_MINUTELY_RECURRENCE,"MINUTELY"}, + {ICAL_HOURLY_RECURRENCE,"HOURLY"}, + {ICAL_DAILY_RECURRENCE,"DAILY"}, + {ICAL_WEEKLY_RECURRENCE,"WEEKLY"}, + {ICAL_MONTHLY_RECURRENCE,"MONTHLY"}, + {ICAL_YEARLY_RECURRENCE,"YEARLY"}, + {ICAL_NO_RECURRENCE,0} +}; + +char* icalenum_recurrence_to_string(icalrecurrencetype_frequency kind) +{ + int i; + + for (i=0; freq_map[i].kind != ICAL_NO_RECURRENCE ; i++) { + if ( freq_map[i].kind == kind ) { + return freq_map[i].str; + } + } + return 0; +} + + +struct { + icalrecurrencetype_frequency kind; + int major; + int minor; + char* str; +} 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 sequence."}, + {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."} +}; + +struct {icalproperty_method method; char* str;} method_map[] = { + {ICAL_METHOD_PUBLISH,"PUBLISH"}, + {ICAL_METHOD_REQUEST,"REQUEST"}, + {ICAL_METHOD_REPLY,"REPLY"}, + {ICAL_METHOD_ADD,"ADD"}, + {ICAL_METHOD_CANCEL,"CANCEL"}, + {ICAL_METHOD_REFRESH,"REFRESH"}, + {ICAL_METHOD_COUNTER,"CPUNTER"}, + {ICAL_METHOD_DECLINECOUNTER,"DECLINECOUNTER"}, + /* CAP Methods */ + {ICAL_METHOD_CREATE,"CREATE"}, + {ICAL_METHOD_READ,"READ"}, + {ICAL_METHOD_RESPONSE,"RESPONSE"}, + {ICAL_METHOD_MOVE,"MOVE"}, + {ICAL_METHOD_MODIFY,"MODIFY"}, + {ICAL_METHOD_GENERATEUID,"GENERATEUID"}, + {ICAL_METHOD_DELETE,"DELETE"}, + {ICAL_METHOD_NONE,"NONE"} +}; + + +char* icalenum_method_to_string(icalproperty_method method) +{ + int i; + + for (i=0; method_map[i].method != ICAL_METHOD_NONE; i++) { + if ( method_map[i].method == method) { + return method_map[i].str; + } + } + + return 0; +} + +icalproperty_method icalenum_string_to_method(char* str) +{ + int i; + + for (i=0; method_map[i].method != ICAL_METHOD_NONE; i++) { + if ( strcmp(method_map[i].str, str) == 0) { + return method_map[i].method; + } + } + + return ICAL_METHOD_NONE; +} diff --git a/libical/src/libical/icalenums.h b/libical/src/libical/icalenums.h new file mode 100644 index 0000000000..e60d230854 --- /dev/null +++ b/libical/src/libical/icalenums.h @@ -0,0 +1,459 @@ +/* -*- Mode: C -*-*/ +/*====================================================================== + FILE: icalenums.h + + + + (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 icalenums.h + + Contributions from: + Graham Davison (g.m.davison@computer.org) + +======================================================================*/ + +#ifndef ICALENUMS_H +#define ICALENUMS_H + + + +/*********************************************************************** + * Component enumerations +**********************************************************************/ + +typedef enum icalcomponent_kind { + ICAL_NO_COMPONENT, + ICAL_ANY_COMPONENT, /* Used in get_components to select all components*/ + ICAL_XROOT_COMPONENT, /* Root component returned by parser */ + 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 +} icalcomponent_kind; + +/*********************************************************************** + * Property Enumerations +**********************************************************************/ + +typedef enum icalproperty_kind { + ICAL_ANY_PROPERTY = 0, /* This must be the first enum, for iteration */ + ICAL_CALSCALE_PROPERTY, + ICAL_METHOD_PROPERTY, + ICAL_PRODID_PROPERTY, + ICAL_VERSION_PROPERTY, + ICAL_ATTACH_PROPERTY, + ICAL_CATEGORIES_PROPERTY, + ICAL_CLASS_PROPERTY, + ICAL_COMMENT_PROPERTY, + ICAL_DESCRIPTION_PROPERTY, + ICAL_GEO_PROPERTY, + ICAL_LOCATION_PROPERTY, + ICAL_PERCENTCOMPLETE_PROPERTY, + ICAL_PRIORITY_PROPERTY, + ICAL_RESOURCES_PROPERTY, + ICAL_STATUS_PROPERTY, + ICAL_SUMMARY_PROPERTY, + ICAL_COMPLETED_PROPERTY, + ICAL_DTEND_PROPERTY, + ICAL_DUE_PROPERTY, + ICAL_DTSTART_PROPERTY, + ICAL_DURATION_PROPERTY, + ICAL_FREEBUSY_PROPERTY, + ICAL_TRANSP_PROPERTY, + ICAL_TZID_PROPERTY, + ICAL_TZNAME_PROPERTY, + ICAL_TZOFFSETFROM_PROPERTY, + ICAL_TZOFFSETTO_PROPERTY, + ICAL_TZURL_PROPERTY, + ICAL_ATTENDEE_PROPERTY, + ICAL_CONTACT_PROPERTY, + ICAL_ORGANIZER_PROPERTY, + ICAL_RECURRENCEID_PROPERTY, + ICAL_RELATEDTO_PROPERTY, + ICAL_URL_PROPERTY, + ICAL_UID_PROPERTY, + ICAL_EXDATE_PROPERTY, + ICAL_EXRULE_PROPERTY, + ICAL_RDATE_PROPERTY, + ICAL_RRULE_PROPERTY, + ICAL_ACTION_PROPERTY, + ICAL_REPEAT_PROPERTY, + ICAL_TRIGGER_PROPERTY, + ICAL_CREATED_PROPERTY, + ICAL_DTSTAMP_PROPERTY, + ICAL_LASTMODIFIED_PROPERTY, + ICAL_SEQUENCE_PROPERTY, + ICAL_REQUESTSTATUS_PROPERTY, + ICAL_X_PROPERTY, + + /* CAP Properties */ + ICAL_SCOPE_PROPERTY, + ICAL_MAXRESULTS_PROPERTY, + ICAL_MAXRESULTSSIZE_PROPERTY, + ICAL_QUERY_PROPERTY, + ICAL_QUERYNAME_PROPERTY, + ICAL_TARGET_PROPERTY, + + /* libical private properties */ + ICAL_XLICERROR_PROPERTY, + ICAL_XLICCLUSTERCOUNT_PROPERTY, + + ICAL_NO_PROPERTY /* This must be the last enum, for iteration */ + +} icalproperty_kind; + +/*********************************************************************** + * Enumerations for the values of properties + ***********************************************************************/ + +typedef enum icalproperty_method { + ICAL_METHOD_PUBLISH, + ICAL_METHOD_REQUEST, + ICAL_METHOD_REPLY, + ICAL_METHOD_ADD, + ICAL_METHOD_CANCEL, + ICAL_METHOD_REFRESH, + ICAL_METHOD_COUNTER, + ICAL_METHOD_DECLINECOUNTER, + /* CAP Methods */ + ICAL_METHOD_CREATE, + ICAL_METHOD_READ, + ICAL_METHOD_RESPONSE, + ICAL_METHOD_MOVE, + ICAL_METHOD_MODIFY, + ICAL_METHOD_GENERATEUID, + ICAL_METHOD_DELETE, + ICAL_METHOD_NONE +} icalproperty_method ; + +typedef enum icalproperty_transp { + ICAL_TRANSP_OPAQUE, + ICAL_TRANS_TRANSPARENT +} icalproperty_trans; + +typedef enum icalproperty_calscale { + ICAL_CALSCALE_GREGORIAN +} icalproperty_calscale ; + + +typedef enum icalproperty_class { + ICAL_CLASS_PUBLIC, + ICAL_CLASS_PRIVATE, + ICAL_CLASS_CONFIDENTIAL, + ICAL_CLASS_XNAME +} icalproperty_class; + + +typedef enum icalproperty_status { + ICAL_STATUS_TENTATIVE, + ICAL_STATUS_CONFIRMED, + ICAL_STATUS_CANCELLED, /* CANCELED? SIC */ + ICAL_STATUS_NEEDSACTION, + ICAL_STATUS_COMPLETED, + ICAL_STATUS_INPROCESS, + ICAL_STATUS_DRAFT, + ICAL_STATUS_FINAL +} icalproperty_status; + +typedef enum icalproperty_action { + ICAL_ACTION_AUDIO, + ICAL_ACTION_DISPLAY, + ICAL_ACTION_EMAIL, + ICAL_ACTION_PROCEDURE, + ICAL_ACTION_XNAME +} icalproperty_action; + +/*********************************************************************** + * Value enumerations +**********************************************************************/ + +typedef enum icalvalue_kind { + ICAL_NO_VALUE, + ICAL_ATTACH_VALUE, /* Non-Standard*/ + ICAL_BINARY_VALUE, + ICAL_BOOLEAN_VALUE, + ICAL_CALADDRESS_VALUE, + ICAL_DATE_VALUE, + ICAL_DATETIME_VALUE, + ICAL_DATETIMEDATE_VALUE, /* Non-Standard */ + ICAL_DATETIMEPERIOD_VALUE, /* Non-Standard */ + ICAL_DURATION_VALUE, + ICAL_FLOAT_VALUE, + ICAL_GEO_VALUE, /* Non-Standard */ + ICAL_INTEGER_VALUE, + ICAL_METHOD_VALUE, + ICAL_PERIOD_VALUE, + ICAL_RECUR_VALUE, + ICAL_TEXT_VALUE, + ICAL_TIME_VALUE, + ICAL_TRIGGER_VALUE, /* Non-Standard */ + ICAL_URI_VALUE, + ICAL_UTCOFFSET_VALUE, + ICAL_QUERY_VALUE, + ICAL_XNAME_VALUE +} icalvalue_kind; + + +/*********************************************************************** + * Parameter Enumerations + **********************************************************************/ + + +typedef enum icalparameter_kind { + ICAL_NO_PARAMETER, + ICAL_ANY_PARAMETER, + ICAL_ALTREP_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_CN_PARAMETER, /* text */ + ICAL_CUTYPE_PARAMETER, /*INDIVIDUAL, GROUP, RESOURCE,ROOM,UNKNOWN, x-name*/ + ICAL_DELEGATEDFROM_PARAMETER, /* *("," DQUOTE cal-address DQUOTE) */ + ICAL_DELEGATEDTO_PARAMETER, /* *("," DQUOTE cal-address DQUOTE) */ + ICAL_DIR_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_ENCODING_PARAMETER, /* *BIT, BASE64, x-name */ + ICAL_FMTTYPE_PARAMETER, /* registered MINE content type */ + ICAL_FBTYPE_PARAMETER, /* FREE, BUSY, BUSY-UNAVAILABLE, BUSY-TENTATIVE,x-name */ + ICAL_LANGUAGE_PARAMETER, /* text from RFC 1766 */ + ICAL_MEMBER_PARAMETER, /* DQUOTE cal-address DQUOTE */ + ICAL_PARTSTAT_PARAMETER, /* NEEDS-ACTION, ACCEPTED, DECLINED, TENTATIVE, DELEGATED, x-name */ + ICAL_RANGE_PARAMETER, /* THISANDPRIOR, THISANDFUTURE */ + ICAL_RELATED_PARAMETER, /* START, END */ + ICAL_RELTYPE_PARAMETER, /* PARENT, CHILD, SIBLING,x-name */ + ICAL_ROLE_PARAMETER, /* CHAIR, REQ_PARTICIPANT, OPT_PARTICIPANT, NON_PARTICIPANT, x-name */ + ICAL_RSVP_PARAMETER, /* TRUE. FALSE */ + ICAL_SENTBY_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_TZID_PARAMETER, /* [tzidprefix] paramtext CRLF */ + ICAL_VALUE_PARAMETER, /* BINARY, BOOLEAN, CAL_ADDRESS, DATE, DATE-TIME, DURATION, FLOAT, INTEGER, PERIOD, RECUR, TEXT, TIME, UTC_OFFSET, x-name */ + ICAL_XLICERRORTYPE_PARAMETER, /*ICAL_XLICERROR_PARSE_ERROR,ICAL_XLICERROR_INVALID_ITIP*/ + ICAL_XLICCOMPARETYPE_PARAMETER, /**/ + ICAL_X_PARAMETER /* text */ +} icalparameter_kind; + +typedef enum icalparameter_cutype { + ICAL_CUTYPE_INDIVIDUAL, + ICAL_CUTYPE_GROUP, + ICAL_CUTYPE_RESOURCE, + ICAL_CUTYPE_ROOM, + ICAL_CUTYPE_UNKNOWN, + ICAL_CUTYPE_XNAME +} icalparameter_cutype; + + +typedef enum icalparameter_encoding { + ICAL_ENCODING_8BIT, + ICAL_ENCODING_BASE64, + ICAL_ENCODING_XNAME +} icalparameter_encoding; + +typedef enum icalparameter_fbtype { + ICAL_FBTYPE_FREE, + ICAL_FBTYPE_BUSY, + ICAL_FBTYPE_BUSYUNAVAILABLE, + ICAL_FBTYPE_BUSYTENTATIVE, + ICAL_FBTYPE_XNAME +} icalparameter_fbtype; + +typedef enum icalparameter_partstat { + ICAL_PARTSTAT_NEEDSACTION, + ICAL_PARTSTAT_ACCEPTED, + ICAL_PARTSTAT_DECLINED, + ICAL_PARTSTAT_TENTATIVE, + ICAL_PARTSTAT_DELEGATED, + ICAL_PARTSTAT_COMPLETED, + ICAL_PARTSTAT_INPROCESS, + ICAL_PARTSTAT_XNAME +} icalparameter_partstat; + +typedef enum icalparameter_range { + ICAL_RANGE_THISANDPRIOR, + ICAL_RANGE_THISANDFUTURE +} icalparameter_range; + +typedef enum icalparameter_related { + ICAL_RELATED_START, + ICAL_RELATED_END +} icalparameter_related; + +typedef enum icalparameter_reltype { + ICAL_RELTYPE_PARENT, + ICAL_RELTYPE_CHILD, + ICAL_RELTYPE_SIBLING, + ICAL_RELTYPE_XNAME +} icalparameter_reltype; + +typedef enum icalparameter_role { + ICAL_ROLE_CHAIR, + ICAL_ROLE_REQPARTICIPANT, + ICAL_ROLE_OPTPARTICIPANT, + ICAL_ROLE_NONPARTICIPANT, + ICAL_ROLE_XNAME +} icalparameter_role; + +typedef enum icalparameter_xlicerrortype { + ICAL_XLICERRORTYPE_COMPONENTPARSEERROR, + ICAL_XLICERRORTYPE_PARAMETERPARSEERROR, + ICAL_XLICERRORTYPE_PROPERTYPARSEERROR, + ICAL_XLICERRORTYPE_VALUEPARSEERROR, + ICAL_XLICERRORTYPE_INVALIDITIP +} icalparameter_xlicerrortype; + +typedef enum icalparameter_xliccomparetype { + ICAL_XLICCOMPARETYPE_EQUAL=0, + ICAL_XLICCOMPARETYPE_LESS=-1, + ICAL_XLICCOMPARETYPE_LESSEQUAL=2, + ICAL_XLICCOMPARETYPE_GREATER=1, + ICAL_XLICCOMPARETYPE_GREATEREQUAL=3, + ICAL_XLICCOMPARETYPE_NOTEQUAL=4, + ICAL_XLICCOMPARETYPE_REGEX=5 +} icalparameter_xliccomparetype; + +typedef enum icalparameter_value { + ICAL_VALUE_XNAME = ICAL_XNAME_VALUE, + ICAL_VALUE_BINARY = ICAL_BINARY_VALUE, + ICAL_VALUE_BOOLEAN = ICAL_BOOLEAN_VALUE, + ICAL_VALUE_CALADDRESS = ICAL_CALADDRESS_VALUE, + ICAL_VALUE_DATE = ICAL_DATE_VALUE, + ICAL_VALUE_DATETIME = ICAL_DATETIME_VALUE, + ICAL_VALUE_DURATION = ICAL_DURATION_VALUE, + ICAL_VALUE_FLOAT = ICAL_FLOAT_VALUE, + ICAL_VALUE_INTEGER = ICAL_INTEGER_VALUE, + ICAL_VALUE_PERIOD = ICAL_PERIOD_VALUE, + ICAL_VALUE_RECUR = ICAL_RECUR_VALUE, + ICAL_VALUE_TEXT = ICAL_TEXT_VALUE, + ICAL_VALUE_TIME = ICAL_TIME_VALUE, + ICAL_VALUE_UTCOFFSET = ICAL_UTCOFFSET_VALUE, + ICAL_VALUE_URI = ICAL_URI_VALUE, + ICAL_VALUE_ERROR = ICAL_NO_VALUE +} icalparameter_value; + +/*********************************************************************** + * Recurrances +**********************************************************************/ + + +typedef enum icalrecurrencetype_frequency +{ + ICAL_NO_RECURRENCE, + ICAL_SECONDLY_RECURRENCE, + ICAL_MINUTELY_RECURRENCE, + ICAL_HOURLY_RECURRENCE, + ICAL_DAILY_RECURRENCE, + ICAL_WEEKLY_RECURRENCE, + ICAL_MONTHLY_RECURRENCE, + ICAL_YEARLY_RECURRENCE +} icalrecurrencetype_frequency; + +typedef enum icalrecurrencetype_weekday +{ + ICAL_NO_WEEKDAY, + ICAL_SUNDAY_WEEKDAY, + ICAL_MONDAY_WEEKDAY, + ICAL_TUESDAY_WEEKDAY, + ICAL_WEDNESDAY_WEEKDAY, + ICAL_THURSDAY_WEEKDAY, + ICAL_FRIDAY_WEEKDAY, + ICAL_SATURDAY_WEEKDAY +} icalrecurrencetype_weekday; + +enum { + ICAL_RECURRENCE_ARRAY_MAX = 0x7f7f, + ICAL_RECURRENCE_ARRAY_MAX_BYTE = 0x7f +}; + + +char* icalenum_recurrence_to_string(icalrecurrencetype_frequency kind); +char* icalenum_weekday_to_string(icalrecurrencetype_weekday kind); + +/*********************************************************************** + * Request Status codes + **********************************************************************/ + +typedef enum icalrequeststatus { + 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; + + + +/*********************************************************************** + * Conversion functions +**********************************************************************/ + +char* icalenum_property_kind_to_string(icalproperty_kind kind); +icalproperty_kind icalenum_string_to_property_kind(char* string); + +char* icalenum_value_kind_to_string(icalvalue_kind kind); +icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind); + +char* icalenum_parameter_kind_to_string(icalparameter_kind kind); +icalparameter_kind icalenum_string_to_parameter_kind(char* string); + +char* icalenum_component_kind_to_string(icalcomponent_kind kind); +icalcomponent_kind icalenum_string_to_component_kind(char* string); + +icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind); + +char* icalenum_method_to_string(icalproperty_method); +icalproperty_method icalenum_string_to_method(char* string); + +#endif /* !ICALENUMS_H */ + + + diff --git a/libical/src/libical/icalerror.c b/libical/src/libical/icalerror.c new file mode 100644 index 0000000000..d84c288d3a --- /dev/null +++ b/libical/src/libical/icalerror.c @@ -0,0 +1,85 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalerror.c + CREATOR: eric 16 May 1999 + + $Id$ + $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 icalerror.c + + ======================================================================*/ + +#include "icalerror.h" + +icalerrorenum icalerrno; + +int foo; +void icalerror_stop_here(void) +{ + foo++; /* Keep optimizers from removing routine */ +} + +void icalerror_clear_errno() { + + icalerrno = ICAL_NO_ERROR; +} + +void icalerror_set_errno(icalerrorenum e) { + + icalerror_stop_here(); + icalerrno = e; +} + + +struct icalerror_string_map { + icalerrorenum error; + char name[160]; +}; + +static struct icalerror_string_map string_map[] = +{ + {ICAL_BADARG_ERROR,"Bad argumnet to function"}, + {ICAL_NEWFAILED_ERROR,"Failed to create a new object via a *_new() routine"}, + {ICAL_MALFORMEDDATA_ERROR,"An input string was not correctly formed"}, + {ICAL_PARSE_ERROR,"Failed to parse a part of an iCal componet"}, + {ICAL_INTERNAL_ERROR,"Random internal error. This indicates an error in the library code, not an error in use"}, + {ICAL_FILE_ERROR,"An operation on a file failed. Check errno for more detail."}, + {ICAL_ALLOCATION_ERROR,"Failed to allocate memory"}, + {ICAL_USAGE_ERROR,"The caller failed to properly sequence called to an object's interface"}, + {ICAL_NO_ERROR,"No error"}, + {ICAL_UNKNOWN_ERROR,"Unknown error type -- icalerror_strerror() was probably given bad input"} +}; + + +char* icalerror_strerror(icalerrorenum e) { + + 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*/ + +} + + + diff --git a/libical/src/libical/icalerror.h b/libical/src/libical/icalerror.h new file mode 100644 index 0000000000..41b1952855 --- /dev/null +++ b/libical/src/libical/icalerror.h @@ -0,0 +1,139 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalerror.h + CREATOR: eric 09 May 1999 + + $Id$ + + + (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 icalerror.h + +======================================================================*/ + + +#ifndef ICALERROR_H +#define ICALERROR_H + +#include <assert.h> +#include <stdio.h> /* For icalerror_warn() */ + +/* 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); + +#ifdef ICAL_ERRORS_ARE_FATAL +#undef NDEBUG +#endif + +#define icalerror_check_value_type(value,type); +#define icalerror_check_property_type(value,type); +#define icalerror_check_parameter_type(value,type); +#define icalerror_check_component_type(value,type); + +/* Assert with a message */ +#ifdef ICAL_ERRORS_ARE_FATAL + +#ifdef __GNUC__ +#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();} +#else /*__GNUC__*/ +#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();} +#endif /*__GNUC__*/ +#else +#define icalerror_assert(test,message) +#endif + + +/* Check & abort if check fails */ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg(test,arg) icalerror_stop_here();assert(test) +#else +#define icalerror_check_arg(test,arg) +#endif +/* Check & return void if check failes*/ + +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_rv(test,arg) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_rv(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return; } +#endif + +/* Check & return 0 if check failes*/ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_rz(test,arg) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_rz(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return 0;} +#endif + + +/* Check & return an error if check failes*/ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_re(test,arg,error) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_re(test,arg,error) if(!(test)) {icalerror_stop_here(); return error}; +#endif + + +/* Warning messages */ + +#ifdef ICAL_ERRORS_ARE_FATAL + +#ifdef __GNUC__ +#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message); abort();} +#else /* __GNU_C__ */ +#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message); abort();} +#endif /* __GNU_C__ */ + +#else /*ICAL_ERRORS_ARE_FATAL */ + +#ifdef __GNUC__ +#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);} +#else /* __GNU_C__ */ +#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);} +#endif /* __GNU_C__ */ + +#endif /*ICAL_ERRORS_ARE_FATAL*/ + +typedef enum icalerrorenum { + + ICAL_BADARG_ERROR, + ICAL_NEWFAILED_ERROR, + ICAL_MALFORMEDDATA_ERROR, + ICAL_PARSE_ERROR, + ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */ + ICAL_FILE_ERROR, + ICAL_ALLOCATION_ERROR, + ICAL_USAGE_ERROR, + ICAL_NO_ERROR, + ICAL_MULTIPLEINCLUSION_ERROR, + ICAL_UNKNOWN_ERROR /* Used for problems in input to icalerror_strerror()*/ + +} icalerrorenum; + +extern icalerrorenum icalerrno; + + +void icalerror_clear_errno(); +void icalerror_set_errno(icalerrorenum); + +char* icalerror_strerror(icalerrorenum e); + + +#endif /* !ICALERROR_H */ + + + diff --git a/libical/src/libical/icalirip.h b/libical/src/libical/icalirip.h new file mode 100644 index 0000000000..eefbca35c5 --- /dev/null +++ b/libical/src/libical/icalirip.h @@ -0,0 +1,108 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalirip.h + CREATOR: eric 20 April 1999 + + $Id$ + + + (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 icalirip.h + +======================================================================*/ + + +#ifndef ICALIRIP_H +#define ICALIRIP_H + +#include "ical.h" + +typedef void* icalirip; + +/********************** Server (Reciever) Interfaces *************************/ + +icalirip* icalirip_new(); +void* icalirip_free(); + +/* Protocol functions */ +char* icalirip_process_request(icalirip* irip, char* string); + +/* iRIP server stubs */ +typedef struct icalirip_response { + char code[6]; + char caluid[1024]; + void* result; +} icalirip_response; + +icalirip_response icalirip_timedout_stub(icalirip* irip); +icalirip_response icalirip_authenticate_stub(icalirip* irip, char* mechanism, char* data); +icalirip_response icalirip_sendata_stub(icalirip* irip, unsigned int time); +icalirip_response icalirip_dequeue_stub(icalirip* irip, char* caluid,unsigned int time); +icalirip_response icalirip_recipient_stub(icalirip* irip, char* address, unsigned int time); +icalirip_response icalirip_switch_stub(icalirip* irip); +icalirip_response icalirip_disconnect_stub(icalirip* irip); +icalirip_response icalirip_unknown_stub(icalirip* irip, char* command); + +/* icalirip_set_stubs makes the module use function pointers to +instead of the above stubs. The set_stubs procedure will requires the +user to link another library with defined the above stubs and +re-directs the call to the appropriate pointer to function. */ + +typedef struct icalirip_stubs { + + void(*authenticate_stub)(icalirip* irip, char* mechanism, char* data); + void (*sendata_stub)(icalirip* irip, unsigned int time); + void (*dequeue_stub)(icalirip* irip, char* caluid, unsigned int time); + void (*recipient_stub)(icalirip* irip, char* address, unsigned int time); + void (*switch_stub)(icalirip* irip); + void (*disconnect_stub)(); + void (*unknown_stub)(icalirip* irip, char* command, char** data); + +} icalirip_stubs; + +void icalirip_set_stubs(icalirip* irip, icalirip_stubs* stubs); + +/********************** Client (Sender) Interfaces **************************/ + +/* Client API */ +icalirip_response icalirip_abort(icalirip* irip); +icalirip_response icalirip_authenticate(icalirip* irip, char* mechanism, char* data); +icalirip_response icalirip_capability(icalirip* irip); +icalirip_response icalirip_continue(icalirip* irip, unsigned int time); +icalirip_response icalirip_sendata(icalirip* irip, icalcomponent* comp, unsigned int time); +icalirip_response icalirip_recipient(icalirip* irip, char* address, unsigned int time); +icalirip_response icalirip_dequeue(icalirip* irip, char* address, unsigned int time); +icalirip_response icalirip_switch(icalirip* irip); +icalirip_response icalirip_disconnect(); +icalirip_response icalirip_unknown(icalirip* irip, char* command); + +/* client stubs */ +void icalirip_send_request(icalirip* irip,char* request); +char* icalirip_get_response(icalirip* irip); + +/********************** Configuration Interfaces **************************/ + +/* Configure capabilities */ +void icalirip_add_auth_mechanism(icalirip* irip, char* auth); +void icalirip_set_max_object_size(icalirip* irip, unsigned int size); +void icalirip_set_max_date(icalirip* irip, time_t time); +void icalirip_set_min_date(icalirip* irip, time_t time); + + +#endif /* !ICALIRIP_H */ + + + diff --git a/libical/src/libical/icalitip.l b/libical/src/libical/icalitip.l new file mode 100644 index 0000000000..263407377e --- /dev/null +++ b/libical/src/libical/icalitip.l @@ -0,0 +1,282 @@ +%{ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalitip.y + CREATOR: eric 10 June 1999 + + DESCRIPTION: + + $Id: icalitip.l,v 1.1 2000/02/17 18:02:28 alves 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 "icalitip.tab.h" +#include "icalparser.h" +#include "icalenums.h" +#include "icalmemory.h" +#include "assert.h" + +#include <string.h> /* For strdup() */ + +#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) yyerror(msg) + +icalvalue_kind value_kind=ICAL_NO_VALUE; +void set_parser_value_state(); +extern enum icalparser_state_enum icalparser_state; +extern int yydebug; + +void yyerror(char *s); + +void init_str_buf(); + +int last_state; + +char *str_buf; +char *str_buf_p; +size_t buf_sz; /* = ICAL_MAX_STR_CONST;*/ + + +%} + +crlf \x0D\x0A +nl \n +lbreak \x0D\x0A\x20 +ulbreak \x0A\x20 +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 + + + +%% + +%{ +%} + + +<binary_value>{ +.* { yylval.v_string= icalmemory_tmp_copy(yytext); + return STRING;} +{crlf}|\n { return EOL;} + +} + +<boolean_value>{ +. { return CHARACTER; } +{crlf}|\n { return EOL;} + +} + +<uri_value>{ +.* { yylval.v_string= icalmemory_tmp_copy(yytext); + return STRING;} +{crlf}|\n { return EOL;} + +} + + +<time_value>{ +{digit}* { yylval.v_string= icalmemory_tmp_copy(yytext); + return DIGITS; } +T { return TIME_CHAR; } +Z { return UTC_CHAR; } +{crlf}|\n { return EOL;} +} + +<duration_value>{ +{digit}+ { yylval.v_string =icalmemory_tmp_copy(yytext); + return DIGITS; } +T { return TIME_CHAR; } +[\+\-PTWHMSD] { return yytext[0]; } +{crlf}|\n { return EOL;} + +} + +<number_value>{ +[\+\-\.0-9]+ { yylval.v_int=atoi(yytext); return INTNUMBER; } +{crlf}|\n { return EOL;} +} + +<period_value>{ +{digit}+ { yylval.v_string =icalmemory_tmp_copy(yytext) ; + return DIGITS; } +T { return TIME_CHAR; } +Z { return UTC_CHAR; } +[\/\+\-PWHMSD] { return yytext[0]; } +{crlf}|\n { return EOL;} + +} + +<recur_value>{ +INTERVAL { return INTERVAL; } +COUNT { return COUNT; } +UNTIL { return UNTIL; } +FREQ { return FREQ; } +BYDAY { return BYDAY; } +BYHOUR { return BYHOUR; } +BYMINUTE { return BYMINUTE; } +BYMONTH { return BYMONTH; } +BYMONTHDAY { return BYMONTHDAY; } +BYSECOND { return BYSECOND; } +BYSETPOS { return BYSETPOS; } +BYWEEKNO { return BYWEEKNO; } +BYYEARDAY { return BYYEARDAY; } +DAILY { return DAILY; } +SECONDLY { return SECONDLY; } +MINUTELY { return MINUTELY; } +HOURLY { return HOURLY; } +MONTHLY { return MONTHLY; } +WEEKLY { return WEEKLY; } +YEARLY { return YEARLY; } +WKST { return WKST; } +MO { return MO; } +SA { return SA; } +SU { return SU; } +TU { return TU; } +WE { return WE; } +TH { return TH; } +FR { return FR; } += { return EQUALS; } +, { return COMMA; } +; { return SEMICOLON; } +[\-\+0-9]+ { yylval.v_string= icalmemory_tmp_copy(yytext); + return DIGITS; } +T { return TIME_CHAR; } +Z { return UTC_CHAR; } +{crlf}|\n { return EOL;} +} + +<utcoffset_value>{ +{crlf}|\n { return EOL;} +\-|\+ { return yytext[0]; } +{digit}{digit} { yylval.v_int=atoi(yytext); return INTNUMBER; } + +} + +<enum_param_value>{ +. { return CHARACTER; } +{crlf}|\n { return EOL;} + +} + +<seperator>{ +, { BEGIN(last_state); return COMMA; } +} + + +%% + +int yywrap() +{ + return 1; +} + + +void set_parser_value_state(icalvalue_kind kind) +{ + + switch (kind){ + + case ICAL_ATTACH_VALUE: + case ICAL_BINARY_VALUE: + {BEGIN(binary_value);break;} + + case ICAL_BOOLEAN_VALUE: + case ICAL_INTEGER_VALUE: + case ICAL_FLOAT_VALUE: + {BEGIN(number_value);break;} + + case ICAL_UTCOFFSET_VALUE: + {BEGIN(utcoffset_value);break;} + + case ICAL_TEXT_VALUE: + {BEGIN(text_value); + init_str_buf(); + break;} + + case ICAL_CALADDRESS_VALUE: + case ICAL_URI_VALUE: + {BEGIN(uri_value);break;} + + case ICAL_DATE_VALUE: + case ICAL_DATETIME_VALUE: + case ICAL_DATETIMEDATE_VALUE: + case ICAL_DATETIMEPERIOD_VALUE: + case ICAL_TIME_VALUE: + {BEGIN(time_value);break;} + + case ICAL_DURATION_VALUE: + {BEGIN(duration_value);break;} + + case ICAL_PERIOD_VALUE: + {BEGIN(period_value);break;} + + case ICAL_GEO_VALUE: + case ICAL_QUERY_VALUE: + {BEGIN(text_value);break;} + + case ICAL_RECUR_VALUE: + {BEGIN(recur_value);break;} + + case ICAL_NO_VALUE: + { + /* The value is probably actually a component name */ + {BEGIN(component); break;} + } + default: + { + assert(1==0); + } + } +} + +void init_str_buf() +{ + str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST); + str_buf_p = str_buf; + buf_sz = ICAL_MAX_STR_CONST; + + +} + diff --git a/libical/src/libical/icalitip.output b/libical/src/libical/icalitip.output new file mode 100644 index 0000000000..1218f89c74 --- /dev/null +++ b/libical/src/libical/icalitip.output @@ -0,0 +1,1698 @@ + + +Terminals which are not used: + + FLOATNUMBER + STRING + EOL + CHARACTER + COLON + TIMESEPERATOR + 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 + + + +Grammar +rule 1 value -> binary_value +rule 2 value -> boolean_value +rule 3 value -> date_value +rule 4 value -> datetime_value +rule 5 value -> duration_value +rule 6 value -> period_value +rule 7 value -> recur_value +rule 8 value -> utcoffset_value +rule 9 value -> error +rule 10 binary_value -> "unimplemented2" +rule 11 boolean_value -> TRUE +rule 12 boolean_value -> FALSE +rule 13 date_value -> DIGITS +rule 14 utc_char -> /* empty */ +rule 15 utc_char -> UTC_CHAR +rule 16 utc_char_b -> /* empty */ +rule 17 utc_char_b -> UTC_CHAR +rule 18 datetime_value -> DIGITS TIME_CHAR DIGITS utc_char +rule 19 dur_date -> dur_day +rule 20 dur_date -> dur_day dur_time +rule 21 dur_week -> DIGITS 'W' +rule 22 dur_time -> TIME_CHAR dur_hour +rule 23 dur_time -> TIME_CHAR dur_minute +rule 24 dur_time -> TIME_CHAR dur_second +rule 25 dur_hour -> DIGITS 'H' +rule 26 dur_hour -> DIGITS 'H' dur_minute +rule 27 dur_minute -> DIGITS 'M' +rule 28 dur_minute -> DIGITS 'M' dur_second +rule 29 dur_second -> DIGITS 'S' +rule 30 dur_day -> DIGITS 'D' +rule 31 dur_prefix -> /* empty */ +rule 32 dur_prefix -> '+' +rule 33 dur_prefix -> '-' +rule 34 duration_value -> dur_prefix 'P' dur_date +rule 35 duration_value -> dur_prefix 'P' dur_time +rule 36 duration_value -> dur_prefix 'P' dur_week +rule 37 period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b +rule 38 period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' duration_value +rule 39 recur_start -> FREQ EQUALS SECONDLY +rule 40 recur_start -> FREQ EQUALS MINUTELY +rule 41 recur_start -> FREQ EQUALS HOURLY +rule 42 recur_start -> FREQ EQUALS DAILY +rule 43 recur_start -> FREQ EQUALS WEEKLY +rule 44 recur_start -> FREQ EQUALS MONTHLY +rule 45 recur_start -> FREQ EQUALS YEARLY +rule 46 weekday -> SU +rule 47 weekday -> MO +rule 48 weekday -> TU +rule 49 weekday -> WE +rule 50 weekday -> TH +rule 51 weekday -> FR +rule 52 weekday -> SA +rule 53 weekday_list -> weekday +rule 54 weekday_list -> DIGITS weekday +rule 55 weekday_list -> weekday_list COMMA weekday +rule 56 recur_list -> DIGITS +rule 57 recur_list -> recur_list COMMA DIGITS +rule 58 recur_skip -> INTERVAL EQUALS DIGITS +rule 59 recur_skip -> WKST EQUALS SU +rule 60 recur_skip -> WKST EQUALS MO +rule 61 recur_skip -> WKST EQUALS TU +rule 62 recur_skip -> WKST EQUALS WE +rule 63 recur_skip -> WKST EQUALS TH +rule 64 recur_skip -> WKST EQUALS FR +rule 65 recur_skip -> WKST EQUALS SA +rule 66 recur_skip -> BYSECOND EQUALS recur_list +rule 67 recur_skip -> BYMINUTE EQUALS recur_list +rule 68 recur_skip -> BYHOUR EQUALS recur_list +rule 69 recur_skip -> BYDAY EQUALS weekday_list +rule 70 recur_skip -> BYMONTH EQUALS recur_list +rule 71 recur_skip -> BYMONTHDAY EQUALS recur_list +rule 72 recur_skip -> BYYEARDAY EQUALS recur_list +rule 73 recur_skip -> BYWEEKNO EQUALS recur_list +rule 74 recur_skip -> BYSETPOS EQUALS recur_list +rule 75 recur_skip -> UNTIL EQUALS datetime_value +rule 76 recur_skip -> UNTIL EQUALS date_value +rule 77 recur_skip -> COUNT EQUALS DIGITS +rule 78 recur_skip_list -> /* empty */ +rule 79 recur_skip_list -> recur_skip_list SEMICOLON recur_skip +rule 80 recur_value -> recur_start recur_skip_list +rule 81 plusminus -> '+' +rule 82 plusminus -> '-' +rule 83 utcoffset_value -> plusminus INTNUMBER INTNUMBER +rule 84 utcoffset_value -> plusminus INTNUMBER INTNUMBER INTNUMBER + +Terminals, with rules where they appear + +$ (-1) +'+' (43) 32 81 +'-' (45) 33 82 +'/' (47) 37 38 +'D' (68) 30 +'H' (72) 25 26 +'M' (77) 27 28 +'P' (80) 34 35 36 +'S' (83) 29 +'W' (87) 21 +error (256) 9 +DIGITS (257) 13 18 21 25 26 27 28 29 30 37 38 54 56 57 58 77 +INTNUMBER (258) 83 84 +FLOATNUMBER (259) +STRING (260) +EOL (261) +EQUALS (262) 39 40 41 42 43 44 45 58 59 60 61 62 63 64 65 66 67 68 + 69 70 71 72 73 74 75 76 77 +CHARACTER (263) +COLON (264) +COMMA (265) 55 57 +SEMICOLON (266) 79 +TIMESEPERATOR (267) +TRUE (268) 11 +FALSE (269) 12 +FREQ (270) 39 40 41 42 43 44 45 +BYDAY (271) 69 +BYHOUR (272) 68 +BYMINUTE (273) 67 +BYMONTH (274) 70 +BYMONTHDAY (275) 71 +BYSECOND (276) 66 +BYSETPOS (277) 74 +BYWEEKNO (278) 73 +BYYEARDAY (279) 72 +DAILY (280) 42 +MINUTELY (281) 40 +MONTHLY (282) 44 +SECONDLY (283) 39 +WEEKLY (284) 43 +HOURLY (285) 41 +YEARLY (286) 45 +INTERVAL (287) 58 +COUNT (288) 77 +UNTIL (289) 75 76 +WKST (290) 59 60 61 62 63 64 65 +MO (291) 47 60 +SA (292) 52 65 +SU (293) 46 59 +TU (294) 48 61 +WE (295) 49 62 +TH (296) 50 63 +FR (297) 51 64 +BIT8 (298) +ACCEPTED (299) +ADD (300) +AUDIO (301) +BASE64 (302) +BINARY (303) +BOOLEAN (304) +BUSY (305) +BUSYTENTATIVE (306) +BUSYUNAVAILABLE (307) +CALADDRESS (308) +CANCEL (309) +CANCELLED (310) +CHAIR (311) +CHILD (312) +COMPLETED (313) +CONFIDENTIAL (314) +CONFIRMED (315) +COUNTER (316) +DATE (317) +DATETIME (318) +DECLINECOUNTER (319) +DECLINED (320) +DELEGATED (321) +DISPLAY (322) +DRAFT (323) +DURATION (324) +EMAIL (325) +END (326) +FINAL (327) +FLOAT (328) +FREE (329) +GREGORIAN (330) +GROUP (331) +INDIVIDUAL (332) +INPROCESS (333) +INTEGER (334) +NEEDSACTION (335) +NONPARTICIPANT (336) +OPAQUE (337) +OPTPARTICIPANT (338) +PARENT (339) +PERIOD (340) +PRIVATE (341) +PROCEDURE (342) +PUBLIC (343) +PUBLISH (344) +RECUR (345) +REFRESH (346) +REPLY (347) +REQPARTICIPANT (348) +REQUEST (349) +RESOURCE (350) +ROOM (351) +SIBLING (352) +START (353) +TENTATIVE (354) +TEXT (355) +THISANDFUTURE (356) +THISANDPRIOR (357) +TIME (358) +TRANSPAENT (359) +UNKNOWN (360) +UTCOFFSET (361) +XNAME (362) +ALTREP (363) +CN (364) +CUTYPE (365) +DAYLIGHT (366) +DIR (367) +ENCODING (368) +EVENT (369) +FBTYPE (370) +FMTTYPE (371) +LANGUAGE (372) +MEMBER (373) +PARTSTAT (374) +RANGE (375) +RELATED (376) +RELTYPE (377) +ROLE (378) +RSVP (379) +SENTBY (380) +STANDARD (381) +URI (382) +TIME_CHAR (383) 18 22 23 24 37 38 +UTC_CHAR (384) 15 17 +"unimplemented2" (385) 10 + +Nonterminals, with rules where they appear + +value (141) + on left: 1 2 3 4 5 6 7 8 9 +binary_value (142) + on left: 10, on right: 1 +boolean_value (143) + on left: 11 12, on right: 2 +date_value (144) + on left: 13, on right: 3 76 +utc_char (145) + on left: 14 15, on right: 18 37 38 +utc_char_b (146) + on left: 16 17, on right: 37 +datetime_value (147) + on left: 18, on right: 4 75 +dur_date (148) + on left: 19 20, on right: 34 +dur_week (149) + on left: 21, on right: 36 +dur_time (150) + on left: 22 23 24, on right: 20 35 +dur_hour (151) + on left: 25 26, on right: 22 +dur_minute (152) + on left: 27 28, on right: 23 26 +dur_second (153) + on left: 29, on right: 24 28 +dur_day (154) + on left: 30, on right: 19 20 +dur_prefix (155) + on left: 31 32 33, on right: 34 35 36 +duration_value (156) + on left: 34 35 36, on right: 5 38 +period_value (157) + on left: 37 38, on right: 6 +recur_start (158) + on left: 39 40 41 42 43 44 45, on right: 80 +weekday (159) + on left: 46 47 48 49 50 51 52, on right: 53 54 55 +weekday_list (160) + on left: 53 54 55, on right: 55 69 +recur_list (161) + on left: 56 57, on right: 57 66 67 68 70 71 72 73 74 +recur_skip (162) + on left: 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 + 76 77, on right: 79 +recur_skip_list (163) + on left: 78 79, on right: 79 80 +recur_value (164) + on left: 80, on right: 7 +plusminus (165) + on left: 81 82, on right: 83 84 +utcoffset_value (166) + on left: 83 84, on right: 8 + + +state 0 + + error shift, and go to state 1 + DIGITS shift, and go to state 2 + TRUE shift, and go to state 3 + FALSE shift, and go to state 4 + FREQ shift, and go to state 5 + "unimplemented2" shift, and go to state 6 + '+' shift, and go to state 7 + '-' shift, and go to state 8 + + 'P' reduce using rule 31 (dur_prefix) + + value go to state 133 + binary_value go to state 9 + boolean_value go to state 10 + date_value go to state 11 + datetime_value go to state 12 + dur_prefix go to state 13 + duration_value go to state 14 + period_value go to state 15 + recur_start go to state 16 + recur_value go to state 17 + plusminus go to state 18 + utcoffset_value go to state 19 + + + +state 1 + + value -> error . (rule 9) + + $default reduce using rule 9 (value) + + + +state 2 + + date_value -> DIGITS . (rule 13) + datetime_value -> DIGITS . TIME_CHAR DIGITS utc_char (rule 18) + period_value -> DIGITS . TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b (rule 37) + period_value -> DIGITS . TIME_CHAR DIGITS utc_char '/' duration_value (rule 38) + + TIME_CHAR shift, and go to state 20 + + $default reduce using rule 13 (date_value) + + + +state 3 + + boolean_value -> TRUE . (rule 11) + + $default reduce using rule 11 (boolean_value) + + + +state 4 + + boolean_value -> FALSE . (rule 12) + + $default reduce using rule 12 (boolean_value) + + + +state 5 + + recur_start -> FREQ . EQUALS SECONDLY (rule 39) + recur_start -> FREQ . EQUALS MINUTELY (rule 40) + recur_start -> FREQ . EQUALS HOURLY (rule 41) + recur_start -> FREQ . EQUALS DAILY (rule 42) + recur_start -> FREQ . EQUALS WEEKLY (rule 43) + recur_start -> FREQ . EQUALS MONTHLY (rule 44) + recur_start -> FREQ . EQUALS YEARLY (rule 45) + + EQUALS shift, and go to state 21 + + + +state 6 + + binary_value -> "unimplemented2" . (rule 10) + + $default reduce using rule 10 (binary_value) + + + +state 7 + + dur_prefix -> '+' . (rule 32) + plusminus -> '+' . (rule 81) + + INTNUMBER reduce using rule 81 (plusminus) + $default reduce using rule 32 (dur_prefix) + + + +state 8 + + dur_prefix -> '-' . (rule 33) + plusminus -> '-' . (rule 82) + + INTNUMBER reduce using rule 82 (plusminus) + $default reduce using rule 33 (dur_prefix) + + + +state 9 + + value -> binary_value . (rule 1) + + $default reduce using rule 1 (value) + + + +state 10 + + value -> boolean_value . (rule 2) + + $default reduce using rule 2 (value) + + + +state 11 + + value -> date_value . (rule 3) + + $default reduce using rule 3 (value) + + + +state 12 + + value -> datetime_value . (rule 4) + + $default reduce using rule 4 (value) + + + +state 13 + + duration_value -> dur_prefix . 'P' dur_date (rule 34) + duration_value -> dur_prefix . 'P' dur_time (rule 35) + duration_value -> dur_prefix . 'P' dur_week (rule 36) + + 'P' shift, and go to state 22 + + + +state 14 + + value -> duration_value . (rule 5) + + $default reduce using rule 5 (value) + + + +state 15 + + value -> period_value . (rule 6) + + $default reduce using rule 6 (value) + + + +state 16 + + recur_value -> recur_start . recur_skip_list (rule 80) + + $default reduce using rule 78 (recur_skip_list) + + recur_skip_list go to state 23 + + + +state 17 + + value -> recur_value . (rule 7) + + $default reduce using rule 7 (value) + + + +state 18 + + utcoffset_value -> plusminus . INTNUMBER INTNUMBER (rule 83) + utcoffset_value -> plusminus . INTNUMBER INTNUMBER INTNUMBER (rule 84) + + INTNUMBER shift, and go to state 24 + + + +state 19 + + value -> utcoffset_value . (rule 8) + + $default reduce using rule 8 (value) + + + +state 20 + + datetime_value -> DIGITS TIME_CHAR . DIGITS utc_char (rule 18) + period_value -> DIGITS TIME_CHAR . DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b (rule 37) + period_value -> DIGITS TIME_CHAR . DIGITS utc_char '/' duration_value (rule 38) + + DIGITS shift, and go to state 25 + + + +state 21 + + recur_start -> FREQ EQUALS . SECONDLY (rule 39) + recur_start -> FREQ EQUALS . MINUTELY (rule 40) + recur_start -> FREQ EQUALS . HOURLY (rule 41) + recur_start -> FREQ EQUALS . DAILY (rule 42) + recur_start -> FREQ EQUALS . WEEKLY (rule 43) + recur_start -> FREQ EQUALS . MONTHLY (rule 44) + recur_start -> FREQ EQUALS . YEARLY (rule 45) + + DAILY shift, and go to state 26 + MINUTELY shift, and go to state 27 + MONTHLY shift, and go to state 28 + SECONDLY shift, and go to state 29 + WEEKLY shift, and go to state 30 + HOURLY shift, and go to state 31 + YEARLY shift, and go to state 32 + + + +state 22 + + duration_value -> dur_prefix 'P' . dur_date (rule 34) + duration_value -> dur_prefix 'P' . dur_time (rule 35) + duration_value -> dur_prefix 'P' . dur_week (rule 36) + + DIGITS shift, and go to state 33 + TIME_CHAR shift, and go to state 34 + + dur_date go to state 35 + dur_week go to state 36 + dur_time go to state 37 + dur_day go to state 38 + + + +state 23 + + recur_skip_list -> recur_skip_list . SEMICOLON recur_skip (rule 79) + recur_value -> recur_start recur_skip_list . (rule 80) + + SEMICOLON shift, and go to state 39 + + $default reduce using rule 80 (recur_value) + + + +state 24 + + utcoffset_value -> plusminus INTNUMBER . INTNUMBER (rule 83) + utcoffset_value -> plusminus INTNUMBER . INTNUMBER INTNUMBER (rule 84) + + INTNUMBER shift, and go to state 40 + + + +state 25 + + datetime_value -> DIGITS TIME_CHAR DIGITS . utc_char (rule 18) + period_value -> DIGITS TIME_CHAR DIGITS . utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b (rule 37) + period_value -> DIGITS TIME_CHAR DIGITS . utc_char '/' duration_value (rule 38) + + UTC_CHAR shift, and go to state 41 + + $default reduce using rule 14 (utc_char) + + utc_char go to state 42 + + + +state 26 + + recur_start -> FREQ EQUALS DAILY . (rule 42) + + $default reduce using rule 42 (recur_start) + + + +state 27 + + recur_start -> FREQ EQUALS MINUTELY . (rule 40) + + $default reduce using rule 40 (recur_start) + + + +state 28 + + recur_start -> FREQ EQUALS MONTHLY . (rule 44) + + $default reduce using rule 44 (recur_start) + + + +state 29 + + recur_start -> FREQ EQUALS SECONDLY . (rule 39) + + $default reduce using rule 39 (recur_start) + + + +state 30 + + recur_start -> FREQ EQUALS WEEKLY . (rule 43) + + $default reduce using rule 43 (recur_start) + + + +state 31 + + recur_start -> FREQ EQUALS HOURLY . (rule 41) + + $default reduce using rule 41 (recur_start) + + + +state 32 + + recur_start -> FREQ EQUALS YEARLY . (rule 45) + + $default reduce using rule 45 (recur_start) + + + +state 33 + + dur_week -> DIGITS . 'W' (rule 21) + dur_day -> DIGITS . 'D' (rule 30) + + 'W' shift, and go to state 43 + 'D' shift, and go to state 44 + + + +state 34 + + dur_time -> TIME_CHAR . dur_hour (rule 22) + dur_time -> TIME_CHAR . dur_minute (rule 23) + dur_time -> TIME_CHAR . dur_second (rule 24) + + DIGITS shift, and go to state 45 + + dur_hour go to state 46 + dur_minute go to state 47 + dur_second go to state 48 + + + +state 35 + + duration_value -> dur_prefix 'P' dur_date . (rule 34) + + $default reduce using rule 34 (duration_value) + + + +state 36 + + duration_value -> dur_prefix 'P' dur_week . (rule 36) + + $default reduce using rule 36 (duration_value) + + + +state 37 + + duration_value -> dur_prefix 'P' dur_time . (rule 35) + + $default reduce using rule 35 (duration_value) + + + +state 38 + + dur_date -> dur_day . (rule 19) + dur_date -> dur_day . dur_time (rule 20) + + TIME_CHAR shift, and go to state 34 + + $default reduce using rule 19 (dur_date) + + dur_time go to state 49 + + + +state 39 + + recur_skip_list -> recur_skip_list SEMICOLON . recur_skip (rule 79) + + BYDAY shift, and go to state 50 + BYHOUR shift, and go to state 51 + BYMINUTE shift, and go to state 52 + BYMONTH shift, and go to state 53 + BYMONTHDAY shift, and go to state 54 + BYSECOND shift, and go to state 55 + BYSETPOS shift, and go to state 56 + BYWEEKNO shift, and go to state 57 + BYYEARDAY shift, and go to state 58 + INTERVAL shift, and go to state 59 + COUNT shift, and go to state 60 + UNTIL shift, and go to state 61 + WKST shift, and go to state 62 + + recur_skip go to state 63 + + + +state 40 + + utcoffset_value -> plusminus INTNUMBER INTNUMBER . (rule 83) + utcoffset_value -> plusminus INTNUMBER INTNUMBER . INTNUMBER (rule 84) + + INTNUMBER shift, and go to state 64 + + $default reduce using rule 83 (utcoffset_value) + + + +state 41 + + utc_char -> UTC_CHAR . (rule 15) + + $default reduce using rule 15 (utc_char) + + + +state 42 + + datetime_value -> DIGITS TIME_CHAR DIGITS utc_char . (rule 18) + period_value -> DIGITS TIME_CHAR DIGITS utc_char . '/' DIGITS TIME_CHAR DIGITS utc_char_b (rule 37) + period_value -> DIGITS TIME_CHAR DIGITS utc_char . '/' duration_value (rule 38) + + '/' shift, and go to state 65 + + $default reduce using rule 18 (datetime_value) + + + +state 43 + + dur_week -> DIGITS 'W' . (rule 21) + + $default reduce using rule 21 (dur_week) + + + +state 44 + + dur_day -> DIGITS 'D' . (rule 30) + + $default reduce using rule 30 (dur_day) + + + +state 45 + + dur_hour -> DIGITS . 'H' (rule 25) + dur_hour -> DIGITS . 'H' dur_minute (rule 26) + dur_minute -> DIGITS . 'M' (rule 27) + dur_minute -> DIGITS . 'M' dur_second (rule 28) + dur_second -> DIGITS . 'S' (rule 29) + + 'H' shift, and go to state 66 + 'M' shift, and go to state 67 + 'S' shift, and go to state 68 + + + +state 46 + + dur_time -> TIME_CHAR dur_hour . (rule 22) + + $default reduce using rule 22 (dur_time) + + + +state 47 + + dur_time -> TIME_CHAR dur_minute . (rule 23) + + $default reduce using rule 23 (dur_time) + + + +state 48 + + dur_time -> TIME_CHAR dur_second . (rule 24) + + $default reduce using rule 24 (dur_time) + + + +state 49 + + dur_date -> dur_day dur_time . (rule 20) + + $default reduce using rule 20 (dur_date) + + + +state 50 + + recur_skip -> BYDAY . EQUALS weekday_list (rule 69) + + EQUALS shift, and go to state 69 + + + +state 51 + + recur_skip -> BYHOUR . EQUALS recur_list (rule 68) + + EQUALS shift, and go to state 70 + + + +state 52 + + recur_skip -> BYMINUTE . EQUALS recur_list (rule 67) + + EQUALS shift, and go to state 71 + + + +state 53 + + recur_skip -> BYMONTH . EQUALS recur_list (rule 70) + + EQUALS shift, and go to state 72 + + + +state 54 + + recur_skip -> BYMONTHDAY . EQUALS recur_list (rule 71) + + EQUALS shift, and go to state 73 + + + +state 55 + + recur_skip -> BYSECOND . EQUALS recur_list (rule 66) + + EQUALS shift, and go to state 74 + + + +state 56 + + recur_skip -> BYSETPOS . EQUALS recur_list (rule 74) + + EQUALS shift, and go to state 75 + + + +state 57 + + recur_skip -> BYWEEKNO . EQUALS recur_list (rule 73) + + EQUALS shift, and go to state 76 + + + +state 58 + + recur_skip -> BYYEARDAY . EQUALS recur_list (rule 72) + + EQUALS shift, and go to state 77 + + + +state 59 + + recur_skip -> INTERVAL . EQUALS DIGITS (rule 58) + + EQUALS shift, and go to state 78 + + + +state 60 + + recur_skip -> COUNT . EQUALS DIGITS (rule 77) + + EQUALS shift, and go to state 79 + + + +state 61 + + recur_skip -> UNTIL . EQUALS datetime_value (rule 75) + recur_skip -> UNTIL . EQUALS date_value (rule 76) + + EQUALS shift, and go to state 80 + + + +state 62 + + recur_skip -> WKST . EQUALS SU (rule 59) + recur_skip -> WKST . EQUALS MO (rule 60) + recur_skip -> WKST . EQUALS TU (rule 61) + recur_skip -> WKST . EQUALS WE (rule 62) + recur_skip -> WKST . EQUALS TH (rule 63) + recur_skip -> WKST . EQUALS FR (rule 64) + recur_skip -> WKST . EQUALS SA (rule 65) + + EQUALS shift, and go to state 81 + + + +state 63 + + recur_skip_list -> recur_skip_list SEMICOLON recur_skip . (rule 79) + + $default reduce using rule 79 (recur_skip_list) + + + +state 64 + + utcoffset_value -> plusminus INTNUMBER INTNUMBER INTNUMBER . (rule 84) + + $default reduce using rule 84 (utcoffset_value) + + + +state 65 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' . DIGITS TIME_CHAR DIGITS utc_char_b (rule 37) + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' . duration_value (rule 38) + + DIGITS shift, and go to state 82 + '+' shift, and go to state 83 + '-' shift, and go to state 84 + + $default reduce using rule 31 (dur_prefix) + + dur_prefix go to state 13 + duration_value go to state 85 + + + +state 66 + + dur_hour -> DIGITS 'H' . (rule 25) + dur_hour -> DIGITS 'H' . dur_minute (rule 26) + + DIGITS shift, and go to state 86 + + $default reduce using rule 25 (dur_hour) + + dur_minute go to state 87 + + + +state 67 + + dur_minute -> DIGITS 'M' . (rule 27) + dur_minute -> DIGITS 'M' . dur_second (rule 28) + + DIGITS shift, and go to state 88 + + $default reduce using rule 27 (dur_minute) + + dur_second go to state 89 + + + +state 68 + + dur_second -> DIGITS 'S' . (rule 29) + + $default reduce using rule 29 (dur_second) + + + +state 69 + + recur_skip -> BYDAY EQUALS . weekday_list (rule 69) + + DIGITS shift, and go to state 90 + MO shift, and go to state 91 + SA shift, and go to state 92 + SU shift, and go to state 93 + TU shift, and go to state 94 + WE shift, and go to state 95 + TH shift, and go to state 96 + FR shift, and go to state 97 + + weekday go to state 98 + weekday_list go to state 99 + + + +state 70 + + recur_skip -> BYHOUR EQUALS . recur_list (rule 68) + + DIGITS shift, and go to state 100 + + recur_list go to state 101 + + + +state 71 + + recur_skip -> BYMINUTE EQUALS . recur_list (rule 67) + + DIGITS shift, and go to state 100 + + recur_list go to state 102 + + + +state 72 + + recur_skip -> BYMONTH EQUALS . recur_list (rule 70) + + DIGITS shift, and go to state 100 + + recur_list go to state 103 + + + +state 73 + + recur_skip -> BYMONTHDAY EQUALS . recur_list (rule 71) + + DIGITS shift, and go to state 100 + + recur_list go to state 104 + + + +state 74 + + recur_skip -> BYSECOND EQUALS . recur_list (rule 66) + + DIGITS shift, and go to state 100 + + recur_list go to state 105 + + + +state 75 + + recur_skip -> BYSETPOS EQUALS . recur_list (rule 74) + + DIGITS shift, and go to state 100 + + recur_list go to state 106 + + + +state 76 + + recur_skip -> BYWEEKNO EQUALS . recur_list (rule 73) + + DIGITS shift, and go to state 100 + + recur_list go to state 107 + + + +state 77 + + recur_skip -> BYYEARDAY EQUALS . recur_list (rule 72) + + DIGITS shift, and go to state 100 + + recur_list go to state 108 + + + +state 78 + + recur_skip -> INTERVAL EQUALS . DIGITS (rule 58) + + DIGITS shift, and go to state 109 + + + +state 79 + + recur_skip -> COUNT EQUALS . DIGITS (rule 77) + + DIGITS shift, and go to state 110 + + + +state 80 + + recur_skip -> UNTIL EQUALS . datetime_value (rule 75) + recur_skip -> UNTIL EQUALS . date_value (rule 76) + + DIGITS shift, and go to state 111 + + date_value go to state 112 + datetime_value go to state 113 + + + +state 81 + + recur_skip -> WKST EQUALS . SU (rule 59) + recur_skip -> WKST EQUALS . MO (rule 60) + recur_skip -> WKST EQUALS . TU (rule 61) + recur_skip -> WKST EQUALS . WE (rule 62) + recur_skip -> WKST EQUALS . TH (rule 63) + recur_skip -> WKST EQUALS . FR (rule 64) + recur_skip -> WKST EQUALS . SA (rule 65) + + MO shift, and go to state 114 + SA shift, and go to state 115 + SU shift, and go to state 116 + TU shift, and go to state 117 + WE shift, and go to state 118 + TH shift, and go to state 119 + FR shift, and go to state 120 + + + +state 82 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS . TIME_CHAR DIGITS utc_char_b (rule 37) + + TIME_CHAR shift, and go to state 121 + + + +state 83 + + dur_prefix -> '+' . (rule 32) + + $default reduce using rule 32 (dur_prefix) + + + +state 84 + + dur_prefix -> '-' . (rule 33) + + $default reduce using rule 33 (dur_prefix) + + + +state 85 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' duration_value . (rule 38) + + $default reduce using rule 38 (period_value) + + + +state 86 + + dur_minute -> DIGITS . 'M' (rule 27) + dur_minute -> DIGITS . 'M' dur_second (rule 28) + + 'M' shift, and go to state 67 + + + +state 87 + + dur_hour -> DIGITS 'H' dur_minute . (rule 26) + + $default reduce using rule 26 (dur_hour) + + + +state 88 + + dur_second -> DIGITS . 'S' (rule 29) + + 'S' shift, and go to state 68 + + + +state 89 + + dur_minute -> DIGITS 'M' dur_second . (rule 28) + + $default reduce using rule 28 (dur_minute) + + + +state 90 + + weekday_list -> DIGITS . weekday (rule 54) + + MO shift, and go to state 91 + SA shift, and go to state 92 + SU shift, and go to state 93 + TU shift, and go to state 94 + WE shift, and go to state 95 + TH shift, and go to state 96 + FR shift, and go to state 97 + + weekday go to state 122 + + + +state 91 + + weekday -> MO . (rule 47) + + $default reduce using rule 47 (weekday) + + + +state 92 + + weekday -> SA . (rule 52) + + $default reduce using rule 52 (weekday) + + + +state 93 + + weekday -> SU . (rule 46) + + $default reduce using rule 46 (weekday) + + + +state 94 + + weekday -> TU . (rule 48) + + $default reduce using rule 48 (weekday) + + + +state 95 + + weekday -> WE . (rule 49) + + $default reduce using rule 49 (weekday) + + + +state 96 + + weekday -> TH . (rule 50) + + $default reduce using rule 50 (weekday) + + + +state 97 + + weekday -> FR . (rule 51) + + $default reduce using rule 51 (weekday) + + + +state 98 + + weekday_list -> weekday . (rule 53) + + $default reduce using rule 53 (weekday_list) + + + +state 99 + + weekday_list -> weekday_list . COMMA weekday (rule 55) + recur_skip -> BYDAY EQUALS weekday_list . (rule 69) + + COMMA shift, and go to state 123 + + $default reduce using rule 69 (recur_skip) + + + +state 100 + + recur_list -> DIGITS . (rule 56) + + $default reduce using rule 56 (recur_list) + + + +state 101 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYHOUR EQUALS recur_list . (rule 68) + + COMMA shift, and go to state 124 + + $default reduce using rule 68 (recur_skip) + + + +state 102 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYMINUTE EQUALS recur_list . (rule 67) + + COMMA shift, and go to state 124 + + $default reduce using rule 67 (recur_skip) + + + +state 103 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYMONTH EQUALS recur_list . (rule 70) + + COMMA shift, and go to state 124 + + $default reduce using rule 70 (recur_skip) + + + +state 104 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYMONTHDAY EQUALS recur_list . (rule 71) + + COMMA shift, and go to state 124 + + $default reduce using rule 71 (recur_skip) + + + +state 105 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYSECOND EQUALS recur_list . (rule 66) + + COMMA shift, and go to state 124 + + $default reduce using rule 66 (recur_skip) + + + +state 106 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYSETPOS EQUALS recur_list . (rule 74) + + COMMA shift, and go to state 124 + + $default reduce using rule 74 (recur_skip) + + + +state 107 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYWEEKNO EQUALS recur_list . (rule 73) + + COMMA shift, and go to state 124 + + $default reduce using rule 73 (recur_skip) + + + +state 108 + + recur_list -> recur_list . COMMA DIGITS (rule 57) + recur_skip -> BYYEARDAY EQUALS recur_list . (rule 72) + + COMMA shift, and go to state 124 + + $default reduce using rule 72 (recur_skip) + + + +state 109 + + recur_skip -> INTERVAL EQUALS DIGITS . (rule 58) + + $default reduce using rule 58 (recur_skip) + + + +state 110 + + recur_skip -> COUNT EQUALS DIGITS . (rule 77) + + $default reduce using rule 77 (recur_skip) + + + +state 111 + + date_value -> DIGITS . (rule 13) + datetime_value -> DIGITS . TIME_CHAR DIGITS utc_char (rule 18) + + TIME_CHAR shift, and go to state 125 + + $default reduce using rule 13 (date_value) + + + +state 112 + + recur_skip -> UNTIL EQUALS date_value . (rule 76) + + $default reduce using rule 76 (recur_skip) + + + +state 113 + + recur_skip -> UNTIL EQUALS datetime_value . (rule 75) + + $default reduce using rule 75 (recur_skip) + + + +state 114 + + recur_skip -> WKST EQUALS MO . (rule 60) + + $default reduce using rule 60 (recur_skip) + + + +state 115 + + recur_skip -> WKST EQUALS SA . (rule 65) + + $default reduce using rule 65 (recur_skip) + + + +state 116 + + recur_skip -> WKST EQUALS SU . (rule 59) + + $default reduce using rule 59 (recur_skip) + + + +state 117 + + recur_skip -> WKST EQUALS TU . (rule 61) + + $default reduce using rule 61 (recur_skip) + + + +state 118 + + recur_skip -> WKST EQUALS WE . (rule 62) + + $default reduce using rule 62 (recur_skip) + + + +state 119 + + recur_skip -> WKST EQUALS TH . (rule 63) + + $default reduce using rule 63 (recur_skip) + + + +state 120 + + recur_skip -> WKST EQUALS FR . (rule 64) + + $default reduce using rule 64 (recur_skip) + + + +state 121 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR . DIGITS utc_char_b (rule 37) + + DIGITS shift, and go to state 126 + + + +state 122 + + weekday_list -> DIGITS weekday . (rule 54) + + $default reduce using rule 54 (weekday_list) + + + +state 123 + + weekday_list -> weekday_list COMMA . weekday (rule 55) + + MO shift, and go to state 91 + SA shift, and go to state 92 + SU shift, and go to state 93 + TU shift, and go to state 94 + WE shift, and go to state 95 + TH shift, and go to state 96 + FR shift, and go to state 97 + + weekday go to state 127 + + + +state 124 + + recur_list -> recur_list COMMA . DIGITS (rule 57) + + DIGITS shift, and go to state 128 + + + +state 125 + + datetime_value -> DIGITS TIME_CHAR . DIGITS utc_char (rule 18) + + DIGITS shift, and go to state 129 + + + +state 126 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS . utc_char_b (rule 37) + + UTC_CHAR shift, and go to state 130 + + $default reduce using rule 16 (utc_char_b) + + utc_char_b go to state 131 + + + +state 127 + + weekday_list -> weekday_list COMMA weekday . (rule 55) + + $default reduce using rule 55 (weekday_list) + + + +state 128 + + recur_list -> recur_list COMMA DIGITS . (rule 57) + + $default reduce using rule 57 (recur_list) + + + +state 129 + + datetime_value -> DIGITS TIME_CHAR DIGITS . utc_char (rule 18) + + UTC_CHAR shift, and go to state 41 + + $default reduce using rule 14 (utc_char) + + utc_char go to state 132 + + + +state 130 + + utc_char_b -> UTC_CHAR . (rule 17) + + $default reduce using rule 17 (utc_char_b) + + + +state 131 + + period_value -> DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b . (rule 37) + + $default reduce using rule 37 (period_value) + + + +state 132 + + datetime_value -> DIGITS TIME_CHAR DIGITS utc_char . (rule 18) + + $default reduce using rule 18 (datetime_value) + + + +state 133 + + $ go to state 134 + + + +state 134 + + $ go to state 135 + + + +state 135 + + $default accept diff --git a/libical/src/libical/icalitip.tab.c b/libical/src/libical/icalitip.tab.c new file mode 100644 index 0000000000..a51715a9f3 --- /dev/null +++ b/libical/src/libical/icalitip.tab.c @@ -0,0 +1,1660 @@ + +/* A Bison parser, made from icalitip.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define DIGITS 257 +#define INTNUMBER 258 +#define FLOATNUMBER 259 +#define STRING 260 +#define EOL 261 +#define EQUALS 262 +#define CHARACTER 263 +#define COLON 264 +#define COMMA 265 +#define SEMICOLON 266 +#define TIMESEPERATOR 267 +#define TRUE 268 +#define FALSE 269 +#define FREQ 270 +#define BYDAY 271 +#define BYHOUR 272 +#define BYMINUTE 273 +#define BYMONTH 274 +#define BYMONTHDAY 275 +#define BYSECOND 276 +#define BYSETPOS 277 +#define BYWEEKNO 278 +#define BYYEARDAY 279 +#define DAILY 280 +#define MINUTELY 281 +#define MONTHLY 282 +#define SECONDLY 283 +#define WEEKLY 284 +#define HOURLY 285 +#define YEARLY 286 +#define INTERVAL 287 +#define COUNT 288 +#define UNTIL 289 +#define WKST 290 +#define MO 291 +#define SA 292 +#define SU 293 +#define TU 294 +#define WE 295 +#define TH 296 +#define FR 297 +#define BIT8 298 +#define ACCEPTED 299 +#define ADD 300 +#define AUDIO 301 +#define BASE64 302 +#define BINARY 303 +#define BOOLEAN 304 +#define BUSY 305 +#define BUSYTENTATIVE 306 +#define BUSYUNAVAILABLE 307 +#define CALADDRESS 308 +#define CANCEL 309 +#define CANCELLED 310 +#define CHAIR 311 +#define CHILD 312 +#define COMPLETED 313 +#define CONFIDENTIAL 314 +#define CONFIRMED 315 +#define COUNTER 316 +#define DATE 317 +#define DATETIME 318 +#define DECLINECOUNTER 319 +#define DECLINED 320 +#define DELEGATED 321 +#define DISPLAY 322 +#define DRAFT 323 +#define DURATION 324 +#define EMAIL 325 +#define END 326 +#define FINAL 327 +#define FLOAT 328 +#define FREE 329 +#define GREGORIAN 330 +#define GROUP 331 +#define INDIVIDUAL 332 +#define INPROCESS 333 +#define INTEGER 334 +#define NEEDSACTION 335 +#define NONPARTICIPANT 336 +#define OPAQUE 337 +#define OPTPARTICIPANT 338 +#define PARENT 339 +#define PERIOD 340 +#define PRIVATE 341 +#define PROCEDURE 342 +#define PUBLIC 343 +#define PUBLISH 344 +#define RECUR 345 +#define REFRESH 346 +#define REPLY 347 +#define REQPARTICIPANT 348 +#define REQUEST 349 +#define RESOURCE 350 +#define ROOM 351 +#define SIBLING 352 +#define START 353 +#define TENTATIVE 354 +#define TEXT 355 +#define THISANDFUTURE 356 +#define THISANDPRIOR 357 +#define TIME 358 +#define TRANSPAENT 359 +#define UNKNOWN 360 +#define UTCOFFSET 361 +#define XNAME 362 +#define ALTREP 363 +#define CN 364 +#define CUTYPE 365 +#define DAYLIGHT 366 +#define DIR 367 +#define ENCODING 368 +#define EVENT 369 +#define FBTYPE 370 +#define FMTTYPE 371 +#define LANGUAGE 372 +#define MEMBER 373 +#define PARTSTAT 374 +#define RANGE 375 +#define RELATED 376 +#define RELTYPE 377 +#define ROLE 378 +#define RSVP 379 +#define SENTBY 380 +#define STANDARD 381 +#define URI 382 +#define TIME_CHAR 383 +#define UTC_CHAR 384 + +#line 1 "icalitip.y" + +/* -*- Mode: C -*- + ====================================================================== + FILE: icalitip.y + CREATOR: eric 10 June 1999 + + DESCRIPTION: + + $Id$ + $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 + + + + ================================b======================================*/ + +#include <stdlib.h> +#include <string.h> /* for strdup() */ +#include <limits.h> /* for SHRT_MAX*/ +#include "icalparser.h" +#include "ical.h" +#include "pvl.h" + +#define YYERROR_VERBOSE +#define YYDEBUG 1 + +icalvalue *icalparser_yy_value; /* Current Value */ + +/* Globals for UTCOFFSET values */ +int utc; +int utc_b; +int utcsign; + +/* Globals for DURATION values */ +struct icaldurationtype duration; + +/* Globals for RECUR values */ +struct icalrecurrencetype recur; +short skiplist[367]; +short skippos; + +void copy_list(short* array, size_t size); +void clear_recur(); +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 yyerror(char *s); /* Don't know why I need this.... */ +int yylex(void); /* Or this. */ +void set_parser_value_state(); +struct icaltimetype fill_datetime(char* d, char* t); + + + +/* Set the state of the lexer so it will interpret values ( iCAL + VALUEs, that is, ) correctly. */ + + +#line 75 "icalitip.y" +typedef union { + float v_float; + int v_int; + char* v_string; + +} YYSTYPE; +#ifndef YYDEBUG +#define YYDEBUG 1 +#endif + +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 135 +#define YYFLAG -32768 +#define YYNTBASE 141 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 385 ? yytranslate[x] : 167) + +static const short yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 137, 2, 138, 2, 140, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 136, 2, 2, + 2, 133, 2, 2, 2, 2, 134, 2, 2, 139, + 2, 2, 135, 2, 2, 2, 132, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 20, 22, 24, 26, 27, 29, 30, 32, 37, 39, + 42, 45, 48, 51, 54, 57, 61, 64, 68, 71, + 74, 75, 77, 79, 83, 87, 91, 101, 108, 112, + 116, 120, 124, 128, 132, 136, 138, 140, 142, 144, + 146, 148, 150, 152, 155, 159, 161, 165, 169, 173, + 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, + 217, 221, 225, 229, 233, 237, 241, 245, 246, 250, + 253, 255, 257, 261 +}; + +static const short yyrhs[] = { 142, + 0, 143, 0, 144, 0, 147, 0, 156, 0, 157, + 0, 164, 0, 166, 0, 1, 0, 131, 0, 14, + 0, 15, 0, 3, 0, 0, 130, 0, 0, 130, + 0, 3, 129, 3, 145, 0, 154, 0, 154, 150, + 0, 3, 132, 0, 129, 151, 0, 129, 152, 0, + 129, 153, 0, 3, 133, 0, 3, 133, 152, 0, + 3, 134, 0, 3, 134, 153, 0, 3, 135, 0, + 3, 136, 0, 0, 137, 0, 138, 0, 155, 139, + 148, 0, 155, 139, 150, 0, 155, 139, 149, 0, + 3, 129, 3, 145, 140, 3, 129, 3, 146, 0, + 3, 129, 3, 145, 140, 156, 0, 16, 8, 29, + 0, 16, 8, 27, 0, 16, 8, 31, 0, 16, + 8, 26, 0, 16, 8, 30, 0, 16, 8, 28, + 0, 16, 8, 32, 0, 39, 0, 37, 0, 40, + 0, 41, 0, 42, 0, 43, 0, 38, 0, 159, + 0, 3, 159, 0, 160, 11, 159, 0, 3, 0, + 161, 11, 3, 0, 33, 8, 3, 0, 36, 8, + 39, 0, 36, 8, 37, 0, 36, 8, 40, 0, + 36, 8, 41, 0, 36, 8, 42, 0, 36, 8, + 43, 0, 36, 8, 38, 0, 22, 8, 161, 0, + 19, 8, 161, 0, 18, 8, 161, 0, 17, 8, + 160, 0, 20, 8, 161, 0, 21, 8, 161, 0, + 25, 8, 161, 0, 24, 8, 161, 0, 23, 8, + 161, 0, 35, 8, 147, 0, 35, 8, 144, 0, + 34, 8, 3, 0, 0, 163, 12, 162, 0, 158, + 163, 0, 137, 0, 138, 0, 165, 4, 4, 0, + 165, 4, 4, 4, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 112, 114, 115, 116, 117, 118, 119, 120, 121, 127, + 129, 132, 135, 150, 152, 155, 157, 159, 175, 176, + 178, 183, 186, 189, 193, 197, 202, 206, 211, 216, + 221, 224, 227, 231, 236, 241, 250, 271, 303, 305, + 306, 307, 308, 309, 310, 314, 316, 317, 318, 319, + 320, 321, 325, 327, 328, 331, 333, 336, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 357, 360, 364, 366, 368, + 376, 377, 379, 385 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","DIGITS", +"INTNUMBER","FLOATNUMBER","STRING","EOL","EQUALS","CHARACTER","COLON","COMMA", +"SEMICOLON","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","TIME_CHAR","UTC_CHAR","\"unimplemented2\"", +"'W'","'H'","'M'","'S'","'D'","'+'","'-'","'P'","'/'","value","binary_value", +"boolean_value","date_value","utc_char","utc_char_b","datetime_value","dur_date", +"dur_week","dur_time","dur_hour","dur_minute","dur_second","dur_day","dur_prefix", +"duration_value","period_value","recur_start","weekday","weekday_list","recur_list", +"recur_skip","recur_skip_list","recur_value","plusminus","utcoffset_value", NULL +}; +#endif + +static const short yyr1[] = { 0, + 141, 141, 141, 141, 141, 141, 141, 141, 141, 142, + 143, 143, 144, 145, 145, 146, 146, 147, 148, 148, + 149, 150, 150, 150, 151, 151, 152, 152, 153, 154, + 155, 155, 155, 156, 156, 156, 157, 157, 158, 158, + 158, 158, 158, 158, 158, 159, 159, 159, 159, 159, + 159, 159, 160, 160, 160, 161, 161, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 163, 163, 164, + 165, 165, 166, 166 +}; + +static const short yyr2[] = { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 1, 0, 1, 4, 1, 2, + 2, 2, 2, 2, 2, 3, 2, 3, 2, 2, + 0, 1, 1, 3, 3, 3, 9, 6, 3, 3, + 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 3, 1, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 0, 3, 2, + 1, 1, 3, 4 +}; + +static const short yydefact[] = { 0, + 9, 13, 11, 12, 0, 10, 32, 33, 1, 2, + 3, 4, 0, 5, 6, 78, 7, 0, 8, 0, + 0, 0, 80, 0, 14, 42, 40, 44, 39, 43, + 41, 45, 0, 0, 34, 36, 35, 19, 0, 83, + 15, 18, 21, 30, 0, 22, 23, 24, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 79, 84, 31, 25, 27, 29, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 32, 33, 38, 0, 26, 0, 28, 0, + 47, 52, 46, 48, 49, 50, 51, 53, 69, 56, + 68, 67, 70, 71, 66, 74, 73, 72, 58, 77, + 13, 76, 75, 60, 65, 59, 61, 62, 63, 64, + 0, 54, 0, 0, 0, 16, 55, 57, 14, 17, + 37, 18, 0, 0, 0 +}; + +static const short yydefgoto[] = { 133, + 9, 10, 11, 42, 131, 12, 35, 36, 37, 46, + 47, 48, 38, 13, 14, 15, 16, 98, 99, 101, + 63, 23, 17, 18, 19 +}; + +static const short yypact[] = { -1, +-32768, -123,-32768,-32768, 1,-32768, 3, 6,-32768,-32768, +-32768,-32768, -127,-32768,-32768,-32768,-32768, 64,-32768, 66, + -10, -2, 58, 67, -58,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, -128, 70,-32768,-32768,-32768, -55, 28, 71, +-32768, -64,-32768,-32768, -68,-32768,-32768,-32768,-32768, 69, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83,-32768,-32768, 2, 89, 90,-32768, 0, 91, + 91, 91, 91, 91, 91, 91, 91, 92, 93, 94, + -14, -51,-32768,-32768,-32768, -36,-32768, -56,-32768, -7, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 88,-32768, + 95, 95, 95, 95, 95, 95, 95, 95,-32768,-32768, + -29,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 98,-32768, -7, 99, 100, -26,-32768,-32768, -58,-32768, +-32768,-32768, 105, 107,-32768 +}; + +static const short yypgoto[] = {-32768, +-32768,-32768, 29, -21,-32768, 30,-32768,-32768, 84,-32768, + 45, 46,-32768,-32768, 47,-32768,-32768, -79,-32768, -17, +-32768,-32768,-32768,-32768,-32768 +}; + + +#define YYLAST 140 + + +static const short yytable[] = { 1, + 33, 2, 90, 43, 82, 20, -81, 44, 21, -82, + 122, 22, 3, 4, 5, 26, 27, 28, 29, 30, + 31, 32, 114, 115, 116, 117, 118, 119, 120, 91, + 92, 93, 94, 95, 96, 97, 91, 92, 93, 94, + 95, 96, 97, 127, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 102, 103, 104, 105, 106, 107, 108, + 59, 60, 61, 62, 66, 67, 68, 24, 25, 39, + 40, 41, 45, 34, 64, 65, 69, 121, 68, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 86, 88, 100, 109, 110, 111, 67, 123, 125, + 126, 128, 129, 130, 134, 124, 135, 132, 112, 113, + 87, 85, 89, 0, 0, 0, 0, 0, 0, 0, + 0, 49, 0, 0, 0, 0, 34, 0, 0, 6, + 0, 0, 0, 0, 0, 7, 8, -31, 83, 84 +}; + +static const short yycheck[] = { 1, + 3, 3, 3, 132, 3, 129, 4, 136, 8, 4, + 90, 139, 14, 15, 16, 26, 27, 28, 29, 30, + 31, 32, 37, 38, 39, 40, 41, 42, 43, 37, + 38, 39, 40, 41, 42, 43, 37, 38, 39, 40, + 41, 42, 43, 123, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 71, 72, 73, 74, 75, 76, 77, + 33, 34, 35, 36, 133, 134, 135, 4, 3, 12, + 4, 130, 3, 129, 4, 140, 8, 129, 135, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 3, 3, 3, 3, 3, 3, 134, 11, 129, + 3, 3, 3, 130, 0, 11, 0, 129, 80, 80, + 66, 65, 67, -1, -1, -1, -1, -1, -1, -1, + -1, 38, -1, -1, -1, -1, 129, -1, -1, 131, + -1, -1, -1, -1, -1, 137, 138, 139, 137, 138 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/lib/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/lib/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 9: +#line 121 "icalitip.y" +{ + icalparser_yy_value = 0; + icalparser_clear_flex_input(); + yyclearin; + ; + break;} +case 11: +#line 131 "icalitip.y" +{ icalparser_yy_value = icalvalue_new_boolean(1); ; + break;} +case 12: +#line 133 "icalitip.y" +{ icalparser_yy_value = icalvalue_new_boolean(0); ; + break;} +case 13: +#line 136 "icalitip.y" +{ + struct icaltimetype stm; + + stm = fill_datetime(yyvsp[0].v_string,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); + ; + break;} +case 14: +#line 151 "icalitip.y" +{utc = 0;; + break;} +case 15: +#line 152 "icalitip.y" +{utc = 1;; + break;} +case 16: +#line 156 "icalitip.y" +{utc_b = 0;; + break;} +case 17: +#line 157 "icalitip.y" +{utc_b = 1;; + break;} +case 18: +#line 161 "icalitip.y" +{ + struct icaltimetype stm; + stm = fill_datetime(yyvsp[-3].v_string, yyvsp[-1].v_string); + stm.is_utc = utc; + stm.is_date = 0; + + icalparser_yy_value = + icalvalue_new_datetime(stm); + ; + break;} +case 21: +#line 179 "icalitip.y" +{ + duration.weeks = atoi(yyvsp[-1].v_string); + ; + break;} +case 22: +#line 184 "icalitip.y" +{ + ; + break;} +case 23: +#line 187 "icalitip.y" +{ + ; + break;} +case 24: +#line 190 "icalitip.y" +{ + ; + break;} +case 25: +#line 194 "icalitip.y" +{ + duration.hours = atoi(yyvsp[-1].v_string); + ; + break;} +case 26: +#line 198 "icalitip.y" +{ + duration.hours = atoi(yyvsp[-2].v_string); + ; + break;} +case 27: +#line 203 "icalitip.y" +{ + duration.minutes = atoi(yyvsp[-1].v_string); + ; + break;} +case 28: +#line 207 "icalitip.y" +{ + duration.minutes = atoi(yyvsp[-2].v_string); + ; + break;} +case 29: +#line 212 "icalitip.y" +{ + duration.seconds = atoi(yyvsp[-1].v_string); + ; + break;} +case 30: +#line 217 "icalitip.y" +{ + duration.days = atoi(yyvsp[-1].v_string); + ; + break;} +case 31: +#line 222 "icalitip.y" +{ + ; + break;} +case 32: +#line 225 "icalitip.y" +{ + ; + break;} +case 33: +#line 228 "icalitip.y" +{ + ; + break;} +case 34: +#line 232 "icalitip.y" +{ + icalparser_yy_value = icalvalue_new_duration(duration); + memset(&duration,0, sizeof(duration)); + ; + break;} +case 35: +#line 237 "icalitip.y" +{ + icalparser_yy_value = icalvalue_new_duration(duration); + memset(&duration,0, sizeof(duration)); + ; + break;} +case 36: +#line 242 "icalitip.y" +{ + icalparser_yy_value = icalvalue_new_duration(duration); + memset(&duration,0, sizeof(duration)); + ; + break;} +case 37: +#line 251 "icalitip.y" +{ + struct icalperiodtype p; + + p.start = fill_datetime(yyvsp[-8].v_string,yyvsp[-6].v_string); + p.start.is_utc = utc; + p.start.is_date = 0; + + + p.end = fill_datetime(yyvsp[-3].v_string,yyvsp[-1].v_string); + 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); + ; + break;} +case 38: +#line 272 "icalitip.y" +{ + struct icalperiodtype p; + + p.start = fill_datetime(yyvsp[-5].v_string,yyvsp[-3].v_string); + 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); + + ; + break;} +case 39: +#line 304 "icalitip.y" +{clear_recur();recur.freq = ICAL_SECONDLY_RECURRENCE;; + break;} +case 40: +#line 305 "icalitip.y" +{clear_recur();recur.freq = ICAL_MINUTELY_RECURRENCE;; + break;} +case 41: +#line 306 "icalitip.y" +{clear_recur();recur.freq = ICAL_HOURLY_RECURRENCE;; + break;} +case 42: +#line 307 "icalitip.y" +{clear_recur();recur.freq = ICAL_DAILY_RECURRENCE;; + break;} +case 43: +#line 308 "icalitip.y" +{clear_recur();recur.freq = ICAL_WEEKLY_RECURRENCE;; + break;} +case 44: +#line 309 "icalitip.y" +{clear_recur();recur.freq = ICAL_MONTHLY_RECURRENCE;; + break;} +case 45: +#line 310 "icalitip.y" +{clear_recur();recur.freq = ICAL_YEARLY_RECURRENCE;; + break;} +case 46: +#line 315 "icalitip.y" +{ skiplist[skippos]=ICAL_SUNDAY_WEEKDAY; if( skippos<8) skippos++;; + break;} +case 47: +#line 316 "icalitip.y" +{ skiplist[skippos]=ICAL_MONDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 48: +#line 317 "icalitip.y" +{ skiplist[skippos]=ICAL_TUESDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 49: +#line 318 "icalitip.y" +{ skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 50: +#line 319 "icalitip.y" +{ skiplist[skippos]=ICAL_THURSDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 51: +#line 320 "icalitip.y" +{ skiplist[skippos]=ICAL_FRIDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 52: +#line 321 "icalitip.y" +{ skiplist[skippos]=ICAL_SATURDAY_WEEKDAY;if( skippos<8) skippos++;; + break;} +case 54: +#line 327 "icalitip.y" +{ ; + break;} +case 56: +#line 332 "icalitip.y" +{ skiplist[skippos] = atoi(yyvsp[0].v_string); skippos++;; + break;} +case 57: +#line 333 "icalitip.y" +{ skiplist[skippos] = atoi(yyvsp[0].v_string); if (skippos<367) skippos++;; + break;} +case 58: +#line 337 "icalitip.y" +{recur.interval = atoi(yyvsp[0].v_string);; + break;} +case 59: +#line 338 "icalitip.y" +{recur.week_start = ICAL_SUNDAY_WEEKDAY;; + break;} +case 60: +#line 339 "icalitip.y" +{recur.week_start = ICAL_MONDAY_WEEKDAY;; + break;} +case 61: +#line 340 "icalitip.y" +{recur.week_start = ICAL_TUESDAY_WEEKDAY;; + break;} +case 62: +#line 341 "icalitip.y" +{recur.week_start = ICAL_WEDNESDAY_WEEKDAY;; + break;} +case 63: +#line 342 "icalitip.y" +{recur.week_start = ICAL_THURSDAY_WEEKDAY;; + break;} +case 64: +#line 343 "icalitip.y" +{recur.week_start = ICAL_FRIDAY_WEEKDAY;; + break;} +case 65: +#line 344 "icalitip.y" +{recur.week_start = ICAL_SATURDAY_WEEKDAY;; + break;} +case 66: +#line 345 "icalitip.y" +{copy_list(recur.by_second,60);; + break;} +case 67: +#line 346 "icalitip.y" +{copy_list(recur.by_minute,60);; + break;} +case 68: +#line 347 "icalitip.y" +{copy_list(recur.by_hour,24);; + break;} +case 69: +#line 348 "icalitip.y" +{copy_list(recur.by_day,7);; + break;} +case 70: +#line 349 "icalitip.y" +{copy_list(recur.by_month,12);; + break;} +case 71: +#line 350 "icalitip.y" +{copy_list(recur.by_month_day,31);; + break;} +case 72: +#line 351 "icalitip.y" +{copy_list(recur.by_year_day,366);; + break;} +case 73: +#line 352 "icalitip.y" +{copy_list(recur.by_week_no,53);; + break;} +case 74: +#line 353 "icalitip.y" +{copy_list(recur.by_set_pos,366);; + break;} +case 75: +#line 355 "icalitip.y" +{ recur.until = icalvalue_get_datetime(icalparser_yy_value); + icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; + break;} +case 76: +#line 358 "icalitip.y" +{ recur.until = icalvalue_get_date(icalparser_yy_value); + icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; + break;} +case 77: +#line 361 "icalitip.y" +{ recur.count = atoi(yyvsp[0].v_string); ; + break;} +case 80: +#line 370 "icalitip.y" +{ icalparser_yy_value = icalvalue_new_recur(recur); ; + break;} +case 81: +#line 376 "icalitip.y" +{ utcsign = 1; ; + break;} +case 82: +#line 377 "icalitip.y" +{ utcsign = -1; ; + break;} +case 83: +#line 381 "icalitip.y" +{ + icalparser_yy_value = icalvalue_new_utcoffset( utcsign * (yyvsp[-1].v_int*3600) + (yyvsp[0].v_int*60) ); + ; + break;} +case 84: +#line 386 "icalitip.y" +{ + icalparser_yy_value = icalvalue_new_utcoffset(utcsign * (yyvsp[-2].v_int*3600) + (yyvsp[-1].v_int*60) +(yyvsp[0].v_int)); + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/lib/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 392 "icalitip.y" + + + +void clear_recur() +{ + memset(&skiplist, ICAL_RECURRENCE_ARRAY_MAX_BYTE, sizeof(skiplist)); + skippos = 0; + + icalrecurrencetype_clear(&recur); +} + +void copy_list(short* array, size_t size) +{ + memcpy(array, skiplist, size*sizeof(short)); + memset(&skiplist,ICAL_RECURRENCE_ARRAY_MAX_BYTE, sizeof(skiplist)); + skippos = 0; +} + +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 yyerror(char* s) +{ + /*fprintf(stderr,"Parse error \'%s\'\n", s);*/ +} + diff --git a/libical/src/libical/icalitip.tab.h b/libical/src/libical/icalitip.tab.h new file mode 100644 index 0000000000..3a2b7bee08 --- /dev/null +++ b/libical/src/libical/icalitip.tab.h @@ -0,0 +1,137 @@ +typedef union { + float v_float; + int v_int; + char* v_string; + +} YYSTYPE; +#define DIGITS 257 +#define INTNUMBER 258 +#define FLOATNUMBER 259 +#define STRING 260 +#define EOL 261 +#define EQUALS 262 +#define CHARACTER 263 +#define COLON 264 +#define COMMA 265 +#define SEMICOLON 266 +#define TIMESEPERATOR 267 +#define TRUE 268 +#define FALSE 269 +#define FREQ 270 +#define BYDAY 271 +#define BYHOUR 272 +#define BYMINUTE 273 +#define BYMONTH 274 +#define BYMONTHDAY 275 +#define BYSECOND 276 +#define BYSETPOS 277 +#define BYWEEKNO 278 +#define BYYEARDAY 279 +#define DAILY 280 +#define MINUTELY 281 +#define MONTHLY 282 +#define SECONDLY 283 +#define WEEKLY 284 +#define HOURLY 285 +#define YEARLY 286 +#define INTERVAL 287 +#define COUNT 288 +#define UNTIL 289 +#define WKST 290 +#define MO 291 +#define SA 292 +#define SU 293 +#define TU 294 +#define WE 295 +#define TH 296 +#define FR 297 +#define BIT8 298 +#define ACCEPTED 299 +#define ADD 300 +#define AUDIO 301 +#define BASE64 302 +#define BINARY 303 +#define BOOLEAN 304 +#define BUSY 305 +#define BUSYTENTATIVE 306 +#define BUSYUNAVAILABLE 307 +#define CALADDRESS 308 +#define CANCEL 309 +#define CANCELLED 310 +#define CHAIR 311 +#define CHILD 312 +#define COMPLETED 313 +#define CONFIDENTIAL 314 +#define CONFIRMED 315 +#define COUNTER 316 +#define DATE 317 +#define DATETIME 318 +#define DECLINECOUNTER 319 +#define DECLINED 320 +#define DELEGATED 321 +#define DISPLAY 322 +#define DRAFT 323 +#define DURATION 324 +#define EMAIL 325 +#define END 326 +#define FINAL 327 +#define FLOAT 328 +#define FREE 329 +#define GREGORIAN 330 +#define GROUP 331 +#define INDIVIDUAL 332 +#define INPROCESS 333 +#define INTEGER 334 +#define NEEDSACTION 335 +#define NONPARTICIPANT 336 +#define OPAQUE 337 +#define OPTPARTICIPANT 338 +#define PARENT 339 +#define PERIOD 340 +#define PRIVATE 341 +#define PROCEDURE 342 +#define PUBLIC 343 +#define PUBLISH 344 +#define RECUR 345 +#define REFRESH 346 +#define REPLY 347 +#define REQPARTICIPANT 348 +#define REQUEST 349 +#define RESOURCE 350 +#define ROOM 351 +#define SIBLING 352 +#define START 353 +#define TENTATIVE 354 +#define TEXT 355 +#define THISANDFUTURE 356 +#define THISANDPRIOR 357 +#define TIME 358 +#define TRANSPAENT 359 +#define UNKNOWN 360 +#define UTCOFFSET 361 +#define XNAME 362 +#define ALTREP 363 +#define CN 364 +#define CUTYPE 365 +#define DAYLIGHT 366 +#define DIR 367 +#define ENCODING 368 +#define EVENT 369 +#define FBTYPE 370 +#define FMTTYPE 371 +#define LANGUAGE 372 +#define MEMBER 373 +#define PARTSTAT 374 +#define RANGE 375 +#define RELATED 376 +#define RELTYPE 377 +#define ROLE 378 +#define RSVP 379 +#define SENTBY 380 +#define STANDARD 381 +#define URI 382 +#define TIME_CHAR 383 +#define UTC_CHAR 384 + + +extern YYSTYPE yylval; diff --git a/libical/src/libical/icalitip.y b/libical/src/libical/icalitip.y new file mode 100644 index 0000000000..7415fe2676 --- /dev/null +++ b/libical/src/libical/icalitip.y @@ -0,0 +1,434 @@ +%{ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalitip.y + CREATOR: eric 10 June 1999 + + DESCRIPTION: + + $Id: icalitip.y,v 1.1 2000/02/17 18:02:27 alves 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 + + + + ================================b======================================*/ + +#include <stdlib.h> +#include <string.h> /* for strdup() */ +#include <limits.h> /* for SHRT_MAX*/ +#include "icalparser.h" +#include "ical.h" +#include "pvl.h" + +#define YYERROR_VERBOSE +#define YYDEBUG 1 + +icalvalue *icalparser_yy_value; /* Current Value */ + +/* Globals for UTCOFFSET values */ +int utc; +int utc_b; +int utcsign; + +/* Globals for DURATION values */ +struct icaldurationtype duration; + +/* Globals for RECUR values */ +struct icalrecurrencetype recur; +short skiplist[367]; +short skippos; + +void copy_list(short* array, size_t size); +void clear_recur(); +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 yyerror(char *s); /* Don't know why I need this.... */ +int yylex(void); /* Or this. */ +void set_parser_value_state(); +struct icaltimetype fill_datetime(char* d, char* t); + + + +/* 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; + +} + +%token <v_string> DIGITS +%token <v_int> INTNUMBER +%token <v_float> FLOATNUMBER +%token <v_string> STRING +%token EOL EQUALS CHARACTER COLON COMMA SEMICOLON 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 TIME_CHAR UTC_CHAR + + +%% + +value: + binary_value + | boolean_value + | date_value + | datetime_value + | duration_value + | period_value + | recur_value + | utcoffset_value + | error { + icalparser_yy_value = 0; + icalparser_clear_flex_input(); + yyclearin; + } + +binary_value: "unimplemented2" + +boolean_value: + TRUE + { icalparser_yy_value = icalvalue_new_boolean(1); } + | FALSE + { icalparser_yy_value = icalvalue_new_boolean(0); } + +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_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); + + } + + + +/* Recur */ + +recur_start: + FREQ EQUALS SECONDLY {clear_recur();recur.freq = ICAL_SECONDLY_RECURRENCE;} + | FREQ EQUALS MINUTELY {clear_recur();recur.freq = ICAL_MINUTELY_RECURRENCE;} + | FREQ EQUALS HOURLY {clear_recur();recur.freq = ICAL_HOURLY_RECURRENCE;} + | FREQ EQUALS DAILY {clear_recur();recur.freq = ICAL_DAILY_RECURRENCE;} + | FREQ EQUALS WEEKLY {clear_recur();recur.freq = ICAL_WEEKLY_RECURRENCE;} + | FREQ EQUALS MONTHLY {clear_recur();recur.freq = ICAL_MONTHLY_RECURRENCE;} + | FREQ EQUALS YEARLY {clear_recur();recur.freq = ICAL_YEARLY_RECURRENCE;} + ; + + +weekday: + SU { skiplist[skippos]=ICAL_SUNDAY_WEEKDAY; if( skippos<8) skippos++;} + | MO { skiplist[skippos]=ICAL_MONDAY_WEEKDAY;if( skippos<8) skippos++;} + | TU { skiplist[skippos]=ICAL_TUESDAY_WEEKDAY;if( skippos<8) skippos++;} + | WE { skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY;if( skippos<8) skippos++;} + | TH { skiplist[skippos]=ICAL_THURSDAY_WEEKDAY;if( skippos<8) skippos++;} + | FR { skiplist[skippos]=ICAL_FRIDAY_WEEKDAY;if( skippos<8) skippos++;} + | SA { skiplist[skippos]=ICAL_SATURDAY_WEEKDAY;if( skippos<8) skippos++;} + ; + + +weekday_list: + weekday + | DIGITS weekday { } /* HACK Incorectly handles int in BYDAY */ + | weekday_list COMMA weekday + + +recur_list: + DIGITS { skiplist[skippos] = atoi($1); skippos++;} + | recur_list COMMA DIGITS { skiplist[skippos] = atoi($3); if (skippos<367) skippos++;} + ; + +recur_skip: + INTERVAL EQUALS DIGITS {recur.interval = atoi($3);} + | WKST EQUALS SU {recur.week_start = ICAL_SUNDAY_WEEKDAY;} + | WKST EQUALS MO {recur.week_start = ICAL_MONDAY_WEEKDAY;} + | WKST EQUALS TU {recur.week_start = ICAL_TUESDAY_WEEKDAY;} + | WKST EQUALS WE {recur.week_start = ICAL_WEDNESDAY_WEEKDAY;} + | WKST EQUALS TH {recur.week_start = ICAL_THURSDAY_WEEKDAY;} + | WKST EQUALS FR {recur.week_start = ICAL_FRIDAY_WEEKDAY;} + | WKST EQUALS SA {recur.week_start = ICAL_SATURDAY_WEEKDAY;} + | BYSECOND EQUALS recur_list{copy_list(recur.by_second,60);} + | BYMINUTE EQUALS recur_list{copy_list(recur.by_minute,60);} + | BYHOUR EQUALS recur_list{copy_list(recur.by_hour,24);} + | BYDAY EQUALS weekday_list{copy_list(recur.by_day,7);} + | BYMONTH EQUALS recur_list{copy_list(recur.by_month,12);} + | BYMONTHDAY EQUALS recur_list{copy_list(recur.by_month_day,31);} + | BYYEARDAY EQUALS recur_list{copy_list(recur.by_year_day,366);} + | BYWEEKNO EQUALS recur_list{copy_list(recur.by_week_no,53);} + | BYSETPOS EQUALS recur_list{copy_list(recur.by_set_pos,366);} + | UNTIL EQUALS datetime_value + { recur.until = icalvalue_get_datetime(icalparser_yy_value); + icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;} + | UNTIL EQUALS date_value + { recur.until = icalvalue_get_date(icalparser_yy_value); + icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;} + | COUNT EQUALS DIGITS + { recur.count = atoi($3); } + ; + +recur_skip_list: + /* empty */ + | recur_skip_list SEMICOLON recur_skip + +recur_value: + recur_start recur_skip_list + { icalparser_yy_value = icalvalue_new_recur(recur); } + + + +/* 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)); + } + + + +%% + + +void clear_recur() +{ + memset(&skiplist, ICAL_RECURRENCE_ARRAY_MAX_BYTE, sizeof(skiplist)); + skippos = 0; + + icalrecurrencetype_clear(&recur); +} + +void copy_list(short* array, size_t size) +{ + memcpy(array, skiplist, size*sizeof(short)); + memset(&skiplist,ICAL_RECURRENCE_ARRAY_MAX_BYTE, sizeof(skiplist)); + skippos = 0; +} + +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 yyerror(char* s) +{ + /*fprintf(stderr,"Parse error \'%s\'\n", s);*/ +} + diff --git a/libical/src/libical/icalmemory.c b/libical/src/libical/icalmemory.c new file mode 100644 index 0000000000..7d99eb62b3 --- /dev/null +++ b/libical/src/libical/icalmemory.c @@ -0,0 +1,239 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalmemory.c + CREATOR: eric 30 June 1999 + + $Id$ + $Locker$ + + The contents of this file are subject to the Mozilla Public License + Version 1.0 (the "License"); you may not use this file except in + compliance with the License. You may obtain a copy of the License at + http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS IS" + basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + the License for the specific language governing rights and + limitations under the License. + + The Original Code is icalmemory.h + The Initial Developer of the Original Code is Eric Busboom + + (C) COPYRIGHT 1999 The Software Studio. + http://www.softwarestudio.org + + ======================================================================*/ + +/* 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 + +#include "icalmemory.h" +#include "icalerror.h" + +#include <stdio.h> /* for printf (debugging) */ +#include <stdlib.h> /* for malloc, realloc */ + +#define BUFFER_RING_SIZE 25 +#define MIN_BUFFER_SIZE 200 + +void* buffer_ring[BUFFER_RING_SIZE+1]; +int buffer_pos = 0; +int initialized = 0; + +/* Create a new temporary buffer on the ring. Libical owns these and wil deallocate them. */ +void* +icalmemory_tmp_buffer (size_t size) +{ + void *rtrn; + /* 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; + } + + /* Ideally, this routine would re-use an existing buffer if it is + larger than the requested buffer. Maybe later.... */ + + if (size < MIN_BUFFER_SIZE){ + size = MIN_BUFFER_SIZE; + } + + if ( buffer_ring[buffer_pos] != 0){ + /*sprintf(buffer_ring[buffer_pos], "***DEALLOCATED MEMORY***: %d",buffer_pos);*/ + free( buffer_ring[buffer_pos]); + buffer_ring[buffer_pos] = 0; + } + + + rtrn = buffer_ring[buffer_pos] = (void*)malloc(size); + + memset(rtrn,0,size); + + if(++buffer_pos > BUFFER_RING_SIZE){ + buffer_pos = 0; + } + + return rtrn; +} + +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(char* str) +{ + char* b = icalmemory_tmp_buffer(strlen(str)+1); + + strcpy(b,str); + + return b; +} + + + +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) +{ + /* HACK. need to handle out of memory case */ + void *b = malloc(size); + + memset(b,0,size); + + return b; +} + +void* icalmemory_resize_buffer(void* buf, size_t size) +{ + /* HACK. need to handle out of memory case */ + + return realloc(buf, size); +} + +void icalmemory_free_buffer(void* buf) +{ + free(buf); +} + +void +icalmemory_append_string(char** buf, char** pos, size_t* buf_size, + 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; + +} diff --git a/libical/src/libical/icalmemory.h b/libical/src/libical/icalmemory.h new file mode 100644 index 0000000000..26d22b7316 --- /dev/null +++ b/libical/src/libical/icalmemory.h @@ -0,0 +1,76 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalmemory.h + CREATOR: eric 30 June 1999 + + + $Id$ + $Locker$ + + The contents of this file are subject to the Mozilla Public License + Version 1.0 (the "License"); you may not use this file except in + compliance with the License. You may obtain a copy of the License at + http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS IS" + basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + the License for the specific language governing rights and + limitations under the License. + + The Original Code is icalmemory.h + The Initial Developer of the Original Code is Eric Busboom + + (C) COPYRIGHT 1999 The Software Studio. + 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(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(); + +/* 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, + 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); + +#endif /* !ICALMEMORY_H */ + + + diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c new file mode 100644 index 0000000000..ab984722d5 --- /dev/null +++ b/libical/src/libical/icalparameter.c @@ -0,0 +1,1883 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalderivedparameters.{c,h} + CREATOR: eric 09 May 1999 + + $Id$ + $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 icalderivedparameters.{c,h} + + Contributions from: + Graham Davison (g.m.davison@computer.org) + + ======================================================================*/ + +#include "ical.h" +#include "icalerror.h" +#include <stdlib.h> /* for malloc() */ +#include <errno.h> +#include <string.h> /* for memset() */ +#include "icalmemory.h" + +struct icalparameter_impl +{ + icalparameter_kind kind; + char id[5]; + int size; + char* string; + char* x_name; + icalproperty* parent; + + union data { + int v_int; + int v_rsvp; + icalparameter_cutype v_cutype; + icalparameter_encoding v_encoding; + icalparameter_fbtype v_fbtype; + icalparameter_partstat v_partstat; + icalparameter_range v_range; + icalparameter_related v_related; + icalparameter_reltype v_reltype; + icalparameter_role v_role; + icalparameter_value v_value; + icalparameter_xlicerrortype v_xlicerrortype; + icalparameter_xliccomparetype v_xliccomparetype; + } data; +}; + +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); + errno = ENOMEM; + return 0; + } + + strcpy(v->id,"para"); + + v->kind = kind; + v->size = 0; + v->string = 0; + v->x_name = 0; + v->parent = 0; + memset(&(v->data),0,sizeof(v->data)); + + return v; +} + +icalparameter* +icalparameter_new (icalparameter_kind kind) +{ + struct icalparameter_impl* v = icalparameter_new_impl(kind); + + return (icalparameter*) v; + +} + +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 = strdup(old->string); + if (new->string == 0){ + icalparameter_free(new); + return 0; + } + } + + if (old->x_name != 0){ + new->x_name = strdup(old->x_name); + if (new->x_name == 0){ + icalparameter_free(new); + return 0; + } + } + + return new; +} + + +icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) +{ + + icalparameter* param=0; + + icalerror_check_arg_rz((val!=0),"val"); + + switch (kind) { + case ICAL_ALTREP_PARAMETER: + { + param = icalparameter_new_altrep(val); + + break; + } + case ICAL_CN_PARAMETER: + { + param = icalparameter_new_cn(val); + + break; + } + case ICAL_CUTYPE_PARAMETER: + { + if(strcmp(val,"INDIVIDUAL") == 0){ + param = icalparameter_new_cutype(ICAL_CUTYPE_INDIVIDUAL); + } + else if(strcmp(val,"GROUP") == 0){ + param = icalparameter_new_cutype(ICAL_CUTYPE_GROUP); + } + else if(strcmp(val,"RESOURCE") == 0){ + param = icalparameter_new_cutype(ICAL_CUTYPE_RESOURCE); + } + else if(strcmp(val,"ROOM") == 0){ + param = icalparameter_new_cutype(ICAL_CUTYPE_ROOM); + } + else if(strcmp(val,"UNKNOWN") == 0){ + param = icalparameter_new_cutype(ICAL_CUTYPE_UNKNOWN); + } + else { + param = icalparameter_new_cutype(ICAL_CUTYPE_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + + case ICAL_DELEGATEDFROM_PARAMETER: + { + param = icalparameter_new_delegatedfrom(val); + + break; + } + case ICAL_DELEGATEDTO_PARAMETER: + { + param = icalparameter_new_delegatedto(val); + + break; + } + case ICAL_DIR_PARAMETER: + { + param = icalparameter_new_dir(val); + + break; + } + case ICAL_ENCODING_PARAMETER: + { + if(strcmp(val,"BIT8") == 0){ + param = icalparameter_new_encoding(ICAL_ENCODING_8BIT); + } + else if(strcmp(val,"BASE64") == 0){ + param = icalparameter_new_encoding(ICAL_ENCODING_BASE64); + } + else { + param = icalparameter_new_encoding(ICAL_ENCODING_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + case ICAL_FBTYPE_PARAMETER: + { + if(strcmp(val,"FREE") == 0){ + param = icalparameter_new_fbtype(ICAL_FBTYPE_FREE); + } + else if(strcmp(val,"BUSY") == 0){ + param = icalparameter_new_fbtype(ICAL_FBTYPE_BUSY); + } + else if(strcmp(val,"BUSYUNAVAILABLE") == 0){ + param = icalparameter_new_fbtype(ICAL_FBTYPE_BUSYUNAVAILABLE); + } + else if(strcmp(val,"BUSYTENTATIVE") == 0){ + param = icalparameter_new_fbtype(ICAL_FBTYPE_BUSYTENTATIVE); + } + else { + param = icalparameter_new_fbtype(ICAL_FBTYPE_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + case ICAL_FMTTYPE_PARAMETER: + { + param = icalparameter_new_fmttype(val); + break; + } + case ICAL_LANGUAGE_PARAMETER: + { + param = icalparameter_new_language(val); + + break; + } + case ICAL_MEMBER_PARAMETER: + { + param = icalparameter_new_member(val); + + break; + } + case ICAL_PARTSTAT_PARAMETER: + { + if(strcmp(val,"NEEDSACTION") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_NEEDSACTION); + } + else if(strcmp(val,"ACCEPTED") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_ACCEPTED); + } + else if(strcmp(val,"DECLINED") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_DECLINED); + } + else if(strcmp(val,"TENTATIVE") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE); + } + else if(strcmp(val,"DELEGATED") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED); + } + else if(strcmp(val,"COMPLETED") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_COMPLETED); + } + else if(strcmp(val,"INPROCESS") == 0){ + param = icalparameter_new_partstat(ICAL_PARTSTAT_INPROCESS); + } + else { + param = icalparameter_new_partstat(ICAL_PARTSTAT_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + case ICAL_RANGE_PARAMETER: + { + if(strcmp(val,"THISANDFUTURE") == 0){ + param = icalparameter_new_range(ICAL_RANGE_THISANDFUTURE); + } + else if(strcmp(val,"THISANDPRIOR") == 0){ + param = icalparameter_new_range(ICAL_RANGE_THISANDPRIOR); + } + + break; + } + case ICAL_RELATED_PARAMETER: + { + if(strcmp(val,"START") == 0){ + param = icalparameter_new_related(ICAL_RELATED_START); + } + else if(strcmp(val,"END") == 0){ + param = icalparameter_new_related(ICAL_RELATED_END); + } + + break; + } + case ICAL_RELTYPE_PARAMETER: + { + if(strcmp(val,"PARENT") == 0){ + param = icalparameter_new_reltype(ICAL_RELTYPE_PARENT); + } + else if(strcmp(val,"CHILD") == 0){ + param = icalparameter_new_reltype(ICAL_RELTYPE_CHILD); + } + else if(strcmp(val,"SIBLING") == 0){ + param = icalparameter_new_reltype(ICAL_RELTYPE_SIBLING); + } + else { + param = icalparameter_new_reltype(ICAL_RELTYPE_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + case ICAL_ROLE_PARAMETER: + { + if(strcmp(val,"CHAIR") == 0){ + param = icalparameter_new_role(ICAL_ROLE_CHAIR); + } + else if(strcmp(val,"REQ-PARTICIPANT") == 0){ + param = icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT); + } + else if(strcmp(val,"OPT-PARTICIPANT") == 0){ + param = icalparameter_new_role(ICAL_ROLE_OPTPARTICIPANT); + } + else if(strcmp(val,"NON-PARTICIPANT") == 0){ + param = icalparameter_new_role(ICAL_ROLE_NONPARTICIPANT); + } + else { + param = icalparameter_new_role(ICAL_ROLE_XNAME); + icalparameter_set_xvalue(param,val); + } + break; + } + case ICAL_RSVP_PARAMETER: + { + if(strcmp(val,"TRUE") == 0){ + param = icalparameter_new_rsvp(1); + } + else if(strcmp(val,"FALSE") == 0){ + param = icalparameter_new_rsvp(0); + } + + break; + } + case ICAL_SENTBY_PARAMETER: + { + param = icalparameter_new_sentby(val); + + break; + } + case ICAL_TZID_PARAMETER: + { + param = icalparameter_new_tzid(val); + + break; + } + case ICAL_VALUE_PARAMETER: + { + if(strcmp(val,"BINARY") == 0){ + param = icalparameter_new_value(ICAL_VALUE_BINARY); + } + else if(strcmp(val,"BOOLEAN") == 0){ + param = icalparameter_new_value(ICAL_VALUE_BOOLEAN); + } + else if(strcmp(val,"CAL-ADDRESS") == 0){ + param = icalparameter_new_value(ICAL_VALUE_CALADDRESS); + } + else if(strcmp(val,"DATE") == 0){ + param = icalparameter_new_value(ICAL_VALUE_DATE); + } + else if(strcmp(val,"DATE-TIME") == 0){ + param = icalparameter_new_value(ICAL_VALUE_DATETIME); + } + else if(strcmp(val,"DURATION") == 0){ + param = icalparameter_new_value(ICAL_VALUE_DURATION); + } + else if(strcmp(val,"FLOAT") == 0){ + param = icalparameter_new_value(ICAL_VALUE_FLOAT); + } + else if(strcmp(val,"INTEGER") == 0){ + param = icalparameter_new_value(ICAL_VALUE_INTEGER); + } + else if(strcmp(val,"PERIOD") == 0){ + param = icalparameter_new_value(ICAL_VALUE_PERIOD); + } + else if(strcmp(val,"RECUR") == 0){ + param = icalparameter_new_value(ICAL_VALUE_RECUR); + } + else if(strcmp(val,"TEXT") == 0){ + param = icalparameter_new_value(ICAL_VALUE_TEXT); + } + else if(strcmp(val,"TIME") == 0){ + param = icalparameter_new_value(ICAL_VALUE_TIME); + } + else if(strcmp(val,"URI") == 0){ + param = icalparameter_new_value(ICAL_VALUE_URI); + } + else if(strcmp(val,"UTC-OFFSET") == 0){ + param = icalparameter_new_value(ICAL_VALUE_UTCOFFSET); + } + else { + param = 0; + } + break; + } + case ICAL_XLICERRORTYPE_PARAMETER: + { + + if(strcmp(val,"COMPONENT_PARSE_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_COMPONENTPARSEERROR); + } + else if(strcmp(val,"PROPERTY_PARSE_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_PROPERTYPARSEERROR); + } + else if(strcmp(val,"PARAMETER_PARSE_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_PARAMETERPARSEERROR); + } + else if(strcmp(val,"VALUE_PARSE_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_VALUEPARSEERROR); + } + else if(strcmp(val,"INVALID_ITIP") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP); + } + break; + } + case ICAL_X_PARAMETER: + { + param = icalparameter_new(ICAL_FBTYPE_PARAMETER); + icalparameter_set_xvalue(param,val); + break; + } + + case ICAL_NO_PARAMETER: + default: + { + return 0; + } + + + } + + return param; +} + +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 (impl->string); + } + + if (impl->x_name != 0){ + free (impl->x_name); + } + + memset(impl,0,sizeof(impl)); + + impl->parent = 0; + impl->id[0] = 'X'; + free(impl); +} + + +char no_parameter[]="Error: No Parameter"; +char* +icalparameter_as_ical_string (icalparameter* parameter) +{ + struct icalparameter_impl* impl; + size_t buf_size = 1024; + char* buf; + char* buf_ptr; + char *out_buf; + char *kind_string; + + char tend[1024]; /* HACK . Should be using memory buffer ring */ + + 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; + + kind_string = icalenum_parameter_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, "="); + + switch (impl->kind) { + case ICAL_CUTYPE_PARAMETER: + { + switch (impl->data.v_cutype) { + case ICAL_CUTYPE_INDIVIDUAL: { + strcpy(tend,"INDIVIDUAL");break; + } + case ICAL_CUTYPE_GROUP:{ + strcpy(tend,"GROUP");break; + } + case ICAL_CUTYPE_RESOURCE: { + strcpy(tend,"RESOURCE");break; + } + case ICAL_CUTYPE_ROOM:{ + strcpy(tend,"ROOM");break; + } + case ICAL_CUTYPE_UNKNOWN:{ + strcpy(tend,"UNKNOWN");break; + } + case ICAL_CUTYPE_XNAME:{ + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + + } + case ICAL_ENCODING_PARAMETER: + { + switch (impl->data.v_encoding) { + case ICAL_ENCODING_8BIT: { + strcpy(tend,"8BIT");break; + } + case ICAL_ENCODING_BASE64:{ + strcpy(tend,"BASE64");break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + + case ICAL_FBTYPE_PARAMETER: + { + switch (impl->data.v_fbtype) { + case ICAL_FBTYPE_FREE:{ + strcpy(tend,"FREE");break; + } + case ICAL_FBTYPE_BUSY: { + strcpy(tend,"BUSY");break; + } + case ICAL_FBTYPE_BUSYUNAVAILABLE:{ + strcpy(tend,"BUSYUNAVAILABLE");break; + } + case ICAL_FBTYPE_BUSYTENTATIVE:{ + strcpy(tend,"BUSYTENTATIVE");break; + } + case ICAL_FBTYPE_XNAME:{ + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + + } + case ICAL_PARTSTAT_PARAMETER: + { + switch (impl->data.v_partstat) { + case ICAL_PARTSTAT_NEEDSACTION: { + strcpy(tend,"NEEDSACTION");break; + } + case ICAL_PARTSTAT_ACCEPTED: { + strcpy(tend,"ACCEPTED");break; + } + case ICAL_PARTSTAT_DECLINED:{ + strcpy(tend,"DECLINED");break; + } + case ICAL_PARTSTAT_TENTATIVE:{ + strcpy(tend,"TENTATIVE");break; + } + case ICAL_PARTSTAT_DELEGATED:{ + strcpy(tend,"DELEGATED");break; + } + case ICAL_PARTSTAT_COMPLETED:{ + strcpy(tend,"COMPLETED");break; + } + case ICAL_PARTSTAT_INPROCESS:{ + strcpy(tend,"INPROCESS");break; + } + case ICAL_PARTSTAT_XNAME:{ + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + + } + case ICAL_RANGE_PARAMETER: + { + switch (impl->data.v_range) { + case ICAL_RANGE_THISANDPRIOR: { + strcpy(tend,"THISANDPRIOR");break; + } + case ICAL_RANGE_THISANDFUTURE: { + strcpy(tend,"THISANDFUTURE");break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + case ICAL_RELATED_PARAMETER: + { + switch (impl->data.v_related) { + case ICAL_RELATED_START: { + strcpy(tend,"START");break; + } + case ICAL_RELATED_END: { + strcpy(tend,"END");break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + case ICAL_RELTYPE_PARAMETER: + { + switch (impl->data.v_reltype) { + case ICAL_RELTYPE_PARENT: { + strcpy(tend,"PARENT");break; + } + case ICAL_RELTYPE_CHILD:{ + strcpy(tend,"CHILD");break; + } + case ICAL_RELTYPE_SIBLING:{ + strcpy(tend,"SIBLING");break; + } + case ICAL_RELTYPE_XNAME:{ + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + case ICAL_ROLE_PARAMETER: + { + switch (impl->data.v_role) { + case ICAL_ROLE_CHAIR: { + strcpy(tend,"CHAIR");break; + } + case ICAL_ROLE_REQPARTICIPANT: { + strcpy(tend,"REQ-PARTICIPANT");break; + } + case ICAL_ROLE_OPTPARTICIPANT: { + strcpy(tend,"OPT-PARTICIPANT");break; + } + case ICAL_ROLE_NONPARTICIPANT: { + strcpy(tend,"NON-PARTICIPANT");break; + } + case ICAL_ROLE_XNAME:{ + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + case ICAL_RSVP_PARAMETER: + { + switch (impl->data.v_rsvp) { + case 1: { + strcpy(tend,"TRUE");break; + } + case 0: { + strcpy(tend,"FALSE");break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + case ICAL_VALUE_PARAMETER: + { + switch (impl->data.v_value) { + case ICAL_VALUE_BINARY: { + strcpy(tend,"BINARY");break; + } + case ICAL_VALUE_BOOLEAN: { + strcpy(tend,"BOOLEAN");break; + } + case ICAL_VALUE_CALADDRESS: { + strcpy(tend,"CAL-ADDRESS");break; + } + case ICAL_VALUE_DATE: { + strcpy(tend,"DATE");break; + } + case ICAL_VALUE_DATETIME: { + strcpy(tend,"DATE-TIME");break; + } + case ICAL_VALUE_DURATION: { + strcpy(tend,"DURATION");break; + } + case ICAL_VALUE_FLOAT: { + strcpy(tend,"FLOAT");break; + } + case ICAL_VALUE_INTEGER: { + strcpy(tend,"INTEGER");break; + } + case ICAL_VALUE_PERIOD: { + strcpy(tend,"PERIOD");break; + } + case ICAL_VALUE_RECUR: { + strcpy(tend,"RECUR");break; + } + case ICAL_VALUE_TEXT: { + strcpy(tend,"TEXT");break; + } + case ICAL_VALUE_TIME: { + strcpy(tend,"TIME");break; + } + case ICAL_VALUE_UTCOFFSET: { + strcpy(tend,"UTC-OFFSET");break; + } + case ICAL_VALUE_XNAME: { + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + } + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + } + break; + } + + + case ICAL_XLICERRORTYPE_PARAMETER: + { + switch (impl->data.v_xlicerrortype) { + case ICAL_XLICERRORTYPE_COMPONENTPARSEERROR: + { + strcpy(tend,"COMPONENT_PARSE_ERROR");break; + } + case ICAL_XLICERRORTYPE_PROPERTYPARSEERROR: + { + strcpy(tend,"PROPERTY_PARSE_ERROR");break; + } + case ICAL_XLICERRORTYPE_PARAMETERPARSEERROR: + { + strcpy(tend,"PARAMETER_PARSE_ERROR");break; + } + case ICAL_XLICERRORTYPE_VALUEPARSEERROR: + { + strcpy(tend,"VALUE_PARSE_ERROR");break; + } + case ICAL_XLICERRORTYPE_INVALIDITIP: + { + strcpy(tend,"INVALID_ITIP");break; + } + } + break; + } + + case ICAL_XLICCOMPARETYPE_PARAMETER: + { + switch (impl->data.v_xliccomparetype) { + case ICAL_XLICCOMPARETYPE_EQUAL: + { + strcpy(tend,"EQUAL");break; + } + case ICAL_XLICCOMPARETYPE_NOTEQUAL: + { + strcpy(tend,"NOTEQUAL");break; + } + case ICAL_XLICCOMPARETYPE_LESS: + { + strcpy(tend,"LESS");break; + } + case ICAL_XLICCOMPARETYPE_GREATER: + { + strcpy(tend,"GREATER");break; + } + case ICAL_XLICCOMPARETYPE_LESSEQUAL: + { + strcpy(tend,"LESSEQUAL");break; + } + case ICAL_XLICCOMPARETYPE_GREATEREQUAL: + { + strcpy(tend,"GREATEREQUAL");break; + } + case ICAL_XLICCOMPARETYPE_REGEX: + { + strcpy(tend,"REGEX");break; + } + break; + } + + default:{ + icalerror_set_errno(ICAL_BADARG_ERROR);break; + } + break; + } + + + case ICAL_SENTBY_PARAMETER: + case ICAL_TZID_PARAMETER: + case ICAL_X_PARAMETER: + case ICAL_FMTTYPE_PARAMETER: + case ICAL_LANGUAGE_PARAMETER: + case ICAL_MEMBER_PARAMETER: + case ICAL_DELEGATEDFROM_PARAMETER: + case ICAL_DELEGATEDTO_PARAMETER: + case ICAL_DIR_PARAMETER: + case ICAL_ALTREP_PARAMETER: + case ICAL_CN_PARAMETER: + { + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + break; + } + + case ICAL_NO_PARAMETER: + case ICAL_ANY_PARAMETER: + { + /* These are actually handled before the case/switch + clause */ + } + + } + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, tend); + + /* 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, char* v) +{ + struct icalparameter_impl *impl = (struct icalparameter_impl*)param; + icalerror_check_arg_rv( (param!=0),"param"); + icalerror_check_arg_rv( (v!=0),"v"); + + if (impl->x_name != 0){ + free(impl->x_name); + } + + impl->x_name = strdup(v); + + if (impl->x_name == 0){ + errno = ENOMEM; + } + +} + +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, 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(impl->string); + } + + impl->string = strdup(v); + + if (impl->string == 0){ + errno = ENOMEM; + } + +} + +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_rv( (param!=0),"param"); + + return impl->parent; +} + + +/* Everything below this line is machine generated. Do not edit. */ +/* ALTREP */ +icalparameter* icalparameter_new_altrep(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_ALTREP_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_altrep((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_altrep(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_altrep(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* CN */ +icalparameter* icalparameter_new_cn(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_CN_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_cn((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_cn(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_cn(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* CUTYPE */ +icalparameter* icalparameter_new_cutype(icalparameter_cutype v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_CUTYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_cutype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_cutype icalparameter_get_cutype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_CUTYPE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_cutype; + +} + +void icalparameter_set_cutype(icalparameter* param, icalparameter_cutype v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_cutype = v; +} + +/* DELEGATED-FROM */ +icalparameter* icalparameter_new_delegatedfrom(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_DELEGATEDFROM_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_delegatedfrom((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_delegatedfrom(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_delegatedfrom(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* DELEGATED-TO */ +icalparameter* icalparameter_new_delegatedto(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_DELEGATEDTO_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_delegatedto((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_delegatedto(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_delegatedto(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* DIR */ +icalparameter* icalparameter_new_dir(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_DIR_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_dir((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_dir(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_dir(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* ENCODING */ +icalparameter* icalparameter_new_encoding(icalparameter_encoding v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_ENCODING_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_encoding((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_encoding icalparameter_get_encoding(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_ENCODING_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_encoding; + +} + +void icalparameter_set_encoding(icalparameter* param, icalparameter_encoding v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_encoding = v; +} + +/* FBTYPE */ +icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_FBTYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_fbtype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_fbtype icalparameter_get_fbtype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_FBTYPE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_fbtype; + +} + +void icalparameter_set_fbtype(icalparameter* param, icalparameter_fbtype v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_fbtype = v; +} + +/* FMTTYPE */ +icalparameter* icalparameter_new_fmttype(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_FMTTYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_fmttype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_fmttype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_fmttype(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* LANGUAGE */ +icalparameter* icalparameter_new_language(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_LANGUAGE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_language((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_language(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_language(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* MEMBER */ +icalparameter* icalparameter_new_member(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_MEMBER_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_member((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_member(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_member(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* PARTSTAT */ +icalparameter* icalparameter_new_partstat(icalparameter_partstat v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_PARTSTAT_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_partstat((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_partstat icalparameter_get_partstat(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_PARTSTAT_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_partstat; + +} + +void icalparameter_set_partstat(icalparameter* param, icalparameter_partstat v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_partstat = v; +} + +/* RANGE */ +icalparameter* icalparameter_new_range(icalparameter_range v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_RANGE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_range((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_range icalparameter_get_range(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_PARTSTAT_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_range; + +} + +void icalparameter_set_range(icalparameter* param, icalparameter_range v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_range = v; +} + +/* RELATED */ +icalparameter* icalparameter_new_related(icalparameter_related v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_RELATED_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_related((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_related icalparameter_get_related(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_PARTSTAT_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_related; + +} + +void icalparameter_set_related(icalparameter* param, icalparameter_related v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_related = v; +} + +/* RELTYPE */ +icalparameter* icalparameter_new_reltype(icalparameter_reltype v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_RELTYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_reltype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_reltype icalparameter_get_reltype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_RELTYPE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_reltype; + +} + +void icalparameter_set_reltype(icalparameter* param, icalparameter_reltype v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_reltype = v; +} + +/* ROLE */ +icalparameter* icalparameter_new_role(icalparameter_role v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_ROLE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_role((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_role icalparameter_get_role(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_ROLE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_role; + +} + +void icalparameter_set_role(icalparameter* param, icalparameter_role v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_role = v; +} + +/* RSVP */ +icalparameter* icalparameter_new_rsvp(int v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_RSVP_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_rsvp((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +int icalparameter_get_rsvp(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_ROLE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_rsvp; + +} + +void icalparameter_set_rsvp(icalparameter* param, int v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_rsvp = v; +} + +/* SENT-BY */ +icalparameter* icalparameter_new_sentby(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_SENTBY_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_sentby((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_sentby(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_sentby(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* TZID */ +icalparameter* icalparameter_new_tzid(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_TZID_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_tzid((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_tzid(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_tzid(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* VALUE */ +icalparameter* icalparameter_new_value(icalparameter_value v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_VALUE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_value((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_value icalparameter_get_value(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_VALUE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_value; + +} + +void icalparameter_set_value(icalparameter* param, icalparameter_value v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_value = v; +} + +/* X */ +icalparameter* icalparameter_new_x(char* v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + icalerror_check_arg_rz( (v!=0),"v"); + impl = icalparameter_new_impl(ICAL_X_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_x((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +char* icalparameter_get_x(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg_rz( (param!=0), "param"); + return ((struct icalparameter_impl*)param)->string; +} + +void icalparameter_set_x(icalparameter* param, char* v) +{ + icalerror_check_arg_rz( (v!=0),"v"); + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->string = strdup(v); +} + +/* X-LIC-ERRORTYPE */ +icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_XLICERRORTYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_xlicerrortype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_VALUE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_xlicerrortype; + +} + +void icalparameter_set_xlicerrortype(icalparameter* param, icalparameter_xlicerrortype v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_xlicerrortype = v; +} + +/* X-LIC-COMPARETYPE */ +icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v) +{ + struct icalparameter_impl *impl; + icalerror_clear_errno(); + + impl = icalparameter_new_impl(ICAL_XLICCOMPARETYPE_PARAMETER); + if (impl == 0) { + return 0; + } + + icalparameter_set_xliccomparetype((icalparameter*) impl,v); + if (icalerrno != ICAL_NO_ERROR) { + icalparameter_free((icalparameter*) impl); + return 0; + } + + return (icalparameter*) impl; +} + +icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* param) +{ + icalerror_clear_errno(); + icalerror_check_arg( (param!=0), "param"); + if ( ((struct icalparameter_impl*)param)->string != 0){ + return ICAL_VALUE_XNAME; + } + + return ((struct icalparameter_impl*)param)->data.v_xliccomparetype; + +} + +void icalparameter_set_xliccomparetype(icalparameter* param, icalparameter_xliccomparetype v) +{ + + icalerror_check_arg_rv( (param!=0), "param"); + icalerror_clear_errno(); + + ((struct icalparameter_impl*)param)->data.v_xliccomparetype = v; +} + diff --git a/libical/src/libical/icalparameter.h b/libical/src/libical/icalparameter.h new file mode 100644 index 0000000000..174cae6f3f --- /dev/null +++ b/libical/src/libical/icalparameter.h @@ -0,0 +1,174 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalparam.h + CREATOR: eric 20 March 1999 + + + $Id$ + $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 icalparam.h + + ======================================================================*/ + +#ifndef ICALPARAM_H +#define ICALPARAM_H + +#include "icalenums.h" /* defined icalparameter_kind and other enums */ + +typedef void icalparameter; + +icalparameter* icalparameter_new(icalparameter_kind kind); +icalparameter* icalparameter_new_clone(icalparameter* p); +icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* value); + +void icalparameter_free(icalparameter* parameter); + +char* icalparameter_as_ical_string(icalparameter* parameter); + +int icalparameter_is_valid(icalparameter* parameter); + +icalparameter_kind icalparameter_isa(icalparameter* parameter); + +int icalparameter_isa_parameter(void* param); + +/* Acess the name of an X parameer */ +void icalparameter_set_xname (icalparameter* param, char* v); +char* icalparameter_get_xname(icalparameter* param); +void icalparameter_set_xvalue (icalparameter* param, char* v); +char* icalparameter_get_xvalue(icalparameter* param); + + +/* Everything below this line is machine generated. Do not edit. */ +/* ALTREP */ +icalparameter* icalparameter_new_altrep(char* v); +char* icalparameter_get_altrep(icalparameter* value); +void icalparameter_set_altrep(icalparameter* value, char* v); + +/* CN */ +icalparameter* icalparameter_new_cn(char* v); +char* icalparameter_get_cn(icalparameter* value); +void icalparameter_set_cn(icalparameter* value, char* v); + +/* CUTYPE */ +icalparameter* icalparameter_new_cutype(icalparameter_cutype v); +icalparameter_cutype icalparameter_get_cutype(icalparameter* value); +void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v); + +/* DELEGATED-FROM */ +icalparameter* icalparameter_new_delegatedfrom(char* v); +char* icalparameter_get_delegatedfrom(icalparameter* value); +void icalparameter_set_delegatedfrom(icalparameter* value, char* v); + +/* DELEGATED-TO */ +icalparameter* icalparameter_new_delegatedto(char* v); +char* icalparameter_get_delegatedto(icalparameter* value); +void icalparameter_set_delegatedto(icalparameter* value, char* v); + +/* DIR */ +icalparameter* icalparameter_new_dir(char* v); +char* icalparameter_get_dir(icalparameter* value); +void icalparameter_set_dir(icalparameter* value, char* v); + +/* ENCODING */ +icalparameter* icalparameter_new_encoding(icalparameter_encoding v); +icalparameter_encoding icalparameter_get_encoding(icalparameter* value); +void icalparameter_set_encoding(icalparameter* value, icalparameter_encoding v); + +/* FBTYPE */ +icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v); +icalparameter_fbtype icalparameter_get_fbtype(icalparameter* value); +void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype v); + +/* FMTTYPE */ +icalparameter* icalparameter_new_fmttype(char* v); +char* icalparameter_get_fmttype(icalparameter* value); +void icalparameter_set_fmttype(icalparameter* value, char* v); + +/* LANGUAGE */ +icalparameter* icalparameter_new_language(char* v); +char* icalparameter_get_language(icalparameter* value); +void icalparameter_set_language(icalparameter* value, char* v); + +/* MEMBER */ +icalparameter* icalparameter_new_member(char* v); +char* icalparameter_get_member(icalparameter* value); +void icalparameter_set_member(icalparameter* value, char* v); + +/* PARTSTAT */ +icalparameter* icalparameter_new_partstat(icalparameter_partstat v); +icalparameter_partstat icalparameter_get_partstat(icalparameter* value); +void icalparameter_set_partstat(icalparameter* value, icalparameter_partstat v); + +/* RANGE */ +icalparameter* icalparameter_new_range(icalparameter_range v); +icalparameter_range icalparameter_get_range(icalparameter* value); +void icalparameter_set_range(icalparameter* value, icalparameter_range v); + +/* RELATED */ +icalparameter* icalparameter_new_related(icalparameter_related v); +icalparameter_related icalparameter_get_related(icalparameter* value); +void icalparameter_set_related(icalparameter* value, icalparameter_related v); + +/* RELTYPE */ +icalparameter* icalparameter_new_reltype(icalparameter_reltype v); +icalparameter_reltype icalparameter_get_reltype(icalparameter* value); +void icalparameter_set_reltype(icalparameter* value, icalparameter_reltype v); + +/* ROLE */ +icalparameter* icalparameter_new_role(icalparameter_role v); +icalparameter_role icalparameter_get_role(icalparameter* value); +void icalparameter_set_role(icalparameter* value, icalparameter_role v); + +/* RSVP */ +icalparameter* icalparameter_new_rsvp(int v); +int icalparameter_get_rsvp(icalparameter* value); +void icalparameter_set_rsvp(icalparameter* value, int v); + +/* SENT-BY */ +icalparameter* icalparameter_new_sentby(char* v); +char* icalparameter_get_sentby(icalparameter* value); +void icalparameter_set_sentby(icalparameter* value, char* v); + +/* TZID */ +icalparameter* icalparameter_new_tzid(char* v); +char* icalparameter_get_tzid(icalparameter* value); +void icalparameter_set_tzid(icalparameter* value, char* v); + +/* VALUE */ +icalparameter* icalparameter_new_value(icalparameter_value v); +icalparameter_value icalparameter_get_value(icalparameter* value); +void icalparameter_set_value(icalparameter* value, icalparameter_value v); + +/* X */ +icalparameter* icalparameter_new_x(char* v); +char* icalparameter_get_x(icalparameter* value); +void icalparameter_set_x(icalparameter* value, char* v); + +/* X-LIC-ERRORTYPE */ +icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v); +icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* value); +void icalparameter_set_xlicerrortype(icalparameter* value, icalparameter_xlicerrortype v); + +/* X-LIC-COMPARETYPE */ +icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v); +icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* value); +void icalparameter_set_xliccomparetype(icalparameter* value, icalparameter_xliccomparetype v); + +#endif ICALPARAMETER_H diff --git a/libical/src/libical/icalparser.c b/libical/src/libical/icalparser.c new file mode 100644 index 0000000000..286c2a8c02 --- /dev/null +++ b/libical/src/libical/icalparser.c @@ -0,0 +1,901 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalparser.c + CREATOR: eric 04 August 1999 + + $Id$ + $Locker$ + + The contents of this file are subject to the Mozilla Public License + Version 1.0 (the "License"); you may not use this file except in + 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 Code is eric. The Initial Developer of the Original + Code is + + (C) COPYRIGHT 1999 The Software Studio. + http://www.softwarestudio.org + + ======================================================================*/ +#include "ical.h" +#include "pvl.h" +#include "icalparser.h" +#include "icalmemory.h" +#include <string.h> /* For strncpy */ +#include <stdio.h> /* For FILE and fgets and sprintf */ +#include <stdlib.h> /* for free */ + + +extern icalvalue* icalparser_yy_value; +void set_parser_value_state(icalvalue_kind kind); +int yyparse(void); + +char* icalparser_get_next_char(char c, char *str); +char* icalparser_get_next_parameter(char* line,char** end); +char* icalparser_get_next_value(char* line, char **end, icalvalue_kind kind); +char* icalparser_get_prop_name(char* line, char** end); +char* icalparser_get_param_name(char* line, char **end); + +icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind, char* str, icalproperty **error); + + + +char* icalparser_get_next_char(char c, char *str) +{ + int quote_mode = 0; + char* p; + + + for(p=str; *p!=0; p++){ + + if ( quote_mode == 0 && *p=='"' && *(p-1) != '\\' ){ + quote_mode =1; + continue; + } + + if ( quote_mode == 1 && *p=='"' && *(p-1) != '\\' ){ + quote_mode =0; + continue; + } + + if (quote_mode == 0 && *p== c && *(p-1) != '\\' ){ + return p; + } + + } + + return 0; +} + +/* make a new tmp buffer out of a substring */ +char* make_segment(char* start, char* end) +{ + char *buf; + size_t size = (size_t)end - (size_t)start; + + buf = icalmemory_tmp_buffer(size+1); + + + strncpy(buf,start,size); + *(buf+size) = 0; + + return buf; + +} + +char* input_buffer; +char* input_buffer_p; +#define min(a,b) ((a) < (b) ? (a) : (b)) + +int icalparser_flex_input(char* buf, int max_size) +{ + int n = min(max_size,strlen(input_buffer_p)); + + if (n > 0){ + memcpy(buf, input_buffer_p, n); + input_buffer_p += n; + return n; + } else { + return 0; + } +} + +void icalparser_clear_flex_input() +{ + input_buffer_p = input_buffer+strlen(input_buffer); +} + +/* Cal the flex parser to parse a complex value */ + +icalvalue* icalparser_parse_value(icalvalue_kind kind, + char* str, icalproperty** error) +{ + int r; + input_buffer_p = input_buffer = str; + + set_parser_value_state(kind); + icalparser_yy_value = 0; + + r = yyparse(); + + /* Error. Parse failed */ + if( icalparser_yy_value == 0 || r != 0){ + + if(icalparser_yy_value !=0){ + icalvalue_free(icalparser_yy_value); + icalparser_yy_value = 0; + } + + return 0; + } + + if (error != 0){ + *error = 0; + } + + return icalparser_yy_value; +} + +char* icalparser_get_prop_name(char* line, char** end) +{ + char* p; + char* v; + char *str; + + p = icalparser_get_next_char(';',line); + v = icalparser_get_next_char(':',line); + if (p== 0 && v == 0) { + return 0; + } + + /* There is no ';' or, it is after the ';' that marks the beginning of + the value */ + if (v!=0 && ( p == 0 || p > v)){ + str = make_segment(line,v); + *end = v+1; + } else { + str = make_segment(line,p); + *end = p+1; + } + + return str; +} + +char* icalparser_get_param_name(char* line, char **end) +{ + + char* next; + char *str; + + next = icalparser_get_next_char('=',line); + + if (next == 0) { + return 0; + } + + str = make_segment(line,next); + *end = next+1; + return str; + +} + +char* icalparser_get_next_paramvalue(char* line, char **end) +{ + + char* next; + char *str; + + next = icalparser_get_next_char(',',line); + + if (next == 0){ + next = (char*)(size_t)line+(size_t)strlen(line);\ + } + + if (next == line){ + return 0; + } else { + str = make_segment(line,next); + *end = next+1; + return str; + } + +} + +/* A property may have multiple values, if the values are seperated by + commas in the content line. This routine will look for the next + comma after line and will set the next place to start searching in + end. */ + +char* icalparser_get_next_value(char* line, char **end, icalvalue_kind kind) +{ + + char* next; + char *p; + char *str; + size_t length = strlen(line); + + p = line; + while(1){ + + next = icalparser_get_next_char(',',p); + + /* Unforunately, RFC2445 says that for the RECUR value, COMMA + can both seperate digits in a list, and it can seperate + multiple recurrence specifications. This is not a friendly + part of the spec. This weirdness tries to + distinguish the two uses. it is probably a HACK*/ + + if( kind == ICAL_RECUR_VALUE ) { + if ( next != 0 && + (*end+length) > next+5 && + strncmp(next,"FREQ",4) == 0 + ) { + /* The COMMA was followed by 'FREQ', is it a real seperator*/ + /* Fall through */ + printf("%s\n",next); + } else if (next != 0){ + /* Not real, get the next COMMA */ + p = next+1; + next = 0; + continue; + } + } + + /* If the comma is preceeded by a '\', then it is a literal and + not a value seperator*/ + + if ( (next!=0 && *(next-1) == '\\') || + (next!=0 && *(next-3) == '\\') + ) + /*second clause for '/' is on prev line. HACK may be out of bounds */ + { + p = next+1; + } else { + break; + } + + } + + if (next == 0){ + next = (char*)(size_t)line+length; + *end = next; + } else { + *end = next+1; + } + + if (next == line){ + return 0; + } + + + str = make_segment(line,next); + return str; + +} + +char* icalparser_get_next_parameter(char* line,char** end) +{ + char *next; + char *v; + char *str; + + v = icalparser_get_next_char(':',line); + next = icalparser_get_next_char(';', line); + + /* There is no ';' or, it is after the ':' that marks the beginning of + the value */ + + if (next == 0 || next > v) { + next = icalparser_get_next_char(':', line); + } + + if (next != 0) { + str = make_segment(line,next); + *end = next+1; + return str; + } else { + *end = line; + return 0; + } +} + +/* HACK. This is not threadsafe */ +int buffer_full=0; +size_t tmp_buf_size = 80; +char temp[80]; + + +/* Get a single property line, from the property name through the + final new line, and include any continuation lines */ + +char* icalparser_get_line(char* (*line_gen_func)(char *s, size_t size, void *d), int *lineno) +{ + char *line; + char *line_p; + size_t buf_size = tmp_buf_size; + + + line_p = line = icalmemory_new_buffer(buf_size); + line[0] = '\0'; + + while(1) { + + /* The buffer is not clear, so transfer the data in it to the + output. This may be left over from a previous call */ + if (temp[0] != '\0' ) { + if (temp[tmp_buf_size-1] == 0){ + buffer_full = 1; + } else { + buffer_full = 0; + } + icalmemory_append_string(&line,&line_p,&buf_size,temp); + temp[0] = '\0' ; + } + + temp[tmp_buf_size-1] = 1; /* Mark end of buffer */ + + if ((*line_gen_func)(temp,tmp_buf_size,0)==0){/* Get more data */ + if (temp[0] == '\0'){ + if(line[0] != '\0'){ + break; + } else { + free(line); + return 0; + } + } + } + + if ( line_p > line+1 && *(line_p-1) == '\n' && temp[0] == ' ') { + + /* If the output line ends in a '\n' and the temp buffer + begins with a ' ', then the buffer holds a continuation + line, so keep reading. */ + + /* back up the pointer to erase the continuation characters */ + line_p--; + + /* shift the temp buffer down to eliminate the leading space*/ + memmove(&(temp[0]),&(temp[1]),tmp_buf_size); + temp[tmp_buf_size-1] = temp[tmp_buf_size-2]; + + } else if ( buffer_full == 1 ) { + + /* The buffer was filled on the last read, so read again */ + + } else { + + /* Looks like the end of this content line, so break */ + break; + } + + + } + + /* Erase the final newline */ + if ( line_p > line+1 && *(line_p-1) == '\n') { + + *(line_p-1) = '\0'; + } else { + *(line_p) = '\0'; + } + + return line; + +} + +#if 0 +char* icalparser_old_get_line(char* (*line_gen_func)(char *s, size_t size, void *d), int *lineno) +{ + char *line, *output_line; + char *line_p; + char last_line = 0; + size_t buf_size = tmp_buf_size; + int break_flag = 0; + + line_p = line = icalmemory_new_buffer(buf_size); + + /* If the hold buffer is empty, read a line. Otherwise, use the data that + is still in 'temp'*/ + if (hold == 1){ + /* Do nothing */ + } else { + temp[tmp_buf_size-1] = 1; /* Mark end of buffer */ + (*line_gen_func)(temp,tmp_buf_size,0); + } + + /* Append the hold buffer or new line into the output */ + icalmemory_append_string(&line,&line_p,&buf_size,temp); + + if ( temp[tmp_buf_size-1] == 0 ) { /* Check if mark was overwritten */ + buffer_full = 1; + } else { + buffer_full = 0; + } + + /* Try to suck up any continuation lines */ + while(last_line == 0){ + + temp[tmp_buf_size-1] = 1; /* Mark end of buffer */ + if ((*line_gen_func)(temp,tmp_buf_size,0) == 0){ + /* No more lines -- we are finished */ + if (hold == 1) { + hold = 0; + break_flag = 1; + } else { + icalmemory_free_buffer(line); + return 0; + } + } else { + if ( temp[tmp_buf_size-1] == 0 ) { + buffer_full = 1; + } else { + buffer_full = 0; + } + } + + /* keep track of line numbers */ + if (lineno != 0){ + (*lineno)++; + } + + + /* Determine wether to copy the line to the output, or + save it in the hold buffer */ + + if ( line_p > line+1 && *(line_p-1) == '\n' && temp[0] == ' ') { + + /* If the last line ( in the 'line' string ) ends in a '\n' + and the current line begins with a ' ', then the current line + is a continuation line, so append it. */ + + /* back up the pointer to erase the continuation characters */ + line_p--; + icalmemory_append_string(&line,&line_p,&buf_size,&(temp[1])); + + hold = 0; + buffer_full= 0; + + } else if (buffer_full == 1) { + + /* The last line that was read filled up the read + buffer. Append it and read again */ + + icalmemory_append_string(&line,&line_p,&buf_size,temp); + + hold = 0; + + } else if (break_flag != 1 ){ + /* Nope -- the line was not a continuation line. + Save the line for the next call */ + + hold =1; + break; + } else { + break; + } + } + + /* Erase the final newline */ + if ( line_p > line+1 && *(line_p-1) == '\n') { + + *(line_p-1) = '\0'; + } + + output_line = icalmemory_tmp_copy(line); + icalmemory_free_buffer(line); + + return output_line; +} +#endif + +void insert_error(icalcomponent* comp, char* text, + char* message, icalparameter_xlicerrortype type) +{ + char temp[1024]; + + if (strlen(text) > 256) { + sprintf(temp,"%s: \'%256s...\'",message,text); + } else { + sprintf(temp,"%s: \'%s\'",message,text); + } + + icalcomponent_add_property + (comp, + icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype(type), + 0)); +} + +icalcomponent* icalparser_parse(char* (*line_gen_func)(char *s, size_t size, void* d)) +{ + + char *line = 0; + char *p; + char *str; + char *end; + int lineno = 0; + + int vcount = 0; + + icalcomponent *root_component = 0; + icalcomponent *tail = 0; + icalproperty *prop; + icalvalue *value; + + icalvalue_kind value_kind; + + pvl_list components = pvl_newlist(); + + do { + + value_kind = ICAL_NO_VALUE; + + /* Get a single property line, from a property name through a + newline */ + if (line!=0){ + free(line); + } + + line = icalparser_get_line(line_gen_func,&lineno); + + if (line == 0){ + continue; + } + + end = 0; + + str = icalparser_get_prop_name(line, &end); + + if (str == 0){ + tail = pvl_data(pvl_tail(components)); + + if (tail){ + insert_error(tail,line, + "Got a data line, but could not find a property name or component begin tag", + ICAL_XLICERRORTYPE_COMPONENTPARSEERROR); + } + tail = 0; + continue; + } + +/********************************************************************** + * Handle begin and end of components + **********************************************************************/ + + + /* If the property name is BEGIN or END, we are actually + starting or ending a new component */ + + if(strcmp(str,"BEGIN") == 0){ + icalcomponent *c; ; + + str = icalparser_get_next_value(end,&end, value_kind); + + c = icalcomponent_new_from_string(str); + + if (c == 0){ + c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT); + insert_error(c,str,"Parse error in component name", + ICAL_XLICERRORTYPE_COMPONENTPARSEERROR); + } + + pvl_push(components,c); + + continue; + } else if (strcmp(str,"END") == 0 ) { + + str = icalparser_get_next_value(end,&end, value_kind); + + root_component = pvl_pop(components); + + tail = pvl_data(pvl_tail(components)); + + if(tail != 0){ + icalcomponent_add_component(tail,root_component); + } + + tail = 0; + continue; + } + + + /* There is no point in continuing if we have not seen a + component yet */ + + if(pvl_data(pvl_tail(components)) == 0){ + continue; + } + + +/********************************************************************** + * Handle property names + **********************************************************************/ + /* At this point, the property name really is a property name, + (Not a component name) so make a new property and add it to + the component */ + + prop = icalproperty_new_from_string(str); + + if (prop != 0){ + tail = pvl_data(pvl_tail(components)); + + icalcomponent_add_property(tail, prop); + + /* Set the value kind for the default for this type of + property. This may be re-set by a VALUE parameter */ + value_kind = + icalenum_property_kind_to_value_kind( + icalproperty_isa(prop)); + } else { + icalcomponent* tail = pvl_data(pvl_tail(components)); + + insert_error(tail,str,"Parse error in property name", + ICAL_XLICERRORTYPE_PROPERTYPARSEERROR); + + tail = 0; + continue; + } + +/********************************************************************** + * Handle parameter values + **********************************************************************/ + + /* Now, add any parameters to the last property */ + + p = 0; + while(1) { + + if (*(end-1) == ':'){ + /* if the last seperator was a ":" and the value is a + URL, icalparser_get_next_parameter will find the + ':' in the URL, so better break now. */ + break; + } + + str = icalparser_get_next_parameter(end,&end); + + if (str != 0){ + char* name; + char* pvalue; + icalparameter *param = 0; + icalparameter_kind kind; + + tail = pvl_data(pvl_tail(components)); + + name = icalparser_get_param_name(str,&pvalue); + + if (name == 0){ + insert_error(tail, str, "Can't parse parameter name", + ICAL_XLICERRORTYPE_PARAMETERPARSEERROR); + tail = 0; + break; + } + + kind = icalenum_string_to_parameter_kind(name); + if (kind != ICAL_NO_PARAMETER){ + param = icalparameter_new_from_string(kind,pvalue); + } else { + + /* Error. Failed to parse the parameter*/ + insert_error(tail, str, "Can't parse parameter name", + ICAL_XLICERRORTYPE_PARAMETERPARSEERROR); + tail = 0; + continue; + } + + if (param == 0){ + insert_error(tail,str,"Can't parse parameter value", + ICAL_XLICERRORTYPE_PARAMETERPARSEERROR); + + tail = 0; + continue; + } + + /* If it is a VALUE parameter, set the kind of value*/ + if (icalparameter_isa(param)==ICAL_VALUE_PARAMETER){ + + value_kind = (icalvalue_kind) + icalparameter_get_value(param); + + if (value_kind == ICAL_NO_VALUE){ + + /* Ooops, could not parse the value of the + parameter ( it was not one of the defined + values ), so reset the value_kind */ + + icalcomponent* tail + = pvl_data(pvl_tail(components)); + + insert_error( + tail, str, + "Got a VALUE parameter with an unknown type", + ICAL_XLICERRORTYPE_PARAMETERPARSEERROR); + icalparameter_free(param); + + value_kind = + icalenum_property_kind_to_value_kind( + icalproperty_isa(prop)); + + icalparameter_free(param); + tail = 0; + continue; + } + } + + /* Everything is OK, so add the parameter */ + icalproperty_add_parameter(prop,param); + tail = 0; + + } else { + /* If we did not get a param string, go on to looking + for a value */ + break; + } + } + +/********************************************************************** + * Handle values + **********************************************************************/ + + /* Look for values. If there are ',' characters in the values, + then there are multiple values, so clone the current + parameter and add one part of the value to each clone */ + + vcount=0; + while(1) { + str = icalparser_get_next_value(end,&end, value_kind); + + if (str != 0){ + + if (vcount > 0){ + /* Actually, only clone after the second value */ + icalproperty* clone = icalproperty_new_clone(prop); + tail = pvl_data(pvl_tail(components)); + + icalcomponent_add_property(tail, clone); + prop = clone; + tail = 0; + } + + value = icalvalue_new_from_string(value_kind, str); + + /* Don't add properties without value */ + if (value == 0){ + char temp[1024]; + + icalproperty_kind prop_kind = icalproperty_isa(prop); + tail = pvl_data(pvl_tail(components)); + + sprintf(temp,"Can't parse as %s value in %s property. Removing entire property", + icalenum_value_kind_to_string(value_kind), + icalenum_property_kind_to_string(prop_kind)); + + insert_error(tail, str, temp, + ICAL_XLICERRORTYPE_VALUEPARSEERROR); + + /* Remove the troublesome property */ + icalcomponent_remove_property(tail,prop); + icalproperty_free(prop); + prop = 0; + tail = 0; + break; + + } else { + vcount++; + icalproperty_set_value(prop, value); + } + + + } else { + + break; + } + } + + } while( !feof(stdin) && line !=0 ); + + + if (pvl_data(pvl_tail(components)) == 0){ + /* A nice, clean exit */ + pvl_free(components); + free(line); + return root_component; + } + + /* Clear off any component that may be left in the list */ + /* This will happen if some components did not have an "END" tag*/ + + while((tail=pvl_data(pvl_tail(components))) != 0){ + + insert_error(tail," ", + "Missing END tag for this component. Closing component at end of input.", + ICAL_XLICERRORTYPE_COMPONENTPARSEERROR); + + + root_component = pvl_pop(components); + tail=pvl_data(pvl_tail(components)); + + if(tail != 0){ + icalcomponent_add_component(tail,root_component); + } + } + + free(line); + return root_component; +} + +char* string_line_generator_pos=0; +char* string_line_generator_str; +char* string_line_generator(char *out, size_t buf_size, void *d) +{ + char *n; + + if(string_line_generator_pos==0){ + string_line_generator_pos=string_line_generator_str; + } + + /* If the pointer is at the end of the string, we are done */ + if (*string_line_generator_pos ==0){ + return 0; + } + + n = strchr(string_line_generator_pos,'\n'); + + /* If no newline, take the rest of the string, and leave the + pointer at the \0 */ + + if (n == 0) { + n = string_line_generator_pos + strlen(string_line_generator_pos); + } else { + n++; + } + + strncpy(out,string_line_generator_pos,(n-string_line_generator_pos)); + + *(out+(n-string_line_generator_pos)) = '\0'; + + string_line_generator_pos = n; + + return out; + +} + +void _test_string_line_generator(char* str) +{ + char *line; + int lineno=0; + string_line_generator_str = str; + string_line_generator_pos = 0; + + while((line = icalparser_get_line(string_line_generator,&lineno))){ + printf("#%d: %s\n",lineno,line); + } + + + string_line_generator_pos = 0; + string_line_generator_str = 0; +} + + + +icalcomponent* icalparser_parse_string(char* str) +{ + + icalcomponent *c; + + string_line_generator_str = str; + string_line_generator_pos = 0; + c = icalparser_parse(string_line_generator); + string_line_generator_pos = 0; + string_line_generator_str = 0; + + return c; + +} diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h new file mode 100644 index 0000000000..9e47e38bfb --- /dev/null +++ b/libical/src/libical/icalparser.h @@ -0,0 +1,79 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalparser.h + CREATOR: eric 20 April 1999 + + $Id$ + + + (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 icalparser.h + +======================================================================*/ + + +#ifndef ICALPARSER_H +#define ICALPARSER_H + +#include "ical.h" +#include <stdio.h> /* For FILE* */ + +/*********************************************************************** + * 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(char* (*line_gen_func)()); + +/* Parse directly from a string */ +icalcomponent* icalparser_parse_string(char* str); + +/* icalparser_flex_input is the routine that is called from the macro + YYINPUT in the flex lexer. */ +int icalparser_flex_input(char* buf, int max_size); +void icalparser_clear_flex_input(); + +/*********************************************************************** + * Line-oriented parsing. + * + * Create a new parser via icalparse_new_parser, then add ines one at + * a time with icalparse_add_line(). After adding the last line, call + * icalparse_close() to return the parsed component. + ***********************************************************************/ + +/* These are not implemented yet */ +typedef void* icalparser; +icalparser icalparse_new_parser(); +void icalparse_add_line(icalparser* parser ); +icalcomponent* icalparse_close(icalparser* parser); + +/*********************************************************************** + * Parser support functions + ***********************************************************************/ + +/* Use the flex/bison parser to turn a string into a value type */ +icalvalue* icalparser_parse_value(icalvalue_kind kind, char* str, icalcomponent** errors); + +char* icalparser_get_line(char* (*line_gen_func)(char *s, size_t size, void *d), int *lineno); + + + +/* a line_gen_function that returns lines from a string */ + + +#endif /* !ICALPARSE_H */ diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c new file mode 100644 index 0000000000..7eb7c81111 --- /dev/null +++ b/libical/src/libical/icalproperty.c @@ -0,0 +1,3083 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalproperty.c + CREATOR: eric 28 April 1999 + + $Id$ + + + (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 icalproperty.c + +======================================================================*/ + +#include <string.h> /* For strdup, rindex */ +#include <assert.h> +#include <stdlib.h> +#include <errno.h> +#include <stdio.h> /* for printf */ +#include <stdarg.h> /* for va_list, va_start, etc. */ + +#include "ical.h" +#include "pvl.h" +#include "icalenums.h" +#include "icalerror.h" +#include "icalmemory.h" + +/* 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 *impl,va_list args) +{ + + void* vp; + + 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 { + abort(); + } + + } + + +} + +struct icalproperty_impl* +icalproperty_new_impl (icalproperty_kind kind) +{ + struct icalproperty_impl* prop; + + if ( ( prop = (struct icalproperty_impl*) + malloc(sizeof(struct icalproperty_impl))) == 0) { + errno = ENOMEM; + 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) +{ + icalproperty *prop = (icalproperty*)icalproperty_new_impl(kind); + + return prop; +} + + +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 = 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; + +} + +/* This one works a little differently from the other *_from_string + routines; the string input is the name of the property, not the + data associated with the property, as it is in + icalvalue_from_string. All of the parsing associated with + properties is driven by routines in icalparse.c */ + +icalproperty* icalproperty_new_from_string(char* str) +{ + icalproperty_kind kind; + + icalerror_check_arg_rz( (str!=0),"str"); + + kind = icalenum_string_to_property_kind(str); + + if (kind == ICAL_NO_PROPERTY){ + + if( str[0] == 'X' && str[1] == '-'){ + icalproperty *p = icalproperty_new(ICAL_X_PROPERTY); + icalproperty_set_x_name(p,str); + return p; + } else { + icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); + return 0; + } + + } else { + return icalproperty_new(kind); + } +} + +void +icalproperty_free (icalproperty* prop) +{ + struct icalproperty_impl *p; + + icalparameter* param; + + icalerror_check_arg_re((prop!=0),"prop",ICAL_BADARG_ERROR); + + 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 */ + + 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; + + 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 = icalenum_property_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, "\n"); + + /* 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); + + if (kind_string == 0 ) { + char temp[1024]; + sprintf(temp, "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, "\n"); + + } + + /* Append value */ + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :"); + + value = icalproperty_get_value(prop); + + if (value != 0){ + icalmemory_append_string(&buf, &buf_ptr, &buf_size, + icalvalue_as_ical_string(icalproperty_get_value(prop))); + } else { + icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value"); + + } + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + /* 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_remove_parameter (icalproperty* prop, icalparameter_kind kind) +{ + icalerror_check_arg_rv((prop!=0),"prop"); + + assert(0); /* This routine is not implemented */ +} + + +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; + } + + return (icalparameter*) pvl_data(p->parameter_iterator); +} + + +icalparameter* +icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + icalerror_check_arg_rz( (prop!=0),"prop"); + + if (p->parameter_iterator == 0 ) { + return 0; + } + + p->parameter_iterator = pvl_next(p->parameter_iterator); + + if (p->parameter_iterator == 0 ) { + return 0; + } + + return (icalparameter*) pvl_data(p->parameter_iterator); +} + +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); +} + + +icalvalue* +icalproperty_get_value (icalproperty* prop) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rz( (prop!=0),"prop"); + + return p->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 = strdup(name); + + if(impl->x_name == 0){ + icalerror_set_errno(ICAL_ALLOCATION_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; +} + + +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_rv( (property!=0),"property"); + + return impl->parent; +} + + +/* Everything below this line is machine generated. Do not edit. */ + +/* METHOD */ + +icalproperty* icalproperty_new_method(icalproperty_method v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY); + + + icalproperty_set_method((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_method(icalproperty_method v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY); + + + icalproperty_set_method((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_method(icalproperty* prop, icalproperty_method v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_method(v); + + icalproperty_set_value(prop,value); + +} + +icalproperty_method icalproperty_get_method(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_method(value); +} + +/* LAST-MODIFIED */ + +icalproperty* icalproperty_new_lastmodified(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY); + + + icalproperty_set_lastmodified((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY); + + + icalproperty_set_lastmodified((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* UID */ + +icalproperty* icalproperty_new_uid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_uid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_uid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_uid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_uid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_uid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* PRODID */ + +icalproperty* icalproperty_new_prodid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_prodid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_prodid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_prodid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_prodid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_prodid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* STATUS */ + +icalproperty* icalproperty_new_status(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_status((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_status(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_status((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_status(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_status(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DESCRIPTION */ + +icalproperty* icalproperty_new_description(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_description((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_description(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_description((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_description(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_description(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DURATION */ + +icalproperty* icalproperty_new_duration(struct icaldurationtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY); + + + icalproperty_set_duration((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY); + + + icalproperty_set_duration((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_duration(v); + + icalproperty_set_value(prop,value); + +} + +struct icaldurationtype icalproperty_get_duration(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_duration(value); +} + +/* CATEGORIES */ + +icalproperty* icalproperty_new_categories(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_categories((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_categories(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_categories((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_categories(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_categories(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* VERSION */ + +icalproperty* icalproperty_new_version(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_version((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_version(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_version((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_version(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_version(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZOFFSETFROM */ + +icalproperty* icalproperty_new_tzoffsetfrom(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY); + + + icalproperty_set_tzoffsetfrom((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY); + + + icalproperty_set_tzoffsetfrom((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_utcoffset(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_tzoffsetfrom(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_utcoffset(value); +} + +/* RRULE */ + +icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY); + + + icalproperty_set_rrule((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY); + + + icalproperty_set_rrule((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_recur(v); + + icalproperty_set_value(prop,value); + +} + +struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_recur(value); +} + +/* ATTENDEE */ + +icalproperty* icalproperty_new_attendee(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_attendee((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_attendee(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_attendee((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_attendee(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_caladdress(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_attendee(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_caladdress(value); +} + +/* CONTACT */ + +icalproperty* icalproperty_new_contact(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_contact((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_contact(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_contact((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_contact(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_contact(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RELATED-TO */ + +icalproperty* icalproperty_new_relatedto(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_relatedto((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_relatedto(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_relatedto((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_relatedto(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_relatedto(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* ORGANIZER */ + +icalproperty* icalproperty_new_organizer(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_organizer((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_organizer(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_organizer((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_organizer(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_caladdress(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_organizer(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_caladdress(value); +} + +/* COMMENT */ + +icalproperty* icalproperty_new_comment(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_comment((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_comment(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_comment((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_comment(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_comment(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TRIGGER */ + +icalproperty* icalproperty_new_trigger(union icaltriggertype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY); + + + icalproperty_set_trigger((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY); + + + icalproperty_set_trigger((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_trigger(v); + + icalproperty_set_value(prop,value); + +} + +union icaltriggertype icalproperty_get_trigger(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_trigger(value); +} + +/* X-LIC-ERROR */ + +icalproperty* icalproperty_new_xlicerror(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicerror(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicerror(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicerror(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* CLASS */ + +icalproperty* icalproperty_new_class(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_class((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_class(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_class((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_class(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_class(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZOFFSETTO */ + +icalproperty* icalproperty_new_tzoffsetto(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY); + + + icalproperty_set_tzoffsetto((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzoffsetto(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY); + + + icalproperty_set_tzoffsetto((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzoffsetto(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_utcoffset(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_tzoffsetto(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_utcoffset(value); +} + +/* TRANSP */ + +icalproperty* icalproperty_new_transp(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_transp((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_transp(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_transp((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_transp(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_transp(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* SEQUENCE */ + +icalproperty* icalproperty_new_sequence(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY); + + + icalproperty_set_sequence((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_sequence(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY); + + + icalproperty_set_sequence((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_sequence(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_sequence(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* LOCATION */ + +icalproperty* icalproperty_new_location(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_location((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_location(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_location((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_location(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_location(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* REQUEST-STATUS */ + +icalproperty* icalproperty_new_requeststatus(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_requeststatus((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_requeststatus(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_requeststatus((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_requeststatus(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_requeststatus(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* EXDATE */ + +icalproperty* icalproperty_new_exdate(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY); + + + icalproperty_set_exdate((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY); + + + icalproperty_set_exdate((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_exdate(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* TZID */ + +icalproperty* icalproperty_new_tzid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RESOURCES */ + +icalproperty* icalproperty_new_resources(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_resources((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_resources(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_resources((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_resources(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_resources(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZURL */ + +icalproperty* icalproperty_new_tzurl(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzurl((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzurl(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzurl((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzurl(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_uri(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzurl(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_uri(value); +} + +/* REPEAT */ + +icalproperty* icalproperty_new_repeat(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY); + + + icalproperty_set_repeat((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_repeat(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY); + + + icalproperty_set_repeat((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_repeat(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_repeat(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* PRIORITY */ + +icalproperty* icalproperty_new_priority(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY); + + + icalproperty_set_priority((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_priority(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY); + + + icalproperty_set_priority((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_priority(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_priority(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* FREEBUSY */ + +icalproperty* icalproperty_new_freebusy(struct icalperiodtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY); + + + icalproperty_set_freebusy((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY); + + + icalproperty_set_freebusy((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_period(v); + + icalproperty_set_value(prop,value); + +} + +struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_period(value); +} + +/* DTSTART */ + +icalproperty* icalproperty_new_dtstart(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY); + + + icalproperty_set_dtstart((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY); + + + icalproperty_set_dtstart((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtstart(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* RECURRENCE-ID */ + +icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY); + + + icalproperty_set_recurrenceid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY); + + + icalproperty_set_recurrenceid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* SUMMARY */ + +icalproperty* icalproperty_new_summary(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_summary((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_summary(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_summary((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_summary(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_summary(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DTEND */ + +icalproperty* icalproperty_new_dtend(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY); + + + icalproperty_set_dtend((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY); + + + icalproperty_set_dtend((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtend(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* TZNAME */ + +icalproperty* icalproperty_new_tzname(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzname((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzname(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzname((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzname(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzname(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RDATE */ + +icalproperty* icalproperty_new_rdate(struct icalperiodtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY); + + + icalproperty_set_rdate((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_rdate(struct icalperiodtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY); + + + icalproperty_set_rdate((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimeperiod(v); + + icalproperty_set_value(prop,value); + +} + +struct icalperiodtype icalproperty_get_rdate(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimeperiod(value); +} + +/* URL */ + +icalproperty* icalproperty_new_url(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_url((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_url(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_url((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_url(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_uri(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_url(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_uri(value); +} + +/* ATTACH */ + +icalproperty* icalproperty_new_attach(struct icalattachtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + + + icalproperty_set_attach((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + + + icalproperty_set_attach((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_attach(v); + + icalproperty_set_value(prop,value); + +} + +struct icalattachtype icalproperty_get_attach(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_attach(value); +} + +/* X-LIC-CLUSTERCOUNT */ + +icalproperty* icalproperty_new_xlicclustercount(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + + + icalproperty_set_xlicclustercount((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicclustercount(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + + + icalproperty_set_xlicclustercount((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicclustercount(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_xlicclustercount(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* EXRULE */ + +icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY); + + + icalproperty_set_exrule((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY); + + + icalproperty_set_exrule((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_recur(v); + + icalproperty_set_value(prop,value); + +} + +struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_recur(value); +} + +/* QUERY */ + +icalproperty* icalproperty_new_query(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_query((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_query(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_query((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_query(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_query(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_query(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_query(value); +} + +/* PERCENT-COMPLETE */ + +icalproperty* icalproperty_new_percentcomplete(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY); + + + icalproperty_set_percentcomplete((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_percentcomplete(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY); + + + icalproperty_set_percentcomplete((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_percentcomplete(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_percentcomplete(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* CALSCALE */ + +icalproperty* icalproperty_new_calscale(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_calscale((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_calscale(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_calscale((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_calscale(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_calscale(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* CREATED */ + +icalproperty* icalproperty_new_created(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY); + + + icalproperty_set_created((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY); + + + icalproperty_set_created((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_created(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_created(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* GEO */ + +icalproperty* icalproperty_new_geo(struct icalgeotype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY); + + + icalproperty_set_geo((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY); + + + icalproperty_set_geo((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_geo(v); + + icalproperty_set_value(prop,value); + +} + +struct icalgeotype icalproperty_get_geo(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_geo(value); +} + +/* COMPLETED */ + +icalproperty* icalproperty_new_completed(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY); + + + icalproperty_set_completed((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY); + + + icalproperty_set_completed((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_completed(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* DTSTAMP */ + +icalproperty* icalproperty_new_dtstamp(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY); + + + icalproperty_set_dtstamp((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY); + + + icalproperty_set_dtstamp((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* DUE */ + +icalproperty* icalproperty_new_due(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY); + + + icalproperty_set_due((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY); + + + icalproperty_set_due((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_due(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_due(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* ACTION */ + +icalproperty* icalproperty_new_action(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_action((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_action(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_action((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_action(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_action(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} diff --git a/libical/src/libical/icalproperty.h b/libical/src/libical/icalproperty.h new file mode 100644 index 0000000000..2cd28fe179 --- /dev/null +++ b/libical/src/libical/icalproperty.h @@ -0,0 +1,368 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalderivedproperties.{c,h} + CREATOR: eric 09 May 1999 + + $Id$ + + (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. + + + ======================================================================*/ + + +#ifndef ICALPROPERTY_H +#define ICALPROPERTY_H + +#include <time.h> + +typedef void icalproperty; + +icalproperty* icalproperty_new(icalproperty_kind kind); + +icalproperty* icalproperty_new_clone(icalproperty * prop); + +icalproperty* icalproperty_new_from_string(char* str); + +char* icalproperty_as_ical_string(icalproperty* prop); + +void icalproperty_free(icalproperty* prop); + +icalproperty_kind icalproperty_isa(icalproperty* property); +int icalproperty_isa_property(void* property); + +void icalproperty_add_parameter(icalproperty* prop,icalparameter* parameter); + +void icalproperty_remove_parameter(icalproperty* prop, + icalparameter_kind kind); + +int icalproperty_count_parameters(icalproperty* prop); + +/* Iterate through the parameters */ +icalparameter* icalproperty_get_first_parameter(icalproperty* prop, + icalparameter_kind kind); +icalparameter* icalproperty_get_next_parameter(icalproperty* prop, + icalparameter_kind kind); +/* Access the value of the property */ +void icalproperty_set_value(icalproperty* prop, icalvalue* value); +icalvalue* icalproperty_get_value(icalproperty* prop); + +/* Deal with X properties */ + +void icalproperty_set_x_name(icalproperty* prop, char* name); +char* icalproperty_get_x_name(icalproperty* prop); + + +/* Everything below this line is machine generated. Do not edit. */ + +/* METHOD */ +icalproperty* icalproperty_new_method(icalproperty_method v); +icalproperty* icalproperty_vanew_method(icalproperty_method v, ...); +void icalproperty_set_method(icalproperty* prop, icalproperty_method v); +icalproperty_method icalproperty_get_method(icalproperty* prop); + +/* LAST-MODIFIED */ +icalproperty* icalproperty_new_lastmodified(struct icaltimetype v); +icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...); +void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop); + +/* UID */ +icalproperty* icalproperty_new_uid(char* v); +icalproperty* icalproperty_vanew_uid(char* v, ...); +void icalproperty_set_uid(icalproperty* prop, char* v); +char* icalproperty_get_uid(icalproperty* prop); + +/* PRODID */ +icalproperty* icalproperty_new_prodid(char* v); +icalproperty* icalproperty_vanew_prodid(char* v, ...); +void icalproperty_set_prodid(icalproperty* prop, char* v); +char* icalproperty_get_prodid(icalproperty* prop); + +/* STATUS */ +icalproperty* icalproperty_new_status(char* v); +icalproperty* icalproperty_vanew_status(char* v, ...); +void icalproperty_set_status(icalproperty* prop, char* v); +char* icalproperty_get_status(icalproperty* prop); + +/* DESCRIPTION */ +icalproperty* icalproperty_new_description(char* v); +icalproperty* icalproperty_vanew_description(char* v, ...); +void icalproperty_set_description(icalproperty* prop, char* v); +char* icalproperty_get_description(icalproperty* prop); + +/* DURATION */ +icalproperty* icalproperty_new_duration(struct icaldurationtype v); +icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...); +void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v); +struct icaldurationtype icalproperty_get_duration(icalproperty* prop); + +/* CATEGORIES */ +icalproperty* icalproperty_new_categories(char* v); +icalproperty* icalproperty_vanew_categories(char* v, ...); +void icalproperty_set_categories(icalproperty* prop, char* v); +char* icalproperty_get_categories(icalproperty* prop); + +/* VERSION */ +icalproperty* icalproperty_new_version(char* v); +icalproperty* icalproperty_vanew_version(char* v, ...); +void icalproperty_set_version(icalproperty* prop, char* v); +char* icalproperty_get_version(icalproperty* prop); + +/* TZOFFSETFROM */ +icalproperty* icalproperty_new_tzoffsetfrom(int v); +icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...); +void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v); +int icalproperty_get_tzoffsetfrom(icalproperty* prop); + +/* RRULE */ +icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v); +icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...); +void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v); +struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop); + +/* ATTENDEE */ +icalproperty* icalproperty_new_attendee(char* v); +icalproperty* icalproperty_vanew_attendee(char* v, ...); +void icalproperty_set_attendee(icalproperty* prop, char* v); +char* icalproperty_get_attendee(icalproperty* prop); + +/* CONTACT */ +icalproperty* icalproperty_new_contact(char* v); +icalproperty* icalproperty_vanew_contact(char* v, ...); +void icalproperty_set_contact(icalproperty* prop, char* v); +char* icalproperty_get_contact(icalproperty* prop); + +/* RELATED-TO */ +icalproperty* icalproperty_new_relatedto(char* v); +icalproperty* icalproperty_vanew_relatedto(char* v, ...); +void icalproperty_set_relatedto(icalproperty* prop, char* v); +char* icalproperty_get_relatedto(icalproperty* prop); + +/* ORGANIZER */ +icalproperty* icalproperty_new_organizer(char* v); +icalproperty* icalproperty_vanew_organizer(char* v, ...); +void icalproperty_set_organizer(icalproperty* prop, char* v); +char* icalproperty_get_organizer(icalproperty* prop); + +/* COMMENT */ +icalproperty* icalproperty_new_comment(char* v); +icalproperty* icalproperty_vanew_comment(char* v, ...); +void icalproperty_set_comment(icalproperty* prop, char* v); +char* icalproperty_get_comment(icalproperty* prop); + +/* TRIGGER */ +icalproperty* icalproperty_new_trigger(union icaltriggertype v); +icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...); +void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v); +union icaltriggertype icalproperty_get_trigger(icalproperty* prop); + +/* X-LIC-ERROR */ +icalproperty* icalproperty_new_xlicerror(char* v); +icalproperty* icalproperty_vanew_xlicerror(char* v, ...); +void icalproperty_set_xlicerror(icalproperty* prop, char* v); +char* icalproperty_get_xlicerror(icalproperty* prop); + +/* CLASS */ +icalproperty* icalproperty_new_class(char* v); +icalproperty* icalproperty_vanew_class(char* v, ...); +void icalproperty_set_class(icalproperty* prop, char* v); +char* icalproperty_get_class(icalproperty* prop); + +/* TZOFFSETTO */ +icalproperty* icalproperty_new_tzoffsetto(int v); +icalproperty* icalproperty_vanew_tzoffsetto(int v, ...); +void icalproperty_set_tzoffsetto(icalproperty* prop, int v); +int icalproperty_get_tzoffsetto(icalproperty* prop); + +/* TRANSP */ +icalproperty* icalproperty_new_transp(char* v); +icalproperty* icalproperty_vanew_transp(char* v, ...); +void icalproperty_set_transp(icalproperty* prop, char* v); +char* icalproperty_get_transp(icalproperty* prop); + +/* SEQUENCE */ +icalproperty* icalproperty_new_sequence(int v); +icalproperty* icalproperty_vanew_sequence(int v, ...); +void icalproperty_set_sequence(icalproperty* prop, int v); +int icalproperty_get_sequence(icalproperty* prop); + +/* LOCATION */ +icalproperty* icalproperty_new_location(char* v); +icalproperty* icalproperty_vanew_location(char* v, ...); +void icalproperty_set_location(icalproperty* prop, char* v); +char* icalproperty_get_location(icalproperty* prop); + +/* REQUEST-STATUS */ +icalproperty* icalproperty_new_requeststatus(char* v); +icalproperty* icalproperty_vanew_requeststatus(char* v, ...); +void icalproperty_set_requeststatus(icalproperty* prop, char* v); +char* icalproperty_get_requeststatus(icalproperty* prop); + +/* EXDATE */ +icalproperty* icalproperty_new_exdate(struct icaltimetype v); +icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...); +void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_exdate(icalproperty* prop); + +/* TZID */ +icalproperty* icalproperty_new_tzid(char* v); +icalproperty* icalproperty_vanew_tzid(char* v, ...); +void icalproperty_set_tzid(icalproperty* prop, char* v); +char* icalproperty_get_tzid(icalproperty* prop); + +/* RESOURCES */ +icalproperty* icalproperty_new_resources(char* v); +icalproperty* icalproperty_vanew_resources(char* v, ...); +void icalproperty_set_resources(icalproperty* prop, char* v); +char* icalproperty_get_resources(icalproperty* prop); + +/* TZURL */ +icalproperty* icalproperty_new_tzurl(char* v); +icalproperty* icalproperty_vanew_tzurl(char* v, ...); +void icalproperty_set_tzurl(icalproperty* prop, char* v); +char* icalproperty_get_tzurl(icalproperty* prop); + +/* REPEAT */ +icalproperty* icalproperty_new_repeat(int v); +icalproperty* icalproperty_vanew_repeat(int v, ...); +void icalproperty_set_repeat(icalproperty* prop, int v); +int icalproperty_get_repeat(icalproperty* prop); + +/* PRIORITY */ +icalproperty* icalproperty_new_priority(int v); +icalproperty* icalproperty_vanew_priority(int v, ...); +void icalproperty_set_priority(icalproperty* prop, int v); +int icalproperty_get_priority(icalproperty* prop); + +/* FREEBUSY */ +icalproperty* icalproperty_new_freebusy(struct icalperiodtype v); +icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...); +void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v); +struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop); + +/* DTSTART */ +icalproperty* icalproperty_new_dtstart(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...); +void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtstart(icalproperty* prop); + +/* RECURRENCE-ID */ +icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v); +icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...); +void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop); + +/* SUMMARY */ +icalproperty* icalproperty_new_summary(char* v); +icalproperty* icalproperty_vanew_summary(char* v, ...); +void icalproperty_set_summary(icalproperty* prop, char* v); +char* icalproperty_get_summary(icalproperty* prop); + +/* DTEND */ +icalproperty* icalproperty_new_dtend(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...); +void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtend(icalproperty* prop); + +/* TZNAME */ +icalproperty* icalproperty_new_tzname(char* v); +icalproperty* icalproperty_vanew_tzname(char* v, ...); +void icalproperty_set_tzname(icalproperty* prop, char* v); +char* icalproperty_get_tzname(icalproperty* prop); + +/* RDATE */ +icalproperty* icalproperty_new_rdate(struct icalperiodtype v); +icalproperty* icalproperty_vanew_rdate(struct icalperiodtype v, ...); +void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v); +struct icalperiodtype icalproperty_get_rdate(icalproperty* prop); + +/* URL */ +icalproperty* icalproperty_new_url(char* v); +icalproperty* icalproperty_vanew_url(char* v, ...); +void icalproperty_set_url(icalproperty* prop, char* v); +char* icalproperty_get_url(icalproperty* prop); + +/* ATTACH */ +icalproperty* icalproperty_new_attach(struct icalattachtype v); +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...); +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v); +struct icalattachtype icalproperty_get_attach(icalproperty* prop); + +/* X-LIC-CLUSTERCOUNT */ +icalproperty* icalproperty_new_xlicclustercount(int v); +icalproperty* icalproperty_vanew_xlicclustercount(int v, ...); +void icalproperty_set_xlicclustercount(icalproperty* prop, int v); +int icalproperty_get_xlicclustercount(icalproperty* prop); + +/* EXRULE */ +icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v); +icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...); +void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v); +struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop); + +/* QUERY */ +icalproperty* icalproperty_new_query(char* v); +icalproperty* icalproperty_vanew_query(char* v, ...); +void icalproperty_set_query(icalproperty* prop, char* v); +char* icalproperty_get_query(icalproperty* prop); + +/* PERCENT-COMPLETE */ +icalproperty* icalproperty_new_percentcomplete(int v); +icalproperty* icalproperty_vanew_percentcomplete(int v, ...); +void icalproperty_set_percentcomplete(icalproperty* prop, int v); +int icalproperty_get_percentcomplete(icalproperty* prop); + +/* CALSCALE */ +icalproperty* icalproperty_new_calscale(char* v); +icalproperty* icalproperty_vanew_calscale(char* v, ...); +void icalproperty_set_calscale(icalproperty* prop, char* v); +char* icalproperty_get_calscale(icalproperty* prop); + +/* CREATED */ +icalproperty* icalproperty_new_created(struct icaltimetype v); +icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...); +void icalproperty_set_created(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_created(icalproperty* prop); + +/* GEO */ +icalproperty* icalproperty_new_geo(struct icalgeotype v); +icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...); +void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v); +struct icalgeotype icalproperty_get_geo(icalproperty* prop); + +/* COMPLETED */ +icalproperty* icalproperty_new_completed(struct icaltimetype v); +icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...); +void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_completed(icalproperty* prop); + +/* DTSTAMP */ +icalproperty* icalproperty_new_dtstamp(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...); +void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop); + +/* DUE */ +icalproperty* icalproperty_new_due(struct icaltimetype v); +icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...); +void icalproperty_set_due(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_due(icalproperty* prop); + +/* ACTION */ +icalproperty* icalproperty_new_action(char* v); +icalproperty* icalproperty_vanew_action(char* v, ...); +void icalproperty_set_action(icalproperty* prop, char* v); +char* icalproperty_get_action(icalproperty* prop); +#endif ICALPROPERTY_H diff --git a/libical/src/libical/icalrestriction.c b/libical/src/libical/icalrestriction.c new file mode 100644 index 0000000000..9393b3ea34 --- /dev/null +++ b/libical/src/libical/icalrestriction.c @@ -0,0 +1,1582 @@ +/* -*- Mode: C -*- */ +/* ====================================================================== + File: icalrestriction.c + + (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. + + + ======================================================================*/ + +#include "icalenums.h" +#include "icalrestriction.h" + +/* Define the structs for the restrictions. these data are filled out +in machine generated code below */ + +typedef int (*restriction_func)(icalcomponent* comp); + +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_component_record icalrestriction_component_records[]; +icalrestriction_property_record icalrestriction_property_records[]; + +/* 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' */ + +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 more",/*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]; + +} + +int icalrestriction_check_component(icalproperty_method method, + icalcomponent* comp) +{ + icalproperty_kind kind; + icalcomponent_kind comp_kind; + icalrestriction_kind restr; + 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); + + restr = icalrestriction_get_property_restriction(method, + comp_kind, + kind); + + + if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ) { + /* HACK. Treat this as a 0/1 restriction */ + restr = ICAL_RESTRICTION_ZEROORONE; + compare = icalrestriction_compare(restr,count); + } else if (restr == ICAL_RESTRICTION_ONEMUTUAL ) { + /* HACK. Treat this as a 0/1 restriction */ + restr = ICAL_RESTRICTION_ZEROORONE; + compare = icalrestriction_compare(restr,count); + } else { + compare = icalrestriction_compare(restr,count); + } + + assert(compare != -1); + + + if (compare == 0){ + char temp[1024]; + + sprintf(temp, "Failed iTIP restrictions for property %s. 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)); + } + + + 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_kind +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].restriction; + } + } + + return ICAL_RESTRICTION_UNKNOWN; +} + +icalrestriction_kind +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].restriction; + } + } + + return ICAL_RESTRICTION_UNKNOWN; +} + +/* Everything below this line is machine generated. Do not edit. */ +icalrestriction_property_record icalrestriction_property_records[] = { + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE} +}; +icalrestriction_component_record icalrestriction_component_records[] = { + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO}, + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE} +}; diff --git a/libical/src/libical/icalrestriction.h b/libical/src/libical/icalrestriction.h new file mode 100644 index 0000000000..ca4beeea7b --- /dev/null +++ b/libical/src/libical/icalrestriction.h @@ -0,0 +1,72 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalrestriction.h + CREATOR: eric 24 April 1999 + + $Id$ + + + (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 icalrestriction.h + + Contributions from: + Graham Davison (g.m.davison@computer.org) + + +======================================================================*/ + +#include "ical.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); + +icalrestriction_kind +icalrestriction_get_property_restriction(icalproperty_method method, + icalcomponent_kind component, + icalproperty_kind property); + +icalrestriction_kind +icalrestriction_get_component_restriction(icalproperty_method method, + icalcomponent_kind component, + icalcomponent_kind subcomponent); + +int +icalrestriction_is_parameter_allowed(icalproperty_kind property, + icalparameter_kind parameter); + +int icalrestriction_check(icalcomponent* comp); + + +#endif /* !ICALRESTRICTION_H */ + + + diff --git a/libical/src/libical/icaltypes.c b/libical/src/libical/icaltypes.c new file mode 100644 index 0000000000..14daa2915d --- /dev/null +++ b/libical/src/libical/icaltypes.c @@ -0,0 +1,200 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icaltypes.c + CREATOR: eric 16 May 1999 + + $Id$ + $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 icaltypes.c + + ======================================================================*/ + +#include "icaltypes.h" +#include "icalerror.h" +#include <stdlib.h> /* for malloc */ +#include <errno.h> /* for errno */ +#include <string.h> /* for strdup */ +#include <assert.h> +#include <limits.h> /* for SHRT_MAX */ + +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 = strdup(url); + + /* HACK This routine should do something if 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; +} + + + +time_t +icalperiodtype_duration (struct icalperiodtype period); + + +time_t +icalperiodtype_end (struct icalperiodtype period); + +struct icaltimetype +icaltimetype_from_timet(time_t v, int date) +{ + struct icaltimetype tt; + struct tm t; + time_t tm = time(&v); + +/* HACK Does not properly consider timezone */ + t = *(gmtime(&tm)); + + tt.second = t.tm_sec; + tt.minute = t.tm_min; + tt.hour = t.tm_hour; + tt.day = t.tm_mday; + tt.month = t.tm_mon + 1; + tt.year = t.tm_year+ 1900; + + tt.is_utc = 1; + tt.is_date = date; + + return tt; +} + +/* From Russel Steinthal */ +time_t icaldurationtype_as_timet(struct icaldurationtype dur) +{ + return (time_t) (dur.seconds + + (60 * dur.minutes) + + (60 * 60 * dur.hours) + + (60 * 60 * 24 * dur.days) + + (60 * 60 * 24 * 7 * dur.weeks)); +} + + +void icalrecurrencetype_clear(struct icalrecurrencetype *recur) +{ + memset(recur,ICAL_RECURRENCE_ARRAY_MAX_BYTE, + sizeof(struct icalrecurrencetype)); + + recur->week_start = ICAL_NO_WEEKDAY; + recur->freq = ICAL_NO_RECURRENCE; + recur->interval = 0; + recur->until.year = 0; + recur->count = 0; +} diff --git a/libical/src/libical/icaltypes.h b/libical/src/libical/icaltypes.h new file mode 100644 index 0000000000..c33e8acd7d --- /dev/null +++ b/libical/src/libical/icaltypes.h @@ -0,0 +1,168 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icaltypes.h + CREATOR: eric 20 March 1999 + + + (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 icaltypes.h + +======================================================================*/ + +#ifndef ICALTYPES_H +#define ICALTYPES_H + +#include <time.h> +#include "icalenums.h" /* for recurrence enums */ + +/* 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 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 icaltimetype +{ + int year; + int month; + int day; + int hour; + int minute; + int second; + + int is_utc; /* 1-> time is in UTC timezone */ + + int is_date; /* 1 -> interpret this as date. */ +}; + +struct icaltimetype icaltimetype_from_timet(time_t v, int is_date); + + +/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of + the values and fields in struct icalrecurrencetype */ + + +struct icalrecurrencetype +{ + icalrecurrencetype_frequency freq; + + + /* until and count are mutually exclusive. */ + struct icaltimetype until; + int count; + + short interval; + + icalrecurrencetype_weekday week_start; + + /* The BY* parameters can each take a list of values. Here I + * assume that the list of values will not be larger than the + * range of the value -- that is, the client will not name a + * value more than once. + + * Each of the lists is terminated with the value SHRT_MAX + * unless the the list is full. */ + + short by_second[61]; + short by_minute[61]; + short by_hour[25]; + short by_day[8]; + short by_month_day[32]; + short by_year_day[367]; + short by_week_no[54]; + short by_month[13]; + short by_set_pos[367]; +}; + + +void icalrecurrencetype_clear(struct icalrecurrencetype *r); + +struct icaldurationtype +{ + unsigned int days; + unsigned int weeks; + unsigned int hours; + unsigned int minutes; + unsigned int seconds; +}; + +struct icaldurationtype icaldurationtype_from_timet(time_t t); +time_t icaldurationtype_as_timet(struct icaldurationtype duration); + +/* Return the next occurance of 'r' after the time specified by 'after' */ +struct icaltimetype icalrecurrencetype_next_occurance( + struct icalrecurrencetype *r, + struct icaltimetype *after); + + +struct icalperiodtype +{ + struct icaltimetype start; /* Must be absolute */ + struct icaltimetype end; /* Must be absolute */ + struct icaldurationtype duration; +}; + +time_t icalperiodtype_duration(struct icalperiodtype period); +time_t icalperiodtype_end(struct icalperiodtype period); + +union icaltriggertype +{ + struct icaltimetype time; + struct icaldurationtype duration; +}; + +struct icalrequestsstatustype { + + short minor; + short major; + +}; + + +#endif /* !ICALTYPES_H */ diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c new file mode 100644 index 0000000000..81352dd247 --- /dev/null +++ b/libical/src/libical/icalvalue.c @@ -0,0 +1,1987 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalvalue.c + CREATOR: eric 02 May 1999 + + $Id$ + + + (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 icalvalue.c + + Contributions from: + Graham Davison (g.m.davison@computer.org) + + +======================================================================*/ + + +#include "ical.h" +#include "icalerror.h" +#include "icalmemory.h" +#include "icalparser.h" +#include "icalenums.h" + +#include <stdlib.h> /* for malloc */ +#include <stdio.h> /* for sprintf */ +#include <string.h> /* For memset, others */ +#include <errno.h> +#include <time.h> /* for mktime */ +#include <stdlib.h> /* for atoi and atof */ +#include <limits.h> /* for SHRT_MAX */ + +#if _MAC_OS_ +#include "strdup.h" +#endif + +void print_datetime_to_string(char* str, struct icaltimetype *data); +void print_date_to_string(char* str, struct icaltimetype *data); +void print_time_to_string(char* str, struct icaltimetype *data); +void print_recur_to_string(char* str, struct icaltimetype *data); + +struct icalvalue_impl { + icalvalue_kind kind; + char id[5]; + int size; + icalproperty* parent; + + union data { + struct icalattachtype v_attach; + /* void *v_binary; */ /* use v_attach */ + 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 a value in this + union, but it contributes 2000 bytes to every*/ + + struct icalrecurrencetype *v_recur; + union icaltriggertype v_trigger; + icalproperty_method v_method; + + } data; +}; + +struct icalvalue_impl* icalvalue_new_impl(icalvalue_kind kind){ + + struct icalvalue_impl* v; + + if ( ( v = (struct icalvalue_impl*) + malloc(sizeof(struct icalvalue_impl))) == 0) { + errno = ENOMEM; + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + strcpy(v->id,"val"); + + v->kind = kind; + v->size = 0; + v->parent = 0; + memset(&(v->data),0,sizeof(v->data)); + + return v; + +} + + + +icalvalue* +icalvalue_new (icalvalue_kind kind) +{ + return (icalvalue*)icalvalue_new_impl(kind); +} + +icalvalue* icalvalue_new_clone(icalvalue* value){ + + struct icalvalue_impl* new; + struct icalvalue_impl* old = (struct icalvalue_impl*)value; + + new = icalvalue_new_impl(old->kind); + + if (new == 0){ + return 0; + } + + + strcpy(new->id, old->id); + new->kind = old->kind; + new->size = old->size; + + switch (new->kind){ + + /* The contents of the attach value may or may not be owned by the + * library. */ + case ICAL_ATTACH_VALUE: + case ICAL_BINARY_VALUE: + { + /* HACK ugh. I don't feel like impleenting this */ + } + + case ICAL_TEXT_VALUE: + case ICAL_CALADDRESS_VALUE: + case ICAL_URI_VALUE: + { + if (old->data.v_string != 0) { + new->data.v_string=strdup(old->data.v_string); + + if ( new->data.v_string == 0 ) { + return 0; + } + + } + break; + } + case ICAL_RECUR_VALUE: + { + if(old->data.v_recur != 0){ + new->data.v_recur = malloc(sizeof(struct icalrecurrencetype)); + + if(new->data.v_recur == 0){ + return 0; + } + + memcpy( new->data.v_recur, old->data.v_recur, + sizeof(struct icalrecurrencetype)); + } + break; + } + + default: + { + /* all of the other types are stored as values, not + pointers, so we can just copy the whole structure. */ + + new->data = old->data; + } + } + + return new; +} + +icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,char* str,icalproperty** error) +{ + + icalvalue *value = 0; + + icalerror_check_arg_rz(str!=0,"str"); + + if (error != 0){ + *error = 0; + } + + switch (kind){ + + case ICAL_ATTACH_VALUE: + { + /* HACK */ + value = 0; + + if (error != 0){ + char temp[1024]; + sprintf(temp,"ATTACH Values are not implemented"); + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + icalerror_warn("Parsing ATTACH properties is unimplmeneted"); + break; + } + + case ICAL_BINARY_VALUE: + { + /* HACK */ + value = 0; + + if (error != 0){ + char temp[1024]; + sprintf(temp,"BINARY Values are not implemented"); + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + icalerror_warn("Parsing BINARY values is unimplmeneted"); + break; + } + + case ICAL_BOOLEAN_VALUE: + { + /* HACK */ + value = 0; + + if (error != 0){ + char temp[1024]; + sprintf(temp,"BOOLEAN Values are not implemented"); + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + icalerror_warn("Parsing BOOLEAN values is unimplmeneted"); + break; + } + + case ICAL_INTEGER_VALUE: + { + value = icalvalue_new_integer(atoi(str)); + break; + } + + case ICAL_FLOAT_VALUE: + { + value = icalvalue_new_float(atof(str)); + break; + } + + case ICAL_UTCOFFSET_VALUE: + { + value = icalparser_parse_value(kind,str,(icalcomponent*)0); + break; + } + + case ICAL_TEXT_VALUE: + { + value = icalvalue_new_text(str); + break; + } + + case ICAL_CALADDRESS_VALUE: + { + value = icalvalue_new_caladdress(str); + break; + } + + case ICAL_URI_VALUE: + { + value = icalvalue_new_uri(str); + break; + } + + case ICAL_METHOD_VALUE: + { + icalproperty_method method = icalenum_string_to_method(str); + value = icalvalue_new_method(method); + } + case ICAL_GEO_VALUE: + { + value = 0; + /* HACK */ + + if (error != 0){ + char temp[1024]; + sprintf(temp,"GEO Values are not implemented"); + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + /*icalerror_warn("Parsing GEO properties is unimplmeneted");*/ + + break; + } + + case ICAL_RECUR_VALUE: + case ICAL_DATE_VALUE: + case ICAL_DATETIME_VALUE: + case ICAL_DATETIMEDATE_VALUE: + case ICAL_DATETIMEPERIOD_VALUE: + case ICAL_TIME_VALUE: + case ICAL_DURATION_VALUE: + case ICAL_PERIOD_VALUE: + case ICAL_TRIGGER_VALUE: + { + value = icalparser_parse_value(kind,str,error); + break; + } + + default: + { + + if (error != 0 ){ + char temp[1024]; + + if (strlen(str) > 265) { + sprintf(temp,"Unknown type for \'%256s...\'",str); + } else { + sprintf(temp,"Unknown type for \'%s\'",str); + + } + + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + icalerror_warn("icalvalue_new_from_string got an unknown value type"); + value=0; + } + } + + + if (error != 0 && *error == 0 && value == 0){ + char temp[1024]; + + if (strlen(str) > 265) { + sprintf(temp,"Failed to parse value: \'%256s...\'",str); + } else { + sprintf(temp,"Failed to parse value: \'%s\'",str); + + } + + *error = icalproperty_vanew_xlicerror( + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); + } + + + return value; + +} + +icalvalue* icalvalue_new_from_string(icalvalue_kind kind,char* str) +{ + return icalvalue_new_from_string_with_error(kind,str,(icalproperty*)0); +} + + + +void +icalvalue_free (icalvalue* value) +{ + struct icalvalue_impl* v = (struct icalvalue_impl*)value; + + icalerror_check_arg_rv((value != 0),"value"); + +#ifdef ICAL_FREE_ON_LIST_IS_ERROR + icalerror_assert( (v->parent ==0),"This value is still attached to a property"); + +#else + if(v->parent !=0){ + return; + } +#endif + + + switch (v->kind){ + case ICAL_BINARY_VALUE: + case ICAL_ATTACH_VALUE: { + /* HACK ugh. This will be tough to implement */ + } + case ICAL_TEXT_VALUE: + case ICAL_CALADDRESS_VALUE: + case ICAL_URI_VALUE: + { + if (v->data.v_string != 0) { + free(v->data.v_string); + v->data.v_string = 0; + } + break; + } + case ICAL_RECUR_VALUE: + { + if(v->data.v_recur != 0){ + free(v->data.v_recur); + v->data.v_recur = 0; + } + break; + } + + default: + { + /* Nothing to do */ + } + } + + v->kind = ICAL_NO_VALUE; + v->size = 0; + v->parent = 0; + memset(&(v->data),0,sizeof(v->data)); + v->id[0] = 'X'; + free(v); +} + +int +icalvalue_is_valid (icalvalue* value) +{ + /*struct icalvalue_impl* v = (struct icalvalue_impl*)value;*/ + + if(value == 0){ + return 0; + } + + return 1; +} + +char* icalvalue_binary_as_ical_string(icalvalue* value) { + + char* data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_binary(value); + + str = (char*)icalmemory_tmp_buffer(60); + sprintf(str,"icalvalue_binary_as_ical_string is not implemented yet"); + + return str; +} + + +char* icalvalue_int_as_ical_string(icalvalue* value) { + + int data; + char* str = (char*)icalmemory_tmp_buffer(2); + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_integer(value); + + sprintf(str,"%d",data); + + return str; +} + +char* icalvalue_utcoffset_as_ical_string(icalvalue* value) +{ + int data,h,m,s; + char sign; + char* str = (char*)icalmemory_tmp_buffer(9); + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_utcoffset(value); + + if (abs(data) == data){ + sign = '+'; + } else { + sign = '-'; + } + + h = data/3600; + m = (data - (h*3600))/ 60; + s = (data - (h*3600) - (m*60)); + + sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s)); + + return str; +} + +char* icalvalue_string_as_ical_string(icalvalue* value) { + + char* data; + char* str = 0; + icalerror_check_arg_rz( (value!=0),"value"); + data = ((struct icalvalue_impl*)value)->data.v_string; + + str = (char*)icalmemory_tmp_buffer(strlen(data)+1); + + strcpy(str,data); + + return str; +} + + +char* icalvalue_recur_as_ical_string(icalvalue* value) +{ + char* str; + char *str_p; + size_t buf_sz = 200; + char temp[20]; + int i,j; + struct icalvalue_impl *impl = (struct icalvalue_impl*)value; + struct icalrecurrencetype *recur = impl->data.v_recur; + + struct { char* str; short* array; short limit; } map[] = + { + {";BYSECOND=",recur->by_second,60}, + {";BYMINUTE=",recur->by_minute,60}, + {";BYHOUR=",recur->by_hour,24}, + {";BYDAY=",recur->by_day,7}, + {";BYMONTHDAY=",recur->by_month_day,31}, + {";BYYEARDAY=",recur->by_year_day,366}, + {";BYWEEKNO=",recur->by_week_no,52}, + {";BYMONTH=",recur->by_month,12}, + {";BYSETPOS=",recur->by_set_pos,366}, + {0,0,0}, + }; + + icalerror_check_arg_rz((value != 0),"value"); + + if(recur->freq == ICAL_NO_RECURRENCE){ + return 0; + } + + str = (char*)icalmemory_tmp_buffer(buf_sz); + str_p = str; + + icalmemory_append_string(&str,&str_p,&buf_sz,"FREQ="); + icalmemory_append_string(&str,&str_p,&buf_sz, + icalenum_recurrence_to_string(recur->freq)); + + if(recur->until.year != 0){ + + temp[0] = 0; + print_datetime_to_string(temp,&(recur->until)); + + icalmemory_append_string(&str,&str_p,&buf_sz,";UNTIL="); + icalmemory_append_string(&str,&str_p,&buf_sz, temp); + } + + if(recur->count != 0){ + sprintf(temp,"%d",recur->count); + icalmemory_append_string(&str,&str_p,&buf_sz,";COUNT="); + icalmemory_append_string(&str,&str_p,&buf_sz, temp); + } + + if(recur->interval != 0){ + sprintf(temp,"%d",recur->interval); + icalmemory_append_string(&str,&str_p,&buf_sz,";INTERVAL="); + icalmemory_append_string(&str,&str_p,&buf_sz, temp); + } + + for(j =0; map[j].str != 0; j++){ + short* array = map[j].array; + short limit = map[j].limit; + + /* Skip unused arrays */ + if( array[0] != ICAL_RECURRENCE_ARRAY_MAX ) { + + icalmemory_append_string(&str,&str_p,&buf_sz,map[j].str); + + for(i=0; i< limit && array[i] != ICAL_RECURRENCE_ARRAY_MAX; + i++){ + if (j == 3) { /* BYDAY */ + icalmemory_append_string(&str,&str_p,&buf_sz, + icalenum_weekday_to_string(array[i])); + } else { + sprintf(temp,"%d",array[i]); + icalmemory_append_string(&str,&str_p,&buf_sz, temp); + } + + if( (i+1)<limit &&array[i+1] + != ICAL_RECURRENCE_ARRAY_MAX){ + icalmemory_append_char(&str,&str_p,&buf_sz,','); + } + } + } + } + + return str; +} + +char* icalvalue_text_as_ical_string(icalvalue* value) { + + char *str; + char *str_p; + char *rtrn; + char *p; + size_t buf_sz; + int line_length; + + line_length = 0; + + buf_sz = strlen(((struct icalvalue_impl*)value)->data.v_string)+1; + + str_p = str = (char*)icalmemory_new_buffer(buf_sz); + + if (str_p == 0){ + return 0; + } + + for(p=((struct icalvalue_impl*)value)->data.v_string; *p!=0; p++){ + + switch(*p){ + case '\n': { + icalmemory_append_string(&str,&str_p,&buf_sz,"\\n"); + line_length+=3; + break; + } + + case '\t': { + icalmemory_append_string(&str,&str_p,&buf_sz,"\\t"); + line_length+=3; + break; + } + case '\r': { + icalmemory_append_string(&str,&str_p,&buf_sz,"\\r"); + line_length+=3; + break; + } + case '\b': { + icalmemory_append_string(&str,&str_p,&buf_sz,"\\b"); + line_length+=3; + break; + } + case '\f': { + icalmemory_append_string(&str,&str_p,&buf_sz,"\\f"); + line_length+=3; + break; + } + + case ';': + case ',':{ + icalmemory_append_char(&str,&str_p,&buf_sz,'\\'); + icalmemory_append_char(&str,&str_p,&buf_sz,*p); + line_length+=3; + break; + } + + case '"':{ + icalmemory_append_char(&str,&str_p,&buf_sz,'\\'); + icalmemory_append_char(&str,&str_p,&buf_sz,*p); + line_length+=3; + break; + } + + default: { + icalmemory_append_char(&str,&str_p,&buf_sz,*p); + line_length++; + } + } + + if (line_length > 65 && *p == ' '){ + icalmemory_append_string(&str,&str_p,&buf_sz,"\n "); + line_length=0; + } + + + if (line_length > 75){ + icalmemory_append_string(&str,&str_p,&buf_sz,"\n "); + line_length=0; + } + + } + + /* Assume the last character is not a '\0' and add one. We could + check *str_p != 0, but that would be an uninitialized memory + read. */ + + + icalmemory_append_char(&str,&str_p,&buf_sz,'\0'); + + rtrn = icalmemory_tmp_copy(str); + + icalmemory_free_buffer(str); + + return rtrn; +} + + +char* icalvalue_attach_as_ical_string(icalvalue* value) { + + struct icalattachtype a; + char * str; + + icalerror_check_arg_rz( (value!=0),"value"); + + a = icalvalue_get_attach(value); + + if (a.binary != 0) { + return icalvalue_binary_as_ical_string(value); + } else if (a.base64 != 0) { + str = (char*)icalmemory_tmp_buffer(strlen(a.base64)+1); + strcpy(str,a.base64); + return str; + } else if (a.url != 0){ + return icalvalue_string_as_ical_string(value); + } else { + icalerrno = ICAL_MALFORMEDDATA_ERROR; + return 0; + } +} + +void append_duration_segment(char** buf, char** buf_ptr, size_t* buf_size, + char* sep, unsigned int value) { + + char digits[256]; /* HACK: large hardcoded limit */ + + sprintf(digits,"%d",value); + + icalmemory_append_string(buf, buf_ptr, buf_size, digits); + icalmemory_append_string(buf, buf_ptr, buf_size, sep); + +} + +char* icalvalue_duration_as_ical_string(icalvalue* value) { + + struct icaldurationtype data; + char *buf, *output_line; + size_t buf_size = 256; + char* buf_ptr = 0; + + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_duration(value); + + buf = (char*)icalmemory_new_buffer(buf_size); + buf_ptr = buf; + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "P"); + + + if (data.weeks != 0 ) { + append_duration_segment(&buf, &buf_ptr, &buf_size, "W", data.weeks); + } + + if (data.days != 0 ) { + append_duration_segment(&buf, &buf_ptr, &buf_size, "D", data.days); + } + + if (data.hours != 0 || data.minutes != 0 || data.seconds != 0) { + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "T"); + + if (data.hours != 0 ) { + append_duration_segment(&buf, &buf_ptr, &buf_size, "H", data.hours); + } + if (data.minutes != 0 ) { + append_duration_segment(&buf, &buf_ptr, &buf_size, "M", data.minutes); + } + if (data.seconds != 0 ) { + append_duration_segment(&buf, &buf_ptr, &buf_size, "S", data.seconds); + } + + } + + output_line = icalmemory_tmp_copy(buf); + icalmemory_free_buffer(buf); + + return output_line; + + +} + +void print_time_to_string(char* str, struct icaltimetype *data) +{ + char temp[20]; + + if (data->is_utc == 1){ + sprintf(temp,"%02d%02d%02dZ",data->hour,data->minute,data->second); + } else { + sprintf(temp,"%02d%02d%02d",data->hour,data->minute,data->second); + } + + strcat(str,temp); +} + + +char* icalvalue_time_as_ical_string(icalvalue* value) { + + struct icaltimetype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_time(value); + + str = (char*)icalmemory_tmp_buffer(8); + + str[0] = 0; + print_time_to_string(str,&data); + + return str; +} + +void print_date_to_string(char* str, struct icaltimetype *data) +{ + char temp[20]; + + sprintf(temp,"%04d%02d%02d",data->year,data->month,data->day); + + strcat(str,temp); +} + +char* icalvalue_date_as_ical_string(icalvalue* value) { + + struct icaltimetype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_date(value); + + str = (char*)icalmemory_tmp_buffer(9); + + str[0] = 0; + print_date_to_string(str,&data); + + return str; +} + +void print_datetime_to_string(char* str, struct icaltimetype *data) +{ + print_date_to_string(str,data); + strcat(str,"T"); + print_time_to_string(str,data); + +} + +char* icalvalue_datetime_as_ical_string(icalvalue* value) { + + struct icaltimetype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_date(value); + + str = (char*)icalmemory_tmp_buffer(20); + + str[0] = 0; + + print_datetime_to_string(str,&data); + + return str; + +} + + +char* icalvalue_datetimedate_as_ical_string(icalvalue* value) { + + struct icaltimetype data; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_datetime(value); + + if (data.is_date == 1){ + return icalvalue_date_as_ical_string(value); + } else { + return icalvalue_datetime_as_ical_string(value); + } +} + + +char* icalvalue_float_as_ical_string(icalvalue* value) { + + float data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_float(value); + + str = (char*)icalmemory_tmp_buffer(15); + + sprintf(str,"%f",data); + + return str; +} + +char* icalvalue_geo_as_ical_string(icalvalue* value) { + + struct icalgeotype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + + data = icalvalue_get_geo(value); + + str = (char*)icalmemory_tmp_buffer(25); + + sprintf(str,"%f;%f",data.lat,data.lon); + + return str; +} + +char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) { + + struct icalperiodtype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_datetimeperiod(value); + + str = (char*)icalmemory_tmp_buffer(60); + + if( data.end.second == -1){ + /* This is a DATE-TIME value, since there is no end value */ + icalvalue *v= icalvalue_new_datetime(data.start); + + strcpy(str,icalvalue_datetime_as_ical_string(v)); + + free(v); + + } else { + icalvalue *v1 = icalvalue_new_datetime(data.start); + icalvalue *v2 = icalvalue_new_datetime(data.end); + + sprintf(str,"%s/%s", + icalvalue_datetime_as_ical_string(v1), + icalvalue_datetime_as_ical_string(v2) + ); + + free(v1); + free(v2); + + } + + return str; +} + +char* icalvalue_period_as_ical_string(icalvalue* value) { + + struct icalperiodtype data; + char* str; + icalvalue *s,*e; + + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_period(value); + + str = (char*)icalmemory_tmp_buffer(60); + + s = icalvalue_new_datetime(data.start); + + if (data.end.second != -1){ + /* use the end date */ + e = icalvalue_new_datetime(data.end); + + sprintf(str,"%s/%s", + icalvalue_datetime_as_ical_string(s), + icalvalue_datetime_as_ical_string(e) + ); + + + } else { + /* use the duration */ + e = icalvalue_new_duration(data.duration); + + sprintf(str,"%s/%s", + icalvalue_datetime_as_ical_string(s), + icalvalue_duration_as_ical_string(e) + ); + + } + + icalvalue_free(e); + icalvalue_free(s); + return str; +} + +char* icalvalue_trigger_as_ical_string(icalvalue* value) { + + union icaltriggertype data; + char* str; + icalerror_check_arg_rz( (value!=0),"value"); + data = icalvalue_get_trigger(value); + + str = (char*)icalmemory_tmp_buffer(60); + sprintf(str,"icalvalue_trigger_as_ical_string is not implemented yet"); + + return str; +} + +char* +icalvalue_as_ical_string (icalvalue* value) +{ + struct icalvalue_impl* v = (struct icalvalue_impl*)value; + + v=v; + + if(value == 0){ + return 0; + } + + switch (v->kind){ + + case ICAL_ATTACH_VALUE: + return icalvalue_attach_as_ical_string(value); + + case ICAL_BINARY_VALUE: + return icalvalue_binary_as_ical_string(value); + + case ICAL_BOOLEAN_VALUE: + case ICAL_INTEGER_VALUE: + return icalvalue_int_as_ical_string(value); + + case ICAL_UTCOFFSET_VALUE: + return icalvalue_utcoffset_as_ical_string(value); + + case ICAL_TEXT_VALUE: + return icalvalue_text_as_ical_string(value); + + case ICAL_URI_VALUE: + case ICAL_CALADDRESS_VALUE: + return icalvalue_string_as_ical_string(value); + + case ICAL_DATE_VALUE: + return icalvalue_date_as_ical_string(value); + case ICAL_DATETIME_VALUE: + return icalvalue_datetime_as_ical_string(value); + case ICAL_DATETIMEDATE_VALUE: + return icalvalue_datetimedate_as_ical_string(value); + case ICAL_DURATION_VALUE: + return icalvalue_duration_as_ical_string(value); + case ICAL_TIME_VALUE: + return icalvalue_time_as_ical_string(value); + + case ICAL_PERIOD_VALUE: + return icalvalue_period_as_ical_string(value); + case ICAL_DATETIMEPERIOD_VALUE: + return icalvalue_datetimeperiod_as_ical_string(value); + + case ICAL_FLOAT_VALUE: + return icalvalue_float_as_ical_string(value); + + case ICAL_GEO_VALUE: + return icalvalue_geo_as_ical_string(value); + + case ICAL_RECUR_VALUE: + return icalvalue_recur_as_ical_string(value); + + case ICAL_TRIGGER_VALUE: + return icalvalue_trigger_as_ical_string(value); + + case ICAL_METHOD_VALUE: + return icalenum_method_to_string(v->data.v_method); + + case ICAL_NO_VALUE: + default: + { + return 0; + } + } +} + + +icalvalue_kind +icalvalue_isa (icalvalue* value) +{ + struct icalvalue_impl* v = (struct icalvalue_impl*)value; + + if(value == 0){ + return ICAL_NO_VALUE; + } + + return v->kind; +} + + +int +icalvalue_isa_value (void* value) +{ + struct icalvalue_impl *impl = (struct icalvalue_impl *)value; + + icalerror_check_arg_rz( (value!=0), "value"); + + if (strcmp(impl->id,"val") == 0) { + return 1; + } else { + return 0; + } +} + + +icalparameter_xliccomparetype +icalvalue_compare(icalvalue* a, icalvalue *b) +{ + struct icalvalue_impl *impla = (struct icalvalue_impl *)a; + struct icalvalue_impl *implb = (struct icalvalue_impl *)b; + + icalerror_check_arg_rz( (a!=0), "a"); + icalerror_check_arg_rz( (b!=0), "b"); + + /* Not the same type; they can only be unequal */ + if (icalvalue_isa(a) != icalvalue_isa(b)){ + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + + switch (icalvalue_isa(a)){ + + case ICAL_ATTACH_VALUE: + case ICAL_BINARY_VALUE: + + case ICAL_BOOLEAN_VALUE: + { + if (icalvalue_get_boolean(a) == icalvalue_get_boolean(b)){ + return ICAL_XLICCOMPARETYPE_EQUAL; + } else { + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + } + + case ICAL_FLOAT_VALUE: + { + if (impla->data.v_float > implb->data.v_float){ + return ICAL_XLICCOMPARETYPE_GREATER; + } else if (impla->data.v_float < implb->data.v_float){ + return ICAL_XLICCOMPARETYPE_LESS; + } else { + return ICAL_XLICCOMPARETYPE_EQUAL; + } + } + + case ICAL_INTEGER_VALUE: + case ICAL_UTCOFFSET_VALUE: + { + if (impla->data.v_int > implb->data.v_int){ + return ICAL_XLICCOMPARETYPE_GREATER; + } else if (impla->data.v_int < implb->data.v_int){ + return ICAL_XLICCOMPARETYPE_LESS; + } else { + return ICAL_XLICCOMPARETYPE_EQUAL; + } + } + + case ICAL_TEXT_VALUE: + case ICAL_URI_VALUE: + case ICAL_CALADDRESS_VALUE: + case ICAL_TRIGGER_VALUE: + case ICAL_DATE_VALUE: + case ICAL_DATETIME_VALUE: + case ICAL_DATETIMEDATE_VALUE: + case ICAL_DURATION_VALUE: + case ICAL_TIME_VALUE: + case ICAL_DATETIMEPERIOD_VALUE: + { + int r; + + r = strcmp(icalvalue_as_ical_string(a), + icalvalue_as_ical_string(b)); + + if (r > 0) { + return ICAL_XLICCOMPARETYPE_GREATER; + } else if (r < 0){ + return ICAL_XLICCOMPARETYPE_LESS; + } else { + return 0; + } + + + } + + case ICAL_METHOD_VALUE: + { + if (icalvalue_get_method(a) == icalvalue_get_method(b)){ + return ICAL_XLICCOMPARETYPE_EQUAL; + } else { + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + + } + case ICAL_PERIOD_VALUE: + case ICAL_GEO_VALUE: + case ICAL_RECUR_VALUE: + case ICAL_NO_VALUE: + default: + { + icalerror_warn("Comparison not implemented for value type"); + return ICAL_XLICCOMPARETYPE_REGEX+1; /* HACK */ + } + } + +} + +void icalvalue_set_parent(icalvalue* value, + icalproperty* property) +{ + struct icalvalue_impl* v = (struct icalvalue_impl*)value; + + v->parent = property; + +} + +icalproperty* icalvalue_get_parent(icalvalue* value) +{ + struct icalvalue_impl* v = (struct icalvalue_impl*)value; + + + return v->parent; +} + + + +/* 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_ALLOCATION_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); +} + + + + +/* The remaining interfaces are 'new', 'set' and 'get' for each of the value + types */ + + +/* Everything below this line is machine generated. Do not edit. */ + +icalvalue* +icalvalue_new_attach (struct icalattachtype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_ATTACH_VALUE); + + + icalvalue_set_attach((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_attach(icalvalue* value, struct icalattachtype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_ATTACH_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_attach = v; +} + +struct icalattachtype +icalvalue_get_attach(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_ATTACH_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_attach; +} + + +icalvalue* +icalvalue_new_binary (char* v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_BINARY_VALUE); + + icalerror_check_arg_rz( (v!=0),"v"); + + icalvalue_set_binary((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_binary(icalvalue* value, char* v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_value_type(value, ICAL_BINARY_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_string = strdup(v); + + if (impl->data.v_string == 0){ + errno = ENOMEM; + } + +} + +char* +icalvalue_get_binary(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_BINARY_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_string; +} + + +icalvalue* +icalvalue_new_boolean (int v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_BOOLEAN_VALUE); + + + icalvalue_set_boolean((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_boolean(icalvalue* value, int v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_BOOLEAN_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; +} + +int +icalvalue_get_boolean(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_BOOLEAN_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_int; +} + + +icalvalue* +icalvalue_new_caladdress (char* v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_CALADDRESS_VALUE); + + icalerror_check_arg_rz( (v!=0),"v"); + + icalvalue_set_caladdress((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_caladdress(icalvalue* value, char* v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_string = strdup(v); + + if (impl->data.v_string == 0){ + errno = ENOMEM; + } + +} + +char* +icalvalue_get_caladdress(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_string; +} + + +icalvalue* +icalvalue_new_date (struct icaltimetype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATE_VALUE); + + + icalvalue_set_date((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_date(icalvalue* value, struct icaltimetype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_DATE_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; +} + +struct icaltimetype +icalvalue_get_date(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_DATE_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_time; +} + + +icalvalue* +icalvalue_new_datetime (struct icaltimetype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIME_VALUE); + + + icalvalue_set_datetime((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_datetime(icalvalue* value, struct icaltimetype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_DATETIME_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; +} + +struct icaltimetype +icalvalue_get_datetime(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_DATETIME_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_time; +} + + +icalvalue* +icalvalue_new_datetimedate (struct icaltimetype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIMEDATE_VALUE); + + + icalvalue_set_datetimedate((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_datetimedate(icalvalue* value, struct icaltimetype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_DATETIMEDATE_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; +} + +struct icaltimetype +icalvalue_get_datetimedate(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_DATETIMEDATE_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_time; +} + + +icalvalue* +icalvalue_new_datetimeperiod (struct icalperiodtype 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 icalperiodtype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_period = v; +} + +struct icalperiodtype +icalvalue_get_datetimeperiod(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_period; +} + + +icalvalue* +icalvalue_new_duration (struct icaldurationtype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DURATION_VALUE); + + + icalvalue_set_duration((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_duration(icalvalue* value, struct icaldurationtype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_DURATION_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_duration = v; +} + +struct icaldurationtype +icalvalue_get_duration(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_DURATION_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_duration; +} + + +icalvalue* +icalvalue_new_float (float v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_FLOAT_VALUE); + + + icalvalue_set_float((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_float(icalvalue* value, float v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_FLOAT_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_float = v; +} + +float +icalvalue_get_float(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_FLOAT_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_float; +} + + +icalvalue* +icalvalue_new_geo (struct icalgeotype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_GEO_VALUE); + + + icalvalue_set_geo((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_geo(icalvalue* value, struct icalgeotype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_GEO_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_geo = v; +} + +struct icalgeotype +icalvalue_get_geo(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_GEO_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_geo; +} + + +icalvalue* +icalvalue_new_integer (int v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_INTEGER_VALUE); + + + icalvalue_set_integer((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_integer(icalvalue* value, int v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_INTEGER_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; +} + +int +icalvalue_get_integer(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_INTEGER_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_int; +} + + +icalvalue* +icalvalue_new_method (icalproperty_method v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_METHOD_VALUE); + + + icalvalue_set_method((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_method(icalvalue* value, icalproperty_method v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_METHOD_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_method = v; +} + +icalproperty_method +icalvalue_get_method(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_METHOD_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_method; +} + + +icalvalue* +icalvalue_new_period (struct icalperiodtype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_PERIOD_VALUE); + + + icalvalue_set_period((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_period(icalvalue* value, struct icalperiodtype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_PERIOD_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_period = v; +} + +struct icalperiodtype +icalvalue_get_period(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_PERIOD_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_period; +} + + +icalvalue* +icalvalue_new_text (char* v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TEXT_VALUE); + + icalerror_check_arg_rz( (v!=0),"v"); + + icalvalue_set_text((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_text(icalvalue* value, char* v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_value_type(value, ICAL_TEXT_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_string = strdup(v); + + if (impl->data.v_string == 0){ + errno = ENOMEM; + } + +} + +char* +icalvalue_get_text(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_TEXT_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_string; +} + + +icalvalue* +icalvalue_new_time (struct icaltimetype v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TIME_VALUE); + + + icalvalue_set_time((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_time(icalvalue* value, struct icaltimetype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_TIME_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; +} + +struct icaltimetype +icalvalue_get_time(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_TIME_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_time; +} + + +icalvalue* +icalvalue_new_trigger (union 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, union icaltriggertype v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_TRIGGER_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_trigger = v; +} + +union icaltriggertype +icalvalue_get_trigger(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_TRIGGER_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_trigger; +} + + +icalvalue* +icalvalue_new_uri (char* v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_URI_VALUE); + + icalerror_check_arg_rz( (v!=0),"v"); + + icalvalue_set_uri((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_uri(icalvalue* value, char* v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_value_type(value, ICAL_URI_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_string = strdup(v); + + if (impl->data.v_string == 0){ + errno = ENOMEM; + } + +} + +char* +icalvalue_get_uri(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_URI_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_string; +} + + +icalvalue* +icalvalue_new_utcoffset (int v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_UTCOFFSET_VALUE); + + + icalvalue_set_utcoffset((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_utcoffset(icalvalue* value, int v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + + icalerror_check_value_type(value, ICAL_UTCOFFSET_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; +} + +int +icalvalue_get_utcoffset(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_UTCOFFSET_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_int; +} + + +icalvalue* +icalvalue_new_query (char* v) +{ + struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_QUERY_VALUE); + + icalerror_check_arg_rz( (v!=0),"v"); + + icalvalue_set_query((icalvalue*)impl,v); + + return (icalvalue*)impl; +} + +void +icalvalue_set_query(icalvalue* value, char* v) +{ + struct icalvalue_impl* impl; + + icalerror_check_arg_rv( (value!=0),"value"); + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_value_type(value, ICAL_QUERY_VALUE); + + impl = (struct icalvalue_impl*)value; + impl->data.v_string = strdup(v); + + if (impl->data.v_string == 0){ + errno = ENOMEM; + } + +} + +char* +icalvalue_get_query(icalvalue* value) +{ + icalerror_check_arg( (value!=0),"value"); + icalerror_check_value_type(value, ICAL_QUERY_VALUE); + + return ((struct icalvalue_impl*)value)->data.v_string; +} + diff --git a/libical/src/libical/icalvalue.h b/libical/src/libical/icalvalue.h new file mode 100644 index 0000000000..b5a2e6da9e --- /dev/null +++ b/libical/src/libical/icalvalue.h @@ -0,0 +1,164 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalvalue.h + CREATOR: eric 20 March 1999 + + + $Id$ + $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 icalvalue.h + + ======================================================================*/ + +#ifndef ICALVALUE_H +#define ICALVALUE_H + +#include <time.h> +#include "icalenums.h" +#include "icaltypes.h" + +typedef void icalvalue; + +icalvalue* icalvalue_new(icalvalue_kind kind); + +icalvalue* icalvalue_new_clone(icalvalue* value); + +icalvalue* icalvalue_new_from_string(icalvalue_kind kind, char* str); + +void icalvalue_free(icalvalue* value); + +int icalvalue_is_valid(icalvalue* value); + +char* icalvalue_as_ical_string(icalvalue* value); + +icalvalue_kind icalvalue_isa(icalvalue* value); + +int icalvalue_isa_value(void*); + +icalparameter_xliccomparetype +icalvalue_compare(icalvalue* a, icalvalue *b); + +/* Everything below this line is machine generated. Do not edit. */ +/* ATTACH # Non-std */ +icalvalue* icalvalue_new_attach(struct icalattachtype v); +struct icalattachtype icalvalue_get_attach(icalvalue* value); +void icalvalue_set_attach(icalvalue* value, struct icalattachtype v); + +/* BINARY */ +icalvalue* icalvalue_new_binary(char* v); +char* icalvalue_get_binary(icalvalue* value); +void icalvalue_set_binary(icalvalue* value, char* v); + +/* BOOLEAN */ +icalvalue* icalvalue_new_boolean(int v); +int icalvalue_get_boolean(icalvalue* value); +void icalvalue_set_boolean(icalvalue* value, int v); + +/* CAL-ADDRESS */ +icalvalue* icalvalue_new_caladdress(char* v); +char* icalvalue_get_caladdress(icalvalue* value); +void icalvalue_set_caladdress(icalvalue* value, char* v); + +/* DATE */ +icalvalue* icalvalue_new_date(struct icaltimetype v); +struct icaltimetype icalvalue_get_date(icalvalue* value); +void icalvalue_set_date(icalvalue* value, struct icaltimetype v); + +/* DATE-TIME */ +icalvalue* icalvalue_new_datetime(struct icaltimetype v); +struct icaltimetype icalvalue_get_datetime(icalvalue* value); +void icalvalue_set_datetime(icalvalue* value, struct icaltimetype v); + +/* DATE-TIME-DATE # Non-std */ +icalvalue* icalvalue_new_datetimedate(struct icaltimetype v); +struct icaltimetype icalvalue_get_datetimedate(icalvalue* value); +void icalvalue_set_datetimedate(icalvalue* value, struct icaltimetype v); + +/* DATE-TIME-PERIOD # Non-std */ +icalvalue* icalvalue_new_datetimeperiod(struct icalperiodtype v); +struct icalperiodtype icalvalue_get_datetimeperiod(icalvalue* value); +void icalvalue_set_datetimeperiod(icalvalue* value, struct icalperiodtype v); + +/* DURATION */ +icalvalue* icalvalue_new_duration(struct icaldurationtype v); +struct icaldurationtype icalvalue_get_duration(icalvalue* value); +void icalvalue_set_duration(icalvalue* value, struct icaldurationtype v); + +/* FLOAT */ +icalvalue* icalvalue_new_float(float v); +float icalvalue_get_float(icalvalue* value); +void icalvalue_set_float(icalvalue* value, float v); + +/* GEO # Non-std */ +icalvalue* icalvalue_new_geo(struct icalgeotype v); +struct icalgeotype icalvalue_get_geo(icalvalue* value); +void icalvalue_set_geo(icalvalue* value, struct icalgeotype v); + +/* INTEGER */ +icalvalue* icalvalue_new_integer(int v); +int icalvalue_get_integer(icalvalue* value); +void icalvalue_set_integer(icalvalue* value, int v); + +/* METHOD # Non-std */ +icalvalue* icalvalue_new_method(icalproperty_method v); +icalproperty_method icalvalue_get_method(icalvalue* value); +void icalvalue_set_method(icalvalue* value, icalproperty_method v); + +/* PERIOD */ +icalvalue* icalvalue_new_period(struct icalperiodtype v); +struct icalperiodtype icalvalue_get_period(icalvalue* value); +void icalvalue_set_period(icalvalue* value, struct icalperiodtype v); + +/* RECUR */ +icalvalue* icalvalue_new_recur(struct icalrecurrencetype v); +struct icalrecurrencetype icalvalue_get_recur(icalvalue* value); +void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v); + +/* TEXT */ +icalvalue* icalvalue_new_text(char* v); +char* icalvalue_get_text(icalvalue* value); +void icalvalue_set_text(icalvalue* value, char* v); + +/* TIME */ +icalvalue* icalvalue_new_time(struct icaltimetype v); +struct icaltimetype icalvalue_get_time(icalvalue* value); +void icalvalue_set_time(icalvalue* value, struct icaltimetype v); + +/* TRIGGER # Non-std */ +icalvalue* icalvalue_new_trigger(union icaltriggertype v); +union icaltriggertype icalvalue_get_trigger(icalvalue* value); +void icalvalue_set_trigger(icalvalue* value, union icaltriggertype v); + +/* URI */ +icalvalue* icalvalue_new_uri(char* v); +char* icalvalue_get_uri(icalvalue* value); +void icalvalue_set_uri(icalvalue* value, char* v); + +/* UTC-OFFSET */ +icalvalue* icalvalue_new_utcoffset(int v); +int icalvalue_get_utcoffset(icalvalue* value); +void icalvalue_set_utcoffset(icalvalue* value, int v); + +/* QUERY */ +icalvalue* icalvalue_new_query(char* v); +char* icalvalue_get_query(icalvalue* value); +void icalvalue_set_query(icalvalue* value, char* v); + +#endif ICALVALUE_H diff --git a/libical/src/libical/icalvcal.h b/libical/src/libical/icalvcal.h new file mode 100644 index 0000000000..3a1098e6c2 --- /dev/null +++ b/libical/src/libical/icalvcal.h @@ -0,0 +1,39 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalvcal.h + CREATOR: eric 13 January 2000 + + + $Id$ + $Locker$ + + (C) COPYRIGHT 2000 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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + +======================================================================*/ + +#ifndef ICALVCAL_H +#define ICALVCAL_H + +VCalObject* icalvcal_new_vcal_from_ical(icalcomponent* component); +icalcomponent* icalvcal_new_ical_from_vcal(VCalObject* vcal); + + +#endif /* !ICALVCAL_H */ + + + diff --git a/libical/src/libical/lex.yy.c b/libical/src/libical/lex.yy.c new file mode 100644 index 0000000000..8874bb12d9 --- /dev/null +++ b/libical/src/libical/lex.yy.c @@ -0,0 +1,2164 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> +#include <unistd.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char yytext[]; + + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + if ( yyleng >= YYLMAX ) \ + YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \ + yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 63 +#define YY_END_OF_BUFFER 64 +static yyconst short int yy_accept[229] = + { 0, + 0, 0, 0, 0, 1, 1, 0, 0, 5, 5, + 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 64, 63, 1, 2, 1, 3, + 4, 3, 5, 6, 5, 10, 63, 7, 8, 9, + 14, 63, 13, 11, 12, 16, 63, 15, 21, 63, + 20, 17, 18, 19, 56, 63, 53, 51, 52, 50, + 63, 63, 63, 63, 63, 63, 63, 63, 54, 63, + 63, 63, 55, 57, 63, 58, 63, 60, 61, 60, + + 62, 1, 2, 4, 5, 6, 10, 7, 14, 11, + 16, 15, 21, 17, 56, 53, 0, 0, 0, 49, + 0, 0, 0, 43, 44, 0, 45, 48, 46, 0, + 47, 0, 0, 57, 59, 61, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, + 0, 42, 0, 26, 0, 0, 0, 0, 0, 0, + 0, 23, 35, 0, 0, 0, 0, 0, 24, 0, + 0, 27, 0, 0, 0, 0, 0, 0, 38, 0, + + 0, 0, 0, 40, 41, 0, 29, 0, 0, 0, + 0, 0, 0, 39, 0, 28, 0, 31, 32, 33, + 0, 22, 37, 36, 0, 34, 30, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 4, 5, 6, 7, 8, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 1, 10, 1, + 11, 1, 1, 1, 12, 13, 14, 15, 16, 17, + 1, 18, 19, 1, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 1, 33, 34, + 1, 1, 1, 1, 1, 1, 12, 13, 14, 15, + + 16, 17, 1, 18, 19, 1, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 1, + 33, 34, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[35] = + { 0, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1 + } ; + +static yyconst short int yy_base[236] = + { 0, + 0, 0, 0, 0, 0, 2, 4, 6, 8, 10, + 12, 14, 47, 0, 78, 86, 94, 0, 128, 0, + 0, 0, 16, 24, 29, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 257, 256, 0, 0, + 0, 0, 0, 0, 260, 263, 0, 263, 257, 263, + 263, 256, 0, 263, 255, 263, 254, 246, 263, 263, + 263, 252, 263, 244, 263, 263, 250, 33, 263, 249, + 263, 241, 263, 263, 263, 247, 48, 263, 263, 263, + 215, 223, 234, 218, 220, 220, 5, 43, 40, 219, + 44, 225, 263, 263, 238, 263, 230, 263, 263, 236, + + 263, 0, 263, 263, 0, 263, 263, 228, 263, 227, + 263, 101, 263, 226, 263, 57, 148, 204, 214, 216, + 201, 201, 206, 205, 263, 213, 263, 263, 263, 197, + 209, 196, 211, 263, 263, 263, 210, 197, 59, 204, + 203, 202, 194, 195, 189, 187, 197, 182, 182, 186, + 190, 188, 178, 179, 172, 174, 180, 179, 57, 185, + 188, 170, 165, 263, 176, 169, 166, 176, 170, 171, + 158, 263, 157, 263, 150, 145, 145, 149, 147, 151, + 142, 263, 263, 135, 136, 149, 143, 112, 263, 92, + 91, 263, 92, 102, 95, 93, 92, 99, 263, 101, + + 90, 73, 83, 263, 263, 85, 84, 79, 63, 53, + 62, 47, 34, 263, 14, 263, 33, 263, 263, 263, + 11, 263, 263, 263, 5, 263, 263, 263, 181, 183, + 185, 187, 189, 35, 0 + } ; + +static yyconst short int yy_def[236] = + { 0, + 229, 229, 229, 229, 230, 230, 231, 231, 232, 232, + 229, 229, 229, 13, 229, 229, 229, 17, 228, 19, + 229, 229, 229, 229, 233, 233, 229, 229, 229, 229, + 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, + 229, 229, 229, 229, 228, 228, 234, 228, 234, 228, + 228, 228, 235, 228, 235, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + + 228, 234, 228, 228, 235, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 0, 228, 228, + 228, 228, 228, 228, 228 + } ; + +static yyconst short int yy_nxt[298] = + { 0, + 105, 48, 49, 48, 49, 51, 52, 51, 52, 54, + 55, 54, 55, 56, 57, 56, 57, 94, 95, 96, + 58, 96, 58, 123, 97, 94, 95, 96, 124, 96, + 99, 100, 97, 99, 100, 102, 112, 227, 112, 112, + 59, 112, 59, 226, 225, 60, 224, 60, 61, 62, + 63, 116, 63, 116, 125, 64, 116, 128, 126, 131, + 116, 63, 116, 132, 63, 116, 223, 222, 63, 129, + 178, 63, 127, 221, 63, 65, 220, 157, 63, 66, + 67, 68, 158, 68, 68, 179, 68, 66, 67, 68, + 219, 68, 68, 218, 68, 69, 70, 71, 217, 71, + + 216, 71, 72, 215, 112, 214, 112, 112, 71, 112, + 213, 71, 212, 211, 210, 71, 209, 208, 71, 207, + 206, 71, 73, 205, 204, 71, 203, 74, 46, 75, + 76, 77, 78, 77, 46, 46, 77, 79, 80, 46, + 81, 82, 83, 46, 84, 85, 86, 46, 46, 87, + 46, 46, 46, 46, 46, 88, 89, 90, 46, 91, + 92, 93, 137, 202, 201, 138, 200, 199, 198, 139, + 197, 196, 195, 194, 193, 140, 192, 191, 190, 141, + 142, 46, 46, 47, 47, 50, 50, 53, 53, 98, + 98, 189, 188, 187, 186, 185, 184, 183, 182, 181, + + 180, 177, 176, 175, 174, 173, 172, 171, 170, 169, + 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, + 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, + 146, 145, 144, 143, 114, 110, 108, 136, 135, 134, + 133, 130, 122, 121, 120, 119, 118, 117, 115, 114, + 113, 111, 110, 109, 108, 107, 106, 104, 103, 228, + 101, 101, 45, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228 + + } ; + +static yyconst short int yy_chk[298] = + { 0, + 235, 5, 5, 6, 6, 7, 7, 8, 8, 9, + 9, 10, 10, 11, 11, 12, 12, 23, 23, 23, + 11, 23, 12, 87, 23, 24, 24, 24, 87, 24, + 25, 25, 24, 26, 26, 234, 68, 225, 68, 68, + 11, 68, 12, 221, 217, 11, 215, 12, 13, 13, + 13, 77, 13, 77, 88, 13, 77, 89, 88, 91, + 116, 13, 116, 91, 13, 116, 213, 212, 13, 89, + 159, 13, 88, 211, 13, 13, 210, 139, 13, 15, + 15, 15, 139, 15, 15, 159, 15, 16, 16, 16, + 209, 16, 16, 208, 16, 17, 17, 17, 207, 17, + + 206, 17, 17, 203, 112, 202, 112, 112, 17, 112, + 201, 17, 200, 198, 197, 17, 196, 195, 17, 194, + 193, 17, 17, 191, 190, 17, 188, 17, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 117, 187, 186, 117, 185, 184, 181, 117, + 180, 179, 178, 177, 176, 117, 175, 173, 171, 117, + 117, 229, 229, 230, 230, 231, 231, 232, 232, 233, + 233, 170, 169, 168, 167, 166, 165, 163, 162, 161, + + 160, 158, 157, 156, 155, 154, 153, 152, 151, 150, + 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, + 138, 137, 133, 132, 131, 130, 126, 124, 123, 122, + 121, 120, 119, 118, 114, 110, 108, 100, 97, 95, + 92, 90, 86, 85, 84, 83, 82, 81, 76, 72, + 70, 67, 64, 62, 58, 57, 55, 52, 49, 45, + 38, 37, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, + 228, 228, 228, 228, 228, 228, 228 + + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +#ifndef YYLMAX +#define YYLMAX 8192 +#endif + +char yytext[YYLMAX]; +char *yytext_ptr; +#line 1 "icalitip.l" +#define INITIAL 0 +#line 2 "icalitip.l" +/* -*- Mode: C -*- + ====================================================================== + FILE: icalitip.y + CREATOR: eric 10 June 1999 + + DESCRIPTION: + + $Id$ + $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 "icalitip.tab.h" +#include "icalparser.h" +#include "icalenums.h" +#include "icalmemory.h" +#include "assert.h" + +#include <string.h> /* For strdup() */ + +#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) yyerror(msg) + +icalvalue_kind value_kind=ICAL_NO_VALUE; +void set_parser_value_state(); +extern enum icalparser_state_enum icalparser_state; +extern int yydebug; + +void yyerror(char *s); + +void init_str_buf(); + +int last_state; + +char *str_buf; +char *str_buf_p; +size_t buf_sz; /* = ICAL_MAX_STR_CONST;*/ + + +#define quoted_string 1 + +#define binary_value 2 +#define boolean_value 3 +#define uri_value 4 +#define time_value 5 +#define duration_value 6 +#define number_value 7 +#define period_value 8 +#define recur_value 9 +#define text_value 10 +#define utcoffset_value 11 + +#define enum_param_value 12 +#define string_param_value 13 +#define stringlist_param_value 14 +#define keyword 15 +#define line_start 16 +#define component 17 +#define seperator 18 +#define parameter 19 +#define end_of_value 20 +#define paramtext 21 + +#line 599 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 92 "icalitip.l" + + + + + + +#line 757 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 229 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 263 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + + +case 1: +YY_RULE_SETUP +#line 99 "icalitip.l" +{ yylval.v_string= icalmemory_tmp_copy(yytext); + return STRING;} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 101 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 3: +YY_RULE_SETUP +#line 106 "icalitip.l" +{ return CHARACTER; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 107 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 5: +YY_RULE_SETUP +#line 112 "icalitip.l" +{ yylval.v_string= icalmemory_tmp_copy(yytext); + return STRING;} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 114 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 7: +YY_RULE_SETUP +#line 120 "icalitip.l" +{ yylval.v_string= icalmemory_tmp_copy(yytext); + return DIGITS; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 122 "icalitip.l" +{ return TIME_CHAR; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 123 "icalitip.l" +{ return UTC_CHAR; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 124 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 11: +YY_RULE_SETUP +#line 128 "icalitip.l" +{ yylval.v_string =icalmemory_tmp_copy(yytext); + return DIGITS; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 130 "icalitip.l" +{ return TIME_CHAR; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 131 "icalitip.l" +{ return yytext[0]; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 132 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 15: +YY_RULE_SETUP +#line 137 "icalitip.l" +{ yylval.v_int=atoi(yytext); return INTNUMBER; } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 138 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 17: +YY_RULE_SETUP +#line 142 "icalitip.l" +{ yylval.v_string =icalmemory_tmp_copy(yytext) ; + return DIGITS; } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 144 "icalitip.l" +{ return TIME_CHAR; } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 145 "icalitip.l" +{ return UTC_CHAR; } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 146 "icalitip.l" +{ return yytext[0]; } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 147 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 22: +YY_RULE_SETUP +#line 152 "icalitip.l" +{ return INTERVAL; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 153 "icalitip.l" +{ return COUNT; } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 154 "icalitip.l" +{ return UNTIL; } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 155 "icalitip.l" +{ return FREQ; } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 156 "icalitip.l" +{ return BYDAY; } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 157 "icalitip.l" +{ return BYHOUR; } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 158 "icalitip.l" +{ return BYMINUTE; } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 159 "icalitip.l" +{ return BYMONTH; } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 160 "icalitip.l" +{ return BYMONTHDAY; } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 161 "icalitip.l" +{ return BYSECOND; } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 162 "icalitip.l" +{ return BYSETPOS; } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 163 "icalitip.l" +{ return BYWEEKNO; } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 164 "icalitip.l" +{ return BYYEARDAY; } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 165 "icalitip.l" +{ return DAILY; } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 166 "icalitip.l" +{ return SECONDLY; } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 167 "icalitip.l" +{ return MINUTELY; } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 168 "icalitip.l" +{ return HOURLY; } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 169 "icalitip.l" +{ return MONTHLY; } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 170 "icalitip.l" +{ return WEEKLY; } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 171 "icalitip.l" +{ return YEARLY; } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 172 "icalitip.l" +{ return WKST; } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 173 "icalitip.l" +{ return MO; } + YY_BREAK +case 44: +YY_RULE_SETUP +#line 174 "icalitip.l" +{ return SA; } + YY_BREAK +case 45: +YY_RULE_SETUP +#line 175 "icalitip.l" +{ return SU; } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 176 "icalitip.l" +{ return TU; } + YY_BREAK +case 47: +YY_RULE_SETUP +#line 177 "icalitip.l" +{ return WE; } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 178 "icalitip.l" +{ return TH; } + YY_BREAK +case 49: +YY_RULE_SETUP +#line 179 "icalitip.l" +{ return FR; } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 180 "icalitip.l" +{ return EQUALS; } + YY_BREAK +case 51: +YY_RULE_SETUP +#line 181 "icalitip.l" +{ return COMMA; } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 182 "icalitip.l" +{ return SEMICOLON; } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 183 "icalitip.l" +{ yylval.v_string= icalmemory_tmp_copy(yytext); + return DIGITS; } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 185 "icalitip.l" +{ return TIME_CHAR; } + YY_BREAK +case 55: +YY_RULE_SETUP +#line 186 "icalitip.l" +{ return UTC_CHAR; } + YY_BREAK +case 56: +YY_RULE_SETUP +#line 187 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 57: +YY_RULE_SETUP +#line 191 "icalitip.l" +{ return EOL;} + YY_BREAK +case 58: +YY_RULE_SETUP +#line 192 "icalitip.l" +{ return yytext[0]; } + YY_BREAK +case 59: +YY_RULE_SETUP +#line 193 "icalitip.l" +{ yylval.v_int=atoi(yytext); return INTNUMBER; } + YY_BREAK + + +case 60: +YY_RULE_SETUP +#line 198 "icalitip.l" +{ return CHARACTER; } + YY_BREAK +case 61: +YY_RULE_SETUP +#line 199 "icalitip.l" +{ return EOL;} + YY_BREAK + + +case 62: +YY_RULE_SETUP +#line 204 "icalitip.l" +{ BEGIN(last_state); return COMMA; } + YY_BREAK + +case 63: +YY_RULE_SETUP +#line 208 "icalitip.l" +YY_FATAL_ERROR( "flex scanner jammed" ); + YY_BREAK +#line 1183 "lex.yy.c" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(quoted_string): +case YY_STATE_EOF(binary_value): +case YY_STATE_EOF(boolean_value): +case YY_STATE_EOF(uri_value): +case YY_STATE_EOF(time_value): +case YY_STATE_EOF(duration_value): +case YY_STATE_EOF(number_value): +case YY_STATE_EOF(period_value): +case YY_STATE_EOF(recur_value): +case YY_STATE_EOF(text_value): +case YY_STATE_EOF(utcoffset_value): +case YY_STATE_EOF(enum_param_value): +case YY_STATE_EOF(string_param_value): +case YY_STATE_EOF(stringlist_param_value): +case YY_STATE_EOF(keyword): +case YY_STATE_EOF(line_start): +case YY_STATE_EOF(component): +case YY_STATE_EOF(seperator): +case YY_STATE_EOF(parameter): +case YY_STATE_EOF(end_of_value): +case YY_STATE_EOF(paramtext): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 229 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 229 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 228); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 208 "icalitip.l" + + +int yywrap() +{ + return 1; +} + + +void set_parser_value_state(icalvalue_kind kind) +{ + + switch (kind){ + + case ICAL_ATTACH_VALUE: + case ICAL_BINARY_VALUE: + {BEGIN(binary_value);break;} + + case ICAL_BOOLEAN_VALUE: + case ICAL_INTEGER_VALUE: + case ICAL_FLOAT_VALUE: + {BEGIN(number_value);break;} + + case ICAL_UTCOFFSET_VALUE: + {BEGIN(utcoffset_value);break;} + + case ICAL_TEXT_VALUE: + {BEGIN(text_value); + init_str_buf(); + break;} + + case ICAL_CALADDRESS_VALUE: + case ICAL_URI_VALUE: + {BEGIN(uri_value);break;} + + case ICAL_DATE_VALUE: + case ICAL_DATETIME_VALUE: + case ICAL_DATETIMEDATE_VALUE: + case ICAL_DATETIMEPERIOD_VALUE: + case ICAL_TIME_VALUE: + {BEGIN(time_value);break;} + + case ICAL_DURATION_VALUE: + {BEGIN(duration_value);break;} + + case ICAL_PERIOD_VALUE: + {BEGIN(period_value);break;} + + case ICAL_GEO_VALUE: + case ICAL_QUERY_VALUE: + {BEGIN(text_value);break;} + + case ICAL_RECUR_VALUE: + {BEGIN(recur_value);break;} + + case ICAL_NO_VALUE: + { + /* The value is probably actually a component name */ + {BEGIN(component); break;} + } + default: + { + assert(1==0); + } + } +} + +void init_str_buf() +{ + str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST); + str_buf_p = str_buf; + buf_sz = ICAL_MAX_STR_CONST; + + +} + diff --git a/libical/src/libical/locking.c b/libical/src/libical/locking.c new file mode 100644 index 0000000000..f38873cf70 --- /dev/null +++ b/libical/src/libical/locking.c @@ -0,0 +1,142 @@ + +/* + I Stole this from: + http://www.cis.temple.edu/~ingargio/old/cis307s96/readings/rwlockexample.html + + CIS 307: An example using Read/Write File Locks + [fcntl.h], [fcntl.c], [fcntlmain.c] + +In Stevens "Advanced Programming in the Unix Environment" we see ways to use +the Unix service fcntl to lock portions of a file for reading and writing in +the manner stated in the Reader and Writer problem [any number of readers at +a time, but writers must operate alone]. Here we have three files that adapt +and use the code from Stevens: + +*fcntl.h: Specification of the locking functions. +*fcntl.c: Implementation of the locking functions. +*fcntlmain.c: Driver that does a simple test of the locking functions. + +WARNING: A file lock request which is blocked can be interrupted by a +signal. In this case the lock operation returns EINTR. Thus we may think we +got a lock when we really don't. A solution is to block signals when +locking. Another solution is to test the value returned by the lock +operation and relock if the value is EINTR. Another solution, which we adopt +here, is to do nothing about it. + +/* fcntl.c -- Defines mutexes in terms of read/write locks on files. + * (code is mostly from Stevens: Advanced Programming in the + * Unix environment. See from page 367 on. + * filerwlock, filerwlockCreate, filerwlockDelete, + * filerwreadlock, filerwlongreadlock, filerwlongunlock, + * filerwlockUnlock + */ + +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> + +int lock_reg(int, int, int, off_t, int, off_t); + +#define read_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, len) + +#define readw_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_RDLCK, offset, whence, len) + +#define write_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, len) + +#define writew_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLKW, F_WRLCK, offset, whence, len) + +#define un_lock(fd, offset, whence, len) \ + lock_reg(fd, F_SETLK, F_UNLCK, offset, whence, len) + +pid_t lock_test(int, int , off_t , int , off_t ); + +#define is_readlock(fd, offset, whence, len) \ + lock_test(fd, F_RDLCK, offset, whence, len) + +#define is_writelock(fd, offset, whence, len) \ + lock_test(fd, F_WRLCK, offset, whence, len) + +int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len) +{ + struct flock lock; + lock.l_type = type; /* F_RDLCK, F_WRLCK, F_UNLCK */ + lock.l_start = offset; /* byte offset relative to l_whence */ + lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */ + lock.l_len = len; /* #bytes (0 means to EOF) */ + return (fcntl(fd, cmd, &lock)); +} + +pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len) +{ + struct flock lock; + lock.l_type = type; /* F_RDLCK or F_WRLCK */ + lock.l_start = offset; /* byte offset relative to l_whence */ + lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */ + lock.l_len = len; /* #bytes (0 means to EOF) */ + if (fcntl(fd,F_GETLK,&lock) < 0){ + perror("fcntl"); exit(1);} + if (lock.l_type == F_UNLCK) + return (0); /* false, region is not locked by another process */ + return (lock.l_pid); /* true, return pid of lock owner */ +} + +typedef struct { + int fd; + int n;} filerwlock; + +/* Create N read/write locks and returns the id of this cluster of locks. */ +filerwlock * filerwlockCreate(char *filename, int n) { + filerwlock *fl = (filerwlock *)malloc(sizeof(filerwlock)); + if (((fl->fd) = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IWUSR)) < 0) { + perror("open"); + exit(1);} + fl->n = n; + return fl; + } + +/* Delete the cluster of read/write locks associated with fl. */ +int filerwlockDelete(filerwlock *fl) { + if (close(fl->fd) < 0) { + perror("close"); + exit(1);} + return free(fl); + } + +/* Given the read/write lock cluster fl, lock its ith element */ +int filerwreadlock(filerwlock *fl, int i) { + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockLock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + readw_lock(fl->fd, i, SEEK_SET, 1); + } + +int filerwwritelock(filerwlock *fl, int i) { + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockLock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + writew_lock(fl->fd, i, SEEK_SET, 1); + } + +/* Given the lock cluster fl, unlock its ith element */ +int filerwunlock(filerwlock *fl, int i){ + + if ((i < 0) | (i >= fl->n)) { + printf("filerwlockUnlock needs i in range 0 .. %d\n", (fl->n)-1); + exit(0);} + un_lock(fl->fd, i, SEEK_SET, 1); + } + +/* Given the lock cluster fl, it read locks all its elements */ +int filerwlongreadlock(filerwlock *fl) { + readw_lock(fl->fd, 0, SEEK_SET, fl->n); +} + +/* Given the lock cluster fl, it unlocks all its elements */ +int filerwlongunlock(filerwlock *fl) { + un_lock(fl->fd, 0, SEEK_SET, fl->n); +} + diff --git a/libical/src/libical/pvl.c b/libical/src/libical/pvl.c new file mode 100644 index 0000000000..b88272a6a0 --- /dev/null +++ b/libical/src/libical/pvl.c @@ -0,0 +1,764 @@ +/*====================================================================== + FILE: pvl.c + CREATOR: eric November, 1995 + + + (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. +======================================================================*/ + +#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; + + 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; + + 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); + } + +} diff --git a/libical/src/libical/pvl.h b/libical/src/libical/pvl.h new file mode 100644 index 0000000000..8113f7495a --- /dev/null +++ b/libical/src/libical/pvl.h @@ -0,0 +1,104 @@ +/*====================================================================== + FILE: pvl.h + CREATOR: eric November, 1995 + + + (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. + +======================================================================*/ + +/* + struct pvl_elem_t + + This type is private. Always use pvl_elem instead + + */ + +#ifndef __PVL_H__ +#define __PVL_H__ + +typedef void* pvl_list; +typedef void* pvl_elem; + +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 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__ */ + + + + + diff --git a/libical/src/libical/testlocks.c b/libical/src/libical/testlocks.c new file mode 100644 index 0000000000..d3e9e55cec --- /dev/null +++ b/libical/src/libical/testlocks.c @@ -0,0 +1,70 @@ +/* This is just a driver to test the filerwlock objects defined in fcntl.c */ +/* MAXCHILD processes are forked. They take turns in using LOCKSSIZE locks.*/ +/* I compiled the program as follows */ +/* cc fcntlmain.c fcntl.c -o fcntlmain */ +/* and then run the image fcntlmain. */ +/* Notice that after the program has run I find the file "mylock" in my */ +/* directory. Not very desirable. Perhaps there is a way to avoid that? */ + +#include <stdio.h> +#include <sys/types.h> +#include "fcntl.h" + +#define LOCKFILE "mylock" +#define LOCKSSIZE 5 +#define MAXCHILD 4 + +void child (int self); + +pid_t cldrn[4]; +filerwlock *fl; + +int +main(void){ + int i; + + fl = filerwlockCreate(LOCKFILE, LOCKSSIZE); + + for (i=0;i < MAXCHILD; i++) { + if ((cldrn[i]=fork()) < 0) { + perror("fork"); + exit(1);} + if (cldrn[i]==0) + child(i); + } + for (i=0; i < MAXCHILD; i++) + wait(); + + filerwlockDelete(fl); + exit(0); +} + +void child (int self) { + int i, j; + char s[256]; + for (j=0; j<8; j++) { + + if (self == 0) { + filerwwritelock(fl,1); + } else if (self == (MAXCHILD-1)) { + filerwlongreadlock(fl); + } else { + filerwreadlock(fl,1); + } + + printf("Child %d starts to sleep on lock %d\n", self, 1); + + sleep(3); + + printf("Child %d ends sleep on lock %d\n", self, 1); + + if (self == (MAXCHILD-1)) { + filerwlongunlock(fl); + } else { + filerwunlock(fl,1); + } + + sleep(1); + } + exit(0); +} diff --git a/libical/src/libicalss/Makefile b/libical/src/libicalss/Makefile new file mode 100644 index 0000000000..91691b9051 --- /dev/null +++ b/libical/src/libicalss/Makefile @@ -0,0 +1,49 @@ +# Generated automatically from Makefile.in by configure. +SOURCES = icalcluster.c icalstore.c icalcalendar.c +OBJECTS = ${SOURCES:.c=.o} +INCLUDES = -I . -I.. -I../libical +CFLAGS = -Wall -g $(INCLUDES) -DSTDC_HEADERS=1 -DHAVE_MALLOC_H=1 -DHAVE_UNISTD_H=1 -DHAVE_TIME_H=1 -DHAVE_STDIO_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_ASSERT_H=1 -DHAVE_STRDUP=1 -DICAL_ERRORS_ARE_FATAL +LIBS = +CC = gcc +AR = ar cr +RANLIB = ranlib + +prefix = /usr/local +PREFIX = ${prefix} +EXEC_PREFIX = ${prefix} +BIN_DIR = $(EXEC_PREFIX)/bin +LIB_DIR = $(EXEC_PREFIX)/lib +INCLUDE_DIR = $(PREFIX)/include + +INSTALL = /usr/bin/install -c +INSTALL_DATA = ${INSTALL} -m 644 +INSTALL_PROGRAM= ${INSTALL} -m 755 + +all: lib + +lib: $(OBJECTS) + $(AR) libicalss.a $(OBJECTS) + $(RANLIB) libicalss.a + + +clean: + -/bin/rm -f *.o *.a + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -f icaltest parser core output *.output + +ci: clean + ci -u *.c *.h *.l *.y Makefile.in + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + + +install: + $(INSTALL_DATA) libicalss.a $(LIB_DIR)/libicalss.a; + for i in `ls *.h`; \ + do \ + $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \ + done; + + diff --git a/libical/src/libicalss/Makefile.in b/libical/src/libicalss/Makefile.in new file mode 100644 index 0000000000..fe4de906ad --- /dev/null +++ b/libical/src/libicalss/Makefile.in @@ -0,0 +1,48 @@ +SOURCES = icalcluster.c icalstore.c icalcalendar.c +OBJECTS = ${SOURCES:.c=.o} +INCLUDES = -I . -I.. -I../libical +CFLAGS = -Wall @CFLAGS@ $(INCLUDES) @DEFS@ -DICAL_ERRORS_ARE_FATAL +LIBS = +CC = @CC@ +AR = @AR@ cr +RANLIB = @RANLIB@ + +prefix = @prefix@ +PREFIX = ${prefix} +EXEC_PREFIX = @exec_prefix@ +BIN_DIR = $(EXEC_PREFIX)/bin +LIB_DIR = $(EXEC_PREFIX)/lib +INCLUDE_DIR = $(PREFIX)/include + +INSTALL = @INSTALL@ +INSTALL_DATA = ${INSTALL} -m 644 +INSTALL_PROGRAM= ${INSTALL} -m 755 + +all: lib + +lib: $(OBJECTS) + $(AR) libicalss.a $(OBJECTS) + $(RANLIB) libicalss.a + + +clean: + -/bin/rm -f *.o *.a + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -f icaltest parser core output *.output + +ci: clean + ci -u *.c *.h *.l *.y Makefile.in + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + + +install: + $(INSTALL_DATA) libicalss.a $(LIB_DIR)/libicalss.a; + for i in `ls *.h`; \ + do \ + $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \ + done; + + diff --git a/libical/src/libicalss/icalcalendar.c b/libical/src/libicalss/icalcalendar.c new file mode 100644 index 0000000000..0933df1e31 --- /dev/null +++ b/libical/src/libicalss/icalcalendar.c @@ -0,0 +1,263 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalcalendar.c + CREATOR: eric 23 December 1999 + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + + ======================================================================*/ + + +#include "icalcalendar.h" +#include "icalcluster.h" +#include <limits.h> +#include <sys/stat.h> /* For mkdir, stat */ +#include <sys/types.h> /* For mkdir */ +#include <fcntl.h> /* For mkdir */ +#include <unistd.h> /* For mkdir, stat */ +#include <stdlib.h> /* for malloc */ +#include <string.h> /* for strcat */ +#include <errno.h> + +#define BOOKED_DIR "booked" +#define INCOMING_FILE "incoming.ics" +#define PROP_FILE "properties.ics" +#define FBLIST_FILE "freebusy.ics" + +struct icalcalendar_impl +{ + char* dir; + icalcomponent* freebusy; + icalcomponent* properties; + icalstore* booked; + icalstore* incoming; +}; + +struct icalcalendar_impl* icalcalendar_new_impl() +{ + struct icalcalendar_impl* impl; + + if ( ( impl = (struct icalcalendar_impl*) + malloc(sizeof(struct icalcalendar_impl))) == 0) { + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + return impl; +} + + +icalerrorenum icalcalendar_create(struct icalcalendar_impl* impl) +{ + char path[PATH_MAX]; + struct stat sbuf; + int r; + + icalerror_check_arg_re((impl != 0),"impl",ICAL_BADARG_ERROR); + + path[0] = '\0'; + strcpy(path,impl->dir); + strcat(path,"/"); + strcat(path,BOOKED_DIR); + + r = stat(path,&sbuf); + + if( r != 0 && errno == ENOENT){ + + if(mkdir(path,0777)!=0){ + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + } + + return ICAL_NO_ERROR; +} + +icalcalendar* icalcalendar_new(char* dir) +{ + struct icalcalendar_impl* impl; + + icalerror_check_arg_rz((dir != 0),"dir"); + + impl = icalcalendar_new_impl(); + + if (impl == 0){ + return 0; + } + + impl->dir = (char*)strdup(dir); + impl->freebusy = 0; + impl->properties = 0; + impl->booked = 0; + impl->incoming = 0; + + if (icalcalendar_create(impl) != ICAL_NO_ERROR){ + free(impl); + return 0; + } + + return impl; +} + +void icalcalendar_free(icalcalendar* calendar) +{ + + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + + if (impl->dir !=0){ + free(impl->dir); + } + + if (impl->freebusy !=0){ + icalcluster_free(impl->freebusy); + } + + if (impl->properties !=0){ + icalcluster_free(impl->properties); + } + + if (impl->booked !=0){ + icalstore_free(impl->booked); + } + + if (impl->incoming !=0){ + icalstore_free(impl->incoming); + } + + impl->dir = 0; + impl->freebusy = 0; + impl->properties = 0; + impl->booked = 0; + impl->incoming = 0; + + + free(impl); +} + + +int icalcalendar_lock(icalcalendar* calendar) +{ + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + return 0; +} + +int icalcalendar_unlock(icalcalendar* calendar) +{ + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + return 0; +} + +int icalcalendar_islocked(icalcalendar* calendar) +{ + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + return 0; +} + +int icalcalendar_ownlock(icalcalendar* calendar) +{ + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + return 0; +} + +icalstore* icalcalendar_get_booked(icalcalendar* calendar) +{ + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + char dir[PATH_MAX]; + + icalerror_check_arg_rz((impl != 0),"impl"); + + dir[0] = '\0'; + strcpy(dir,impl->dir); + strcat(dir,"/"); + strcat(dir,BOOKED_DIR); + + if (impl->booked == 0){ + icalerror_clear_errno(); + impl->booked = icalstore_new(dir); + assert(icalerrno == ICAL_NO_ERROR); + } + + return impl->booked; + +} + +icalcluster* icalcalendar_get_incoming(icalcalendar* calendar) +{ + char path[PATH_MAX]; + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + + path[0] = '\0'; + strcpy(path,impl->dir); + strcat(path,"/"); + strcat(path,INCOMING_FILE); + + if (impl->properties == 0){ + impl->properties = icalcluster_new(path); + } + + return impl->properties; +} + +icalcluster* icalcalendar_get_properties(icalcalendar* calendar) +{ + char path[PATH_MAX]; + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + + path[0] = '\0'; + strcpy(path,impl->dir); + strcat(path,"/"); + strcat(path,PROP_FILE); + + if (impl->properties == 0){ + impl->properties = icalcluster_new(path); + } + + return impl->properties; +} + +icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar) +{ + char path[PATH_MAX]; + struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; + icalerror_check_arg_rz((impl != 0),"impl"); + + path[0] = '\0'; + strcpy(path,impl->dir); + strcat(path,"/"); + strcat(path,FBLIST_FILE); + + + if (impl->freebusy == 0){ + impl->freebusy = icalcluster_new(path); + } + + return impl->freebusy; +} + + + + diff --git a/libical/src/libicalss/icalcalendar.h b/libical/src/libicalss/icalcalendar.h new file mode 100644 index 0000000000..90e7b33c22 --- /dev/null +++ b/libical/src/libicalss/icalcalendar.h @@ -0,0 +1,68 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalcalendar.h + CREATOR: eric 23 December 1999 + + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + +======================================================================*/ + +#ifndef ICALCALENDAR_H +#define ICALCALENDAR_H + +#include "ical.h" +#include "icalstore.h" +#include "icalcluster.h" + +/* icalcalendar + * Routines for storing calendar data in a file system. The calendar + * has two icalstores, one for incoming components and one for booked + * components. It also has interfaces to access the free/busy list + * and a list of calendar properties */ + +typedef void icalcalendar; + +icalcalendar* icalcalendar_new(char* dir); + +void icalcalendar_free(icalcalendar* calendar); + +int icalcalendar_lock(icalcalendar* calendar); + +int icalcalendar_unlock(icalcalendar* calendar); + +int icalcalendar_islocked(icalcalendar* calendar); + +int icalcalendar_ownlock(icalcalendar* calendar); + +icalstore* icalcalendar_get_booked(icalcalendar* calendar); + +icalcluster* icalcalendar_get_incoming(icalcalendar* calendar); + +icalcluster* icalcalendar_get_properties(icalcalendar* calendar); + +icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar); + + +#endif /* !ICALCALENDAR_H */ + + + diff --git a/libical/src/libicalss/icalcluster.c b/libical/src/libicalss/icalcluster.c new file mode 100644 index 0000000000..00e7ef0365 --- /dev/null +++ b/libical/src/libicalss/icalcluster.c @@ -0,0 +1,399 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalcluster.c + CREATOR: eric 23 December 1999 + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + + ======================================================================*/ + + +#include "icalcluster.h" +#include <errno.h> +#include <limits.h> /* For PATH_MAX */ +#include <sys/stat.h> /* for stat */ +#include <unistd.h> /* for stat, getpid */ +#include <stdlib.h> +#include <string.h> + +struct icalcluster_impl { + char *path; + icalcomponent* cluster; + int changed; +}; + +icalcluster* icalcluster_new_impl() +{ + struct icalcluster_impl* comp; + + if ( ( comp = (struct icalcluster_impl*) + malloc(sizeof(struct icalcluster_impl))) == 0) { + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + errno = ENOMEM; + return 0; + } + + return comp; +} + +icalerrorenum icalcluster_create_cluster(char *path) +{ + + FILE* f; + int r; + icalcomponent *c; + struct icaltimetype tt; + + icalerror_clear_errno(); + + f = fopen(path,"w"); + + if (f == 0){ + fclose(f); + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + + /* Create the root component in the cluster. This component holds + all of the other components and stores a count of + components. */ + + memset(&tt,0,sizeof(struct icaltimetype)); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_xlicclustercount(0), + icalproperty_new_dtstart(tt), /* dtstart of earliest comp */ + icalproperty_new_dtend(tt), /* dtend of latest comp, excl. recuring */ + 0 + ); + + if (c == 0){ + fclose(f); + icalerror_set_errno(ICAL_INTERNAL_ERROR); + return ICAL_INTERNAL_ERROR; + } + + + /* Write the base component to the file */ + r = fputs(icalcomponent_as_ical_string(c),f); + + fclose(f); + + icalcomponent_free(c); + + if (r == EOF){ + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + + return ICAL_NO_ERROR; +} + +FILE* parser_file; /*HACK. Not Thread Safe */ +char* read_from_file(char *s, size_t size) +{ + char *c = fgets(s,size, parser_file); + return c; +} + +icalerrorenum icalcluster_load(icalcluster* cluster, char* path) +{ + struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster; + icalerrorenum error; + errno = 0; + + icalerror_check_arg_rz((cluster!=0),"cluster"); + icalerror_check_arg_rz((path!=0),"path"); + + if(impl->path != 0 && strcmp(impl->path,path) == 0){ + /* Already have the right cluster, so return */ + return ICAL_NO_ERROR; + } + + error = icalcluster_commit(cluster); + + if (error != ICAL_NO_ERROR){ + icalerror_set_errno(error); + return error; + } + + free(impl->path); + + impl->path= (char*)strdup(path); + + parser_file = fopen(impl->path,"r"); + + /* HACK. Yeah, the following code is horrible....*/ + if (parser_file ==0 || errno != 0){ + + /* Try to create the cluster */ + error = icalcluster_create_cluster(path); + + if (error == ICAL_NO_ERROR){ + /* Try to open the parser again. */ + errno = 0; + parser_file = fopen(impl->path,"r"); + + if (parser_file ==0 || errno != 0){ + impl->cluster = 0; + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + } else { + impl->cluster = 0; + icalerror_set_errno(error); /* Redundant, actually */ + return error; + } + } + + impl->cluster = icalparser_parse(read_from_file); + + fclose(parser_file); + + if (impl->cluster == 0){ + icalerror_set_errno(ICAL_PARSE_ERROR); + return ICAL_PARSE_ERROR; + } + + return ICAL_NO_ERROR; +} + + +icalcluster* icalcluster_new(char* path) +{ + struct icalcluster_impl *impl = icalcluster_new_impl(); + struct stat sbuf; + int createclusterfile = 0; + icalerrorenum error; + + icalerror_clear_errno(); + icalerror_check_arg_rz( (path!=0), "path"); + + if (impl == 0){ + return 0; + } + + /*impl->path = strdup(path); icalcluster_load does this */ + impl->changed = 0; + impl->cluster = 0; + impl->path = 0; + + /* Check if the path already exists and if it is a regular file*/ + if (stat(path,&sbuf) != 0){ + + /* A file by the given name does not exist, or there was + another error */ + + if (errno == ENOENT) { + /* It was because the file does not exist */ + createclusterfile = 1; + } else { + /* It was because of another error */ + icalerror_set_errno(ICAL_FILE_ERROR); + return 0; + } + } else { + /* A file by the given name exists, but is it a regular file */ + + if (!S_ISREG(sbuf.st_mode)){ + /* Nope, not a directory */ + icalerror_set_errno(ICAL_FILE_ERROR); + return 0; + } else { + /* Lets assume that it is a file of the right type */ + createclusterfile = 0; + } + } + + /* if cluster does not already exist, create it */ + + if (createclusterfile == 1) { + error = icalcluster_create_cluster(path); + + if (error != ICAL_NO_ERROR){ + icalerror_set_errno(error); + return 0; + } + } + + error = icalcluster_load(impl,path); + + if (error != ICAL_NO_ERROR){ + return 0; + } + + return impl; +} + +void icalcluster_free(icalcluster* cluster) +{ + struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rv((cluster!=0),"cluster"); + + if (impl->cluster != 0){ + icalcluster_commit(cluster); + icalcomponent_free(impl->cluster); + impl->cluster=0; + } + + if(impl->path != 0){ + free(impl->path); + impl->path = 0; + } + + free(impl); +} + +icalerrorenum icalcluster_commit(icalcluster* cluster) +{ + int ws; /* Size in char of file written to disk */ + FILE *f; + + struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR); + + if (impl->changed != 0 ){ + /* write the cluster to disk */ + + /* Construct a filename and write out the file */ + + if ( (f = fopen(impl->path,"w")) != 0){ + + char* str = icalcomponent_as_ical_string(impl->cluster); + + ws = fwrite(str,sizeof(char),strlen(str),f); + + if ( ws < strlen(str)){ + fclose(f); + return ICAL_FILE_ERROR; + } + + fclose(f); + impl->changed = 0; + return ICAL_NO_ERROR; + } else { + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + + } + + return ICAL_NO_ERROR; +} + +void icalcluster_mark(icalcluster* cluster){ + + struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rv((impl!=0),"cluster"); + + impl->changed = 1; + +} + +icalcomponent* icalcluster_get_component(icalcluster* cluster){ + struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR); + + return impl->cluster; +} + + +/* manipulate the components in the cluster */ + +icalerrorenum icalcluster_add_component(icalcluster *cluster, + icalcomponent* child) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rv((cluster!=0),"cluster"); + icalerror_check_arg_rv((child!=0),"child"); + + icalcomponent_add_component(impl->cluster,child); + + icalcluster_mark(cluster); + + return ICAL_NO_ERROR; + +} + +icalerrorenum icalcluster_remove_component(icalcluster *cluster, + icalcomponent* child) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rv((cluster!=0),"cluster"); + icalerror_check_arg_rv((child!=0),"child"); + + icalcomponent_remove_component(impl->cluster,child); + + icalcluster_mark(cluster); + + return ICAL_NO_ERROR; +} + +int icalcluster_count_components(icalcluster *cluster, + icalcomponent_kind kind) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + if(cluster == 0){ + icalerror_set_errno(ICAL_BADARG_ERROR); + return -1; + } + + return icalcomponent_count_components(impl->cluster,kind); +} + +/* Iterate through components */ +icalcomponent* icalcluster_get_current_component (icalcluster* cluster) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rz((cluster!=0),"cluster"); + + return icalcomponent_get_current_component(impl->cluster); +} + +icalcomponent* icalcluster_get_first_component(icalcluster* cluster, + icalcomponent_kind kind) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rz((cluster!=0),"cluster"); + + return icalcomponent_get_first_component(impl->cluster,kind); +} + +icalcomponent* icalcluster_get_next_component(icalcluster* cluster, + icalcomponent_kind kind) +{ + struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster; + + icalerror_check_arg_rz((cluster!=0),"cluster"); + + return icalcomponent_get_next_component(impl->cluster,kind); +} + diff --git a/libical/src/libicalss/icalcluster.h b/libical/src/libicalss/icalcluster.h new file mode 100644 index 0000000000..05c3a4b144 --- /dev/null +++ b/libical/src/libicalss/icalcluster.h @@ -0,0 +1,75 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalcluster.h + CREATOR: eric 23 December 1999 + + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + +======================================================================*/ + +#ifndef ICALCLUSTER_H +#define ICALCLUSTER_H + +#include "ical.h" + +typedef void icalcluster; + + +icalcluster* icalcluster_new(char* path); +void icalcluster_free(icalcluster* cluster); + + +/* Load a new file into the cluster */ +icalerrorenum icalcluster_load(icalcluster* cluster, char* path); + +/* Return a reference to the internal component. */ +icalcomponent* icalcluster_get_component(icalcluster* cluster); + +/* Mark the cluster as changed, so it will be written to disk when it + is freed*/ +void icalcluster_mark(icalcluster* cluster); + +/* Write the cluster data back to disk */ +icalerrorenum icalcluster_commit(icalcluster* cluster); + +/* manipulate the components in the cluster */ +icalerrorenum icalcluster_add_component(icalcomponent* parent, + icalcomponent* child); + +icalerrorenum icalcluster_remove_component(icalcomponent* parent, + icalcomponent* child); + +int icalcluster_count_components(icalcomponent* component, + icalcomponent_kind kind); + +/* Iterate through components */ +icalcomponent* icalcluster_get_current_component (icalcomponent* component); + +icalcomponent* icalcluster_get_first_component(icalcomponent* component, + icalcomponent_kind kind); +icalcomponent* icalcluster_get_next_component(icalcomponent* component, + icalcomponent_kind kind); + +#endif /* !ICALCLUSTER_H */ + + + diff --git a/libical/src/libicalss/icalcomponent.h b/libical/src/libicalss/icalcomponent.h new file mode 100644 index 0000000000..9e0e9f5a9f --- /dev/null +++ b/libical/src/libicalss/icalcomponent.h @@ -0,0 +1,115 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalcomponent.h + CREATOR: eric 20 March 1999 + + + (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 icalcomponent.h + +======================================================================*/ + +#ifndef ICALCOMPONENT_H +#define ICALCOMPONENT_H + +#include "icalproperty.h" +#include "icalvalue.h" +#include "icalenums.h" /* defines icalcomponent_kind */ + +typedef void icalcomponent; + +icalcomponent* icalcomponent_new(icalcomponent_kind kind); +icalcomponent* icalcomponent_new_clone(icalcomponent* component); +icalcomponent* icalcomponent_new_from_string(char* str); +icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...); +void icalcomponent_free(icalcomponent* component); + +char* icalcomponent_as_ical_string(icalcomponent* component); + +int icalcomponent_is_valid(icalcomponent* component); + +icalcomponent_kind icalcomponent_isa(icalcomponent* component); + +int icalcomponent_isa_component (void* component); + +/* + * Working with properties + */ + +void icalcomponent_add_property(icalcomponent* component, + icalproperty* property); + +void icalcomponent_remove_property(icalcomponent* component, + icalproperty* property); + +int icalcomponent_count_properties(icalcomponent* component, + icalproperty_kind kind); + +/* Iterate through the properties */ +icalproperty* icalcomponent_get_current_property(icalcomponent* component); + +icalproperty* icalcomponent_get_first_property(icalcomponent* component, + icalproperty_kind kind); +icalproperty* icalcomponent_get_next_property(icalcomponent* component, + icalproperty_kind kind); + +/* Return a null-terminated array of icalproperties*/ + +icalproperty** icalcomponent_get_properties(icalcomponent* component, + icalproperty_kind kind); + + +/* + * Working with components + */ + + +void icalcomponent_add_component(icalcomponent* parent, + icalcomponent* child); + +void icalcomponent_remove_component(icalcomponent* parent, + icalcomponent* child); + +int icalcomponent_count_components(icalcomponent* component, + icalcomponent_kind kind); + +/* 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); + +/* Return a null-terminated array of icalproperties*/ +icalproperty** icalcomponent_get_component(icalcomponent* component, + icalproperty_kind kind); + +/* Working with embedded error properties */ + +int icalcomponent_count_errors(icalcomponent* component); +void icalcomponent_strip_errors(icalcomponent* component); + + +/* Internal operations. You don't see these... */ +icalcomponent* icalcomponent_get_parent(icalcomponent* component); +void icalcomponent_set_parent(icalcomponent* component, + icalcomponent* parent); + +#endif /* !ICALCOMPONENT_H */ + + + diff --git a/libical/src/libicalss/icalstore.c b/libical/src/libicalss/icalstore.c new file mode 100644 index 0000000000..014c9ed19b --- /dev/null +++ b/libical/src/libicalss/icalstore.c @@ -0,0 +1,815 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icalstore.c + CREATOR: eric 28 November 1999 + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + + ======================================================================*/ + + +/* + + icalstore manages a database of ical components and offers + interfaces for reading, writting and searching for components. + + icalstore groups components in to clusters based on their DTSTART + time -- all components that start in the same month are grouped + together in a single file. All files in a sotre are kept in a single + directory. ( If a component does not have DTSTART, the store uses + DTSTAMP or CREATE ) + + The primary interfaces are icalstore_first and icalstore_next. These + routine iterate through all of the components in the store, subject + to the current gauge. A gauge is an icalcomponent that is tested + against other componets for a match. If a gauge has been set with + icalstore_select, icalstore_first and icalstore_next will only + return componentes that match the gauge. + + The Store generated UIDs for all objects that are stored if they do + not already have a UID. The UID is the name of the cluster (month & + year as MMYYYY) plus a unique serial number. The serial number is + stored as a property of the cluster. + +*/ + +#include "ical.h" +#include "icalstore.h" +#include "pvl.h" +#include "icalerror.h" +#include "icalparser.h" +#include "icalcluster.h" + +#include "filelock.h" + +#include <limits.h> +#include <dirent.h> /* for opendir() */ +#include <errno.h> +#include <sys/types.h> /* for opendir() */ +#include <sys/stat.h> /* for stat */ +#include <unistd.h> /* for stat, getpid */ +#include <time.h> /* for clock() */ +#include <stdlib.h> /* for rand(), srand() */ +#include <sys/utsname.h> /* for uname */ +#include <string.h> /* for strdup */ + + +struct icalstore_impl +{ + char* dir; + icalcomponent* gauge; + icalcluster* cluster; + int first_component; + pvl_list directory; + pvl_elem directory_iterator; +}; + +struct icalstore_impl* icalstore_new_impl() +{ + struct icalstore_impl* comp; + + if ( ( comp = (struct icalstore_impl*) + malloc(sizeof(struct icalstore_impl))) == 0) { + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + return comp; +} + + + +void icalstore_lock_dir(char* dir) +{ +} + + +void icalstore_unlock_dir(char* dir) +{ +} + +/* Load the contents of the store directory into the store's internal directory list*/ +icalerrorenum icalstore_read_directory(struct icalstore_impl* impl) +{ + struct dirent *de; + DIR* dp; + char *str; + + dp = opendir(impl->dir); + + if ( dp == 0) { + icalerror_set_errno(ICAL_FILE_ERROR); + return ICAL_FILE_ERROR; + } + + /* clear contents of directory list */ + while((str = pvl_pop(impl->directory))){ + free(str); + } + + /* load all of the cluster names in the directory list */ + for(de = readdir(dp); + de != 0; + de = readdir(dp)){ + + /* Remove known directory names '.' and '..'*/ + if (strcmp(de->d_name,".") == 0 || + strcmp(de->d_name,"..") == 0 ){ + continue; + } + + pvl_push(impl->directory, (void*)strdup(de->d_name)); + } + + closedir(dp); + + return ICAL_NO_ERROR; +} + +icalstore* icalstore_new(char* dir) +{ + struct icalstore_impl *impl = icalstore_new_impl(); + struct stat sbuf; + + if (impl == 0){ + return 0; + } + + icalerror_check_arg_rz( (dir!=0), "dir"); + + if (stat(dir,&sbuf) != 0){ + icalerror_set_errno(ICAL_FILE_ERROR); + return 0; + } + + /* dir is not the name of a direectory*/ + if (!S_ISDIR(sbuf.st_mode)){ + icalerror_set_errno(ICAL_USAGE_ERROR); + return 0; + } + + icalstore_lock_dir(dir); + + impl = icalstore_new_impl(); + + if (impl ==0){ + icalerror_set_errno(ICAL_ALLOCATION_ERROR); + return 0; + } + + impl->directory = pvl_newlist(); + impl->directory_iterator = 0; + impl->dir = (char*)strdup(dir); + impl->gauge = 0; + impl->first_component = 0; + impl->cluster = 0; + + icalstore_read_directory(impl); + + return (icalstore*) impl; +} + +void icalstore_free(icalstore* s) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)s; + char* str; + + icalstore_unlock_dir(impl->dir); + + if(impl->dir !=0){ + free(impl->dir); + } + + if(impl->gauge !=0){ + icalcomponent_free(impl->gauge); + } + + if(impl->cluster !=0){ + icalcluster_free(impl->cluster); + } + + while( (str=pvl_pop(impl->directory)) != 0){ + free(str); + } + + pvl_free(impl->directory); + + impl->directory = 0; + impl->directory_iterator = 0; + impl->dir = 0; + impl->gauge = 0; + impl->first_component = 0; + + free(impl); + +} + +/* icalstore_next_uid_number updates a serial number in the Store + directory in a file called SEQUENCE */ + +int icalstore_next_uid_number(icalstore* store) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)store; + char sequence = 0; + char temp[128]; + char filename[PATH_MAX]; + char *r; + FILE *f; + struct stat sbuf; + + icalerror_check_arg_rz( (store!=0), "store"); + + sprintf(filename,"%s/%s",impl->dir,"SEQUENCE"); + + /* Create the file if it does not exist.*/ + if (stat(filename,&sbuf) == -1 || !S_ISREG(sbuf.st_mode)){ + + f = fopen(filename,"w"); + if (f != 0){ + fprintf(f,"0"); + fclose(f); + } else { + icalerror_warn("Can't create SEQUENCE file in icalstore_next_uid_number"); + return 0; + } + + } + + if ( (f = fopen(filename,"r+")) != 0){ + + rewind(f); + r = fgets(temp,128,f); + + if (r == 0){ + sequence = 1; + } else { + sequence = atoi(temp)+1; + } + + rewind(f); + + fprintf(f,"%d",sequence); + + fclose(f); + + return sequence; + + } else { + icalerror_warn("Can't create SEQUENCE file in icalstore_next_uid_number"); + return 0; + } + +} + +icalerrorenum icalstore_next_cluster(icalstore* store) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)store; + char path[PATH_MAX]; + + if (impl->directory_iterator == 0){ + icalerror_set_errno(ICAL_INTERNAL_ERROR); + return ICAL_INTERNAL_ERROR; + } + impl->directory_iterator = pvl_next(impl->directory_iterator); + + if (impl->directory_iterator == 0){ + /* There are no more clusters */ + impl->cluster = 0; + return ICAL_NO_ERROR; + } + + + sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator)); + + return icalcluster_load(impl->cluster,path); +} + +void icalstore_add_uid(icalstore* store, icalstore* comp) +{ + char uidstring[PATH_MAX]; + icalproperty *uid; + struct utsname unamebuf; + + icalerror_check_arg_rz( (store!=0), "store"); + icalerror_check_arg_rz( (comp!=0), "comp"); + + uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY); + + if (uid == 0) { + + uname(&unamebuf); + + sprintf(uidstring,"%d-%s",getpid(),unamebuf.nodename); + + uid = icalproperty_new_uid(uidstring); + icalcomponent_add_property(comp,uid); + } else { + + strcpy(uidstring,icalproperty_get_uid(uid)); + } +} + +icalerrorenum icalstore_add_component(icalstore* store, icalstore* comp) +{ + struct icalstore_impl *impl; + char clustername[PATH_MAX]; + icalproperty *dt, *count, *lm; + icalvalue *v; + struct icaltimetype tm; + icalerrorenum error = ICAL_NO_ERROR; + + impl = (struct icalstore_impl*)store; + icalerror_check_arg_rz( (store!=0), "store"); + icalerror_check_arg_rz( (comp!=0), "comp"); + + errno = 0; + + icalstore_add_uid(store,comp); + + /* Determine which cluster this object belongs in */ + + dt = icalcomponent_get_first_property(comp,ICAL_DTSTART_PROPERTY); + + if (dt == 0){ + dt = icalcomponent_get_first_property(comp,ICAL_DTSTAMP_PROPERTY); + } + + if (dt == 0){ + dt = icalcomponent_get_first_property(comp,ICAL_CREATED_PROPERTY); + } + + if (dt == 0){ + icalerror_warn("The component does not have a DTSTART, DTSTAMP or a CREATED property, so it cannot be added to the store"); + icalerror_set_errno(ICAL_BADARG_ERROR); + return ICAL_BADARG_ERROR; + } + + v = icalproperty_get_value(dt); + + tm = icalvalue_get_datetime(v); + + sprintf(clustername,"%s/%04d%02d",impl->dir,tm.year,tm.month); + + /* Load the cluster and insert the object */ + + if (impl->cluster == 0){ + impl->cluster = icalcluster_new(clustername); + + if (impl->cluster == 0){ + error = icalerrno; + } + } else { + error = icalcluster_load(impl->cluster, + clustername); + + } + + + if (error != ICAL_NO_ERROR){ + icalerror_set_errno(error); + return error; + } + + /* Update or add the LAST-MODIFIED property */ + + lm = icalcomponent_get_first_property(comp, + ICAL_LASTMODIFIED_PROPERTY); + + if (lm == 0){ + lm = icalproperty_new_lastmodified(icaltimetype_from_timet( time(0),1)); + icalcomponent_add_property(comp,lm); + } else { + icalproperty_set_lastmodified(comp,icaltimetype_from_timet( time(0),1)); + } + + + /* Add the component to the cluster */ + + icalcluster_add_component(impl->cluster,comp); + + + /* Increment the clusters count value */ + count = icalcomponent_get_first_property( + icalcluster_get_component(impl->cluster), + ICAL_XLICCLUSTERCOUNT_PROPERTY); + + if (count == 0){ + icalerror_set_errno(ICAL_INTERNAL_ERROR); + return ICAL_INTERNAL_ERROR; + } + + icalproperty_set_xlicclustercount(count, + icalproperty_get_xlicclustercount(count)+1); + + + icalcluster_mark(impl->cluster); + + return ICAL_NO_ERROR; +} + +/* Remove a component in the current cluster */ +icalerrorenum icalstore_remove_component(icalstore* store, icalstore* comp) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)store; + icalproperty *count; + + icalerror_check_arg_re((store!=0),"store",ICAL_BADARG_ERROR); + icalerror_check_arg_re((comp!=0),"comp",ICAL_BADARG_ERROR); + icalerror_check_arg_re((impl->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR); + +/* HACK The following code should be used to ensure that the component +the caller is trying to remove is actually in the cluster, but it +resets the internal iterators, which immediately ends any loops over +the cluster the caller may have in progress + + for(c = icalcluster_get_first_component( + impl->cluster, + ICAL_ANY_COMPONENT); + c != 0; + c = icalcluster_get_next_component( + impl->cluster, + ICAL_ANY_COMPONENT)){ + + if (c == comp){ + found = 1; + } + + } + + if (found != 1){ + icalerror_warn("icalstore_remove_component: component is not part of current cluster"); + icalerror_set_errno(ICAL_USAGE_ERROR); + return ICAL_USAGE_ERROR; + } + +*/ + + icalcluster_remove_component(impl->cluster, + comp); + + icalcluster_mark(impl->cluster); + + /* Decrement the clusters count value */ + count = icalcomponent_get_first_property( + icalcluster_get_component(impl->cluster), + ICAL_XLICCLUSTERCOUNT_PROPERTY); + + if (count == 0){ + icalerror_set_errno(ICAL_INTERNAL_ERROR); + return ICAL_INTERNAL_ERROR; + } + + icalproperty_set_xlicclustercount(count, + icalproperty_get_xlicclustercount(count)-1); + + return ICAL_NO_ERROR; +} + +/* Convert a VQUERY component into a gauge */ +icalcomponent* icalstore_make_gauge(icalcomponent* query); + +/* icalstore_test compares a component against a gauge, and returns + true if the component passes the test + + The gauge is a VCALENDAR component that specifies how to test the + target components. The guage holds a collection of VEVENT, VTODO or + VJOURNAL sub-components. Each of the sub-components has a + collection of properties that are compared to corresponding + properties in the target component, according to the + X-LIC-COMPARETYPE parameters to the gauge's properties. + + When a gauge has several sub-components, the results of testing the + target against each of them is ORed together - the target + component will pass if it matches any of the sub-components in the + gauge. However, the results of matching the proeprties in a + sub-component are ANDed -- the target must match every property in + a gauge sub-component to match the sub-component. + + Here is an example: + + BEGIN:VCOMPONENT + BEGIN:VEVENT + DTSTART;X-LIC-COMPARETYPE=LESS:19981025T020000 + ORGANIZER;X-LIC-COMPARETYPE=EQUAL:mrbig@host.com + END:VEVENT + BEGIN:VEVENT + LOCATION;X-LIC-COMPARETYPE=EQUAL:McNary's Pub + END:VEVENT + END:VCALENDAR + + This gauge has two sub-components; one which will match a VEVENT + based on start time, and organizer, and another that matches based + on LOCATION. A target component will pass the test if it matched + either of the gauge. + + */ + +int icalstore_test(icalcomponent* comp, icalcomponent* gauge) +{ + int pass = 0,localpass = 0; + icalcomponent *c; + icalproperty *p; + icalcomponent *child; + + icalerror_check_arg_rz( (comp!=0), "comp"); + icalerror_check_arg_rz( (gauge!=0), "gauge"); + + for(c = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){ + + + /* Test properties. For each property in the gauge, search through + the component for a similar property. If one is found, compare + the two properties value with the comparison specified in the + gauge with the X-LIC-COMPARETYPE parameter */ + + for(p = icalcomponent_get_first_property(c,ICAL_ANY_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(c,ICAL_ANY_PROPERTY)){ + + icalproperty* targetprop; + icalparameter* compareparam; + icalparameter_xliccomparetype compare; + int rel; /* The realtionship between the gauge and target values.*/ + + /* Extract the comparison type from the gauge. If there is no + comparison type, assume that it is "EQUAL" */ + + compareparam = icalproperty_get_first_parameter( + p, + ICAL_XLICCOMPARETYPE_PARAMETER); + + if (compareparam!=0){ + compare = icalparameter_get_xliccomparetype(compareparam); + } else { + compare = ICAL_XLICCOMPARETYPE_EQUAL; + } + + /* Find a property in the component that has the same type as + the gauge property */ + + targetprop = icalcomponent_get_first_property(comp, + icalproperty_isa(p)); + + + if(targetprop == 0){ + continue; + } + + /* Compare the values of the gauge property and the target + property */ + + rel = icalvalue_compare(icalproperty_get_value(p), + icalproperty_get_value(targetprop)); + + /* Now see if the comparison is equavalent to the comparison + specified in the gauge */ + + if (rel == compare){ + localpass++; + } else if (compare == ICAL_XLICCOMPARETYPE_LESSEQUAL && + ( rel == ICAL_XLICCOMPARETYPE_LESS || + rel == ICAL_XLICCOMPARETYPE_EQUAL)) { + localpass++; + } else if (compare == ICAL_XLICCOMPARETYPE_GREATEREQUAL && + ( rel == ICAL_XLICCOMPARETYPE_GREATER || + rel == ICAL_XLICCOMPARETYPE_EQUAL)) { + localpass++; + } else if (compare == ICAL_XLICCOMPARETYPE_NOTEQUAL && + ( rel == ICAL_XLICCOMPARETYPE_GREATER || + rel == ICAL_XLICCOMPARETYPE_LESS)) { + pass++; + } else { + localpass = 0; + } + + pass += localpass; + } + + + /* test subcomponents. Look for a child component that has a + counterpart in the gauge. If one is found, recursively call + icalstore_test */ + + for(child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT); + child != 0; + child = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){ + + pass += icalstore_test(child,gauge); + + } + } + + return pass>0; + +} + +icalcomponent* icalstore_query(icalstore* store, icalstore* query); + + +icalcomponent* icalstore_fetch(icalstore* store, char* uid) +{ + icalcomponent *gauge; + icalcomponent *old_gauge; + icalcomponent *c; + struct icalstore_impl *impl = (struct icalstore_impl*)store; + + icalerror_check_arg_rz( (store!=0), "store"); + icalerror_check_arg_rz( (uid!=0), "uid"); + + gauge = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_uid( + uid, + icalparameter_new_xliccomparetype( + ICAL_XLICCOMPARETYPE_EQUAL), + 0), + 0), + 0); + + old_gauge = impl->gauge; + impl->gauge = gauge; + + c= icalstore_get_first_component(store); + + impl->gauge = old_gauge; + + icalcomponent_free(gauge); + + return c; +} + + +int icalstore_has_uid(icalstore* store, char* uid) +{ + icalcomponent *c; + + icalerror_check_arg_rz( (store!=0), "store"); + icalerror_check_arg_rz( (uid!=0), "uid"); + + /* HACK. This is a temporary implementation. _has_uid should use a + database, and _fetch should use _has_uid, not the other way + around */ + c = icalstore_fetch(store,uid); + + return c!=0; + +} + + +icalerrorenum icalstore_select(icalstore* store, icalcomponent* gauge) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)store; + + icalerror_check_arg_re( (store!=0), "store",ICAL_BADARG_ERROR); + icalerror_check_arg_re( (gauge!=0), "gauge",ICAL_BADARG_ERROR); + + if (!icalcomponent_is_valid(gauge)){ + return ICAL_BADARG_ERROR; + } + + impl->gauge = gauge; + + return ICAL_NO_ERROR; +} + + + +icalcomponent* icalstore_get_first_component(icalstore* store) +{ + struct icalstore_impl *impl = (struct icalstore_impl*)store; + icalerrorenum error; + char path[PATH_MAX]; + + error = icalstore_read_directory(impl); + + if (error != ICAL_NO_ERROR){ + icalerror_set_errno(error); + return 0; + } + + impl->directory_iterator = pvl_head(impl->directory); + + if (impl->directory_iterator == 0){ + icalerror_set_errno(error); + return 0; + } + + sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator)); + + if (impl->cluster == 0){ + impl->cluster = icalcluster_new(path); + + if (impl->cluster == 0){ + error = icalerrno; + } + } else { + error = icalcluster_load(impl->cluster,path); + + } + + if (error != ICAL_NO_ERROR){ + icalerror_set_errno(error); + return 0; + } + + impl->first_component = 1; + + return icalstore_get_next_component(store); +} + +icalcomponent* icalstore_get_next_component(icalstore* store) +{ + struct icalstore_impl *impl; + icalcomponent *c; + icalerrorenum error; + + icalerror_check_arg_rz( (store!=0), "store"); + + impl = (struct icalstore_impl*)store; + + if(impl->cluster == 0){ + + icalerror_warn("icalstore_get_next_component called with a NULL cluster (Caller must call icalstore_get_first_component first"); + icalerror_set_errno(ICAL_USAGE_ERROR); + return 0; + + } + + /* Set the component iterator for the following for loop */ + if (impl->first_component == 1){ + icalcluster_get_first_component( + impl->cluster, + ICAL_ANY_COMPONENT); + impl->first_component = 0; + } else { + icalcluster_get_next_component( + impl->cluster, + ICAL_ANY_COMPONENT); + } + + + while(1){ + /* Iterate through all of the objects in the cluster*/ + for( c = icalcluster_get_current_component( + impl->cluster); + c != 0; + c = icalcluster_get_next_component( + impl->cluster, + ICAL_ANY_COMPONENT)){ + + /* If there is a gauge defined and the component does not + pass the gauge, skip the rest of the loop */ + if (impl->gauge != 0 && icalstore_test(c,impl->gauge) == 0){ + continue; + } + + /* Either there is no gauge, or the component passed the + gauge, so return it*/ + + return c; + } + + /* Fell through the loop, so the component we want is not + in this cluster. Load a new cluster and try again.*/ + + error = icalstore_next_cluster(store); + + if(impl->cluster == 0 || error != ICAL_NO_ERROR){ + /* No more clusters */ + return 0; + } else { + c = icalcluster_get_first_component( + impl->cluster, + ICAL_ANY_COMPONENT); + } + } +} + + + + + + diff --git a/libical/src/libicalss/icalstore.h b/libical/src/libicalss/icalstore.h new file mode 100644 index 0000000000..13e0a182b5 --- /dev/null +++ b/libical/src/libicalss/icalstore.h @@ -0,0 +1,78 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalstore.h + CREATOR: eric 28 November 1999 + + + $Id$ + $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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + +======================================================================*/ + +#ifndef ICALSTORE_H +#define ICALSTORE_H + +#include "ical.h" +#include "icalerror.h" +typedef void icalstore; + +/* icalstore Routines for storing, fetching, and searching for ical + * objects in a database */ + +icalstore* icalstore_new(char* dir); + +void icalstore_free(icalstore* store); + +/* Add a new component to the store */ +icalerrorenum icalstore_add_component(icalstore* store, icalstore* comp); + +/* Remove a component from the store */ +icalerrorenum icalstore_remove_component(icalstore* store, icalstore* comp); + +/* Restrict the component returned by icalstore_first, _next to those + that pass the gauge */ +icalerrorenum icalstore_select(icalstore* store, icalcomponent* gauge); + +/* Return true if a component passes the gauge */ +int icalstore_test(icalcomponent* comp, icalcomponent* gauge); + +/* Clear the restrictions set by icalstore_select */ +void icalstore_clear(icalstore* store); + +/* Get a single component by uid */ +icalcomponent* icalstore_fetch(icalstore* store, char* uid); + +/* Return true of the store has an object with the given UID */ +int icalstore_has_uid(icalstore* store, char* uid); + +/* Return the first component in the store, or first that passes the gauge.*/ +icalcomponent* icalstore_get_first_component(icalstore* store); + +/* Return the next component in the store, or next that passes the gauge.*/ +icalcomponent* icalstore_get_next_component(icalstore* store); + + +int icalstore_next_uid_number(icalstore* store); + + +#endif /* !ICALSTORE_H */ + + + diff --git a/libical/src/pvl/Makefile b/libical/src/pvl/Makefile new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/libical/src/pvl/Makefile diff --git a/libical/src/test/Makefile b/libical/src/test/Makefile new file mode 100644 index 0000000000..29eeed08ee --- /dev/null +++ b/libical/src/test/Makefile @@ -0,0 +1,37 @@ +# Generated automatically from Makefile.in by configure. +INCLUDES = -I . -I../libical -I../libicalss +CFLAGS = -Wall -g $(INCLUDES) +LIBS = -L../libical -L../libicalss -licalss -lical +CC = gcc +LD = ld + +all: usecases copycluster regression parser findobj + +parser: icaltestparser.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o icalparser icaltestparser.o $(LIBS) + +copycluster: copycluster.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o copycluster copycluster.o $(INCLUDES) $(LIBS) + +findobj: findobj.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o findobj findobj.o $(INCLUDES) $(LIBS) + +regression: regression.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o regression regression.o $(INCLUDES) $(LIBS) + +usecases: usecases.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o usecases usecases.o $(INCLUDES) $(LIBS) + +clean: + -/bin/rm -f *.o + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -rf icalparser core regression usecases copycluster findobj + +ci: clean + ci -u *.c *.h + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + +install:
\ No newline at end of file diff --git a/libical/src/test/Makefile.in b/libical/src/test/Makefile.in new file mode 100644 index 0000000000..5d3d5f709f --- /dev/null +++ b/libical/src/test/Makefile.in @@ -0,0 +1,36 @@ +INCLUDES = -I . -I../libical -I../libicalss +CFLAGS = -Wall -g $(INCLUDES) +LIBS = -L../libical -L../libicalss -licalss -lical +CC = gcc +LD = ld + +all: usecases copycluster regression parser findobj + +parser: icaltestparser.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o icalparser icaltestparser.o $(LIBS) + +copycluster: copycluster.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o copycluster copycluster.o $(INCLUDES) $(LIBS) + +findobj: findobj.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o findobj findobj.o $(INCLUDES) $(LIBS) + +regression: regression.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o regression regression.o $(INCLUDES) $(LIBS) + +usecases: usecases.o ../libical/libical.a ../libicalss/libicalss.a + $(CC) -o usecases usecases.o $(INCLUDES) $(LIBS) + +clean: + -/bin/rm -f *.o + -/bin/rm -f \#* + -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c + -/bin/rm -rf icalparser core regression usecases copycluster findobj + +ci: clean + ci -u *.c *.h + +depend: + @makedepend -Y $(INCLUDES) $(SOURCES) + +install:
\ No newline at end of file diff --git a/libical/src/test/alice/booked/199706 b/libical/src/test/alice/booked/199706 new file mode 100644 index 0000000000..8ad5c7d8b1 --- /dev/null +++ b/libical/src/test/alice/booked/199706 @@ -0,0 +1,317 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :13 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +COMMENT + :DUKES forfeit the game +SEQUENCE + :2 +UID + :0981234-1234234-23@example.com +DTSTAMP + :19970613T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ATTENDEE + ;PARTSTAT=ACCEPTED + :Mailto:B@example.com +ORGANIZER + :MAILTO:A@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970612T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +COMMENT + :Sorry +COMMENT + : I cannot change this meeting time +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +DTSTAMP + :19970614T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970611T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=ACCEPTED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970614T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +ATTENDEE + ;PARTSTAT=DECLINED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +COMMENT + :Sorry +COMMENT + : I will be out of town at that time. +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970614T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :A@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'Mailto' +ATTENDEE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +COMMENT + :Mr. B cannot attend. It's raining. Lets cancel. +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +STATUS + :CANCELLED +DTSTAMP + :19970613T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :mailto:B@example.com +COMMENT + :You're off the hook for this meeting +UID + :calsrv.example.com-873970198738777@example.com +DTSTAMP + :19970613T193000Z +SEQUENCE + :1 +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=MONTHLY\;BYMONTHDAY=1\;UNTIL=19980901T210000Z' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970601T210000Z +DTEND + :19970601T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970526T083000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=MONTHLY\;BYMONTHDAY=1' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970601T210000Z +DTEND + :19970601T220000Z +DTSTAMP + :19970602T094000Z +LOCATION + :Conference Call +STATUS + :CONFIRMED +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PROPERTY_PARSE_ERROR + :Parse error in property name: 'FOO' +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +REQUEST-STATUS + :2.8\;Repeating event ignored. Scheduled as a single event\;RRULE +REQUEST-STATUS + :3.0\;Invalid Property Name\;FOO +UID + :guid-1@host1.com +SEQUENCE + :0 +DTSTAMP + :19970603T094000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +UID + : guid-1-12345@host1.com +DTSTAMP + :19970603T094000 +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +UID + :acme-12345@host1.com +DTSTAMP + :19970603T094000 +LAST-MODIFIED + :20000209T060028Z +END:VEVENT +END:VCALENDAR diff --git a/libical/src/test/alice/booked/199707 b/libical/src/test/alice/booked/199707 new file mode 100644 index 0000000000..c52d27aa91 --- /dev/null +++ b/libical/src/test/alice/booked/199707 @@ -0,0 +1,701 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :19 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTART + :19970701T200000Z +DTSTAMP + :19970611T190000Z +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +UID + :0981234-1234234-23@example.com +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTAMP + :19970612T190000Z +DTSTART + :19970701T210000Z +DTEND + :19970701T230000Z +SEQUENCE + :1 +UID + :0981234-1234234-23@example.com +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +ATTACH + :http://www.dukes.com/ +CATEGORIES + :SPORTS EVENT +CATEGORIES + :ENTERTAINMENT +CLASS + :PRIVATE +DESCRIPTION + :MIDWAY STADIUM\nBig time game. MUST see.\nExpected duration:2 hours\n +DTEND + ;TZID=America-Chicago + :19970701T180000 +DTSTART + ;TZID=America-Chicago + :19970702T160000 +DTSTAMP + :19970614T190000Z +STATUS + :CONFIRMED +LOCATION + :http://www.midwaystadium.com/ +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter value: 'VALUE=America-Chicago' +PRIORITY + :2 +RESOURCES + :SCOREBOARD +SEQUENCE + :3 +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +UID + :0981234-1234234-23@example.com +RELATED-TO + :0981234-1234234-14@example.com +LAST-MODIFIED + :20000209T060027Z +BEGIN:VALARM +TRIGGER + :PT2H +ACTION + :DISPLAY +DESCRIPTION + :You should be leaving for the game now. +END:VALARM +BEGIN:VALARM +TRIGGER + :PT30M +ACTION + :AUDIO +END:VALARM +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTAMP + :19970614T190000Z +UID + :0981234-1234234-23@example.com +DTSTART + ;VALUE=DATE + :19970714 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;INTERVAL=1' +SUMMARY + : Bastille Day +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + ;CN=BIG A + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + ;CN=B + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=C + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=Hal + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=FALSE + :conf_Big@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=ROOM' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T200000Z +SUMMARY + :Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=Hal + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + ;CUTYPE=ROOM + :Mailto:Conf@example.com +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTART + :19970701T180000Z +DTEND + :19970701T190000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +DTSTAMP + :19970613T190000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTART + :19970701T190000Z +DTEND + :19970701T200000Z +SUMMARY + :Discuss the Merits of the election results +LOCATION + :Green Conference Room +UID + :calsrv.example.com-873970198738777a@example.com +SEQUENCE + :0 +DTSTAMP + :19970611T190000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTART + :19970701T160000Z +DTEND + :19970701T190000Z +DTSTAMP + :19970612T190000Z +SUMMARY + :Discuss the Merits of the election results +LOCATION + :Green Conference Room +COMMENT + :This time works much better and I think the big conference room is + too big +UID + :calsrv.example.com-873970198738777a@example.com +SEQUENCE + :0 +DTSTAMP + :19970611T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970613T190000Z +DTSTART + :19970701T160000Z +DTEND + :19970701T190000Z +SUMMARY + :Discuss the Merits of the election results - changed to meet B's schedule +LOCATION + :Green Conference Room +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +DTSTART + :19970701T180000Z +DTEND + :19970701T200000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +DTSTAMP + :19970611T190000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DECLINED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +SUMMARY + :Phone Conference +DTSTART + :19970701T180000Z +DTEND + :19970701T200000Z +DTSTAMP + :19970614T200000Z +COMMENT + :DELEGATE (ATTENDEE Mailto:E@example.com) DECLINED YOURINVITATION +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :CR_Big@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=ROOM' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T203000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :2 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:B@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'STATUS=ACCEPTED' +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T203000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY' +SUMMARY + :Phone Conference +UID + :123456@example.com +SEQUENCE + :1 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :A@example.COM +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :B@example.fr +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :c@example.jp +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970613T190030Z +DTSTART + ;TZID=America-SanJose + :19970701T140000 +DTEND + ;TZID=America-SanJose + :19970701T150000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY\;INTERVAL=20\;WKST=SU\;BYDAY=TU' +RDATE + ;TZID=America-SanJose + :19970910T140000 +EXDATE + ;TZID=America-SanJose + :19970909T140000 +EXDATE + ;TZID=America-SanJose + :19971028T140000 +SUMMARY + :Weekly Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1com +RECURRENCE-ID + :19970701T210000Z +SEQUENCE + :1 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970703T210000Z +DTEND + :19970703T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970626T093000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1.com +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +RECURRENCE-ID + :19970801T210000Z +SEQUENCE + :2 +STATUS + :CANCELLED +DTSTAMP + :19970721T093000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1.com +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DTSTAMP + :19970721T103000Z +STATUS + :CANCELLED +SEQUENCE + :3 +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :4 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970715T210000Z +DTEND + :19970715T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970629T093000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :guid-1@host1.com +RECURRENCE-ID + :19970715T210000Z +SEQUENCE + :4 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;RSVP=TRUE + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970715T220000Z +DTEND + :19970715T230000Z +LOCATION + :Conference Call +COMMENT + :May we bump this by an hour? I have a conflict +DTSTAMP + :19970629T094000Z +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +END:VCALENDAR diff --git a/libical/src/test/alice/booked/199708 b/libical/src/test/alice/booked/199708 new file mode 100644 index 0000000000..2db95cabcf --- /dev/null +++ b/libical/src/test/alice/booked/199708 @@ -0,0 +1,45 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :1 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VEVENT +UID + :acme-12345@host1.com +SEQUENCE + :3 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY' +RDATE + ;VALUE=PERIOD + :19970819T210000Z/19970081T220000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +DESCRIPTION + :IETF-C&S Conference Call +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970801T210000Z +DTEND + :19970801T220000Z +RECURRENCE-ID + :19970809T210000Z +DTSTAMP + :19970726T083000 +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060028Z +END:VEVENT +END:VCALENDAR diff --git a/libical/src/test/alice/booked/199709 b/libical/src/test/alice/booked/199709 new file mode 100644 index 0000000000..30a4471bde --- /dev/null +++ b/libical/src/test/alice/booked/199709 @@ -0,0 +1,58 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :1 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VEVENT +UID + :guid-1@host1.com +RECURRENCE-ID + :19970901T210000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'THISANDFUTURE' +SEQUENCE + :3 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Discussion +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970901T210000Z +DTEND + :19970901T220000Z +LOCATION + :Building 32 +LOCATION + : Microsoft +LOCATION + : Seattle +LOCATION + : WA +DTSTAMP + :19970526T083000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +END:VCALENDAR diff --git a/libical/src/test/alice/booked/199803 b/libical/src/test/alice/booked/199803 new file mode 100644 index 0000000000..4b673d7ccc --- /dev/null +++ b/libical/src/test/alice/booked/199803 @@ -0,0 +1,241 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :7 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TU\;FREQ=WEEKLY' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +LOCATION + :The White Room +DTSTAMP + :19980301T093000Z +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :7 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TH\;FREQ=WEEKLY' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +DTSTAMP + :19980303T193000Z +LOCATION + :The Usual conference room +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :7 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TU' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +DTSTAMP + :19980303T193000Z +LOCATION + :The White Room +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :0 +RDATE + :19980304T180000Z +RDATE + :19980311T180000Z +RDATE + :19980318T180000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980304T180000Z +DTEND + :19980304T200000Z +DTSTAMP + :19980303T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :1 +RECURRENCE-ID + :19980311T180000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980311T160000Z +DTEND + :19980311T180000Z +DTSTAMP + :19980306T193000Z +LOCATION + :The Small conference room +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :2 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980315T180000Z +DTEND + :19980315T200000Z +DTSTAMP + :19980307T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :2 +RDATE + :19980304T180000Z +RDATE + :19980311T160000Z +RDATE + :19980315T180000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=COMPONENT_PARSE_ERROR + :Got a data line\, but could not find a property name or component + begin tag: 'Error! Bookmark not defined.' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980304T180000Z +DTEND + :19980304T200000Z +DTSTAMP + :19980303T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +LAST-MODIFIED + :20000209T060027Z +END:VEVENT +END:VCALENDAR diff --git a/libical/src/test/alice/incoming.ics b/libical/src/test/alice/incoming.ics new file mode 100644 index 0000000000..c25b6b11c3 --- /dev/null +++ b/libical/src/test/alice/incoming.ics @@ -0,0 +1,2164 @@ +BEGIN:VCALENDAR +X-LIC-CLUSTERCOUNT + :0 +DTSTART + :00000000T000000 +DTEND + :00000000T000000 +BEGIN:VCALENDAR +METHOD + :PUBLISH +PRODID + :-//ACME/DesktopCalendar//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTART + :19970701T200000Z +DTSTAMP + :19970611T190000Z +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +UID + :0981234-1234234-23@example.com +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :PUBLISH +VERSION + :2.0 +PRODID + :-//ACME/DesktopCalendar//EN +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTAMP + :19970612T190000Z +DTSTART + :19970701T210000Z +DTEND + :19970701T230000Z +SEQUENCE + :1 +UID + :0981234-1234234-23@example.com +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :CANCEL +VERSION + :2.0 +PRODID + :-//ACME/DesktopCalendar//EN +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +COMMENT + :DUKES forfeit the game +SEQUENCE + :2 +UID + :0981234-1234234-23@example.com +DTSTAMP + :19970613T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :PUBLISH +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PROPERTY_PARSE_ERROR + :Parse error in property name: 'SCALE' +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTIMEZONE +TZID + :America-Chicago +TZURL + :http://zones.stds_r_us.net/tz/America-Chicago +BEGIN:STANDARD +DTSTART + :19671029T020000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;BYDAY=-1SU\;BYMONTH=10' +TZOFFSETFROM + :-050000 +TZOFFSETTO + :-060000 +TZNAME + :CST +END:STANDARD +BEGIN:DAYLIGHT +DTSTART + :19870405T020000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;BYDAY=1SU\;BYMONTH=4' +TZOFFSETFROM + :-060000 +TZOFFSETTO + :-050000 +TZNAME + :CDT +END:DAYLIGHT +END:VTIMEZONE +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +ATTACH + :http://www.dukes.com/ +CATEGORIES + :SPORTS EVENT +CATEGORIES + :ENTERTAINMENT +CLASS + :PRIVATE +DESCRIPTION + :MIDWAY STADIUM\nBig time game. MUST see.\nExpected duration:2 hours\n +DTEND + ;TZID=America-Chicago + :19970701T180000 +DTSTART + ;TZID=America-Chicago + :19970702T160000 +DTSTAMP + :19970614T190000Z +STATUS + :CONFIRMED +LOCATION + :http://www.midwaystadium.com/ +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter value: 'VALUE=America-Chicago' +PRIORITY + :2 +RESOURCES + :SCOREBOARD +SEQUENCE + :3 +SUMMARY + :ST. PAUL SAINTS -VS- DULUTH-SUPERIOR DUKES +UID + :0981234-1234234-23@example.com +RELATED-TO + :0981234-1234234-14@example.com +BEGIN:VALARM +TRIGGER + :PT2H +ACTION + :DISPLAY +DESCRIPTION + :You should be leaving for the game now. +END:VALARM +BEGIN:VALARM +TRIGGER + :PT30M +ACTION + :AUDIO +END:VALARM +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :PUBLISH +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :mailto:a@example.com +DTSTAMP + :19970614T190000Z +UID + :0981234-1234234-23@example.com +DTSTART + ;VALUE=DATE + :19970714 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;INTERVAL=1' +SUMMARY + : Bastille Day +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + ;CN=BIG A + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + ;CN=B + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=C + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=Hal + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=FALSE + :conf_Big@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=ROOM' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T200000Z +SUMMARY + :Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ATTENDEE + ;PARTSTAT=ACCEPTED + :Mailto:B@example.com +ORGANIZER + :MAILTO:A@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970612T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + ;CN=Hal + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + ;CUTYPE=ROOM + :Mailto:Conf@example.com +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTART + :19970701T180000Z +DTEND + :19970701T190000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +DTSTAMP + :19970613T190000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTART + :19970701T190000Z +DTEND + :19970701T200000Z +SUMMARY + :Discuss the Merits of the election results +LOCATION + :Green Conference Room +UID + :calsrv.example.com-873970198738777a@example.com +SEQUENCE + :0 +DTSTAMP + :19970611T190000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :COUNTER +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTART + :19970701T160000Z +DTEND + :19970701T190000Z +DTSTAMP + :19970612T190000Z +SUMMARY + :Discuss the Merits of the election results +LOCATION + :Green Conference Room +COMMENT + :This time works much better and I think the big conference room is + too big +UID + :calsrv.example.com-873970198738777a@example.com +SEQUENCE + :0 +DTSTAMP + :19970611T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970613T190000Z +DTSTART + :19970701T160000Z +DTEND + :19970701T190000Z +SUMMARY + :Discuss the Merits of the election results - changed to meet B's schedule +LOCATION + :Green Conference Room +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :DECLINECOUNTER +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +COMMENT + :Sorry +COMMENT + : I cannot change this meeting time +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +DTSTAMP + :19970614T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970611T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +DTSTART + :19970701T180000Z +DTEND + :19970701T200000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +DTSTAMP + :19970611T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=ACCEPTED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970614T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DELEGATED + ;DELEGATED-TO="Mailto:E@example.com" + :Mailto:C@example.com +ATTENDEE + ;PARTSTAT=DECLINED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +COMMENT + :Sorry +COMMENT + : I will be out of town at that time. +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +REQUEST-STATUS + :2.0\;Success +DTSTAMP + :19970614T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :MAILTO:A@Example.com +ATTENDEE + ;PARTSTAT=DECLINED + ;DELEGATED-FROM="Mailto:C@example.com" + :Mailto:E@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +SUMMARY + :Phone Conference +DTSTART + :19970701T180000Z +DTEND + :19970701T200000Z +DTSTAMP + :19970614T200000Z +COMMENT + :DELEGATE (ATTENDEE Mailto:E@example.com) DECLINED YOURINVITATION +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :CANCEL +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :A@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'Mailto' +ATTENDEE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +COMMENT + :Mr. B cannot attend. It's raining. Lets cancel. +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :1 +STATUS + :CANCELLED +DTSTAMP + :19970613T190000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :CANCEL +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :mailto:B@example.com +COMMENT + :You're off the hook for this meeting +UID + :calsrv.example.com-873970198738777@example.com +DTSTAMP + :19970613T193000Z +SEQUENCE + :1 +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :CR_Big@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=ROOM' +ATTENDEE + ;ROLE=NON-PARTICIPANT + ;RSVP=FALSE + :Mailto:E@example.com +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T203000Z +SUMMARY + :Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :2 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:B@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'STATUS=ACCEPTED' +ATTENDEE + :Mailto:C@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970611T190000Z +DTSTART + :19970701T200000Z +DTEND + :19970701T203000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY' +SUMMARY + :Phone Conference +UID + :123456@example.com +SEQUENCE + :1 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +VERSION + :2.0 +METHOD + :PUBLISH +X-LIC-SENDER + :eric@busboom.org +BEGIN:VFREEBUSY +DTSTAMP + :19980101T124100Z +ORGANIZER + :MAILTO:A@Example.com +DTSTART + :19980101T124200Z +DTEND + :19980107T124200Z +FREEBUSY + :19980101T180000Z/19980101T190000Z +FREEBUSY + :19980103T020000Z/19980103T050000Z +FREEBUSY + :19980107T020000Z/19980107T050000Z +FREEBUSY + :19980113T000000Z/19980113T010000Z +FREEBUSY + :19980115T190000Z/19980115T200000Z +FREEBUSY + :19980115T220000Z/19980115T230000Z +FREEBUSY + :19980116T013000Z/19980116T043000Z +END:VFREEBUSY +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VFREEBUSY +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +DTSTAMP + :19970613T190000Z +DTSTART + :19970701T080000Z +DTEND + :19970701T200000 +UID + :calsrv.example.com-873970198738777@example.com +END:VFREEBUSY +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VFREEBUSY +ORGANIZER + :MAILTO:A@example.com +ATTENDEE + :Mailto:B@example.com +DTSTART + :19970701T080000Z +DTEND + :19970701T200000Z +UID + :calsrv.example.com-873970198738777@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as PERIOD value in FREEBUSY property. Removing entire + property: '19970701T090000Z/PT1H' +DTSTAMP + :19970613T190030Z +END:VFREEBUSY +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTIMEZONE +TZID + :America-SanJose +TZURL + :http://zones.stds_r_us.net/tz/America-SanJose +BEGIN:STANDARD +DTSTART + :19671029T020000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;BYDAY=-1SU\;BYMONTH=10' +TZOFFSETFROM + :-070000 +TZOFFSETTO + :-080000 +TZNAME + :PST +END:STANDARD +BEGIN:DAYLIGHT +DTSTART + :19870405T020000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=YEARLY\;BYDAY=1SU\;BYMONTH=4' +TZOFFSETFROM + :-080000 +TZOFFSETTO + :-070000 +TZNAME + :PDT +END:DAYLIGHT +END:VTIMEZONE +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :A@example.COM +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :B@example.fr +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :c@example.jp +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTAMP + :19970613T190030Z +DTSTART + ;TZID=America-SanJose + :19970701T140000 +DTEND + ;TZID=America-SanJose + :19970701T150000 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY\;INTERVAL=20\;WKST=SU\;BYDAY=TU' +RDATE + ;TZID=America-SanJose + :19970910T140000 +EXDATE + ;TZID=America-SanJose + :19970909T140000 +EXDATE + ;TZID=America-SanJose + :19971028T140000 +SUMMARY + :Weekly Phone Conference +UID + :calsrv.example.com-873970198738777@example.com +SEQUENCE + :0 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=MONTHLY\;BYMONTHDAY=1\;UNTIL=19980901T210000Z' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970601T210000Z +DTEND + :19970601T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970526T083000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1com +RECURRENCE-ID + :19970701T210000Z +SEQUENCE + :1 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970703T210000Z +DTEND + :19970703T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970626T093000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :CANCEL +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +RECURRENCE-ID + :19970801T210000Z +SEQUENCE + :2 +STATUS + :CANCELLED +DTSTAMP + :19970721T093000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :CANCEL +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +DTSTAMP + :19970721T103000Z +STATUS + :CANCELLED +SEQUENCE + :3 +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +RECURRENCE-ID + :19970901T210000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'THISANDFUTURE' +SEQUENCE + :3 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Discussion +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970901T210000Z +DTEND + :19970901T220000Z +LOCATION + :Building 32 +LOCATION + : Microsoft +LOCATION + : Seattle +LOCATION + : WA +DTSTAMP + :19970526T083000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :ADD +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :4 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970715T210000Z +DTEND + :19970715T220000Z +LOCATION + :Conference Call +DTSTAMP + :19970629T093000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TU\;FREQ=WEEKLY' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +LOCATION + :The White Room +DTSTAMP + :19980301T093000Z +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :ADD +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :7 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TH\;FREQ=WEEKLY' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +DTSTAMP + :19980303T193000Z +LOCATION + :The Usual conference room +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :7 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'WKST=SU\;BYDAY=TU' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980303T210000Z +DTEND + :19980303T220000Z +DTSTAMP + :19980303T193000Z +LOCATION + :The White Room +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :0 +RDATE + :19980304T180000Z +RDATE + :19980311T180000Z +RDATE + :19980318T180000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980304T180000Z +DTEND + :19980304T200000Z +DTSTAMP + :19980303T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :1 +RECURRENCE-ID + :19980311T180000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980311T160000Z +DTEND + :19980311T180000Z +DTSTAMP + :19980306T193000Z +LOCATION + :The Small conference room +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :ADD +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :2 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980315T180000Z +DTEND + :19980315T200000Z +DTSTAMP + :19980307T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :123456789@host1.com +SEQUENCE + :2 +RDATE + :19980304T180000Z +RDATE + :19980311T160000Z +RDATE + :19980315T180000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=COMPONENT_PARSE_ERROR + :Got a data line\, but could not find a property name or component + begin tag: 'Error! Bookmark not defined.' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +SUMMARY + :Review Accounts +DTSTART + :19980304T180000Z +DTEND + :19980304T200000Z +DTSTAMP + :19980303T193000Z +LOCATION + :Conference Room A +STATUS + :CONFIRMED +END:VEVENT +BEGIN:VEVENT +X-LIC-ERROR + ;X-LIC-ERRORTYPE=COMPONENT_PARSE_ERROR + :Got a data line\, but could not find a property name or component + begin tag: 'Error! Bookmark not defined.' +SEQUENCE + :2 +RECURRENCE-ID + :19980311T160000Z +X-LIC-ERROR + ;X-LIC-ERRORTYPE=COMPONENT_PARSE_ERROR + :Got a data line\, but could not find a property name or component + begin tag: 'Error! Bookmark not defined.' +ATTENDEE + :ROLE=CHAIR;Error! Bookmark not defined. +ATTENDEE + :Error! Bookmark not defined. +SUMMARY + :Review Accounts +DTSTART + :19980311T160000Z +DTEND + :19980304T180000Z +DTSTAMP + :19980306T193000Z +LOCATION + :The Small conference room +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :COUNTER +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +RECURRENCE-ID + :19970715T210000Z +SEQUENCE + :4 +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;RSVP=TRUE + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970715T220000Z +DTEND + :19970715T230000Z +LOCATION + :Conference Call +COMMENT + :May we bump this by an hour? I have a conflict +DTSTAMP + :19970629T094000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :guid-1@host1.com +SEQUENCE + :0 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=MONTHLY\;BYMONTHDAY=1' +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DESCRIPTION + :IETF-C&S Conference Call +CLASS + :PUBLIC +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970601T210000Z +DTEND + :19970601T220000Z +DTSTAMP + :19970602T094000Z +LOCATION + :Conference Call +STATUS + :CONFIRMED +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PROPERTY_PARSE_ERROR + :Parse error in property name: 'FOO' +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//RDU Software//NONSGML HandCal//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +REQUEST-STATUS + :2.8\;Repeating event ignored. Scheduled as a single event\;RRULE +REQUEST-STATUS + :3.0\;Invalid Property Name\;FOO +UID + :guid-1@host1.com +SEQUENCE + :0 +DTSTAMP + :19970603T094000Z +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:C@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +DTSTART + :19970701T170000Z +DUE + :19970722T170000Z +PRIORITY + :1 +SUMMARY + :Create the requirements document +UID + :calsrv.example.com-873970198738777-00@example.com +SEQUENCE + :0 +DTSTAMP + :19970717T200000Z +STATUS + :Needs Action +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;PARTSTAT=ACCEPTED + :Mailto:B@example.com +UID + :calsrv.example.com-873970198738777-00@example.com +COMMENT + :I'll send you my input by e-mail +SEQUENCE + :0 +DTSTAMP + :19970717T203000Z +REQUEST-STATUS + :2.0\;Success +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +UID + :calsrv.example.com-873970198738777-00@example.com +SUMMARY + :Create the requirements document +PRIORITY + :1 +SEQUENCE + :0 +STATUS + :IN-PROCESS +DTSTART + :19970701T170000Z +DTSTAMP + :19970717T230000Z +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :MAILTO:A@example.com +ATTENDEE + ;PARTSTAT=IN-PROCESS + :Mailto:B@example.com +PERCENT-COMPLETE + :75 +UID + :calsrv.example.com-873970198738777-00@example.com +DTSTAMP + :19970717T233000Z +SEQUENCE + :0 +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :MAILTO:A@example.com +ATTENDEE + ;PARTSTAT=COMPLETED + :Mailto:D@example.com +UID + :calsrv.example.com-873970198738777-00@example.com +DTSTAMP + :19970717T233000Z +SEQUENCE + :0 +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + ;PARTSTAT=ACCEPTED + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;PARTSTAT=IN-PROCESS + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +DTSTART + :19970701T170000Z +DUE + :19970722T170000Z +PRIORITY + :1 +SUMMARY + :Create the requirements document +UID + :calsrv.example.com-873970198738777-00@example.com +SEQUENCE + :1 +DTSTAMP + :19970718T100000Z +STATUS + :IN-PROGRESS +PERCENT-COMPLETE + :40 +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REQUEST +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + :Mailto:A@example.com +ATTENDEE + ;RSVP=TRUE + :Mailto:B@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +ATTENDEE + ;RSVP=TRUE + :Mailto:D@example.com +X-LIC-ERROR + ;X-LIC-ERRORTYPE=PARAMETER_PARSE_ERROR + :Can't parse parameter name: 'TYPE=INDIVIDUAL' +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=MONTHLY\;COUNT=10\;BYDAY=1FR' +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as DATE-TIME value in DTSTART property. Removing entire + property: '19980101T100000-0700' +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as DATE-TIME value in DUE property. Removing entire property: + '19980103T100000-0700' +SUMMARY + :Send Status Reports to Area Managers +UID + :calsrv.example.com-873970198738777-00@example.com +SEQUENCE + :0 +DTSTAMP + :19970717T200000Z +STATUS + :NEEDS ACTION +PRIORITY + :1 +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//ACME/DesktopCalendar//EN +METHOD + :REPLY +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VTODO +ATTENDEE + ;PARTSTAT=IN-PROCESS + :Mailto:B@example.com +PERCENT-COMPLETE + :75 +UID + :calsrv.example.com-873970198738777-00@example.com +DTSTAMP + :19970717T233000Z +RECURRENCE-ID + :19980101T170000Z +SEQUENCE + :1 +END:VTODO +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :PUBLISH +PRODID + :-//ACME/DesktopCalendar//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VJOURNAL +DTSTART + :19971002T200000Z +ORGANIZER + :MAILTO:A@Example.com +SUMMARY + :Phone conference minutes +DESCRIPTION + :The editors meeting was held on October 1 +DESCRIPTION + : 1997. Details are in the attached document. +UID + :0981234-1234234-2410@example.com +RELATED-TO + :0981234-1234234-2402-35@example.com +ATTACH + :ftp://ftp.example.com/pub/ed/minutes100197.txt +END:VJOURNAL +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//RDU Software//NONSGML HandCal//EN +METHOD + :REFRESH +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +ATTENDEE + :Mailto:C@example.com +ATTENDEE + :Mailto:D@example.com +UID + : guid-1-12345@host1.com +DTSTAMP + :19970603T094000 +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +METHOD + :REQUEST +PRODID + :-//RDU Software//NONSGML HandCal//EN +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +UID + :acme-12345@host1.com +SEQUENCE + :3 +X-LIC-ERROR + ;X-LIC-ERRORTYPE=VALUE_PARSE_ERROR + :Can't parse as RECUR value in RRULE property. Removing entire property: + 'FREQ=WEEKLY' +RDATE + ;VALUE=PERIOD + :19970819T210000Z/19970081T220000Z +ORGANIZER + :Mailto:A@example.com +ATTENDEE + ;ROLE=CHAIR + ;PARTSTAT=ACCEPTED + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +DESCRIPTION + :IETF-C&S Conference Call +SUMMARY + :IETF Calendaring Working Group Meeting +DTSTART + :19970801T210000Z +DTEND + :19970801T220000Z +RECURRENCE-ID + :19970809T210000Z +DTSTAMP + :19970726T083000 +STATUS + :CONFIRMED +END:VEVENT +END:VCALENDAR +BEGIN:VCALENDAR +PRODID + :-//RDU Software//NONSGML HandCal//EN +METHOD + :REFRESH +VERSION + :2.0 +X-LIC-SENDER + :eric@busboom.org +BEGIN:VEVENT +ORGANIZER + :Mailto:A@example.com +ATTENDEE + :Mailto:B@example.com +UID + :acme-12345@host1.com +DTSTAMP + :19970603T094000 +END:VEVENT +END:VCALENDAR +END:VCALENDAR diff --git a/libical/src/test/copycluster b/libical/src/test/copycluster Binary files differnew file mode 100755 index 0000000000..ced0a0157e --- /dev/null +++ b/libical/src/test/copycluster diff --git a/libical/src/test/copycluster.c b/libical/src/test/copycluster.c new file mode 100644 index 0000000000..b059130c13 --- /dev/null +++ b/libical/src/test/copycluster.c @@ -0,0 +1,113 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: copycluster.c + CREATOR: eric 15 January 2000 + + $Id$ + $Locker$ + + (C) COPYRIGHT 2000 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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + + ======================================================================*/ + +#include <stdio.h> /* for printf */ +#include "ical.h" +#include "icalcluster.h" +#include <errno.h> +#include <string.h> /* For strerror */ +#include "icalrestriction.h" + +/* This program copies a file that holds iCal components to an other file. */ + + +void usage(char* arg0) { + printf("usage: %s cluster-file1 cluster-file2\n",arg0); +} + +int main(int c, char *argv[]){ + + icalcluster *clusterin, *clusterout; + icalcomponent *itr; + int count=0; + int tostdout = 0; + + if(c < 2 || c > 3){ + usage(argv[0]); + exit(1); + } + + if (c == 2){ + tostdout = 1; + } + + clusterin = icalcluster_new(argv[1]); + + if (clusterin == 0){ + printf("Could not open input cluster \"%s\"",argv[1]); + + exit(1); + } + + if (!tostdout){ + clusterout = icalcluster_new(argv[2]); + if (clusterout == 0){ + printf("Could not open output cluster \"%s\"\n",argv[2]); + exit(1); + } + } + + + for (itr = icalcluster_get_first_component(clusterin, + ICAL_ANY_COMPONENT); + itr != 0; + itr = icalcluster_get_next_component(clusterin, + ICAL_ANY_COMPONENT)){ + + icalrestriction_check(itr); + + if (itr != 0){ + + if(tostdout){ + + printf("--------------\n%s\n",icalcomponent_as_ical_string(itr)); + } else { + + icalcluster_add_component(clusterout, + icalcomponent_new_clone(itr)); + } + + count++; + + } else { + printf("Got NULL component"); + } + } + + + printf("Transfered %d components\n",count); + + icalcluster_free(clusterin); + + if (!tostdout){ + icalcluster_mark(clusterout); + icalcluster_free(clusterout); + } + + return 0; +} + diff --git a/libical/src/test/findobj b/libical/src/test/findobj Binary files differnew file mode 100755 index 0000000000..ff7058a7b3 --- /dev/null +++ b/libical/src/test/findobj diff --git a/libical/src/test/findobj.c b/libical/src/test/findobj.c new file mode 100644 index 0000000000..e7ec59169a --- /dev/null +++ b/libical/src/test/findobj.c @@ -0,0 +1,71 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: findobj.c + CREATOR: eric 11 February 2000 + + $Id$ + $Locker$ + + (C) COPYRIGHT 2000 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 Code is eric. The Initial Developer of the Original + Code is Eric Busboom + + + ======================================================================*/ + +#include <stdio.h> /* for printf */ +#include "ical.h" +#include "icalcalendar.h" +#include <errno.h> +#include <string.h> /* For strerror */ +#include "icalrestriction.h" + +/* This program finds an object stored in a calendar */ + +void usage(char* arg0) { + printf("usage: %s calendar-dir uid\n",arg0); +} + +int main(int c, char *argv[]){ + + icalcalendar *cal; + icalstore *booked; + icalcomponent *itr; + + if(c < 2 || c > 3){ + usage(argv[0]); + exit(1); + } + + cal = icalcalendar_new(argv[1]); + + if(cal == 0){ + fprintf(stderr,"%s: error in opening calendar \"%s\": %s. errno is \"%s\"\n", + argv[0],argv[1],icalerror_strerror(icalerrno), + strerror(errno)); + } + + booked = icalcalendar_get_booked(cal); + + itr = icalstore_fetch(booked,argv[2]); + + + if(itr != 0){ + printf("%s",icalcomponent_as_ical_string(itr)); + } + + return 0; +} + diff --git a/libical/src/test/icalparser b/libical/src/test/icalparser Binary files differnew file mode 100755 index 0000000000..25d75af1b1 --- /dev/null +++ b/libical/src/test/icalparser diff --git a/libical/src/test/icaltestparser.c b/libical/src/test/icaltestparser.c new file mode 100644 index 0000000000..d56af49258 --- /dev/null +++ b/libical/src/test/icaltestparser.c @@ -0,0 +1,110 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: icaltestparser.c + CREATOR: eric 20 June 1999 + + $Id$ + $Locker$ + + The contents of this file are subject to the Mozilla Public License + Version 1.0 (the "License"); you may not use this file except in + compliance with the License. You may obtain a copy of the License at + http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS IS" + basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + the License for the specific language governing rights and + limitations under the License. + + The original author is Eric Busboom + The original code is icaltestparser.c + + + (C) COPYRIGHT 1999 The Software Studio. + http://www.softwarestudio.org + + ======================================================================*/ + +#include <stdio.h> +#include <errno.h> +#include <stdio.h> +#include <string.h> +#include "ical.h" + +#include <stdlib.h> + +char str[] = "BEGIN:VCALENDAR +PRODID:\"-//RDU Software//NONSGML HandCal//EN\" +VERSION:2.0 +BEGIN:VTIMEZONE +TZID:US-Eastern +BEGIN:STANDARD +DTSTART:19990404T020000 +RDATE:19990u404xT020000 +TZOFFSETFROM:-0500 +TZOFFSETTO:-0400 +END:STANDARD +BEGIN:DAYLIGHT +DTSTART:19990404T020000 +RDATE:19990404T020000 +TZOFFSETFROM:-0500 +TZOFFSETTO:-0400 +TZNAME:EDT +Dkjhgri:derhvnv; +BEGIN:dfkjh +END:dfdfkjh +END:DAYLIGHT +END:VTIMEZONE +BEGIN:VEVENT +GEO:Bongo +DTSTAMP:19980309T231000Z +UID:guid-1.host1.com +ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com +ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP + :MAILTO:employee-A@host.com +DESCRIPTION:Project XYZ Review Meeting +CATEGORIES:MEETING +CLASS:PUBLIC +CREATED:19980309T130000Z +SUMMARY:XYZ Project Review +DTSTART;TZID=US-Eastern:19980312T083000 +DTEND;TZID=US-Eastern:19980312T093000 +LOCATION:1CP Conference Room 4350 +END:VEVENT +END:VCALENDAR +"; + +extern int yydebug; + +/* Have the parser fetch data from stdin */ + +char* read_stdin(char *s, size_t size, void *d) +{ + char *c = fgets(s,size, stdin); + + return c; + +} + +int main() +{ + + /* This is how we would have the parser parse a string */ + /* icalcomponent *c = icalparser_parse_string(str);*/ + + icalcomponent *c = icalparser_parse(read_stdin); + + printf("%s\n",icalcomponent_as_ical_string(c)); + + /* Strip errors and spit it out again + printf("\n%d Errors in Component\n",icalcomponent_count_errors(c)); + icalcomponent_strip_errors(c); + printf("%s\n",icalcomponent_as_ical_string(c)); + */ + + icalmemory_free_ring(); + icalcomponent_free(c); + + return 1; +} + diff --git a/libical/src/test/regression b/libical/src/test/regression Binary files differnew file mode 100755 index 0000000000..181f28b5ab --- /dev/null +++ b/libical/src/test/regression diff --git a/libical/src/test/regression.c b/libical/src/test/regression.c new file mode 100644 index 0000000000..822de6b22c --- /dev/null +++ b/libical/src/test/regression.c @@ -0,0 +1,1314 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: usecases.c + CREATOR: eric 03 April 1999 + + DESCRIPTION: + + $Id$ + $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 usecases.c + + + ======================================================================*/ + +#include "ical.h" +#include <assert.h> +#include <string.h> /* for strdup */ +#include <stdlib.h> /* for malloc */ +#include <stdio.h> /* for printf */ +#include <time.h> /* for time() */ +#include "icalmemory.h" +#include "icalstore.h" +#include "icalcluster.h" +#include "icalerror.h" +#include "icalrestriction.h" +#include "icalcalendar.h" + +/* This example creates and minipulates the ical object that appears + * in rfc 2445, page 137 */ + +/* + BEGIN:VCALENDAR + PRODID:-//RDU Software//NONSGML HandCal//EN + VERSION:2.0 + BEGIN:VTIMEZONE + TZID:US-Eastern + BEGIN:STANDARD + DTSTART:19981025T020000 + RDATE:19981025T020000 + TZOFFSETFROM:-0400 + TZOFFSETTO:-0500 + TZNAME:EST + END:STANDARD + BEGIN:DAYLIGHT + DTSTART:19990404T020000 + RDATE:19990404T020000 + TZOFFSETFROM:-0500 + TZOFFSETTO:-0400 + TZNAME:EDT + END:DAYLIGHT + END:VTIMEZONE + BEGIN:VEVENT + DTSTAMP:19980309T231000Z + UID:guid-1.host1.com + ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com + ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP: + MAILTO:employee-A@host.com + DESCRIPTION:Project XYZ Review Meeting + CATEGORIES:MEETING + CLASS:PUBLIC + CREATED:19980309T130000Z + SUMMARY:XYZ Project Review + DTSTART;TZID=US-Eastern:19980312T083000 + DTEND;TZID=US-Eastern:19980312T093000 + LOCATION:1CP Conference Room 4350 + END:VEVENT + END:VCALENDAR + +*/ +char str[] = "BEGIN:VCALENDAR +PRODID:\"-//RDU Software//NONSGML HandCal//EN\" +VERSION:2.0 +BEGIN:VTIMEZONE +TZID:US-Eastern +BEGIN:STANDARD +DTSTART:19981025T020000 +RDATE:19981025T020000 +TZOFFSETFROM:-0400 +TZOFFSETTO:-0500 +TZNAME:EST +END:STANDARD +BEGIN:DAYLIGHT +DTSTART:19990404T020000 +RDATE:19990404T020000 +TZOFFSETFROM:-0500 +TZOFFSETTO:-0400 +TZNAME:EDT +END:DAYLIGHT +END:VTIMEZONE +BEGIN:VEVENT +DTSTAMP:19980309T231000Z +UID:guid-1.host1.com +ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com +ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com +DESCRIPTION:Project XYZ Review Meeting +CATEGORIES:MEETING +CLASS:PUBLIC +CREATED:19980309T130000Z +SUMMARY:XYZ Project Review +DTSTART;TZID=US-Eastern:19980312T083000 +DTEND;TZID=US-Eastern:19980312T093000 +LOCATION:1CP Conference Room 4350 +END:VEVENT +BEGIN:BOOGA +DTSTAMP:19980309T231000Z +X-LIC-FOO:Booga +DTSTOMP:19980309T231000Z +UID:guid-1.host1.com +END:BOOGA +END:VCALENDAR"; + +void _test_string_line_generator(char* str); + +void test_string_line_generator() { + + _test_string_line_generator(str); + +} + +icalcomponent* create_simple_component() +{ + + icalcomponent* calendar; + struct icalperiodtype rtime; + + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + + rtime.end.hour++; + + + + /* Create calendar and add properties */ + calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT); + + + icalcomponent_add_property( + calendar, + icalproperty_new_version("2.0") + ); + + printf("%s\n",icalcomponent_as_ical_string(calendar)); + + return calendar; + +} + +/* Create a new component */ +icalcomponent* create_new_component() +{ + + icalcomponent* calendar; + icalcomponent* timezone; + icalcomponent* tzc; + icalcomponent* event; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icalperiodtype rtime; + icalproperty* property; + + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + + rtime.end.hour++; + + + + /* Create calendar and add properties */ + calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT); + + + icalcomponent_add_property( + calendar, + icalproperty_new_version("2.0") + ); + + icalcomponent_add_property( + calendar, + icalproperty_new_prodid("-//RDU Software//NONSGML HandCal//EN") + ); + + /* Create a timezone object and add it to the calendar */ + + timezone = icalcomponent_new(ICAL_VTIMEZONE_COMPONENT); + + icalcomponent_add_property( + timezone, + icalproperty_new_tzid("US_Eastern") + ); + + /* Add a sub-component of the timezone */ + tzc = icalcomponent_new(ICAL_XDAYLIGHT_COMPONENT); + + icalcomponent_add_property( + tzc, + icalproperty_new_dtstart(atime) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_rdate(rtime) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzoffsetfrom(-4.0) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzoffsetto(-5.0) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzname("EST") + ); + + icalcomponent_add_component(timezone,tzc); + + icalcomponent_add_component(calendar,timezone); + + /* Add a second subcomponent */ + tzc = icalcomponent_new(ICAL_XSTANDARD_COMPONENT); + + icalcomponent_add_property( + tzc, + icalproperty_new_dtstart(atime) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_rdate(rtime) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzoffsetfrom(-4.0) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzoffsetto(-5.0) + ); + + icalcomponent_add_property( + tzc, + icalproperty_new_tzname("EST") + ); + + icalcomponent_add_component(timezone,tzc); + + /* Add an event */ + + event = icalcomponent_new(ICAL_VEVENT_COMPONENT); + + icalcomponent_add_property( + event, + icalproperty_new_dtstamp(atime) + ); + + icalcomponent_add_property( + event, + icalproperty_new_uid("guid-1.host1.com") + ); + + /* add a property that has parameters */ + property = icalproperty_new_organizer("mrbig@host.com"); + + icalproperty_add_parameter( + property, + icalparameter_new_role(ICAL_ROLE_CHAIR) + ); + + icalcomponent_add_property(event,property); + + /* add another property that has parameters */ + property = icalproperty_new_attendee("employee-A@host.com"); + + icalproperty_add_parameter( + property, + icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT) + ); + + icalproperty_add_parameter( + property, + icalparameter_new_rsvp(1) + ); + + icalproperty_add_parameter( + property, + icalparameter_new_cutype(ICAL_CUTYPE_GROUP) + ); + + icalcomponent_add_property(event,property); + + + /* more properties */ + + icalcomponent_add_property( + event, + icalproperty_new_description("Project XYZ Review Meeting") + ); + + icalcomponent_add_property( + event, + icalproperty_new_categories("MEETING") + ); + + icalcomponent_add_property( + event, + icalproperty_new_class("PUBLIC") + ); + + icalcomponent_add_property( + event, + icalproperty_new_created(atime) + ); + + icalcomponent_add_property( + event, + icalproperty_new_summary("XYZ Project Review") + ); + + + property = icalproperty_new_dtstart(atime); + + icalproperty_add_parameter( + property, + icalparameter_new_tzid("US-Eastern") + ); + + icalcomponent_add_property(event,property); + + + property = icalproperty_new_dtend(atime); + + icalproperty_add_parameter( + property, + icalparameter_new_tzid("US-Eastern") + ); + + icalcomponent_add_property(event,property); + + icalcomponent_add_property( + event, + icalproperty_new_location("1CP Conference Room 4350") + ); + + icalcomponent_add_component(calendar,event); + + printf("%s\n",icalcomponent_as_ical_string(calendar)); + + icalcomponent_free(calendar); + + return 0; +} + + +/* Create a new component, using the va_args list */ + +icalcomponent* create_new_component_with_va_args() +{ + + icalcomponent* calendar; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icalperiodtype rtime; + + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + + rtime.end.hour++; + + calendar = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_version("2.0"), + icalproperty_new_prodid("-//RDU Software//NONSGML HandCal//EN"), + icalcomponent_vanew( + ICAL_VTIMEZONE_COMPONENT, + icalproperty_new_tzid("US_Eastern"), + icalcomponent_vanew( + ICAL_XDAYLIGHT_COMPONENT, + icalproperty_new_dtstart(atime), + icalproperty_new_rdate(rtime), + icalproperty_new_tzoffsetfrom(-4.0), + icalproperty_new_tzoffsetto(-5.0), + icalproperty_new_tzname("EST"), + 0 + ), + icalcomponent_vanew( + ICAL_XSTANDARD_COMPONENT, + icalproperty_new_dtstart(atime), + icalproperty_new_rdate(rtime), + icalproperty_new_tzoffsetfrom(-5.0), + icalproperty_new_tzoffsetto(-4.0), + icalproperty_new_tzname("EST"), + 0 + ), + 0 + ), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstamp(atime), + icalproperty_new_uid("guid-1.host1.com"), + icalproperty_vanew_organizer( + "mrbig@host.com", + icalparameter_new_role(ICAL_ROLE_CHAIR), + 0 + ), + icalproperty_vanew_attendee( + "employee-A@host.com", + icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT), + icalparameter_new_rsvp(1), + icalparameter_new_cutype(ICAL_CUTYPE_GROUP), + 0 + ), + icalproperty_new_description("Project XYZ Review Meeting"), + icalproperty_new_categories("MEETING"), + icalproperty_new_class("PUBLIC"), + icalproperty_new_created(atime), + icalproperty_new_summary("XYZ Project Review"), + icalproperty_vanew_dtstart( + atime, + icalparameter_new_tzid("US-Eastern"), + 0 + ), + icalproperty_vanew_dtend( + atime, + icalparameter_new_tzid("US-Eastern"), + 0 + ), + icalproperty_new_location("1CP Conference Room 4350"), + 0 + ), + 0 + ); + + printf("%s\n",icalcomponent_as_ical_string(calendar)); + + + icalcomponent_free(calendar); + + return 0; +} + + +/* Return a list of all attendees who are required. */ + +char** get_required_attendees(icalproperty* event) +{ + icalproperty* p; + icalparameter* parameter; + + char **attendees; + int max = 10; + int c = 0; + + attendees = malloc(max * (sizeof (char *))); + + assert(event != 0); + assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT); + + for( + p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) + ) { + + parameter = icalproperty_get_first_parameter(p,ICAL_ROLE_PARAMETER); + + if ( icalparameter_get_role(parameter) == ICAL_ROLE_REQPARTICIPANT) + { + attendees[c++] = strdup(icalproperty_get_attendee(p)); + + if (c >= max) { + max *= 2; + attendees = realloc(attendees, max * (sizeof (char *))); + } + + } + } + + return attendees; +} + +/* If an attendee has a PARTSTAT of NEEDSACTION or has no PARTSTAT + parameter, change it to TENTATIVE. */ + +void update_attendees(icalproperty* event) +{ + icalproperty* p; + icalparameter* parameter; + + + assert(event != 0); + assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT); + + for( + p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) + ) { + + parameter = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER); + + if (parameter == 0) { + + icalproperty_add_parameter( + p, + icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) + ); + + } else if (icalparameter_get_partstat(parameter) == ICAL_PARTSTAT_NEEDSACTION) { + + icalproperty_remove_parameter(p,ICAL_PARTSTAT_PARAMETER); + + icalparameter_free(parameter); + + icalproperty_add_parameter( + p, + icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) + ); + } + + } +} + + +void test_values() +{ + icalvalue *v; + icalvalue *copy; + + v = icalvalue_new_caladdress("cap://value/1"); + printf("caladdress 1: %s\n",icalvalue_get_caladdress(v)); + icalvalue_set_caladdress(v,"cap://value/2"); + printf("caladdress 2: %s\n",icalvalue_get_caladdress(v)); + printf("String: %s\n",icalvalue_as_ical_string(v)); + + copy = icalvalue_new_clone(v); + printf("Clone: %s\n",icalvalue_as_ical_string(v)); + icalvalue_free(v); + icalvalue_free(copy); + + + v = icalvalue_new_boolean(1); + printf("caladdress 1: %d\n",icalvalue_get_boolean(v)); + icalvalue_set_boolean(v,2); + printf("caladdress 2: %d\n",icalvalue_get_boolean(v)); + printf("String: %s\n",icalvalue_as_ical_string(v)); + + copy = icalvalue_new_clone(v); + printf("Clone: %s\n",icalvalue_as_ical_string(v)); + icalvalue_free(v); + icalvalue_free(copy); + + + v = icalvalue_new_date(icaltimetype_from_timet( time(0),0)); + printf("date 1: %s\n",icalvalue_as_ical_string(v)); + icalvalue_set_date(v,icaltimetype_from_timet( time(0)+3600,0)); + printf("date 2: %s\n",icalvalue_as_ical_string(v)); + + copy = icalvalue_new_clone(v); + printf("Clone: %s\n",icalvalue_as_ical_string(v)); + icalvalue_free(v); + icalvalue_free(copy); + + + v = icalvalue_new(-1); + + printf("Invalid type: %p\n",v); + + if (v!=0) icalvalue_free(v); + + + /* v = icalvalue_new_caladdress(0); + + printf("Bad string: %p\n",v); + + if (v!=0) icalvalue_free(v); */ + +} + +void test_properties() +{ + icalproperty *prop; + icalparameter *param; + + icalproperty *clone; + + prop = icalproperty_vanew_comment( + "Another Comment", + icalparameter_new_cn("A Common Name 1"), + icalparameter_new_cn("A Common Name 2"), + icalparameter_new_cn("A Common Name 3"), + icalparameter_new_cn("A Common Name 4"), + 0); + + for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PROPERTY); + param != 0; + param = icalproperty_get_next_parameter(prop,ICAL_ANY_PROPERTY)) { + + printf("Prop parameter: %s\n",icalparameter_get_cn(param)); + } + + printf("Prop value: %s\n",icalproperty_get_comment(prop)); + + + printf("As iCAL string:\n %s\n",icalproperty_as_ical_string(prop)); + + clone = icalproperty_new_clone(prop); + + printf("Clone:\n %s\n",icalproperty_as_ical_string(prop)); + + icalproperty_free(clone); + icalproperty_free(prop); + + prop = icalproperty_new(-1); + + printf("Invalid type: %p\n",prop); + + if (prop!=0) icalproperty_free(prop); + + /* + prop = icalproperty_new_method(0); + + printf("Bad string: %p\n",prop); + + + if (prop!=0) icalproperty_free(prop); + */ +} + +void test_parameters() +{ + icalparameter *p; + + p = icalparameter_new_cn("A Common Name"); + + printf("Common Name: %s\n",icalparameter_get_cn(p)); + + printf("As String: %s\n",icalparameter_as_ical_string(p)); + + icalparameter_free(p); +} + + +void test_components() +{ + + icalcomponent* c; + icalcomponent* child; + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_version("2.0"), + icalproperty_new_prodid("-//RDU Software//NONSGML HandCal//EN"), + icalproperty_vanew_comment( + "A Comment", + icalparameter_new_cn("A Common Name 1"), + 0), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_version("2.0"), + icalproperty_new_description("This is an event"), + icalproperty_vanew_comment( + "Another Comment", + icalparameter_new_cn("A Common Name 1"), + icalparameter_new_cn("A Common Name 2"), + icalparameter_new_cn("A Common Name 3"), + icalparameter_new_cn("A Common Name 4"), + 0), + icalproperty_vanew_xlicerror( + "This is only a test", + icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_COMPONENTPARSEERROR), + 0), + + 0 + ), + 0 + ); + + printf("Original Component:\n%s\n\n",icalcomponent_as_ical_string(c)); + + child = icalcomponent_get_first_component(c,ICAL_VEVENT_COMPONENT); + + printf("Child Component:\n%s\n\n",icalcomponent_as_ical_string(child)); + + icalcomponent_free(c); + +} + +void test_memory() +{ + size_t bufsize = 256; + char *p; + + char S1[] = "1) When in the Course of human events, "; + char S2[] = "2) it becomes necessary for one people to dissolve the political bands which have connected them with another, "; + char S3[] = "3) and to assume among the powers of the earth, "; + char S4[] = "4) the separate and equal station to which the Laws of Nature and of Nature's God entitle them, "; + char S5[] = "5) a decent respect to the opinions of mankind requires that they "; + char S6[] = "6) should declare the causes which impel them to the separation. "; + char S7[] = "7) We hold these truths to be self-evident, "; + char S8[] = "8) that all men are created equal, "; + +/* char S9[] = "9) that they are endowed by their Creator with certain unalienable Rights, "; + char S10[] = "10) that among these are Life, Liberty, and the pursuit of Happiness. "; + char S11[] = "11) That to secure these rights, Governments are instituted among Men, "; + char S12[] = "12) deriving their just powers from the consent of the governed. "; +*/ + + + char *f, *b1, *b2, *b3, *b4, *b5, *b6, *b7, *b8; + + #define BUFSIZE 1024 + + + f = icalmemory_new_buffer(bufsize); + p = f; + b1 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b1, S1); + icalmemory_append_string(&f, &p, &bufsize, b1); + + b2 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b2, S2); + icalmemory_append_string(&f, &p, &bufsize, b2); + + b3 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b3, S3); + icalmemory_append_string(&f, &p, &bufsize, b3); + + b4 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b4, S4); + icalmemory_append_string(&f, &p, &bufsize, b4); + + b5 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b5, S5); + icalmemory_append_string(&f, &p, &bufsize, b5); + + b6 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b6, S6); + icalmemory_append_string(&f, &p, &bufsize, b6); + + b7 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b7, S7); + icalmemory_append_string(&f, &p, &bufsize, b7); + + b8 = icalmemory_tmp_buffer(BUFSIZE); + strcpy(b8, S8); + icalmemory_append_string(&f, &p, &bufsize, b8); + + + printf("1: %p %s \n",b1,b1); + printf("2: %p %s\n",b2,b2); + printf("3: %p %s\n",b3,b3); + printf("4: %p %s\n",b4,b4); + printf("5: %p %s\n",b5,b5); + printf("6: %p %s\n",b6,b6); + printf("7: %p %s\n",b7,b7); + printf("8: %p %s\n",b8,b8); + + + printf("Final: %s\n", f); + + printf("Final buffer size: %d\n",bufsize); + + free(f); + + bufsize = 4; + f = icalmemory_new_buffer(bufsize); + p = f; + + icalmemory_append_char(&f, &p, &bufsize, 'a'); + icalmemory_append_char(&f, &p, &bufsize, 'b'); + icalmemory_append_char(&f, &p, &bufsize, 'c'); + icalmemory_append_char(&f, &p, &bufsize, 'd'); + icalmemory_append_char(&f, &p, &bufsize, 'e'); + icalmemory_append_char(&f, &p, &bufsize, 'f'); + icalmemory_append_char(&f, &p, &bufsize, 'g'); + icalmemory_append_char(&f, &p, &bufsize, 'h'); + icalmemory_append_char(&f, &p, &bufsize, 'i'); + icalmemory_append_char(&f, &p, &bufsize, 'j'); + icalmemory_append_char(&f, &p, &bufsize, 'a'); + icalmemory_append_char(&f, &p, &bufsize, 'b'); + icalmemory_append_char(&f, &p, &bufsize, 'c'); + icalmemory_append_char(&f, &p, &bufsize, 'd'); + icalmemory_append_char(&f, &p, &bufsize, 'e'); + icalmemory_append_char(&f, &p, &bufsize, 'f'); + icalmemory_append_char(&f, &p, &bufsize, 'g'); + icalmemory_append_char(&f, &p, &bufsize, 'h'); + icalmemory_append_char(&f, &p, &bufsize, 'i'); + icalmemory_append_char(&f, &p, &bufsize, 'j'); + + printf("Char-by-Char buffer: %s\n", f); + +} + +int test_parser() +{ + + + icalcomponent *c = icalparser_parse_string(str); + printf("%s\n",icalcomponent_as_ical_string(c)); + icalcomponent_free(c); + icalmemory_free_ring(); + return 1; +} + + +int test_store() +{ + + icalcomponent *c, *gauge; + icalerrorenum error; + icalcomponent *next, *itr; + icalcluster* cluster; + struct icalperiodtype rtime; + icalstore *s = icalstore_new("store"); + int i; + + rtime.start = icaltimetype_from_timet( time(0),0); + + cluster = icalcluster_new("clusterin.vcd"); + + if (cluster == 0){ + printf("Failed to create cluster: %s\n",icalerror_strerror(icalerrno)); + return 0; + } + +#define NUMCOMP 4 + + /* Duplicate every component in the cluster NUMCOMP times */ + + icalerror_clear_errno(); + + for (i = 1; i<NUMCOMP+1; i++){ + + /*rtime.start.month = i%12;*/ + rtime.start.month = i; + rtime.end = rtime.start; + rtime.end.hour++; + + for (itr = icalcluster_get_first_component(cluster, + ICAL_ANY_COMPONENT); + itr != 0; + itr = icalcluster_get_next_component(cluster, + ICAL_ANY_COMPONENT)){ + icalcomponent *clone; + icalproperty *p; + + + if(icalcomponent_isa(itr) != ICAL_VEVENT_COMPONENT){ + continue; + } + + assert(itr != 0); + + /* Change the dtstart and dtend times in the component + pointed to by Itr*/ + + clone = icalcomponent_new_clone(itr); + assert(icalerrno == ICAL_NO_ERROR); + assert(clone !=0); + + /* DTSTART*/ + p = icalcomponent_get_first_property(clone,ICAL_DTSTART_PROPERTY); + assert(icalerrno == ICAL_NO_ERROR); + + if (p == 0){ + p = icalproperty_new_dtstart(rtime.start); + icalcomponent_add_property(clone,p); + } else { + icalproperty_set_dtstart(p,rtime.start); + } + assert(icalerrno == ICAL_NO_ERROR); + + /* DTEND*/ + p = icalcomponent_get_first_property(clone,ICAL_DTEND_PROPERTY); + assert(icalerrno == ICAL_NO_ERROR); + + if (p == 0){ + p = icalproperty_new_dtstart(rtime.end); + icalcomponent_add_property(clone,p); + } else { + icalproperty_set_dtstart(p,rtime.end); + } + assert(icalerrno == ICAL_NO_ERROR); + + printf("\n----------\n%s\n---------\n",icalcomponent_as_ical_string(clone)); + + error = icalstore_add_component(s,clone); + + assert(icalerrno == ICAL_NO_ERROR); + + } + + } + + gauge = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_summary( + "Submit Income Taxes", + icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL), + 0), + 0), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_summary( + "Bastille Day Party", + icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL), + 0), + 0), + 0); + +#if 0 + + + icalstore_select(s,gauge); + + for(c = icalstore_first(s); c != 0; c = icalstore_next(s)){ + + printf("Got one! (%d)\n", count++); + + if (c != 0){ + printf("%s", icalcomponent_as_ical_string(c));; + if (icalstore_store(s2,c) == 0){ + printf("Failed to write!\n"); + } + icalcomponent_free(c); + } else { + printf("Failed to get component\n"); + } + } + + + icalstore_free(s2); +#endif + + + for(c = icalstore_get_first_component(s); + c != 0; + c = next){ + + next = icalstore_get_next_component(s); + + if (c != 0){ + /*icalstore_remove_component(s,c);*/ + printf("%s", icalcomponent_as_ical_string(c));; + } else { + printf("Failed to get component\n"); + } + + + } + + icalstore_free(s); + return 0; +} + +int test_compare() +{ + icalvalue *v1, *v2; + icalcomponent *c, *gauge; + + v1 = icalvalue_new_caladdress("cap://value/1"); + v2 = icalvalue_new_clone(v1); + + printf("%d\n",icalvalue_compare(v1,v2)); + + v1 = icalvalue_new_caladdress("A"); + v2 = icalvalue_new_caladdress("B"); + + printf("%d\n",icalvalue_compare(v1,v2)); + + v1 = icalvalue_new_caladdress("B"); + v2 = icalvalue_new_caladdress("A"); + + printf("%d\n",icalvalue_compare(v1,v2)); + + v1 = icalvalue_new_integer(5); + v2 = icalvalue_new_integer(5); + + printf("%d\n",icalvalue_compare(v1,v2)); + + v1 = icalvalue_new_integer(5); + v2 = icalvalue_new_integer(10); + + printf("%d\n",icalvalue_compare(v1,v2)); + + v1 = icalvalue_new_integer(10); + v2 = icalvalue_new_integer(5); + + printf("%d\n",icalvalue_compare(v1,v2)); + + + gauge = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_comment( + "Comment", + icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL), + 0), + 0), + 0); + + c = icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_comment( + "Comment", + 0), + 0); + + printf("%s",icalcomponent_as_ical_string(gauge)); + + printf("%d\n",icalstore_test(c,gauge)); + + return 0; +} + +void test_restriction() +{ + icalcomponent *comp; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + int valid; + + struct icalperiodtype rtime; + + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + + rtime.end.hour++; + + + /* Property restrictions */ + assert(icalrestriction_get_property_restriction( + ICAL_METHOD_PUBLISH, + ICAL_VEVENT_COMPONENT, + ICAL_SEQUENCE_PROPERTY) == 5); /* ZEROORONE -> 5 */ + + assert(icalrestriction_get_property_restriction( + ICAL_METHOD_PUBLISH, + ICAL_VEVENT_COMPONENT, + ICAL_ATTACH_PROPERTY)==3); /* ZEROPLUS -> 3 */ + + assert(icalrestriction_get_property_restriction( + ICAL_METHOD_DECLINECOUNTER, + ICAL_VEVENT_COMPONENT, + ICAL_SEQUENCE_PROPERTY)==1); /* ZERO -> 1 */ + + /* Component restrictions */ + assert(icalrestriction_get_component_restriction( + ICAL_METHOD_PUBLISH, + ICAL_VJOURNAL_COMPONENT, + ICAL_X_COMPONENT) == 3); /* ZEROPLUS */ + + assert(icalrestriction_get_component_restriction( + ICAL_METHOD_CANCEL, + ICAL_VJOURNAL_COMPONENT, + ICAL_VEVENT_COMPONENT) == 1); /* ZERO */ + + comp = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_version("2.0"), + icalproperty_new_prodid("-//RDU Software//NONSGML HandCal//EN"), + icalproperty_new_method(ICAL_METHOD_CANCEL), + icalcomponent_vanew( + ICAL_VTIMEZONE_COMPONENT, + icalproperty_new_tzid("US_Eastern"), + icalcomponent_vanew( + ICAL_XDAYLIGHT_COMPONENT, + icalproperty_new_dtstart(atime), + icalproperty_new_rdate(rtime), + icalproperty_new_tzoffsetfrom(-4.0), + icalproperty_new_tzoffsetto(-5.0), + icalproperty_new_tzname("EST"), + 0 + ), + icalcomponent_vanew( + ICAL_XSTANDARD_COMPONENT, + icalproperty_new_dtstart(atime), + icalproperty_new_rdate(rtime), + icalproperty_new_tzoffsetfrom(-5.0), + icalproperty_new_tzoffsetto(-4.0), + icalproperty_new_tzname("EST"), + 0 + ), + 0 + ), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstamp(atime), + icalproperty_new_uid("guid-1.host1.com"), + icalproperty_vanew_organizer( + "mrbig@host.com", + icalparameter_new_role(ICAL_ROLE_CHAIR), + 0 + ), + icalproperty_vanew_attendee( + "employee-A@host.com", + icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT), + icalparameter_new_rsvp(1), + icalparameter_new_cutype(ICAL_CUTYPE_GROUP), + 0 + ), + icalproperty_new_description("Project XYZ Review Meeting"), + icalproperty_new_categories("MEETING"), + icalproperty_new_class("PUBLIC"), + icalproperty_new_created(atime), + icalproperty_new_summary("XYZ Project Review"), + icalproperty_vanew_dtstart( + atime, + icalparameter_new_tzid("US-Eastern"), + 0 + ), + icalproperty_vanew_dtend( + atime, + icalparameter_new_tzid("US-Eastern"), + 0 + ), + icalproperty_new_location("1CP Conference Room 4350"), + 0 + ), + 0 + ); + + valid = icalrestriction_check(comp); + + printf("#### %d ####\n%s\n",valid, icalcomponent_as_ical_string(comp)); + +} + +void test_calendar() +{ + icalcomponent *comp; + icalcluster *c; + icalstore *s; + icalcalendar* calendar = icalcalendar_new("calendar"); + icalerrorenum error; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + + comp = icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_version("2.0"), + icalproperty_new_description("This is an event"), + icalproperty_new_dtstart(atime), + icalproperty_vanew_comment( + "Another Comment", + icalparameter_new_cn("A Common Name 1"), + icalparameter_new_cn("A Common Name 2"), + icalparameter_new_cn("A Common Name 3"), + icalparameter_new_cn("A Common Name 4"), + 0), + icalproperty_vanew_xlicerror( + "This is only a test", + icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_COMPONENTPARSEERROR), + 0), + + 0); + + + s = icalcalendar_get_booked(calendar); + + error = icalstore_add_component(s,comp); + + assert(error == ICAL_NO_ERROR); + + c = icalcalendar_get_properties(calendar); + + error = icalcluster_add_component(c,icalcomponent_new_clone(comp)); + + assert(error == ICAL_NO_ERROR); + + icalcalendar_free(calendar); + +} + +void test_recur() +{ + icalvalue *v; + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=DAILY;COUNT=5;BYDAY=MO,TU,WE,TH,FR"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=YEARLY;UNTIL=123456T123456;BYSETPOS=-1,2"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=YEARLY;UNTIL=123456T123456;INTERVAL=2;BYMONTH=1;BYDAY=SU;BYHOUR=8,9;BYMINUTE=30"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=MONTHLY;BYDAY=-1MO,TU,WE,TH,FR"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=WEEKLY;INTERVAL=20;WKST=SU;BYDAY=TU"); + + printf("%s\n",icalvalue_as_ical_string(v)); + +} + +void test_duration() +{ + + icalvalue *v; + + v = icalvalue_new_from_string(ICAL_DURATION_VALUE, + "PT8H30M"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_PERIOD_VALUE, + "19971015T050000Z/PT8H30M"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_PERIOD_VALUE, + "19971015T050000Z/19971015T060000Z"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + +} + +int main(int argc, char *argv[]) +{ + +#if 0 + printf("\n------------Test Calendar---------------\n"); + test_calendar(); + + printf("\n------------Test Store---------------\n"); + test_store(); + + printf("\n------------Test duration---------------\n"); + test_duration(); + +#endif + + printf("\n------------Test recur---------------\n"); + test_recur(); + + + +exit(0); + + printf("\n------------Test Restriction---------------\n"); + test_restriction(); + + + + printf("\n------------Test Compare---------------\n"); + test_compare(); + + printf("\n------------Test Memory---------------\n"); + test_memory(); + + printf("\n------------Test Values---------------\n"); + test_values(); + + printf("\n------------Test Parameters-----------\n"); + test_parameters(); + + printf("\n------------Test Properties-----------\n"); + test_properties(); + + printf("\n------------Test Components ----------\n"); + test_components(); + + printf("\n------------Create Components --------\n"); + create_new_component(); + + printf("\n------------Test Parser---------------\n"); + test_parser(); + + printf("\n----- Create Components with vaargs ---\n"); + create_new_component_with_va_args(); + + + + + return 0; +} + + + diff --git a/libical/src/test/usecases b/libical/src/test/usecases Binary files differnew file mode 100755 index 0000000000..541faf8388 --- /dev/null +++ b/libical/src/test/usecases diff --git a/libical/src/test/usecases.c b/libical/src/test/usecases.c new file mode 100644 index 0000000000..d07b5edac5 --- /dev/null +++ b/libical/src/test/usecases.c @@ -0,0 +1,561 @@ +/* -*- Mode: C -*- + ====================================================================== + FILE: usecases.c + CREATOR: eric 03 April 1999 + + DESCRIPTION: + + $Id$ + $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 usecases.c + + + ======================================================================*/ + +#include "ical.h" +#include <assert.h> +#include <string.h> /* for strdup */ +#include <stdlib.h> /* for malloc */ +#include <stdio.h> /* for printf */ +#include <time.h> /* for time() */ +#include "icalmemory.h" + +/* + + Here is the example iCal object that the examples routines in this + file will use: + + BEGIN:VCALENDAR + PRODID:-//RDU Software//NONSGML HandCal//EN + VERSION:2.0 + BEGIN:VTIMEZONE + BEGIN:VEVENT + DTSTAMP:19980309T231000Z + UID:guid-1.host1.com + ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com + ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP: + MAILTO:employee-A@host.com + DESCRIPTION:Project XYZ Review Meeting + CREATED:19980309T130000Z + SUMMARY:XYZ Project Review + DTSTART;TZID=US-Eastern:19980312T083000 + DTEND;TZID=US-Eastern:19980312T093000 + END:VEVENT + END:VCALENDAR + +*/ +char str[] = "BEGIN:VCALENDAR +PRODID:\"-//RDU Software//NONSGML HandCal//EN\" +VERSION:2.0 +BEGIN:VEVENT +DTSTAMP:19980309T231000Z +UID:guid-1.host1.com +ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com +ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com +DESCRIPTION:Project XYZ Review Meeting +CATEGORIES:MEETING +CREATED:19980309T130000Z +SUMMARY:XYZ Project Review +DTSTART;TZID=US-Eastern:19980312T083000 +DTEND;TZID=US-Eastern:19980312T093000 +END:VEVENT +END:VCALENDAR"; + +/* Creating iCal Components + + There are two ways to create new component in libical. You can + build the component from primitive parts, or you can create it + from a string. + + There are two variations of the API for building the component from + primitive parts. In the first variation, you add each parameter and + value to a property, and then add each property to a + component. This results in a long series of function calls. This + style is show in create_new_component() + + The second variation uses vargs lists to nest many primitive part + constructors, resulting in a compact, neatly formated way to create + components. This style is shown in create_new_component_with_va_args() + + + +*/ + +icalcomponent* create_new_component() +{ + + /* variable definitions */ + icalcomponent* calendar; + icalcomponent* event; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icalperiodtype rtime; + icalproperty* property; + + /* Define a time type that will use as data later. */ + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + rtime.end.hour++; + + /* Create calendar and add properties */ + + calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT); + + /* Nearly every libical function call has the same general + form. The first part of the name defines the 'class' for the + function, and the first argument will be a pointer to a struct + of that class. So, icalcomponent_ functions will all take + icalcomponent* as their first argument. */ + + /* The next call creates a new proeprty and immediately adds it to the + 'calendar' component. */ + + icalcomponent_add_property( + calendar, + icalproperty_new_version(strdup("2.0")) + ); + + /* Note the use of strdup() in the previous and next call. All + properties constructors for properties with value types of + TEXT will take control of the string you pass into them. Since + the string '2.0' is a static string, we need to duplicate it in + new memory before giving it to the property */ + + /* Here is the short version of the memory rules: + + If the routine name has "new" in it: + Caller owns the returned memory. + If you pass in a string, the routine takes the memory. + + If the routine name has "add" in it: + The routine takes control of the component, property, + parameter or value memory. + + If the routine returns a string ( "get" and "as_ical_string" ) + The library owns the returned memory. + + */ + + icalcomponent_add_property( + calendar, + icalproperty_new_prodid(strdup("-//RDU Software//NONSGML HandCal//EN")) + ); + + /* Add an event */ + + event = icalcomponent_new(ICAL_VEVENT_COMPONENT); + + icalcomponent_add_property( + event, + icalproperty_new_dtstamp(atime) + ); + + /* In the previous call, atime is a struct, and it is passed in by value. + This is how all compound types of values are handled. */ + + icalcomponent_add_property( + event, + icalproperty_new_uid(strdup("guid-1.host1.com")) + ); + + /* add a property that has parameters */ + property = icalproperty_new_organizer(strdup("mrbig@host.com")); + + icalproperty_add_parameter( + property, + icalparameter_new_role(ICAL_ROLE_CHAIR) + ); + + icalcomponent_add_property(event,property); + + /* In this style of component creation, you need to use an extra + call to add parameters to properties, but the form of this + operation is the same as adding a property to a component */ + + /* add another property that has parameters */ + property = icalproperty_new_attendee(strdup("employee-A@host.com")); + + icalproperty_add_parameter( + property, + icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT) + ); + + icalproperty_add_parameter( + property, + icalparameter_new_rsvp(1) + ); + + icalproperty_add_parameter( + property, + icalparameter_new_cutype(ICAL_CUTYPE_GROUP) + ); + + icalcomponent_add_property(event,property); + + + /* more properties */ + + icalcomponent_add_property( + event, + icalproperty_new_description(strdup("Project XYZ Review Meeting")) + ); + + icalcomponent_add_property( + event, + icalproperty_new_categories(strdup("MEETING")) + ); + + icalcomponent_add_property( + event, + icalproperty_new_class(strdup("PUBLIC")) + ); + + icalcomponent_add_property( + event, + icalproperty_new_created(atime) + ); + + icalcomponent_add_property( + event, + icalproperty_new_summary(strdup("XYZ Project Review")) + ); + + property = icalproperty_new_dtstart(atime); + + icalproperty_add_parameter( + property, + icalparameter_new_tzid(strdup("US-Eastern")) + ); + + icalcomponent_add_property(event,property); + + + property = icalproperty_new_dtend(atime); + + icalproperty_add_parameter( + property, + icalparameter_new_tzid(strdup("US-Eastern")) + ); + + icalcomponent_add_property(event,property); + + icalcomponent_add_property( + event, + icalproperty_new_location(strdup("1CP Conference Room 4350")) + ); + + icalcomponent_add_component(calendar,event); + + return calendar; +} + + +/* Now, create the same component as in the previous routine, but use +the constructor style. */ + +icalcomponent* create_new_component_with_va_args() +{ + + /* This is a similar set up to the last routine */ + icalcomponent* calendar; + struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icalperiodtype rtime; + + rtime.start = icaltimetype_from_timet( time(0),0); + rtime.end = icaltimetype_from_timet( time(0),0); + rtime.end.hour++; + + /* Some of these routines are the same as those in the previous + routine, but we've also added several 'vanew' routines. These + 'vanew' routines take a list of properties, parameters or + values and add each of them to the parent property or + component. */ + + calendar = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_version(strdup("2.0")), + icalproperty_new_prodid(strdup("-//RDU Software//NONSGML HandCal//EN")), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstamp(atime), + icalproperty_new_uid(strdup("guid-1.host1.com")), + icalproperty_vanew_organizer( + strdup("mrbig@host.com"), + icalparameter_new_role(ICAL_ROLE_CHAIR), + 0 + ), + icalproperty_vanew_attendee( + strdup("employee-A@host.com"), + icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT), + icalparameter_new_rsvp(1), + icalparameter_new_cutype(ICAL_CUTYPE_GROUP), + 0 + ), + icalproperty_new_description(strdup("Project XYZ Review Meeting")), + icalproperty_new_categories(strdup("MEETING")), + icalproperty_new_class(strdup("PUBLIC")), + icalproperty_new_created(atime), + icalproperty_new_summary(strdup("XYZ Project Review")), + icalproperty_vanew_dtstart( + atime, + icalparameter_new_tzid(strdup("US-Eastern")), + 0 + ), + icalproperty_vanew_dtend( + atime, + icalparameter_new_tzid(strdup("US-Eastern")), + 0 + ), + icalproperty_new_location(strdup("1CP Conference Room 4350")), + 0 + ), + 0 + ); + + + /* Note that properties with no parameters can use the regular + 'new' constructor, while those with parameters use the 'vanew' + constructor. And, be sure that the last argument in the 'vanew' + call is a zero. Without, your program will probably crash. */ + + return calendar; +} + + +/* Now, lets try to get a particular parameter out of a + component. This routine will return a list of strings of all + attendees who are required. Note that this routine assumes that the + component that we pass in is a VEVENT; the top level component we + created in the above two routines is a VCALENDAR */ + +char *attendees[10]; +#define MAX_ATTENDEES 10; + +char** get_required_attendees(icalcomponent* event) +{ + icalproperty* p; + icalparameter* parameter; + int c=0; + + assert(event != 0); + assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT); + + /* This loop iterates over all of the ATTENDEE properties in the + event */ + + /* Yes, the iteration routines save their state in the event + struct, so the are not thread safe unless you lock the whole + event. */ + + for( + p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) + ) { + + /* Get the first ROLE parameter in the property. There should + only be one, so we wont bother to iterate over them. */ + + parameter = icalproperty_get_first_parameter(p,ICAL_ROLE_PARAMETER); + + /* If the parameter indicates the participant is required, get + the attendees name and stick a copy of it into the output + array */ + + if ( icalparameter_get_role(parameter) == ICAL_ROLE_REQPARTICIPANT) + { + attendees[c++] = strdup(icalproperty_get_attendee(p)); + } + } + + return attendees; +} + +/* Here is a similar example. If an attendee has a PARTSTAT of + NEEDSACTION or has no PARTSTAT parameter, change it to + TENTATIVE. */ + +void update_attendees(icalcomponent* event) +{ + icalproperty* p; + icalparameter* parameter; + + assert(event != 0); + assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT); + + for( + p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) + ) { + + parameter = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER); + + if (parameter == 0) { + + /* There was no PARTSTAT parameter, so add one. */ + icalproperty_add_parameter( + p, + icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) + ); + + } else if (icalparameter_get_partstat(parameter) == ICAL_PARTSTAT_NEEDSACTION) { + /* Remove the NEEDSACTION parameter and replace it with + TENTATIVE */ + + icalproperty_remove_parameter(p,ICAL_PARTSTAT_PARAMETER); + + /* Don't forget to free it */ + icalparameter_free(parameter); + + /* Add a new one */ + icalproperty_add_parameter( + p, + icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) + ); + } + + } +} + +/* Here are some examples of manipulating properties */ + +void test_properties() +{ + icalproperty *prop; + icalparameter *param; + icalvalue *value; + + icalproperty *clone; + + /* Create a new property */ + prop = icalproperty_vanew_comment( + strdup("Another Comment"), + icalparameter_new_cn("A Common Name 1"), + icalparameter_new_cn("A Common Name 2"), + icalparameter_new_cn("A Common Name 3"), + icalparameter_new_cn("A Common Name 4"), + 0); + + /* Iterate through all of the parameters in the property */ + for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PROPERTY); + param != 0; + param = icalproperty_get_next_parameter(prop,ICAL_ANY_PROPERTY)) { + + printf("Prop parameter: %s\n",icalparameter_get_cn(param)); + } + + /* Get a string representation of the property's value */ + printf("Prop value: %s\n",icalproperty_get_comment(prop)); + + /* Spit out the property in its RFC 2445 representation */ + printf("As iCAL string:\n %s\n",icalproperty_as_ical_string(prop)); + + /* Make a copy of the property. Caller owns the memory */ + clone = icalproperty_new_clone(prop); + + /* Get a reference to the value within the clone property */ + value = icalproperty_get_value(clone); + + printf("Value: %s",icalvalue_as_ical_string(value)); + + /* Free the original and the clone */ + icalproperty_free(clone); + icalproperty_free(prop); + +} + + + +/* Here are some ways to work with values. */ +void test_values() +{ + icalvalue *v; + icalvalue *copy; + + v = icalvalue_new_caladdress(strdup("cap://value/1")); + printf("caladdress 1: %s\n",icalvalue_get_caladdress(v)); + + icalvalue_set_caladdress(v,strdup("cap://value/2")); + printf("caladdress 2: %s\n",icalvalue_get_caladdress(v)); + printf("String: %s\n",icalvalue_as_ical_string(v)); + + copy = icalvalue_new_clone(v); + printf("Clone: %s\n",icalvalue_as_ical_string(v)); + icalvalue_free(v); + icalvalue_free(copy); + + +} + +void test_parameters() +{ + icalparameter *p; + + p = icalparameter_new_cn("A Common Name"); + + printf("Common Name: %s\n",icalparameter_get_cn(p)); + + printf("As String: %s\n",icalparameter_as_ical_string(p)); +} + + +int test_parser() +{ + + + icalcomponent *c = icalparser_parse_string(str); + printf("%s\n",icalcomponent_as_ical_string(c)); + icalcomponent_free(c); + icalmemory_free_ring(); + return 1; +} + + +int main(int argc, char *argv[]) +{ + icalcomponent *c1; + icalcomponent *c2; + icalcomponent *vevent; + char **attendees; + + c1 = create_new_component(); + c2 = create_new_component_with_va_args(); + + /* Extract the VEVENT component from the component */ + + vevent = icalcomponent_get_first_component(c1,ICAL_VEVENT_COMPONENT); + + attendees = get_required_attendees(vevent); + + printf("Attendees: %s\n",attendees[0]); + + /* Now print out the component as a string. Remember that the + library retains control of the memory returned by + icalcomponent_as_ical_string. Do not sotre references to it or + try to free it. It is stored on an internal ring buffer,and the + library will eventuall reclaim it. */ + + printf("%s\n",icalcomponent_as_ical_string(c1)); + + return 0; + +} + + + |