Initial revision

svn path=/trunk/; revision=6915

7 files changed, 3801 insertions, 0 deletions

diff --git a/libical/src/libical/icalparameter.c.in b/libical/src/libical/icalparameter.c.in
new file mode 100644
index 0000000000..0a0efc1332
--- /dev/null
+++ b/libical/src/libical/icalparameter.c.in
@@ -0,0 +1,1234 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedparameters.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id: icalparameter.c.in,v 1.1 2000/12/11 22:05:59 federico Exp $
+  $Locker:  $
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalderivedparameters.{c,h}
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+ ======================================================================*/
+#line 29 "icalparameter.c.in"
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+#include "icalparameter.h"
+#include "icalproperty.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+
+#include <stdlib.h> /* for malloc() */
+#include <errno.h>
+#include <string.h> /* for memset() */
+
+union icalparameter_impl_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_kind kind;
+	char id[5];
+	int size;
+	const char* string;
+	const char* x_name;
+	icalproperty* parent;
+
+	union icalparameter_impl_data 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 = icalmemory_strdup(old->string);
+	if (new->string == 0){
+	    icalparameter_free(new);
+	    return 0;
+	}
+    }
+
+    if (old->x_name != 0){
+	new->x_name = icalmemory_strdup(old->x_name);
+	if (new->x_name == 0){
+	    icalparameter_free(new);
+	    return 0;
+	}
+    }
+
+    return new;
+}
+
+#if 1
+/* The following code is meant to replace most of the case-switch
+   statements, but it is still a work in progress */
+struct param_string_map {
+	icalparameter_kind kind;
+	int val; /* Actually, union of several types of enums */
+	const char* str;
+} param_string_map[] =
+{
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_INDIVIDUAL,"INDIVIDUAL"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_GROUP,"GROUP"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_RESOURCE,"RESOURCE"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_ROOM,"ROOM"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_UNKNOWN,"UNKNOWN"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_FREE,"FREE"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSY,"BUSY"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYUNAVAILABLE,"BUSYUNAVAILABLE"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYTENTATIVE,"BUSYTENTATIVE"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_NEEDSACTION,"NEEDSACTION"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_ACCEPTED,"ACCEPTED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DECLINED,"DECLINED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_TENTATIVE,"TENTATIVE"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DELEGATED,"DELEGATED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_COMPLETED,"COMPLETED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_INPROCESS,"INPROCESS"},
+    {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDPRIOR,"THISANDPRIOR"},
+    {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDFUTURE,"THISANDFUTURE"},
+    {ICAL_RELATED_PARAMETER,ICAL_RELATED_START,"START"},
+    {ICAL_RELATED_PARAMETER,ICAL_RELATED_END,"END"},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_PARENT,"PARENT"},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_CHILD,"CHILD"},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_SIBLING,"SIBLING"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_CHAIR,"CHAIR"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_REQPARTICIPANT,"REQ-PARTICIPANT"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_OPTPARTICIPANT,"OPT-PARTICIPANT"}, 
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_NONPARTICIPANT,"NON-PARTICIPANT"},
+    {ICAL_RSVP_PARAMETER,ICAL_RSVP_PARAMETER,"TRUE"},
+    {ICAL_RSVP_PARAMETER,ICAL_RSVP_PARAMETER,"FALSE"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_BINARY,"BINARY"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_BOOLEAN,"BOOLEAN"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATE,"DATE"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_DURATION,"DURATION"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_FLOAT,"FLOAT"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_INTEGER,"INTEGER"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_PERIOD,"PERIOD"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_RECUR,"RECUR"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_TEXT,"TEXT"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_TIME,"TIME"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_URI,"URI"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_XNAME,"ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_COMPONENTPARSEERROR,"COMPONENT_PARSE_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PROPERTYPARSEERROR,"PROPERTY_PARSE_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR,"PARAMETER_NAME_PARSE_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR,"PARAMETER_VALUE_PARSE_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_VALUEPARSEERROR,"VALUE_PARSE_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_INVALIDITIP,"INVALID_ITIP"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_UNKVCALPROP,"UNKNOWN_VCAL_PROP_ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_MIMEPARSEERROR,"MIME_PARSE_ERROR"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_EQUAL,"EQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_NOTEQUAL,"NOTEQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESS,"LESS"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATER,"GREATER"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESSEQUAL,"LESSEQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATEREQUAL,"GREATEREQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_REGEX,"REGEX"},
+    {ICAL_NO_PARAMETER,0,""},
+
+};
+
+void icalparameter_set_impl_data(icalparameter_kind kind, 
+				 union icalparameter_impl_data *data,
+				 int value)
+{
+
+    switch (kind){
+	case ICAL_CUTYPE_PARAMETER:
+	    data->v_cutype=value; break;
+	case ICAL_FBTYPE_PARAMETER:
+	    data->v_fbtype=value; break;
+	case ICAL_PARTSTAT_PARAMETER:
+	    data->v_partstat=value; break;
+	case ICAL_RANGE_PARAMETER:
+	    data->v_range=value; break;
+	case ICAL_RELATED_PARAMETER:
+	    data->v_related=value; break;
+	case ICAL_RELTYPE_PARAMETER:
+	    data->v_reltype=value; break;
+	case ICAL_ROLE_PARAMETER:
+	    data->v_role=value; break;
+	case ICAL_RSVP_PARAMETER:
+	    data->v_rsvp=value; break;
+	case ICAL_VALUE_PARAMETER:
+	    data->v_value=value; break;
+	case ICAL_XLICERRORTYPE_PARAMETER:
+	   data->v_xlicerrortype=value; break;
+	case ICAL_XLICCOMPARETYPE_PARAMETER:
+	   data->v_xliccomparetype=value; break;
+	default:
+    }
+}
+
+icalparameter* icalparameter_new_from_string_test(icalparameter_kind kind, char* val)
+{
+    int i =0;
+    icalparameter* param=0;
+
+    icalerror_check_arg_rz((val!=0),"val");
+
+    switch(kind){
+	
+	/* These are all string values parameters */
+	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:
+	{
+	    struct icalparameter_impl *impl = icalparameter_new_impl(kind);
+	    if (impl == 0) {
+		return 0;
+	    }
+	    ((struct icalparameter_impl*)param)->string = 
+		icalmemory_strdup(val);
+	    
+	    return (icalparameter*) impl;
+	    
+	}
+
+	case ICAL_NO_PARAMETER:
+	case ICAL_ANY_PARAMETER:
+	{
+	}
+
+	default: {
+	    int found = 0;
+	    /* All other types are enumerated */
+	    for(i = 0; param_string_map[i].kind != ICAL_NO_PARAMETER; i++){
+
+		if(kind ==  param_string_map[i].kind &&
+		   strcmp(val,param_string_map[i].str) == 0){		    
+
+		    struct icalparameter_impl *impl = 
+			icalparameter_new_impl(kind);
+		    found = 1;
+
+		    icalparameter_set_impl_data(kind,&impl->data,
+				param_string_map[i].val);		
+
+		    return (icalparameter*)impl;
+		} 
+	    }
+	    
+	    /* Didn't find the standard enumerated type, so it must be
+               an X parameter */
+	    if (found ==0) {
+		icalparameter *param = icalparameter_new(kind);
+		
+		icalparameter_set_xvalue(param,val);
+		
+		return param;
+
+	    }	   
+	}	    
+    }
+
+    return 0;
+}
+
+#endif 
+
+
+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);
+	    }
+	    else if(strcmp(val,"MIME_PARSE_ERROR") == 0){ 
+		param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_MIMEPARSEERROR);
+	    }
+	    else if(strcmp(val,"UNKNOWN_VCAL_PROP_ERROR") == 0){ 
+		param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_UNKVCALPROP);
+	    }
+	    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 ((void*)impl->string);
+    }
+    
+    if (impl->x_name != 0){
+	free ((void*)impl->x_name);
+    }
+    
+    memset(impl,0,sizeof(impl));
+
+    impl->parent = 0;
+    impl->id[0] = 'X';
+    free(impl);
+}
+
+
+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;
+    const 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;
+		}
+		case ICAL_XLICERRORTYPE_UNKVCALPROP:
+		{
+		    strcpy(tend,"UNKNOWN_VCAL_PROP_ERROR");break;
+		}
+		case ICAL_XLICERRORTYPE_MIMEPARSEERROR:
+		{
+		    strcpy(tend,"MIME_PARSE_ERROR");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, const char* v)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+    icalerror_check_arg_rv( (param!=0),"param");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    if (impl->x_name != 0){
+	free((void*)impl->x_name);
+    }
+
+    impl->x_name = icalmemory_strdup(v);
+
+    if (impl->x_name == 0){
+	errno = ENOMEM;
+    }
+
+}
+
+const char*
+icalparameter_get_xname (icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+    icalerror_check_arg_rz( (param!=0),"param");
+
+    return impl->x_name;
+}
+
+void
+icalparameter_set_xvalue (icalparameter* param, const char* v)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rv( (param!=0),"param");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    if (impl->string != 0){
+	free((void*)impl->string);
+    }
+
+    impl->string = icalmemory_strdup(v);
+
+    if (impl->string == 0){
+	errno = ENOMEM;
+    }
+
+}
+
+const char*
+icalparameter_get_xvalue (icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rz( (param!=0),"param");
+
+    return impl->string;
+
+}
+
+void icalparameter_set_parent(icalparameter* param,
+			     icalproperty* property)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rv( (param!=0),"param");
+
+    impl->parent = property;
+}
+
+icalproperty* icalparameter_get_parent(icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rv( (param!=0),"param");
+
+    return impl->parent;
+}
+
+
+/* Everything below this line is machine generated. Do not edit. */
diff --git a/libical/src/libical/icalparameter.h.in b/libical/src/libical/icalparameter.h.in
new file mode 100644
index 0000000000..d3bd4c963c
--- /dev/null
+++ b/libical/src/libical/icalparameter.h.in
@@ -0,0 +1,57 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparam.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id: icalparameter.h.in,v 1.1 2000/12/11 22:05:59 federico Exp $
+  $Locker:  $
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+#ifndef ICALPARAM_H
+#define ICALPARAM_H
+
+#include "icalenums.h"
+
+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, const char* v);
+const char* icalparameter_get_xname(icalparameter* param);
+void icalparameter_set_xvalue (icalparameter* param, const char* v);
+const char* icalparameter_get_xvalue(icalparameter* param);
+
+
+/* Everything below this line is machine generated. Do not edit. */
diff --git a/libical/src/libical/icalproperty.c.in b/libical/src/libical/icalproperty.c.in
new file mode 100644
index 0000000000..12a9ec4afa
--- /dev/null
+++ b/libical/src/libical/icalproperty.c.in
@@ -0,0 +1,560 @@
+/* -*- Mode: C -*- */
+
+/*======================================================================
+  FILE: icalproperty.c
+  CREATOR: eric 28 April 1999
+  
+  $Id: icalproperty.c.in,v 1.1 2000/12/11 22:05:59 federico Exp $
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalproperty.c
+
+======================================================================*/
+#line 27 "icalproperty.c.in"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalproperty.h"
+#include "icalcomponent.h"
+#include "pvl.h"
+#include "icalenums.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+
+#include <string.h> /* For icalmemory_strdup, rindex */
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h> /* for printf */
+#include <stdarg.h> /* for va_list, va_start, etc. */
+                                               
+#define TMP_BUF_SIZE 1024
+
+/* Private routines for icalproperty */
+void icalvalue_set_parent(icalvalue* value,
+			     icalproperty* property);
+icalproperty* icalvalue_get_parent(icalvalue* value);
+
+void icalparameter_set_parent(icalparameter* param,
+			     icalproperty* property);
+icalproperty* icalparameter_get_parent(icalparameter* value);
+
+
+void icalproperty_set_x_name(icalproperty* prop, char* name);
+
+struct icalproperty_impl 
+{
+	char id[5];
+	icalproperty_kind kind;
+	char* x_name;
+	pvl_list parameters;
+	pvl_elem parameter_iterator;
+	icalvalue* value;
+	icalcomponent *parent;
+};
+
+void icalproperty_add_parameters(struct icalproperty_impl *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 {
+	    assert(0);
+	}
+
+    }
+    
+    
+}
+
+
+struct icalproperty_impl*
+icalproperty_new_impl (icalproperty_kind kind)
+{
+    struct icalproperty_impl* prop;
+
+    if ( ( prop = (struct icalproperty_impl*)
+	   malloc(sizeof(struct icalproperty_impl))) == 0) {
+	icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+	return 0;
+    }
+    
+    strcpy(prop->id,"prop");
+
+    prop->kind = kind;
+    prop->parameters = pvl_newlist();
+    prop->parameter_iterator = 0;
+    prop->value = 0;
+    prop->x_name = 0;
+    prop->parent = 0;
+
+    return prop;
+}
+
+
+icalproperty*
+icalproperty_new (icalproperty_kind kind)
+{
+    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 = icalmemory_strdup(old->x_name);
+	
+	if (new->x_name == 0) {
+	    icalproperty_free(new);
+	    icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+	    return 0;
+	}
+    }
+
+    for(p=pvl_head(old->parameters);p != 0; p = pvl_next(p)){
+	icalparameter *param = icalparameter_new_clone(pvl_data(p));
+	
+	if (param == 0){
+	    icalproperty_free(new);
+	    icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+	    return 0;
+	}
+
+	pvl_push(new->parameters,param);
+    
+    } 
+
+    return new;
+
+}
+
+/* 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 */
+
+    const char* property_name = 0; 
+    size_t buf_size = 1024;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;
+    icalvalue* value;
+    char *out_buf;
+
+    char newline[] = "\n";
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+
+
+    /* Append property name */
+
+    if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
+	property_name = impl->x_name;
+    } else {
+	property_name = 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){
+	const char *str = icalvalue_as_ical_string(value);
+	icalerror_assert((str !=0),"Could not get string representation of a value");
+	icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
+    } else {
+	icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value"); 
+	
+    }
+    
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+
+    /* Now, copy the buffer to a tmp_buffer, which is safe to give to
+       the caller without worring about de-allocating it. */
+
+    
+    out_buf = icalmemory_tmp_buffer(strlen(buf)+1);
+    strcpy(out_buf, buf);
+
+    icalmemory_free_buffer(buf);
+
+    return out_buf;
+}
+
+
+
+icalproperty_kind
+icalproperty_isa (icalproperty* property)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)property;
+
+   if(property != 0){
+       return p->kind;
+   }
+
+   return ICAL_NO_PROPERTY;
+}
+
+int
+icalproperty_isa_property (void* property)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+
+    icalerror_check_arg_rz( (property!=0), "property");
+
+    if (strcmp(impl->id,"prop") == 0) {
+	return 1;
+    } else {
+	return 0;
+    }
+}
+
+
+void
+icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+   icalerror_check_arg_rv( (prop!=0),"prop");
+   icalerror_check_arg_rv( (parameter!=0),"parameter");
+    
+   pvl_push(p->parameters, parameter);
+
+}
+
+void
+icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
+{
+    icalproperty_kind kind;
+
+    kind = icalparameter_isa(parameter);
+
+    icalproperty_remove_parameter(prop,kind);
+
+    icalproperty_add_parameter(prop,parameter);
+}
+
+
+void
+icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+    pvl_elem p;     
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rv((prop!=0),"prop");
+    
+    for(p=pvl_head(impl->parameters);p != 0; p = pvl_next(p)){
+	icalparameter* param = (icalparameter *)pvl_data (p);
+        if (icalparameter_isa(param) == kind) {
+            pvl_remove (impl->parameters, p);
+            icalparameter_free (param);
+            break;
+        }
+    }                       
+}
+
+
+int
+icalproperty_count_parameters (icalproperty* prop)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+    if(prop != 0){
+	return pvl_count(p->parameters);
+    }
+
+    icalerror_set_errno(ICAL_USAGE_ERROR);
+    return -1;
+}
+
+
+icalparameter*
+icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+   struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+   icalerror_check_arg_rz( (prop!=0),"prop");
+   
+   p->parameter_iterator = pvl_head(p->parameters);
+
+   if (p->parameter_iterator == 0) {
+       return 0;
+   }
+
+   for( p->parameter_iterator = pvl_head(p->parameters);
+	p->parameter_iterator !=0;
+	p->parameter_iterator = pvl_next(p->parameter_iterator)){
+
+       icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
+
+       if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
+	   return param;
+       }
+   }
+
+   return 0;
+}
+
+
+icalparameter*
+icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+    
+    if (p->parameter_iterator == 0) {
+	return 0;
+    }
+    
+    for( p->parameter_iterator = pvl_next(p->parameter_iterator);
+	 p->parameter_iterator !=0;
+	 p->parameter_iterator = pvl_next(p->parameter_iterator)){
+	
+	icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
+	
+	if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
+	    return param;
+	}
+    }
+    
+    return 0;
+
+}
+
+void
+icalproperty_set_value (icalproperty* prop, icalvalue* value)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rv((prop !=0),"prop");
+    icalerror_check_arg_rv((value !=0),"value");
+    
+    if (p->value != 0){
+	icalvalue_set_parent(p->value,0);
+	icalvalue_free(p->value);
+	p->value = 0;
+    }
+
+    p->value = value;
+    
+    icalvalue_set_parent(value,prop);
+}
+
+
+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 = icalmemory_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. */
diff --git a/libical/src/libical/icalproperty.h.in b/libical/src/libical/icalproperty.h.in
new file mode 100644
index 0000000000..cfc7704970
--- /dev/null
+++ b/libical/src/libical/icalproperty.h.in
@@ -0,0 +1,57 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedproperties.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id: icalproperty.h.in,v 1.1 2000/12/11 22:05:59 federico Exp $
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+
+#ifndef ICALPROPERTY_H
+#define ICALPROPERTY_H
+
+#include <time.h>
+#include "icalparameter.h"
+#include "icalvalue.h"  
+#include "icalrecur.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_set_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. */
diff --git a/libical/src/libical/icalrestriction.c.in b/libical/src/libical/icalrestriction.c.in
new file mode 100644
index 0000000000..454442531f
--- /dev/null
+++ b/libical/src/libical/icalrestriction.c.in
@@ -0,0 +1,447 @@
+/*  -*- Mode: C -*- */
+/*  ======================================================================
+  File: icalrestriction.c
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+/*#line 7 "icalrestriction.c.in"*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalrestriction.h"
+#include "icalenums.h"
+#include "icalerror.h"
+
+#include <assert.h>
+#include <stdio.h> /* For snprintf */   
+
+#define TMP_BUF_SIZE 1024
+
+
+/* Define the structs for the restrictions. these data are filled out
+in machine generated code below */
+
+struct icalrestriction_property_record;
+
+typedef char* (*restriction_func)(struct icalrestriction_property_record* rec,icalcomponent* comp,icalproperty* prop);
+
+
+typedef struct icalrestriction_property_record {
+	icalproperty_method method;
+	icalcomponent_kind component;
+	icalproperty_kind property;
+	icalrestriction_kind restriction;
+	restriction_func function;
+} icalrestriction_property_record;
+
+
+typedef struct icalrestriction_component_record {
+	icalproperty_method method;
+	icalcomponent_kind component;
+	icalcomponent_kind subcomponent;
+	icalrestriction_kind restriction;
+	restriction_func function;
+} icalrestriction_component_record;
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+					 icalcomponent_kind component,
+					 icalproperty_kind property);
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+					  icalcomponent_kind component,
+					  icalcomponent_kind subcomponent);
+
+icalrestriction_component_record icalrestriction_component_records[];
+icalrestriction_property_record icalrestriction_property_records[]; 
+
+icalrestriction_property_record null_prop_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_UNKNOWN,0};
+icalrestriction_component_record null_comp_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_UNKNOWN,0};
+
+
+/* The each row gives the result of comparing a restriction against a
+   count. The columns in each row represent 0,1,2+. '-1' indicates
+   'invalid, 'don't care' or 'needs more analysis' So, for
+   ICAL_RESTRICTION_ONE, if there is 1 of a property with that
+   restriction, it passes, but if there are 0 or 2+, it fails. */
+
+char compare_map[ICAL_RESTRICTION_UNKNOWN+1][3] = {
+    { 1, 1, 1},/*ICAL_RESTRICTION_NONE*/
+    { 1, 0, 0},/*ICAL_RESTRICTION_ZERO*/
+    { 0, 1, 0},/*ICAL_RESTRICTION_ONE*/
+    { 1, 1, 1},/*ICAL_RESTRICTION_ZEROPLUS*/
+    { 0, 1, 1},/*ICAL_RESTRICTION_ONEPLUS*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ZEROORONE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEMUTUAL*/
+    { 1, 1, 1} /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+char restr_string_map[ICAL_RESTRICTION_UNKNOWN+1][60] = {
+    "unknown number",/*ICAL_RESTRICTION_NONE*/
+    "0",/*ICAL_RESTRICTION_ZERO*/
+    "1",/*ICAL_RESTRICTION_ONE*/
+    "zero or more",/*ICAL_RESTRICTION_ZEROPLUS*/
+    "one or more" ,/*ICAL_RESTRICTION_ONEPLUS*/
+    "zero or one",/*ICAL_RESTRICTION_ZEROORONE*/
+    "zero or one, exclusive with another property",/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    "zero or one, mutual with another property",/*ICAL_RESTRICTION_ONEMUTUAL*/
+    "unknown number" /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+
+int
+icalrestriction_compare(icalrestriction_kind restr, int count){
+
+    if ( restr < ICAL_RESTRICTION_NONE || restr > ICAL_RESTRICTION_UNKNOWN
+	 || count < 0){
+	return -1;
+    }
+
+    if (count > 2) {
+	count = 2;
+    }
+
+    return compare_map[restr][count];
+
+}
+
+/* Special case routines */
+
+char* icalrestriction_may_be_draft_final_canceled(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_DRAFT ||
+	   stat == ICAL_STATUS_FINAL ||
+	   stat == ICAL_STATUS_CANCELLED )){
+
+	return "Failed iTIP restrictions for STATUS property. Value must be one of DRAFT, FINAL, or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_may_be_comp_need_process(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_COMPLETED ||
+	   stat == ICAL_STATUS_NEEDSACTION ||
+	   stat == ICAL_STATUS_INPROCESS )){
+
+	return "Failed iTIP restrictions for STATUS property. Value must be one of COMPLETED, NEEDS-ACTION or IN-PROCESS";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf(icalrestriction_property_record *rec,
+				       icalcomponent* comp, 
+				       icalproperty* prop){
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+	   stat == ICAL_STATUS_CONFIRMED )){
+
+	return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE or CONFIRMED";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf_cancel(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+	   stat == ICAL_STATUS_CONFIRMED ||
+	   stat == ICAL_STATUS_CANCELLED )){
+
+	return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE, CONFIRMED or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_cancel_if_present(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    /* This routine will not be called if prop == 0 */
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( stat != ICAL_STATUS_CANCELLED)
+    {
+	return "Failed iTIP restrictions for STATUS property. Value must be CANCELLED";
+
+    }
+ 
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_canceled_no_attendee(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    /* Hack. see rfc2446, 3.2.5 CANCEL for porperty STATUS. I don't
+       understand the note */
+
+    return 0;    
+}
+char* icalrestriction_must_be_recurring(icalrestriction_property_record *rec,
+					icalcomponent* comp, 
+					icalproperty* prop){
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_must_have_duration(icalrestriction_property_record *rec,
+					 icalcomponent* comp, 
+					 icalproperty* prop){
+    
+    if( !icalcomponent_get_first_property(comp,ICAL_DURATION_PROPERTY)){
+
+	return "Failed iTIP restrictions for STATUS property. This component must have a DURATION property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_have_repeat(icalrestriction_property_record *rec,
+				       icalcomponent* comp, 
+				       icalproperty* prop){
+    if( !icalcomponent_get_first_property(comp,ICAL_REPEAT_PROPERTY)){
+
+	return "Failed iTIP restrictions for STATUS property. This component must have a REPEAT property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_if_tz_ref(icalrestriction_property_record *rec,
+				     icalcomponent* comp, 
+				     icalproperty* prop){
+
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_no_dtend(icalrestriction_property_record *rec,
+			       icalcomponent* comp, 
+			       icalproperty* prop){
+
+    if( !icalcomponent_get_first_property(comp,ICAL_DTEND_PROPERTY)){
+
+	return "Failed iTIP restrictions for STATUS property. The component must not have both DURATION and DTEND";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_no_duration(icalrestriction_property_record *rec,
+				icalcomponent* comp, 
+				  icalproperty* prop){
+
+    /* _no_dtend takes care of this one */
+    return 0;    
+}                                     
+
+
+int icalrestriction_check_component(icalproperty_method method,
+				    icalcomponent* comp)
+{
+    icalproperty_kind kind;
+    icalcomponent_kind comp_kind;
+    icalrestriction_kind restr;
+    icalrestriction_property_record *prop_record;
+    icalrestriction_component_record *comp_record;
+    char* funcr = 0;
+    icalproperty *prop;
+
+    int count;
+    int compare;
+    int valid = 1;
+
+    comp_kind = icalcomponent_isa(comp);
+
+    /* Check all of the properties in this component */
+
+    for(kind = ICAL_ANY_PROPERTY+1; kind != ICAL_NO_PROPERTY; kind++){
+	count = icalcomponent_count_properties(comp, kind);
+	
+	prop_record = icalrestriction_get_property_restriction(method, 
+							 comp_kind,
+							 kind);
+
+	restr = prop_record->restriction;
+
+	if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ||
+	    restr == ICAL_RESTRICTION_ONEMUTUAL) {
+
+	    /* First treat is as a 0/1 restriction */
+	    restr = ICAL_RESTRICTION_ZEROORONE;
+	    compare = icalrestriction_compare(restr,count);
+
+	} else {
+
+	    compare = icalrestriction_compare(restr,count);
+	}
+
+	assert(compare != -1);
+
+	if (compare == 0){
+	    char temp[TMP_BUF_SIZE];
+	    
+	    snprintf(temp, TMP_BUF_SIZE,"Failed iTIP restrictions for %s property. Expected %s instances of the property and got %d",
+		    icalenum_property_kind_to_string(kind),
+		    restr_string_map[restr], count);
+	    
+	    icalcomponent_add_property
+		(comp,
+		 icalproperty_vanew_xlicerror(
+		     temp,
+		     icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP),
+		     0));   
+	} 
+
+
+	prop = icalcomponent_get_first_property(comp, kind);
+
+	if (prop != 0 && prop_record->function !=0  ){
+	    funcr =  prop_record->function(prop_record,comp,prop);
+	}
+
+	if(funcr !=0){
+	    icalcomponent_add_property
+		(comp,
+		 icalproperty_vanew_xlicerror(
+		     funcr,
+		     icalparameter_new_xlicerrortype(
+			 ICAL_XLICERRORTYPE_INVALIDITIP),
+		     0));   
+
+	    compare = 0;
+	}
+
+	valid = valid && compare;
+    }
+
+
+
+    return valid;
+
+
+}
+
+int icalrestriction_check(icalcomponent* outer_comp)
+{
+    icalcomponent_kind comp_kind;
+    icalproperty_method method;
+    icalcomponent* inner_comp;
+    icalproperty *method_prop;
+    int valid;
+    
+    icalerror_check_arg_rz( (outer_comp!=0), "outer comp");
+
+
+    /* Get the Method value from the outer component */
+
+    comp_kind = icalcomponent_isa(outer_comp);
+
+    if (comp_kind != ICAL_VCALENDAR_COMPONENT){
+	icalerror_set_errno(ICAL_BADARG_ERROR);
+	return 0;
+    }
+
+    method_prop = icalcomponent_get_first_property(outer_comp,
+						   ICAL_METHOD_PROPERTY);
+
+    if (method_prop == 0){
+	method = ICAL_METHOD_NONE;
+    } else {
+	method = icalproperty_get_method(method_prop);
+    }
+   
+
+    /* Check the VCALENDAR wrapper */
+    valid = icalrestriction_check_component(ICAL_METHOD_NONE,outer_comp);
+
+
+    /* Now check the inner components */
+
+    for(inner_comp= icalcomponent_get_first_component(outer_comp,
+						      ICAL_ANY_COMPONENT);
+	inner_comp != 0;
+	inner_comp= icalcomponent_get_next_component(outer_comp,
+						     ICAL_ANY_COMPONENT)){
+
+	valid = valid && icalrestriction_check_component(method,inner_comp);
+
+    }
+
+
+    return valid;
+
+}
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+					 icalcomponent_kind component,
+					 icalproperty_kind property)
+{
+    int i;
+
+    for(i = 0;
+	icalrestriction_property_records[i].restriction != ICAL_RESTRICTION_NONE;
+	i++){
+
+	if (method == icalrestriction_property_records[i].method &&
+	    component == icalrestriction_property_records[i].component &&
+	    property ==  icalrestriction_property_records[i].property ){
+	    return  &icalrestriction_property_records[i];
+	}
+    }
+	
+    return &null_prop_record;
+}
+
+
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+					  icalcomponent_kind component,
+					  icalcomponent_kind subcomponent)
+{
+
+    int i;
+
+    for(i = 0;
+	icalrestriction_component_records[i].restriction != ICAL_RESTRICTION_NONE;
+	i++){
+
+	if (method == icalrestriction_component_records[i].method &&
+	    component == icalrestriction_component_records[i].component &&
+	    subcomponent ==  icalrestriction_component_records[i].subcomponent ){
+	    return  &icalrestriction_component_records[i];
+	}
+    }
+	
+    return &null_comp_record;
+}
+
diff --git a/libical/src/libical/icalvalue.c.in b/libical/src/libical/icalvalue.c.in
new file mode 100644
index 0000000000..7adcecb990
--- /dev/null
+++ b/libical/src/libical/icalvalue.c.in
@@ -0,0 +1,1388 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.c
+  CREATOR: eric 02 May 1999
+  
+  $Id: icalvalue.c.in,v 1.1 2000/12/11 22:06:02 federico Exp $
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.c
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#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 "icalmemory_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 */
+		const char *v_string;
+		/*char *v_text;*/
+		/*char *v_caladdress;*/
+		/*char *v_uri;*/
+		float v_float;
+		int v_int;
+		/*int v_boolean;*/
+		/*int v_integer;*/
+		struct icaldurationtype v_duration;
+		/*int v_utcoffset;*/
+
+		struct icalperiodtype v_period;
+		/*struct icalperiodtype v_datetimeperiod;*/
+		struct icalgeotype v_geo;
+		/*time_t v_time;*/
+		struct icaltimetype v_time;
+		/*struct icaltimetype v_date;*/
+		/*struct icaltimetype v_datetime;*/
+		/*struct icaltimetype v_datetimedate;*/
+
+		/* struct icalrecurrencetype was once included
+                   directly ( not referenced ) in this union, but it
+                   contributes 2000 bytes to every value, so now it is
+                   a reference*/
+
+		struct icalrecurrencetype *v_recur;
+		union icaltriggertype v_trigger;
+		icalproperty_method v_method;
+		icalproperty_status v_status;
+
+	} 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=icalmemory_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;
+}
+
+char* icalmemory_strdup_and_dequote(const char* str)
+{
+    char* p;
+    char* out = (char*)malloc(sizeof(char) * strlen(str) +1);
+    char* pout;
+
+    if (out == 0){
+	return 0;
+    }
+
+    pout = out;
+
+    for (p = str; *p!=0; p++){
+	
+	if( *p == '\\')
+	{
+	    p++;
+	    switch(*p){
+		case 0:
+		{
+		    break;
+		    *pout = '\0';
+		}
+		case 'n':
+		{
+		    *pout = '\n';
+		    break;
+		}
+		case 'N':
+		{
+		    *pout = '\n';
+		    break;
+		}
+		case '\\':
+		case ',':
+		case ';':
+		{
+		    *pout = *p;
+		    break;
+		}
+		default:
+		{
+		    *pout = ' ';
+		}		
+	    }
+	} else {
+	    *pout = *p;
+	}
+
+	pout++;
+	
+    }
+
+    *pout = '\0';
+
+    return out;
+}
+
+icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const 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:
+	{
+	    char* dequoted_str = icalmemory_strdup_and_dequote(str);
+	    value = icalvalue_new_text(dequoted_str);
+	    free(dequoted_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);
+
+	    if(method == ICAL_METHOD_NONE){
+		value = 0;
+	    } else {
+		value = icalvalue_new_method(method);
+	    }
+
+	    break; 
+
+	}
+
+
+	case ICAL_STATUS_VALUE:
+	{
+	    icalproperty_status status = icalenum_string_to_status(str);
+
+	    if(status == ICAL_STATUS_NONE){
+		value = 0;
+	    } else {
+		value = icalvalue_new_status(status);
+	    }
+
+	    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,const 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((void*)v->data.v_string);
+		v->data.v_string = 0;
+	    }
+	    break;
+	}
+	case ICAL_RECUR_VALUE:
+	{
+	    if(v->data.v_recur != 0){
+		free((void*)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) {
+
+    const 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) {
+
+    const 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,
+			     icalrecur_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 */
+		    short dow = icalrecurrencetype_day_day_of_week(array[i]);
+		    const char *daystr = icalrecur_weekday_to_string(dow);
+		    short pos = icalrecurrencetype_day_position(array[i]);  
+		    
+		    if (pos == 0)
+			icalmemory_append_string(&str,&str_p,&buf_sz,daystr);
+		    else {
+			sprintf(temp,"%d%s",pos,daystr);
+			icalmemory_append_string(&str,&str_p,&buf_sz,temp);
+		    }                  
+		    
+		} 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;
+    const 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;
+}
+
+const 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_STATUS_VALUE:
+	    return icalenum_status_to_string(v->data.v_status);
+
+
+	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_STATUS_VALUE:
+	{
+	    if (icalvalue_get_status(a) == icalvalue_get_status(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. */
diff --git a/libical/src/libical/icalvalue.h.in b/libical/src/libical/icalvalue.h.in
new file mode 100644
index 0000000000..7ad2c3e0f3
--- /dev/null
+++ b/libical/src/libical/icalvalue.h.in
@@ -0,0 +1,58 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id: icalvalue.h.in,v 1.1 2000/12/11 22:06:03 federico Exp $
+  $Locker:  $
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.h
+
+  ======================================================================*/
+
+#ifndef ICALVALUE_H
+#define ICALVALUE_H
+
+#include <time.h>
+#include "icalenums.h"
+#include "icaltypes.h"
+#include "icalrecur.h"
+                          
+typedef void icalvalue;
+
+icalvalue* icalvalue_new(icalvalue_kind kind);
+
+icalvalue* icalvalue_new_clone(icalvalue* value);
+
+icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str);
+
+void icalvalue_free(icalvalue* value);
+
+int icalvalue_is_valid(icalvalue* value);
+
+const char* icalvalue_as_ical_string(icalvalue* value);
+
+icalvalue_kind icalvalue_isa(icalvalue* value);
+
+int icalvalue_isa_value(void*);
+
+icalparameter_xliccomparetype
+icalvalue_compare(icalvalue* a, icalvalue *b);
+
+/* Everything below this line is machine generated. Do not edit. */