summaryrefslogtreecommitdiffabout
path: root/libkcal
authorzautrix <zautrix>2004-06-29 11:59:46 (UTC)
committer zautrix <zautrix>2004-06-29 11:59:46 (UTC)
commitda43dbdc6c82453228f34766fc74585615cba938 (patch) (side-by-side diff)
tree16576932cea08bf117b2d0320b0d5f66ee8ad093 /libkcal
parent627489ea2669d3997676bc3cee0f5d0d0c16c4d4 (diff)
downloadkdepimpi-da43dbdc6c82453228f34766fc74585615cba938.zip
kdepimpi-da43dbdc6c82453228f34766fc74585615cba938.tar.gz
kdepimpi-da43dbdc6c82453228f34766fc74585615cba938.tar.bz2
New lib ical.Some minor changes as well.
Diffstat (limited to 'libkcal') (more/less context) (ignore whitespace changes)
-rw-r--r--libkcal/calendar.h1
-rw-r--r--libkcal/calendarlocal.cpp31
-rw-r--r--libkcal/calendarlocal.h1
-rw-r--r--libkcal/icalformat.cpp8
-rw-r--r--libkcal/icalformatimpl.cpp79
-rw-r--r--libkcal/icalformatimpl.h2
-rw-r--r--libkcal/vcalformat.cpp22
-rw-r--r--libkcal/versit/port.h109
-rw-r--r--libkcal/versit/vcc.c1817
-rw-r--r--libkcal/versit/vcc.h12
-rw-r--r--libkcal/versit/vobject.c363
-rw-r--r--libkcal/versit/vobject.h173
12 files changed, 1415 insertions, 1203 deletions
diff --git a/libkcal/calendar.h b/libkcal/calendar.h
index 7a85e74..7d23619 100644
--- a/libkcal/calendar.h
+++ b/libkcal/calendar.h
@@ -139,32 +139,33 @@ public:
Return filtered list of all incidences of this calendar.
*/
virtual QPtrList<Incidence> incidences();
/**
Return unfiltered list of all incidences of this calendar.
*/
virtual QPtrList<Incidence> rawIncidences();
/**
Adds a Event to this calendar object.
@param anEvent a pointer to the event to add
@return true on success, false on error.
*/
virtual bool addEventNoDup( Event *event ) = 0;
+ virtual bool addAnniversaryNoDup( Event *event ) = 0;
virtual bool addEvent( Event *anEvent ) = 0;
/**
Delete event from calendar.
*/
virtual void deleteEvent( Event * ) = 0;
/**
Retrieves an event on the basis of the unique string ID.
*/
virtual Event *event( const QString &UniqueStr ) = 0;
virtual Event *event( int ) = 0;
/**
Builds and then returns a list of all events that match for the
date specified. useful for dayView, etc. etc.
The calendar filter is applied.
*/
QPtrList<Event> events( const QDate &date, bool sorted = false);
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index 8ff8b14..3c572f0 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -83,32 +83,63 @@ bool CalendarLocal::save( const QString &fileName, CalFormat *format )
void CalendarLocal::close()
{
mEventList.setAutoDelete( true );
mTodoList.setAutoDelete( true );
mJournalList.setAutoDelete( false );
mEventList.clear();
mTodoList.clear();
mJournalList.clear();
mEventList.setAutoDelete( false );
mTodoList.setAutoDelete( false );
mJournalList.setAutoDelete( false );
setModified( false );
}
+
+bool CalendarLocal::addAnniversaryNoDup( Event *event )
+{
+ QString cat;
+ bool isBirthday = true;
+ if( event->categoriesStr() == i18n( "Anniversary" ) ) {
+ isBirthday = false;
+ cat = i18n( "Anniversary" );
+ } else if( event->categoriesStr() == i18n( "Birthday" ) ) {
+ isBirthday = true;
+ cat = i18n( "Birthday" );
+ } else {
+ qDebug("addAnniversaryNoDup called without fitting category! ");
+ return false;
+ }
+ Event * eve;
+ for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
+ if ( !(eve->categories().contains( cat ) ))
+ continue;
+ // now we have an event with fitting category
+ if ( eve->dtStart().date() != event->dtStart().date() )
+ continue;
+ // now we have an event with fitting category+date
+ if ( eve->summary() != event->summary() )
+ continue;
+ // now we have an event with fitting category+date+summary
+ return false;
+ }
+ return addEvent( event );
+
+}
bool CalendarLocal::addEventNoDup( Event *event )
{
Event * eve;
for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
if ( *eve == *event ) {
//qDebug("CalendarLocal::Duplicate event found! Not inserted! ");
return false;
}
}
return addEvent( event );
}
bool CalendarLocal::addEvent( Event *event )
{
insertEvent( event );
diff --git a/libkcal/calendarlocal.h b/libkcal/calendarlocal.h
index a17cf11..a2e50e3 100644
--- a/libkcal/calendarlocal.h
+++ b/libkcal/calendarlocal.h
@@ -56,32 +56,33 @@ class CalendarLocal : public Calendar
CalendarLocal takes ownership of the CalFormat object.
@return true, if successfull, false on error.
@param fileName the name of the file
*/
bool save( const QString &fileName, CalFormat *format = 0 );
/**
Clears out the current calendar, freeing all used memory etc. etc.
*/
void close();
void save() {}
/**
Add Event to calendar.
*/
+ bool addAnniversaryNoDup( Event *event );
bool addEventNoDup( Event *event );
bool addEvent( Event *event );
/**
Deletes an event from this calendar.
*/
void deleteEvent( Event *event );
/**
Retrieves an event on the basis of the unique string ID.
*/
Event *event( const QString &uid );
/**
Return unfiltered list of all events in calendar.
*/
QPtrList<Event> rawEvents();
diff --git a/libkcal/icalformat.cpp b/libkcal/icalformat.cpp
index 5893db5..f2e7dfc 100644
--- a/libkcal/icalformat.cpp
+++ b/libkcal/icalformat.cpp
@@ -404,58 +404,60 @@ ScheduleMessage *ICalFormat::parseScheduleMessage( Calendar *cal,
Incidence *existingIncidence = cal->event(incidence->uid());
if (existingIncidence) {
// TODO: check, if cast is required, or if it can be done by virtual funcs.
if (existingIncidence->type() == "Todo") {
Todo *todo = static_cast<Todo *>(existingIncidence);
icalcomponent_add_component(calendarComponent,
mImpl->writeTodo(todo));
}
if (existingIncidence->type() == "Event") {
Event *event = static_cast<Event *>(existingIncidence);
icalcomponent_add_component(calendarComponent,
mImpl->writeEvent(event));
}
} else {
calendarComponent = 0;
}
-
+ qDebug("icalclassify commented out ");
+ ScheduleMessage::Status status;
+#if 0
icalclass result = icalclassify(message,calendarComponent,(char *)"");
- ScheduleMessage::Status status;
switch (result) {
case ICAL_PUBLISH_NEW_CLASS:
status = ScheduleMessage::PublishNew;
break;
case ICAL_OBSOLETE_CLASS:
status = ScheduleMessage::Obsolete;
break;
case ICAL_REQUEST_NEW_CLASS:
status = ScheduleMessage::RequestNew;
break;
case ICAL_REQUEST_UPDATE_CLASS:
status = ScheduleMessage::RequestUpdate;
break;
case ICAL_UNKNOWN_CLASS:
default:
status = ScheduleMessage::Unknown;
break;
}
-
+#endif
+ status = ScheduleMessage::RequestUpdate;
return new ScheduleMessage(incidence,method,status);
}
void ICalFormat::setTimeZone( const QString &id, bool utc )
{
mTimeZoneId = id;
mUtc = utc;
tzOffsetMin = KGlobal::locale()->timezoneOffset(mTimeZoneId);
//qDebug("ICalFormat::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(), tzOffsetMin);
}
QString ICalFormat::timeZoneId() const
diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp
index e5c27a0..32a1337 100644
--- a/libkcal/icalformatimpl.cpp
+++ b/libkcal/icalformatimpl.cpp
@@ -177,36 +177,36 @@ icalcomponent *ICalFormatImpl::writeEvent(Event *event)
for ( QStringList::Iterator it = tmpStrList.begin();
it != tmpStrList.end();
++it )
addPropValue(vevent, VCAttachProp, (*it).utf8());
// resources
tmpStrList = anEvent->resources();
tmpStr = tmpStrList.join(";");
if (!tmpStr.isEmpty())
addPropValue(vevent, VCResourcesProp, tmpStr.utf8());
#endif
// Transparency
switch( event->transparency() ) {
case Event::Transparent:
- icalcomponent_add_property(vevent, icalproperty_new_transp("TRANSPARENT"));
+ icalcomponent_add_property(vevent, icalproperty_new_transp(ICAL_TRANSP_TRANSPARENT));
break;
case Event::Opaque:
- icalcomponent_add_property(vevent, icalproperty_new_transp("OPAQUE"));
+ icalcomponent_add_property(vevent, icalproperty_new_transp(ICAL_TRANSP_OPAQUE));
break;
}
return vevent;
}
icalcomponent *ICalFormatImpl::writeFreeBusy(FreeBusy *freebusy,
Scheduler::Method method)
{
#if QT_VERSION >= 300
kdDebug(5800) << "icalformatimpl: writeFreeBusy: startDate: "
<< freebusy->dtStart().toString("ddd MMMM d yyyy: h:m:s ap") << " End Date: "
<< freebusy->dtEnd().toString("ddd MMMM d yyyy: h:m:s ap") << endl;
#endif
icalcomponent *vfreebusy = icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
@@ -309,46 +309,47 @@ void ICalFormatImpl::writeIncidence(icalcomponent *parent,Incidence *incidence)
if (!incidence->summary().isEmpty()) {
icalcomponent_add_property(parent,icalproperty_new_summary(
incidence->summary().utf8()));
}
// location
if (!incidence->location().isEmpty()) {
icalcomponent_add_property(parent,icalproperty_new_location(
incidence->location().utf8()));
}
// TODO:
// status
// addPropValue(parent, VCStatusProp, incidence->getStatusStr().utf8());
// secrecy
- const char *classStr;
+ enum icalproperty_class classInt;
switch (incidence->secrecy()) {
case Incidence::SecrecyPublic:
- classStr = "PUBLIC";
+ classInt = ICAL_CLASS_PUBLIC;
break;
case Incidence::SecrecyConfidential:
- classStr = "CONFIDENTIAL";
+ classInt = ICAL_CLASS_CONFIDENTIAL;
break;
case Incidence::SecrecyPrivate:
+ classInt =ICAL_CLASS_PRIVATE ;
default:
- classStr = "PRIVATE";
+ classInt =ICAL_CLASS_PRIVATE ;
break;
}
- icalcomponent_add_property(parent,icalproperty_new_class(classStr));
+ icalcomponent_add_property(parent,icalproperty_new_class(classInt));
// priority
icalcomponent_add_property(parent,icalproperty_new_priority(
incidence->priority()));
// categories
QStringList categories = incidence->categories();
QStringList::Iterator it;
for(it = categories.begin(); it != categories.end(); ++it ) {
icalcomponent_add_property(parent,icalproperty_new_categories((*it).utf8()));
}
// TODO: Ensure correct concatenation of categories properties.
/*
// categories
tmpStrList = incidence->getCategories();
@@ -508,40 +509,45 @@ icalproperty *ICalFormatImpl::writeAttendee(Attendee *attendee)
role = ICAL_ROLE_NONPARTICIPANT;
break;
}
icalproperty_add_parameter(p,icalparameter_new_role(role));
if (!attendee->uid().isEmpty()) {
icalparameter* icalparameter_uid = icalparameter_new_x(attendee->uid().utf8());
icalparameter_set_xname(icalparameter_uid,"X-UID");
icalproperty_add_parameter(p,icalparameter_uid);
}
return p;
}
icalproperty *ICalFormatImpl::writeAttachment(Attachment *att)
{
- icalattachtype* attach = icalattachtype_new();
+#if 0
+ icalattachtype* attach = icalattachtype_new();
if (att->isURI())
icalattachtype_set_url(attach, att->uri().utf8().data());
else
icalattachtype_set_base64(attach, att->data(), 0);
-
+#endif
+ icalattach *attach;
+ if (att->isURI())
+ attach = icalattach_new_from_url( att->uri().utf8().data());
+ else
+ attach = icalattach_new_from_data ( (unsigned char *)att->data(), 0, 0);
icalproperty *p = icalproperty_new_attach(attach);
-
if (!att->mimeType().isEmpty())
icalproperty_add_parameter(p,icalparameter_new_fmttype(att->mimeType().utf8().data()));
if (att->isBinary()) {
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY));
icalproperty_add_parameter(p,icalparameter_new_encoding(ICAL_ENCODING_BASE64));
}
return p;
}
icalproperty *ICalFormatImpl::writeRecurrenceRule(Recurrence *recur)
{
// kdDebug(5800) << "ICalFormatImpl::writeRecurrenceRule()" << endl;
icalrecurrencetype r;
@@ -673,73 +679,67 @@ icalproperty *ICalFormatImpl::writeRecurrenceRule(Recurrence *recur)
const char *str = icalrecurrencetype_as_string(&r);
if (str) {
kdDebug(5800) << " String: " << str << endl;
} else {
kdDebug(5800) << " No String" << endl;
}
#endif
return icalproperty_new_rrule(r);
}
icalcomponent *ICalFormatImpl::writeAlarm(Alarm *alarm)
{
icalcomponent *a = icalcomponent_new(ICAL_VALARM_COMPONENT);
icalproperty_action action;
- icalattachtype *attach = 0;
+ icalattach *attach = 0;
switch (alarm->type()) {
case Alarm::Procedure:
action = ICAL_ACTION_PROCEDURE;
- attach = icalattachtype_new();
- icalattachtype_set_url(attach,QFile::encodeName(alarm->programFile()).data());
+ attach = icalattach_new_from_url( QFile::encodeName(alarm->programFile()).data() );
icalcomponent_add_property(a,icalproperty_new_attach(attach));
- icalattachtype_free(attach);
if (!alarm->programArguments().isEmpty()) {
icalcomponent_add_property(a,icalproperty_new_description(alarm->programArguments().utf8()));
}
break;
case Alarm::Audio:
action = ICAL_ACTION_AUDIO;
if (!alarm->audioFile().isEmpty()) {
- attach = icalattachtype_new();
- icalattachtype_set_url(attach,QFile::encodeName( alarm->audioFile() ).data());
+ attach = icalattach_new_from_url(QFile::encodeName( alarm->audioFile() ).data());
icalcomponent_add_property(a,icalproperty_new_attach(attach));
- icalattachtype_free(attach);
}
break;
case Alarm::Email: {
action = ICAL_ACTION_EMAIL;
QValueList<Person> addresses = alarm->mailAddresses();
for (QValueList<Person>::Iterator ad = addresses.begin(); ad != addresses.end(); ++ad) {
icalproperty *p = icalproperty_new_attendee("MAILTO:" + (*ad).email().utf8());
if (!(*ad).name().isEmpty()) {
icalproperty_add_parameter(p,icalparameter_new_cn((*ad).name().utf8()));
}
icalcomponent_add_property(a,p);
}
icalcomponent_add_property(a,icalproperty_new_summary(alarm->mailSubject().utf8()));
icalcomponent_add_property(a,icalproperty_new_description(alarm->text().utf8()));
QStringList attachments = alarm->mailAttachments();
if (attachments.count() > 0) {
for (QStringList::Iterator at = attachments.begin(); at != attachments.end(); ++at) {
- attach = icalattachtype_new();
- icalattachtype_set_url(attach,QFile::encodeName( *at ).data());
+ attach = icalattach_new_from_url(QFile::encodeName( *at ).data());
icalcomponent_add_property(a,icalproperty_new_attach(attach));
- icalattachtype_free(attach);
}
}
break;
}
case Alarm::Display:
action = ICAL_ACTION_DISPLAY;
icalcomponent_add_property(a,icalproperty_new_description(alarm->text().utf8()));
break;
case Alarm::Invalid:
default:
kdDebug(5800) << "Unknown type of alarm" << endl;
action = ICAL_ACTION_NONE;
break;
}
icalcomponent_add_property(a,icalproperty_new_action(action));
@@ -925,36 +925,34 @@ Event *ICalFormatImpl::readEvent(icalcomponent *vevent)
index2 = 0;
QString resource;
while ((index2 = resources.find(';', index1)) != -1) {
resource = resources.mid(index1, (index2 - index1));
tmpStrList.append(resource);
index1 = index2;
}
anEvent->setResources(tmpStrList);
}
#endif
case ICAL_RELATEDTO_PROPERTY: // releated event (parent)
event->setRelatedToUid(QString::fromUtf8(icalproperty_get_relatedto(p)));
mEventsRelate.append(event);
break;
-
case ICAL_TRANSP_PROPERTY: // Transparency
- transparency = QString::fromUtf8(icalproperty_get_transp(p));
- if( transparency == "TRANSPARENT" )
+ if(icalproperty_get_transp(p) == ICAL_TRANSP_TRANSPARENT )
event->setTransparency( Event::Transparent );
else
event->setTransparency( Event::Opaque );
break;
default:
// kdDebug(5800) << "ICALFormat::readEvent(): Unknown property: " << kind
// << endl;
break;
}
p = icalcomponent_get_next_property(vevent,ICAL_ANY_PROPERTY);
}
QString msade = event->nonKDECustomProperty("X-MICROSOFT-CDO-ALLDAYEVENT");
if (!msade.isNull()) {
@@ -1105,53 +1103,51 @@ Attendee *ICalFormatImpl::readAttendee(icalproperty *attendee)
}
p = icalproperty_get_first_parameter(attendee,ICAL_X_PARAMETER);
uid = icalparameter_get_xvalue(p);
// This should be added, but there seems to be a libical bug here.
/*while (p) {
// if (icalparameter_get_xname(p) == "X-UID") {
uid = icalparameter_get_xvalue(p);
p = icalproperty_get_next_parameter(attendee,ICAL_X_PARAMETER);
} */
return new Attendee( name, email, rsvp, status, role, uid );
}
Attachment *ICalFormatImpl::readAttachment(icalproperty *attach)
{
- icalattachtype *a = icalproperty_get_attach(attach);
+ icalattach *a = icalproperty_get_attach(attach);
icalparameter_value v = ICAL_VALUE_NONE;
icalparameter_encoding e = ICAL_ENCODING_NONE;
Attachment *attachment = 0;
-
+ /*
icalparameter *vp = icalproperty_get_first_parameter(attach, ICAL_VALUE_PARAMETER);
if (vp)
v = icalparameter_get_value(vp);
icalparameter *ep = icalproperty_get_first_parameter(attach, ICAL_ENCODING_PARAMETER);
if (ep)
e = icalparameter_get_encoding(ep);
-
- if (v == ICAL_VALUE_BINARY && e == ICAL_ENCODING_BASE64)
- attachment = new Attachment(icalattachtype_get_base64(a));
- else if ((v == ICAL_VALUE_NONE || v == ICAL_VALUE_URI) && (e == ICAL_ENCODING_NONE || e == ICAL_ENCODING_8BIT)) {
- attachment = new Attachment(QString(icalattachtype_get_url(a)));
- } else {
- kdWarning(5800) << "Unsupported attachment format, discarding it!" << endl;
- return 0;
+ */
+ int isurl = icalattach_get_is_url (a);
+ if (isurl == 0)
+ attachment = new Attachment((const char*)icalattach_get_data(a));
+ else {
+ attachment = new Attachment(QString(icalattach_get_url(a)));
}
icalparameter *p = icalproperty_get_first_parameter(attach, ICAL_FMTTYPE_PARAMETER);
if (p)
attachment->setMimeType(QString(icalparameter_get_fmttype(p)));
return attachment;
}
#include <qtextcodec.h>
void ICalFormatImpl::readIncidence(icalcomponent *parent,Incidence *incidence)
{
readIncidenceBase(parent,incidence);
icalproperty *p = icalcomponent_get_first_property(parent,ICAL_ANY_PROPERTY);
bool readrec = false;
const char *text;
@@ -1237,41 +1233,42 @@ void ICalFormatImpl::readIncidence(icalcomponent *parent,Incidence *incidence)
text = icalproperty_get_categories(p);
categories.append(QString::fromUtf8(text));
break;
//*******************************************
case ICAL_RRULE_PROPERTY:
// we do need (maybe )start datetime of incidence for recurrence
// such that we can read recurrence only after we read incidence completely
readrec = true;
rectype = icalproperty_get_rrule(p);
break;
case ICAL_EXDATE_PROPERTY:
icaltime = icalproperty_get_exdate(p);
incidence->addExDate(readICalDate(icaltime));
break;
- case ICAL_CLASS_PROPERTY:
- text = icalproperty_get_class(p);
- if (strcmp(text,"PUBLIC") == 0) {
+ case ICAL_CLASS_PROPERTY: {
+ int inttext = icalproperty_get_class(p);
+ if (inttext == ICAL_CLASS_PUBLIC ) {
incidence->setSecrecy(Incidence::SecrecyPublic);
- } else if (strcmp(text,"CONFIDENTIAL") == 0) {
+ } else if (inttext == ICAL_CLASS_CONFIDENTIAL ) {
incidence->setSecrecy(Incidence::SecrecyConfidential);
} else {
incidence->setSecrecy(Incidence::SecrecyPrivate);
}
+ }
break;
case ICAL_ATTACH_PROPERTY: // attachments
incidence->addAttachment(readAttachment(p));
break;
default:
// kdDebug(5800) << "ICALFormat::readIncidence(): Unknown property: " << kind
// << endl;
break;
}
p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
}
if ( readrec ) {
readRecurrenceRule(rectype,incidence);
@@ -1340,35 +1337,35 @@ void ICalFormatImpl::readIncidenceBase(icalcomponent *parent,IncidenceBase *inci
}
p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
}
// custom properties
readCustomProperties(parent, incidenceBase);
}
void ICalFormatImpl::readCustomProperties(icalcomponent *parent,CustomProperties *properties)
{
QMap<QCString, QString> customProperties;
icalproperty *p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY);
while (p) {
-
QString value = QString::fromUtf8(icalproperty_get_x(p));
- customProperties[icalproperty_get_name(p)] = value;
+ customProperties[icalproperty_get_x_name(p)] = value;
+ //qDebug("ICalFormatImpl::readCustomProperties %s %s",value.latin1(), icalproperty_get_x_name(p) );
p = icalcomponent_get_next_property(parent,ICAL_X_PROPERTY);
}
properties->setCustomProperties(customProperties);
}
void ICalFormatImpl::readRecurrenceRule(struct icalrecurrencetype rrule,Incidence *incidence)
{
// kdDebug(5800) << "Read recurrence for " << incidence->summary() << endl;
Recurrence *recur = incidence->recurrence();
recur->setCompatVersion(mCalendarVersion);
recur->unsetRecurs();
struct icalrecurrencetype r = rrule;
@@ -1654,34 +1651,34 @@ void ICalFormatImpl::readAlarm(icalcomponent *alarm,Incidence *incidence)
ialarm->setMailSubject(QString::fromUtf8(icalproperty_get_summary(p)));
break;
// Only in EMAIL alarm
case ICAL_ATTENDEE_PROPERTY: {
QString email = QString::fromUtf8(icalproperty_get_attendee(p));
QString name;
icalparameter *param = icalproperty_get_first_parameter(p,ICAL_CN_PARAMETER);
if (param) {
name = QString::fromUtf8(icalparameter_get_cn(param));
}
ialarm->addMailAddress(Person(name, email));
break;
}
// Only in AUDIO and EMAIL and PROCEDURE alarms
case ICAL_ATTACH_PROPERTY: {
- icalattachtype *attach = icalproperty_get_attach(p);
- QString url = QFile::decodeName(icalattachtype_get_url(attach));
+ icalattach *attach = icalproperty_get_attach(p);
+ QString url = QFile::decodeName(icalattach_get_url(attach));
switch ( action ) {
case ICAL_ACTION_AUDIO:
ialarm->setAudioFile( url );
break;
case ICAL_ACTION_PROCEDURE:
ialarm->setProgramFile( url );
break;
case ICAL_ACTION_EMAIL:
ialarm->addMailAttachment( url );
break;
default:
break;
}
break;
}
default:
diff --git a/libkcal/icalformatimpl.h b/libkcal/icalformatimpl.h
index 2f32365..203c302 100644
--- a/libkcal/icalformatimpl.h
+++ b/libkcal/icalformatimpl.h
@@ -42,33 +42,33 @@ class ICalFormatImpl {
/** Create new iCal format for calendar object */
ICalFormatImpl( ICalFormat *parent );
virtual ~ICalFormatImpl();
bool populate( Calendar *, icalcomponent *fs);
icalcomponent *writeIncidence(Incidence *incidence);
icalcomponent *writeTodo(Todo *todo);
icalcomponent *writeEvent(Event *event);
icalcomponent *writeFreeBusy(FreeBusy *freebusy,
Scheduler::Method method);
icalcomponent *writeJournal(Journal *journal);
void writeIncidence(icalcomponent *parent,Incidence *incidence);
icalproperty *writeAttendee(Attendee *attendee);
icalproperty *writeAttachment(Attachment *attach);
icalproperty *writeRecurrenceRule(Recurrence *);
- icalproperty *writeAlarm(Alarm *alarm);
+ icalcomponent *writeAlarm(Alarm *alarm);
QString extractErrorProperty(icalcomponent *);
Todo *readTodo(icalcomponent *vtodo);
Event *readEvent(icalcomponent *vevent);
FreeBusy *readFreeBusy(icalcomponent *vfreebusy);
Journal *readJournal(icalcomponent *vjournal);
Attendee *readAttendee(icalproperty *attendee);
Attachment *readAttachment(icalproperty *attach);
void readIncidence(icalcomponent *parent,Incidence *incidence);
void readRecurrenceRule(struct icalrecurrencetype rrule,Incidence *event);
void readRecurrence( const struct icalrecurrencetype &r, Recurrence* recur,Incidence *event );
void readAlarm(icalcomponent *alarm,Incidence *incidence);
/** Return the PRODID string loaded from calendar file */
const QString &loadedProductId() { return mLoadedProductId; }
icaltimetype writeICalDate(const QDate &);
diff --git a/libkcal/vcalformat.cpp b/libkcal/vcalformat.cpp
index 59030d5..72a781a 100644
--- a/libkcal/vcalformat.cpp
+++ b/libkcal/vcalformat.cpp
@@ -335,35 +335,35 @@ VObject *VCalFormat::eventToVTodo(const Todo *anEvent)
addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
addPropValue(a, VCRepeatCountProp, "1");
addPropValue(a, VCAudioContentProp, QFile::encodeName(alarm->audioFile()));
}
else if (alarm->type() == Alarm::Procedure) {
a = addProp(vtodo, VCPAlarmProp);
addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
addPropValue(a, VCRepeatCountProp, "1");
addPropValue(a, VCProcedureNameProp, QFile::encodeName(alarm->programFile()));
}
}
}
if (anEvent->pilotId()) {
// pilot sync stuff
tmpStr.sprintf("%i",anEvent->pilotId());
- addPropValue(vtodo, KPilotIdProp, tmpStr.local8Bit());
+ addPropValue(vtodo, XPilotIdProp, tmpStr.local8Bit());
tmpStr.sprintf("%i",anEvent->syncStatus());
- addPropValue(vtodo, KPilotStatusProp, tmpStr.local8Bit());
+ addPropValue(vtodo, XPilotStatusProp, tmpStr.local8Bit());
}
return vtodo;
}
VObject* VCalFormat::eventToVEvent(const Event *anEvent)
{
VObject *vevent;
QString tmpStr;
QStringList tmpStrList;
vevent = newVObject(VCEventProp);
// start and end time
tmpStr = qDateTimeToISO(anEvent->dtStart(),
!anEvent->doesFloat());
@@ -513,33 +513,33 @@ VObject* VCalFormat::eventToVEvent(const Event *anEvent)
}
addPropValue(vevent,VCRRuleProp, tmpStr.local8Bit());
} // event repeats
// exceptions to recurrence
DateList dateList = anEvent->exDates();
DateList::ConstIterator it;
QString tmpStr2;
for (it = dateList.begin(); it != dateList.end(); ++it) {
tmpStr = qDateToISO(*it) + ";";
tmpStr2 += tmpStr;
}
if (!tmpStr2.isEmpty()) {
tmpStr2.truncate(tmpStr2.length()-1);
- addPropValue(vevent, VCExDateProp, tmpStr2.local8Bit());
+ addPropValue(vevent, VCExpDateProp, tmpStr2.local8Bit());
}
// description
if (!anEvent->description().isEmpty()) {
VObject *d = addPropValue(vevent, VCDescriptionProp,
anEvent->description().local8Bit());
if (anEvent->description().find('\n') != -1)
addProp(d, VCQuotedPrintableProp);
}
// summary
if (!anEvent->summary().isEmpty())
addPropValue(vevent, VCSummaryProp, anEvent->summary().local8Bit());
if (!anEvent->location().isEmpty())
addPropValue(vevent, VCLocationProp, anEvent->location().local8Bit());
@@ -628,35 +628,35 @@ VObject* VCalFormat::eventToVEvent(const Event *anEvent)
tmpStr.sprintf("%i",anEvent->priority());
addPropValue(vevent, VCPriorityProp, tmpStr.local8Bit());
// transparency
tmpStr.sprintf("%i",anEvent->transparency());
addPropValue(vevent, VCTranspProp, tmpStr.local8Bit());
// related event
if (anEvent->relatedTo()) {
addPropValue(vevent, VCRelatedToProp,
anEvent->relatedTo()->uid().local8Bit());
}
if (anEvent->pilotId()) {
// pilot sync stuff
tmpStr.sprintf("%i",anEvent->pilotId());
- addPropValue(vevent, KPilotIdProp, tmpStr.local8Bit());
+ addPropValue(vevent, XPilotIdProp, tmpStr.local8Bit());
tmpStr.sprintf("%i",anEvent->syncStatus());
- addPropValue(vevent, KPilotStatusProp, tmpStr.local8Bit());
+ addPropValue(vevent, XPilotStatusProp, tmpStr.local8Bit());
}
return vevent;
}
Todo *VCalFormat::VTodoToEvent(VObject *vtodo)
{
VObject *vo;
VObjectIterator voi;
char *s;
Todo *anEvent = new Todo;
// creation date
if ((vo = isAPropertyOf(vtodo, VCDCreatedProp)) != 0) {
anEvent->setCreated(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))));
@@ -836,40 +836,40 @@ Todo *VCalFormat::VTodoToEvent(VObject *vtodo)
deleteStr(s);
//const char* category;
QString category;
while ((index2 = categories.find(',', index1)) != -1) {
//category = (const char *) categories.mid(index1, (index2 - index1));
category = categories.mid(index1, (index2 - index1));
tmpStrList.append(category);
index1 = index2+1;
}
// get last category
category = categories.mid(index1, (categories.length()-index1));
tmpStrList.append(category);
anEvent->setCategories(tmpStrList);
}
/* PILOT SYNC STUFF */
- if ((vo = isAPropertyOf(vtodo, KPilotIdProp))) {
+ if ((vo = isAPropertyOf(vtodo, XPilotIdProp))) {
anEvent->setPilotId(atoi(s = fakeCString(vObjectUStringZValue(vo))));
deleteStr(s);
}
else
anEvent->setPilotId(0);
- if ((vo = isAPropertyOf(vtodo, KPilotStatusProp))) {
+ if ((vo = isAPropertyOf(vtodo, XPilotStatusProp))) {
anEvent->setSyncStatus(atoi(s = fakeCString(vObjectUStringZValue(vo))));
deleteStr(s);
}
else
anEvent->setSyncStatus(Event::SYNCMOD);
return anEvent;
}
Event* VCalFormat::VEventToEvent(VObject *vevent)
{
VObject *vo;
VObjectIterator voi;
char *s;
Event *anEvent = new Event;
@@ -1194,33 +1194,33 @@ Event* VCalFormat::VEventToEvent(VObject *vevent)
QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rEndDate);
} else {
int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
if (rDuration == 0)
anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, -1);
else
anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rDuration);
}
} else {
kdDebug(5800) << "we don't understand this type of recurrence!" << endl;
} // if
} // repeats
// recurrence exceptions
- if ((vo = isAPropertyOf(vevent, VCExDateProp)) != 0) {
+ if ((vo = isAPropertyOf(vevent, VCExpDateProp)) != 0) {
s = fakeCString(vObjectUStringZValue(vo));
QStringList exDates = QStringList::split(",",s);
QStringList::ConstIterator it;
for(it = exDates.begin(); it != exDates.end(); ++it ) {
anEvent->addExDate(ISOToQDate(*it));
}
deleteStr(s);
}
// summary
if ((vo = isAPropertyOf(vevent, VCSummaryProp))) {
s = fakeCString(vObjectUStringZValue(vo));
anEvent->setSummary(QString::fromLocal8Bit(s));
deleteStr(s);
}
if ((vo = isAPropertyOf(vevent, VCLocationProp))) {
@@ -1358,40 +1358,40 @@ Event* VCalFormat::VEventToEvent(VObject *vevent)
// transparency
if ((vo = isAPropertyOf(vevent, VCTranspProp)) != 0) {
int i = atoi(s = fakeCString(vObjectUStringZValue(vo)));
anEvent->setTransparency( i == 1 ? Event::Transparent : Event::Opaque );
deleteStr(s);
}
// related event
if ((vo = isAPropertyOf(vevent, VCRelatedToProp)) != 0) {
anEvent->setRelatedToUid(s = fakeCString(vObjectUStringZValue(vo)));
deleteStr(s);
mEventsRelate.append(anEvent);
}
/* PILOT SYNC STUFF */
- if ((vo = isAPropertyOf(vevent, KPilotIdProp))) {
+ if ((vo = isAPropertyOf(vevent, XPilotIdProp))) {
anEvent->setPilotId(atoi(s = fakeCString(vObjectUStringZValue(vo))));
deleteStr(s);
}
else
anEvent->setPilotId(0);
- if ((vo = isAPropertyOf(vevent, KPilotStatusProp))) {
+ if ((vo = isAPropertyOf(vevent, XPilotStatusProp))) {
anEvent->setSyncStatus(atoi(s = fakeCString(vObjectUStringZValue(vo))));
deleteStr(s);
}
else
anEvent->setSyncStatus(Event::SYNCMOD);
return anEvent;
}
QString VCalFormat::qDateToISO(const QDate &qd)
{
QString tmpStr;
ASSERT(qd.isValid());
@@ -1509,33 +1509,33 @@ void VCalFormat::populate(VObject *vcal)
// Store all events with a relatedTo property in a list for post-processing
mEventsRelate.clear();
mTodosRelate.clear();
initPropIterator(&i, vcal);
// go through all the vobjects in the vcal
while (moreIteration(&i)) {
curVO = nextVObject(&i);
/************************************************************************/
// now, check to see that the object is an event or todo.
if (strcmp(vObjectName(curVO), VCEventProp) == 0) {
- if ((curVOProp = isAPropertyOf(curVO, KPilotStatusProp)) != 0) {
+ if ((curVOProp = isAPropertyOf(curVO, XPilotStatusProp)) != 0) {
char *s;
s = fakeCString(vObjectUStringZValue(curVOProp));
// check to see if event was deleted by the kpilot conduit
if (atoi(s) == Event::SYNCDEL) {
deleteStr(s);
kdDebug(5800) << "skipping pilot-deleted event" << endl;
goto SKIP;
}
deleteStr(s);
}
// this code checks to see if we are trying to read in an event
// that we already find to be in the calendar. If we find this
// to be the case, we skip the event.
if ((curVOProp = isAPropertyOf(curVO, VCUniqueStringProp)) != 0) {
char *s = fakeCString(vObjectUStringZValue(curVOProp));
diff --git a/libkcal/versit/port.h b/libkcal/versit/port.h
index afc16dd..1768bee 100644
--- a/libkcal/versit/port.h
+++ b/libkcal/versit/port.h
@@ -1,75 +1,88 @@
/***************************************************************************
-(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International
-Business Machines Corporation and Siemens Rolm Communications Inc.
-
-For purposes of this license notice, the term Licensors shall mean,
-collectively, Apple Computer, Inc., AT&T Corp., International
-Business Machines Corporation and Siemens Rolm Communications Inc.
-The term Licensor shall mean any of the Licensors.
-
-Subject to acceptance of the following conditions, permission is hereby
-granted by Licensors without the need for written agreement and without
-license or royalty fees, to use, copy, modify and distribute this
-software for any purpose.
-
-The above copyright notice and the following four paragraphs must be
-reproduced in all copies of this software and any software including
-this software.
-
-THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE
-ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR
-MODIFICATIONS.
-
-IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT,
-INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
-OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.
-
-The software is provided with RESTRICTED RIGHTS. Use, duplication, or
-disclosure by the government are subject to restrictions set forth in
-DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
+(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International
+Business Machines Corporation and Siemens Rolm Communications Inc.
+
+For purposes of this license notice, the term Licensors shall mean,
+collectively, Apple Computer, Inc., AT&T Corp., International
+Business Machines Corporation and Siemens Rolm Communications Inc.
+The term Licensor shall mean any of the Licensors.
+
+Subject to acceptance of the following conditions, permission is hereby
+granted by Licensors without the need for written agreement and without
+license or royalty fees, to use, copy, modify and distribute this
+software for any purpose.
+
+The above copyright notice and the following four paragraphs must be
+reproduced in all copies of this software and any software including
+this software.
+
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE
+ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR
+MODIFICATIONS.
+
+IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT,
+INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
+OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.
+
+The software is provided with RESTRICTED RIGHTS. Use, duplication, or
+disclosure by the government are subject to restrictions set forth in
+DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
***************************************************************************/
#ifndef __PORT_H__
#define __PORT_H__ 1
+
#if defined(__CPLUSPLUS__) || defined(__cplusplus)
extern "C" {
#endif
-
-#define vCardClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCard"
-#define vCalendarClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCalendar"
-
-/* The above strings vCardClipboardFormat and vCalendarClipboardFormat
-are globally unique IDs which can be used to generate clipboard format
-ID's as per the requirements of a specific platform. For example, in
-Windows they are used as the parameter in a call to RegisterClipboardFormat.
+
+/* some of these #defines are commented out because */
+/* Visual C++ sets them on the compiler command line instead */
+
+/* #define _DEBUG */
+/* #define WIN32 */
+/* #define WIN16 */
+/* #define _WINDOWS */
+/* #define __MWERKS__ */
+/* #define INCLUDEMFC */
+
+#define vCardClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCard"
+#define vCalendarClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCalendar"
+
+/* The above strings vCardClipboardFormat and vCalendarClipboardFormat
+are globally unique IDs which can be used to generate clipboard format
+ID's as per the requirements of a specific platform. For example, in
+Windows they are used as the parameter in a call to RegisterClipboardFormat.
For example:
CLIPFORMAT foo = RegisterClipboardFormat(vCardClipboardFormat);
*/
-#define vCardMimeType "text/x-vCard"
-#define vCalendarMimeType "text/x-vCalendar"
+#define vCardMimeType "text/x-vCard"
+#define vCalendarMimeType "text/x-vCalendar"
+
+#define DLLEXPORT(t) t
#ifndef FALSE
-#define FALSE 0
+#define FALSE 0
#endif
#ifndef TRUE
-#define TRUE 1
+#define TRUE 1
#endif
-#define Parse_Debug(t)
-
+#define stricmp strcasecmp
+
#if defined(__CPLUSPLUS__) || defined(__cplusplus)
}
#endif
#endif /* __PORT_H__ */
diff --git a/libkcal/versit/vcc.c b/libkcal/versit/vcc.c
index 350cac3..9be752d 100644
--- a/libkcal/versit/vcc.c
+++ b/libkcal/versit/vcc.c
@@ -1,104 +1,104 @@
-
-/* A Bison parser, made from ./vcc.y
- by GNU Bison version 1.28 */
+/* A Bison parser, made from vcc.y
+ by GNU bison 1.35. */
#define YYBISON 1 /* Identify Bison output. */
-#ifdef _WIN32_
-#define strcasecmp _stricmp
-#endif
-
-#define EQ 257
-#define COLON 258
-#define DOT 259
-#define SEMICOLON 260
-#define SPACE 261
-#define HTAB 262
-#define LINESEP 263
-#define NEWLINE 264
-#define BEGIN_VCARD 265
-#define END_VCARD 266
-#define BEGIN_VCAL 267
-#define END_VCAL 268
-#define BEGIN_VEVENT 269
-#define END_VEVENT 270
-#define BEGIN_VTODO 271
-#define END_VTODO 272
-#define ID 273
-#define STRING 274
-
-#line 1 "./vcc.y"
+# define EQ 257
+# define COLON 258
+# define DOT 259
+# define SEMICOLON 260
+# define SPACE 261
+# define HTAB 262
+# define LINESEP 263
+# define NEWLINE 264
+# define BEGIN_VCARD 265
+# define END_VCARD 266
+# define BEGIN_VCAL 267
+# define END_VCAL 268
+# define BEGIN_VEVENT 269
+# define END_VEVENT 270
+# define BEGIN_VTODO 271
+# define END_VTODO 272
+# define ID 273
+# define STRING 274
+
+#line 1 "vcc.y"
/***************************************************************************
-(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International
-Business Machines Corporation and Siemens Rolm Communications Inc.
-
-For purposes of this license notice, the term Licensors shall mean,
-collectively, Apple Computer, Inc., AT&T Corp., International
-Business Machines Corporation and Siemens Rolm Communications Inc.
-The term Licensor shall mean any of the Licensors.
-
-Subject to acceptance of the following conditions, permission is hereby
-granted by Licensors without the need for written agreement and without
-license or royalty fees, to use, copy, modify and distribute this
-software for any purpose.
-
-The above copyright notice and the following four paragraphs must be
-reproduced in all copies of this software and any software including
-this software.
-
-THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE
-ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR
-MODIFICATIONS.
-
-IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT,
-INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
-OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.
-
-The software is provided with RESTRICTED RIGHTS. Use, duplication, or
-disclosure by the government are subject to restrictions set forth in
-DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
+(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International
+Business Machines Corporation and Siemens Rolm Communications Inc.
+
+For purposes of this license notice, the term Licensors shall mean,
+collectively, Apple Computer, Inc., AT&T Corp., International
+Business Machines Corporation and Siemens Rolm Communications Inc.
+The term Licensor shall mean any of the Licensors.
+
+Subject to acceptance of the following conditions, permission is hereby
+granted by Licensors without the need for written agreement and without
+license or royalty fees, to use, copy, modify and distribute this
+software for any purpose.
+
+The above copyright notice and the following four paragraphs must be
+reproduced in all copies of this software and any software including
+this software.
+
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE
+ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR
+MODIFICATIONS.
+
+IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT,
+INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
+OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.
+
+The software is provided with RESTRICTED RIGHTS. Use, duplication, or
+disclosure by the government are subject to restrictions set forth in
+DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
***************************************************************************/
/*
* src: vcc.c
* doc: Parser for vCard and vCalendar. Note that this code is
* generated by a yacc parser generator. Generally it should not
* be edited by hand. The real source is vcc.y. The #line directives
* can be commented out here to make it easier to trace through
- * in a debugger. However, if a bug is found it should
+ * in a debugger. However, if a bug is found it should
* be fixed in vcc.y and this file regenerated.
*/
/* debugging utilities */
#if __DEBUG
#define DBG_(x) printf x
#else
#define DBG_(x)
#endif
+#ifdef WIN32
+#define snprintf _snprintf
+#define strcasecmp stricmp
+#endif
+
/**** External Functions ****/
/* assign local name to parser variables and functions so that
we can use more than one yacc based parser.
*/
#define yyparse mime_parse
#define yylex mime_lex
#define yyerror mime_error
#define yychar mime_char
/* #define p_yyval p_mime_val */
#undef yyval
#define yyval mime_yyval
/* #define p_yylval p_mime_lval */
#undef yylval
#define yylval mime_yylval
@@ -107,1336 +107,1514 @@ DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
#define yyerrflag mime_errflag
#define yyss mime_ss
#define yyssp mime_ssp
#define yyvs mime_vs
#define yyvsp mime_vsp
#define yylhs mime_lhs
#define yylen mime_len
#define yydefred mime_defred
#define yydgoto mime_dgoto
#define yysindex mime_sindex
#define yyrindex mime_rindex
#define yygindex mime_gindex
#define yytable mime_table
#define yycheck mime_check
#define yyname mime_name
#define yyrule mime_rule
-#undef YYPREFIX
#define YYPREFIX "mime_"
#ifndef _NO_LINE_FOLDING
#define _SUPPORT_LINE_FOLDING 1
#endif
-#include <string.h>
-#ifndef __FreeBSD__
-#include <malloc.h>
+/* undef below if compile with MFC */
+/* #define INCLUDEMFC 1 */
+
+#if defined(WIN32) || defined(_WIN32)
+#ifdef INCLUDEMFC
+#include <afx.h>
#endif
+#endif
+
+#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "vcc.h"
-/* The following is a hack that I hope will get things compiling
- * on SunOS 4.1.x systems
- */
-#ifndef SEEK_SET
-#define SEEK_SET 0 /* Seek from beginning of file. */
-#define SEEK_CUR 1 /* Seek from current position. */
-#define SEEK_END 2 /* Seek from end of file. */
-#endif
-
/**** Types, Constants ****/
-#define YYDEBUG 0 /* 1 to compile in some debugging code */
+#define YYDEBUG 1 /* 1 to compile in some debugging code */
#define MAXTOKEN 256 /* maximum token (line) length */
-#define YYSTACKSIZE 1000 /* ~unref ? */
+#define YYSTACKSIZE 50 /* ~unref ? */
#define MAXLEVEL 10 /* max # of nested objects parseable */
/* (includes outermost) */
/**** Global Variables ****/
int mime_lineNum, mime_numErrors; /* yyerror() can use these */
static VObject* vObjList;
static VObject *curProp;
static VObject *curObj;
static VObject* ObjStack[MAXLEVEL];
static int ObjStackTop;
/* A helpful utility for the rest of the app. */
#if __CPLUSPLUS__
extern "C" {
#endif
- /* static void Parse_Debug(const char *s);*/
+ extern void Parse_Debug(const char *s);
static void yyerror(char *s);
#if __CPLUSPLUS__
};
#endif
int yyparse();
-static int yylex();
+
enum LexMode {
L_NORMAL,
L_VCARD,
L_VCAL,
L_VEVENT,
L_VTODO,
L_VALUES,
L_BASE64,
L_QUOTED_PRINTABLE
};
/**** Private Forward Declarations ****/
static int pushVObject(const char *prop);
static VObject* popVObject();
-char* lexDataFromBase64();
static void lexPopMode(int top);
static int lexWithinMode(enum LexMode mode);
static void lexPushMode(enum LexMode mode);
static void enterProps(const char *s);
static void enterAttr(const char *s1, const char *s2);
-/* static void enterValues(const char *value); */
-static void appendValue(const char *value);
+static void enterValues(const char *value);
static void mime_error_(char *s);
-#line 181 "./vcc.y"
+#line 180 "vcc.y"
+#ifndef YYSTYPE
typedef union {
char *str;
VObject *vobj;
- } YYSTYPE;
-#include <stdio.h>
-
-#ifndef __cplusplus
-#ifndef __STDC__
-#define const
+ } yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
#endif
+#ifndef YYDEBUG
+# define YYDEBUG 0
#endif
#define YYFINAL 62
#define YYFLAG -32768
#define YYNTBASE 21
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
#define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 51)
-static const char yytranslate[] = { 0,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20
+/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
+static const char yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20
};
-#if YYDEBUG != 0
-static const short yyprhs[] = { 0,
- 0, 2, 3, 7, 9, 11, 13, 14, 19, 20,
- 24, 27, 29, 30, 36, 38, 39, 43, 45, 48,
- 50, 53, 55, 59, 61, 62, 67, 69, 71, 72,
- 73, 78, 79, 83, 86, 88, 90, 92, 94, 95,
- 100, 101, 105, 106, 111, 112
+#if YYDEBUG
+static const short yyprhs[] =
+{
+ 0, 0, 2, 3, 7, 9, 11, 13, 14, 19,
+ 20, 24, 27, 29, 30, 36, 38, 39, 43, 45,
+ 48, 50, 53, 55, 59, 61, 62, 67, 69, 71,
+ 72, 73, 78, 79, 83, 86, 88, 90, 92, 94,
+ 95, 100, 101, 105, 106, 111, 112
};
-
-static const short yyrhs[] = { 22,
- 0, 0, 24, 23, 22, 0, 24, 0, 25, 0,
- 40, 0, 0, 11, 26, 28, 12, 0, 0, 11,
- 27, 12, 0, 29, 28, 0, 29, 0, 0, 31,
- 4, 30, 37, 9, 0, 1, 0, 0, 36, 32,
- 33, 0, 36, 0, 34, 33, 0, 34, 0, 6,
- 35, 0, 36, 0, 36, 3, 36, 0, 19, 0,
- 0, 39, 6, 38, 37, 0, 39, 0, 20, 0,
- 0, 0, 13, 41, 43, 14, 0, 0, 13, 42,
- 14, 0, 44, 43, 0, 44, 0, 45, 0, 48,
- 0, 28, 0, 0, 15, 46, 28, 16, 0, 0,
- 15, 47, 16, 0, 0, 17, 49, 28, 18, 0,
- 0, 17, 50, 18, 0
+static const short yyrhs[] =
+{
+ 22, 0, 0, 24, 23, 22, 0, 24, 0, 25,
+ 0, 40, 0, 0, 11, 26, 28, 12, 0, 0,
+ 11, 27, 12, 0, 29, 28, 0, 29, 0, 0,
+ 31, 4, 30, 37, 9, 0, 1, 0, 0, 36,
+ 32, 33, 0, 36, 0, 34, 33, 0, 34, 0,
+ 6, 35, 0, 36, 0, 36, 3, 36, 0, 19,
+ 0, 0, 39, 6, 38, 37, 0, 39, 0, 20,
+ 0, 0, 0, 13, 41, 43, 14, 0, 0, 13,
+ 42, 14, 0, 44, 43, 0, 44, 0, 45, 0,
+ 48, 0, 28, 0, 0, 15, 46, 28, 16, 0,
+ 0, 15, 47, 16, 0, 0, 17, 49, 28, 18,
+ 0, 0, 17, 50, 18, 0
};
#endif
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
- 209, 212, 215, 215, 219, 220, 223, 229, 234, 240,
- 246, 247, 250, 254, 260, 263, 268, 268, 274, 275,
- 278, 281, 285, 292, 295, 296, 296, 300, 301, 305,
- 309, 311, 314, 317, 318, 321, 323, 324, 327, 334,
- 339, 345, 351, 358, 363, 369
+#if YYDEBUG
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const short yyrline[] =
+{
+ 0, 208, 211, 211, 214, 218, 219, 222, 222, 233,
+ 233, 245, 246, 249, 249, 259, 262, 262, 267, 273,
+ 274, 277, 280, 284, 291, 294, 294, 295, 299, 300,
+ 303, 303, 309, 309, 315, 316, 319, 321, 322, 325,
+ 325, 337, 337, 349, 349, 361, 361
};
#endif
-#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+#if (YYDEBUG) || defined YYERROR_VERBOSE
-static const char * const yytname[] = { "$","error","$undefined.","EQ","COLON",
-"DOT","SEMICOLON","SPACE","HTAB","LINESEP","NEWLINE","BEGIN_VCARD","END_VCARD",
-"BEGIN_VCAL","END_VCAL","BEGIN_VEVENT","END_VEVENT","BEGIN_VTODO","END_VTODO",
-"ID","STRING","mime","vobjects","@1","vobject","vcard","@2","@3","items","item",
-"@4","prop","@5","attr_params","attr_param","attr","name","values","@6","value",
-"vcal","@7","@8","calitems","calitem","eventitem","@9","@10","todoitem","@11",
-"@12", NULL
+/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
+static const char *const yytname[] =
+{
+ "$", "error", "$undefined.", "EQ", "COLON", "DOT", "SEMICOLON", "SPACE",
+ "HTAB", "LINESEP", "NEWLINE", "BEGIN_VCARD", "END_VCARD", "BEGIN_VCAL",
+ "END_VCAL", "BEGIN_VEVENT", "END_VEVENT", "BEGIN_VTODO", "END_VTODO",
+ "ID", "STRING", "mime", "vobjects", "@1", "vobject", "vcard", "@2",
+ "@3", "items", "item", "@4", "prop", "@5", "attr_params", "attr_param",
+ "attr", "name", "values", "@6", "value", "vcal", "@7", "@8", "calitems",
+ "calitem", "eventitem", "@9", "@10", "todoitem", "@11", "@12", 0
};
#endif
-static const short yyr1[] = { 0,
- 21, 23, 22, 22, 24, 24, 26, 25, 27, 25,
- 28, 28, 30, 29, 29, 32, 31, 31, 33, 33,
- 34, 35, 35, 36, 38, 37, 37, 39, 39, 41,
- 40, 42, 40, 43, 43, 44, 44, 44, 46, 45,
- 47, 45, 49, 48, 50, 48
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const short yyr1[] =
+{
+ 0, 21, 23, 22, 22, 24, 24, 26, 25, 27,
+ 25, 28, 28, 30, 29, 29, 32, 31, 31, 33,
+ 33, 34, 35, 35, 36, 38, 37, 37, 39, 39,
+ 41, 40, 42, 40, 43, 43, 44, 44, 44, 46,
+ 45, 47, 45, 49, 48, 50, 48
};
-static const short yyr2[] = { 0,
- 1, 0, 3, 1, 1, 1, 0, 4, 0, 3,
- 2, 1, 0, 5, 1, 0, 3, 1, 2, 1,
- 2, 1, 3, 1, 0, 4, 1, 1, 0, 0,
- 4, 0, 3, 2, 1, 1, 1, 1, 0, 4,
- 0, 3, 0, 4, 0, 3
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const short yyr2[] =
+{
+ 0, 1, 0, 3, 1, 1, 1, 0, 4, 0,
+ 3, 2, 1, 0, 5, 1, 0, 3, 1, 2,
+ 1, 2, 1, 3, 1, 0, 4, 1, 1, 0,
+ 0, 4, 0, 3, 2, 1, 1, 1, 1, 0,
+ 4, 0, 3, 0, 4, 0, 3
};
-static const short yydefact[] = { 0,
- 7, 30, 1, 2, 5, 6, 0, 0, 0, 0,
- 0, 15, 24, 0, 0, 0, 16, 10, 39, 43,
- 38, 0, 0, 36, 37, 33, 3, 8, 11, 13,
- 0, 0, 0, 0, 0, 31, 34, 29, 0, 17,
- 20, 0, 42, 0, 46, 28, 0, 27, 21, 22,
- 19, 40, 44, 14, 25, 0, 29, 23, 26, 0,
- 0, 0
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+ doesn't specify something else to do. Zero means the default is an
+ error. */
+static const short yydefact[] =
+{
+ 0, 7, 30, 1, 2, 5, 6, 0, 0, 0,
+ 0, 0, 15, 24, 0, 0, 0, 16, 10, 39,
+ 43, 38, 0, 0, 36, 37, 33, 3, 8, 11,
+ 13, 0, 0, 0, 0, 0, 31, 34, 29, 0,
+ 17, 20, 0, 42, 0, 46, 28, 0, 27, 21,
+ 22, 19, 40, 44, 14, 25, 0, 29, 23, 26,
+ 0, 0, 0
};
-static const short yydefgoto[] = { 60,
- 3, 11, 4, 5, 7, 8, 21, 15, 38, 16,
- 31, 40, 41, 49, 17, 47, 57, 48, 6, 9,
- 10, 22, 23, 24, 32, 33, 25, 34, 35
+static const short yydefgoto[] =
+{
+ 60, 3, 11, 4, 5, 7, 8, 21, 15, 38,
+ 16, 31, 40, 41, 49, 17, 47, 57, 48, 6,
+ 9, 10, 22, 23, 24, 32, 33, 25, 34, 35
};
-static const short yypact[] = { -9,
- -6, -5,-32768, 7,-32768,-32768, 2, -1, 19, 15,
- -9,-32768,-32768, 1, 0, 26, 27,-32768, 16, 17,
--32768, 23, 9,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
- 33, 2, 24, 2, 25,-32768,-32768, 13, 22,-32768,
- 33, 28,-32768, 29,-32768,-32768, 36, 40,-32768, 39,
--32768,-32768,-32768,-32768,-32768, 22, 13,-32768,-32768, 48,
- 49,-32768
+static const short yypact[] =
+{
+ -9, -6, -5,-32768, 7,-32768,-32768, 2, -1, 19,
+ 15, -9,-32768,-32768, 1, 0, 26, 27,-32768, 16,
+ 17,-32768, 23, 9,-32768,-32768,-32768,-32768,-32768,-32768,
+ -32768, 33, 2, 24, 2, 25,-32768,-32768, 13, 22,
+ -32768, 33, 28,-32768, 29,-32768,-32768, 36, 40,-32768,
+ 39,-32768,-32768,-32768,-32768,-32768, 22, 13,-32768,-32768,
+ 48, 49,-32768
};
-static const short yypgoto[] = {-32768,
- 41,-32768,-32768,-32768,-32768,-32768, -7,-32768,-32768,-32768,
--32768, 10,-32768,-32768, -34, -4,-32768,-32768,-32768,-32768,
--32768, 31,-32768,-32768,-32768,-32768,-32768,-32768,-32768
+static const short yypgoto[] =
+{
+ -32768, 41,-32768,-32768,-32768,-32768,-32768, -7,-32768,-32768,
+ -32768,-32768, 10,-32768,-32768, -34, -4,-32768,-32768,-32768,
+ -32768,-32768, 31,-32768,-32768,-32768,-32768,-32768,-32768,-32768
};
#define YYLAST 54
-static const short yytable[] = { 14,
- 12, 1, 12, 2, 50, -9, -4, 29, -32, 12,
- 18, -12, 28, -12, -12, -12, -12, -12, 13, 12,
- 13, 58, -35, 19, 42, 20, 44, 13, 26, 30,
- -18, -41, 46, 19, -45, 20, 36, 13, 39, 43,
- 13, 56, 45, 52, 54, 55, 53, 61, 62, 0,
- 51, 27, 59, 37
+static const short yytable[] =
+{
+ 14, 12, 1, 12, 2, 50, -9, -4, 29, -32,
+ 12, 18, -12, 28, -12, -12, -12, -12, -12, 13,
+ 12, 13, 58, -35, 19, 42, 20, 44, 13, 26,
+ 30, -18, -41, 46, 19, -45, 20, 36, 13, 39,
+ 43, 13, 56, 45, 52, 54, 55, 53, 61, 62,
+ 0, 51, 27, 59, 37
};
-static const short yycheck[] = { 7,
- 1, 11, 1, 13, 39, 12, 0, 15, 14, 1,
- 12, 12, 12, 14, 15, 16, 17, 18, 19, 1,
- 19, 56, 14, 15, 32, 17, 34, 19, 14, 4,
- 4, 16, 20, 15, 18, 17, 14, 19, 6, 16,
- 19, 3, 18, 16, 9, 6, 18, 0, 0, -1,
- 41, 11, 57, 23
+static const short yycheck[] =
+{
+ 7, 1, 11, 1, 13, 39, 12, 0, 15, 14,
+ 1, 12, 12, 12, 14, 15, 16, 17, 18, 19,
+ 1, 19, 56, 14, 15, 32, 17, 34, 19, 14,
+ 4, 4, 16, 20, 15, 18, 17, 14, 19, 6,
+ 16, 19, 3, 18, 16, 9, 6, 18, 0, 0,
+ -1, 41, 11, 57, 23
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/share/bison.simple"
-/* This file comes from bison-1.28. */
+#line 3 "/usr/share/bison/bison.simple"
/* Skeleton output parser for bison,
- Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
+ Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
-/* This is the parser code that is written into each bison parser
- when the %semantic_parser declaration is not specified in the grammar.
- It was written by Richard Stallman by simplifying the hairy parser
- used when %semantic_parser is specified. */
+/* This is the parser code that is written into each bison parser when
+ the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# if YYSTACK_USE_ALLOCA
+# define YYSTACK_ALLOC alloca
+# else
+# ifndef YYSTACK_USE_ALLOCA
+# if defined (alloca) || defined (_ALLOCA_H)
+# define YYSTACK_ALLOC alloca
+# else
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+# define YYSTACK_ALLOC malloc
+# define YYSTACK_FREE free
+# endif
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if (! defined (yyoverflow) \
+ && (! defined (__cplusplus) \
+ || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ short yyss;
+ YYSTYPE yyvs;
+# if YYLSP_NEEDED
+ YYLTYPE yyls;
+# endif
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# if YYLSP_NEEDED
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ + 2 * YYSTACK_GAP_MAX)
+# else
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAX)
+# endif
+
+/* Copy COUNT objects from FROM to TO. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if 1 < __GNUC__
+# define YYCOPY(To, From, Count) \
+ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+# else
+# define YYCOPY(To, From, Count) \
+ do \
+ { \
+ register YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (To)[yyi] = (From)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack, Stack, yysize); \
+ Stack = &yyptr->Stack; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
-#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#else /* not GNU C. */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
-#include <alloca.h>
-#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C. */
-/* This used to test MSDOS, but that is a bad idea
- since that symbol is in the user namespace. */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
- instead, just don't use alloca. */
-#include <malloc.h>
#endif
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
- So I turned it off. rms, 2 May 1997. */
-/* #include <malloc.h> */
- #pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
- and on HPUX 10. Eventually we can turn this on. */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#endif /* __hpux */
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
#endif
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
-
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
-#else
-#define YYSTACK_ALLOC malloc
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
#endif
-
-/* Note: there must be only one dollar sign in this file.
- It is replaced by the list of actions, each action
- as one case of the switch. */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrlab1
-/* Like YYERROR except do call yyerror.
- This remains here temporarily to ease the
- transition to the new meaning of YYERROR, for GCC.
+/* Like YYERROR except do call yyerror. This remains here temporarily
+ to ease the transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
-#define YYBACKUP(token, value) \
+#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
- { yychar = (token), yylval = (value); \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
yychar1 = YYTRANSLATE (yychar); \
YYPOPSTACK; \
goto yybackup; \
} \
else \
- { yyerror ("syntax error: cannot back up"); YYERROR; } \
+ { \
+ yyerror ("syntax error: cannot back up"); \
+ YYERROR; \
+ } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
-#ifndef YYPURE
-#define YYLEX yylex()
-#endif
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
-#ifdef YYLEX_PARAM
-#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
-#else
-#define YYLEX yylex(&yylval, &yylloc)
-#endif
-#else /* not YYLSP_NEEDED */
-#ifdef YYLEX_PARAM
-#define YYLEX yylex(&yylval, YYLEX_PARAM)
-#else
-#define YYLEX yylex(&yylval)
-#endif
-#endif /* not YYLSP_NEEDED */
-#endif
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+ are run).
-/* If nonreentrant, generate the variables here */
+ When YYLLOC_DEFAULT is run, CURRENT is set the location of the
+ first token. By default, to implement support for ranges, extend
+ its range to the last symbol. */
-#ifndef YYPURE
-
-int yychar; /* the lookahead symbol */
-YYSTYPE yylval; /* the semantic value of the */
- /* lookahead symbol */
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc; /* location data for the lookahead */
- /* symbol */
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ Current.last_line = Rhs[N].last_line; \
+ Current.last_column = Rhs[N].last_column;
#endif
-int yynerrs; /* number of parse errors so far */
-#endif /* not YYPURE */
-
-#if YYDEBUG != 0
-int yydebug; /* nonzero means print parse trace */
-/* Since this is uninitialized, it does not stop multiple parsers
- from coexisting. */
-#endif
-
-/* YYINITDEPTH indicates the initial size of the parser's stacks */
+/* YYLEX -- calling `yylex' with the right arguments. */
+
+#if YYPURE
+# if YYLSP_NEEDED
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval, &yylloc)
+# endif
+# else /* !YYLSP_NEEDED */
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval)
+# endif
+# endif /* !YYLSP_NEEDED */
+#else /* !YYPURE */
+# define YYLEX yylex ()
+#endif /* !YYPURE */
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+#endif /* !YYDEBUG */
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
-#define YYINITDEPTH 200
+# define YYINITDEPTH 200
#endif
-/* YYMAXDEPTH is the maximum size the stacks can grow to
- (effective only if the built-in stack extension method is used). */
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
+# undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
+# define YYMAXDEPTH 10000
#endif
-/* Define __yy_memcpy. Note that the size argument
- should be passed with type unsigned int, because that is what the non-GCC
- definitions require. With GCC, __builtin_memcpy takes an arg
- of type size_t, but it can handle unsigned int. */
-
-#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
-#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
-#else /* not GNU C or C++ */
-#ifndef __cplusplus
-
-/* This is the most reliable way to avoid incompatibilities
- in available built-in functions on various systems. */
-static void
-__yy_memcpy (to, from, count)
- char *to;
- char *from;
- unsigned int count;
-{
- register char *f = from;
- register char *t = to;
- register int i = count;
+#ifdef YYERROR_VERBOSE
- while (i-- > 0)
- *t++ = *f++;
-}
+# ifndef yystrlen
+# if defined (__GLIBC__) && defined (_STRING_H)
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+# if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+# else
+yystrlen (yystr)
+ const char *yystr;
+# endif
+{
+ register const char *yys = yystr;
-#else /* __cplusplus */
+ while (*yys++ != '\0')
+ continue;
-/* This is the most reliable way to avoid incompatibilities
- in available built-in functions on various systems. */
-static void
-__yy_memcpy (char *to, char *from, unsigned int count)
+ return yys - yystr - 1;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+# if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+# else
+yystpcpy (yydest, yysrc)
+ char *yydest;
+ const char *yysrc;
+# endif
{
- register char *t = to;
- register char *f = from;
- register int i = count;
+ register char *yyd = yydest;
+ register const char *yys = yysrc;
- while (i-- > 0)
- *t++ = *f++;
-}
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
-#endif
+ return yyd - 1;
+}
+# endif
+# endif
#endif
-#line 217 "/usr/share/bison.simple"
+#line 315 "/usr/share/bison/bison.simple"
+
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
It should actually point to an object.
Grammar actions can access the variable by casting it
to the proper pointer type. */
#ifdef YYPARSE_PARAM
-#ifdef __cplusplus
-#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else /* not __cplusplus */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
-#define YYPARSE_PARAM_ARG
-#define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
+# if defined (__STDC__) || defined (__cplusplus)
+# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL
+# else
+# define YYPARSE_PARAM_ARG YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+# endif
+#else /* !YYPARSE_PARAM */
+# define YYPARSE_PARAM_ARG
+# define YYPARSE_PARAM_DECL
+#endif /* !YYPARSE_PARAM */
/* Prevent warning if -Wstrict-prototypes. */
-#if defined (__GNUC__) && ! defined (__cplusplus)
-#ifdef YYPARSE_PARAM
+#ifdef __GNUC__
+# ifdef YYPARSE_PARAM
int yyparse (void *);
-#else
+# else
int yyparse (void);
+# endif
#endif
+
+/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
+ variables are global, or local to YYPARSE. */
+
+#define YY_DECL_NON_LSP_VARIABLES \
+/* The lookahead symbol. */ \
+int yychar; \
+ \
+/* The semantic value of the lookahead symbol. */ \
+YYSTYPE yylval; \
+ \
+/* Number of parse errors so far. */ \
+int yynerrs;
+
+#if YYLSP_NEEDED
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES \
+ \
+/* Location data for the lookahead symbol. */ \
+YYLTYPE yylloc;
+#else
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES
#endif
+
+/* If nonreentrant, generate the variables here. */
+
+#if !YYPURE
+YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
int
-yyparse(YYPARSE_PARAM_ARG)
+yyparse (YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
{
+ /* If reentrant, generate the variables here. */
+#if YYPURE
+ YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
register int yystate;
register int yyn;
+ int yyresult;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+ /* Lookahead token as an internal (translated) token number. */
+ int yychar1 = 0;
+
+ /* Three stacks and their tools:
+ `yyss': related to states,
+ `yyvs': related to semantic values,
+ `yyls': related to locations.
+
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ short yyssa[YYINITDEPTH];
+ short *yyss = yyssa;
register short *yyssp;
- register YYSTYPE *yyvsp;
- int yyerrstatus; /* number of tokens to shift before error messages enabled */
- int yychar1 = 0; /* lookahead token as an internal (translated) token number */
- short yyssa[YYINITDEPTH]; /* the state stack */
- YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
-
- short *yyss = yyssa; /* refer to the stacks thru separate pointers */
- YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs = yyvsa;
+ register YYSTYPE *yyvsp;
-#ifdef YYLSP_NEEDED
- YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
+#if YYLSP_NEEDED
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
+#endif
-#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
+#if YYLSP_NEEDED
+# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
-#define YYPOPSTACK (yyvsp--, yyssp--)
+# define YYPOPSTACK (yyvsp--, yyssp--)
#endif
- int yystacksize = YYINITDEPTH;
- int yyfree_stacks = 0;
+ YYSIZE_T yystacksize = YYINITDEPTH;
-#ifdef YYPURE
- int yychar;
- YYSTYPE yylval;
- int yynerrs;
-#ifdef YYLSP_NEEDED
- YYLTYPE yylloc;
-#endif
-#endif
- YYSTYPE yyval; /* the variable used to return */
- /* semantic values from the action */
- /* routines */
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+#if YYLSP_NEEDED
+ YYLTYPE yyloc;
+#endif
+ /* When reducing, the number of symbols on the RHS of the reduced
+ rule. */
int yylen;
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Starting parse\n");
-#endif
+ YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
- yyssp = yyss - 1;
+ yyssp = yyss;
yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp = yyls;
#endif
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks.
+ */
+ yyssp++;
-/* Push a new state, which is found in yystate . */
-/* In all cases, when you get here, the value and location stacks
- have just been pushed. so pushing a state here evens the stacks. */
-yynewstate:
-
- *++yyssp = yystate;
+ yysetstate:
+ *yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
- /* Give user a chance to reallocate the stack */
- /* Use copies of these so that the &'s don't force the real ones into memory. */
- YYSTYPE *yyvs1 = yyvs;
- short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
- YYLTYPE *yyls1 = yyls;
-#endif
-
/* Get the current used size of the three stacks, in elements. */
- int size = yyssp - yyss + 1;
+ YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
- /* Each stack pointer address is followed by the size of
- the data in use in that stack, in bytes. */
-#ifdef YYLSP_NEEDED
- /* This used to be a conditional around just the two extra args,
- but that might be undefined if yyoverflow is a macro. */
- yyoverflow("parser stack overflow",
- &yyss1, size * sizeof (*yyssp),
- &yyvs1, size * sizeof (*yyvsp),
- &yyls1, size * sizeof (*yylsp),
- &yystacksize);
-#else
- yyoverflow("parser stack overflow",
- &yyss1, size * sizeof (*yyssp),
- &yyvs1, size * sizeof (*yyvsp),
- &yystacksize);
-#endif
-
- yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
- yyls = yyls1;
-#endif
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. */
+# if YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+ /* This used to be a conditional around just the two extra args,
+ but that might be undefined if yyoverflow is a macro. */
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yyls1, yysize * sizeof (*yylsp),
+ &yystacksize);
+ yyls = yyls1;
+# else
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+# endif
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyoverflowlab;
+# else
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
- {
- yyerror("parser stack overflow");
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 2;
- }
+ goto yyoverflowlab;
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
- yyfree_stacks = 1;
-#endif
- yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
- __yy_memcpy ((char *)yyss, (char *)yyss1,
- size * (unsigned int) sizeof (*yyssp));
- yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
- __yy_memcpy ((char *)yyvs, (char *)yyvs1,
- size * (unsigned int) sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
- yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
- __yy_memcpy ((char *)yyls, (char *)yyls1,
- size * (unsigned int) sizeof (*yylsp));
-#endif
+
+ {
+ short *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyoverflowlab;
+ YYSTACK_RELOCATE (yyss);
+ YYSTACK_RELOCATE (yyvs);
+# if YYLSP_NEEDED
+ YYSTACK_RELOCATE (yyls);
+# endif
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
#endif /* no yyoverflow */
- yyssp = yyss + size - 1;
- yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
- yylsp = yyls + size - 1;
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+ yylsp = yyls + yysize - 1;
#endif
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Entering state %d\n", yystate);
-#endif
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
goto yybackup;
- yybackup:
+
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (yychar == YYEMPTY)
{
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Reading a token: ");
-#endif
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Now at end of input.\n");
-#endif
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
- yychar1 = YYTRANSLATE(yychar);
+ yychar1 = YYTRANSLATE (yychar);
-#if YYDEBUG != 0
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables
+ which are defined only if `YYDEBUG' is set. */
if (yydebug)
{
- fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
- /* Give the individual parser a way to print the precise meaning
- of a token, for further debugging info. */
-#ifdef YYPRINT
+ YYFPRINTF (stderr, "Next token is %d (%s",
+ yychar, yytname[yychar1]);
+ /* Give the individual parser a way to print the precise
+ meaning of a token, for further debugging info. */
+# ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
-#endif
- fprintf (stderr, ")\n");
+# endif
+ YYFPRINTF (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
-
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+ YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+ yychar, yytname[yychar1]));
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
*++yylsp = yylloc;
#endif
- /* count tokens shifted since error; after three, turn off error status. */
- if (yyerrstatus) yyerrstatus--;
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
yystate = yyn;
goto yynewstate;
-/* Do the default action for the current state. */
-yydefault:
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
+ goto yyreduce;
-/* Do a reduction. yyn is the number of a rule to reduce with. */
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
yyreduce:
+ /* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
- if (yylen > 0)
- yyval = yyvsp[1-yylen]; /* implement default value of the action */
-#if YYDEBUG != 0
+ /* If YYLEN is nonzero, implement the default value of the action:
+ `$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to the semantic value of
+ the lookahead token. This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+ /* Similarly for the default location. Let the user run additional
+ commands if for instance locations are ranges. */
+ yyloc = yylsp[1-yylen];
+ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+#endif
+
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables which
+ are defined only if `YYDEBUG' is set. */
if (yydebug)
{
- int i;
+ int yyi;
- fprintf (stderr, "Reducing via rule %d (line %d), ",
- yyn, yyrline[yyn]);
+ YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
- for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
- fprintf (stderr, "%s ", yytname[yyrhs[i]]);
- fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+ YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+ YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
-
switch (yyn) {
case 2:
-#line 213 "./vcc.y"
-{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; ;
- break;}
+#line 212 "vcc.y"
+{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; }
+ break;
case 4:
-#line 216 "./vcc.y"
-{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; ;
- break;}
+#line 215 "vcc.y"
+{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; }
+ break;
case 7:
-#line 225 "./vcc.y"
+#line 224 "vcc.y"
{
lexPushMode(L_VCARD);
if (!pushVObject(VCCardProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 8:
-#line 230 "./vcc.y"
+#line 229 "vcc.y"
{
lexPopMode(0);
yyval.vobj = popVObject();
- ;
- break;}
+ }
+ break;
case 9:
-#line 235 "./vcc.y"
+#line 234 "vcc.y"
{
lexPushMode(L_VCARD);
if (!pushVObject(VCCardProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 10:
-#line 240 "./vcc.y"
+#line 239 "vcc.y"
{
lexPopMode(0);
yyval.vobj = popVObject();
- ;
- break;}
+ }
+ break;
case 13:
-#line 251 "./vcc.y"
+#line 250 "vcc.y"
{
lexPushMode(L_VALUES);
- ;
- break;}
+ }
+ break;
case 14:
-#line 255 "./vcc.y"
+#line 254 "vcc.y"
{
if (lexWithinMode(L_BASE64) || lexWithinMode(L_QUOTED_PRINTABLE))
lexPopMode(0);
lexPopMode(0);
- ;
- break;}
+ }
+ break;
case 16:
-#line 264 "./vcc.y"
+#line 263 "vcc.y"
{
enterProps(yyvsp[0].str);
- ;
- break;}
+ }
+ break;
case 18:
-#line 269 "./vcc.y"
+#line 268 "vcc.y"
{
enterProps(yyvsp[0].str);
- ;
- break;}
+ }
+ break;
case 22:
-#line 282 "./vcc.y"
+#line 281 "vcc.y"
{
enterAttr(yyvsp[0].str,0);
- ;
- break;}
+ }
+ break;
case 23:
-#line 286 "./vcc.y"
+#line 285 "vcc.y"
{
enterAttr(yyvsp[-2].str,yyvsp[0].str);
- ;
- break;}
+ }
+ break;
case 25:
-#line 295 "./vcc.y"
-{ appendValue(yyvsp[-1].str); ;
- break;}
+#line 294 "vcc.y"
+{ enterValues(yyvsp[-1].str); }
+ break;
case 27:
-#line 297 "./vcc.y"
-{ appendValue(yyvsp[0].str); ;
- break;}
+#line 296 "vcc.y"
+{ enterValues(yyvsp[0].str); }
+ break;
case 29:
-#line 302 "./vcc.y"
-{ yyval.str = 0; ;
- break;}
+#line 300 "vcc.y"
+{ yyval.str = 0; }
+ break;
case 30:
-#line 307 "./vcc.y"
-{ if (!pushVObject(VCCalProp)) YYERROR; ;
- break;}
+#line 305 "vcc.y"
+{ if (!pushVObject(VCCalProp)) YYERROR; }
+ break;
case 31:
-#line 310 "./vcc.y"
-{ yyval.vobj = popVObject(); ;
- break;}
+#line 308 "vcc.y"
+{ yyval.vobj = popVObject(); }
+ break;
case 32:
-#line 312 "./vcc.y"
-{ if (!pushVObject(VCCalProp)) YYERROR; ;
- break;}
+#line 310 "vcc.y"
+{ if (!pushVObject(VCCalProp)) YYERROR; }
+ break;
case 33:
-#line 314 "./vcc.y"
-{ yyval.vobj = popVObject(); ;
- break;}
+#line 312 "vcc.y"
+{ yyval.vobj = popVObject(); }
+ break;
case 39:
-#line 329 "./vcc.y"
+#line 327 "vcc.y"
{
lexPushMode(L_VEVENT);
if (!pushVObject(VCEventProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 40:
-#line 335 "./vcc.y"
+#line 333 "vcc.y"
{
lexPopMode(0);
popVObject();
- ;
- break;}
+ }
+ break;
case 41:
-#line 340 "./vcc.y"
+#line 338 "vcc.y"
{
lexPushMode(L_VEVENT);
if (!pushVObject(VCEventProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 42:
-#line 345 "./vcc.y"
+#line 343 "vcc.y"
{
lexPopMode(0);
popVObject();
- ;
- break;}
+ }
+ break;
case 43:
-#line 353 "./vcc.y"
+#line 351 "vcc.y"
{
lexPushMode(L_VTODO);
if (!pushVObject(VCTodoProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 44:
-#line 359 "./vcc.y"
+#line 357 "vcc.y"
{
lexPopMode(0);
popVObject();
- ;
- break;}
+ }
+ break;
case 45:
-#line 364 "./vcc.y"
+#line 362 "vcc.y"
{
lexPushMode(L_VTODO);
if (!pushVObject(VCTodoProp)) YYERROR;
- ;
- break;}
+ }
+ break;
case 46:
-#line 369 "./vcc.y"
+#line 367 "vcc.y"
{
lexPopMode(0);
popVObject();
- ;
- break;}
+ }
+ break;
}
- /* the action file gets copied in in place of this dollarsign */
-#line 543 "/usr/share/bison.simple"
+#line 705 "/usr/share/bison/bison.simple"
+
+
yyvsp -= yylen;
yyssp -= yylen;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp -= yylen;
#endif
-#if YYDEBUG != 0
+#if YYDEBUG
if (yydebug)
{
- short *ssp1 = yyss - 1;
- fprintf (stderr, "state stack now");
- while (ssp1 != yyssp)
- fprintf (stderr, " %d", *++ssp1);
- fprintf (stderr, "\n");
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
}
#endif
*++yyvsp = yyval;
-
-#ifdef YYLSP_NEEDED
- yylsp++;
- if (yylen == 0)
- {
- yylsp->first_line = yylloc.first_line;
- yylsp->first_column = yylloc.first_column;
- yylsp->last_line = (yylsp-1)->last_line;
- yylsp->last_column = (yylsp-1)->last_column;
- yylsp->text = 0;
- }
- else
- {
- yylsp->last_line = (yylsp+yylen-1)->last_line;
- yylsp->last_column = (yylsp+yylen-1)->last_column;
- }
+#if YYLSP_NEEDED
+ *++yylsp = yyloc;
#endif
- /* Now "shift" the result of the reduction.
- Determine what state that goes to,
- based on the state we popped back to
- and the rule number reduced by. */
+ /* Now `shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
-yyerrlab: /* here on detecting error */
- if (! yyerrstatus)
- /* If not already recovering from an error, report this error. */
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
{
++yynerrs;
#ifdef YYERROR_VERBOSE
yyn = yypact[yystate];
if (yyn > YYFLAG && yyn < YYLAST)
{
- int size = 0;
- char *msg;
- int x, count;
-
- count = 0;
- /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
- for (x = (yyn < 0 ? -yyn : 0);
- x < (sizeof(yytname) / sizeof(char *)); x++)
- if (yycheck[x + yyn] == x)
- size += strlen(yytname[x]) + 15, count++;
- msg = (char *) malloc(size + 15);
- if (msg != 0)
+ YYSIZE_T yysize = 0;
+ char *yymsg;
+ int yyx, yycount;
+
+ yycount = 0;
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+ if (yycheck[yyx + yyn] == yyx)
+ yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+ yysize += yystrlen ("parse error, unexpected ") + 1;
+ yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+ yymsg = (char *) YYSTACK_ALLOC (yysize);
+ if (yymsg != 0)
{
- strcpy(msg, "parse error");
+ char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+ yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
- if (count < 5)
+ if (yycount < 5)
{
- count = 0;
- for (x = (yyn < 0 ? -yyn : 0);
- x < (sizeof(yytname) / sizeof(char *)); x++)
- if (yycheck[x + yyn] == x)
+ yycount = 0;
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *));
+ yyx++)
+ if (yycheck[yyx + yyn] == yyx)
{
- strcat(msg, count == 0 ? ", expecting `" : " or `");
- strcat(msg, yytname[x]);
- strcat(msg, "'");
- count++;
+ const char *yyq = ! yycount ? ", expecting " : " or ";
+ yyp = yystpcpy (yyp, yyq);
+ yyp = yystpcpy (yyp, yytname[yyx]);
+ yycount++;
}
}
- yyerror(msg);
- free(msg);
+ yyerror (yymsg);
+ YYSTACK_FREE (yymsg);
}
else
- yyerror ("parse error; also virtual memory exceeded");
+ yyerror ("parse error; also virtual memory exhausted");
}
else
-#endif /* YYERROR_VERBOSE */
- yyerror("parse error");
+#endif /* defined (YYERROR_VERBOSE) */
+ yyerror ("parse error");
}
-
goto yyerrlab1;
-yyerrlab1: /* here on error raised explicitly by an action */
+
+/*--------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action |
+`--------------------------------------------------*/
+yyerrlab1:
if (yyerrstatus == 3)
{
- /* if just tried and failed to reuse lookahead token after an error, discard it. */
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;
-
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
-
+ YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+ yychar, yytname[yychar1]));
yychar = YYEMPTY;
}
- /* Else will try to reuse lookahead token
- after shifting the error token. */
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
goto yyerrhandle;
-yyerrdefault: /* current state does not do anything special for the error token. */
+/*-------------------------------------------------------------------.
+| yyerrdefault -- current state does not do anything special for the |
+| error token. |
+`-------------------------------------------------------------------*/
+yyerrdefault:
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
- yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
- if (yyn) goto yydefault;
+
+ /* If its default is to accept any token, ok. Otherwise pop it. */
+ yyn = yydefact[yystate];
+ if (yyn)
+ goto yydefault;
#endif
-yyerrpop: /* pop the current state because it cannot handle the error token */
- if (yyssp == yyss) YYABORT;
+/*---------------------------------------------------------------.
+| yyerrpop -- pop the current state because it cannot handle the |
+| error token |
+`---------------------------------------------------------------*/
+yyerrpop:
+ if (yyssp == yyss)
+ YYABORT;
yyvsp--;
yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp--;
#endif
-#if YYDEBUG != 0
+#if YYDEBUG
if (yydebug)
{
- short *ssp1 = yyss - 1;
- fprintf (stderr, "Error: state stack now");
- while (ssp1 != yyssp)
- fprintf (stderr, " %d", *++ssp1);
- fprintf (stderr, "\n");
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "Error: state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
}
#endif
+/*--------------.
+| yyerrhandle. |
+`--------------*/
yyerrhandle:
-
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;
yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
goto yyerrdefault;
yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrpop;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrpop;
if (yyn == YYFINAL)
YYACCEPT;
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Shifting error token, ");
-#endif
+ YYDPRINTF ((stderr, "Shifting error token, "));
*++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
*++yylsp = yylloc;
#endif
yystate = yyn;
goto yynewstate;
- yyacceptlab:
- /* YYACCEPT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 0;
- yyabortlab:
- /* YYABORT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+/*---------------------------------------------.
+| yyoverflowab -- parser overflow comes here. |
+`---------------------------------------------*/
+yyoverflowlab:
+ yyerror ("parser stack overflow");
+ yyresult = 2;
+ /* Fall through. */
+
+yyreturn:
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
#endif
- }
- return 1;
+ return yyresult;
}
-#line 375 "./vcc.y"
+#line 373 "vcc.y"
-/****************************************************************************/
static int pushVObject(const char *prop)
{
VObject *newObj;
if (ObjStackTop == MAXLEVEL)
return FALSE;
ObjStack[++ObjStackTop] = curObj;
if (curObj) {
newObj = addProp(curObj,prop);
curObj = newObj;
}
else
curObj = newVObject(prop);
return TRUE;
}
-/****************************************************************************/
/* This pops the recently built vCard off the stack and returns it. */
static VObject* popVObject()
{
VObject *oldObj;
if (ObjStackTop < 0) {
yyerror("pop on empty Object Stack\n");
return 0;
}
oldObj = curObj;
curObj = ObjStack[ObjStackTop--];
return oldObj;
}
-/* static void enterValues(const char *value) */
-/* { */
-/* if (fieldedProp && *fieldedProp) { */
-/* if (value) { */
-/* addPropValue(curProp,*fieldedProp,value); */
-/* } */
- /* else this field is empty, advance to next field */
-/* fieldedProp++; */
-/* } */
-/* else { */
-/* if (value) { */
-/* setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); */
-/* } */
-/* } */
-/* deleteStr(value); */
-/* } */
-
-static void appendValue(const char *value)
-{
- char *p1, *p2;
- wchar_t *p3;
- int i;
-
- if (fieldedProp && *fieldedProp) {
- if (value) {
- addPropValue(curProp, *fieldedProp, value);
+static void enterValues(const char *value)
+ {
+ if (fieldedProp && *fieldedProp) {
+ if (value) {
+ addPropValue(curProp,*fieldedProp,value);
+ }
+ /* else this field is empty, advance to next field */
+ fieldedProp++;
+ }
+ else {
+ if (value) {
+ char *p1, *p2;
+ wchar_t *p3;
+ int i;
+
+ /* If the property already has a string value, we append this one,
+ using ';' to separate the values. */
+ if (vObjectUStringZValue(curProp)) {
+ p1 = fakeCString(vObjectUStringZValue(curProp));
+ p2 = malloc((strlen(p1)+strlen(value)+1));
+ strcpy(p2, p1);
+ deleteStr(p1);
+
+ i = strlen(p2);
+ p2[i] = ';';
+ p2[i+1] = '\0';
+ p2 = strcat(p2, value);
+ p3 = (wchar_t *) vObjectUStringZValue(curProp);
+ free(p3);
+ setVObjectUStringZValue_(curProp,fakeUnicode(p2,0));
+ deleteStr(p2);
+ } else {
+ setVObjectUStringZValue_(curProp,fakeUnicode(value,0));
+ }
+ }
}
- /* else this field is empty, advance to next field */
- fieldedProp++;
- } else {
- if (value) {
- if (vObjectUStringZValue(curProp)) {
- p1 = fakeCString(vObjectUStringZValue(curProp));
- p2 = malloc(sizeof(char *) * (strlen(p1)+strlen(value)+1));
- strcpy(p2, p1);
- deleteStr(p1);
-
- i = strlen(p2);
- p2[i] = ',';
- p2[i+1] = '\0';
- p2 = strcat(p2, value);
- p3 = (wchar_t *) vObjectUStringZValue(curProp);
- free(p3);
- setVObjectUStringZValue_(curProp,fakeUnicode(p2,0));
- deleteStr(p2);
- } else {
- setVObjectUStringZValue_(curProp,fakeUnicode(value,0));
- }
+ deleteStr(value);
}
- }
- deleteStr(value);
-}
-
static void enterProps(const char *s)
{
curProp = addGroup(curObj,s);
deleteStr(s);
}
static void enterAttr(const char *s1, const char *s2)
{
- const char *p1=0L, *p2=0L;
+ const char *p1, *p2;
p1 = lookupProp_(s1);
if (s2) {
VObject *a;
p2 = lookupProp_(s2);
a = addProp(curProp,p1);
setVObjectStringZValue(a,p2);
}
else
addProp(curProp,p1);
- if (strcasecmp(p1,VCBase64Prop) == 0 || (s2 && strcasecmp(p2,VCBase64Prop)==0))
+ if (stricmp(p1,VCBase64Prop) == 0 || (s2 && stricmp(p2,VCBase64Prop)==0))
lexPushMode(L_BASE64);
- else if (strcasecmp(p1,VCQuotedPrintableProp) == 0
- || (s2 && strcasecmp(p2,VCQuotedPrintableProp)==0))
+ else if (stricmp(p1,VCQuotedPrintableProp) == 0
+ || (s2 && stricmp(p2,VCQuotedPrintableProp)==0))
lexPushMode(L_QUOTED_PRINTABLE);
deleteStr(s1); deleteStr(s2);
}
#define MAX_LEX_LOOKAHEAD_0 32
#define MAX_LEX_LOOKAHEAD 64
#define MAX_LEX_MODE_STACK_SIZE 10
#define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop])
struct LexBuf {
/* input */
+#ifdef INCLUDEMFC
+ CFile *inputFile;
+#else
FILE *inputFile;
+#endif
char *inputString;
unsigned long curPos;
unsigned long inputLen;
/* lookahead buffer */
/* -- lookahead buffer is short instead of char so that EOF
/ can be represented correctly.
*/
unsigned long len;
short buf[MAX_LEX_LOOKAHEAD];
unsigned long getPtr;
/* context stack */
unsigned long lexModeStackTop;
enum LexMode lexModeStack[MAX_LEX_MODE_STACK_SIZE];
/* token buffer */
unsigned long maxToken;
char *strs;
@@ -1456,44 +1634,46 @@ static void lexPopMode(int top)
{
/* special case of pop for ease of error recovery -- this
version will never underflow */
if (top)
lexBuf.lexModeStackTop = 0;
else
if (lexBuf.lexModeStackTop > 0) lexBuf.lexModeStackTop--;
}
static int lexWithinMode(enum LexMode mode) {
unsigned long i;
for (i=0;i<lexBuf.lexModeStackTop;i++)
if (mode == lexBuf.lexModeStack[i]) return 1;
return 0;
}
-static int lexGetc_()
+static char lexGetc_()
{
/* get next char from input, no buffering. */
if (lexBuf.curPos == lexBuf.inputLen)
return EOF;
else if (lexBuf.inputString)
return *(lexBuf.inputString + lexBuf.curPos++);
else {
- if (!feof(lexBuf.inputFile))
- return fgetc(lexBuf.inputFile);
- else
- return EOF;
+#ifdef INCLUDEMFC
+ char result;
+ return lexBuf.inputFile->Read(&result, 1) == 1 ? result : EOF;
+#else
+ return fgetc(lexBuf.inputFile);
+#endif
}
}
static int lexGeta()
{
++lexBuf.len;
return (lexBuf.buf[lexBuf.getPtr] = lexGetc_());
}
static int lexGeta_(int i)
{
++lexBuf.len;
return (lexBuf.buf[(lexBuf.getPtr+i)%MAX_LEX_LOOKAHEAD] = lexGetc_());
}
static void lexSkipLookahead() {
@@ -1506,127 +1686,104 @@ static void lexSkipLookahead() {
static int lexLookahead() {
int c = (lexBuf.len)?
lexBuf.buf[lexBuf.getPtr]:
lexGeta();
/* do the \r\n -> \n or \r -> \n translation here */
if (c == '\r') {
int a = (lexBuf.len>1)?
lexBuf.buf[(lexBuf.getPtr+1)%MAX_LEX_LOOKAHEAD]:
lexGeta_(1);
if (a == '\n') {
lexSkipLookahead();
}
lexBuf.buf[lexBuf.getPtr] = c = '\n';
}
else if (c == '\n') {
- int a;
- if (lexBuf.len > 1)
- a = lexBuf.buf[lexBuf.getPtr];
- else
- a = lexGeta_(1);
+ int a = (lexBuf.len>1)?
+ lexBuf.buf[lexBuf.getPtr+1]:
+ lexGeta_(1);
if (a == '\r') {
lexSkipLookahead();
}
lexBuf.buf[lexBuf.getPtr] = '\n';
}
return c;
}
static int lexGetc() {
int c = lexLookahead();
if (lexBuf.len > 0 && lexBuf.buf[lexBuf.getPtr]!=EOF) {
/* EOF will remain in lookahead buffer */
lexBuf.getPtr = (lexBuf.getPtr + 1) % MAX_LEX_LOOKAHEAD;
lexBuf.len--;
}
return c;
}
static void lexSkipLookaheadWord() {
if (lexBuf.strsLen <= lexBuf.len) {
lexBuf.len -= lexBuf.strsLen;
lexBuf.getPtr = (lexBuf.getPtr + lexBuf.strsLen) % MAX_LEX_LOOKAHEAD;
}
}
static void lexClearToken()
{
lexBuf.strsLen = 0;
}
static void lexAppendc(int c)
{
- /* not sure if I am doing this right to fix purify report -- PGB */
- lexBuf.strs = (char *) realloc(lexBuf.strs, (size_t) lexBuf.strsLen + 1);
lexBuf.strs[lexBuf.strsLen] = c;
/* append up to zero termination */
if (c == 0) return;
lexBuf.strsLen++;
if (lexBuf.strsLen > lexBuf.maxToken) {
/* double the token string size */
lexBuf.maxToken <<= 1;
lexBuf.strs = (char*) realloc(lexBuf.strs,(size_t)lexBuf.maxToken);
}
}
static char* lexStr() {
return dupStr(lexBuf.strs,(size_t)lexBuf.strsLen+1);
}
static void lexSkipWhite() {
int c = lexLookahead();
while (c == ' ' || c == '\t') {
lexSkipLookahead();
c = lexLookahead();
}
}
static char* lexGetWord() {
int c;
lexSkipWhite();
lexClearToken();
c = lexLookahead();
- /* some "words" have a space in them, like "NEEDS ACTION".
- this may be an oversight of the spec, but it is true nevertheless.
- while (c != EOF && !strchr("\t\n ;:=",c)) { */
- while (c != EOF && !strchr("\n;:=",c)) {
+ while (c != EOF && !strchr("\t\n ;:=",c)) {
lexAppendc(c);
lexSkipLookahead();
c = lexLookahead();
}
lexAppendc(0);
return lexStr();
}
-void lexPushLookahead(char *s, int len) {
- int putptr;
- if (len == 0) len = strlen(s);
- putptr = (int)lexBuf.getPtr - len;
- /* this function assumes that length of word to push back
- / is not greater than MAX_LEX_LOOKAHEAD.
- */
- if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD;
- lexBuf.getPtr = putptr;
- while (*s) {
- lexBuf.buf[putptr] = *s++;
- putptr = (putptr + 1) % MAX_LEX_LOOKAHEAD;
- }
- lexBuf.len += len;
- }
-
static void lexPushLookaheadc(int c) {
int putptr;
/* can't putback EOF, because it never leaves lookahead buffer */
if (c == EOF) return;
putptr = (int)lexBuf.getPtr - 1;
if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD;
lexBuf.getPtr = putptr;
lexBuf.buf[putptr] = c;
lexBuf.len += 1;
}
static char* lexLookaheadWord() {
/* this function can lookahead word with max size of MAX_LEX_LOOKAHEAD_0
/ and thing bigger than that will stop the lookahead and return 0;
/ leading white spaces are not recoverable.
*/
@@ -1709,85 +1866,77 @@ static char* lexGet1Value() {
lexPushLookaheadc('\n');
break;
}
}
else {
lexAppendc(c);
lexSkipLookahead();
}
c = lexLookahead();
}
lexAppendc(0);
handleMoreRFC822LineBreak(c);
return c==EOF?0:lexStr();
}
#endif
-char* lexGetStrUntil(char *termset) {
- int c = lexLookahead();
- lexClearToken();
- while (c != EOF && !strchr(termset,c)) {
- lexAppendc(c);
- lexSkipLookahead();
- c = lexLookahead();
- }
- lexAppendc(0);
- return c==EOF?0:lexStr();
- }
static int match_begin_name(int end) {
char *n = lexLookaheadWord();
int token = ID;
if (n) {
- if (!strcasecmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD;
- else if (!strcasecmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL;
- else if (!strcasecmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT;
- else if (!strcasecmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO;
+ if (!stricmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD;
+ else if (!stricmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL;
+ else if (!stricmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT;
+ else if (!stricmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO;
deleteStr(n);
return token;
}
return 0;
}
+#ifdef INCLUDEMFC
+void initLex(const char *inputstring, unsigned long inputlen, CFile *inputfile)
+#else
void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile)
+#endif
{
/* initialize lex mode stack */
lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL;
/* iniatialize lex buffer. */
lexBuf.inputString = (char*) inputstring;
lexBuf.inputLen = inputlen;
lexBuf.curPos = 0;
lexBuf.inputFile = inputfile;
lexBuf.len = 0;
lexBuf.getPtr = 0;
lexBuf.maxToken = MAXTOKEN;
lexBuf.strs = (char*)malloc(MAXTOKEN);
lexBuf.strsLen = 0;
}
static void finiLex() {
free(lexBuf.strs);
}
-/****************************************************************************/
/* This parses and converts the base64 format for binary encoding into
* a decoded buffer (allocated with new). See RFC 1521.
*/
static char * lexGetDataFromBase64()
{
unsigned long bytesLen = 0, bytesMax = 0;
int quadIx = 0, pad = 0;
unsigned long trip = 0;
unsigned char b;
int c;
unsigned char *bytes = NULL;
unsigned char *oldBytes = NULL;
DBG_(("db: lexGetDataFromBase64\n"));
while (1) {
c = lexGetc();
@@ -1944,41 +2093,43 @@ static char* lexGetQuotedPrintable()
lexPushLookaheadc('\n');
goto EndString;
}
case (char)EOF:
break;
default:
lexAppendc(cur);
break;
} /* switch */
} while (cur != (char)EOF);
EndString:
lexAppendc(0);
return lexStr();
} /* LexQuotedPrintable */
-static int yylex() {
+int yylex() {
int lexmode = LEXMODE();
if (lexmode == L_VALUES) {
int c = lexGetc();
if (c == ';') {
DBG_(("db: SEMICOLON\n"));
lexPushLookaheadc(c);
+#ifdef _SUPPORT_LINE_FOLDING
handleMoreRFC822LineBreak(c);
+#endif
lexSkipLookahead();
return SEMICOLON;
}
else if (strchr("\n",c)) {
++mime_lineNum;
/* consume all line separator(s) adjacent to each other */
c = lexLookahead();
while (strchr("\n",c)) {
lexSkipLookahead();
c = lexLookahead();
++mime_lineNum;
}
DBG_(("db: LINESEP\n"));
return LINESEP;
}
else {
@@ -1995,164 +2146,170 @@ static int yylex() {
}
else {
#ifdef _SUPPORT_LINE_FOLDING
p = lexGet1Value();
#else
p = lexGetStrUntil(";\n");
#endif
}
if (p) {
DBG_(("db: STRING: '%s'\n", p));
yylval.str = p;
return STRING;
}
else return 0;
}
}
-
else {
/* normal mode */
while (1) {
int c = lexGetc();
switch(c) {
case ':': {
/* consume all line separator(s) adjacent to each other */
/* ignoring linesep immediately after colon. */
- c = lexLookahead();
+/* c = lexLookahead();
while (strchr("\n",c)) {
lexSkipLookahead();
c = lexLookahead();
++mime_lineNum;
- }
+ }*/
DBG_(("db: COLON\n"));
return COLON;
}
case ';':
DBG_(("db: SEMICOLON\n"));
return SEMICOLON;
case '=':
DBG_(("db: EQ\n"));
return EQ;
- /* ignore tabs/newlines in this mode. We can't ignore
- * spaces, because values like NEEDS ACTION have a space. */
- case '\t': continue;
+ /* ignore whitespace in this mode */
+ case '\t':
+ case ' ': continue;
case '\n': {
++mime_lineNum;
continue;
}
case EOF: return 0;
break;
- default: {
- lexPushLookaheadc(c);
- /* pending lutz : why linker error with isalpha(c)? */
- /*if ( isalpha(c) || c == ' ') { */
- if ( ( c >= 'A' && c <= 'Z') || ( c >= 'a' && c <= 'z') || c == ' ') {
-
+ default: {
+ lexPushLookaheadc(c);
+ if (isalpha(c)) {
char *t = lexGetWord();
yylval.str = t;
- if (!strcasecmp(t, "begin")) {
+ if (!stricmp(t, "begin")) {
return match_begin_end_name(0);
}
- else if (!strcasecmp(t,"end")) {
+ else if (!stricmp(t,"end")) {
return match_begin_end_name(1);
}
else {
DBG_(("db: ID '%s'\n", t));
return ID;
}
}
else {
- /* unknown token */
+ /* unknow token */
return 0;
- }
+ }
break;
}
}
}
}
-
return 0;
}
/***************************************************************************/
-/*** Public Functions ****/
+/*** Public Functions ****/
/***************************************************************************/
static VObject* Parse_MIMEHelper()
{
ObjStackTop = -1;
mime_numErrors = 0;
mime_lineNum = 1;
vObjList = 0;
curObj = 0;
if (yyparse() != 0)
return 0;
finiLex();
return vObjList;
}
-/****************************************************************************/
-VObject* Parse_MIME(const char *input, unsigned long len)
+DLLEXPORT(VObject*) Parse_MIME(const char *input, unsigned long len)
{
initLex(input, len, 0);
return Parse_MIMEHelper();
}
+#if INCLUDEMFC
+
+DLLEXPORT(VObject*) Parse_MIME_FromFile(CFile *file)
+ {
+ unsigned long startPos;
+ VObject *result;
+
+ initLex(0,-1,file);
+ startPos = file->GetPosition();
+ if (!(result = Parse_MIMEHelper()))
+ file->Seek(startPos, CFile::begin);
+ return result;
+ }
+
+#else
+
VObject* Parse_MIME_FromFile(FILE *file)
{
- VObject *result;
+ VObject *result;
long startPos;
initLex(0,(unsigned long)-1,file);
startPos = ftell(file);
if (!(result = Parse_MIMEHelper())) {
fseek(file,startPos,SEEK_SET);
}
return result;
}
-VObject* Parse_MIME_FromFileName(const char *fname)
+DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname)
{
FILE *fp = fopen(fname,"r");
if (fp) {
VObject* o = Parse_MIME_FromFile(fp);
fclose(fp);
return o;
}
else {
- char msg[255];
- sprintf(msg, "can't open file '%s' for reading\n", fname);
+ char msg[256];
+ snprintf(msg, sizeof(msg), "can't open file '%s' for reading\n", fname);
mime_error_(msg);
return 0;
}
}
-/****************************************************************************/
-void YYDebug(const char *s)
-{
- Parse_Debug(s);
-}
+#endif
static MimeErrorHandler mimeErrorHandler;
-void registerMimeErrorHandler(MimeErrorHandler me)
+DLLEXPORT(void) registerMimeErrorHandler(MimeErrorHandler me)
{
mimeErrorHandler = me;
}
static void mime_error(char *s)
{
char msg[256];
if (mimeErrorHandler) {
sprintf(msg,"%s at line %d", s, mime_lineNum);
mimeErrorHandler(msg);
}
}
static void mime_error_(char *s)
{
if (mimeErrorHandler) {
diff --git a/libkcal/versit/vcc.h b/libkcal/versit/vcc.h
index 03886d1..0e52034 100644
--- a/libkcal/versit/vcc.h
+++ b/libkcal/versit/vcc.h
@@ -35,42 +35,46 @@ disclosure by the government are subject to restrictions set forth in
DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
***************************************************************************/
#ifndef __VCC_H__
#define __VCC_H__ 1
#include "vobject.h"
#if defined(__CPLUSPLUS__) || defined(__cplusplus)
extern "C" {
#endif
typedef void (*MimeErrorHandler)(char *);
-extern void registerMimeErrorHandler(MimeErrorHandler);
+extern DLLEXPORT(void) registerMimeErrorHandler(MimeErrorHandler);
-extern VObject* Parse_MIME(const char *input, unsigned long len);
-extern VObject* Parse_MIME_FromFileName(const char* fname);
+extern DLLEXPORT(VObject*) Parse_MIME(const char *input, unsigned long len);
+extern DLLEXPORT(VObject*) Parse_MIME_FromFileName(char* fname);
/* NOTE regarding Parse_MIME_FromFile
-The function below, Parse_MIME_FromFile, come in two flavors,
+The function above, Parse_MIME_FromFile, comes in two flavors,
neither of which is exported from the DLL. Each version takes
a CFile or FILE* as a parameter, neither of which can be
passed across a DLL interface (at least that is my experience).
If you are linking this code into your build directly then
you may find them a more convenient API that the other flavors
that take a file name. If you use them with the DLL LIB you
will get a link error.
*/
+#if INCLUDEMFC
+extern VObject* Parse_MIME_FromFile(CFile *file);
+#else
extern VObject* Parse_MIME_FromFile(FILE *file);
+#endif
#if defined(__CPLUSPLUS__) || defined(__cplusplus)
}
#endif
#endif /* __VCC_H__ */
diff --git a/libkcal/versit/vobject.c b/libkcal/versit/vobject.c
index 637efb2..3fac63e 100644
--- a/libkcal/versit/vobject.c
+++ b/libkcal/versit/vobject.c
@@ -29,236 +29,255 @@ EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.
The software is provided with RESTRICTED RIGHTS. Use, duplication, or
disclosure by the government are subject to restrictions set forth in
DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
***************************************************************************/
/*
* src: vobject.c
* doc: vobject and APIs to construct vobject, APIs pretty print
* vobject, and convert a vobject into its textual representation.
*/
-#include <stdlib.h>
+#ifdef WIN32
+#define snprintf _snprintf
+#define strcasecmp stricmp
+#endif
#include "vobject.h"
+#include <stdlib.h>
#include <string.h>
#include <stdio.h>
-#ifdef _WIN32_
+#include <fcntl.h>
- #define strcasecmp _stricmp
-#endif
-
-#define NAME_OF(o) o->id
+#define NAME_OF(o) o->id
#define VALUE_TYPE(o) o->valType
#define STRINGZ_VALUE_OF(o) o->val.strs
#define USTRINGZ_VALUE_OF(o) o->val.ustrs
#define INTEGER_VALUE_OF(o) o->val.i
#define LONG_VALUE_OF(o) o->val.l
#define ANY_VALUE_OF(o) o->val.any
#define VOBJECT_VALUE_OF(o) o->val.vobj
+typedef union ValueItem {
+ const char *strs;
+ const wchar_t *ustrs;
+ unsigned int i;
+ unsigned long l;
+ void *any;
+ VObject *vobj;
+ } ValueItem;
+
+struct VObject {
+ VObject *next;
+ const char *id;
+ VObject *prop;
+ unsigned short valType;
+ ValueItem val;
+ };
+
+typedef struct StrItem StrItem;
+
+struct StrItem {
+ StrItem *next;
+ const char *s;
+ unsigned int refCnt;
+ };
+
const char** fieldedProp;
/*----------------------------------------------------------------------
The following functions involve with memory allocation:
newVObject
deleteVObject
dupStr
deleteStr
newStrItem
deleteStrItem
----------------------------------------------------------------------*/
-VObject* newVObject_(const char *id)
+DLLEXPORT(VObject*) newVObject_(const char *id)
{
VObject *p = (VObject*)malloc(sizeof(VObject));
p->next = 0;
p->id = id;
p->prop = 0;
VALUE_TYPE(p) = 0;
ANY_VALUE_OF(p) = 0;
return p;
}
-VObject* newVObject(const char *id)
+DLLEXPORT(VObject*) newVObject(const char *id)
{
return newVObject_(lookupStr(id));
}
-void deleteVObject(VObject *p)
+DLLEXPORT(void) deleteVObject(VObject *p)
{
- if (p->id)
unUseStr(p->id);
- if (p)
free(p);
- p = NULL;
}
-char* dupStr(const char *s, unsigned int size)
+DLLEXPORT(char*) dupStr(const char *s, unsigned int size)
{
char *t;
if (size == 0) {
size = strlen(s);
}
t = (char*)malloc(size+1);
if (t) {
memcpy(t,s,size);
t[size] = 0;
return t;
}
else {
return (char*)0;
}
}
-void deleteStr(const char *p)
+DLLEXPORT(void) deleteStr(const char *p)
{
- if (p)
- free((void*)p);
- p = NULL;
+ if (p) free((void*)p);
}
static StrItem* newStrItem(const char *s, StrItem *next)
{
StrItem *p = (StrItem*)malloc(sizeof(StrItem));
p->next = next;
p->s = s;
p->refCnt = 1;
return p;
}
static void deleteStrItem(StrItem *p)
{
- if (p)
- free((void*)p);
- p = NULL;
+ free((void*)p);
}
/*----------------------------------------------------------------------
The following function provide accesses to VObject's value.
----------------------------------------------------------------------*/
-const char* vObjectName(VObject *o)
+DLLEXPORT(const char*) vObjectName(VObject *o)
{
return NAME_OF(o);
}
-void setVObjectName(VObject *o, const char* id)
+DLLEXPORT(void) setVObjectName(VObject *o, const char* id)
{
NAME_OF(o) = id;
}
-const char* vObjectStringZValue(VObject *o)
+DLLEXPORT(const char*) vObjectStringZValue(VObject *o)
{
return STRINGZ_VALUE_OF(o);
}
-void setVObjectStringZValue(VObject *o, const char *s)
+DLLEXPORT(void) setVObjectStringZValue(VObject *o, const char *s)
{
STRINGZ_VALUE_OF(o) = dupStr(s,0);
VALUE_TYPE(o) = VCVT_STRINGZ;
}
-void setVObjectStringZValue_(VObject *o, const char *s)
+DLLEXPORT(void) setVObjectStringZValue_(VObject *o, const char *s)
{
STRINGZ_VALUE_OF(o) = s;
VALUE_TYPE(o) = VCVT_STRINGZ;
}
-const wchar_t* vObjectUStringZValue(VObject *o)
+DLLEXPORT(const wchar_t*) vObjectUStringZValue(VObject *o)
{
return USTRINGZ_VALUE_OF(o);
}
-void setVObjectUStringZValue(VObject *o, const wchar_t *s)
+DLLEXPORT(void) setVObjectUStringZValue(VObject *o, const wchar_t *s)
{
USTRINGZ_VALUE_OF(o) = (wchar_t*) dupStr((char*)s,(uStrLen(s)+1)*2);
VALUE_TYPE(o) = VCVT_USTRINGZ;
}
-void setVObjectUStringZValue_(VObject *o, const wchar_t *s)
+DLLEXPORT(void) setVObjectUStringZValue_(VObject *o, const wchar_t *s)
{
USTRINGZ_VALUE_OF(o) = s;
VALUE_TYPE(o) = VCVT_USTRINGZ;
}
-unsigned int vObjectIntegerValue(VObject *o)
+DLLEXPORT(unsigned int) vObjectIntegerValue(VObject *o)
{
return INTEGER_VALUE_OF(o);
}
-void setVObjectIntegerValue(VObject *o, unsigned int i)
+DLLEXPORT(void) setVObjectIntegerValue(VObject *o, unsigned int i)
{
INTEGER_VALUE_OF(o) = i;
VALUE_TYPE(o) = VCVT_UINT;
}
-unsigned long vObjectLongValue(VObject *o)
+DLLEXPORT(unsigned long) vObjectLongValue(VObject *o)
{
return LONG_VALUE_OF(o);
}
-void setVObjectLongValue(VObject *o, unsigned long l)
+DLLEXPORT(void) setVObjectLongValue(VObject *o, unsigned long l)
{
LONG_VALUE_OF(o) = l;
VALUE_TYPE(o) = VCVT_ULONG;
}
-void* vObjectAnyValue(VObject *o)
+DLLEXPORT(void*) vObjectAnyValue(VObject *o)
{
return ANY_VALUE_OF(o);
}
-void setVObjectAnyValue(VObject *o, void *t)
+DLLEXPORT(void) setVObjectAnyValue(VObject *o, void *t)
{
ANY_VALUE_OF(o) = t;
VALUE_TYPE(o) = VCVT_RAW;
}
-VObject* vObjectVObjectValue(VObject *o)
+DLLEXPORT(VObject*) vObjectVObjectValue(VObject *o)
{
return VOBJECT_VALUE_OF(o);
}
-void setVObjectVObjectValue(VObject *o, VObject *p)
+DLLEXPORT(void) setVObjectVObjectValue(VObject *o, VObject *p)
{
VOBJECT_VALUE_OF(o) = p;
VALUE_TYPE(o) = VCVT_VOBJECT;
}
-int vObjectValueType(VObject *o)
+DLLEXPORT(int) vObjectValueType(VObject *o)
{
return VALUE_TYPE(o);
}
/*----------------------------------------------------------------------
The following functions can be used to build VObject.
----------------------------------------------------------------------*/
-VObject* addVObjectProp(VObject *o, VObject *p)
+DLLEXPORT(VObject*) addVObjectProp(VObject *o, VObject *p)
{
/* circular link list pointed to tail */
/*
o {next,id,prop,val}
V
pn {next,id,prop,val}
V
...
p1 {next,id,prop,val}
V
pn
-->
o {next,id,prop,val}
V
pn {next,id,prop,val}
V
@@ -267,122 +286,122 @@ VObject* addVObjectProp(VObject *o, VObject *p)
p1 {next,id,prop,val}
V
pn
*/
VObject *tail = o->prop;
if (tail) {
p->next = tail->next;
o->prop = tail->next = p;
}
else {
o->prop = p->next = p;
}
return p;
}
-VObject* addProp(VObject *o, const char *id)
+DLLEXPORT(VObject*) addProp(VObject *o, const char *id)
{
return addVObjectProp(o,newVObject(id));
}
-VObject* addProp_(VObject *o, const char *id)
+DLLEXPORT(VObject*) addProp_(VObject *o, const char *id)
{
return addVObjectProp(o,newVObject_(id));
}
-void addList(VObject **o, VObject *p)
+DLLEXPORT(void) addList(VObject **o, VObject *p)
{
p->next = 0;
if (*o == 0) {
*o = p;
}
else {
VObject *t = *o;
while (t->next) {
t = t->next;
}
t->next = p;
}
}
-VObject* nextVObjectInList(VObject *o)
+DLLEXPORT(VObject*) nextVObjectInList(VObject *o)
{
return o->next;
}
-VObject* setValueWithSize_(VObject *prop, void *val, unsigned int size)
+DLLEXPORT(VObject*) setValueWithSize_(VObject *prop, void *val, unsigned int size)
{
VObject *sizeProp;
setVObjectAnyValue(prop, val);
sizeProp = addProp(prop,VCDataSizeProp);
setVObjectLongValue(sizeProp, size);
return prop;
}
-VObject* setValueWithSize(VObject *prop, void *val, unsigned int size)
+DLLEXPORT(VObject*) setValueWithSize(VObject *prop, void *val, unsigned int size)
{
- void *p = dupStr(val,size);
+ void *p = dupStr((const char *)val,size);
return setValueWithSize_(prop,p,p?size:0);
}
-void initPropIterator(VObjectIterator *i, VObject *o)
+DLLEXPORT(void) initPropIterator(VObjectIterator *i, VObject *o)
{
i->start = o->prop;
i->next = 0;
}
-void initVObjectIterator(VObjectIterator *i, VObject *o)
+DLLEXPORT(void) initVObjectIterator(VObjectIterator *i, VObject *o)
{
i->start = o->next;
i->next = 0;
}
-int moreIteration(VObjectIterator *i)
+DLLEXPORT(int) moreIteration(VObjectIterator *i)
{
return (i->start && (i->next==0 || i->next!=i->start));
}
-VObject* nextVObject(VObjectIterator *i)
+DLLEXPORT(VObject*) nextVObject(VObjectIterator *i)
{
if (i->start && i->next != i->start) {
if (i->next == 0) {
i->next = i->start->next;
return i->next;
}
else {
i->next = i->next->next;
return i->next;
}
}
else return (VObject*)0;
}
-VObject* isAPropertyOf(VObject *o, const char *id)
+DLLEXPORT(VObject*) isAPropertyOf(VObject *o, const char *id)
{
VObjectIterator i;
initPropIterator(&i,o);
while (moreIteration(&i)) {
VObject *each = nextVObject(&i);
- if (!strcasecmp(id,each->id))
+ if (!stricmp(id,each->id))
return each;
}
return (VObject*)0;
}
-VObject* addGroup(VObject *o, const char *g)
+DLLEXPORT(VObject*) addGroup(VObject *o, const char *g)
{
/*
a.b.c
-->
prop(c)
prop(VCGrouping=b)
prop(VCGrouping=a)
*/
char *dot = strrchr(g,'.');
if (dot) {
VObject *p, *t;
char *gs, *n = dot+1;
gs = dupStr(g,0); /* so we can write to it. */
/* used to be
* t = p = addProp_(o,lookupProp_(n));
*/
@@ -397,50 +416,50 @@ VObject* addGroup(VObject *o, const char *g)
}
else
n = gs;
/* property(VCGroupingProp=n);
* and the value may have VCGrouping property
*/
t = addProp(t,VCGroupingProp);
setVObjectStringZValue(t,lookupProp_(n));
} while (n != gs);
deleteStr(gs);
return p;
}
else
return addProp_(o,lookupProp(g));
}
-VObject* addPropValue(VObject *o, const char *p, const char *v)
+DLLEXPORT(VObject*) addPropValue(VObject *o, const char *p, const char *v)
{
VObject *prop;
prop = addProp(o,p);
setVObjectUStringZValue_(prop, fakeUnicode(v,0));
return prop;
}
-VObject* addPropSizedValue_(VObject *o, const char *p, const char *v,
+DLLEXPORT(VObject*) addPropSizedValue_(VObject *o, const char *p, const char *v,
unsigned int size)
{
VObject *prop;
prop = addProp(o,p);
setValueWithSize_(prop, (void*)v, size);
return prop;
}
-VObject* addPropSizedValue(VObject *o, const char *p, const char *v,
+DLLEXPORT(VObject*) addPropSizedValue(VObject *o, const char *p, const char *v,
unsigned int size)
{
return addPropSizedValue_(o,p,dupStr(v,size),size);
}
/*----------------------------------------------------------------------
The following pretty print a VObject
----------------------------------------------------------------------*/
static void printVObject_(FILE *fp, VObject *o, int level);
static void indent(FILE *fp, int level)
{
int i;
@@ -515,177 +534,173 @@ static void printVObject_(FILE *fp, VObject *o, int level)
fprintf(fp,"[NULL]\n");
return;
}
printNameValue(fp,o,level);
initPropIterator(&t,o);
while (moreIteration(&t)) {
VObject *eachProp = nextVObject(&t);
printVObject_(fp,eachProp,level+1);
}
}
void printVObject(FILE *fp,VObject *o)
{
printVObject_(fp,o,0);
}
-void printVObjectToFile(char *fname,VObject *o)
+DLLEXPORT(void) printVObjectToFile(char *fname,VObject *o)
{
FILE *fp = fopen(fname,"w");
if (fp) {
printVObject(fp,o);
fclose(fp);
}
}
-void printVObjectsToFile(char *fname,VObject *list)
+DLLEXPORT(void) printVObjectsToFile(char *fname,VObject *list)
{
FILE *fp = fopen(fname,"w");
if (fp) {
while (list) {
printVObject(fp,list);
list = nextVObjectInList(list);
}
fclose(fp);
}
}
-void cleanVObject(VObject *o)
+DLLEXPORT(void) cleanVObject(VObject *o)
{
if (o == 0) return;
if (o->prop) {
/* destroy time: cannot use the iterator here.
Have to break the cycle in the circular link
list and turns it into regular NULL-terminated
list -- since at some point of destruction,
the reference entry for the iterator to work
will not longer be valid.
*/
VObject *p;
p = o->prop->next;
o->prop->next = 0;
do {
VObject *t = p->next;
cleanVObject(p);
p = t;
} while (p);
}
switch (VALUE_TYPE(o)) {
case VCVT_USTRINGZ:
case VCVT_STRINGZ:
case VCVT_RAW:
- /* assume they are all allocated by malloc. */
+ /* assume they are all allocated by malloc. */
free((char*)STRINGZ_VALUE_OF(o));
break;
case VCVT_VOBJECT:
cleanVObject(VOBJECT_VALUE_OF(o));
break;
}
deleteVObject(o);
}
-void cleanVObjects(VObject *list)
+DLLEXPORT(void) cleanVObjects(VObject *list)
{
while (list) {
VObject *t = list;
list = nextVObjectInList(list);
cleanVObject(t);
}
}
/*----------------------------------------------------------------------
The following is a String Table Facilities.
----------------------------------------------------------------------*/
#define STRTBLSIZE 255
static StrItem *strTbl[STRTBLSIZE];
static unsigned int hashStr(const char *s)
{
unsigned int h = 0;
int i;
for (i=0;s[i];i++) {
h += s[i]*i;
}
return h % STRTBLSIZE;
}
-const char* lookupStr(const char *s)
+DLLEXPORT(const char*) lookupStr(const char *s)
{
- char *newS;
-
- StrItem *t;
- unsigned int h = hashStr(s);
- if ((t = strTbl[h]) != 0) {
- do {
- if (strcasecmp(t->s,s) == 0) {
- t->refCnt++;
- return t->s;
- }
- t = t->next;
- } while (t);
- }
- newS = dupStr(s,0);
- strTbl[h] = newStrItem(newS,strTbl[h]);
- return newS;
+ StrItem *t;
+ unsigned int h = hashStr(s);
+ if ((t = strTbl[h]) != 0) {
+ do {
+ if (stricmp(t->s,s) == 0) {
+ t->refCnt++;
+ return t->s;
+ }
+ t = t->next;
+ } while (t);
+ }
+ s = dupStr(s,0);
+ strTbl[h] = newStrItem(s,strTbl[h]);
+ return s;
}
-void unUseStr(const char *s)
+DLLEXPORT(void) unUseStr(const char *s)
{
- StrItem *cur, *prev;
-
+ StrItem *t, *p;
unsigned int h = hashStr(s);
- cur = strTbl[h];
- prev = cur;
- while (cur != 0) {
- if (strcasecmp(cur->s,s) == 0) {
- cur->refCnt--;
- /* if that was the last reference to this string, kill it. */
- if (cur->refCnt == 0) {
- if (cur == strTbl[h]) {
- strTbl[h] = cur->next;
- deleteStr(prev->s);
- deleteStrItem(prev);
- } else {
- prev->next = cur->next;
- deleteStr(cur->s);
- deleteStrItem(cur);
- }
- return;
+ if ((t = strTbl[h]) != 0) {
+ p = t;
+ do {
+ if (stricmp(t->s,s) == 0) {
+ t->refCnt--;
+ if (t->refCnt == 0) {
+ if (p == strTbl[h]) {
+ strTbl[h] = t->next;
+ }
+ else {
+ p->next = t->next;
+ }
+ deleteStr(t->s);
+ deleteStrItem(t);
+ return;
+ }
+ }
+ p = t;
+ t = t->next;
+ } while (t);
}
- }
- prev = cur;
- cur = cur->next;
- }
}
-void cleanStrTbl()
+DLLEXPORT(void) cleanStrTbl()
{
- int i;
- for (i=0; i<STRTBLSIZE;i++) {
- StrItem *t = strTbl[i];
- while (t) {
- StrItem *p;
- deleteStr(t->s);
- p = t;
- t = t->next;
- deleteStrItem(p);
- }
- strTbl[i] = 0;
- }
+ int i;
+ for (i=0; i<STRTBLSIZE;i++) {
+ StrItem *t = strTbl[i];
+ while (t) {
+ StrItem *p;
+ deleteStr(t->s);
+ p = t;
+ t = t->next;
+ deleteStrItem(p);
+ } while (t);
+ strTbl[i] = 0;
+ }
}
struct PreDefProp {
const char *name;
const char *alias;
const char** fields;
unsigned int flags;
};
/* flags in PreDefProp */
#define PD_BEGIN 0x1
#define PD_INTERNAL 0x2
static const char *adrFields[] = {
VCPostalBoxProp,
@@ -794,33 +809,33 @@ static struct PreDefProp propNames[] = {
{ VCDayLightProp, 0, 0, 0 },
{ VCDCreatedProp, 0, 0, 0 },
{ VCDeliveryLabelProp, 0, 0, 0 },
{ VCDescriptionProp, 0, 0, 0 },
{ VCDIBProp, 0, 0, 0 },
{ VCDisplayStringProp, 0, 0, 0 },
{ VCDomesticProp, 0, 0, 0 },
{ VCDTendProp, 0, 0, 0 },
{ VCDTstartProp, 0, 0, 0 },
{ VCDueProp, 0, 0, 0 },
{ VCEmailAddressProp, 0, 0, 0 },
{ VCEncodingProp, 0, 0, 0 },
{ VCEndProp, 0, 0, 0 },
{ VCEventProp, 0, 0, PD_BEGIN },
{ VCEWorldProp, 0, 0, 0 },
{ VCExNumProp, 0, 0, 0 },
- { VCExDateProp, 0, 0, 0 },
+ { VCExpDateProp, 0, 0, 0 },
{ VCExpectProp, 0, 0, 0 },
{ VCExtAddressProp, 0, 0, 0 },
{ VCFamilyNameProp, 0, 0, 0 },
{ VCFaxProp, 0, 0, 0 },
{ VCFullNameProp, 0, 0, 0 },
{ VCGeoLocationProp, 0, 0, 0 },
{ VCGeoProp, 0, 0, 0 },
{ VCGIFProp, 0, 0, 0 },
{ VCGivenNameProp, 0, 0, 0 },
{ VCGroupingProp, 0, 0, 0 },
{ VCHomeProp, 0, 0, 0 },
{ VCIBMMailProp, 0, 0, 0 },
{ VCInlineProp, 0, 0, 0 },
{ VCInternationalProp, 0, 0, 0 },
{ VCInternetProp, 0, 0, 0 },
{ VCISDNProp, 0, 0, 0 },
@@ -908,146 +923,137 @@ static struct PreDefProp propNames[] = {
{ VCWAVEProp, 0, 0, 0 },
{ VCWMFProp, 0, 0, 0 },
{ VCWorkProp, 0, 0, 0 },
{ VCX400Prop, 0, 0, 0 },
{ VCX509Prop, 0, 0, 0 },
{ VCXRuleProp, 0, 0, 0 },
{ 0,0,0,0 }
};
static struct PreDefProp* lookupPropInfo(const char* str)
{
/* brute force for now, could use a hash table here. */
int i;
for (i = 0; propNames[i].name; i++)
- if (strcasecmp(str, propNames[i].name) == 0) {
+ if (stricmp(str, propNames[i].name) == 0) {
return &propNames[i];
}
return 0;
}
-const char* lookupProp_(const char* str)
+DLLEXPORT(const char*) lookupProp_(const char* str)
{
int i;
for (i = 0; propNames[i].name; i++)
- if (strcasecmp(str, propNames[i].name) == 0) {
+ if (stricmp(str, propNames[i].name) == 0) {
const char* s;
s = propNames[i].alias?propNames[i].alias:propNames[i].name;
return lookupStr(s);
}
return lookupStr(str);
}
-const char* lookupProp(const char* str)
+DLLEXPORT(const char*) lookupProp(const char* str)
{
int i;
for (i = 0; propNames[i].name; i++)
- if (strcasecmp(str, propNames[i].name) == 0) {
+ if (stricmp(str, propNames[i].name) == 0) {
const char *s;
fieldedProp = propNames[i].fields;
s = propNames[i].alias?propNames[i].alias:propNames[i].name;
return lookupStr(s);
}
fieldedProp = 0;
return lookupStr(str);
}
/*----------------------------------------------------------------------
APIs to Output text form.
----------------------------------------------------------------------*/
#define OFILE_REALLOC_SIZE 256
typedef struct OFile {
FILE *fp;
char *s;
int len;
int limit;
int alloc:1;
int fail:1;
} OFile;
-
-/* vCalendar files need crlf linebreaks. The disabled functions didn't provide
- that. */
#if 0
-
static void appendsOFile(OFile *fp, const char *s)
{
int slen;
if (fp->fail) return;
slen = strlen(s);
if (fp->fp) {
fwrite(s,1,slen,fp->fp);
}
else {
stuff:
if (fp->len + slen < fp->limit) {
memcpy(fp->s+fp->len,s,slen);
fp->len += slen;
return;
}
else if (fp->alloc) {
fp->limit = fp->limit + OFILE_REALLOC_SIZE;
if (OFILE_REALLOC_SIZE <= slen) fp->limit += slen;
- if (fp->s)
- fp->s = realloc(fp->s,fp->limit);
- else
- fp->s = malloc(fp->limit);
+ fp->s = (char *) realloc(fp->s,fp->limit);
if (fp->s) goto stuff;
}
if (fp->alloc)
free(fp->s);
fp->s = 0;
fp->fail = 1;
}
}
static void appendcOFile(OFile *fp, char c)
{
if (fp->fail) return;
if (fp->fp) {
fputc(c,fp->fp);
}
else {
stuff:
if (fp->len+1 < fp->limit) {
fp->s[fp->len] = c;
fp->len++;
return;
}
else if (fp->alloc) {
fp->limit = fp->limit + OFILE_REALLOC_SIZE;
- fp->s = realloc(fp->s,fp->limit);
+ fp->s = (char *) realloc(fp->s,fp->limit);
if (fp->s) goto stuff;
}
if (fp->alloc)
free(fp->s);
fp->s = 0;
fp->fail = 1;
}
}
-
#else
-
static void appendcOFile_(OFile *fp, char c)
{
if (fp->fail) return;
if (fp->fp) {
fputc(c,fp->fp);
}
else {
stuff:
if (fp->len+1 < fp->limit) {
fp->s[fp->len] = c;
fp->len++;
return;
}
else if (fp->alloc) {
fp->limit = fp->limit + OFILE_REALLOC_SIZE;
fp->s = realloc(fp->s,fp->limit);
@@ -1102,98 +1108,111 @@ static void initMemOFile(OFile *fp, char *s, int len)
fp->fail = 0;
}
static int writeBase64(OFile *fp, unsigned char *s, long len)
{
long cur = 0;
int i, numQuads = 0;
unsigned long trip;
unsigned char b;
char quad[5];
#define MAXQUADS 16
quad[4] = 0;
while (cur < len) {
- /* collect the triplet of bytes into 'trip' */
+ /* collect the triplet of bytes into 'trip' */
trip = 0;
for (i = 0; i < 3; i++) {
b = (cur < len) ? *(s + cur) : 0;
cur++;
trip = trip << 8 | b;
}
/* fill in 'quad' with the appropriate four characters */
for (i = 3; i >= 0; i--) {
b = (unsigned char)(trip & 0x3F);
trip = trip >> 6;
if ((3 - i) < (cur - len))
- quad[i] = '='; /* pad char */
+ quad[i] = '='; /* pad char */
else if (b < 26) quad[i] = (char)b + 'A';
else if (b < 52) quad[i] = (char)(b - 26) + 'a';
else if (b < 62) quad[i] = (char)(b - 52) + '0';
else if (b == 62) quad[i] = '+';
else quad[i] = '/';
}
/* now output 'quad' with appropriate whitespace and line ending */
appendsOFile(fp, (numQuads == 0 ? " " : ""));
appendsOFile(fp, quad);
appendsOFile(fp, ((cur >= len)?"\n" :(numQuads==MAXQUADS-1?"\n" : "")));
numQuads = (numQuads + 1) % MAXQUADS;
}
appendcOFile(fp,'\n');
return 1;
}
-/* this function really sucks. Too basic. */
-static void writeQPString(OFile *fp, const char *s, int qp)
+static void writeString(OFile *fp, const char *s)
+{
+ appendsOFile(fp,s);
+}
+
+static void writeQPString(OFile *fp, const char *s)
{
+ char buf[4];
+ int count=0;
const char *p = s;
+
while (*p) {
- if (*p == '\n') {
- if (p[1]) appendsOFile(fp,"=0A=");
- }
- if (*p == '=' && qp)
- appendsOFile(fp,"=3D");
- else
- appendcOFile(fp,*p);
- p++;
+ /* break up lines biggger than 75 chars */
+ if(count >=74){
+ count=0;
+ appendsOFile(fp,"=\n");
+ }
+
+ /* escape any non ASCII characters and '=' as per rfc1521 */
+ if (*p<= 0x1f || *p >=0x7f || *p == '=' ) {
+ sprintf(buf,"=%02X",(unsigned char)*p);
+ appendsOFile(fp,buf);
+ count+=3;
+ } else {
+ appendcOFile(fp,*p);
+ count++;
+ }
+ p++;
}
}
+
+
static void writeVObject_(OFile *fp, VObject *o);
-static void writeValue(OFile *fp, VObject *o, unsigned long size)
+static void writeValue(OFile *fp, VObject *o, unsigned long size,int quote)
{
if (o == 0) return;
switch (VALUE_TYPE(o)) {
case VCVT_USTRINGZ: {
char *s = fakeCString(USTRINGZ_VALUE_OF(o));
- if (isAPropertyOf(o, VCQuotedPrintableProp))
- writeQPString(fp, s, 1);
- else
- writeQPString(fp, s, 0);
+ if(quote) writeQPString(fp, s);
+ else writeString(fp,s);
deleteStr(s);
break;
}
case VCVT_STRINGZ: {
- if (isAPropertyOf(o, VCQuotedPrintableProp))
- writeQPString(fp, STRINGZ_VALUE_OF(o), 1);
- else
- writeQPString(fp, STRINGZ_VALUE_OF(o), 0);
+ if(quote) writeQPString(fp, STRINGZ_VALUE_OF(o));
+ else writeString(fp,STRINGZ_VALUE_OF(o));
break;
}
case VCVT_UINT: {
char buf[16];
sprintf(buf,"%u", INTEGER_VALUE_OF(o));
appendsOFile(fp,buf);
break;
}
case VCVT_ULONG: {
char buf[16];
sprintf(buf,"%lu", LONG_VALUE_OF(o));
appendsOFile(fp,buf);
break;
}
case VCVT_RAW: {
appendcOFile(fp,'\n');
@@ -1207,111 +1226,113 @@ static void writeValue(OFile *fp, VObject *o, unsigned long size)
}
}
static void writeAttrValue(OFile *fp, VObject *o)
{
if (NAME_OF(o)) {
struct PreDefProp *pi;
pi = lookupPropInfo(NAME_OF(o));
if (pi && ((pi->flags & PD_INTERNAL) != 0)) return;
appendcOFile(fp,';');
appendsOFile(fp,NAME_OF(o));
}
else
appendcOFile(fp,';');
if (VALUE_TYPE(o)) {
appendcOFile(fp,'=');
- writeValue(fp,o,0);
+ writeValue(fp,o,0,0);
}
}
static void writeGroup(OFile *fp, VObject *o)
{
char buf1[256];
char buf2[256];
strcpy(buf1,NAME_OF(o));
while ((o=isAPropertyOf(o,VCGroupingProp)) != 0) {
- strncpy(buf2,STRINGZ_VALUE_OF(o),sizeof(buf2));
- buf2[sizeof(buf2)] = '\0';
- strncat(buf2,".",sizeof(buf2)-strlen(buf2)-1);
- strncat(buf2,buf1,sizeof(buf2)-strlen(buf2)-1);
+ strcpy(buf2,STRINGZ_VALUE_OF(o));
+ strcat(buf2,".");
+ strcat(buf2,buf1);
strcpy(buf1,buf2);
}
appendsOFile(fp,buf1);
}
static int inList(const char **list, const char *s)
{
if (list == 0) return 0;
while (*list) {
- if (strcasecmp(*list,s) == 0) return 1;
+ if (stricmp(*list,s) == 0) return 1;
list++;
}
return 0;
}
static void writeProp(OFile *fp, VObject *o)
{
+ int isQuoted=0;
if (NAME_OF(o)) {
struct PreDefProp *pi;
VObjectIterator t;
const char **fields_ = 0;
pi = lookupPropInfo(NAME_OF(o));
if (pi && ((pi->flags & PD_BEGIN) != 0)) {
writeVObject_(fp,o);
return;
}
if (isAPropertyOf(o,VCGroupingProp))
writeGroup(fp,o);
else
appendsOFile(fp,NAME_OF(o));
if (pi) fields_ = pi->fields;
initPropIterator(&t,o);
while (moreIteration(&t)) {
const char *s;
VObject *eachProp = nextVObject(&t);
s = NAME_OF(eachProp);
- if (strcasecmp(VCGroupingProp,s) && !inList(fields_,s))
+ if (stricmp(VCGroupingProp,s) && !inList(fields_,s))
writeAttrValue(fp,eachProp);
+ if (stricmp(VCQPProp,s)==0 || stricmp(VCQuotedPrintableProp,s)==0)
+ isQuoted=1;
}
if (fields_) {
int i = 0, n = 0;
const char** fields = fields_;
/* output prop as fields */
appendcOFile(fp,':');
while (*fields) {
- VObject *tl = isAPropertyOf(o,*fields);
+ VObject *t = isAPropertyOf(o,*fields);
i++;
- if (tl) n = i;
+ if (t) n = i;
fields++;
}
fields = fields_;
for (i=0;i<n;i++) {
- writeValue(fp,isAPropertyOf(o,*fields),0);
+ writeValue(fp,isAPropertyOf(o,*fields),0,isQuoted);
fields++;
if (i<(n-1)) appendcOFile(fp,';');
}
}
}
if (VALUE_TYPE(o)) {
unsigned long size = 0;
VObject *p = isAPropertyOf(o,VCDataSizeProp);
if (p) size = LONG_VALUE_OF(p);
appendcOFile(fp,':');
- writeValue(fp,o,size);
+ writeValue(fp,o,size,isQuoted);
}
appendcOFile(fp,'\n');
}
static void writeVObject_(OFile *fp, VObject *o)
{
if (NAME_OF(o)) {
struct PreDefProp *pi;
pi = lookupPropInfo(NAME_OF(o));
if (pi && ((pi->flags & PD_BEGIN) != 0)) {
VObjectIterator t;
const char *begin = NAME_OF(o);
appendsOFile(fp,"BEGIN:");
appendsOFile(fp,begin);
@@ -1322,112 +1343,112 @@ static void writeVObject_(OFile *fp, VObject *o)
writeProp(fp, eachProp);
}
appendsOFile(fp,"END:");
appendsOFile(fp,begin);
appendsOFile(fp,"\n\n");
}
}
}
void writeVObject(FILE *fp, VObject *o)
{
OFile ofp;
initOFile(&ofp,fp);
writeVObject_(&ofp,o);
}
-void writeVObjectToFile(char *fname, VObject *o)
+DLLEXPORT(void) writeVObjectToFile(char *fname, VObject *o)
{
FILE *fp = fopen(fname,"w");
if (fp) {
writeVObject(fp,o);
fclose(fp);
}
}
-void writeVObjectsToFile(char *fname, VObject *list)
+DLLEXPORT(void) writeVObjectsToFile(char *fname, VObject *list)
{
FILE *fp = fopen(fname,"w");
if (fp) {
while (list) {
writeVObject(fp,list);
list = nextVObjectInList(list);
}
fclose(fp);
}
}
-char* writeMemVObject(char *s, int *len, VObject *o)
+DLLEXPORT(char*) writeMemVObject(char *s, int *len, VObject *o)
{
OFile ofp;
initMemOFile(&ofp,s,len?*len:0);
writeVObject_(&ofp,o);
if (len) *len = ofp.len;
appendcOFile(&ofp,0);
return ofp.s;
}
-char* writeMemVObjects(char *s, int *len, VObject *list)
+DLLEXPORT(char*) writeMemVObjects(char *s, int *len, VObject *list)
{
OFile ofp;
initMemOFile(&ofp,s,len?*len:0);
while (list) {
writeVObject_(&ofp,list);
list = nextVObjectInList(list);
}
if (len) *len = ofp.len;
appendcOFile(&ofp,0);
return ofp.s;
}
/*----------------------------------------------------------------------
APIs to do fake Unicode stuff.
----------------------------------------------------------------------*/
-wchar_t* fakeUnicode(const char *ps, int *bytes)
+DLLEXPORT(wchar_t*) fakeUnicode(const char *ps, int *bytes)
{
wchar_t *r, *pw;
int len = strlen(ps)+1;
pw = r = (wchar_t*)malloc(sizeof(wchar_t)*len);
if (bytes)
*bytes = len * sizeof(wchar_t);
while (*ps) {
if (*ps == '\n')
*pw = (wchar_t)0x2028;
else if (*ps == '\r')
*pw = (wchar_t)0x2029;
else
*pw = (wchar_t)(unsigned char)*ps;
ps++; pw++;
}
*pw = (wchar_t)0;
return r;
}
-int uStrLen(const wchar_t *u)
+DLLEXPORT(int) uStrLen(const wchar_t *u)
{
int i = 0;
while (*u != (wchar_t)0) { u++; i++; }
return i;
}
-char* fakeCString(const wchar_t *u)
+DLLEXPORT(char*) fakeCString(const wchar_t *u)
{
char *s, *t;
int len = uStrLen(u) + 1;
- t = s = (char*)malloc(len+1);
+ t = s = (char*)malloc(len);
while (*u) {
if (*u == (wchar_t)0x2028)
*t = '\n';
else if (*u == (wchar_t)0x2029)
*t = '\r';
else
*t = (char)*u;
u++; t++;
}
*t = 0;
return s;
}
/* end of source file vobject.c */
diff --git a/libkcal/versit/vobject.h b/libkcal/versit/vobject.h
index 0ec8b31..85c299e 100644
--- a/libkcal/versit/vobject.h
+++ b/libkcal/versit/vobject.h
@@ -129,33 +129,33 @@ extern "C" {
#define VCDayLightProp "DAYLIGHT"
#define VCDCreatedProp "DCREATED"
#define VCDeliveryLabelProp "LABEL"
#define VCDescriptionProp "DESCRIPTION"
#define VCDIBProp "DIB"
#define VCDisplayStringProp "DISPLAYSTRING"
#define VCDomesticProp "DOM"
#define VCDTendProp "DTEND"
#define VCDTstartProp "DTSTART"
#define VCDueProp "DUE"
#define VCEmailAddressProp "EMAIL"
#define VCEncodingProp "ENCODING"
#define VCEndProp "END"
#define VCEventProp "VEVENT"
#define VCEWorldProp "EWORLD"
#define VCExNumProp "EXNUM"
-#define VCExDateProp "EXDATE"
+#define VCExpDateProp "EXDATE"
#define VCExpectProp "EXPECT"
#define VCExtAddressProp "EXT ADD"
#define VCFamilyNameProp "F"
#define VCFaxProp "FAX"
#define VCFullNameProp "FN"
#define VCGeoProp "GEO"
#define VCGeoLocationProp "GEO"
#define VCGIFProp "GIF"
#define VCGivenNameProp "G"
#define VCGroupingProp "Grouping"
#define VCHomeProp "HOME"
#define VCIBMMailProp "IBMMail"
#define VCInlineProp "INLINE"
#define VCInternationalProp "INTL"
#define VCInternetProp "INTERNET"
#define VCISDNProp "ISDN"
@@ -234,151 +234,136 @@ extern "C" {
#define VCTodoProp "VTODO"
#define VCTranspProp "TRANSP"
#define VCUniqueStringProp "UID"
#define VCURLProp "URL"
#define VCURLValueProp "URLVAL"
#define VCValueProp "VALUE"
#define VCVersionProp "VERSION"
#define VCVideoProp "VIDEO"
#define VCVoiceProp "VOICE"
#define VCWAVEProp "WAVE"
#define VCWMFProp "WMF"
#define VCWorkProp "WORK"
#define VCX400Prop "X400"
#define VCX509Prop "X509"
#define VCXRuleProp "XRULE"
-/* extensions for KOrganizer / KPilot */
-#define KPilotIdProp "X-PILOTID"
-#define KPilotStatusProp "X-PILOTSTAT"
+/* Extensions */
+#define XPilotIdProp "X-PILOTID"
+#define XPilotStatusProp "X-PILOTSTAT"
/* extensions for iMIP / iTIP */
#define ICOrganizerProp "X-ORGANIZER"
#define ICMethodProp "X-METHOD"
#define ICRequestStatusProp "X-REQUEST-STATUS"
-
typedef struct VObject VObject;
-typedef union ValueItem {
- const char *strs;
- const wchar_t *ustrs;
- unsigned int i;
- unsigned long l;
- void *any;
- VObject *vobj;
- } ValueItem;
-
-struct VObject {
- VObject *next;
- const char *id;
- VObject *prop;
- unsigned short valType;
- ValueItem val;
- };
-
-typedef struct StrItem StrItem;
-
-struct StrItem {
- StrItem *next;
- const char *s;
- unsigned int refCnt;
- };
-
typedef struct VObjectIterator {
VObject* start;
VObject* next;
} VObjectIterator;
-extern VObject* newVObject(const char *id);
-extern void deleteVObject(VObject *p);
-extern char* dupStr(const char *s, unsigned int size);
-extern void deleteStr(const char *p);
-extern void unUseStr(const char *s);
-
-extern void setVObjectName(VObject *o, const char* id);
-extern void setVObjectStringZValue(VObject *o, const char *s);
-extern void setVObjectStringZValue_(VObject *o, const char *s);
-extern void setVObjectUStringZValue(VObject *o, const wchar_t *s);
-extern void setVObjectUStringZValue_(VObject *o, const wchar_t *s);
-extern void setVObjectIntegerValue(VObject *o, unsigned int i);
-extern void setVObjectLongValue(VObject *o, unsigned long l);
-extern void setVObjectAnyValue(VObject *o, void *t);
-extern VObject* setValueWithSize(VObject *prop, void *val, unsigned int size);
-extern VObject* setValueWithSize_(VObject *prop, void *val, unsigned int size);
-
-extern const char* vObjectName(VObject *o);
-extern const char* vObjectStringZValue(VObject *o);
-extern const wchar_t* vObjectUStringZValue(VObject *o);
-extern unsigned int vObjectIntegerValue(VObject *o);
-extern unsigned long vObjectLongValue(VObject *o);
-extern void* vObjectAnyValue(VObject *o);
-extern VObject* vObjectVObjectValue(VObject *o);
-extern void setVObjectVObjectValue(VObject *o, VObject *p);
-
-extern VObject* addVObjectProp(VObject *o, VObject *p);
-extern VObject* addProp(VObject *o, const char *id);
-extern VObject* addProp_(VObject *o, const char *id);
-extern VObject* addPropValue(VObject *o, const char *p, const char *v);
-extern VObject* addPropSizedValue_(VObject *o, const char *p, const char *v, unsigned int size);
-extern VObject* addPropSizedValue(VObject *o, const char *p, const char *v, unsigned int size);
-extern VObject* addGroup(VObject *o, const char *g);
-extern void addList(VObject **o, VObject *p);
-
-extern VObject* isAPropertyOf(VObject *o, const char *id);
-
-extern VObject* nextVObjectInList(VObject *o);
-extern void initPropIterator(VObjectIterator *i, VObject *o);
-extern int moreIteration(VObjectIterator *i);
-extern VObject* nextVObject(VObjectIterator *i);
-
-extern char* writeMemVObject(char *s, int *len, VObject *o);
-extern char* writeMemVObjects(char *s, int *len, VObject *list);
-
-extern const char* lookupStr(const char *s);
-extern void cleanStrTbl();
-
-extern void cleanVObject(VObject *o);
-extern void cleanVObjects(VObject *list);
-
-extern const char* lookupProp(const char* str);
-extern const char* lookupProp_(const char* str);
-
-extern wchar_t* fakeUnicode(const char *ps, int *bytes);
-extern int uStrLen(const wchar_t *u);
-extern char* fakeCString(const wchar_t *u);
-
-extern void printVObjectToFile(char *fname,VObject *o);
-extern void printVObjectsToFile(char *fname,VObject *list);
-extern void writeVObjectToFile(char *fname, VObject *o);
-extern void writeVObjectsToFile(char *fname, VObject *list);
-
-extern int vObjectValueType(VObject *o);
+extern DLLEXPORT(VObject*) newVObject(const char *id);
+extern DLLEXPORT(void) deleteVObject(VObject *p);
+extern DLLEXPORT(char*) dupStr(const char *s, unsigned int size);
+extern DLLEXPORT(void) deleteStr(const char *p);
+extern DLLEXPORT(void) unUseStr(const char *s);
+
+extern DLLEXPORT(void) setVObjectName(VObject *o, const char* id);
+extern DLLEXPORT(void) setVObjectStringZValue(VObject *o, const char *s);
+extern DLLEXPORT(void) setVObjectStringZValue_(VObject *o, const char *s);
+extern DLLEXPORT(void) setVObjectUStringZValue(VObject *o, const wchar_t *s);
+extern DLLEXPORT(void) setVObjectUStringZValue_(VObject *o, const wchar_t *s);
+extern DLLEXPORT(void) setVObjectIntegerValue(VObject *o, unsigned int i);
+extern DLLEXPORT(void) setVObjectLongValue(VObject *o, unsigned long l);
+extern DLLEXPORT(void) setVObjectAnyValue(VObject *o, void *t);
+extern DLLEXPORT(VObject*) setValueWithSize(VObject *prop, void *val, unsigned int size);
+extern DLLEXPORT(VObject*) setValueWithSize_(VObject *prop, void *val, unsigned int size);
+
+extern DLLEXPORT(const char*) vObjectName(VObject *o);
+extern DLLEXPORT(const char*) vObjectStringZValue(VObject *o);
+extern DLLEXPORT(const wchar_t*) vObjectUStringZValue(VObject *o);
+extern DLLEXPORT(unsigned int) vObjectIntegerValue(VObject *o);
+extern DLLEXPORT(unsigned long) vObjectLongValue(VObject *o);
+extern DLLEXPORT(void*) vObjectAnyValue(VObject *o);
+extern DLLEXPORT(VObject*) vObjectVObjectValue(VObject *o);
+extern DLLEXPORT(void) setVObjectVObjectValue(VObject *o, VObject *p);
+
+extern DLLEXPORT(VObject*) addVObjectProp(VObject *o, VObject *p);
+extern DLLEXPORT(VObject*) addProp(VObject *o, const char *id);
+extern DLLEXPORT(VObject*) addProp_(VObject *o, const char *id);
+extern DLLEXPORT(VObject*) addPropValue(VObject *o, const char *p, const char *v);
+extern DLLEXPORT(VObject*) addPropSizedValue_(VObject *o, const char *p, const char *v, unsigned int size);
+extern DLLEXPORT(VObject*) addPropSizedValue(VObject *o, const char *p, const char *v, unsigned int size);
+extern DLLEXPORT(VObject*) addGroup(VObject *o, const char *g);
+extern DLLEXPORT(void) addList(VObject **o, VObject *p);
+
+extern DLLEXPORT(VObject*) isAPropertyOf(VObject *o, const char *id);
+
+extern DLLEXPORT(VObject*) nextVObjectInList(VObject *o);
+extern DLLEXPORT(void) initPropIterator(VObjectIterator *i, VObject *o);
+extern DLLEXPORT(int) moreIteration(VObjectIterator *i);
+extern DLLEXPORT(VObject*) nextVObject(VObjectIterator *i);
+
+extern DLLEXPORT(char*) writeMemVObject(char *s, int *len, VObject *o);
+extern DLLEXPORT(char*) writeMemVObjects(char *s, int *len, VObject *list);
+
+extern DLLEXPORT(const char*) lookupStr(const char *s);
+extern DLLEXPORT(void) cleanStrTbl();
+
+extern DLLEXPORT(void) cleanVObject(VObject *o);
+extern DLLEXPORT(void) cleanVObjects(VObject *list);
+
+extern DLLEXPORT(const char*) lookupProp(const char* str);
+extern DLLEXPORT(const char*) lookupProp_(const char* str);
+
+extern DLLEXPORT(wchar_t*) fakeUnicode(const char *ps, int *bytes);
+extern DLLEXPORT(int) uStrLen(const wchar_t *u);
+extern DLLEXPORT(char*) fakeCString(const wchar_t *u);
+
+extern DLLEXPORT(void) printVObjectToFile(char *fname,VObject *o);
+extern DLLEXPORT(void) printVObjectsToFile(char *fname,VObject *list);
+extern DLLEXPORT(void) writeVObjectToFile(char *fname, VObject *o);
+extern DLLEXPORT(void) writeVObjectsToFile(char *fname, VObject *list);
+
+extern DLLEXPORT(int) vObjectValueType(VObject *o);
/* return type of vObjectValueType: */
#define VCVT_NOVALUE 0
/* if the VObject has no value associated with it. */
#define VCVT_STRINGZ 1
/* if the VObject has value set by setVObjectStringZValue. */
#define VCVT_USTRINGZ 2
/* if the VObject has value set by setVObjectUStringZValue. */
#define VCVT_UINT 3
/* if the VObject has value set by setVObjectIntegerValue. */
#define VCVT_ULONG 4
/* if the VObject has value set by setVObjectLongValue. */
#define VCVT_RAW 5
/* if the VObject has value set by setVObjectAnyValue. */
#define VCVT_VOBJECT 6
/* if the VObject has value set by setVObjectVObjectValue. */
extern const char** fieldedProp;
+/* NOTE regarding printVObject and writeVObject
+
+The functions below are not exported from the DLL because they
+take a FILE* as a parameter, which cannot be passed across a DLL
+interface (at least that is my experience). Instead you can use
+their companion functions which take file names or pointers
+to memory. However, if you are linking this code into
+your build directly then you may find them a more convenient API
+and you can go ahead and use them. If you try to use them with
+the DLL LIB you will get a link error.
+*/
extern void printVObject(FILE *fp,VObject *o);
extern void writeVObject(FILE *fp, VObject *o);
#if defined(__CPLUSPLUS__) || defined(__cplusplus)
}
#endif
#endif /* __VOBJECT_H__ */