aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--libical/configure.in1
-rw-r--r--libical/src/libical/.cvsignore12
-rw-r--r--libical/src/libical/icalparameter.c382
-rw-r--r--libical/src/libical/icalparameter.c.in1246
-rw-r--r--libical/src/libical/icalparameter.h (renamed from libical/src/libical/icalparameter.h.in)24
-rw-r--r--libical/src/libical/icalproperty.c (renamed from libical/src/libical/icalproperty.c.in)246
-rw-r--r--libical/src/libical/icalproperty.h116
-rw-r--r--libical/src/libical/icalproperty.h.in57
-rw-r--r--libical/src/libical/icaltime.c11
-rw-r--r--libical/src/libical/icalvalue.c (renamed from libical/src/libical/icalvalue.c.in)584
-rw-r--r--libical/src/libical/icalvalue.h (renamed from libical/src/libical/icalvalue.h.in)23
11 files changed, 949 insertions, 1753 deletions
diff --git a/libical/configure.in b/libical/configure.in
index 112ac66ded..3b69f4d5ee 100644
--- a/libical/configure.in
+++ b/libical/configure.in
@@ -94,6 +94,7 @@ scripts/Makefile
src/Makefile
src/libical/Makefile
src/libical/icalversion.h
+src/libicalss/Makefile
src/libicalvcal/Makefile
src/python/Makefile
src/test/Makefile
diff --git a/libical/src/libical/.cvsignore b/libical/src/libical/.cvsignore
index fd83172a6b..ef04480fde 100644
--- a/libical/src/libical/.cvsignore
+++ b/libical/src/libical/.cvsignore
@@ -12,11 +12,11 @@ y.output
.libs
.deps
icalversion.h
-icalproperty.h
-icalvalue.h
-icalvalue.c
ical.h
-icalparameter.h
-icalparameter.c
-icalproperty.c
+icalderivedparameter.c
+icalderivedparameter.h
+icalderivedproperty.c
+icalderivedproperty.h
+icalderivedvalue.h
+icalderivedvalue.c
icalrestriction.c
diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c
new file mode 100644
index 0000000000..156ecdb04b
--- /dev/null
+++ b/libical/src/libical/icalparameter.c
@@ -0,0 +1,382 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalderivedparameters.{c,h}
+ CREATOR: eric 09 May 1999
+
+ $Id$
+ $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 "icalparameterimpl.h"
+
+#include <stdlib.h> /* for malloc() */
+#include <errno.h>
+#include <string.h> /* for memset() */
+
+/* In icalderivedparameter */
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const char* val);
+
+
+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;
+ v->data = 0;
+
+ return v;
+}
+
+icalparameter*
+icalparameter_new (icalparameter_kind kind)
+{
+ struct icalparameter_impl* v = icalparameter_new_impl(kind);
+
+ return (icalparameter*) v;
+
+}
+
+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);
+}
+
+
+
+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;
+}
+
+icalparameter* icalparameter_new_from_string(const char *str)
+{
+ char* eq;
+ char* cpy;
+ icalparameter_kind kind;
+ icalparameter *param;
+
+ icalerror_check_arg_rz(str != 0,"str");
+
+ cpy = icalmemory_strdup(str);
+
+ if (cpy == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ eq = strchr(cpy,'=');
+
+ if(eq == 0){
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return 0;
+ }
+
+ *eq = '\0';
+
+ eq++;
+
+ kind = icalparameter_string_to_kind(cpy);
+
+ if(kind == ICAL_NO_PARAMETER){
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return 0;
+ }
+
+ param = icalparameter_new_from_value_string(kind,eq);
+
+ if(kind == ICAL_X_PARAMETER){
+ icalparameter_set_xname(param,cpy);
+ }
+
+ free(cpy);
+
+ return param;
+
+}
+
+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;
+
+ 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;
+
+ if(impl->kind == ICAL_X_PARAMETER) {
+
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size,
+ icalparameter_get_xname(impl));
+
+ } else {
+
+ kind_string = icalparameter_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, "=");
+
+ if(impl->string !=0){
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, impl->string);
+ } else if (impl->data != 0){
+ const char* str = icalparameter_enum_to_string(impl->data);
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
+ } else {
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return 0;
+ }
+
+ /* 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_rz( (param!=0),"param");
+
+ return impl->parent;
+}
+
+
+/* Everything below this line is machine generated. Do not edit. */
+/* ALTREP */
diff --git a/libical/src/libical/icalparameter.c.in b/libical/src/libical/icalparameter.c.in
deleted file mode 100644
index 6ffb9b27eb..0000000000
--- a/libical/src/libical/icalparameter.c.in
+++ /dev/null
@@ -1,1246 +0,0 @@
-/* -*- Mode: C -*-
- ======================================================================
- FILE: icalderivedparameters.{c,h}
- CREATOR: eric 09 May 1999
-
- $Id: icalparameter.c.in,v 1.4 2001/02/09 07:09:46 jpr 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,"NEEDS-ACTION"},
- {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:
- break;
- }
-}
-
-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,"NEEDS-ACTION") == 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;
-
- if(impl->kind == ICAL_X_PARAMETER) {
-
- icalmemory_append_string(&buf, &buf_ptr, &buf_size,
- icalparameter_get_xname(impl));
-
- } else {
-
- 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,"NEEDS-ACTION");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;
- }
- default:{
- icalerror_set_errno(ICAL_BADARG_ERROR);break;
- }
- 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_rz( (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
index c215fa0fdc..3f3b59f049 100644
--- a/libical/src/libical/icalparameter.h.in
+++ b/libical/src/libical/icalparameter.h
@@ -4,8 +4,8 @@
CREATOR: eric 20 March 1999
- $Id: icalparameter.h.in,v 1.1.1.2 2001/01/23 19:20:40 jpr Exp $
- $Locker: $
+ $Id$
+ $Locker$
@@ -29,13 +29,19 @@
#ifndef ICALPARAM_H
#define ICALPARAM_H
-#include "icalenums.h"
+#include "icalderivedparameter.h"
-typedef void icalparameter;
+/* Declared in icalderivedparameter.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);
+
+/* Create from string of form "PARAMNAME=VALUE" */
+icalparameter* icalparameter_new_from_string(const char* value);
+
+/* Create from just the value, the part after the "=" */
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind, const char* value);
void icalparameter_free(icalparameter* parameter);
@@ -53,5 +59,11 @@ const char* icalparameter_get_xname(icalparameter* param);
void icalparameter_set_xvalue (icalparameter* param, const char* v);
const char* icalparameter_get_xvalue(icalparameter* param);
+/* Convert enumerations */
+
+const char* icalparameter_kind_to_string(icalparameter_kind kind);
+icalparameter_kind icalparameter_string_to_kind(const char* string);
+
+
-/* Everything below this line is machine generated. Do not edit. */
+#endif
diff --git a/libical/src/libical/icalproperty.c.in b/libical/src/libical/icalproperty.c
index 936db3f728..c5638827e5 100644
--- a/libical/src/libical/icalproperty.c.in
+++ b/libical/src/libical/icalproperty.c
@@ -4,7 +4,7 @@
FILE: icalproperty.c
CREATOR: eric 28 April 1999
- $Id: icalproperty.c.in,v 1.4 2001/02/05 19:43:57 jpr Exp $
+ $Id$
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
@@ -30,11 +30,13 @@
#endif
#include "icalproperty.h"
+#include "icalparameter.h"
#include "icalcomponent.h"
#include "pvl.h"
#include "icalenums.h"
#include "icalerror.h"
#include "icalmemory.h"
+#include "icalparser.h"
#include <string.h> /* For icalmemory_strdup, rindex */
#include <assert.h>
@@ -68,11 +70,13 @@ struct icalproperty_impl
icalcomponent *parent;
};
-void icalproperty_add_parameters(struct icalproperty_impl *impl,va_list args)
+void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
{
void* vp;
-
+
+ struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
while((vp = va_arg(args, void*)) != 0) {
if (icalvalue_isa_value(vp) != 0 ){
@@ -117,9 +121,11 @@ icalproperty_new_impl (icalproperty_kind kind)
icalproperty*
icalproperty_new (icalproperty_kind kind)
{
- icalproperty *prop = (icalproperty*)icalproperty_new_impl(kind);
+ if(kind == ICAL_NO_PROPERTY){
+ return 0;
+ }
- return prop;
+ return (icalproperty*)icalproperty_new_impl(kind);
}
@@ -166,30 +172,48 @@ icalproperty_new_clone(icalproperty* prop)
}
-/* 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;
+
+ size_t buf_size = 1024;
+ char* buf = icalmemory_new_buffer(buf_size);
+ char* buf_ptr = buf;
+ icalproperty *prop;
+ icalcomponent *comp;
+ int errors = 0;
icalerror_check_arg_rz( (str!=0),"str");
- kind = icalenum_string_to_property_kind(str);
+ /* Is this a HACK or a crafty reuse of code? */
- if(kind == ICAL_X_PROPERTY){
- icalproperty *p = icalproperty_new(ICAL_X_PROPERTY);
- icalproperty_set_x_name(p,str);
- return p;
- } else if (kind == ICAL_NO_PROPERTY){
- icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- return 0;
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:VCALENDAR\n");
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n");
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:VCALENDAR\n");
+
+ comp = icalparser_parse_string(buf);
+
+ if(comp == 0){
+ icalerror_set_errno(ICAL_PARSE_ERROR);
+ return 0;
+ }
+
+ errors = icalcomponent_count_errors(comp);
+
+ prop = icalcomponent_get_first_property(comp,ICAL_ANY_PROPERTY);
+
+ icalcomponent_remove_property(comp,prop);
+
+ icalcomponent_free(comp);
+ free(buf);
+
+ if(errors > 0){
+ icalproperty_free(prop);
+ return 0;
} else {
- return icalproperty_new(kind);
+ return prop;
}
+
}
void
@@ -269,7 +293,7 @@ icalproperty_as_ical_string (icalproperty* prop)
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);
+ property_name = icalproperty_kind_to_string(impl->kind);
}
if (property_name == 0 ) {
@@ -301,7 +325,7 @@ icalproperty_as_ical_string (icalproperty* prop)
icalvalue_kind this_kind = ICAL_NO_VALUE;
icalvalue_kind default_kind
- = icalenum_property_kind_to_value_kind(impl->kind);
+ = icalproperty_kind_to_value_kind(impl->kind);
if(orig_val_param){
orig_kind = (icalvalue_kind)icalparameter_get_value(orig_val_param);
@@ -319,11 +343,11 @@ icalproperty_as_ical_string (icalproperty* prop)
the property. But, use the default, not the one
specified in the property */
- kind_string = icalenum_value_kind_to_string(default_kind);
+ kind_string = icalvalue_kind_to_string(default_kind);
} else if (this_kind != default_kind && this_kind != ICAL_NO_VALUE){
/* Not the default, so it must be specified */
- kind_string = icalenum_value_kind_to_string(this_kind);
+ kind_string = icalvalue_kind_to_string(this_kind);
} else {
/* Don'tinclude the VALUE parameter at all */
}
@@ -437,6 +461,9 @@ void
icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
{
icalparameter_kind kind;
+
+ icalerror_check_arg_rv( (prop!=0),"prop");
+ icalerror_check_arg_rv( (parameter!=0),"parameter");
kind = icalparameter_isa(parameter);
@@ -445,6 +472,71 @@ icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
icalproperty_add_parameter(prop,parameter);
}
+void icalproperty_set_parameter_from_string(icalproperty* prop,
+ const char* name, const char* value)
+{
+
+ icalparameter_kind kind;
+ icalparameter *param;
+
+ icalerror_check_arg_rv( (prop!=0),"prop");
+ icalerror_check_arg_rv( (name!=0),"name");
+ icalerror_check_arg_rv( (value!=0),"value");
+
+ kind = icalparameter_string_to_kind(name);
+
+ if(kind == ICAL_NO_PARAMETER){
+ icalerror_set_errno(ICAL_BADARG_ERROR);
+ return;
+ }
+
+ param = icalparameter_new_from_value_string(kind,value);
+
+ if (param == 0){
+ icalerror_set_errno(ICAL_BADARG_ERROR);
+ return;
+ }
+
+ icalproperty_set_parameter(prop,param);
+
+}
+
+const char* icalproperty_get_parameter_as_string(icalproperty* prop,
+ const char* name)
+{
+ icalparameter_kind kind;
+ icalparameter *param;
+ char* str;
+ char* pv;
+
+ icalerror_check_arg_rz( (prop!=0),"prop");
+ icalerror_check_arg_rz( (name!=0),"name");
+
+ kind = icalparameter_string_to_kind(name);
+
+ if(kind == ICAL_NO_PROPERTY){
+ /* icalenum_string_to_parameter_kind will set icalerrno */
+ return 0;
+ }
+
+ param = icalproperty_get_first_parameter(prop,kind);
+
+ if (param == 0){
+ return 0;
+ }
+
+ str = icalparameter_as_ical_string(param);
+
+ pv = strchr(str,'=');
+
+ if(pv == 0){
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ return 0;
+ }
+
+ return pv+1;
+
+}
void
icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
@@ -553,6 +645,49 @@ icalproperty_set_value (icalproperty* prop, icalvalue* value)
}
+void icalproperty_set_value_from_string(icalproperty* prop,const char* str,
+ const char* type)
+{
+ icalvalue *oval,*nval;
+ icalvalue_kind kind = ICAL_NO_VALUE;
+
+ icalerror_check_arg_rv( (prop!=0),"prop");
+ icalerror_check_arg_rv( (str!=0),"str");
+ icalerror_check_arg_rv( (type!=0),"type");
+
+ if(strcmp(type,"NO")==0){
+ /* Get the type from the value the property already has, if it exists */
+ oval = icalproperty_get_value(prop);
+ if(oval != 0){
+ /* Use the existing value kind */
+ kind = icalvalue_isa(oval);
+ } else {
+ /* Use the default kind for the property */
+ kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
+ }
+ } else {
+ /* Use the given kind string */
+ kind = icalvalue_string_to_kind(type);
+ }
+
+ if(kind == ICAL_NO_VALUE){
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return;
+ }
+
+ nval = icalvalue_new_from_string(kind, str);
+
+ if(nval == 0){
+ /* icalvalue_new_from_string sets errno */
+ assert(icalerrno != ICAL_NO_ERROR);
+ return;
+ }
+
+ icalproperty_set_value(prop,nval);
+
+
+}
+
icalvalue*
icalproperty_get_value (icalproperty* prop)
{
@@ -563,6 +698,19 @@ icalproperty_get_value (icalproperty* prop)
return p->value;
}
+const char* icalproperty_get_value_as_string(icalproperty* prop)
+{
+ icalvalue *value;
+
+ struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+ icalerror_check_arg_rz( (prop!=0),"prop");
+
+ value = impl->value;
+
+ return icalvalue_as_ical_string(value);
+}
+
void icalproperty_set_x_name(icalproperty* prop, char* name)
{
@@ -578,7 +726,7 @@ void icalproperty_set_x_name(icalproperty* prop, char* name)
impl->x_name = icalmemory_strdup(name);
if(impl->x_name == 0){
- icalerror_set_errno(ICAL_ALLOCATION_ERROR);
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
}
}
@@ -593,6 +741,45 @@ char* icalproperty_get_x_name(icalproperty* prop){
}
+/* From Jonathan Yue <jonathan.yue@cp.net> */
+char* icalproperty_get_name (icalproperty* prop)
+{
+
+ const char* property_name = 0;
+ size_t buf_size = 256;
+ char* buf = icalmemory_new_buffer(buf_size);
+ char* buf_ptr = buf;
+
+ 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;
+ } else {
+ property_name = icalproperty_kind_to_string(impl->kind);
+ }
+
+ if (property_name == 0 ) {
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return 0;
+
+ } else {
+ /* _append_string will automatically grow the buffer if
+ property_name is longer than the initial buffer size */
+ icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
+ }
+
+ /* Add the buffer to the temporary buffer ring -- the caller will
+ not have to free the memory. */
+ icalmemory_add_tmp_buffer(buf);
+
+ return buf;
+}
+
+
+
+
void icalproperty_set_parent(icalproperty* property,
icalcomponent* component)
{
@@ -607,10 +794,15 @@ icalcomponent* icalproperty_get_parent(icalproperty* property)
{
struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
- icalerror_check_arg_rv( (property!=0),"property");
+ icalerror_check_arg_rz( (property!=0),"property");
return impl->parent;
}
+
+
+
+
+
/* Everything below this line is machine generated. Do not edit. */
diff --git a/libical/src/libical/icalproperty.h b/libical/src/libical/icalproperty.h
new file mode 100644
index 0000000000..6f5f1bfaef
--- /dev/null
+++ b/libical/src/libical/icalproperty.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalproperty.h
+ CREATOR: eric 20 March 1999
+
+
+ $Id$
+ $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 ICALPROPERTY_H
+#define ICALPROPERTY_H
+
+#include <time.h>
+
+
+#include "icalderivedparameter.h"
+
+#include "icalvalue.h"
+#include "icalrecur.h"
+
+/* Actually in icalderivedproperty.h:
+ typedef void icalproperty; */
+
+#include "icalderivedproperty.h" /* To get icalproperty_kind enumerations */
+
+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_set_parameter_from_string(icalproperty* prop,
+ const char* name, const char* value);
+const char* icalproperty_get_parameter_as_string(icalproperty* prop,
+ const char* name);
+
+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);
+void icalproperty_set_value_from_string(icalproperty* prop,const char* value, const char* kind);
+
+icalvalue* icalproperty_get_value(icalproperty* prop);
+const char* icalproperty_get_value_as_string(icalproperty* prop);
+
+/* Deal with X properties */
+
+void icalproperty_set_x_name(icalproperty* prop, char* name);
+char* icalproperty_get_x_name(icalproperty* prop);
+
+/* Return the name of the property -- the type name converted to a
+ string, or the value of _get_x_name if the type is and X property */
+char* icalproperty_get_name (icalproperty* prop);
+
+icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
+
+/* Convert kinds to string and get default value type */
+
+icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);
+icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind);
+const char* icalproperty_kind_to_string(icalproperty_kind kind);
+icalproperty_kind icalproperty_string_to_kind(const char* string);
+
+icalproperty_method icalproperty_string_to_method(const char* str);
+const char* icalproperty_method_to_string(icalproperty_method method);
+
+
+const char* icalproperty_enum_to_string(int e);
+int icalproperty_string_to_enum(const char* str);
+
+const char* icalproperty_status_to_string(icalproperty_status);
+icalproperty_status icalproperty_string_to_status(const char* string);
+
+int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e);
+
+
+
+
+#endif /*ICALPROPERTY_H*/
diff --git a/libical/src/libical/icalproperty.h.in b/libical/src/libical/icalproperty.h.in
deleted file mode 100644
index be74b38d43..0000000000
--- a/libical/src/libical/icalproperty.h.in
+++ /dev/null
@@ -1,57 +0,0 @@
-/* -*- Mode: C -*-
- ======================================================================
- FILE: icalderivedproperties.{c,h}
- CREATOR: eric 09 May 1999
-
- $Id: icalproperty.h.in,v 1.1.1.2 2001/01/23 19:20:40 jpr 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/icaltime.c b/libical/src/libical/icaltime.c
index 37ae194bd0..d29833f03f 100644
--- a/libical/src/libical/icaltime.c
+++ b/libical/src/libical/icaltime.c
@@ -170,7 +170,7 @@ time_t icaltime_as_timet(struct icaltimetype tt)
stm.tm_isdst = -1;
if(tt.is_utc == 1 || tt.is_date == 1){
- char* old_tz = set_tz("UTC");
+ struct set_tz_save old_tz = set_tz("UTC");
t = mktime(&stm);
unset_tz(old_tz);
} else {
@@ -248,20 +248,19 @@ int icaltime_utc_offset(struct icaltimetype ictt, const char* tzid)
time_t tt = icaltime_as_timet(ictt);
time_t offset_tt;
struct tm gtm;
-
- char *tzstr = 0;
+ struct set_tz_save old_tz;
if(tzid != 0){
- tzstr = set_tz(tzid);
+ old_tz = set_tz(tzid);
}
-
+
/* Mis-interpret a UTC broken out time as local time */
gtm = *(gmtime(&tt));
gtm.tm_isdst = localtime(&tt)->tm_isdst;
offset_tt = mktime(&gtm);
if(tzid != 0){
- unset_tz(tzstr);
+ unset_tz(old_tz);
}
return tt-offset_tt;
diff --git a/libical/src/libical/icalvalue.c.in b/libical/src/libical/icalvalue.c
index 0bbf7cd934..e7054bb80d 100644
--- a/libical/src/libical/icalvalue.c.in
+++ b/libical/src/libical/icalvalue.c
@@ -3,7 +3,7 @@
FILE: icalvalue.c
CREATOR: eric 02 May 1999
- $Id: icalvalue.c.in,v 1.4 2001/02/05 19:43:57 jpr Exp $
+ $Id$
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
@@ -35,6 +35,7 @@
#include "icalmemory.h"
#include "icalparser.h"
#include "icalenums.h"
+#include "icalvalueimpl.h"
#include <stdlib.h> /* for malloc */
#include <stdio.h> /* for sprintf */
@@ -56,48 +57,6 @@ 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; /*this is the kind that is visible from the outside*/
-
- 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;
- struct icaltriggertype v_trigger;
- icalproperty_method v_method;
- icalproperty_status v_status;
-
- } data;
-};
struct icalvalue_impl* icalvalue_new_impl(icalvalue_kind kind){
@@ -114,6 +73,7 @@ struct icalvalue_impl* icalvalue_new_impl(icalvalue_kind kind){
v->kind = kind;
v->size = 0;
v->parent = 0;
+ v->x_value = 0;
memset(&(v->data),0,sizeof(v->data));
return v;
@@ -255,10 +215,31 @@ char* icalmemory_strdup_and_dequote(const char* str)
return out;
}
+icalvalue* icalvalue_new_enum(icalvalue_kind kind, int x_type, const char* str)
+{
+ int e = icalproperty_string_to_enum(str);
+ struct icalvalue_impl *value;
+
+ if(e != 0 && icalproperty_enum_belongs_to_property(
+ icalproperty_value_kind_to_kind(kind),e)) {
+
+ value = icalvalue_new_impl(kind);
+ value->data.v_enum = e;
+ } else {
+ /* Make it an X value */
+ value = icalvalue_new_impl(kind);
+ value->data.v_enum = x_type;
+ icalvalue_set_x(value,str);
+ }
+
+ return value;
+}
+
+
icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* str,icalproperty** error)
{
- icalvalue *value = 0;
+ struct icalvalue_impl *value = 0;
icalerror_check_arg_rz(str!=0,"str");
@@ -268,141 +249,95 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
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;
-
+ case ICAL_ATTACH_VALUE:
+ case ICAL_BINARY_VALUE:
+ case ICAL_BOOLEAN_VALUE:
+ {
+ /* HACK */
+ value = 0;
+
if (error != 0){
char temp[TMP_BUF_SIZE];
- sprintf(temp,"BOOLEAN Values are not implemented");
+ sprintf(temp,"%s Values are not implemented",
+ icalparameter_kind_to_string(kind));
*error = icalproperty_vanew_xlicerror(
- temp,
- icalparameter_new_xlicerrortype(
- ICAL_XLICERRORTYPE_VALUEPARSEERROR),
- 0);
+ temp,
+ icalparameter_new_xlicerrortype(
+ ICAL_XLICERRORTYPE_VALUEPARSEERROR),
+ 0);
}
-
- icalerror_warn("Parsing BOOLEAN values is unimplmeneted");
break;
}
-
- case ICAL_INTEGER_VALUE:
+
+
+ case ICAL_TRANSP_VALUE:
+ value = icalvalue_new_enum(kind, ICAL_TRANSP_X,str);
+ break;
+ case ICAL_METHOD_VALUE:
+ value = icalvalue_new_enum(kind, ICAL_METHOD_X,str);
+ break;
+ case ICAL_STATUS_VALUE:
+ value = icalvalue_new_enum(kind, ICAL_STATUS_X,str);
+ break;
+ case ICAL_ACTION_VALUE:
+ value = icalvalue_new_enum(kind, ICAL_ACTION_X,str);
+ break;
+ case ICAL_CLASS_VALUE:
+ value = icalvalue_new_enum(kind, ICAL_CLASS_X,str);
+ break;
+
+
+ case ICAL_INTEGER_VALUE:
{
value = icalvalue_new_integer(atoi(str));
break;
}
- case ICAL_FLOAT_VALUE:
- {
+ case ICAL_FLOAT_VALUE:
+ {
value = icalvalue_new_float(atof(str));
break;
}
-
- case ICAL_UTCOFFSET_VALUE:
+
+ case ICAL_UTCOFFSET_VALUE:
{
value = icalparser_parse_value(kind,str,(icalcomponent*)0);
break;
}
-
- case ICAL_TEXT_VALUE:
+
+ 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:
+
+
+ case ICAL_STRING_VALUE:
{
value = icalvalue_new_string(str);
break;
}
-
- case ICAL_CALADDRESS_VALUE:
+
+ case ICAL_CALADDRESS_VALUE:
{
value = icalvalue_new_caladdress(str);
break;
}
-
- case ICAL_URI_VALUE:
+
+ 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:
+ case ICAL_GEO_VALUE:
{
value = 0;
/* HACK */
-
+
if (error != 0){
char temp[TMP_BUF_SIZE];
sprintf(temp,"GEO Values are not implemented");
@@ -427,40 +362,57 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char*
}
case ICAL_TIME_VALUE:
- {
- struct icaltimetype tt;
- tt = icaltime_from_string(str);
- value = icalvalue_new_time(tt);
- break;
- }
case ICAL_DATE_VALUE:
+ case ICAL_DATETIME_VALUE:
+ case ICAL_DATETIMEDATE_VALUE:
{
struct icaltimetype tt;
tt = icaltime_from_string(str);
- value = icalvalue_new_date(tt);
+ if(!icaltime_is_null_time(tt)){
+ value = icalvalue_new_impl(kind);
+ value->data.v_time = tt;
+ }
break;
}
- case ICAL_DATETIME_VALUE:
+
+ case ICAL_DATETIMEPERIOD_VALUE:
{
struct icaltimetype tt;
- tt = icaltime_from_string(str);
- value = icalvalue_new_datetime(tt);
- break;
+ 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_period(p);
+ }
+
+ break;
}
- case ICAL_DATETIMEDATE_VALUE:
+
+ case ICAL_DURATION_VALUE:
{
- struct icaltimetype tt;
- tt = icaltime_from_string(str);
- value = icalvalue_new_datetimedate(tt);
+ struct icaldurationtype dur = icaldurationtype_from_string(str);
+
+ if(icaldurationtype_is_null_duration(dur)){
+ value = 0;
+ } else {
+ value = icalvalue_new_duration(dur);
+ }
+
break;
}
- case ICAL_DATETIMEPERIOD_VALUE:
- case ICAL_DURATION_VALUE:
case ICAL_PERIOD_VALUE:
{
- value = icalparser_parse_value(kind,str,error);
- break;
+ struct icalperiodtype p;
+ p = icalperiodtype_from_string(str);
+
+ if(!icalperiodtype_is_null_period(p)){
+ value = icalvalue_new_period(p);
+ }
+ break;
}
case ICAL_TRIGGER_VALUE:
@@ -531,6 +483,9 @@ icalvalue_free (icalvalue* value)
}
#endif
+ if(v->x_value != 0){
+ free(v->x_value);
+ }
switch (v->kind){
case ICAL_BINARY_VALUE:
@@ -782,8 +737,7 @@ char* icalvalue_attach_as_ical_string(icalvalue* value) {
}
-char* icalvalue_duration_as_ical_string(icalvalue* value)
-{
+char* icalvalue_duration_as_ical_string(icalvalue* value) {
struct icaldurationtype data;
@@ -791,7 +745,6 @@ char* icalvalue_duration_as_ical_string(icalvalue* value)
data = icalvalue_get_duration(value);
return icaldurationtype_as_ical_string(data);
-
}
void print_time_to_string(char* str, struct icaltimetype *data)
@@ -855,7 +808,7 @@ void print_datetime_to_string(char* str, struct icaltimetype *data)
}
-char* icalvalue_datetime_as_ical_string(icalvalue* value) {
+const char* icalvalue_datetime_as_ical_string(icalvalue* value) {
struct icaltimetype data;
char* str;
@@ -886,7 +839,7 @@ char* icalvalue_datetime_as_ical_string(icalvalue* value) {
}
-char* icalvalue_datetimedate_as_ical_string(icalvalue* value) {
+const char* icalvalue_datetimedate_as_ical_string(icalvalue* value) {
struct icaltimetype data;
icalerror_check_arg_rz( (value!=0),"value");
@@ -929,8 +882,7 @@ char* icalvalue_geo_as_ical_string(icalvalue* value) {
return str;
}
-char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
- struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
+const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
struct icaldatetimeperiodtype dtp = icalvalue_get_datetimeperiod(value);
icalerror_check_arg_rz( (value!=0),"value");
@@ -942,24 +894,21 @@ char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
}
}
-char* icalvalue_period_as_ical_string(icalvalue* value) {
+const char* icalvalue_period_as_ical_string(icalvalue* value) {
struct icalperiodtype data;
icalerror_check_arg_rz( (value!=0),"value");
data = icalvalue_get_period(value);
return icalperiodtype_as_ical_string(data);
+
}
-char* icalvalue_trigger_as_ical_string(icalvalue* value)
-{
+char* icalvalue_trigger_as_ical_string(icalvalue* value) {
struct icaltriggertype data;
- char* str;
icalerror_check_arg_rz( (value!=0),"value");
data = icalvalue_get_trigger(value);
-
- str = (char*)icalmemory_tmp_buffer(60);
if(!icaltime_is_null_time(data.time)){
return icaltime_as_ical_string(data.time);
@@ -982,64 +931,71 @@ icalvalue_as_ical_string (icalvalue* value)
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:
+ 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_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);
+ }
+
+ return icalproperty_enum_to_string(v->data.v_enum);
+
+ case ICAL_X_VALUE:
+ return icalmemory_tmp_copy(v->x_value);
+
+ case ICAL_NO_VALUE:
+ default:
{
return 0;
}
@@ -1234,176 +1190,6 @@ icalproperty* icalvalue_get_parent(icalvalue* value)
-/* Recur is a special case, so it is not auto generated. */
-icalvalue*
-icalvalue_new_recur (struct icalrecurrencetype v)
-{
- struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_RECUR_VALUE);
-
- icalvalue_set_recur((icalvalue*)impl,v);
-
- return (icalvalue*)impl;
-}
-
-void
-icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v)
-{
- struct icalvalue_impl* impl;
-
- icalerror_check_arg_rv( (value!=0),"value");
- icalerror_check_value_type(value, ICAL_RECUR_VALUE);
-
- impl = (struct icalvalue_impl*)value;
-
- if (impl->data.v_recur != 0){
- free(impl->data.v_recur);
- impl->data.v_recur = 0;
- }
-
- impl->data.v_recur = malloc(sizeof(struct icalrecurrencetype));
-
- if (impl->data.v_recur == 0){
- icalerror_set_errno(ICAL_ALLOCATION_ERROR);
- return;
- } else {
- memcpy(impl->data.v_recur, &v, sizeof(struct icalrecurrencetype));
- }
-
-}
-
-struct icalrecurrencetype
-icalvalue_get_recur(icalvalue* value)
-{
- icalerror_check_arg( (value!=0),"value");
- icalerror_check_value_type(value, ICAL_RECUR_VALUE);
-
- return *(((struct icalvalue_impl*)value)->data.v_recur);
-}
-
-
-
-
-icalvalue*
-icalvalue_new_trigger (struct icaltriggertype v)
-{
- struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TRIGGER_VALUE);
-
- icalvalue_set_trigger((icalvalue*)impl,v);
-
- return (icalvalue*)impl;
-}
-
-void
-icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v)
-{
- struct icalvalue_impl* impl;
-
- icalerror_check_arg_rv( (value!=0),"value");
-
- impl = (struct icalvalue_impl*)value;
-
- if(!icaltime_is_null_time(v.time)){
- icalvalue_set_datetime((icalvalue*)impl,v.time);
- impl->kind = ICAL_DATETIME_VALUE;
- } else {
- icalvalue_set_duration((icalvalue*)impl,v.duration);
- impl->kind = ICAL_DURATION_VALUE;
- }
-
-}
-
-struct icaltriggertype
-icalvalue_get_trigger(icalvalue* value)
-{
- struct icalvalue_impl *impl = (struct icalvalue_impl*)value;
- struct icaltriggertype tr;
-
- icalerror_check_arg( (value!=0),"value");
- icalerror_check_arg( (value!=0),"value");
-
- if(impl->kind == ICAL_DATETIME_VALUE){
- tr.duration = icaldurationtype_from_int(0);
- tr.time = impl->data.v_time;
- } else if(impl->kind == ICAL_DURATION_VALUE){
- tr.time = icaltime_null_time();
- tr.duration = impl->data.v_duration;
- } else {
- tr.duration = icaldurationtype_from_int(0);
- tr.time = icaltime_null_time();
- icalerror_set_errno(ICAL_BADARG_ERROR);
- }
-
- return tr;
-}
-
-/* DATE-TIME-PERIOD is a special case, and is not auto generated */
-
-icalvalue*
-icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v)
-{
- struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIMEPERIOD_VALUE);
-
- icalvalue_set_datetimeperiod((icalvalue*)impl,v);
-
- return (icalvalue*)impl;
-}
-
-void
-icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v)
-{
- struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
-
- icalerror_check_arg_rv( (value!=0),"value");
-
- icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
-
- if(!icaltime_is_null_time(v.time)){
- if(!icaltime_is_valid_time(v.time)){
- icalerror_set_errno(ICAL_BADARG_ERROR);
- return;
- }
- impl->kind = ICAL_DATETIME_VALUE;
- icalvalue_set_datetime(impl,v.time);
- } else if (!icalperiodtype_is_null_period(v.period)) {
- if(!icalperiodtype_is_valid_period(v.period)){
- icalerror_set_errno(ICAL_BADARG_ERROR);
- return;
- }
- impl->kind = ICAL_PERIOD_VALUE;
- icalvalue_set_period(impl,v.period);
- } else {
- icalerror_set_errno(ICAL_BADARG_ERROR);
- }
-}
-
-struct icaldatetimeperiodtype
-icalvalue_get_datetimeperiod(icalvalue* value)
-{
- struct icaldatetimeperiodtype dtp;
-
- struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
- icalerror_check_arg( (value!=0),"value");
- icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
-
- if(impl->kind == ICAL_DATETIME_VALUE){
- dtp.period = icalperiodtype_null_period();
- dtp.time = impl->data.v_time;
- } else if(impl->kind == ICAL_PERIOD_VALUE) {
- dtp.period = impl->data.v_period;
- dtp.time = icaltime_null_time();
- } else {
- dtp.period = icalperiodtype_null_period();
- dtp.time = icaltime_null_time();
- icalerror_set_errno(ICAL_BADARG_ERROR);
- }
-
- return dtp;
-}
-
-
-
-
-
/* The remaining interfaces are 'new', 'set' and 'get' for each of the value
types */
diff --git a/libical/src/libical/icalvalue.h.in b/libical/src/libical/icalvalue.h
index 90daa49f79..6983c23275 100644
--- a/libical/src/libical/icalvalue.h.in
+++ b/libical/src/libical/icalvalue.h
@@ -4,8 +4,8 @@
CREATOR: eric 20 March 1999
- $Id: icalvalue.h.in,v 1.1.1.3 2001/02/05 19:16:24 jpr Exp $
- $Locker: $
+ $Id$
+ $Locker$
@@ -33,8 +33,14 @@
#include "icalenums.h"
#include "icaltypes.h"
#include "icalrecur.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+#include "icalderivedproperty.h" /* For icalproperty_method, etc. */
+#include "icalderivedparameter.h"
+#include "icalderivedvalue.h"
-typedef void icalvalue;
+/* Defined in icalderivedvalue.h */
+/*typedef void icalvalue;*/
icalvalue* icalvalue_new(icalvalue_kind kind);
@@ -52,8 +58,7 @@ icalvalue_kind icalvalue_isa(icalvalue* value);
int icalvalue_isa_value(void*);
-icalparameter_xliccomparetype
-icalvalue_compare(icalvalue* a, icalvalue *b);
+icalparameter_xliccomparetype icalvalue_compare(icalvalue* a, icalvalue *b);
/* Special, non autogenerated value accessors */
@@ -71,4 +76,10 @@ void icalvalue_set_datetimeperiod(icalvalue* value,
struct icaldatetimeperiodtype v);
struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
-/* Everything below this line is machine generated. Do not edit. */
+/* Convert enumerations */
+
+icalvalue_kind icalvalue_string_to_kind(const char* str);
+const char* icalvalue_kind_to_string(icalvalue_kind kind);
+
+
+#endif /*ICALVALUE_H*/