reparing damage from removing files

svn path=/trunk/; revision=3042

70 files changed, 30591 insertions, 0 deletions

diff --git a/libical/src/.cvsignore b/libical/src/.cvsignore
new file mode 100644
index 0000000000..c038ed7864
--- /dev/null
+++ b/libical/src/.cvsignore
@@ -0,0 +1,2 @@
+Makefile
+Makefile.in
\ No newline at end of file
diff --git a/libical/src/Makefile.am b/libical/src/Makefile.am
new file mode 100644
index 0000000000..37dc5e39cb
--- /dev/null
+++ b/libical/src/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = libical libicalss test
diff --git a/libical/src/libical/.cvsignore b/libical/src/libical/.cvsignore
new file mode 100644
index 0000000000..708af857d7
--- /dev/null
+++ b/libical/src/libical/.cvsignore
@@ -0,0 +1,14 @@
+Makefile
+Makefile.in
+icalitipy.c
+icalitipy.h
+icalitipl.c
+icallexer.c
+icalyacc.c
+icalyacc.h
+y.output
+*.lo
+*.la
+.libs
+.deps
+icalversion.h
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.am b/libical/src/libical/Makefile.am
new file mode 100644
index 0000000000..698a2d5a94
--- /dev/null
+++ b/libical/src/libical/Makefile.am
@@ -0,0 +1,87 @@
+
+#AUTOMAKE_OPTIONS = no-dependencies
+
+#noinst_LTLIBRARIES = libical.la
+lib_LTLIBRARIES = libical.la
+
+INCLUDES = -I.
+
+YFLAGS =-d -v -t
+
+libical_la_SOURCES = \
+	ical.h \
+	icalcomponent.c	\
+	icalcomponent.h	\
+	icalenums.c \
+	icalenums.h \
+	icalerror.c \
+	icalerror.h \
+	icalyacc.y \
+	icallexer.l \
+	icalmemory.c \
+	icalmemory.h \
+	icalparameter.c \
+	icalparameter.h \
+	icalparser.c \
+	icalparser.h \
+	icalproperty.c \
+	icalproperty.h \
+	icalrestriction.c \
+	icalrestriction.h \
+	icaltypes.c \
+	icaltypes.h \
+	icalvalue.c \
+	icalvalue.h \
+	icalvcal.h \
+	pvl.c \
+	pvl.h
+
+include_HEADERS=\
+	ical.h \
+	icalcomponent.h	\
+	icalenums.h \
+	icalerror.h \
+	icalmemory.h \
+	icalparameter.h \
+	icalparser.h \
+	icalproperty.h \
+	icalrestriction.h \
+	icaltypes.h \
+	icalvalue.h \
+	icalvcal.h \
+	icalversion.h \
+	pvl.h
+
+
+
+EXTRA_DIST = icallexer.c icalyacc.c icalyacc.h
+
+CONFIG_CLEAN_FILES =  y.output *~ 
+
+DESIGNDATA = ../../design-data
+ICALSCRIPTS = ../../scripts
+derived: icalproperty icalparameter icalvalue
+
+icalproperty:
+	$(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.h -h $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newh
+	mv icalproperty.newh icalproperty.h
+
+	$(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.c -c $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newc
+	mv icalproperty.newc icalproperty.c
+
+
+icalparameter: 
+	$(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.h -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh
+	mv icalparameter.newh icalparameter.h
+
+	$(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.c -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc
+	mv icalparameter.newc icalparameter.c
+
+icalvalue: 
+	$(ICALSCRIPTS)/mkderivedvalues.pl -i icalvalue.h -h $(DESIGNDATA)/value-c-types.txt > icalvalue.newh
+	mv icalvalue.newh icalvalue.h
+
+	$(ICALSCRIPTS)/mkderivedvalues.pl  -i icalvalue.c -c $(DESIGNDATA)/value-c-types.txt > icalvalue.newc
+	mv icalvalue.newc icalvalue.c
+
+
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..d0f33cd1a1
--- /dev/null
+++ b/libical/src/libical/ical.h
@@ -0,0 +1,43 @@
+/* -*- 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 "icalversion.h"
+#include "icalenums.h"
+#include "icalvalue.h"
+#include "icalparameter.h"
+#include "icalproperty.h"
+#include "icalcomponent.h"
+#include "icaltypes.h"
+#include "icalparser.h"
+#include "icalmemory.h"
+#include "icalerror.h"
+#include "icalrestriction.h"
+
+#endif /* !ICAL_H */
+
+
+
diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c
new file mode 100644
index 0000000000..bd2b13189c
--- /dev/null
+++ b/libical/src/libical/icalcomponent.c
@@ -0,0 +1,782 @@
+/* -*- 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
+
+======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#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"
+
+#define MAX_TMP 1024
+
+
+/* icalproperty functions that only components get to use */
+void icalproperty_set_parent(icalproperty* property,
+			     icalcomponent* component);
+
+icalcomponent* icalproperty_get_parent(icalproperty* property);
+
+
+
+struct icalcomponent_impl 
+{
+	char id[5];
+	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) {
+	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;
+
+#ifdef ICAL_UNIX_NEWLINE    
+    char newline[] = "\n";
+#else
+    char newline[] = "\r\n";
+#endif
+   
+   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, newline);
+   
+
+   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, newline);
+
+   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);
+    }
+}
+
+
+void icalcomponent_convert_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)
+	{
+	    struct icalreqstattype rst;
+	    char tmp[MAX_TMP];
+	    icalparameter *param  = icalproperty_get_first_parameter
+		(p,ICAL_XLICERRORTYPE_PARAMETER);
+
+	    rst.code = ICAL_UNKNOWN_STATUS;
+	    rst.desc = 0;
+
+	    switch(icalparameter_get_xlicerrortype(param)){
+
+		case  ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR: {
+		    rst.code = ICAL_3_2_INVPARAM_STATUS;
+		    break;
+		}
+		case  ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR: {
+		    rst.code = ICAL_3_3_INVPARAMVAL_STATUS;
+		    break;
+		}
+		case  ICAL_XLICERRORTYPE_PROPERTYPARSEERROR: {		    
+		    rst.code = ICAL_3_0_INVPROPNAME_STATUS;
+		    break;
+		}
+		case  ICAL_XLICERRORTYPE_VALUEPARSEERROR: {
+		    rst.code = ICAL_3_1_INVPROPVAL_STATUS;
+		    break;
+		}
+		case  ICAL_XLICERRORTYPE_COMPONENTPARSEERROR: {
+		    rst.code = ICAL_3_4_INVCOMP_STATUS;
+		    break;
+		}
+
+		default: {
+		}
+	    }
+	    if (rst.code != ICAL_UNKNOWN_STATUS){
+		
+		rst.debug = icalproperty_get_xlicerror(p);
+		icalcomponent_add_property(component,
+					   icalproperty_new_requeststatus(
+					       icalreqstattype_as_string(rst)
+					       )
+		    );
+		
+		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_convert_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..8d9f22ca76
--- /dev/null
+++ b/libical/src/libical/icalcomponent.h
@@ -0,0 +1,119 @@
+/* -*- 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);
+
+/* Remove all X-LIC-ERROR properties*/
+void icalcomponent_strip_errors(icalcomponent* component);
+
+/* Convert some X-LIC-ERROR properties into RETURN-STATUS properties*/
+void icalcomponent_convert_errors(icalcomponent* component);
+
+/* Internal operations. You don't see these... */
+icalcomponent* icalcomponent_get_parent(icalcomponent* component);
+void icalcomponent_set_parent(icalcomponent* component, 
+			      icalcomponent* parent);
+
+#endif /* !ICALCOMPONENT_H */
+
+
+
diff --git a/libical/src/libical/icalenums.c b/libical/src/libical/icalenums.c
new file mode 100644
index 0000000000..95f308eec6
--- /dev/null
+++ b/libical/src/libical/icalenums.c
@@ -0,0 +1,615 @@
+/* -*- 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
+
+  ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#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_METHOD_VALUE, "METHOD"}, /* Not an RFC2445 type */
+    { ICAL_GEO_VALUE, "FLOAT"}, /* Not an RFC2445 type */
+    { ICAL_ATTACH_VALUE, "XATTACH"}, /* Not an RFC2445 type */
+    { ICAL_DATETIMEDATE_VALUE, "XDATETIMEDATE"}, /* Not an RFC2445 type */
+    { 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_ANY_COMPONENT, "ANY" },  
+    { ICAL_XROOT_COMPONENT, "XROOT" },  
+
+    /* 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_METHOD_VALUE }, 
+    { ICAL_PRODID_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_VERSION_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_CATEGORIES_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_CLASS_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_COMMENT_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_DESCRIPTION_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_LOCATION_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_PERCENTCOMPLETE_PROPERTY, ICAL_INTEGER_VALUE }, 
+    { ICAL_PRIORITY_PROPERTY, ICAL_INTEGER_VALUE }, 
+    { ICAL_RESOURCES_PROPERTY, ICAL_TEXT_VALUE }, 
+    { ICAL_STATUS_PROPERTY, ICAL_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."},
+    {ICAL_3_5_INVTIME_STATUS, 3,5,"Invalid date or time."},
+    {ICAL_3_6_INVRULE_STATUS, 3,6,"Invalid rule."},
+    {ICAL_3_7_INVCU_STATUS, 3,7,"Invalid Calendar User."},
+    {ICAL_3_8_NOAUTH_STATUS, 3,8,"No authority."},
+    {ICAL_3_9_BADVERSION_STATUS, 3,9,"Unsupported version."},
+    {ICAL_3_10_TOOBIG_STATUS, 3,10,"Request entity too large."},
+    {ICAL_3_11_MISSREQCOMP_STATUS, 3,11,"Required component or property missing."},
+    {ICAL_3_12_UNKCOMP_STATUS, 3,12,"Unknown component or property found."},
+    {ICAL_3_13_BADCOMP_STATUS, 3,13,"Unsupported component or property found"},
+    {ICAL_3_14_NOCAP_STATUS, 3,14,"Unsupported capability."},
+    {ICAL_4_0_BUSY_STATUS, 4,0,"Event conflict. Date/time  is busy."},
+    {ICAL_5_0_MAYBE_STATUS, 5,0,"Request MAY supported."},
+    {ICAL_5_1_UNAVAIL_STATUS, 5,1,"Service unavailable."},
+    {ICAL_5_2_NOSERVICE_STATUS, 5,2,"Invalid calendar service."},
+    {ICAL_5_3_NOSCHED_STATUS, 5,3,"No scheduling support for  user."},
+    {ICAL_UNKNOWN_STATUS, 0,0,"Error: Unknown request status"}
+};
+
+
+char* icalenum_reqstat_desc(icalrequeststatus stat)
+{
+
+    int i;
+
+    for (i=0; status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+	if ( status_map[i].kind ==  stat) {
+	    return status_map[i].str;
+	}
+    }
+
+    return 0;
+}
+
+
+short icalenum_reqstat_major(icalrequeststatus stat)
+{
+    int i;
+
+    for (i=0; status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+	if ( status_map[i].kind ==  stat) {
+	    return status_map[i].major;
+	}
+    }
+    return -1;
+}
+
+short icalenum_reqstat_minor(icalrequeststatus stat)
+{
+    int i;
+
+    for (i=0; status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+	if ( status_map[i].kind ==  stat) {
+	    return status_map[i].minor;
+	}
+    }
+    return -1;
+}
+
+
+icalrequeststatus icalenum_num_to_reqstat(short major, short minor)
+{
+    int i;
+
+    for (i=0; status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+	if ( status_map[i].major ==  major && status_map[i].minor ==  minor) {
+	    return status_map[i].kind;
+	}
+    }
+    return 0;
+}
+
+
+
+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;
+
+    while(*str == ' '){
+	str++;
+    }
+
+
+    for (i=0; method_map[i].method  != ICAL_METHOD_NONE; i++) {
+	if ( strcmp(method_map[i].str, str) == 0) {
+	    return method_map[i].method;
+	}
+    }
+
+    return ICAL_METHOD_NONE;
+}
diff --git a/libical/src/libical/icalenums.h b/libical/src/libical/icalenums.h
new file mode 100644
index 0000000000..ff7cee486e
--- /dev/null
+++ b/libical/src/libical/icalenums.h
@@ -0,0 +1,466 @@
+/* -*- 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 to select all components*/
+    ICAL_XROOT_COMPONENT,
+    ICAL_XATTACH_COMPONENT, /* MIME attached data, returned by parser. */
+    ICAL_VEVENT_COMPONENT,
+    ICAL_VTODO_COMPONENT,
+    ICAL_VJOURNAL_COMPONENT,
+    ICAL_VCALENDAR_COMPONENT,
+    ICAL_VFREEBUSY_COMPONENT,
+    ICAL_VALARM_COMPONENT,
+    ICAL_XAUDIOALARM_COMPONENT,  
+    ICAL_XDISPLAYALARM_COMPONENT,
+    ICAL_XEMAILALARM_COMPONENT,
+    ICAL_XPROCEDUREALARM_COMPONENT,
+    ICAL_VTIMEZONE_COMPONENT,
+    ICAL_XSTANDARD_COMPONENT,
+    ICAL_XDAYLIGHT_COMPONENT,
+    ICAL_X_COMPONENT,
+    ICAL_VSCHEDULE_COMPONENT,
+    ICAL_VQUERY_COMPONENT,
+    ICAL_VCAR_COMPONENT,
+    ICAL_VCOMMAND_COMPONENT,
+    ICAL_XLICINVALID_COMPONENT
+} 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, /* Non-Standard */
+    ICAL_PERIOD_VALUE,
+    ICAL_RECUR_VALUE,
+    ICAL_STRING_VALUE, /* Non-Standard */
+    ICAL_TEXT_VALUE,
+    ICAL_TIME_VALUE,
+    ICAL_TRIGGER_VALUE, /* Non-Standard */
+    ICAL_URI_VALUE,
+    ICAL_UTCOFFSET_VALUE,
+    ICAL_QUERY_VALUE,
+    ICAL_XNAME_VALUE
+} icalvalue_kind;
+
+
+/***********************************************************************
+ * Parameter Enumerations
+ **********************************************************************/
+
+
+typedef enum icalparameter_kind {
+    ICAL_NO_PARAMETER,
+    ICAL_ANY_PARAMETER,
+    ICAL_ALTREP_PARAMETER, /* DQUOTE uri DQUOTE */
+    ICAL_CN_PARAMETER, /* text */
+    ICAL_CUTYPE_PARAMETER, /*INDIVIDUAL, GROUP, RESOURCE,ROOM,UNKNOWN, x-name*/
+    ICAL_DELEGATEDFROM_PARAMETER, /* *("," DQUOTE cal-address DQUOTE) */
+    ICAL_DELEGATEDTO_PARAMETER, /*  *("," DQUOTE cal-address DQUOTE) */
+    ICAL_DIR_PARAMETER, /*  DQUOTE uri DQUOTE */
+    ICAL_ENCODING_PARAMETER, /* *BIT, BASE64, x-name */
+    ICAL_FMTTYPE_PARAMETER, /* registered MINE content type */
+    ICAL_FBTYPE_PARAMETER, /* FREE, BUSY, BUSY-UNAVAILABLE, BUSY-TENTATIVE,x-name */
+    ICAL_LANGUAGE_PARAMETER, /* text from RFC 1766 */
+    ICAL_MEMBER_PARAMETER, /*  DQUOTE cal-address DQUOTE */
+    ICAL_PARTSTAT_PARAMETER, /* NEEDS-ACTION, ACCEPTED, DECLINED, TENTATIVE, DELEGATED, x-name */
+    ICAL_RANGE_PARAMETER, /* THISANDPRIOR, THISANDFUTURE */
+    ICAL_RELATED_PARAMETER, /* START, END */
+    ICAL_RELTYPE_PARAMETER, /* PARENT, CHILD, SIBLING,x-name */
+    ICAL_ROLE_PARAMETER, /* CHAIR, REQ_PARTICIPANT, OPT_PARTICIPANT, NON_PARTICIPANT, x-name */
+    ICAL_RSVP_PARAMETER, /* TRUE. FALSE */
+    ICAL_SENTBY_PARAMETER, /*  DQUOTE uri DQUOTE */
+    ICAL_TZID_PARAMETER, /*  [tzidprefix] paramtext CRLF */
+    ICAL_VALUE_PARAMETER, /* BINARY, BOOLEAN, CAL_ADDRESS, DATE, DATE-TIME, DURATION, FLOAT, INTEGER, PERIOD, RECUR, TEXT, TIME, UTC_OFFSET, x-name */
+    ICAL_XLICERRORTYPE_PARAMETER, /*ICAL_XLICERROR_PARSE_ERROR,ICAL_XLICERROR_INVALID_ITIP*/
+    ICAL_XLICCOMPARETYPE_PARAMETER, /**/
+    ICAL_X_PARAMETER /* text */ 
+} icalparameter_kind;
+
+typedef enum icalparameter_cutype {
+    ICAL_CUTYPE_INDIVIDUAL, 
+    ICAL_CUTYPE_GROUP, 
+    ICAL_CUTYPE_RESOURCE, 
+    ICAL_CUTYPE_ROOM,
+    ICAL_CUTYPE_UNKNOWN,
+    ICAL_CUTYPE_XNAME
+} icalparameter_cutype;
+
+
+typedef enum icalparameter_encoding {
+    ICAL_ENCODING_8BIT, 
+    ICAL_ENCODING_BASE64,
+    ICAL_ENCODING_XNAME
+} icalparameter_encoding;
+
+typedef enum icalparameter_fbtype {
+    ICAL_FBTYPE_FREE, 
+    ICAL_FBTYPE_BUSY, 
+    ICAL_FBTYPE_BUSYUNAVAILABLE, 
+    ICAL_FBTYPE_BUSYTENTATIVE,
+    ICAL_FBTYPE_XNAME
+} icalparameter_fbtype;
+
+typedef enum icalparameter_partstat {
+    ICAL_PARTSTAT_NEEDSACTION, 
+    ICAL_PARTSTAT_ACCEPTED, 
+    ICAL_PARTSTAT_DECLINED, 
+    ICAL_PARTSTAT_TENTATIVE, 
+    ICAL_PARTSTAT_DELEGATED,
+    ICAL_PARTSTAT_COMPLETED,
+    ICAL_PARTSTAT_INPROCESS,
+    ICAL_PARTSTAT_XNAME
+} icalparameter_partstat;
+
+typedef enum icalparameter_range {
+    ICAL_RANGE_THISANDPRIOR, 
+    ICAL_RANGE_THISANDFUTURE
+} icalparameter_range;
+
+typedef enum icalparameter_related {
+    ICAL_RELATED_START, 
+    ICAL_RELATED_END
+} icalparameter_related;
+
+typedef enum icalparameter_reltype {
+    ICAL_RELTYPE_PARENT, 
+    ICAL_RELTYPE_CHILD,
+    ICAL_RELTYPE_SIBLING,
+    ICAL_RELTYPE_XNAME
+} icalparameter_reltype;
+
+typedef enum icalparameter_role {
+    ICAL_ROLE_CHAIR, 
+    ICAL_ROLE_REQPARTICIPANT, 
+    ICAL_ROLE_OPTPARTICIPANT, 
+    ICAL_ROLE_NONPARTICIPANT,
+    ICAL_ROLE_XNAME
+} icalparameter_role;
+
+typedef enum icalparameter_xlicerrortype {
+    ICAL_XLICERRORTYPE_COMPONENTPARSEERROR,
+    ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR,
+    ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR,
+    ICAL_XLICERRORTYPE_PROPERTYPARSEERROR,
+    ICAL_XLICERRORTYPE_VALUEPARSEERROR,
+    ICAL_XLICERRORTYPE_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_UNKNOWN_STATUS,
+    ICAL_2_0_SUCCESS_STATUS,
+    ICAL_2_1_FALLBACK_STATUS,
+    ICAL_2_2_IGPROP_STATUS,
+    ICAL_2_3_IGPARAM_STATUS,
+    ICAL_2_4_IGXPROP_STATUS,
+    ICAL_2_5_IGXPARAM_STATUS,
+    ICAL_2_6_IGCOMP_STATUS,
+    ICAL_2_7_FORWARD_STATUS,
+    ICAL_2_8_ONEEVENT_STATUS,
+    ICAL_2_9_TRUNC_STATUS,
+    ICAL_2_10_ONETODO_STATUS,
+    ICAL_2_11_TRUNCRRULE_STATUS,
+    ICAL_3_0_INVPROPNAME_STATUS,
+    ICAL_3_1_INVPROPVAL_STATUS,
+    ICAL_3_2_INVPARAM_STATUS,
+    ICAL_3_3_INVPARAMVAL_STATUS,
+    ICAL_3_4_INVCOMP_STATUS,
+    ICAL_3_5_INVTIME_STATUS,
+    ICAL_3_6_INVRULE_STATUS,
+    ICAL_3_7_INVCU_STATUS,
+    ICAL_3_8_NOAUTH_STATUS,
+    ICAL_3_9_BADVERSION_STATUS,
+    ICAL_3_10_TOOBIG_STATUS,
+    ICAL_3_11_MISSREQCOMP_STATUS,
+    ICAL_3_12_UNKCOMP_STATUS,
+    ICAL_3_13_BADCOMP_STATUS,
+    ICAL_3_14_NOCAP_STATUS,
+    ICAL_4_0_BUSY_STATUS,
+    ICAL_5_0_MAYBE_STATUS,
+    ICAL_5_1_UNAVAIL_STATUS,
+    ICAL_5_2_NOSERVICE_STATUS,
+    ICAL_5_3_NOSCHED_STATUS
+} icalrequeststatus;
+
+
+char* icalenum_reqstat_desc(icalrequeststatus stat);
+short icalenum_reqstat_major(icalrequeststatus stat);
+short icalenum_reqstat_minor(icalrequeststatus stat);
+icalrequeststatus icalenum_num_to_reqstat(short major, short minor);
+
+/***********************************************************************
+ * Conversion functions
+**********************************************************************/
+
+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..fb9e152b16
--- /dev/null
+++ b/libical/src/libical/icalerror.c
@@ -0,0 +1,99 @@
+/* -*- 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
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+
+icalerrorenum icalerrno;
+
+int foo;
+void icalerror_stop_here(void)
+{
+    foo++; /* Keep optimizers from removing routine */
+}
+
+void icalerror_crash_here(void)
+{
+    int *p=0;
+    *p = 1;
+
+    assert( *p);
+}
+
+
+void icalerror_clear_errno() {
+    
+    icalerrno = ICAL_NO_ERROR;
+}
+
+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..124699c21b
--- /dev/null
+++ b/libical/src/libical/icalerror.h
@@ -0,0 +1,141 @@
+/* -*- 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);
+
+void icalerror_crash_here(void);
+
+#ifdef ICAL_ERRORS_ARE_FATAL
+#undef NDEBUG
+#endif
+
+#define icalerror_check_value_type(value,type);
+#define icalerror_check_property_type(value,type);
+#define icalerror_check_parameter_type(value,type);
+#define icalerror_check_component_type(value,type);
+
+/* Assert with a message */
+#ifdef ICAL_ERRORS_ARE_FATAL
+
+#ifdef __GNUC__
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#else /*__GNUC__*/
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#endif /*__GNUC__*/
+#else
+#define icalerror_assert(test,message) 
+#endif 
+
+
+/* Check & abort if check fails */
+#ifdef ICAL_ERRORS_ARE_FATAL
+#define icalerror_check_arg(test,arg) icalerror_stop_here();assert(test) 
+#else
+#define icalerror_check_arg(test,arg)
+#endif
+/* Check & return void if check 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.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..82536647e3
--- /dev/null
+++ b/libical/src/libical/icalitip.tab.c
@@ -0,0 +1,1663 @@
+
+/*  A Bison parser, made from icalitip.y
+    by GNU Bison version 1.28  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define yyparse icalparser_yyparse
+#define yylex icalparser_yylex
+#define yyerror icalparser_yyerror
+#define yylval icalparser_yylval
+#define yychar icalparser_yychar
+#define yydebug icalparser_yydebug
+#define yynerrs icalparser_yynerrs
+#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;
+#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..197bd1c292
--- /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 icalparser_yylval;
diff --git a/libical/src/libical/icalitipl.l b/libical/src/libical/icalitipl.l
new file mode 100644
index 0000000000..9abe9538c9
--- /dev/null
+++ b/libical/src/libical/icalitipl.l
@@ -0,0 +1,283 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalitip.y
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id: icalitipl.l,v 1.3 2000/05/15 06:18:17 ericb 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 "icalitipy.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) icalparser_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 icalparser_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>{
+.*			 { icalparser_yylval.v_string= icalmemory_tmp_copy(yytext);  
+			   return STRING;}
+{crlf}|\n                { return EOL;}
+
+}
+
+<boolean_value>{
+.			 { return CHARACTER; }
+{crlf}|\n                { return EOL;}
+
+}
+
+<uri_value>{
+.*			 { icalparser_yylval.v_string= icalmemory_tmp_copy(yytext);  
+			   return STRING;}
+{crlf}|\n                { return EOL;}
+
+}
+
+
+<time_value>{
+{digit}*		 { icalparser_yylval.v_string= icalmemory_tmp_copy(yytext);
+                           return DIGITS; }
+T			 { return TIME_CHAR; }
+Z			 { return UTC_CHAR; }
+{crlf}|\n                { return EOL;}
+}
+
+<duration_value>{
+{digit}+		 { icalparser_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]+		 {  icalparser_yylval.v_int=atoi(yytext); return INTNUMBER; }
+{crlf}|\n                { return EOL;}
+}
+
+<period_value>{
+{digit}+		 { icalparser_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]+		 { icalparser_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}		 { icalparser_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/icalitipy.y b/libical/src/libical/icalitipy.y
new file mode 100644
index 0000000000..07573d62cd
--- /dev/null
+++ b/libical/src/libical/icalitipy.y
@@ -0,0 +1,434 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalitip.y
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id: icalitipy.y,v 1.3 2000/05/15 06:18:17 ericb 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/icallexer.l b/libical/src/libical/icallexer.l
new file mode 100644
index 0000000000..7f3358e079
--- /dev/null
+++ b/libical/src/libical/icallexer.l
@@ -0,0 +1,282 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallexer.l
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id: icallexer.l,v 1.3 2000/05/15 06:18:17 ericb 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 "icalyacc.h"
+#include "icalparser.h"
+#include "icalenums.h"
+#include "icalmemory.h"
+#include "assert.h"
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input();
+
+
+#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 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
+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}                { return EOL;}
+
+}
+
+<boolean_value>{
+.			 { return CHARACTER; }
+{crlf}                { return EOL;}
+
+}
+
+<uri_value>{
+.*			 { yylval.v_string= icalmemory_tmp_copy(yytext);  
+			   return STRING;}
+{crlf}                   { return EOL;}
+
+}
+
+
+<time_value>{
+{digit}*		 { yylval.v_string= icalmemory_tmp_copy(yytext);
+                           return DIGITS; }
+T			 { return TIME_CHAR; }
+Z			 { return UTC_CHAR; }
+{crlf}                   { return EOL;}
+}
+
+<duration_value>{
+{digit}+		 { yylval.v_string =icalmemory_tmp_copy(yytext); 
+                           return DIGITS; }
+T			 { return TIME_CHAR; }
+[\+\-PTWHMSD]		 { return yytext[0]; }
+{crlf}	                 { return EOL;}
+
+}
+
+<number_value>{
+[\+\-\.0-9]+		 {  yylval.v_int=atoi(yytext); return INTNUMBER; }
+{crlf}                   { 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}                   { 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}                   { return EOL;}
+}
+
+<utcoffset_value>{
+{crlf}                   { return EOL;}
+\-|\+			 { return yytext[0]; }
+{digit}{digit}		 { yylval.v_int=atoi(yytext); return INTNUMBER; }
+
+}
+
+<enum_param_value>{
+.			 { return CHARACTER; }
+{crlf}                   { return EOL;}
+
+}
+
+<seperator>{
+,       { BEGIN(last_state); return COMMA; } 
+}
+
+
+%% 
+
+int yywrap()
+{
+     return 1;
+}
+
+
+void set_parser_value_state(icalvalue_kind kind)
+{
+
+    switch (kind){
+
+        case ICAL_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/icalmemory.c b/libical/src/libical/icalmemory.c
new file mode 100644
index 0000000000..e89451fbce
--- /dev/null
+++ b/libical/src/libical/icalmemory.c
@@ -0,0 +1,244 @@
+/* -*- 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
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "icalmemory.h"
+#include "icalerror.h"
+
+#include <stdio.h> /* for printf (debugging) */
+#include <stdlib.h> /* for malloc, realloc */
+#include <string.h> /* for memset() */
+
+#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..cf37eb07b2
--- /dev/null
+++ b/libical/src/libical/icalparameter.c
@@ -0,0 +1,1913 @@
+/* -*- 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)
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#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);
+	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_NAME_PARSE_ERROR") == 0){ 
+		param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
+	    }
+	    else if(strcmp(val,"PARAMETER_VALUE_PARSE_ERROR") == 0){ 
+		param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
+	    }
+	    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_XLICCOMPARETYPE_PARAMETER:
+	{
+
+	    if(strcmp(val,"EQUAL") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL);
+	    }
+	    else if(strcmp(val,"NOTEQUAL") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_NOTEQUAL);
+	    }
+	    else if(strcmp(val,"LESS") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_LESS);
+	    }
+	    else if(strcmp(val,"GREATER") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_GREATER);
+	    }
+	    else if(strcmp(val,"LESSEQUAL") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_LESSEQUAL);
+	    }
+	    else if(strcmp(val,"GREATEREQUAL") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_GREATEREQUAL);
+	    }
+	    else if(strcmp(val,"REGEX") == 0){ 
+		param = icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_REGEX);
+	    } else {
+		param = 0;
+	    }
+	    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_URI:  {
+		    strcpy(tend,"URI");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:{
+		    strcpy(tend,"ERROR");
+		    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_PARAMETERNAMEPARSEERROR:
+		{
+		    strcpy(tend,"PARAMETER_NAME_PARSE_ERROR");break;
+		}
+		case ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR:
+		{
+		    strcpy(tend,"PARAMETER_VALUE_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_rv( (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_rv( (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_rv( (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_rv( (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_rv( (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_rv( (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_rv( (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_rv( (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");
+
+    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");
+
+    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");
+
+    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_rv( (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_rv( (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_rv( (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");
+
+    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");
+
+    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..8541ae4fab
--- /dev/null
+++ b/libical/src/libical/icalparser.c
@@ -0,0 +1,990 @@
+/* -*- 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 Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 1999 The Software Studio. 
+ http://www.softwarestudio.org
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "ical.h"
+#include "pvl.h"
+#include "icalparser.h"
+#include "icalmemory.h"
+#include <string.h> /* For strncpy & size_t */
+#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 ical_yy_parse(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);
+
+#define TMP_BUF_SIZE 80
+
+struct icalparser_impl 
+{
+	int buffer_full;
+	size_t tmp_buf_size; 
+	char temp[TMP_BUF_SIZE];
+	icalcomponent *root_component;
+	icalcomponent *tail;
+	int version; 
+	int level;
+	int lineno;
+	icalparser_state state;
+	pvl_list components;
+
+	void *line_gen_data;
+    
+};
+
+
+icalparser* icalparser_new()
+{
+    struct icalparser_impl* impl = 0;
+
+    if ( ( impl = (struct icalparser_impl*)
+	   malloc(sizeof(struct icalparser_impl))) == 0) {
+	icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+	return 0;
+    }
+    
+    impl->root_component = 0;
+    impl->components  = pvl_newlist();  
+    impl->level = 0;
+    impl->state = ICALPARSER_SUCCESS;
+
+    impl->tmp_buf_size = TMP_BUF_SIZE;
+    impl->buffer_full = 0;
+    impl->lineno = 0;
+
+    memset(impl->temp,0, TMP_BUF_SIZE);
+
+    return (icalparser*)impl;
+}
+
+void icalparser_free(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+    icalcomponent *c;
+
+    if (impl->root_component != 0){
+	icalcomponent_free(impl->root_component);
+    }
+
+    while( (c=pvl_pop(impl->components)) != 0){
+	icalcomponent_free(c);
+    }
+    
+    pvl_free(impl->components);
+}
+
+void icalparser_set_gen_data(icalparser* parser, void* data)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+
+    impl->line_gen_data  = data;
+}
+
+
+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 = ical_yy_parse();
+
+    /* 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;
+    }
+}
+
+/* Get a single property line, from the property name through the
+   final new line, and include any continuation lines */
+
+char* icalparser_get_line(icalparser *parser,
+                          char* (*line_gen_func)(char *s, size_t size, void *d))
+{
+    char *line;
+    char *line_p;
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+    size_t buf_size = impl->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 (impl->temp[0] != '\0' ) {
+
+	    /* If the last position in the temp buffer is occupied,
+               mark the buffer as full. The means we will do another
+               read later, because the line is not finished */
+	    if (impl->temp[impl->tmp_buf_size-1] == 0){
+		impl->buffer_full = 1;
+	    } else {
+		impl->buffer_full = 0;
+	    }
+
+	    /* Copy the temp to the output and clear the temp buffer. */
+	    icalmemory_append_string(&line,&line_p,&buf_size,impl->temp);     
+	    impl->temp[0] = '\0' ;
+	}
+	
+	impl->temp[impl->tmp_buf_size-1] = 1; /* Mark end of buffer */
+
+	if ((*line_gen_func)(impl->temp,impl->tmp_buf_size,impl->line_gen_data)
+	    ==0){/* Get more data */
+
+	    /* If the first position is clear, it means we didn't get
+               any more data from the last call to line_ge_func*/
+	    if (impl->temp[0] == '\0'){
+
+		if(line[0] != '\0'){
+		    /* There is data in the output, so fall trhough and process it*/
+		    break;
+		} else {
+		    /* No data in output; return and signal that there
+                       is no more input*/
+		    free(line);
+		    return 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.  */
+
+	if  ( line_p > line+1 && *(line_p-1) == '\n' && impl->temp[0] == ' ') {
+
+	    /* back up the pointer to erase the continuation characters */
+	    line_p--;
+
+	    if ( *(line_p-1) == '\r'){
+		line_p--;
+	    }
+
+	    /* shift the temp buffer down to eliminate the leading space*/
+	    memmove(&(impl->temp[0]),&(impl->temp[1]),impl->tmp_buf_size);
+
+	    impl->temp[impl->tmp_buf_size-1] = impl->temp[impl->tmp_buf_size-2];
+
+	} else if ( impl->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 and/or carriage return*/
+    if ( line_p > line+1 && *(line_p-1) == '\n') {	
+	*(line_p-1) = '\0';
+	if ( *(line_p-2) == '\r'){
+	    *(line_p-2) = '\0';
+	}
+
+    } else {
+	*(line_p) = '\0';
+    }
+
+    return line;
+
+}
+
+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(icalparser *parser,
+				char* (*line_gen_func)(char *s, size_t size, 
+						       void* d))
+{
+
+    char* line; 
+    icalcomponent *c=0; 
+    icalcomponent *root_component=0;
+
+    icalerror_check_arg_rz((parser !=0),"parser");
+
+    do{
+	line = icalparser_get_line(parser, line_gen_func);
+
+	if ((c = icalparser_add_line(parser,line)) != 0){
+          if (root_component == 0){
+            /* Just one component */
+            icalparser_claim(parser);
+            root_component = c;
+          } else if(icalcomponent_isa(root_component) 
+                    != ICAL_XROOT_COMPONENT) {
+            /*Got a second component, so move the two components under
+              an XROOT container */
+            icalcomponent *tempc; 
+            tempc = icalcomponent_new(ICAL_XROOT_COMPONENT);
+            icalcomponent_add_component(tempc, root_component);
+            icalparser_claim(parser);
+            icalcomponent_add_component(tempc, c);
+            root_component = tempc;
+          } else {
+            /* Already have an XROOT container, so add the component
+               to it*/
+            icalcomponent_add_component(root_component, c);
+            icalparser_claim(parser);
+          }
+        }
+    } while ( line != 0);
+
+    return root_component;
+
+}
+
+icalcomponent* icalparser_add_line(icalparser* parser,
+                                       char* line)
+{ 
+    char *p; 
+    char *str;
+    char *end;
+    int vcount = 0;
+    icalproperty *prop;
+    icalvalue *value;
+    icalvalue_kind value_kind = ICAL_NO_VALUE;
+
+
+    struct icalparser_impl *impl = (struct icalparser_impl*)parser;
+    icalerror_check_arg_rz((parser != 0),"parser");
+
+
+    if (line == 0)
+    {
+	impl->state = ICALPARSER_ERROR;
+	return 0;
+    }
+
+    /* Begin by getting the property name at the start of the line. The
+       property name may end up being "BEGIN" or "END" in which case it
+       is not really a property, but the market for the start or end of
+       a component */
+
+    end = 0;
+    str = icalparser_get_prop_name(line, &end);
+
+    if (str == 0){
+	/* Could not get a property name */
+	icalcomponent *tail = pvl_data(pvl_tail(impl->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;
+	impl->state = ICALPARSER_ERROR;
+	return 0; 
+    }
+
+    /**********************************************************************
+     * 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;
+
+	impl->level++;
+	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(impl->components,c);
+
+	impl->state = ICALPARSER_BEGIN_COMP;
+	return 0;
+
+    } else if (strcmp(str,"END") == 0 ) {
+	icalcomponent* tail;
+
+	impl->level--;
+	str = icalparser_get_next_value(end,&end, value_kind);
+
+	impl->root_component = pvl_pop(impl->components);
+
+	tail = pvl_data(pvl_tail(impl->components));
+
+	if(tail != 0){
+	    icalcomponent_add_component(tail,impl->root_component);
+	}
+
+	tail = 0;
+
+	/* Return the component if we are back to the 0th level */
+	if (impl->level == 0){
+	    impl->state = ICALPARSER_SUCCESS;
+	    return impl->root_component;
+	} else {
+	    impl->state = ICALPARSER_END_COMP;
+	    return 0;
+	}
+    }
+
+
+    /* There is no point in continuing if we have not seen a
+       component yet */
+
+    if(pvl_data(pvl_tail(impl->components)) == 0){
+	impl->state = ICALPARSER_ERROR;
+	return 0;
+    }
+
+
+    /**********************************************************************
+     * 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){
+	icalcomponent *tail = pvl_data(pvl_tail(impl->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(impl->components));
+
+	insert_error(tail,str,"Parse error in property name",
+		     ICAL_XLICERRORTYPE_PROPERTYPARSEERROR);
+	    
+	tail = 0;
+	impl->state = ICALPARSER_ERROR;
+	return 0;
+    }
+
+    /**********************************************************************
+     * 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;
+	    icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+
+	    name = icalparser_get_param_name(str,&pvalue);
+
+	    if (name == 0){
+		/* 'tail' defined above */
+		insert_error(tail, str, "Can't parse parameter name",
+			     ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
+		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*/
+		/* 'tail' defined above */
+		insert_error(tail, str, "Can't parse parameter name",
+			     ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
+		tail = 0;
+		impl->state = ICALPARSER_ERROR;
+		return 0;
+	    }
+
+	    if (param == 0){
+		/* 'tail' defined above */
+		insert_error(tail,str,"Can't parse parameter value",
+			     ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
+		    
+		tail = 0;
+		impl->state = ICALPARSER_ERROR;
+		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 */
+			
+		    insert_error(
+			tail, str, 
+			"Got a VALUE parameter with an unknown type",
+			ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
+		    icalparameter_free(param);
+			
+		    value_kind = 
+			icalenum_property_kind_to_value_kind(
+			    icalproperty_isa(prop));
+			
+		    icalparameter_free(param);
+		    tail = 0;
+		    impl->state = ICALPARSER_ERROR;
+		    return 0;
+		} 
+	    }
+
+	    /* Everything is OK, so add the parameter */
+	    icalproperty_add_parameter(prop,param);
+	    tail = 0;
+
+	} else { /* if ( str != 0)  */
+	    /* If we did not get a param string, go on to looking
+	       for a value */
+	    break;
+	} /* if ( str != 0)  */
+
+    } /* while(1) */	    
+	
+    /**********************************************************************
+     * 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);
+		icalcomponent* tail = pvl_data(pvl_tail(impl->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[200]; /* HACK */
+
+		icalproperty_kind prop_kind = icalproperty_isa(prop);
+		icalcomponent* tail = pvl_data(pvl_tail(impl->components));
+
+		sprintf(temp,"Can't parse as %s value in %s property. Removing entire property",
+			icalenum_value_kind_to_string(value_kind),
+			icalenum_property_kind_to_string(prop_kind));
+
+		insert_error(tail, str, temp,
+			     ICAL_XLICERRORTYPE_VALUEPARSEERROR);
+
+		/* Remove the troublesome property */
+		icalcomponent_remove_property(tail,prop);
+		icalproperty_free(prop);
+		prop = 0;
+		tail = 0;
+		impl->state = ICALPARSER_ERROR;
+		return 0;
+		    
+	    } else {
+		vcount++;
+		icalproperty_set_value(prop, value);
+	    }
+
+
+	} else {
+	    if (vcount == 0){
+		char temp[200]; /* HACK */
+		
+		icalproperty_kind prop_kind = icalproperty_isa(prop);
+		icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+		
+		sprintf(temp,"No value for %s property. Removing entire property",
+			icalenum_property_kind_to_string(prop_kind));
+
+		insert_error(tail, str, temp,
+			     ICAL_XLICERRORTYPE_VALUEPARSEERROR);
+
+		/* Remove the troublesome property */
+		icalcomponent_remove_property(tail,prop);
+		icalproperty_free(prop);
+		prop = 0;
+		tail = 0;
+		impl->state = ICALPARSER_ERROR;
+		return 0;
+	    } else {
+
+		break;
+	    }
+	}
+    }
+	
+    /****************************************************************
+     * End of component parsing. 
+     *****************************************************************/
+    
+    if (pvl_data(pvl_tail(impl->components)) == 0 &&
+	impl->level == 0){
+	impl->state = ICALPARSER_SUCCESS;
+	return impl->root_component;
+    } else {
+	impl->state = ICALPARSER_IN_PROGRESS;
+	return 0;
+    }
+
+}
+
+icalparser_state icalparser_get_state(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*) parser;
+    return impl->state;
+
+}
+
+icalcomponent* icalparser_claim(icalparser* parser)
+{
+   struct icalparser_impl* impl = (struct icalparser_impl*) parser;
+   icalcomponent *c = impl->root_component;
+
+   impl->root_component = 0;
+
+   return c;
+
+}
+
+
+icalcomponent* icalparser_clean(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*) parser;
+    icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+
+    icalerror_check_arg_rz((parser != 0 ),"parser");
+
+    /* We won't get a clean exit if some components did not have an
+       "END" tag. Clear off any component that may be left in the list */
+    
+
+    while((tail=pvl_data(pvl_tail(impl->components))) != 0){
+
+	insert_error(tail," ",
+		     "Missing END tag for this component. Closing component at end of input.",
+		     ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+	
+
+	impl->root_component = pvl_pop(impl->components);
+	tail=pvl_data(pvl_tail(impl->components));
+
+	if(tail != 0){
+	    icalcomponent_add_component(tail,impl->root_component);
+	}
+    }
+
+    return impl->root_component;
+
+}
+
+struct slg_data {
+	char* pos;
+	char* str;
+};
+
+char* string_line_generator(char *out, size_t buf_size, void *d)
+{
+    char *n;
+    size_t size;
+    struct slg_data* data = (struct slg_data*)d;
+
+    if(data->pos==0){
+	data->pos=data->str;
+    }
+
+    /* If the pointer is at the end of the string, we are done */
+    if (*(data->pos)==0){
+	return 0;
+    }
+
+    n = strchr(data->pos,'\n');
+    
+    if (n == 0){
+	size = strlen(data->pos);
+    } else {
+	n++; /* include newline in output */
+	size = (n-data->pos);	
+    }
+
+    if (size > buf_size-1){
+	size = buf_size-1;
+    }
+    
+
+    strncpy(out,data->pos,size);
+    
+    *(out+size) = '\0';
+    
+    data->pos += size;
+
+    return out;    
+}
+
+icalcomponent* icalparser_parse_string(char* str)
+{
+    icalcomponent *c;
+    struct slg_data d;
+    icalparser *p;
+
+    d.pos = 0;
+    d.str = str;
+
+    p = icalparser_new();
+    icalparser_set_gen_data(p,&d);
+    c = icalparser_parse(p,string_line_generator);
+    icalparser_free(p);
+
+    return c;
+
+}
diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h
new file mode 100644
index 0000000000..25c07eca9f
--- /dev/null
+++ b/libical/src/libical/icalparser.h
@@ -0,0 +1,94 @@
+/* -*- 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* */
+
+typedef void* icalparser;
+typedef enum icalparser_state {
+    ICALPARSER_ERROR,
+    ICALPARSER_SUCCESS,
+    ICALPARSER_BEGIN_COMP,
+    ICALPARSER_END_COMP,
+    ICALPARSER_IN_PROGRESS
+} icalparser_state;
+
+
+/***********************************************************************
+ * Message oriented parsing.  icalparser_parse takes a string that
+ * holds the text ( in RFC 2445 format ) and returns a pointer to an
+ * icalcomponent. The caller owns the memory. line_gen_func is a
+ * pointer to a function that returns one content line per invocation
+ **********************************************************************/
+
+icalcomponent* icalparser_parse(icalparser *parser,
+				char* (*line_gen_func)(char *s, size_t size, void *d));
+
+/* A simple, and incorrect interface - can only return one component*/
+icalcomponent* icalparser_parse_string(char* str);
+
+
+/***********************************************************************
+ * Line-oriented parsing. 
+ * 
+ * Create a new parser via icalparse_new_parser, then add ines one at
+ * a time with icalparse_add_line(). icalparser_add_line() will return
+ * non-zero when it has finished with a component.
+ ***********************************************************************/
+
+icalparser* icalparser_new();
+void icalparser_set_gen_data(icalparser* parser, void* data);
+icalcomponent* icalparser_add_line(icalparser* parser, char* str );
+icalcomponent* icalparser_claim(icalparser* parser);
+icalcomponent* icalparser_clean(icalparser* parser);
+icalparser_state icalparser_get_state(icalparser* parser);
+void icalparser_free(icalparser* parser);
+
+/***********************************************************************
+ * 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);
+
+/* Given a line generator function, return a single iCal content line.*/
+char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d));
+
+
+/* a line_gen_function that returns lines from a string. To use it,
+   set string_line_generator_str to point to the input string, and set
+   string_line_generator_pos to 0. These globals make the routine not
+   thead-safe.  */
+
+extern char* string_line_generator_str;
+extern char* string_line_generator_pos;
+char* string_line_generator(char *out, size_t buf_size, void *d);
+
+#endif /* !ICALPARSE_H */
diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c
new file mode 100644
index 0000000000..c3fe7c9073
--- /dev/null
+++ b/libical/src/libical/icalproperty.c
@@ -0,0 +1,3095 @@
+/* -*- 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
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#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"
+
+#define TMP_BUF_SIZE 1024
+
+/* Private routines for icalproperty */
+void icalvalue_set_parent(icalvalue* value,
+			     icalproperty* property);
+icalproperty* icalvalue_get_parent(icalvalue* value);
+
+void icalparameter_set_parent(icalparameter* param,
+			     icalproperty* property);
+icalproperty* icalparameter_get_parent(icalparameter* value);
+
+
+void icalproperty_set_x_name(icalproperty* prop, char* name);
+
+struct icalproperty_impl 
+{
+	char id[5];
+	icalproperty_kind kind;
+	char* x_name;
+	pvl_list parameters;
+	pvl_elem parameter_iterator;
+	icalvalue* value;
+	icalcomponent *parent;
+};
+
+void icalproperty_add_parameters(struct icalproperty_impl *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) {
+	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_rv((prop!=0),"prop");
+
+    p = (struct icalproperty_impl*)prop;
+
+#ifdef ICAL_FREE_ON_LIST_IS_ERROR
+    icalerror_assert( (p->parent ==0),"Tried to free a property that is still attached to a component. ");
+    
+#else
+    if(p->parent !=0){
+	return;
+    }
+#endif
+
+    if (p->value != 0){
+        icalvalue_set_parent(p->value,0);
+	icalvalue_free(p->value);
+    }
+    
+    while( (param = pvl_pop(p->parameters)) != 0){
+	icalparameter_free(param);
+    }
+    
+    pvl_free(p->parameters);
+    
+    if (p->x_name != 0) {
+	free(p->x_name);
+    }
+    
+    p->kind = ICAL_NO_PROPERTY;
+    p->parameters = 0;
+    p->parameter_iterator = 0;
+    p->value = 0;
+    p->x_name = 0;
+    p->id[0] = 'X';
+    
+    free(p);
+
+}
+
+
+char*
+icalproperty_as_ical_string (icalproperty* prop)
+{   
+    icalparameter *param;
+
+    /* Create new buffer that we can append names, parameters and a
+       value to, and reallocate as needed. Later, this buffer will be
+       copied to a icalmemory_tmp_buffer, which is managed internally
+       by libical, so it can be given to the caller without fear of
+       the caller forgetting to free it */
+
+    char* property_name = 0; 
+    size_t buf_size = 1024;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;
+    icalvalue* value;
+    char *out_buf;
+
+#ifdef ICAL_UNIX_NEWLINE    
+    char newline[] = "\n";
+#else
+    char newline[] = "\r\n";
+#endif
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+    
+    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, newline);
+
+    /* Append parameters */
+    for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
+	param != 0; 
+	param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
+
+	char* kind_string = icalparameter_as_ical_string(param); 
+
+	if (kind_string == 0 ) {
+	    char temp[TMP_BUF_SIZE];
+	    snprintf(temp, TMP_BUF_SIZE,"Got a parameter of unknown kind in %s property",property_name);
+	    icalerror_warn(temp);
+	    continue;
+	}
+
+	icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
+    	icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
+ 	icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+
+    }    
+
+    /* Append value */
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :");
+
+    value = icalproperty_get_value(prop);
+
+    if (value != 0){
+	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, newline);
+
+    /* Now, copy the buffer to a tmp_buffer, which is safe to give to
+       the caller without worring about de-allocating it. */
+
+    
+    out_buf = icalmemory_tmp_buffer(strlen(buf)+1);
+    strcpy(out_buf, buf);
+
+    icalmemory_free_buffer(buf);
+
+    return out_buf;
+}
+
+
+
+icalproperty_kind
+icalproperty_isa (icalproperty* property)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)property;
+
+   if(property != 0){
+       return p->kind;
+   }
+
+   return ICAL_NO_PROPERTY;
+}
+
+int
+icalproperty_isa_property (void* property)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+
+    icalerror_check_arg_rz( (property!=0), "property");
+
+    if (strcmp(impl->id,"prop") == 0) {
+	return 1;
+    } else {
+	return 0;
+    }
+}
+
+
+void
+icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+   icalerror_check_arg_rv( (prop!=0),"prop");
+   icalerror_check_arg_rv( (parameter!=0),"parameter");
+    
+   pvl_push(p->parameters, parameter);
+
+}
+
+
+void
+icalproperty_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_string(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_string(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..d5ffb784ef
--- /dev/null
+++ b/libical/src/libical/icalrestriction.c
@@ -0,0 +1,1590 @@
+/*  -*- 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.
+ 
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalenums.h"
+#include "icalrestriction.h"
+
+#define TMP_BUF_SIZE 1024
+
+/* Define the structs for the restrictions. these data are filled out
+in machine generated code below */
+
+typedef int (*restriction_func)(icalcomponent* comp);
+
+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' So, for
+   ICAL_RESTRICTION_ONE, if there is 1 of a property with that
+   restriction, it passes, but if there are 0 or 2+, it fails. */
+
+char compare_map[ICAL_RESTRICTION_UNKNOWN+1][3] = {
+    { 1, 1, 1},/*ICAL_RESTRICTION_NONE*/
+    { 1, 0, 0},/*ICAL_RESTRICTION_ZERO*/
+    { 0, 1, 0},/*ICAL_RESTRICTION_ONE*/
+    { 1, 1, 1},/*ICAL_RESTRICTION_ZEROPLUS*/
+    { 0, 1, 1},/*ICAL_RESTRICTION_ONEPLUS*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ZEROORONE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEMUTUAL*/
+    { 1, 1, 1} /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+char restr_string_map[ICAL_RESTRICTION_UNKNOWN+1][60] = {
+    "unknown number",/*ICAL_RESTRICTION_NONE*/
+    "0",/*ICAL_RESTRICTION_ZERO*/
+    "1",/*ICAL_RESTRICTION_ONE*/
+    "zero or more",/*ICAL_RESTRICTION_ZEROPLUS*/
+    "one or more" ,/*ICAL_RESTRICTION_ONEPLUS*/
+    "zero or 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[TMP_BUF_SIZE];
+	    
+	    snprintf(temp, TMP_BUF_SIZE,"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..25e0e12b48
--- /dev/null
+++ b/libical/src/libical/icaltypes.c
@@ -0,0 +1,305 @@
+/* -*- 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
+
+ ======================================================================*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icaltypes.h"
+#include "icalerror.h"
+#include "icalmemory.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 */
+
+#define TEMP_MAX 1024
+
+void*
+icalattachtype_get_data (struct icalattachtype* type);
+
+struct icalattachtype*
+icalattachtype_new()
+{
+    struct icalattachtype* v;
+
+    if ( ( v = (struct icalattachtype*)
+	   malloc(sizeof(struct icalattachtype))) == 0) {
+	errno = ENOMEM;
+	return 0;
+    }
+
+    v->refcount = 1;
+
+    v->binary = 0;
+    v->owns_binary = 0;
+
+    v->base64 = 0;
+    v->owns_base64 = 0;
+
+    v->url = 0; 
+
+    return v;
+}
+
+
+void
+icalattachtype_free(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    
+    v->refcount--;
+
+    if (v->refcount <= 0){
+	
+	if (v->base64 != 0 && v->owns_base64 != 0){
+	    free(v->base64);
+	}
+
+	if (v->binary != 0 && v->owns_binary != 0){
+	    free(v->binary);
+	}
+	
+	if (v->url != 0){
+	    free(v->url);
+	}
+
+	free(v);
+    }
+}
+
+void  icalattachtype_add_reference(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    v->refcount++;
+}
+
+void icalattachtype_set_url(struct icalattachtype* v, char* url)
+{
+    icalerror_check_arg( (v!=0),"v");
+
+    if (v->url != 0){
+	free (v->url);
+    }
+
+    v->url = 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));
+} 
+
+
+struct icaldurationtype icaldurationtype_from_timet(time_t t)
+{
+	struct icaldurationtype dur;
+	time_t used = 0;
+
+	dur.weeks = (t - used) / (60 * 60 * 24 * 7);
+	used += dur.weeks * (60 * 60 * 24 * 7);
+	dur.days = (t - used) / (60 * 60 * 24);
+	used += dur.days * (60 * 60 * 24);
+	dur.hours = (t - used) / (60 * 60);
+	used += dur.hours * (60 * 60);
+	dur.minutes = (t - used) / (60);
+	used += dur.minutes * (60);
+	dur.seconds = (t - used);
+
+	return dur;
+} 
+
+
+void icalrecurrencetype_clear(struct icalrecurrencetype *recur)
+{
+    memset(recur,ICAL_RECURRENCE_ARRAY_MAX_BYTE,
+	   sizeof(struct icalrecurrencetype));
+
+    recur->week_start = ICAL_NO_WEEKDAY;
+    recur->freq = ICAL_NO_RECURRENCE;
+    recur->interval = 0;
+    recur->until.year = 0;
+    recur->count = 0;
+}
+
+
+struct icalreqstattype icalreqstattype_from_string(char* str)
+{
+  char *p1,*p2;
+  size_t len; 
+  struct icalreqstattype stat;
+  int major, minor;
+
+  icalerror_check_arg((str != 0),"str");
+
+  stat.code = ICAL_UNKNOWN_STATUS;
+  stat.debug = 0; 
+
+   stat.desc = 0;
+
+  /* Get the status numbers */
+
+  sscanf(str, "%d.%d",&major, &minor);
+
+  if (major <= 0 || minor < 0){
+    icalerror_set_errno(ICAL_BADARG_ERROR);
+    return stat;
+  }
+
+  stat.code = icalenum_num_to_reqstat(major, minor);
+
+  if (stat.code == ICAL_UNKNOWN_STATUS){
+    icalerror_set_errno(ICAL_BADARG_ERROR);
+    return stat;
+  }
+  
+
+  p1 = strchr(str,';');
+
+  if (p1 == 0){
+    icalerror_set_errno(ICAL_BADARG_ERROR);
+    return stat;
+  }
+
+  /* Just ignore the second clause; it will be taken from inside the library 
+   */
+
+
+
+  p2 = strchr(p1+1,';');
+  if (p2 != 0 && *p2 != 0){
+    stat.debug = p2+1;
+  } 
+
+  return stat;
+  
+}
+
+char* icalreqstattype_as_string(struct icalreqstattype stat)
+{
+  char format[20];
+  char *temp;
+
+  temp = (char*)icalmemory_tmp_buffer(TEMP_MAX);
+
+  icalerror_check_arg_rz((stat.code != ICAL_UNKNOWN_STATUS),"Status");
+  
+  if (stat.desc == 0){
+    stat.desc = icalenum_reqstat_desc(stat.code);
+  }
+  
+  if(stat.debug != 0){
+    snprintf(temp,TEMP_MAX,"%d.%d;%s;%s", icalenum_reqstat_major(stat.code),
+             icalenum_reqstat_minor(stat.code),
+             stat.desc, stat.debug);
+    
+  } else {
+    snprintf(temp,TEMP_MAX,"%d.%d;%s", icalenum_reqstat_major(stat.code),
+             icalenum_reqstat_minor(stat.code),
+             stat.desc);
+  }
+
+  return temp;
+}
diff --git a/libical/src/libical/icaltypes.h b/libical/src/libical/icaltypes.h
new file mode 100644
index 0000000000..77a67fae80
--- /dev/null
+++ b/libical/src/libical/icaltypes.h
@@ -0,0 +1,182 @@
+/* -*- 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 icalreqstattype. This struct contains two string pointers,
+but don't try to free either of them. The "desc" string is a pointer
+to a static table inside the library.  Don't try to free it. The
+"debug" string is a pointer into the string that the called passed
+into to icalreqstattype_from_string. Don't try to free it either, and
+don't use it after the original string has been freed.
+
+BTW, you would get that original string from
+*icalproperty_get_requeststatus() or icalvalue_get_text(), when
+operating on a the value of a request_status property. */
+
+struct icalreqstattype {
+
+  icalrequeststatus code;
+  char* desc;
+  char* debug;
+};
+
+struct icalreqstattype icalreqstattype_from_string(char* str);
+char* icalreqstattype_as_string(struct icalreqstattype);
+
+#endif /* !ICALTYPES_H */
diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c
new file mode 100644
index 0000000000..ec332a0f04
--- /dev/null
+++ b/libical/src/libical/icalvalue.c
@@ -0,0 +1,2039 @@
+/* -*- 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)
+
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#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 <stddef.h> /* For offsetof() macro */
+#include <errno.h>
+#include <time.h> /* for mktime */
+#include <stdlib.h> /* for atoi and atof */
+#include <limits.h> /* for SHRT_MAX */
+
+#if _MAC_OS_
+#include "strdup.h"
+#endif
+
+#define TMP_BUF_SIZE 1024
+
+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) {
+	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_STRING_VALUE:
+	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[TMP_BUF_SIZE];
+		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[TMP_BUF_SIZE];
+		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[TMP_BUF_SIZE];
+		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_STRING_VALUE:
+	{
+	    value = icalvalue_new_string(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);
+	    break; 
+
+	}
+	case ICAL_GEO_VALUE:
+	{
+	    value = 0;
+	    /* HACK */
+
+	    if (error != 0){
+		char temp[TMP_BUF_SIZE];
+		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[TMP_BUF_SIZE];
+
+                snprintf(temp,TMP_BUF_SIZE,"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[TMP_BUF_SIZE];
+	
+        snprintf(temp,TMP_BUF_SIZE,"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;size_t offset; short limit;  } recurmap[] = 
+      {
+        {";BYSECOND=",offsetof(struct icalrecurrencetype,by_second),60},
+        {";BYMINUTE=",offsetof(struct icalrecurrencetype,by_minute),60},
+        {";BYHOUR=",offsetof(struct icalrecurrencetype,by_hour),24},
+        {";BYDAY=",offsetof(struct icalrecurrencetype,by_day),7},
+        {";BYMONTHDAY=",offsetof(struct icalrecurrencetype,by_month_day),31},
+        {";BYYEARDAY=",offsetof(struct icalrecurrencetype,by_year_day),366},
+        {";BYWEEKNO=",offsetof(struct icalrecurrencetype,by_week_no),52},
+        {";BYMONTH=",offsetof(struct icalrecurrencetype,by_month),12},
+        {";BYSETPOS=",offsetof(struct icalrecurrencetype,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; recurmap[j].str != 0; j++){
+	short* array = (short*)(recurmap[j].offset+ (size_t)recur);
+	short limit = recurmap[j].limit;
+
+	/* Skip unused arrays */
+	if( array[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
+
+	    icalmemory_append_string(&str,&str_p,&buf_sz,recurmap[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 temp[TMP_BUF_SIZE];
+
+    sprintf(temp,"%d",value);
+
+    icalmemory_append_string(buf, buf_ptr, buf_size, temp);
+    icalmemory_append_string(buf, buf_ptr, buf_size, sep);
+    
+}
+
+char* 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_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: /* HACK. Not correct for DURATION */
+	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. Well,
+   actually, it is auto-generated, but you will have to manually
+   remove the auto-generated version after each generation.  */
+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_string (char* v)
+{
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_STRING_VALUE);
+ 
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_string((icalvalue*)impl,v);
+
+   return (icalvalue*)impl;
+}
+
+void
+icalvalue_set_string(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_STRING_VALUE);
+
+    impl = (struct icalvalue_impl*)value;
+    impl->data.v_string = strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+
+}
+
+char*
+icalvalue_get_string(icalvalue* value)
+{
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_STRING_VALUE);
+  
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+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..ec7457d6aa
--- /dev/null
+++ b/libical/src/libical/icalvalue.h
@@ -0,0 +1,169 @@
+/* -*- 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);
+
+/* STRING # Non-std */
+icalvalue* icalvalue_new_string(char* v);
+char* icalvalue_get_string(icalvalue* value);
+void icalvalue_set_string(icalvalue* value, char* 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/icalversion.h.in b/libical/src/libical/icalversion.h.in
new file mode 100644
index 0000000000..aaeeed6666
--- /dev/null
+++ b/libical/src/libical/icalversion.h.in
@@ -0,0 +1,3 @@
+
+#define ICAL_PACKAGE "@PACKAGE@"
+#define ICAL_VERSION "@VERSION@"
diff --git a/libical/src/libical/icalyacc.y b/libical/src/libical/icalyacc.y
new file mode 100644
index 0000000000..cffcec96d6
--- /dev/null
+++ b/libical/src/libical/icalyacc.y
@@ -0,0 +1,480 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalitip.y
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id: icalyacc.y,v 1.3 2000/05/15 06:18:18 ericb 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 set_parser_value_state();
+struct icaltimetype fill_datetime(char* d, char* t);
+void ical_yy_error(char *s); /* Don't know why I need this.... */
+/*int yylex(void); /* Or this. */
+
+
+
+/* Set the state of the lexer so it will interpret values ( iCAL
+   VALUEs, that is, ) correctly. */
+
+%}
+
+%union {
+	float v_float;
+	int   v_int;
+	char* v_string;
+
+  /* Renaming hack */
+#define    yymaxdepth ical_yy_maxdepth
+#define    yyparse ical_yy_parse
+#define    yylex   ical_yy_lex
+#define    yyerror ical_yy_error
+#define    yylval  ical_yy_lval
+#define    yychar  ical_yy_char
+#define    yydebug ical_yy_debug
+#define    yypact  ical_yy_pact
+#define    yyr1    ical_yy_r1
+#define    yyr2    ical_yy_r2
+#define    yydef   ical_yy_def
+#define    yychk   ical_yy_chk
+#define    yypgo   ical_yy_pgo
+#define    yyact   ical_yy_act
+#define    yyexca  ical_yy_exca
+#define yyerrflag ical_yy_errflag
+#define yynerrs    ical_yy_nerrs
+#define    yyps    ical_yy_ps
+#define    yypv    ical_yy_pv
+#define    yys     ical_yy_s
+#define    yy_yys  ical_yy_yys
+#define    yystate ical_yy_state
+#define    yytmp   ical_yy_tmp
+#define    yyv     ical_yy_v
+#define    yy_yyv  ical_yy_yyv
+#define    yyval   ical_yy_val
+#define    yylloc  ical_yy_lloc
+#define yyreds     ical_yy_reds
+#define yytoks     ical_yy_toks
+#define yylhs      ical_yy_yylhs
+#define yylen      ical_yy_yylen
+#define yydefred ical_yy_yydefred
+#define yydgoto    ical_yy_yydgoto
+#define yydefred ical_yy_yydefred
+#define yydgoto    ical_yy_yydgoto
+#define yysindex ical_yy_yysindex
+#define yyrindex ical_yy_yyrindex
+#define yygindex ical_yy_yygindex
+#define yytable     ical_yy_yytable
+#define yycheck     ical_yy_yycheck
+#define yyname   ical_yy_yyname
+#define yyrule   ical_yy_yyrule
+
+
+
+}
+
+%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/locking.c b/libical/src/libical/locking.c
new file mode 100644
index 0000000000..0376bc2bec
--- /dev/null
+++ b/libical/src/libical/locking.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/pvl.c b/libical/src/libical/pvl.c
new file mode 100644
index 0000000000..d5225a541e
--- /dev/null
+++ b/libical/src/libical/pvl.c
@@ -0,0 +1,768 @@
+/*======================================================================
+ 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.
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "pvl.h"
+#include <errno.h>
+#include <assert.h>
+#include <stdlib.h>
+
+
+
+/*
+  struct pvl_list_t
+
+  The list structure. This is the hanlde for the entire list 
+
+  This type is also private. Use pvl_list instead 
+
+  */
+
+typedef struct pvl_list_t
+{
+	int MAGIC;		        /* Magic Identifier */
+	struct pvl_elem_t *head;	/* Head of list */
+	struct pvl_elem_t *tail;	/* Tail of list */
+	int count;			/* Number of items in the list */
+	struct pvl_elem_t *p;		/* Pointer used for iterators */
+} pvl_list_t;
+
+
+
+
+/* This global is incremented for each call to pvl_new_element(); it gives each
+ * list a unique identifer */
+
+int pvl_elem_count = 0;
+int pvl_list_count = 0;
+
+
+/*----------------------------------------------------------------------
+  Function: pvl_list pvl_newlist()
+ 
+  Purpose:
+
+  Creates a new list, clears the pointers and assigns a magic number
+
+  Returns:
+
+  Pointer to the new list
+  0 if there is no available memory. 
+  *----------------------------------------------------------------------*/
+
+pvl_list 
+pvl_newlist()
+{
+    struct pvl_list_t *L;
+
+    if ( ( L = (struct pvl_list_t*)malloc(sizeof(struct pvl_list_t))) == 0)
+    {
+	errno = ENOMEM;
+	return 0;
+    }
+
+    L->MAGIC = pvl_list_count;
+    pvl_list_count++;
+    L->head = 0;
+    L->tail = 0;
+    L->count = 0;
+    L->p = 0;
+
+    return L;
+}
+
+void
+pvl_free(pvl_list l)
+{
+   struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+   pvl_clear(l);
+
+   free(L);
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_new_element(void *d, struct pvl_elem_t *next,struct pvl_elem_t *prior)
+ 
+  Purpose:
+  Creates a new list element, assigns a magic number, and assigns 
+  the next and previous pointers. 
+
+  Passing in the next and previous points may seem odd, but it allos the user
+  to set them while keeping the internal data hidden. In nearly all cases, 
+  the user is the pvl library itself. 
+
+  Parameters:
+
+  d	The data item to be stored in the list
+  next  Pointer value to assign to the member "next"
+  prior Pointer value to assign to the member "prior"
+
+  Returns:
+  
+  A pointer to the new element.
+  0 if there is no memory available. 
+
+  *----------------------------------------------------------------------*/
+
+pvl_elem 
+pvl_new_element(void *d, pvl_elem next,pvl_elem prior)
+{
+    struct pvl_elem_t *E;
+
+    if ( ( E = (struct pvl_elem_t*)malloc(sizeof(struct pvl_elem_t))) == 0)
+    {
+	errno = ENOMEM;
+	return 0;
+    }
+
+    E->MAGIC = pvl_elem_count++;
+    E->d = d;
+    E->next = next;
+    E->prior = prior;
+
+    return (pvl_elem)E;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_unshift(pvl_list l,void *d)
+ 
+  Purpose:
+
+  Add a new element to the from of the list
+
+  Parameters:
+
+  l	The list to add the item to 
+  d	Pointer to the item to add
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_unshift(pvl_list l,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = pvl_new_element(d,L->head,0);
+
+    if (E->next != 0)
+    {
+	/* Link the head node to it */
+	E->next->prior = E;
+    }
+
+    /* move the head */
+    L->head = E;
+
+    /* maybe move the tail */
+  
+    if (L->tail == 0)
+    {
+	L->tail = E;
+    }
+
+    L->count++;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_shift(pvl_list l)
+ 
+  Purpose:
+
+  Remove an element from the front of the list 
+
+  Parameters:
+
+  l	The list to operate on
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_shift(pvl_list l)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    if (L->head == 0)
+    {
+	return 0;
+    }
+
+    return pvl_remove(l,(void*)L->head);
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void  pvl_push(pvl_list l,void *d)
+
+  Purpose:
+
+  Add a new item to the tail of the list
+
+  Paramters:
+
+  l	The list to operate on
+  d	Pointer to the item to add
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_push(pvl_list l,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = pvl_new_element(d,0,L->tail);
+
+    /* These are done in pvl_new_element
+       E->next = 0;
+       E->prior = L->tail;
+    */
+
+    if (L->tail != 0) 
+    {
+	L->tail->next = E;
+    }
+
+    if (L->head == 0) 
+    {
+	L->head = E;
+    }
+  
+    L->tail = E;
+
+    L->count++;
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void*  pvl_pop(pvl_list l)
+
+  Purpose:
+
+  Remove an element from the tail of the list 
+
+  Paramters:
+
+  l	The list to operate on
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_pop(pvl_list l)
+{
+
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    if ( L->tail == 0)
+    {
+	return 0;
+    }
+
+    return pvl_remove(l,(void*) L->tail);;
+
+}
+
+
+/*----------------------------------------------------------------------
+  Function: void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
+
+  Purpose:
+  
+  Add a new item to a list that is ordered by a comparison function. 
+  This routine assumes that the list is properly ordered. 
+
+  l	The list to operate on
+  f	Pointer to a comparison function
+  d     Pointer to data to pass to the comparison function
+
+  Returns:
+
+  void
+
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    struct pvl_elem_t *P;
+
+    L->count++;
+
+    /* Empty list, add to head */
+
+    if(L->head == 0)
+    {
+	pvl_unshift(l,d);
+	return;
+    }
+
+    /* smaller than head, add to head */
+
+    if ( ((*f)(d,L->head->d)) < 0)
+    { 
+	pvl_unshift(l,d);
+	return;
+    }
+
+    /* larger than tail, add to tail */
+    if ( (*f)(d,L->tail->d) > 0)
+    { 
+	pvl_push(l,d);
+	return;
+    }
+
+
+    /* Search for the first element that is smaller, and add before it */
+
+    for (P=L->head; P != 0; P = P->next)
+    {
+	if ( (*f)(P->d,d) > 0)
+	{
+	    pvl_insert_before(l,P,d);
+	    return;
+	}
+    }
+
+    /* badness, choke */
+
+    assert(0);
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void  pvl_insert_after(pvl_list l,pvl_elem p,void *d)
+
+  Purpose:
+
+  Add a new item after the referenced element. 
+
+  Parameters:
+
+  l	The list to operate on 
+  p	The list element to add the item after
+  d	Pointer to the item to add. 
+
+  Returns:
+
+  void
+
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_after(pvl_list l,pvl_elem p,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *P = (struct pvl_elem_t *)p;
+    struct pvl_elem_t *E = 0;
+
+    L->count++;
+
+    if (P == 0)
+    {
+	pvl_unshift(l,d);
+	return;
+    }
+
+    if ( P == L->tail)
+    {
+	E = pvl_new_element(d,0,P);
+	L->tail = E;
+	E->prior->next = E;
+    }
+    else
+    {
+	E = pvl_new_element(d,P->next,P);
+	E->next->prior  = E;
+	E->prior->next = E;
+    }
+}
+
+/*----------------------------------------------------------------------
+  Function: void pvl_insert_before(pvl_list l,pvl_elem p,void *d)
+
+  Purpose:
+
+  Add an item after a referenced item
+
+  Parameters:
+
+  l	The list to operate on
+  p	The list element to add the item before
+  d	Pointer to the data to be added. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_before(pvl_list l,pvl_elem p,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *P = (struct pvl_elem_t *)p;
+    struct pvl_elem_t *E = 0;
+
+    L->count++;
+
+    if (P == 0)
+    {
+	pvl_unshift(l,d);
+	return;
+    }
+
+    if ( P == L->head)
+    {
+	E = pvl_new_element(d,P,0);
+	E->next->prior = E;
+	L->head = E;
+    }
+    else
+    {
+	E = pvl_new_element(d,P,P->prior);
+	E->prior->next = E;
+	E->next->prior = E;
+    }
+}
+
+/*----------------------------------------------------------------------
+  Function: void pvl_remove(pvl_list l,pvl_elem e)
+ 
+  Purpose:
+
+  Remove the referenced item from the list
+
+  This routine will free the element, but not the data item that the
+  element contains. 
+
+  Parameters:
+
+  l	The list to operate on
+  e	The element to remove. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_remove(pvl_list l,pvl_elem e)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = (struct pvl_elem_t *)e;
+    void* data;
+
+    if (E == L->head)
+    {
+	if (E->next != 0)
+	{
+	    E->next->prior = 0;
+	    L->head = E->next;
+	} else {
+	    /* E Also points to tail -> only one element in list */
+	    L->tail = 0;
+	    L->head = 0;
+	}
+    }
+    else if (E == L->tail)
+    {
+	if (E->prior != 0)
+	{
+	    E->prior->next = 0;
+	    L->tail = E->prior;
+	} else {
+	    /* E points to the head, so it was the last element */
+	    /* This case should be taken care of in the previous clause */
+	    L->head = 0;
+	    L->tail = 0;
+	}
+    }
+    else
+    {
+	E->prior->next = E->next;
+	E->next->prior = E->prior;
+    }
+
+
+    L->count--;
+
+    data = E->d; 
+
+    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/.cvsignore b/libical/src/libicalss/.cvsignore
new file mode 100644
index 0000000000..732c1577b6
--- /dev/null
+++ b/libical/src/libicalss/.cvsignore
@@ -0,0 +1,6 @@
+Makefile
+.deps
+Makefile.in
+*.lo
+*.la
+.libs
\ No newline at end of file
diff --git a/libical/src/libicalss/Makefile.am b/libical/src/libicalss/Makefile.am
new file mode 100644
index 0000000000..ea37380688
--- /dev/null
+++ b/libical/src/libicalss/Makefile.am
@@ -0,0 +1,23 @@
+
+
+#noinst_LTLIBRARIES = libicalss.la
+lib_LTLIBRARIES = libicalss.la
+
+libicalss_la_SOURCES =\
+	icalcalendar.c	\
+	icalcalendar.h	\
+	icalcluster.c \
+	icalcluster.h \
+	icalstore.c \
+	icalstore.h
+
+include_HEADERS =\
+	icalcalendar.h	\
+	icalcluster.h \
+	icalstore.h
+
+
+INCLUDES =					\
+	-I $(srcdir)/../libical/		\
+	-I ../libical
+
diff --git a/libical/src/libicalss/icalcalendar.c b/libical/src/libicalss/icalcalendar.c
new file mode 100644
index 0000000000..0f2231b1d7
--- /dev/null
+++ b/libical/src/libicalss/icalcalendar.c
@@ -0,0 +1,268 @@
+/* -*- 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
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#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..36bdccc743
--- /dev/null
+++ b/libical/src/libicalss/icalcluster.c
@@ -0,0 +1,423 @@
+/* -*- 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
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#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>
+#include <fcntl.h> /* for fcntl */
+#include <unistd.h> /* for fcntl */
+
+icalerrorenum icalcluster_create_cluster(char *path);
+
+struct icalcluster_impl {
+	char *path;
+	icalcomponent* cluster;
+	int changed;
+	FILE* stream;
+};
+
+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;
+}
+
+char* read_from_file(char *s, size_t size, void *d)
+{
+    char *c = fgets(s,size, (FILE*)d);
+    return c;
+}
+
+icalcluster* icalcluster_new(char* path)
+{
+    struct icalcluster_impl *impl = icalcluster_new_impl(); 
+    struct stat sbuf;
+    int createclusterfile = 0;
+    icalerrorenum error = ICAL_NO_ERROR;
+    icalparser *parser;
+    struct icaltimetype tt;
+    off_t cluster_file_size;
+
+    memset(&tt,0,sizeof(struct icaltimetype));
+
+    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;
+    impl->stream = 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 */
+	cluster_file_size = 0;
+	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 */
+          cluster_file_size = sbuf.st_size;
+          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;
+	}
+    }
+
+    impl->path = (char*)strdup(path);
+
+    errno = 0;
+    impl->stream = fopen(impl->path,"r");
+    
+    if (impl->stream ==0 || errno != 0){
+	impl->cluster = 0;
+	icalerror_set_errno(ICAL_FILE_ERROR); /* Redundant, actually */
+	return 0;
+    }
+
+    icalcluster_lock(impl);
+
+    if(cluster_file_size > 0){
+      parser = icalparser_new();
+      icalparser_set_gen_data(parser,impl->stream);
+      impl->cluster = icalparser_parse(parser,read_from_file);
+      icalparser_free(parser);
+
+      if (icalcomponent_isa(impl->cluster) != ICAL_XROOT_COMPONENT){
+        /* The parser got a single component, so it did not put it in
+           an XROOT. */
+        icalcomponent *cl = impl->cluster;
+        impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+        icalcomponent_add_component(impl->cluster,cl);
+      }
+
+    } else {
+
+      impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+    }      
+
+    if (impl->cluster == 0){
+	icalerror_set_errno(ICAL_PARSE_ERROR);
+	return 0;
+    }
+    
+    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;
+    }
+
+    if(impl->stream != 0){
+	icalcluster_unlock(impl);
+	fclose(impl->stream);
+	impl->stream = 0;
+    }
+
+    free(impl);
+}
+
+char* icalcluster_path(icalcluster* cluster)
+{
+    struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    return impl->path;
+}
+
+
+int icalcluster_lock(icalcluster *cluster)
+{
+    struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+    struct flock lock;
+    int fd; 
+
+    icalerror_check_arg_rz((impl->stream!=0),"impl->stream");
+
+    fd  = fileno(impl->stream);
+
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    return (fcntl(fd, F_SETLKW, &lock)); 
+}
+
+int icalcluster_unlock(icalcluster *cluster)
+{
+    struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+    int fd;
+    struct flock lock;
+    icalerror_check_arg_rz((impl->stream!=0),"impl->stream");
+
+    fd  = fileno(impl->stream);
+
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    return (fcntl(fd, F_UNLCK, &lock)); 
+
+}
+
+icalerrorenum icalcluster_create_cluster(char *path)
+{
+
+    FILE* f;
+    int r;
+    icalcomponent *c;
+
+    icalerror_clear_errno();
+
+    f = fopen(path,"w");
+
+    if (f == 0){
+	icalerror_set_errno(ICAL_FILE_ERROR);
+	return ICAL_FILE_ERROR;
+    }
+
+    
+    /* This used to write data to the file... */
+
+	    
+    fclose(f);
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcluster_commit(icalcluster* cluster)
+{
+    FILE *f;
+    char tmp[PATH_MAX]; /* HACK Buffer overflow potential */
+    char *str;
+    icalparser *parser;
+    icalcomponent *c;
+    
+    struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+
+    icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);
+
+    if (impl->changed == 0 ){
+	return ICAL_NO_ERROR;
+    }
+    
+#ifdef ICAL_SAFESAVES
+    snprintf(tmp,PATH_MAX,"%s-tmp",impl->path);
+#else	
+    strcpy(tmp,impl->path);
+#endif
+    
+    if ( (f = fopen(tmp,"w")) < 0 ){
+	icalerror_set_errno(ICAL_FILE_ERROR);
+	return ICAL_FILE_ERROR;
+    }
+    
+    for(c = icalcomponent_get_first_component(impl->cluster,ICAL_ANY_COMPONENT);
+	c != 0;
+	c = icalcomponent_get_next_component(impl->cluster,ICAL_ANY_COMPONENT)){
+
+	str = icalcomponent_as_ical_string(c);
+    
+	if (  fwrite(str,sizeof(char),strlen(str),f) < strlen(str)){
+	    fclose(f);
+	    return ICAL_FILE_ERROR;
+	}
+    }
+    
+    fclose(f);
+    impl->changed = 0;    
+        
+#ifdef ICAL_SAFESAVES
+    rename(tmp,impl->path); /* HACK, should check for error here */
+#endif
+    
+    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..39fe542027
--- /dev/null
+++ b/libical/src/libicalss/icalcluster.h
@@ -0,0 +1,73 @@
+/* -*- 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);
+
+char* icalcluster_path(icalcluster* cluster);
+
+/* 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..382464e476
--- /dev/null
+++ b/libical/src/libicalss/icalstore.c
@@ -0,0 +1,858 @@
+/* -*- 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "ical.h"
+#include "icalstore.h"
+#include "pvl.h" 
+#include "icalerror.h"
+#include "icalparser.h"
+#include "icalcluster.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(char* dir)
+{
+}
+
+
+void icalstore_unlock(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);
+
+    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(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(impl->directory !=0 &&  (str=pvl_pop(impl->directory)) != 0){
+	free(str);
+    }
+
+    if(impl->directory != 0){
+	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));
+
+    icalcluster_free(impl->cluster);
+
+    impl->cluster = icalcluster_new(path);
+
+    return icalerrno;
+}
+
+void icalstore_add_uid(icalstore* store, icalstore* comp)
+{
+    char uidstring[PATH_MAX];
+    icalproperty *uid;
+    struct utsname unamebuf;
+
+    icalerror_check_arg_rv( (store!=0), "store");
+    icalerror_check_arg_rv( (comp!=0), "comp");
+
+    uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY);
+    
+    if (uid == 0) {
+	
+	uname(&unamebuf);
+	
+	sprintf(uidstring,"%d-%s",(int)getpid(),unamebuf.nodename);
+	
+	uid = icalproperty_new_uid(uidstring);
+	icalcomponent_add_property(comp,uid);
+    } else {
+	
+	strcpy(uidstring,icalproperty_get_uid(uid));
+    }
+}
+
+
+/* This assumes that the top level component is a VCALENDAR, and there
+   is an inner component of type VEVENT, VTODO or VJOURNAL. The inner
+   component must have a DTSTART property */
+
+icalerrorenum icalstore_add_component(icalstore* store, icalstore* comp)
+{
+    struct icalstore_impl *impl;
+    char clustername[PATH_MAX];
+    icalproperty *dt, *count;
+    icalvalue *v;
+    struct icaltimetype tm;
+    icalerrorenum error = ICAL_NO_ERROR;
+    icalcomponent *inner;
+
+    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. This is a HACK */
+
+    for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+	inner != 0;
+	inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+  
+	dt = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
+	
+	if (dt != 0){
+	    break; 
+	}	
+    }
+
+    if (dt == 0){
+	icalerror_warn("The component does not have a DTSTART 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);
+
+    snprintf(clustername,PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month);
+
+    /* Load the cluster and insert the object */
+
+    if(impl->cluster != 0 && 
+       strcmp(clustername,icalcluster_path(impl->cluster)) != 0 ){
+	icalcluster_free(impl->cluster);
+	impl->cluster = 0;
+    }
+
+    if (impl->cluster == 0){
+	impl->cluster = icalcluster_new(clustername);
+
+	if (impl->cluster == 0){
+	    error = icalerrno;
+	}
+    }
+    
+    if (error != ICAL_NO_ERROR){
+	icalerror_set_errno(error);
+	return error;
+    }
+
+    /* 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:XROOT
+   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
+   END:XROOT
+
+   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 sub-components.
+   
+  */
+
+
+int icalstore_test_recurse(icalcomponent* comp, icalcomponent* gauge)
+{
+    int pass = 1,localpass = 0;
+    icalproperty *p;
+    icalcomponent *child,*subgauge; 
+    icalcomponent_kind gaugekind, compkind;
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+
+    gaugekind = icalcomponent_isa(gauge);
+    compkind = icalcomponent_isa(comp);
+
+    if( ! (gaugekind == compkind || gaugekind == ICAL_ANY_COMPONENT) ){
+	return 0;
+    }   
+
+    /* 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(gauge,ICAL_ANY_PROPERTY);
+	p != 0;
+	p = icalcomponent_get_next_property(gauge,ICAL_ANY_PROPERTY)){
+	
+	icalproperty* targetprop; 
+	icalparameter* compareparam;
+	icalparameter_xliccomparetype compare;
+	int rel; /* The relationship 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. HACK -- multiples of a single
+	   property type in the gauge will match only the first
+	   instance in the component */
+	
+	targetprop = icalcomponent_get_first_property(comp,
+						      icalproperty_isa(p));
+	
+	if(targetprop != 0){
+	
+	    /* 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)) {
+		localpass++;
+	    } else {
+		localpass = 0;
+	    }
+	    
+	    pass = pass && (localpass>0);
+	}
+    }
+    
+    /* Test subcomponents. Look for a child component that has a
+       counterpart in the gauge. If one is found, recursively call
+       icalstore_test */
+    
+    for(subgauge = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT);
+	subgauge != 0;
+	subgauge = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){
+	
+	gaugekind = icalcomponent_isa(subgauge);
+
+	if (gaugekind == ICAL_ANY_COMPONENT){
+	    child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+	} else {
+	    child = icalcomponent_get_first_component(comp,gaugekind);
+	}
+	
+	if(child !=0){
+	    localpass = icalstore_test_recurse(child,subgauge);
+	    pass = pass && localpass;
+	} else {
+	    pass = 0;
+	}
+    }
+    
+    return pass;   
+}
+
+/* guagecontainer is an XROOT component that holds several gauges. The
+   results of comparing against these gauges are ORed together in this
+   routine */
+int icalstore_test(icalcomponent* comp, icalcomponent* gaugecontainer)
+{
+    int pass = 0;
+    icalcomponent *gauge; 
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+    
+    for(gauge = icalcomponent_get_first_component(gaugecontainer,ICAL_ANY_COMPONENT);
+	gauge != 0;
+	gauge = icalcomponent_get_next_component(gaugecontainer,ICAL_ANY_COMPONENT)){
+
+	pass += icalstore_test_recurse(comp, 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 the next cluster we need is different than the current cluster, 
+       delete the current one and get a new one */
+
+    if(impl->cluster != 0 && strcmp(path,icalcluster_path(impl->cluster)) != 0 ){
+	icalcluster_free(impl->cluster);
+	impl->cluster = 0;
+    }
+    
+    if (impl->cluster == 0){
+	impl->cluster = icalcluster_new(path);
+
+	if (impl->cluster == 0){
+	    error = icalerrno;
+	}
+    } 
+
+    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/.cvsignore b/libical/src/test/.cvsignore
new file mode 100644
index 0000000000..6b1e8fab06
--- /dev/null
+++ b/libical/src/test/.cvsignore
@@ -0,0 +1,11 @@
+Makefile
+usecases
+copycluster
+regression
+icalparser
+findobj
+.deps
+.libs
+parser
+storage
+Makefile.in
diff --git a/libical/src/test/Makefile.am b/libical/src/test/Makefile.am
new file mode 100644
index 0000000000..50810f4b95
--- /dev/null
+++ b/libical/src/test/Makefile.am
@@ -0,0 +1,12 @@
+
+noinst_PROGRAMS = usecases copycluster regression parser findobj storage
+
+LDADD = ../libical/libical.la ../libicalss/libicalss.la
+INCLUDES = -I$(srcdir) -I$(srcdir)/../libical -I$(srcdir)/../libicalss -I../libical
+
+findobj_SOURCES = findobj.c
+usecases_SOURCES = usecases.c
+copycluster_SOURCES = copycluster.c
+regression_SOURCES = regression.c
+parser_SOURCES = icaltestparser.c
+storage_SOURCES = storage.c
\ 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.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.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/icaltestparser.c b/libical/src/test/icaltestparser.c
new file mode 100644
index 0000000000..3f07fcd044
--- /dev/null
+++ b/libical/src/test/icaltestparser.c
@@ -0,0 +1,123 @@
+/* -*- 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_stream(char *s, size_t size, void *d)
+{
+  char *c = fgets(s,size, (FILE*)d);
+
+  return c;
+
+}
+
+
+
+int main(int argc, char* argv[])
+{
+
+    int lineno = 0;
+    char* line; 
+    FILE* stream;
+    icalcomponent *c; 
+    icalparser *parser = icalparser_new();
+
+    stream = fopen(argv[1],"r");
+
+    assert(stream != 0);
+
+    icalparser_set_gen_data(parser,stream);
+
+    do{
+    
+	line = icalparser_get_line(parser,read_stream);
+
+	c = icalparser_add_line(parser,line);
+
+	if (c != 0){
+	    icalcomponent_convert_errors(c);
+	    printf("%s",icalcomponent_as_ical_string(c));
+	    icalparser_claim(parser);
+	    printf("\n---------------\n");
+	    icalcomponent_free(c);
+	}
+
+    } while ( line != 0);
+
+
+}
diff --git a/libical/src/test/regression.c b/libical/src/test/regression.c
new file mode 100644
index 0000000000..7b1606d432
--- /dev/null
+++ b/libical/src/test/regression.c
@@ -0,0 +1,1334 @@
+/* -*- 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 */
+
+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";
+
+
+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_PARAMETER);
+	param != 0; 
+	param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
+						
+	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_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_REQUEST),
+	    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));
+
+    icalvalue_free(v);
+    v = icalvalue_new_from_string(ICAL_PERIOD_VALUE,
+				  "19971015T050000Z/PT8H30M");
+
+    printf("%s\n",icalvalue_as_ical_string(v));
+
+    icalvalue_free(v);
+    v = icalvalue_new_from_string(ICAL_PERIOD_VALUE,
+				  "19971015T050000Z/19971015T060000Z");
+
+    printf("%s\n",icalvalue_as_ical_string(v));
+    icalvalue_free(v);
+
+
+}
+
+
+void test_strings(){
+
+    icalvalue *v;
+
+    v = icalvalue_new_text("foo;bar;bats");
+    
+    printf("%s\n",icalvalue_as_ical_string(v));
+
+    icalvalue_free(v);
+
+    v = icalvalue_new_text("foo\\;b\nar\\;ba\tts");
+    
+    printf("%s\n",icalvalue_as_ical_string(v));
+    
+    icalvalue_free(v);
+
+
+}
+
+void test_requeststat()
+{
+  icalrequeststatus s;
+  struct icalreqstattype st, st2;
+  char temp[1024];
+
+  s = icalenum_num_to_reqstat(2,1);
+
+  assert(s == ICAL_2_1_FALLBACK_STATUS);
+
+  assert(icalenum_reqstat_major(s) == 2);
+  assert(icalenum_reqstat_minor(s) == 1);
+
+  printf("2.1: %s\n",icalenum_reqstat_desc(s));
+
+  st.code = s;
+  st.debug = "booga";
+  st.desc = 0;
+
+  printf("%s\n",icalreqstattype_as_string(st));
+
+  st.desc = " A non-standard description";
+
+  printf("%s\n",icalreqstattype_as_string(st));
+
+
+  st.desc = 0;
+
+  sprintf(temp,"%s\n",icalreqstattype_as_string(st));
+  
+
+  st2 = icalreqstattype_from_string("2.1;Success but fallback taken  on one or more property  values.;booga");
+
+  printf("%d --  %d --  %s -- %s\n",icalenum_reqstat_major(st2.code),
+         icalenum_reqstat_minor(st2.code),
+         icalenum_reqstat_desc(st2.code),
+         st2.debug);
+
+  st2 = icalreqstattype_from_string("2.1;Success but fallback taken  on one or more property  values.;booga");
+  printf("%s\n",icalreqstattype_as_string(st2));
+
+  st2 = icalreqstattype_from_string("2.1;Success but fallback taken  on one or more property  values.;");
+  printf("%s\n",icalreqstattype_as_string(st2));
+
+  st2 = icalreqstattype_from_string("2.1;Success but fallback taken  on one or more property  values.");
+  printf("%s\n",icalreqstattype_as_string(st2));
+
+  st2 = icalreqstattype_from_string("2.1;");
+  printf("%s\n",icalreqstattype_as_string(st2));
+
+  st2 = icalreqstattype_from_string("2.1");
+  printf("%s\n",icalreqstattype_as_string(st2));
+
+  st2 = icalreqstattype_from_string("16.4");
+  assert(st2.code == ICAL_UNKNOWN_STATUS);
+
+  st2 = icalreqstattype_from_string("1.");
+  assert(st2.code == ICAL_UNKNOWN_STATUS);
+
+}
+
+
+int main(int argc, char *argv[])
+{
+
+
+    printf("\n------------Test Restriction---------------\n");
+    test_restriction();
+
+    exit(0);
+
+    printf("\n------------Test request status-------\n");
+    test_requeststat();
+
+
+    printf("\n------------Test strings---------------\n");
+    test_strings();
+
+    printf("\n------------Test recur---------------\n");
+    test_recur();
+
+    printf("\n------------Test duration---------------\n");
+    test_duration();
+
+    printf("\n------------Test Compare---------------\n");
+    test_compare();
+
+    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----- Create Components with vaargs ---\n");
+    create_new_component_with_va_args();
+
+    
+
+
+    return 0;
+}
+
+
+
diff --git a/libical/src/test/storage.c b/libical/src/test/storage.c
new file mode 100644
index 0000000000..f6d0dd69e5
--- /dev/null
+++ b/libical/src/test/storage.c
@@ -0,0 +1,460 @@
+/* -*- 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 */
+
+char str[] = "BEGIN:VCALENDAR\n\
+PRODID:\"-//RDU Software//NONSGML HandCal//EN\"\n\
+VERSION:2.0\n\
+BEGIN:VTIMEZONE\n\
+TZID:US-Eastern\n\
+BEGIN:STANDARD\n\
+DTSTART:19981025T020000\n\
+RDATE:19981025T020000\n\
+TZOFFSETFROM:-0400\n\
+TZOFFSETTO:-0500\n\
+TZNAME:EST\n\
+END:STANDARD\n\
+BEGIN:DAYLIGHT\n\
+DTSTART:19990404T020000\n\
+RDATE:19990404T020000\n\
+TZOFFSETFROM:-0500\n\
+TZOFFSETTO:-0400\n\
+TZNAME:EDT\n\
+END:DAYLIGHT\n\
+END:VTIMEZONE\n\
+BEGIN:VEVENT\n\
+DTSTAMP:19980309T231000Z\n\
+UID:guid-1.host1.com\n\
+ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com\n\
+ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n\
+DESCRIPTION:Project XYZ Review Meeting\n\
+CATEGORIES:MEETING\n\
+CLASS:PUBLIC\n\
+CREATED:19980309T130000Z\n\
+SUMMARY:XYZ Project Review\n\
+DTSTART;TZID=US-Eastern:19980312T083000\n\
+DTEND;TZID=US-Eastern:19980312T093000\n\
+LOCATION:1CP Conference Room 4350\n\
+END:VEVENT\n\
+BEGIN:BOOGA\n\
+DTSTAMP:19980309T231000Z\n\
+X-LIC-FOO:Booga\n\
+DTSTOMP:19980309T231000Z\n\
+UID:guid-1.host1.com\n\
+END:BOOGA\n\
+END:VCALENDAR";
+
+char str2[] = "BEGIN:VCALENDAR\n\
+PRODID:\"-//RDU Software//NONSGML HandCal//EN\"\n\
+VERSION:2.0\n\
+BEGIN:VEVENT\n\
+DTSTAMP:19980309T231000Z\n\
+UID:guid-1.host1.com\n\
+ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com\n\
+ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n\
+DESCRIPTION:Project XYZ Review Meeting\n\
+CATEGORIES:MEETING\n\
+CLASS:PUBLIC\n\
+CREATED:19980309T130000Z\n\
+SUMMARY:XYZ Project Review\n\
+DTSTART;TZID=US-Eastern:19980312T083000\n\
+DTEND;TZID=US-Eastern:19980312T093000\n\
+LOCATION:1CP Conference Room 4350\n\
+END:VEVENT\n\
+END:VCALENDAR\n\
+";
+
+
+void test_cluster()
+{
+    icalcluster *cin, *cout;
+    int month = 0;
+    int count=0;
+    struct icaltimetype start, end;
+    icalcomponent *c,*clone, *itr;
+
+    start = icaltimetype_from_timet( time(0),0);
+    end = start;
+    end.hour++;
+
+    cout = icalcluster_new("clusterout.ics");
+    assert(cout != 0);
+
+    c = icalparser_parse_string(str2);
+    assert(c != 0);
+
+    for(month = 1; month < 2; month++){
+	icalcomponent *event;
+	icalproperty *dtstart, *dtend;
+
+        cout = icalcluster_new("clusterout.ics");
+        assert(cout != 0);
+
+	start.month = month; 
+	end.month = month;
+	
+	clone = icalcomponent_new_clone(c);
+	assert(clone !=0);
+	event = icalcomponent_get_first_component(clone,ICAL_VEVENT_COMPONENT);
+	assert(event != 0);
+
+	dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
+	assert(dtstart!=0);
+	icalproperty_set_dtstart(dtstart,start);
+        
+	dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
+	assert(dtend!=0);
+	icalproperty_set_dtend(dtend,end);
+	
+	icalcluster_add_component(cout,clone);
+	icalcluster_commit(cout);
+
+        icalcluster_free(cout);
+
+    }
+
+
+    /* Print them out */
+
+
+    cout = icalcluster_new("clusterout.ics");
+    assert(cout != 0);
+    
+    for (itr = icalcluster_get_first_component(cout,
+                                               ICAL_ANY_COMPONENT);
+         itr != 0;
+         itr = icalcluster_get_next_component(cout,
+                                              ICAL_ANY_COMPONENT)){ 
+
+      icalcomponent *event;
+      icalproperty *dtstart, *dtend;
+
+      count++;
+
+      event = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);
+
+      dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
+      dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
+      
+      printf("%d %s %s\n",count, icalproperty_as_ical_string(dtstart),
+             icalproperty_as_ical_string(dtend));
+
+    }
+
+    /* Remove all of them */
+
+    icalcluster_free(cout);
+
+    cout = icalcluster_new("clusterout.ics");
+    assert(cout != 0);
+    
+    for (itr = icalcluster_get_first_component(cout,
+                                               ICAL_ANY_COMPONENT);
+         itr != 0;
+         itr = icalcluster_get_next_component(cout,
+                                              ICAL_ANY_COMPONENT)){ 
+
+
+      icalcluster_remove_component(cout, itr);
+    }
+
+    icalcluster_free(cout);
+
+
+    /* Print them out again */
+
+    cout = icalcluster_new("clusterout.ics");
+    assert(cout != 0);
+    count =0;
+    
+    for (itr = icalcluster_get_first_component(cout,
+                                               ICAL_ANY_COMPONENT);
+         itr != 0;
+         itr = icalcluster_get_next_component(cout,
+                                              ICAL_ANY_COMPONENT)){ 
+
+      icalcomponent *event;
+      icalproperty *dtstart, *dtend;
+
+      count++;
+
+      event = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);
+
+      dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
+      dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
+      
+      printf("%d %s %s\n",count, icalproperty_as_ical_string(dtstart),
+             icalproperty_as_ical_string(dtend));
+
+    }
+
+    icalcluster_free(cout);
+
+
+}
+
+
+
+int test_store()
+{
+
+    icalcomponent *c, *gauge;
+    icalerrorenum error;
+    icalcomponent *next, *itr;
+    icalcluster* cluster;
+    struct icalperiodtype rtime;
+    icalstore *s = icalstore_new("store");
+    int i;
+
+    assert(s != 0);
+
+    rtime.start = icaltimetype_from_timet( time(0),0);
+
+    cluster = icalcluster_new("clusterout.ics");
+
+    assert(cluster != 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, *inner;
+	    icalproperty *p;
+
+	    inner = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);
+            if (inner == 0){
+              continue;
+            }
+
+	    /* Change the dtstart and dtend times in the component
+               pointed to by Itr*/
+
+	    clone = icalcomponent_new_clone(itr);
+	    inner = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);
+
+	    assert(icalerrno == ICAL_NO_ERROR);
+	    assert(inner !=0);
+
+	    /* DTSTART*/
+	    p = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
+	    assert(icalerrno  == ICAL_NO_ERROR);
+
+	    if (p == 0){
+		p = icalproperty_new_dtstart(rtime.start);
+		icalcomponent_add_property(inner,p);
+	    } else {
+		icalproperty_set_dtstart(p,rtime.start);
+	    }
+	    assert(icalerrno  == ICAL_NO_ERROR);
+
+	    /* DTEND*/
+	    p = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
+	    assert(icalerrno  == ICAL_NO_ERROR);
+
+	    if (p == 0){
+		p = icalproperty_new_dtstart(rtime.end);
+		icalcomponent_add_property(inner,p);
+	    } else {
+		icalproperty_set_dtstart(p,rtime.end);
+	    }
+	    assert(icalerrno  == ICAL_NO_ERROR);
+	    
+	    printf("\n----------\n%s\n---------\n",icalcomponent_as_ical_string(inner));
+
+	    error = icalstore_add_component(s,inner);
+	    
+	    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;
+}
+
+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);
+
+}
+
+
+int main(int argc, char *argv[])
+{
+
+
+    printf("\n------------Test Cluster---------------\n");
+    test_cluster();
+
+#if 0    
+
+    printf("\n------------Test Store---------------\n");
+    test_store();
+
+
+
+    printf("\n------------Test Calendar---------------\n");
+    test_calendar();
+
+#endif
+
+    return 0;
+}
+
+
+
diff --git a/libical/src/test/test-component.icd b/libical/src/test/test-component.icd
new file mode 100644
index 0000000000..3fe2995a83
--- /dev/null
+++ b/libical/src/test/test-component.icd
@@ -0,0 +1,23 @@
+BEGIN:VCALENDAR
+X-LIC-CLUSTERCOUNT
+ :0
+DTSTART
+ :00000000T000000
+DTEND
+ :00000000T000000     
+BEGIN:VCALENDAR
+PRODID:-//RDU Software//NONSGML HandCal//EN
+METHOD:REPLY
+VERSION:2.0
+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
+END:VCALENDAR
diff --git a/libical/src/test/usecases.c b/libical/src/test/usecases.c
new file mode 100644
index 0000000000..05c295197f
--- /dev/null
+++ b/libical/src/test/usecases.c
@@ -0,0 +1,553 @@
+/* -*- 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. 
+
+	  There are more rules, so refer to the documentation for more 
+	  details. 
+
+    */
+
+    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 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;
+
+}
+
+
+