1 files changed, 306 insertions, 212 deletions

diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c
index eb5476e..4c67136 100644
--- a/libical/src/libical/icalvalue.c
+++ b/libical/src/libical/icalvalue.c
@@ -1,4 +1,5 @@
-/* -*- Mode: C -*- */
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vi:set ts=4 sts=4 sw=4 expandtab : */
 /*======================================================================
   FILE: icalvalue.c
   CREATOR: eric 02 May 1999
@@ -46,7 +47,10 @@
 #include <stdlib.h> /* for atoi and atof */
 #include <limits.h> /* for SHRT_MAX */         
 
-int snprintf(char *str, size_t n, char const *fmt, ...);
+#ifdef WIN32
+#define snprintf      _snprintf
+#define strcasecmp    stricmp
+#endif
 
 #if _MAC_OS_
 #include "icalmemory_strdup.h"
@@ -54,16 +58,18 @@ int snprintf(char *str, size_t n, char const *fmt, ...);
 
 #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);
+void print_datetime_to_string(char* str,  const struct icaltimetype *data);
+void print_date_to_string(char* str,  const struct icaltimetype *data);
+void print_time_to_string(char* str,  const struct icaltimetype *data);
 
 
 struct icalvalue_impl*  icalvalue_new_impl(icalvalue_kind kind){
 
     struct icalvalue_impl* v;
 
+    if (!icalvalue_kind_is_valid(kind))
+      return NULL;
+
     if ( ( v = (struct icalvalue_impl*)
            malloc(sizeof(struct icalvalue_impl))) == 0) {
         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
@@ -90,10 +96,8 @@ icalvalue_new (icalvalue_kind kind)
     return (icalvalue*)icalvalue_new_impl(kind);
 }
 
-icalvalue* icalvalue_new_clone(icalvalue* value){
-
+icalvalue* icalvalue_new_clone(const icalvalue* old) {
     struct icalvalue_impl* new;
-    struct icalvalue_impl* old = (struct icalvalue_impl*)value;
 
     new = icalvalue_new_impl(old->kind);
 
@@ -101,21 +105,25 @@ icalvalue* icalvalue_new_clone(icalvalue* value){
         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 */
-        }
+            /* Hmm.  We just ref the attach value, which may not be the right
+             * thing to do.  We cannot quite copy the data, anyways, since we
+             * don't know how long it is.
+             */
+            new->data.v_attach = old->data.v_attach;
+            if (new->data.v_attach)
+                icalattach_ref (new->data.v_attach);
 
+            break;
+        }
+        case ICAL_QUERY_VALUE:
         case ICAL_STRING_VALUE:
         case ICAL_TEXT_VALUE:
         case ICAL_CALADDRESS_VALUE:
@@ -146,6 +154,19 @@ icalvalue* icalvalue_new_clone(icalvalue* value){
             break;
         }
 
+        case ICAL_X_VALUE: 
+        {
+            if (old->x_value != 0) {
+                new->x_value=icalmemory_strdup(old->x_value);
+
+                if (new->x_value == 0) {
+                    return 0;
+                }
+            }
+
+            break;
+        }
+
         default:
         {
             /* all of the other types are stored as values, not
@@ -158,7 +179,7 @@ icalvalue* icalvalue_new_clone(icalvalue* value){
     return new;
 }
 
-char* icalmemory_strdup_and_dequote(const char* str)
+static char* icalmemory_strdup_and_dequote(const char* str)
 {
     const char* p;
     char* out = (char*)malloc(sizeof(char) * strlen(str) +1);
@@ -183,18 +204,39 @@ char* icalmemory_strdup_and_dequote(const char* str)
 
                 }
                 case 'n':
+                case 'N':
                 {
                     *pout = '\n';
                     break;
                 }
-                case 'N':
+                case 't':
+                case 'T':
                 {
-                    *pout = '\n';
+                    *pout = '\t';
+                    break;
+                }
+                case 'r':
+                case 'R':
+                {
+                    *pout = '\r';
+                    break;
+                }
+                case 'b':
+                case 'B':
+                {
+                    *pout = '\b';
+                    break;
+                }
+                case 'f':
+                case 'F':
+                {
+                    *pout = '\f';
                     break;
                 }
-                case '\\':
-                case ',':
                 case ';':
+                case ',':
+                case '"':
+                case '\\':
                 {
                     *pout = *p;
                     break;
@@ -217,9 +259,16 @@ char* icalmemory_strdup_and_dequote(const char* str)
     return out;
 }
 
+/*
+ * FIXME
+ *
+ * This is a bad API, as it forces callers to specify their own X type.
+ * This function should take care of this by itself.
+ */
+static
 icalvalue* icalvalue_new_enum(icalvalue_kind kind, int x_type, const char* str)
 {
-    int e = icalproperty_string_to_enum(str);
+    int e = icalproperty_kind_and_string_to_enum(kind, str);
     struct icalvalue_impl *value; 
 
     if(e != 0 && icalproperty_enum_belongs_to_property(
@@ -242,7 +291,6 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
 {
 
     struct icalvalue_impl *value = 0;
-    struct icalattachtype *attach = 0;
     
     icalerror_check_arg_rz(str!=0,"str");
 
@@ -253,12 +301,19 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
     switch (kind){
         
     case ICAL_ATTACH_VALUE:
-        attach = icalattachtype_new();
-              value = icalvalue_new_attach( attach );
-        icalattachtype_free( attach );
-        icalattachtype_set_url( value->data.v_attach, str );
-        break;
-            case ICAL_BINARY_VALUE:
+        {
+            icalattach *attach;
+
+            attach = icalattach_new_from_url (str);
+            if (!attach)
+                break;
+
+            value = icalvalue_new_attach (attach);
+            icalattach_unref (attach);
+            break;
+        }
+
+    case ICAL_BINARY_VALUE:
     case ICAL_BOOLEAN_VALUE:
         {
             /* HACK */
@@ -267,7 +322,7 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
             if (error != 0){
                 char temp[TMP_BUF_SIZE];
                 sprintf(temp,"%s Values are not implemented",
-                        icalparameter_kind_to_string(kind)); 
+                        icalvalue_kind_to_string(kind)); 
                 *error = icalproperty_vanew_xlicerror( 
                                    temp, 
                                    icalparameter_new_xlicerrortype( 
@@ -279,37 +334,50 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
         
 
     case ICAL_TRANSP_VALUE:
-        value = icalvalue_new_enum(kind, ICAL_TRANSP_X,str);
+        value = icalvalue_new_enum(kind, (int)ICAL_TRANSP_X,str);
         break;
     case ICAL_METHOD_VALUE:
-        value = icalvalue_new_enum(kind, ICAL_METHOD_X,str);
+        value = icalvalue_new_enum(kind, (int)ICAL_METHOD_X,str);
         break;
     case ICAL_STATUS_VALUE:
-        value = icalvalue_new_enum(kind, ICAL_STATUS_X,str);
+        value = icalvalue_new_enum(kind, (int)ICAL_STATUS_X,str);
         break;
     case ICAL_ACTION_VALUE:
-        value = icalvalue_new_enum(kind, ICAL_ACTION_X,str);
+        value = icalvalue_new_enum(kind, (int)ICAL_ACTION_X,str);
         break;
+
+    case ICAL_QUERY_VALUE:
+            value = icalvalue_new_query(str);
+            break;
+
     case ICAL_CLASS_VALUE:
-        value = icalvalue_new_enum(kind, ICAL_CLASS_X,str);
+        value = icalvalue_new_enum(kind, (int)ICAL_CLASS_X,str);
         break;
 
 
     case ICAL_INTEGER_VALUE:
-        {
             value = icalvalue_new_integer(atoi(str));
             break;
-        }
 
     case ICAL_FLOAT_VALUE:
-        {
-            value = icalvalue_new_float((float )atof(str));
+            value = icalvalue_new_float((float)atof(str));
             break;
-        }
-        
+
     case ICAL_UTCOFFSET_VALUE:
         {
-            value = icalparser_parse_value(kind,str,(icalcomponent*)0);
+            int t,utcoffset, hours, minutes, seconds;
+            /* treat the UTCOFSET string a a decimal number, disassemble its digits
+               and reconstruct it as sections */
+            t = strtol(str,0,10);
+            /* add phantom seconds field */
+            if(abs(t)<9999){t *= 100; }
+            hours = (t/10000);
+            minutes = (t-hours*10000)/100;
+            seconds = (t-hours*10000-minutes*100);
+            utcoffset = hours*3600+minutes*60+seconds;
+
+            value = icalvalue_new_utcoffset(utcoffset);
+
             break;
         }
         
@@ -321,28 +389,19 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
             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_GEO_VALUE:
-        {
             value = 0;
             /* HACK */
             
@@ -350,16 +409,15 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
                 char temp[TMP_BUF_SIZE];
                 sprintf(temp,"GEO Values are not implemented"); 
                 *error = icalproperty_vanew_xlicerror( 
-                                                      temp, 
-                                                      icalparameter_new_xlicerrortype( 
-                                                                                      ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
-                                                      0); 
+                    temp, 
+                    icalparameter_new_xlicerrortype( 
+                        ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
+                    0); 
             }
-            
+
             /*icalerror_warn("Parsing GEO properties is unimplmeneted");*/
-            
+
             break;
-        }
         
     case ICAL_RECUR_VALUE:
         {
@@ -391,14 +449,17 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
             struct icaltimetype tt;
             struct icalperiodtype p;
             tt = icaltime_from_string(str);
-            p = icalperiodtype_from_string(str);
-            
+
             if(!icaltime_is_null_time(tt)){
-                value = icalvalue_new_datetime(tt);
-            } else if (!icalperiodtype_is_null_period(p)){
+                        value = icalvalue_new_datetime(tt);     
+                break;
+            }  
+            
+                    p = icalperiodtype_from_string(str);    
+            if (!icalperiodtype_is_null_period(p)){
                 value = icalvalue_new_period(p);
             }            
-            
+
             break;
         }
         
@@ -406,9 +467,7 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
         {
             struct icaldurationtype dur = icaldurationtype_from_string(str);
             
-            if(icaldurationtype_is_null_duration(dur)){
-                value = 0;
-            } else {
+            if (!icaldurationtype_is_bad_duration(dur)) {    /* failed to parse */
                 value = icalvalue_new_duration(dur);
             }
             
@@ -429,7 +488,7 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
     case ICAL_TRIGGER_VALUE:
         {
             struct icaltriggertype tr = icaltriggertype_from_string(str);
-            if (!icaltriggertype_is_null_trigger(tr)){
+            if (!icaltriggertype_is_bad_trigger(tr)) {
                 value = icalvalue_new_trigger(tr);
             }
             break;
@@ -444,9 +503,17 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
             break;
 
         }
+
+    case ICAL_X_VALUE:
+        {
+            char* dequoted_str = icalmemory_strdup_and_dequote(str);
+            value = icalvalue_new_x(dequoted_str);
+            free(dequoted_str);
+        }
+        break;
+
     default:
         {
-            
             if (error != 0 ){
                 char temp[TMP_BUF_SIZE];
                 
@@ -484,17 +551,15 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
 
 icalvalue* icalvalue_new_from_string(icalvalue_kind kind,const char* str)
 {
-    return icalvalue_new_from_string_with_error(kind,str,(icalproperty*)0);
+    return icalvalue_new_from_string_with_error(kind,str,(icalproperty**)0);
 }
 
 
 
 void
-icalvalue_free (icalvalue* value)
+icalvalue_free (icalvalue* v)
 {
-    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
-
-    icalerror_check_arg_rv((value != 0),"value");
+    icalerror_check_arg_rv((v != 0),"value");
 
 #ifdef ICAL_FREE_ON_LIST_IS_ERROR
     icalerror_assert( (v->parent ==0),"This value is still attached to a property");
@@ -510,15 +575,19 @@ icalvalue_free (icalvalue* value)
     }
 
     switch (v->kind){
-        case ICAL_ATTACH_VALUE:
-            icalattachtype_free( v->data.v_attach );
+        case ICAL_BINARY_VALUE: 
+        case ICAL_ATTACH_VALUE: {
+            if (v->data.v_attach) {
+                icalattach_unref (v->data.v_attach);
+                v->data.v_attach = NULL;
+            }
+
             break;
-        case ICAL_BINARY_VALUE: {
-            /* HACK ugh. This will be tough to implement */
         }
         case ICAL_TEXT_VALUE:
         case ICAL_CALADDRESS_VALUE:
         case ICAL_URI_VALUE:
+        case ICAL_QUERY_VALUE:
         {
             if (v->data.v_string != 0) { 
                 free((void*)v->data.v_string);
@@ -550,10 +619,8 @@ icalvalue_free (icalvalue* value)
 }
 
 int
-icalvalue_is_valid (icalvalue* value)
+icalvalue_is_valid (const icalvalue* value)
 {
-    /*struct icalvalue_impl* v = (struct icalvalue_impl*)value;*/
-    
     if(value == 0){
         return 0;
     }
@@ -561,7 +628,7 @@ icalvalue_is_valid (icalvalue* value)
     return 1;
 }
 
-char* icalvalue_binary_as_ical_string(icalvalue* value) {
+static char* icalvalue_binary_as_ical_string(const icalvalue* value) {
 
     const char* data;
     char* str;
@@ -575,10 +642,10 @@ char* icalvalue_binary_as_ical_string(icalvalue* value) {
     return str;
 }
 
-#ifndef _WIN32
+
 #define MAX_INT_DIGITS 12 /* Enough for 2^32 + sign*/ 
-char* icalvalue_int_as_ical_string(icalvalue* value) {
     
+static char* icalvalue_int_as_ical_string(const icalvalue* value) {
     int data;
     char* str = (char*)icalmemory_tmp_buffer(MAX_INT_DIGITS); 
 
@@ -590,26 +657,8 @@ char* icalvalue_int_as_ical_string(icalvalue* value) {
 
     return str;
 }
-#else
-// snprintf not working on wintendo
 
-#define MAX_INT_DIGITS 32 /* Enough for 2^32 + sign*/ 
-char* icalvalue_int_as_ical_string(icalvalue* value) {
-    
-    int data;
-    char* str = (char*)icalmemory_tmp_buffer(MAX_INT_DIGITS); 
-
-    icalerror_check_arg_rz( (value!=0),"value");
-
-    data = icalvalue_get_integer(value);
-        
-    sprintf(str,"%d",data);
-
-    return str;
-}
-
-#endif
-char* icalvalue_utcoffset_as_ical_string(icalvalue* value)
+static char* icalvalue_utcoffset_as_ical_string(const icalvalue* value)
 {    
     int data,h,m,s;
     char sign;
@@ -629,18 +678,20 @@ char* icalvalue_utcoffset_as_ical_string(icalvalue* value)
     m = (data - (h*3600))/ 60;
     s = (data - (h*3600) - (m*60));
 
-    sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s));
+    if (s > 0)
+        sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s));
+    else
+        sprintf(str,"%c%02d%02d",sign,abs(h),abs(m));
 
     return str;
 }
 
-char* icalvalue_string_as_ical_string(icalvalue* value) {
+static char* icalvalue_string_as_ical_string(const icalvalue* value) {
 
     const char* data;
     char* str = 0;
     icalerror_check_arg_rz( (value!=0),"value");
-
-    data = ((struct icalvalue_impl*)value)->data.v_string;
+    data = value->data.v_string;
 
     str = (char*)icalmemory_tmp_buffer(strlen(data)+1);   
 
@@ -650,26 +701,27 @@ char* icalvalue_string_as_ical_string(icalvalue* value) {
 }
 
 
-char* icalvalue_recur_as_ical_string(icalvalue* value) 
+static char* icalvalue_recur_as_ical_string(const icalvalue* value) 
 {
-    struct icalvalue_impl *impl = (struct icalvalue_impl*)value;
-    struct icalrecurrencetype *recur = impl->data.v_recur;
+    struct icalrecurrencetype *recur = value->data.v_recur;
 
     return icalrecurrencetype_as_string(recur);
 }
 
-char* icalvalue_text_as_ical_string(icalvalue* value) {
+ /* @todo This is not RFC2445 compliant.
+ * The RFC only allows:
+ * TSAFE-CHAR = %x20-21 / %x23-2B / %x2D-39 / %x3C-5B / %x5D-7E / NON-US-ASCII
+ * As such, \t\r\b\f are not allowed, not even escaped
+ */
 
+static char* icalvalue_text_as_ical_string(const 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;
+    buf_sz = strlen(value->data.v_string)+1;
 
     str_p = str = (char*)icalmemory_new_buffer(buf_sz);
 
@@ -677,61 +729,44 @@ char* icalvalue_text_as_ical_string(icalvalue* value) {
       return 0;
     }
 
-    for(p=((struct icalvalue_impl*)value)->data.v_string; *p!=0; p++){
+    for(p=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 ',':{
+            case ',':
+            case '"':
+            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
@@ -749,34 +784,29 @@ char* icalvalue_text_as_ical_string(icalvalue* value) {
 }
 
 
-char* icalvalue_attach_as_ical_string(icalvalue* value) {
-
-    struct icalattachtype *a;
+static char* 
+icalvalue_attach_as_ical_string(const icalvalue* value) 
+{
+    icalattach *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);
+    if (icalattach_get_is_url (a)) {
+        const char *url;
+
+        url = icalattach_get_url (a);
+        str = icalmemory_tmp_buffer (strlen (url) + 1);
+        strcpy (str, url);
         return str;
-    } else if (a->url != 0){
-        icalvalue *v = icalvalue_new_text( a->url );
-              char *icalstring = icalvalue_string_as_ical_string(v);
-        icalvalue_free( v );
-        return icalstring;
-    } else {
-        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
-        return 0;
-    }
+    } else
+        return icalvalue_binary_as_ical_string (value);
 }
 
 
-char* icalvalue_duration_as_ical_string(icalvalue* value) {
+static char* icalvalue_duration_as_ical_string(const icalvalue* value) {
 
     struct icaldurationtype data;
 
@@ -786,11 +816,11 @@ char* icalvalue_duration_as_ical_string(icalvalue* value) {
     return icaldurationtype_as_ical_string(data);
 }
 
-void print_time_to_string(char* str,  struct icaltimetype *data)
+void print_time_to_string(char* str, const struct icaltimetype *data)
 {
     char temp[20];
 
-    if (data->is_utc == 1){
+    if (icaltime_is_utc(*data)){
         sprintf(temp,"%02d%02d%02dZ",data->hour,data->minute,data->second);
     } else {
         sprintf(temp,"%02d%02d%02d",data->hour,data->minute,data->second);
@@ -800,7 +830,7 @@ void print_time_to_string(char* str,  struct icaltimetype *data)
 }
 
  
-void print_date_to_string(char* str,  struct icaltimetype *data)
+void print_date_to_string(char* str,  const struct icaltimetype *data)
 {
     char temp[20];
 
@@ -809,7 +839,7 @@ void print_date_to_string(char* str,  struct icaltimetype *data)
     strcat(str,temp);
 }
 
-char* icalvalue_date_as_ical_string(icalvalue* value) {
+static char* icalvalue_date_as_ical_string(const icalvalue* value) {
 
     struct icaltimetype data;
     char* str;
@@ -824,15 +854,14 @@ char* icalvalue_date_as_ical_string(icalvalue* value) {
     return str;
 }
 
-void print_datetime_to_string(char* str,  struct icaltimetype *data)
+void print_datetime_to_string(char* str,  const struct icaltimetype *data)
 {
     print_date_to_string(str,data);
     strcat(str,"T");
     print_time_to_string(str,data);
-
 }
 
-const char* icalvalue_datetime_as_ical_string(icalvalue* value) {
+static const char* icalvalue_datetime_as_ical_string(const icalvalue* value) {
     
     struct icaltimetype data;
     char* str;
@@ -859,7 +888,7 @@ const char* icalvalue_datetime_as_ical_string(icalvalue* value) {
 
 }
 
-char* icalvalue_float_as_ical_string(icalvalue* value) {
+static char* icalvalue_float_as_ical_string(const icalvalue* value) {
 
     float data;
     char* str;
@@ -873,7 +902,7 @@ char* icalvalue_float_as_ical_string(icalvalue* value) {
     return str;
 }
 
-char* icalvalue_geo_as_ical_string(icalvalue* value) {
+static char* icalvalue_geo_as_ical_string(const icalvalue* value) {
 
     struct icalgeotype data;
     char* str;
@@ -888,7 +917,7 @@ char* icalvalue_geo_as_ical_string(icalvalue* value) {
     return str;
 }
 
-const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
+static const char* icalvalue_datetimeperiod_as_ical_string(const icalvalue* value) {
     struct icaldatetimeperiodtype dtp = icalvalue_get_datetimeperiod(value);
 
     icalerror_check_arg_rz( (value!=0),"value");
@@ -900,7 +929,7 @@ const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
     }
 }
 
-const char* icalvalue_period_as_ical_string(icalvalue* value) {
+static const char* icalvalue_period_as_ical_string(const icalvalue* value) {
     struct icalperiodtype data;
     icalerror_check_arg_rz( (value!=0),"value");
     data = icalvalue_get_period(value);
@@ -909,7 +938,7 @@ const char* icalvalue_period_as_ical_string(icalvalue* value) {
 
 }
 
-char* icalvalue_trigger_as_ical_string(icalvalue* value) {
+static const char* icalvalue_trigger_as_ical_string(const icalvalue* value) {
 
     struct icaltriggertype data;
 
@@ -925,17 +954,13 @@ char* icalvalue_trigger_as_ical_string(icalvalue* value) {
 }
 
 const char*
-icalvalue_as_ical_string (icalvalue* value)
+icalvalue_as_ical_string(const icalvalue* value)
 {
-    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
-
-    v=v;
-
     if(value == 0){
         return 0;
     }
 
-    switch (v->kind){
+    switch (value->kind){
 
     case ICAL_ATTACH_VALUE:
         return icalvalue_attach_as_ical_string(value);
@@ -953,6 +978,9 @@ icalvalue_as_ical_string (icalvalue* value)
     case ICAL_TEXT_VALUE:
         return icalvalue_text_as_ical_string(value);
         
+    case ICAL_QUERY_VALUE:
+        return icalvalue_string_as_ical_string(value);
+        
     case ICAL_STRING_VALUE:
     case ICAL_URI_VALUE:
     case ICAL_CALADDRESS_VALUE:
@@ -983,21 +1011,24 @@ icalvalue_as_ical_string (icalvalue* value)
         return icalvalue_trigger_as_ical_string(value);
 
     case ICAL_REQUESTSTATUS_VALUE:
-        return icalreqstattype_as_string(v->data.v_requeststatus);
+        return icalreqstattype_as_string(value->data.v_requeststatus);
         
     case ICAL_ACTION_VALUE:
     case ICAL_METHOD_VALUE:
     case ICAL_STATUS_VALUE:
     case ICAL_TRANSP_VALUE:
     case ICAL_CLASS_VALUE:
-        if(v->x_value !=0){
-            return icalmemory_tmp_copy(v->x_value);
+        if(value->x_value !=0){
+            return icalmemory_tmp_copy(value->x_value);
         }
 
-        return icalproperty_enum_to_string(v->data.v_enum);
+        return icalproperty_enum_to_string(value->data.v_enum);
         
     case ICAL_X_VALUE: 
-        return icalmemory_tmp_copy(v->x_value);
+        if (value->x_value != 0)
+            return icalmemory_tmp_copy(value->x_value);
+
+    /* FALLTHRU */
 
     case ICAL_NO_VALUE:
     default:
@@ -1009,15 +1040,13 @@ icalvalue_as_ical_string (icalvalue* value)
 
 
 icalvalue_kind
-icalvalue_isa (icalvalue* value)
+icalvalue_isa (const icalvalue* value)
 {
-    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
-
     if(value == 0){
         return ICAL_NO_VALUE;
     }
 
-    return v->kind;
+    return value->kind;
 }
 
 
@@ -1036,7 +1065,7 @@ icalvalue_isa_value (void* value)
 }
 
 
-int icalvalue_is_time(icalvalue* a) {
+static int icalvalue_is_time(const icalvalue* a) {
     icalvalue_kind kind = icalvalue_isa(a);
 
     if(kind == ICAL_DATETIME_VALUE ||
@@ -1048,11 +1077,14 @@ int icalvalue_is_time(icalvalue* a) {
 
 }
 
+/*
+ * In case of error, this function returns 0. This is partly bogus, as 0 is
+ * not part of the returned enum.
+ * FIXME We should probably add an error value to the enum.
+ */
 icalparameter_xliccomparetype
-icalvalue_compare(icalvalue* a, icalvalue *b)
+icalvalue_compare(const icalvalue* a, const 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");
@@ -1066,7 +1098,29 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
     switch (icalvalue_isa(a)){
 
         case ICAL_ATTACH_VALUE:
-        case ICAL_BINARY_VALUE:
+        {
+            if (icalattach_get_is_url(a->data.v_attach) &&
+                icalattach_get_is_url(b->data.v_attach)) {
+                if (strcasecmp(icalattach_get_url(a->data.v_attach),
+                               icalattach_get_url(b->data.v_attach)) == 0)
+                    return ICAL_XLICCOMPARETYPE_EQUAL;
+                else
+                    return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+            else {
+                if (a->data.v_attach == b->data.v_attach)
+                    return ICAL_XLICCOMPARETYPE_EQUAL;
+                else
+                    return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+        }
+        case ICAL_BINARY_VALUE:
+        {
+            if (a->data.v_attach == b->data.v_attach)
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            else
+                return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+        }
 
         case ICAL_BOOLEAN_VALUE:
         {
@@ -1079,9 +1133,9 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
 
         case ICAL_FLOAT_VALUE:
         {
-            if (impla->data.v_float > implb->data.v_float){
+            if (a->data.v_float > b->data.v_float){
                 return ICAL_XLICCOMPARETYPE_GREATER;
-            } else if (impla->data.v_float < implb->data.v_float){
+            } else if (a->data.v_float < b->data.v_float){
                 return ICAL_XLICCOMPARETYPE_LESS;
             } else {
                 return ICAL_XLICCOMPARETYPE_EQUAL;
@@ -1091,9 +1145,9 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
         case ICAL_INTEGER_VALUE:
         case ICAL_UTCOFFSET_VALUE:
         {
-            if (impla->data.v_int > implb->data.v_int){
+            if (a->data.v_int > b->data.v_int){
                 return ICAL_XLICCOMPARETYPE_GREATER;
-            } else if (impla->data.v_int < implb->data.v_int){
+            } else if (a->data.v_int < b->data.v_int){
                 return ICAL_XLICCOMPARETYPE_LESS;
             } else {
                 return ICAL_XLICCOMPARETYPE_EQUAL;
@@ -1102,12 +1156,12 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
 
         case ICAL_DURATION_VALUE: 
         {
-            int a = icaldurationtype_as_int(impla->data.v_duration);
-            int b = icaldurationtype_as_int(implb->data.v_duration);
+            int dur_a = icaldurationtype_as_int(a->data.v_duration);
+            int dur_b = icaldurationtype_as_int(b->data.v_duration);
 
-            if (a > b){
+            if (dur_a > dur_b){
                 return ICAL_XLICCOMPARETYPE_GREATER;
-            } else if (a < b){
+            } else if (dur_a < dur_b){
                 return ICAL_XLICCOMPARETYPE_LESS;
             } else {
                 return ICAL_XLICCOMPARETYPE_EQUAL;
@@ -1122,6 +1176,8 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
         case ICAL_DATE_VALUE:
         case ICAL_DATETIME_VALUE:
         case ICAL_DATETIMEPERIOD_VALUE:
+        case ICAL_QUERY_VALUE:
+        case ICAL_RECUR_VALUE:
         {
             int r;
 
@@ -1159,31 +1215,49 @@ icalvalue_compare(icalvalue* a, icalvalue *b)
 
         }
 
+        case ICAL_TRANSP_VALUE:
+        {
+            if (icalvalue_get_transp(a) == icalvalue_get_transp(b)){
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            } else {
+                return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+        }
+
+        case ICAL_ACTION_VALUE:
+        {
+            if (icalvalue_get_action(a) == icalvalue_get_action(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 */
+            return 0;
         }
     }   
 
 }
 
-/* Examine the value and possiby chage the kind to agree with the value */
+/** Examine the value and possibly change the kind to agree with the
+ *  value 
+ */
+
 void icalvalue_reset_kind(icalvalue* value)
 {
-    struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
-
-    if( (impl->kind==ICAL_DATETIME_VALUE || impl->kind==ICAL_DATE_VALUE )&&
-        !icaltime_is_null_time(impl->data.v_time) ) {
+    if( (value->kind==ICAL_DATETIME_VALUE || value->kind==ICAL_DATE_VALUE )&&
+        !icaltime_is_null_time(value->data.v_time) ) {
         
-        if( impl->data.v_time.is_date == 1){
-            impl->kind = ICAL_DATE_VALUE;
+        if(icaltime_is_date(value->data.v_time)){
+            value->kind = ICAL_DATE_VALUE;
         } else {
-            impl->kind = ICAL_DATETIME_VALUE;
+            value->kind = ICAL_DATETIME_VALUE;
         }
     }
        
@@ -1192,24 +1266,44 @@ void icalvalue_reset_kind(icalvalue* value)
 void icalvalue_set_parent(icalvalue* value,
                              icalproperty* property)
 {
-    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
-
-    v->parent = property;
-
+    value->parent = property;
 }
 
 icalproperty* icalvalue_get_parent(icalvalue* value)
 {
-    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+    return value->parent;
+}
 
 
-    return v->parent;
-}
+int icalvalue_encode_ical_string(const char *szText, char *szEncText, int nMaxBufferLen)
+{
+    char   *ptr;
+    icalvalue *value = 0;
+
+    if ((szText == 0) || (szEncText == 0))
+        return 0;
+   
+    value = icalvalue_new_from_string(ICAL_STRING_VALUE, szText);
+    
+    if (value == 0)
+        return 0;
+    
+    ptr = icalvalue_text_as_ical_string(value);
+    if (ptr == 0)
+        return 0;
+    
+    if ((int)strlen(ptr) >= nMaxBufferLen)
+        {
+            icalvalue_free (value);
+            return 0;
+        }
 
+    strcpy(szEncText, ptr);
 
+    icalvalue_free ((icalvalue*)value);
+
+    return 1;
+}
 
 /* The remaining interfaces are 'new', 'set' and 'get' for each of the value
    types */
-
-
-/* Everything below this line is machine generated. Do not edit. */