NS_IMETHODIMP
calIcalComponent::AddProperty(calIIcalProperty * aProp)
{
NS_ENSURE_ARG_POINTER(aProp);
// We assume a calIcalProperty is passed in (else the cast wouldn't run and
// we are about to crash), so we assume that this ICS service code has created
// the property.
nsresult rv;
nsCOMPtr<calIIcalPropertyLibical> icalprop = do_QueryInterface(aProp, &rv);
NS_ENSURE_SUCCESS(rv, rv);
calIcalProperty * const ical = toIcalProperty(icalprop);
if (ical->mParent) {
ical->mProperty = icalproperty_new_clone(ical->mProperty);
}
ical->mParent = this;
icalcomponent_add_property(mComponent, ical->mProperty);
nsCOMPtr<calIDateTime> dt;
if (NS_SUCCEEDED(aProp->GetValueAsDatetime(getter_AddRefs(dt))) && dt) {
// make sure timezone definition will be included:
nsCOMPtr<calITimezone> tz;
if (NS_SUCCEEDED(dt->GetTimezone(getter_AddRefs(tz))) && tz) {
getParentVCalendarOrThis()->AddTimezoneReference(tz);
}
}
return NS_OK;
}
static icalcomponent *icalmessage_new_reply_base(icalcomponent *c,
const char *user, const char *msg)
{
icalproperty *attendee;
char tmp[45];
icalcomponent *reply =
icalcomponent_vanew(
ICAL_VCALENDAR_COMPONENT, icalproperty_new_method(ICAL_METHOD_REPLY),
icalcomponent_vanew(
ICAL_VEVENT_COMPONENT,
icalproperty_new_dtstamp(icaltime_from_timet_with_zone(time(0), 0, NULL)),
0),
0);
icalcomponent *inner = icalmessage_get_inner(reply);
icalerror_check_arg_rz(c, "c");
icalmessage_copy_properties(reply, c, ICAL_UID_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_ORGANIZER_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_RECURRENCEID_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_SUMMARY_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_SEQUENCE_PROPERTY);
icalcomponent_set_dtstamp(reply, icaltime_from_timet_with_zone(time(0), 0, NULL));
if (msg != 0) {
icalcomponent_add_property(inner, icalproperty_new_comment(msg));
}
/* Copy this user's attendee property */
attendee = icalmessage_find_attendee(c, user);
if (attendee == 0) {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
icalcomponent_free(reply);
return 0;
}
icalcomponent_add_property(inner, icalproperty_new_clone(attendee));
/* Add PRODID and VERSION */
icalcomponent_add_property(reply, icalproperty_new_version("2.0"));
snprintf(tmp, sizeof(tmp), "-//SoftwareStudio//NONSGML %s %s //EN", ICAL_PACKAGE, ICAL_VERSION);
icalcomponent_add_property(reply, icalproperty_new_prodid(tmp));
return reply;
}
void test_properties()
{
icalproperty *prop;
icalparameter *param;
icalvalue *value;
char *str;
icalproperty *clone;
/* Create a new property */
prop = icalproperty_vanew_comment(
"Another Comment",
icalparameter_new_cn("A Common Name 1"),
icalparameter_new_cn("A Common Name 2"),
icalparameter_new_cn("A Common Name 3"),
icalparameter_new_cn("A Common Name 4"),
0);
/* Iterate through all of the parameters in the property */
for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
printf("Prop parameter: %s\n",icalparameter_get_cn(param));
}
/* Get a string representation of the property's value */
printf("Prop value: %s\n",icalproperty_get_comment(prop));
/* Spit out the property in its RFC 5545 representation */
str = icalproperty_as_ical_string_r(prop);
printf("As iCAL string:\n %s\n", str);
free(str);
/* Make a copy of the property. Caller owns the memory */
clone = icalproperty_new_clone(prop);
/* Get a reference to the value within the clone property */
value = icalproperty_get_value(clone);
str = icalvalue_as_ical_string_r(value);
printf("Value: %s", str);
free(str);
/* Free the original and the clone */
icalproperty_free(clone);
icalproperty_free(prop);
}
static void icalmessage_copy_properties(icalcomponent *to, icalcomponent *from,
icalproperty_kind kind)
{
icalcomponent *to_inner = icalmessage_get_inner(to);
icalcomponent *from_inner = icalmessage_get_inner(from);
if (to_inner == 0 && from_inner == 0) {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return;
}
if (!icalcomponent_get_first_property(from_inner, kind)) {
return;
}
icalcomponent_add_property(
to_inner,
icalproperty_new_clone(icalcomponent_get_first_property(from_inner, kind)));
}
icalcomponent *icalmessage_new_error_reply(icalcomponent *c,
const char *user,
const char *msg,
const char *debug, icalrequeststatus code)
{
icalcomponent *reply;
icalcomponent *inner, *cinner;
struct icalreqstattype rs;
icalerror_check_arg_rz(c, "c");
memset(&rs, 0, sizeof(struct icalreqstattype));
reply = icalmessage_new_reply_base(c, user, msg);
inner = icalmessage_get_inner(reply);
cinner = icalmessage_get_inner(c);
if (reply == 0) {
return 0;
}
if (code != ICAL_UNKNOWN_STATUS) {
rs.code = code;
rs.debug = debug;
icalcomponent_add_property(inner, icalproperty_new_requeststatus(rs));
} else { /* code == ICAL_UNKNOWN_STATUS */
/* Copy all of the request status properties */
icalproperty *p;
for (p = icalcomponent_get_first_property(cinner, ICAL_REQUESTSTATUS_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(cinner, ICAL_REQUESTSTATUS_PROPERTY)) {
icalcomponent_add_property(inner, icalproperty_new_clone(p));
}
}
return reply;
}
static void ical2exchange_get_properties(struct ical2exchange *ical2exchange, icalcomponent *vevent){
icalproperty *icalProp = NULL;
icalproperty *prop = NULL;
const char *xname;
enum icalproperty_kind propType;
icalProp=icalcomponent_get_first_property(vevent, ICAL_ANY_PROPERTY);
while(icalProp!=0){
propType=icalproperty_isa(icalProp);
switch (propType){
case ICAL_ATTACH_PROPERTY:
if(!ical2exchange->attachEvent){
ical2exchange->attachEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
icalcomponent_add_property(ical2exchange->attachEvent, prop);
break;
case ICAL_ATTENDEE_PROPERTY:
if(!ical2exchange->attendeeEvent){
ical2exchange->attendeeEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
icalcomponent_add_property(ical2exchange->attendeeEvent, prop);
break;
case ICAL_CATEGORIES_PROPERTY:
if(!ical2exchange->categoriesEvent){
ical2exchange->categoriesEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
icalcomponent_add_property(ical2exchange->categoriesEvent, prop);
break;
case ICAL_CLASS_PROPERTY:
ical2exchange->classProp=icalProp;
break;
case ICAL_COMMENT_PROPERTY:
ical2exchange->commentProp=icalProp;
break;
case ICAL_CONTACT_PROPERTY:
if(!ical2exchange->contactEvent){
ical2exchange->contactEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
icalcomponent_add_property(ical2exchange->contactEvent, prop);
break;
case ICAL_CREATED_PROPERTY:
break;
case ICAL_DESCRIPTION_PROPERTY:
ical2exchange->descriptionProp=icalProp;
break;
case ICAL_DTEND_PROPERTY:
ical2exchange->dtendProp=icalProp;
break;
case ICAL_DTSTAMP_PROPERTY:
ical2exchange->dtstampProp=icalProp;
break;
case ICAL_DTSTART_PROPERTY:
ical2exchange->dtstartProp=icalProp;
break;
case ICAL_DURATION_PROPERTY:
ical2exchange->durationProp=icalProp;
break;
case ICAL_EXDATE_PROPERTY:
if(!ical2exchange->exdateEvent){
ical2exchange->exdateEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
ical2exchange->exdateCount ++;
icalcomponent_add_property(ical2exchange->exdateEvent, prop);
break;
case ICAL_LASTMODIFIED_PROPERTY:
break;
case ICAL_LOCATION_PROPERTY:
ical2exchange->locationProp=icalProp;
break;
case ICAL_ORGANIZER_PROPERTY:
//TODO: figure out how to MS-OXOABK
ical2exchange->organizerProp=icalProp;
break;
case ICAL_PRIORITY_PROPERTY:
ical2exchange->priorityProp=icalProp;
break;
case ICAL_RDATE_PROPERTY:
if(!ical2exchange->rdateEvent){
ical2exchange->rdateEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
ical2exchange->rdateCount ++;
icalcomponent_add_property(ical2exchange->rdateEvent, prop);
break;
case ICAL_RECURRENCEID_PROPERTY:
ical2exchange->recurrenceidProp=icalProp;
break;
case ICAL_RESOURCES_PROPERTY:
if(!ical2exchange->resourcesEvent){
ical2exchange->resourcesEvent=icalcomponent_new_vevent();
}
prop = icalproperty_new_clone(icalProp);
icalcomponent_add_property(ical2exchange->resourcesEvent, prop);
break;
case ICAL_RRULE_PROPERTY:
ical2exchange->rruleProp=icalProp;
break;
case ICAL_SEQUENCE_PROPERTY:
ical2exchange->sequenceProp=icalProp;
break;
case ICAL_STATUS_PROPERTY:
ical2exchange->statusProp=icalProp;
break;
case ICAL_SUMMARY_PROPERTY:
ical2exchange->summaryProp=icalProp;
break;
case ICAL_TRANSP_PROPERTY:
ical2exchange->transpProp=icalProp;
break;
case ICAL_UID_PROPERTY:
//TODO
ical2exchange->uidProp=icalProp;
break;
case ICAL_X_PROPERTY:
xname=icalproperty_get_x_name(icalProp);
if(!strcmp(xname,"X-MICROSOFT-CDO-BUSYSTATUS")){
ical2exchange->x_busystatusProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-MSNCALENDAR-BUSYSTATUS")){
ical2exchange->x_busystatusProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-APPT-SEQUENCE")){
ical2exchange->x_sequenceProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-IMPORTANCE")){
ical2exchange->x_importanceProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-MSNCALENDAR-IMPORTANCE")){
ical2exchange->x_importanceProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-INTENDEDSTATUS")){
ical2exchange->x_intendedProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-MSNCALENDAR-INTENDEDSTATUS")){
ical2exchange->x_intendedProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-OWNERAPPTID")){
ical2exchange->x_ownerapptidProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-ATTENDEE-CRITICAL-CHANGE")){
ical2exchange->x_attendeecriticalchangeProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-OWNER-CRITICAL-CHANGE")){
ical2exchange->x_ownercriticalchangeProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-CDO-REPLYTIME")){
ical2exchange->x_replytimeProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-DISALLOW-COUNTER")){
ical2exchange->x_disallowcounterProp=icalProp;
} else if(!strcmp(xname,"X-MICROSOFT-ISDRAFT")){
ical2exchange->x_isdraftProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-ALLOWEXTERNCHECK")){
ical2exchange->x_allowexterncheckProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-APPTLASTSEQUENCE")){
ical2exchange->x_apptlastsequenceProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-APPTSEQTIME")){
ical2exchange->x_apptseqtimeProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-AUTOFILLLOCATION")){
ical2exchange->x_autofilllocationProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-AUTOSTARTCHECK")){
ical2exchange->x_autostartcheckProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-CONFCHECK")){
ical2exchange->x_confcheckProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-COLLABORATEDDOC")){
ical2exchange->x_collaborateddocProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-CONFTYPE")){
ical2exchange->x_conftypeProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-MWSURL")){
ical2exchange->x_mwsurlProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-NETSHOWURL")){
ical2exchange->x_netshowurlProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-ONLINEPASSWORD")){
ical2exchange->x_onlinepasswordProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-ORGALIAS")){
ical2exchange->x_orgaliasProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-ORIGINALEND")){
ical2exchange->x_originalendProp=icalProp;
} else if(!strcmp(xname,"X-MS-OLK-ORIGINALSTART")){
ical2exchange->x_originalstartProp=icalProp;
}
break;
default:
break;
}
icalProp=icalcomponent_get_next_property(vevent, ICAL_ANY_PROPERTY);
}
ical2exchange->valarmEvent = icalcomponent_get_first_component(vevent,ICAL_VALARM_COMPONENT);
}
icalcomponent* icalparser_add_line(icalparser* parser,
char* line)
{
char *str;
char *end;
int vcount = 0;
icalproperty *prop;
icalproperty_kind prop_kind;
icalvalue *value;
icalvalue_kind value_kind = ICAL_NO_VALUE;
icalerror_check_arg_rz((parser != 0),"parser");
if (line == 0)
{
parser->state = ICALPARSER_ERROR;
return 0;
}
if(line_is_blank(line) == 1){
return 0;
}
/* Begin by getting the property name at the start of the line. The
property name may end up being "BEGIN" or "END" in which case it
is not really a property, but the marker for the start or end of
a component */
end = 0;
str = parser_get_prop_name(line, &end);
if (str == 0 || *str == '\0' ){
/* Could not get a property name */
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if (tail){
insert_error(tail,line,
"Got a data line, but could not find a property name or component begin tag",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle begin and end of components
**********************************************************************/
/* If the property name is BEGIN or END, we are actually
starting or ending a new component */
if(strcasecmp(str,"BEGIN") == 0){
icalcomponent *c;
icalcomponent_kind comp_kind;
icalmemory_free_buffer(str);
str = NULL;
parser->level++;
str = parser_get_next_value(end,&end, value_kind);
comp_kind = icalenum_string_to_component_kind(str);
if (comp_kind == ICAL_NO_COMPONENT){
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
insert_error(c,str,"Parse error in component name",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
c = icalcomponent_new(comp_kind);
if (c == 0){
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
insert_error(c,str,"Parse error in component name",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
pvl_push(parser->components,c);
parser->state = ICALPARSER_BEGIN_COMP;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else if (strcasecmp(str,"END") == 0 ) {
icalcomponent* tail;
icalmemory_free_buffer(str);
str = NULL;
parser->level--;
str = parser_get_next_value(end,&end, value_kind);
/* Pop last component off of list and add it to the second-to-last*/
parser->root_component = pvl_pop(parser->components);
tail = pvl_data(pvl_tail(parser->components));
if(tail != 0){
icalcomponent_add_component(tail,parser->root_component);
}
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
/* Return the component if we are back to the 0th level */
if (parser->level == 0){
icalcomponent *rtrn;
if(pvl_count(parser->components) != 0){
/* There are still components on the stack -- this means
that one of them did not have a proper "END" */
pvl_push(parser->components,parser->root_component);
icalparser_clean(parser); /* may reset parser->root_component*/
}
assert(pvl_count(parser->components) == 0);
parser->state = ICALPARSER_SUCCESS;
rtrn = parser->root_component;
parser->root_component = 0;
return rtrn;
} else {
parser->state = ICALPARSER_END_COMP;
return 0;
}
}
/* There is no point in continuing if we have not seen a
component yet */
if(pvl_data(pvl_tail(parser->components)) == 0){
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle property names
**********************************************************************/
/* At this point, the property name really is a property name,
(Not a component name) so make a new property and add it to
the component */
prop_kind = icalproperty_string_to_kind(str);
prop = icalproperty_new(prop_kind);
if (prop != 0){
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if(prop_kind==ICAL_X_PROPERTY){
icalproperty_set_x_name(prop,str);
}
icalcomponent_add_property(tail, prop);
/* Set the value kind for the default for this type of
property. This may be re-set by a VALUE parameter */
value_kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
} else {
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
insert_error(tail,str,"Parse error in property name",
ICAL_XLICERRORTYPE_PROPERTYPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
icalmemory_free_buffer(str);
str = NULL;
/**********************************************************************
* Handle parameter values
**********************************************************************/
/* Now, add any parameters to the last property */
while(1) {
if (*(end-1) == ':'){
/* if the last separator was a ":" and the value is a
URL, icalparser_get_next_parameter will find the
':' in the URL, so better break now. */
break;
}
str = parser_get_next_parameter(end,&end);
strstriplt(str);
if (str != 0){
char* name = 0;
char* pvalue = 0;
char *buf_value = NULL;
icalparameter *param = 0;
icalparameter_kind kind;
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
name = parser_get_param_name(str,&pvalue,&buf_value);
if (name == 0){
/* 'tail' defined above */
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
break;
}
kind = icalparameter_string_to_kind(name);
if(kind == ICAL_X_PARAMETER){
param = icalparameter_new(ICAL_X_PARAMETER);
if(param != 0){
icalparameter_set_xname(param,name);
icalparameter_set_xvalue(param,pvalue);
}
icalmemory_free_buffer(buf_value);
buf_value = NULL;
} else if (kind != ICAL_NO_PARAMETER){
param = icalparameter_new_from_value_string(kind,pvalue);
icalmemory_free_buffer(buf_value);
buf_value = NULL;
} else {
/* Error. Failed to parse the parameter*/
/* 'tail' defined above */
/* Change for mozilla */
/* have the option of being flexible towards unsupported parameters */
#ifndef ICAL_ERRORS_ARE_FATAL
continue;
#endif
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
/* if (pvalue) {
free(pvalue);
pvalue = 0;
} */
if (name) {
free(name);
name = 0;
}
return 0;
}
/* if (pvalue) {
free(pvalue);
pvalue = 0;
} */
if (name) {
free(name);
name = 0;
}
if (param == 0){
/* 'tail' defined above */
insert_error(tail,str,"Cant parse parameter value",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(buf_value);
buf_value = NULL;
icalmemory_free_buffer(name);
name = NULL;
icalmemory_free_buffer(str);
str = NULL;
continue;
}
/* If it is a VALUE parameter, set the kind of value*/
if (icalparameter_isa(param)==ICAL_VALUE_PARAMETER){
value_kind = (icalvalue_kind)
icalparameter_value_to_value_kind(
icalparameter_get_value(param)
);
if (value_kind == ICAL_NO_VALUE){
/* Ooops, could not parse the value of the
parameter ( it was not one of the defined
values ), so reset the value_kind */
insert_error(
tail, str,
"Got a VALUE parameter with an unknown type",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
icalparameter_free(param);
value_kind =
icalproperty_kind_to_value_kind(
icalproperty_isa(prop));
icalparameter_free(param);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(name);
name = NULL;
icalmemory_free_buffer(str);
str = NULL;
continue;
}
}
icalmemory_free_buffer(name);
name = NULL;
/* Everything is OK, so add the parameter */
icalproperty_add_parameter(prop,param);
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
} else { /* if ( str != 0) */
/* If we did not get a param string, go on to looking for a value */
if (str != NULL) {
icalmemory_free_buffer(str);
str = NULL;
}
break;
} /* if ( str != 0) */
} /* while(1) */
/**********************************************************************
* Handle values
**********************************************************************/
/* Look for values. If there are ',' characters in the values,
then there are multiple values, so clone the current
parameter and add one part of the value to each clone */
vcount=0;
while(1) {
/* Only some properies can have multiple values. This list was taken
from rfc2445. Also added the x-properties, because the spec actually
says that commas should be escaped. For x-properties, other apps may
depend on that behaviour
*/
switch (prop_kind) {
case ICAL_X_PROPERTY:
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
/* Referring to RFC 2445, section 4.8.5.3 and section 4.8.5.1:
RDATE and EXDATE can specify a list of dates/date-times/periods.
*/
case ICAL_RDATE_PROPERTY:
case ICAL_EXDATE_PROPERTY:
/* Referring to RFC 2445, section 4.8.2.6 Free/Busy Time:
The "FREEBUSY" property can specify more than one value, separated by
the COMMA character (US-ASCII decimal 44).
*/
case ICAL_FREEBUSY_PROPERTY:
str = parser_get_next_value(end,&end, value_kind);
strstriplt (str);
break;
default:
str = icalparser_get_value(end, &end, value_kind);
strstriplt (str);
break;
}
if (str != 0){
if (vcount > 0){
/* Actually, only clone after the second value */
icalproperty* clone = icalproperty_new_clone(prop);
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
icalcomponent_add_property(tail, clone);
prop = clone;
tail = 0;
}
value = icalvalue_new_from_string(value_kind, str);
/* Don't add properties without value */
if (value == 0){
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
snprintf(temp,sizeof(temp),"Can't parse as %s value in %s property. Removing entire property",
icalvalue_kind_to_string(value_kind),
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail,prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else {
vcount++;
icalproperty_set_value(prop, value);
}
icalmemory_free_buffer(str);
str = NULL;
} else {
if (str != NULL) {
icalmemory_free_buffer(str);
str = NULL;
}
if (vcount == 0){
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
snprintf(temp,sizeof(temp),"No value for %s property. Removing entire property",
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail,prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
return 0;
} else {
break;
}
}
}
/****************************************************************
* End of component parsing.
*****************************************************************/
if (pvl_data(pvl_tail(parser->components)) == 0 &&
parser->level == 0){
/* HACK. Does this clause ever get executed? */
parser->state = ICALPARSER_SUCCESS;
assert(0);
return parser->root_component;
} else {
parser->state = ICALPARSER_IN_PROGRESS;
return 0;
}
}
