1 files changed, 348 insertions, 161 deletions

diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c
index 7f2cfa5..45d7a75 100644
--- a/libical/src/libical/icalproperty.c
+++ b/libical/src/libical/icalproperty.c
@@ -25,3 +25,2 @@
 ======================================================================*/
-/*#line 27 "icalproperty.c.in"*/
 
@@ -47,5 +46,6 @@
                                                
-int snprintf(char *str, size_t n, char const *fmt, ...);
-
-#define TMP_BUF_SIZE 1024
+#ifdef WIN32
+#define snprintf      _snprintf
+#define strcasecmp    stricmp
+#endif
 
@@ -74,9 +74,6 @@ struct icalproperty_impl
 
-void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
+void icalproperty_add_parameters(icalproperty* prop, va_list args)
 {
-
     void* vp;
 
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
-  
     while((vp = va_arg(args, void*)) != 0) {
@@ -86,6 +83,6 @@ void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
 
-            icalproperty_add_parameter((icalproperty*)impl,
+            icalproperty_add_parameter((icalproperty*)prop,
                                        (icalparameter*)vp);
         } else {
-            assert(0);
+            icalerror_set_errno(ICAL_BADARG_ERROR);
         }
@@ -93,4 +90,2 @@ void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
     }
-    
-    
 }
@@ -98,9 +93,11 @@ void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
 
-struct icalproperty_impl*
-icalproperty_new_impl (icalproperty_kind kind)
+icalproperty*
+icalproperty_new_impl(icalproperty_kind kind)
 {
-    struct icalproperty_impl* prop;
+    icalproperty* prop;
+
+    if (!icalproperty_kind_is_valid(kind))
+      return NULL;
 
-    if ( ( prop = (struct icalproperty_impl*)
-           malloc(sizeof(struct icalproperty_impl))) == 0) {
+    if ( ( prop = (icalproperty*) malloc(sizeof(icalproperty))) == 0) {
         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
@@ -125,3 +122,3 @@ icalproperty_new (icalproperty_kind kind)
 {
-    if(kind == ICAL_NO_PROPERTY){
+    if (kind == ICAL_NO_PROPERTY){
         return 0;
@@ -134,9 +131,7 @@ icalproperty_new (icalproperty_kind kind)
 icalproperty*
-icalproperty_new_clone(icalproperty* prop)
+icalproperty_new_clone(icalproperty* old)
 {
-    struct icalproperty_impl *old = (struct icalproperty_impl*)prop;
-    struct icalproperty_impl *new = icalproperty_new_impl(old->kind);
+    icalproperty *new = icalproperty_new_impl(old->kind);
     pvl_elem p;
 
-    icalerror_check_arg_rz((prop!=0),"Prop");
     icalerror_check_arg_rz((old!=0),"old");
@@ -221,11 +216,7 @@ icalproperty* icalproperty_new_from_string(const char* str)
 void
-icalproperty_free (icalproperty* prop)
+icalproperty_free (icalproperty* p)
 {
-    struct icalproperty_impl *p;
-
     icalparameter* param;
     
-    icalerror_check_arg_rv((prop!=0),"prop");
-
-    p = (struct icalproperty_impl*)prop;
+    icalerror_check_arg_rv((p!=0),"prop");
 
@@ -267,52 +258,118 @@ icalproperty_free (icalproperty* prop)
 
-const char*
-icalproperty_as_ical_string (icalproperty* prop)
-{   
-    icalparameter *param;
+/* This returns where the start of the next line should be. chars_left does
+   not include the trailing '\0'. */
+#define MAX_LINE_LEN 75
+/*#define MAX_LINE_LEN 120*/
 
-    /* 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;
+static char*
+get_next_line_start (char *line_start, int chars_left)
+{
+    char *pos;
 
-    char newline[] = "\n";
+    /* If we have 74 chars or less left, we can output all of them. 
+       we return a pointer to the '\0' at the end of the string. */
+    if (chars_left < MAX_LINE_LEN) {
+        return line_start + chars_left;
+    } 
 
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
-    
-    icalerror_check_arg_rz( (prop!=0),"prop");
+    /* Now we jump to the last possible character of the line, and step back
+       trying to find a ';' ':' or ' '. If we find one, we return the character
+       after it. */
+    pos = line_start + MAX_LINE_LEN - 2;
+    while (pos > line_start) {
+        if (*pos == ';' || *pos == ':' || *pos == ' ') {
+            return pos + 1;
+        }
+        pos--;
+    }
+    /* Now try to split on a UTF-8 boundary defined as a 7-bit
+       value or as a byte with the two high-most bits set:
+       11xxxxxx.  See http://czyborra.com/utf/ */
 
+    pos = line_start + MAX_LINE_LEN - 1;
+    while (pos > line_start) {
+        /* plain ascii */
+        if ((*pos & 128) == 0)
+            return pos;
 
-    /* Append property name */
+        /* utf8 escape byte */
+        if ((*pos & 192) == 192)
+            return pos;
 
-    if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
-        property_name = impl->x_name;
-    } else {
-        property_name = icalproperty_kind_to_string(impl->kind);
+        pos--;
     }
 
-    if (property_name == 0 ) {
-        icalerror_warn("Got a property of an unknown kind.");
-        icalmemory_free_buffer(buf);
-        return 0;
-        
-    }
+    /* Give up, just break at 74 chars (the 75th char is the space at
+       the start of the line).  */
+
+    return line_start + MAX_LINE_LEN - 1;
+}
 
 
-    icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
-    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+/** This splits the property into lines less than 75 octects long (as
+ *  specified in RFC2445). It tries to split after a ';' if it can.
+ *  It returns a tmp buffer.  NOTE: I'm not sure if it matters if we
+ *  split a line in the middle of a UTF-8 character. It probably won't
+ *  look nice in a text editor. 
+ */
+static char*
+fold_property_line (char *text)
+{
+    size_t buf_size;
+    char *buf, *buf_ptr, *line_start, *next_line_start, *out_buf;
+    int len, chars_left, first_line;
+    char ch;
+
+    /* Start with a buffer twice the size of our property line, so we almost
+       certainly won't overflow it. */
+    len = strlen (text);
+    buf_size = len * 2;
+    buf = icalmemory_new_buffer (buf_size);
+    buf_ptr = buf;
+
+    /* Step through the text, finding each line to add to the output. */
+    line_start = text;
+    chars_left = len;
+    first_line = 1;
+    for (;;) {
+        if (chars_left <= 0)
+            break;
+
+        /* This returns the first character for the next line. */
+        next_line_start = get_next_line_start (line_start, chars_left);
+
+        /* If this isn't the first line, we need to output a newline and space
+           first. */
+        if (!first_line) {
+            icalmemory_append_string (&buf, &buf_ptr, &buf_size, "\n ");
+        }
+        first_line = 0;
+
+        /* This adds the line to our tmp buffer. We temporarily place a '\0'
+           in text, so we can copy the line in one go. */
+        ch = *next_line_start;
+        *next_line_start = '\0';
+        icalmemory_append_string (&buf, &buf_ptr, &buf_size, line_start);
+        *next_line_start = ch;
 
+        /* Now we move on to the next line. */
+        chars_left -= (next_line_start - line_start);
+        line_start = next_line_start;
+    }
+
+    /* Copy it to a temporary buffer, and then free it. */
+    out_buf = icalmemory_tmp_buffer (strlen (buf) + 1);
+    strcpy (out_buf, buf);
+    icalmemory_free_buffer (buf);
+
+    return out_buf;
+}
 
 
-    /* Determine what VALUE parameter to include. The VALUE parameters
-       are ignored in the normal parameter printing ( the block after
-       this one, so we need to do it here */
-    {
+/* Determine what VALUE parameter to include. The VALUE parameters
+   are ignored in the normal parameter printing ( the block after
+   this one, so we need to do it here */
+static const char *
+icalproperty_get_value_kind(icalproperty *prop)
+{
         const char* kind_string = 0;
@@ -322,3 +379,3 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-        icalvalue *value = icalproperty_get_value(impl);
+        icalvalue *value = icalproperty_get_value(prop);
 
@@ -329,3 +386,3 @@ icalproperty_as_ical_string (icalproperty* prop)
         icalvalue_kind default_kind 
-            =  icalproperty_kind_to_value_kind(impl->kind);
+            =  icalproperty_kind_to_value_kind(prop->kind);
 
@@ -356,10 +413,51 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-        if(kind_string!=0){
-            icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
-            icalmemory_append_string(&buf, &buf_ptr, &buf_size, "VALUE=");
-            icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
-            icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
-        }
+        return kind_string;
+}
+
+const 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;
+    const char* kind_string = 0;
+
+    char newline[] = "\n";
+
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+
+
+    /* Append property name */
+
+    if (prop->kind == ICAL_X_PROPERTY && prop->x_name != 0){
+        property_name = prop->x_name;
+    } else {
+        property_name = icalproperty_kind_to_string(prop->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);
+
+    kind_string = icalproperty_get_value_kind(prop);
+    if(kind_string!=0){
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, ";VALUE=");
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
     }
@@ -371,4 +469,4 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-        char* kind_string = icalparameter_as_ical_string(param); 
         icalparameter_kind kind = icalparameter_isa(param);
+        kind_string = icalparameter_as_ical_string(param); 
 
@@ -379,5 +477,5 @@ icalproperty_as_ical_string (icalproperty* prop)
         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);
+          icalerror_warn("Got a parameter of unknown kind for the following property");
+
+          icalerror_warn((property_name) ? property_name : "(NULL)");
             continue;
@@ -385,6 +483,4 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-        icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
+        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);
-
     }    
@@ -393,3 +489,3 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-    icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :");
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, ":");
 
@@ -411,5 +507,4 @@ icalproperty_as_ical_string (icalproperty* prop)
 
-    
-    out_buf = icalmemory_tmp_buffer(strlen(buf)+1);
-    strcpy(out_buf, buf);
+    /* We now use a function to fold the line properly every 75 characters. */
+    out_buf = fold_property_line (buf);
 
@@ -423,7 +518,5 @@ icalproperty_as_ical_string (icalproperty* prop)
 icalproperty_kind
-icalproperty_isa (icalproperty* property)
+icalproperty_isa (icalproperty* p)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)property;
-
-   if(property != 0){
+   if(p != 0){
        return p->kind;
@@ -437,6 +530,5 @@ icalproperty_isa_property (void* property)
 {
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+    icalproperty *impl = (icalproperty *) property;
 
     icalerror_check_arg_rz( (property!=0), "property");
-
     if (strcmp(impl->id,"prop") == 0) {
@@ -450,7 +542,5 @@ icalproperty_isa_property (void* property)
 void
-icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter)
+icalproperty_add_parameter (icalproperty* p,icalparameter* parameter)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
-    
-   icalerror_check_arg_rv( (prop!=0),"prop");
+   icalerror_check_arg_rv( (p!=0),"prop");
    icalerror_check_arg_rv( (parameter!=0),"parameter");
@@ -470,4 +560,7 @@ icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
     kind = icalparameter_isa(parameter);
-
-    icalproperty_remove_parameter(prop,kind);
+    if (kind != ICAL_X_PARAMETER)
+      icalproperty_remove_parameter_by_kind(prop,kind);
+    else
+      icalproperty_remove_parameter_by_name(prop, 
+                                            icalparameter_get_xname(parameter));
 
@@ -493,3 +586,3 @@ void icalproperty_set_parameter_from_string(icalproperty* prop,
     }
-
+    
     param  = icalparameter_new_from_value_string(kind,value);
@@ -501,2 +594,6 @@ void icalproperty_set_parameter_from_string(icalproperty* prop,
 
+    if(kind == ICAL_X_PARAMETER){
+        icalparameter_set_xname(param, name);
+    }
+
     icalproperty_set_parameter(prop,param);
@@ -518,3 +615,3 @@ const char* icalproperty_get_parameter_as_string(icalproperty* prop,
 
-    if(kind == ICAL_NO_PROPERTY){
+    if(kind == ICAL_NO_PARAMETER){
         /* icalenum_string_to_parameter_kind will set icalerrno */
@@ -522,4 +619,14 @@ const char* icalproperty_get_parameter_as_string(icalproperty* prop,
     }
+    
+    for(param = icalproperty_get_first_parameter(prop,kind); 
+            param != 0; 
+            param = icalproperty_get_next_parameter(prop,kind)) {
+            if (kind != ICAL_X_PARAMETER) {
+                    break;
+            }
 
-    param = icalproperty_get_first_parameter(prop,kind);
+            if (strcmp(icalparameter_get_xname(param),name)==0) {
+                    break;
+                    }   
+    }
 
@@ -529,2 +636,3 @@ const char* icalproperty_get_parameter_as_string(icalproperty* prop,
 
+
     str = icalparameter_as_ical_string(param);
@@ -542,7 +650,29 @@ const char* icalproperty_get_parameter_as_string(icalproperty* prop,
 
+/** @see icalproperty_remove_parameter_by_kind() 
+ *
+ *  @deprecated Please use icalproperty_remove_parameter_by_kind()
+ *              instead.
+ */
+
 void
-icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
+icalproperty_remove_parameter(icalproperty* prop, icalparameter_kind kind)
+{
+  icalproperty_remove_parameter_by_kind(prop, kind);
+}
+
+
+/** @brief Remove all parameters with the specified kind.
+ *
+ *  @param prop   A valid icalproperty.
+ *  @param kind   The kind to remove (ex. ICAL_TZID_PARAMETER)
+ *
+ *  See icalproperty_remove_parameter_by_name() and
+ *  icalproperty_remove_parameter_by_ref() for alternate ways of
+ *  removing parameters
+ */
+
+void
+icalproperty_remove_parameter_by_kind(icalproperty* prop, icalparameter_kind kind)
 {
     pvl_elem p;     
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
 
@@ -550,7 +680,7 @@ icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
     
-    for(p=pvl_head(impl->parameters);p != 0; p = pvl_next(p)){
+    for(p=pvl_head(prop->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);
+            pvl_remove (prop->parameters, p);
+            icalparameter_free(param);
             break;
@@ -561,9 +691,88 @@ icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
 
-int
-icalproperty_count_parameters (icalproperty* prop)
+/** @brief Remove all parameters with the specified name.
+ *
+ *  @param prop   A valid icalproperty.
+ *  @param name   The name of the parameter to remove
+ *
+ *  This function removes paramters with the given name.  The name
+ *  corresponds to either a built-in name (TZID, etc.) or the name of
+ *  an extended parameter (X-FOO)
+ *
+ *  See icalproperty_remove_parameter_by_kind() and
+ *  icalproperty_remove_parameter_by_ref() for alternate ways of removing
+ *  parameters
+ */
+
+
+void
+icalproperty_remove_parameter_by_name(icalproperty* prop, const char *name)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    pvl_elem p;     
+
+    icalerror_check_arg_rv((prop!=0),"prop");
+    
+    for(p=pvl_head(prop->parameters);p != 0; p = pvl_next(p)){
+        icalparameter* param = (icalparameter *)pvl_data (p);
+        const char * kind_string;
+
+        if (icalparameter_isa(param) == ICAL_X_PARAMETER)
+          kind_string = icalparameter_get_xname(param);
+        else
+          kind_string = icalparameter_kind_to_string(icalparameter_isa(param));
+
+        if (!kind_string)
+          continue;
 
+        if (0 == strcmp(kind_string, name)) {
+            pvl_remove (prop->parameters, p);
+            break;
+        }
+    }                       
+}
+
+
+/** @brief Remove the specified parameter reference from the property.
+ *
+ *  @param prop   A valid icalproperty.
+ *  @param parameter   A reference to a specific icalparameter.
+ *
+ *  This function removes the specified parameter reference from the
+ *  property.
+ */
+
+void
+icalproperty_remove_parameter_by_ref(icalproperty* prop, icalparameter* parameter)
+{
+    pvl_elem p;
+    icalparameter_kind kind;
+    const char *name;
+
+    icalerror_check_arg_rv((prop!=0),"prop");
+    icalerror_check_arg_rv((parameter!=0),"parameter");
+
+    kind = icalparameter_isa(parameter);
+    name = icalparameter_get_xname(parameter);
+
+    /*
+     * FIXME If it's an X- parameter, also compare the names. It would be nice
+     * to have a better abstraction like icalparameter_equals()
+     */
+    for(p=pvl_head(prop->parameters);p != 0; p = pvl_next(p)){
+        icalparameter* p_param = (icalparameter *)pvl_data (p);
+        if (icalparameter_isa(p_param) == kind &&
+            (kind != ICAL_X_PARAMETER ||
+            !strcmp(icalparameter_get_xname(p_param), name))) {
+            pvl_remove (prop->parameters, p);
+            icalparameter_free(p_param);
+            break;
+        } 
+    }   
+}
+
+
+int
+icalproperty_count_parameters (const icalproperty* prop)
+{
     if(prop != 0){
-        return pvl_count(p->parameters);
+        return pvl_count(prop->parameters);
     }
@@ -576,7 +785,5 @@ icalproperty_count_parameters (icalproperty* prop)
 icalparameter*
-icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind)
+icalproperty_get_first_parameter(icalproperty* p, icalparameter_kind kind)
 {
-   struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
-
-   icalerror_check_arg_rz( (prop!=0),"prop");
+   icalerror_check_arg_rz( (p!=0),"prop");
    
@@ -604,7 +811,5 @@ icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind)
 icalparameter*
-icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind)
+icalproperty_get_next_parameter (icalproperty* p, icalparameter_kind kind)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
-    
-    icalerror_check_arg_rz( (prop!=0),"prop");
+    icalerror_check_arg_rz( (p!=0),"prop");
     
@@ -630,7 +835,5 @@ icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind)
 void
-icalproperty_set_value (icalproperty* prop, icalvalue* value)
+icalproperty_set_value (icalproperty* p, icalvalue* value)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
-
-    icalerror_check_arg_rv((prop !=0),"prop");
+    icalerror_check_arg_rv((p !=0),"prop");
     icalerror_check_arg_rv((value !=0),"value");
@@ -645,3 +848,3 @@ icalproperty_set_value (icalproperty* prop, icalvalue* value)
     
-    icalvalue_set_parent(value,prop);
+    icalvalue_set_parent(value,p);
 }
@@ -693,12 +896,10 @@ void icalproperty_set_value_from_string(icalproperty* prop,const char* str,
 icalvalue*
-icalproperty_get_value (icalproperty* prop)
+icalproperty_get_value(const icalproperty* prop)
 {
-    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
-    
     icalerror_check_arg_rz( (prop!=0),"prop");
     
-    return p->value;
+    return prop->value;
 }
 
-const char* icalproperty_get_value_as_string(icalproperty* prop)
+const char* icalproperty_get_value_as_string(const icalproperty* prop)
 {
@@ -706,7 +907,5 @@ const char* icalproperty_get_value_as_string(icalproperty* prop)
     
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
-    
     icalerror_check_arg_rz( (prop!=0),"prop");
 
-    value = impl->value; 
+    value = prop->value; 
 
@@ -718,4 +917,2 @@ void icalproperty_set_x_name(icalproperty* prop, const char* name)
 {
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
-
     icalerror_check_arg_rv( (name!=0),"name");
@@ -723,9 +920,9 @@ void icalproperty_set_x_name(icalproperty* prop, const char* name)
 
-    if (impl->x_name != 0) {
-        free(impl->x_name);
+    if (prop->x_name != 0) {
+        free(prop->x_name);
     }
 
-    impl->x_name = icalmemory_strdup(name);
+    prop->x_name = icalmemory_strdup(name);
 
-    if(impl->x_name == 0){
+    if(prop->x_name == 0){
         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
@@ -736,8 +933,5 @@ void icalproperty_set_x_name(icalproperty* prop, const char* name)
 const 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;
+    return prop->x_name;
 }
@@ -745,4 +939,11 @@ const char* icalproperty_get_x_name(icalproperty* prop){
 
-/* From Jonathan Yue <jonathan.yue@cp.net>    */
-const char* icalproperty_get_name (icalproperty* prop)
+const char* icalproperty_get_name(const icalproperty* prop)
+{
+#ifndef NO_WARN_DEPRECATED
+        icalerror_warn("icalproperty_get_name() is DEPRECATED, please use icalproperty_get_property_name() instead.");
+#endif
+        return icalproperty_get_property_name(prop);
+}
+
+const char* icalproperty_get_property_name(const icalproperty* prop)
 {
@@ -754,10 +955,8 @@ const char* icalproperty_get_name (icalproperty* prop)
 
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
-
     icalerror_check_arg_rz( (prop!=0),"prop");
  
-    if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
-        property_name = impl->x_name;
+    if (prop->kind == ICAL_X_PROPERTY && prop->x_name != 0){
+        property_name = prop->x_name;
     } else {
-        property_name = icalproperty_kind_to_string(impl->kind);
+        property_name = icalproperty_kind_to_string(prop->kind);
     }
@@ -787,24 +986,12 @@ void icalproperty_set_parent(icalproperty* property,
 {
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
-
     icalerror_check_arg_rv( (property!=0),"property");
     
-    impl->parent = component;
+    property->parent = component;
 }
 
-icalcomponent* icalproperty_get_parent(icalproperty* property)
+icalcomponent* icalproperty_get_parent(const icalproperty* property)
 {
-    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
- 
     icalerror_check_arg_rz( (property!=0),"property");
 
-    return impl->parent;
+    return property->parent;
 }
-
-
-
-
-
-
-
-/* Everything below this line is machine generated. Do not edit. */