33 files changed, 10003 insertions, 0 deletions

diff --git a/libical/src/libicalss/config.h b/libical/src/libicalss/config.h
new file mode 100644
index 0000000..fa66c47
--- a/dev/null
+++ b/libical/src/libicalss/config.h
@@ -0,0 +1,7 @@
+#ifndef LIBICALSS_CONFIG_H
+#define LIBICALSS_CONFIG_H
+
+#define PACKAGE "libicalss"
+#define VERSION "0.23"
+
+#endif
diff --git a/libical/src/libicalss/icalcalendar.h b/libical/src/libicalss/icalcalendar.h
new file mode 100644
index 0000000..f07457c
--- a/dev/null
+++ b/libical/src/libicalss/icalcalendar.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcalendar.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCALENDAR_H
+#define ICALCALENDAR_H
+
+#include "ical.h"
+#include "icalset.h"
+
+/* icalcalendar
+ * Routines for storing calendar data in a file system. The calendar 
+ * has two icaldirsets, one for incoming components and one for booked
+ * components. It also has interfaces to access the free/busy list
+ * and a list of calendar properties */
+
+typedef  void icalcalendar;
+
+icalcalendar* icalcalendar_new(char* dir);
+
+void icalcalendar_free(icalcalendar* calendar);
+
+int icalcalendar_lock(icalcalendar* calendar);
+
+int icalcalendar_unlock(icalcalendar* calendar);
+
+int icalcalendar_islocked(icalcalendar* calendar);
+
+int icalcalendar_ownlock(icalcalendar* calendar);
+
+icalset* icalcalendar_get_booked(icalcalendar* calendar);
+
+icalset* icalcalendar_get_incoming(icalcalendar* calendar);
+
+icalset* icalcalendar_get_properties(icalcalendar* calendar);
+
+icalset* icalcalendar_get_freebusy(icalcalendar* calendar);
+
+
+#endif /* !ICALCALENDAR_H */
+
+
+
diff --git a/libical/src/libicalss/icalclassify.c b/libical/src/libicalss/icalclassify.c
new file mode 100644
index 0000000..c029309
--- a/dev/null
+++ b/libical/src/libicalss/icalclassify.c
@@ -0,0 +1,792 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalclassify.c
+    CREATOR: ebusboom 23 aug 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalclassify.h"
+#include "icalmemory.h"
+#include <ctype.h>   /* For tolower() */
+#include <string.h> /* for index() */
+#include <stdlib.h> /* for malloc and free */
+
+
+
+struct icalclassify_parts {
+    icalcomponent *c;
+    icalcomponent_kind inner_kind;
+    icalproperty_method method;
+    char* organizer;
+    icalparameter_partstat reply_partstat;
+    char* reply_attendee;
+    char* uid;
+    int sequence;
+            struct icaltimetype dtstamp;
+    struct icaltimetype recurrence_id;
+}; 
+        
+
+char* icalclassify_lowercase(const char* str)
+{
+    char* p = 0;
+    char* new = icalmemory_strdup(str);
+
+    if(str ==0){
+        return 0;
+    }
+
+    for(p = new; *p!=0; p++){
+        *p = tolower(*p);
+    }
+
+    return new;
+}
+
+/* Return a set of components that intersect in time with comp. For
+component X and Y to intersect:
+    X.DTSTART < Y.DTEND && X.DTEND > Y.DTSTART
+*/
+
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp)
+{
+    icalcomponent *return_set;
+    icalcomponent *c;
+    struct icaltime_span span,compspan;
+    
+    icalerror_clear_errno();
+    compspan = icalcomponent_get_span(comp);
+
+    if(icalerrno != ICAL_NO_ERROR){
+        return 0;
+    }
+
+
+    return_set = icalcomponent_new(ICAL_XROOT_COMPONENT);
+
+    for(c = icalset_get_first_component(set);
+        c != 0;
+        c = icalset_get_next_component(set)){
+
+        icalerror_clear_errno();
+
+        span = icalcomponent_get_span(c);
+
+        if(icalerrno != ICAL_NO_ERROR){
+            continue;
+        }
+
+        if (compspan.start < span.end && 
+            compspan.end > span.start){
+
+            icalcomponent *clone = icalcomponent_new_clone(c);
+
+            icalcomponent_add_component(return_set,clone);
+                }
+    }
+
+    if(icalcomponent_count_components(return_set,ICAL_ANY_COMPONENT) !=0){
+        return return_set;
+    } else {
+        icalcomponent_free(return_set);
+        return 0;
+    }
+}
+
+
+
+icalproperty* icalclassify_find_attendee(icalcomponent *c, 
+                                                  const char* attendee)
+{
+    icalproperty *p;
+    icalcomponent* inner;
+    char* lattendee;
+    char* upn;
+
+    if(attendee == 0){
+        return 0;
+    }
+
+    lattendee = icalclassify_lowercase(attendee);
+    upn =  strchr(lattendee,':');
+
+    if (upn== 0){
+        upn = lattendee;
+    } else {
+        upn++; /* skip the ";"*/
+    }
+
+    inner = icalcomponent_get_first_real_component(c);
+
+    for(p  = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY);
+        p != 0;
+        p  = icalcomponent_get_next_property(inner,ICAL_ATTENDEE_PROPERTY))
+    {
+        const char* this_attendee
+            = icalclassify_lowercase(icalproperty_get_attendee(p));
+        char* this_upn = strchr(this_attendee,':');
+
+        if(this_upn == 0){
+            continue;
+        } else {
+            this_upn++;
+        }
+
+        if(strcmp(this_upn,upn)==0){
+            return p;
+        }
+
+    }
+
+    return 0;
+
+}
+
+void icalssutil_free_parts(struct icalclassify_parts *parts)
+{
+    if(parts == 0){
+        return;
+    }
+
+    if(parts->organizer != 0){
+        free(parts->organizer);
+    }
+
+    if(parts->uid != 0){
+        free(parts->uid);
+    }
+
+    if(parts->reply_attendee){
+        free(parts->reply_attendee);
+    }
+}
+
+void icalssutil_get_parts(icalcomponent* c,  
+                          struct icalclassify_parts* parts)
+{
+    icalproperty *p;
+    icalcomponent *inner;
+
+    memset(parts,0,sizeof(struct icalclassify_parts));
+
+    parts->method = ICAL_METHOD_NONE;
+    parts->sequence = 0;
+    parts->reply_partstat = ICAL_PARTSTAT_NONE;
+
+    if(c == 0){
+        return;
+    }
+
+    parts->c = c;
+
+    p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY);
+    if(p!=0){
+        parts->method = icalproperty_get_method(p);
+    }
+
+    inner = icalcomponent_get_first_real_component(c);
+
+    parts->inner_kind = icalcomponent_isa(inner);
+
+    p = icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY);
+    if(p!=0){
+        parts->organizer = strdup(icalproperty_get_organizer(p));
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_SEQUENCE_PROPERTY);    
+    if(p!=0){
+        parts->sequence = icalproperty_get_sequence(p);
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_UID_PROPERTY);
+    if(p!=0){
+        parts->uid = strdup(icalproperty_get_uid(p));
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_RECURRENCEID_PROPERTY);
+    if(p!=0){
+        parts->recurrence_id = icalproperty_get_recurrenceid(p);
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
+    if(p!=0){
+        parts->dtstamp = icalproperty_get_dtstamp(p);
+    }
+
+    if(parts->method==ICAL_METHOD_REPLY){
+        icalparameter *param;
+        p  = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY);
+
+        if(p!=0){
+
+            param = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER);
+            
+            if(param != 0){
+                parts->reply_partstat = 
+                    icalparameter_get_partstat(param);
+            }
+            
+            parts->reply_attendee = strdup(icalproperty_get_attendee(p));
+        }
+
+    }    
+
+
+}
+
+
+int icalssutil_is_rescheduled(icalcomponent* a,icalcomponent* b)
+{
+    icalproperty *p1,*p2;
+    icalcomponent *i1,*i2;
+    int i;
+
+    icalproperty_kind kind_array[] = {
+        ICAL_DTSTART_PROPERTY,
+        ICAL_DTEND_PROPERTY,
+        ICAL_DURATION_PROPERTY,
+        ICAL_DUE_PROPERTY,
+        ICAL_RRULE_PROPERTY,
+        ICAL_RDATE_PROPERTY,
+        ICAL_EXRULE_PROPERTY,
+        ICAL_EXDATE_PROPERTY,
+        ICAL_NO_PROPERTY
+    };
+
+    i1 = icalcomponent_get_first_real_component(a);
+    i2 = icalcomponent_get_first_real_component(b);
+
+    for(i =0; kind_array[i] != ICAL_NO_PROPERTY; i++){
+        p1 = icalcomponent_get_first_property(i1,kind_array[i]);
+        p2 = icalcomponent_get_first_property(i2,kind_array[i]);
+        
+        if( (p1!=0)^(p1!=0) ){
+            /* Return true if the property exists in one component and not
+               the other */
+            return 1;
+        }
+        
+        if(p1 && strcmp(icalproperty_as_ical_string(p1),
+                        icalproperty_as_ical_string(p2)) != 0){
+            return 1;
+        }
+    }
+
+    return 0;
+    
+}
+
+#define icalclassify_pre \
+    int rtrn =0; 
+
+#define icalclassify_post \
+    return rtrn;
+
+
+int icalclassify_publish_new(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+        match == 0 && comp->inner_kind != ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+int icalclassify_publish_update(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+        match !=0 && comp->inner_kind != ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+int icalclassify_publish_freebusy(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+       comp->inner_kind == ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+
+int icalclassify_request_new(struct icalclassify_parts *comp, 
+                                    struct icalclassify_parts *match, 
+                                    const char* user)
+{
+    /* Method is  REQUEST, and there is no match */
+
+    icalclassify_pre
+
+    if(match->c==0 && comp->method == ICAL_METHOD_REQUEST){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_update(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /* REQUEST method, Higher SEQUENCE than match, and all
+       time-related properties are unchanged */
+    
+    icalclassify_pre
+
+    if (match != 0 &&
+        comp->sequence >= match->sequence &&
+        !icalssutil_is_rescheduled(comp->c,match->c)){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_reschedule(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /* REQUEST method, Higher SEQUENCE than match, and one or more
+       time-related properties are changed */
+    icalclassify_pre
+
+    if (match->c != 0 &&
+        comp->sequence > match->sequence &&
+        icalssutil_is_rescheduled(comp->c,match->c)){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_delegate(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalparameter* param;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(comp->c,user);
+
+    if(attendee == 0){
+        return 0;
+    }
+
+    param = icalproperty_get_first_parameter(attendee,ICAL_DELEGATEDFROM_PARAMETER);
+            
+    if (param != 0){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_new_organizer(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /*   Organizer has changed between match and component */
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+
+}
+
+int icalclassify_request_status(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_request_forward(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_request_freebusy(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_reply_accept(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee != 0&&
+       comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+}
+int icalclassify_reply_decline(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+
+    if( attendee != 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_delegate(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if( attendee != 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DELEGATED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_crasher_accept(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee= icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee == 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_crasher_decline(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalparameter_partstat partstat;
+    icalproperty* attendee;
+    icalclassify_pre;
+
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee == 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_add_instance(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_ADD){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_event(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_instance(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_all(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_refesh(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_REFRESH){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_counter(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_COUNTER){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_delinecounter(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+
+    if(comp->method == ICAL_METHOD_DECLINECOUNTER){
+        rtrn = 1;
+    }
+        
+    icalclassify_post
+}
+
+struct icalclassify_map {
+        icalproperty_method method;
+        int (*fn)(struct icalclassify_parts *comp,struct icalclassify_parts *match, const char* user);
+        ical_class class;
+} icalclassify_map[] = 
+{ {ICAL_METHOD_PUBLISH,icalclassify_publish_new,ICAL_PUBLISH_NEW_CLASS},
+ {ICAL_METHOD_PUBLISH,icalclassify_publish_update,ICAL_PUBLISH_UPDATE_CLASS},
+ {ICAL_METHOD_PUBLISH,icalclassify_publish_freebusy,ICAL_PUBLISH_FREEBUSY_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_delegate,ICAL_REQUEST_DELEGATE_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_new,ICAL_REQUEST_NEW_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_update,ICAL_REQUEST_UPDATE_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_reschedule,ICAL_REQUEST_RESCHEDULE_CLASS},
+
+  {ICAL_METHOD_REQUEST,icalclassify_request_new_organizer,ICAL_REQUEST_NEW_ORGANIZER_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_forward,ICAL_REQUEST_FORWARD_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_status,ICAL_REQUEST_STATUS_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_freebusy,ICAL_REQUEST_FREEBUSY_CLASS},
+
+  {ICAL_METHOD_REPLY,icalclassify_reply_accept,ICAL_REPLY_ACCEPT_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_decline,ICAL_REPLY_DECLINE_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_delegate,ICAL_REPLY_DELEGATE_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_crasher_accept,ICAL_REPLY_CRASHER_ACCEPT_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_crasher_decline,ICAL_REPLY_CRASHER_DECLINE_CLASS},
+
+  {ICAL_METHOD_ADD,icalclassify_add_instance,ICAL_ADD_INSTANCE_CLASS},
+
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_event,ICAL_CANCEL_EVENT_CLASS},
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_instance,ICAL_CANCEL_INSTANCE_CLASS},
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_all,ICAL_CANCEL_ALL_CLASS},
+
+  {ICAL_METHOD_REFRESH,icalclassify_refesh,ICAL_REFRESH_CLASS},
+  {ICAL_METHOD_COUNTER,icalclassify_counter,ICAL_COUNTER_CLASS},
+  {ICAL_METHOD_DECLINECOUNTER,icalclassify_delinecounter,ICAL_DECLINECOUNTER_CLASS},
+  {ICAL_METHOD_NONE,0,ICAL_NO_CLASS}
+};
+
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user)
+{
+    icalcomponent *inner;
+    icalproperty *p;
+    icalproperty_method method;
+    ical_class class = ICAL_UNKNOWN_CLASS;
+
+    int i;
+
+    struct icalclassify_parts comp_parts;
+    struct icalclassify_parts match_parts;
+
+    inner = icalcomponent_get_first_real_component(c);
+    
+    if (inner == 0) {
+        return ICAL_NO_CLASS;
+    }
+
+    icalssutil_get_parts(c,&comp_parts);
+    icalssutil_get_parts(match,&match_parts);
+
+    /* Determine if the incoming component is obsoleted by the match */
+    if(match != 0 && (
+        comp_parts.method == ICAL_METHOD_REQUEST
+        )){
+        assert ( ! ((comp_parts.dtstamp.is_utc==1)^
+                    (match_parts.dtstamp.is_utc==1)));
+
+        if( comp_parts.sequence<match_parts.sequence &&
+            icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)>0)
+        {
+            /* comp has a smaller sequence and a later DTSTAMP */
+            return ICAL_MISSEQUENCED_CLASS;
+        }
+
+        if( (comp_parts.sequence<match_parts.sequence )
+             /*&&icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0*/
+             ||
+           ( comp_parts.sequence == match_parts.sequence &&
+             icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0)){
+
+            return ICAL_OBSOLETE_CLASS;
+        }
+
+    }
+
+    p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY);
+    if (p == 0) {
+        return ICAL_UNKNOWN_CLASS;
+    }
+    method = icalproperty_get_method(p);
+
+    for (i =0; icalclassify_map[i].method != ICAL_METHOD_NONE; i++){
+        if(icalclassify_map[i].method == method){
+            if( (*(icalclassify_map[i].fn))(&comp_parts,&match_parts,user)==1){
+                class = icalclassify_map[i].class;
+                break;
+            }
+        }
+    }
+
+    icalssutil_free_parts(&comp_parts); 
+    icalssutil_free_parts(&match_parts);
+
+    return class;
+
+}
+
+struct class_map {
+        ical_class class;
+        char *str;
+} class_map[] = {
+    {ICAL_NO_CLASS,"No class"},
+    {ICAL_PUBLISH_NEW_CLASS,"New Publish"},
+    {ICAL_PUBLISH_UPDATE_CLASS,"Publish Update"},
+    {ICAL_PUBLISH_FREEBUSY_CLASS,"Publish freebusy"},
+    {ICAL_REQUEST_NEW_CLASS,"New request"},
+    {ICAL_REQUEST_UPDATE_CLASS,"Update"},
+    {ICAL_REQUEST_RESCHEDULE_CLASS,"Reschedule"},
+    {ICAL_REQUEST_DELEGATE_CLASS,"Delegate request"},
+    {ICAL_REQUEST_NEW_ORGANIZER_CLASS,"New Organizer"},
+    {ICAL_REQUEST_FORWARD_CLASS,"Forward"},
+    {ICAL_REQUEST_STATUS_CLASS,"Status request"},
+    {ICAL_REPLY_ACCEPT_CLASS,"Accept reply"},
+    {ICAL_REPLY_DECLINE_CLASS,"Decline reply"},
+    {ICAL_REPLY_DELEGATE_CLASS,"Delegation reply"},
+    {ICAL_REPLY_CRASHER_ACCEPT_CLASS,"Crasher's accept reply"},
+    {ICAL_REPLY_CRASHER_DECLINE_CLASS,"Crasher's decline reply"},
+    {ICAL_ADD_INSTANCE_CLASS,"Add instance"},
+    {ICAL_CANCEL_EVENT_CLASS,"Cancel event"},
+    {ICAL_CANCEL_INSTANCE_CLASS,"Cancel instance"},
+    {ICAL_CANCEL_ALL_CLASS,"Cancel all instances"},
+    {ICAL_REFRESH_CLASS,"Refresh"},
+    {ICAL_COUNTER_CLASS,"Counter"},
+    {ICAL_DECLINECOUNTER_CLASS,"Decline counter"},
+    {ICAL_MALFORMED_CLASS,"Malformed"}, 
+    {ICAL_OBSOLETE_CLASS,"Obsolete"},
+    {ICAL_MISSEQUENCED_CLASS,"Missequenced"},
+    {ICAL_UNKNOWN_CLASS,"Unknown"}
+};
+
+char* icalclassify_class_to_string(ical_class class)
+{
+    int i; 
+
+    for (i = 0;class_map[i].class != ICAL_UNKNOWN_CLASS;i++){
+        if (class_map[i].class == class){
+            return class_map[i].str;
+        }
+    }
+
+    return "Unknown";
+}
diff --git a/libical/src/libicalss/icalclassify.h b/libical/src/libicalss/icalclassify.h
new file mode 100644
index 0000000..81188b3
--- a/dev/null
+++ b/libical/src/libicalss/icalclassify.h
@@ -0,0 +1,77 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalclassify.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#ifndef ICALCLASSIFY_H
+#define ICALCLASSIFY_H
+
+#include "ical.h"
+#include "icalset.h"
+
+
+typedef enum icalclass {
+    ICAL_NO_CLASS,
+    ICAL_PUBLISH_NEW_CLASS,
+    ICAL_PUBLISH_UPDATE_CLASS,
+    ICAL_PUBLISH_FREEBUSY_CLASS,
+    ICAL_REQUEST_NEW_CLASS,
+    ICAL_REQUEST_UPDATE_CLASS,
+    ICAL_REQUEST_RESCHEDULE_CLASS,
+    ICAL_REQUEST_DELEGATE_CLASS,
+    ICAL_REQUEST_NEW_ORGANIZER_CLASS,
+    ICAL_REQUEST_FORWARD_CLASS,
+    ICAL_REQUEST_STATUS_CLASS,
+    ICAL_REQUEST_FREEBUSY_CLASS,
+    ICAL_REPLY_ACCEPT_CLASS,
+    ICAL_REPLY_DECLINE_CLASS,
+    ICAL_REPLY_DELEGATE_CLASS,
+    ICAL_REPLY_CRASHER_ACCEPT_CLASS,
+    ICAL_REPLY_CRASHER_DECLINE_CLASS,
+    ICAL_ADD_INSTANCE_CLASS,
+    ICAL_CANCEL_EVENT_CLASS,
+    ICAL_CANCEL_INSTANCE_CLASS,
+    ICAL_CANCEL_ALL_CLASS,
+    ICAL_REFRESH_CLASS,
+    ICAL_COUNTER_CLASS,
+    ICAL_DECLINECOUNTER_CLASS,
+    ICAL_MALFORMED_CLASS, 
+    ICAL_OBSOLETE_CLASS, /* 21 */
+    ICAL_MISSEQUENCED_CLASS, /* 22 */
+    ICAL_UNKNOWN_CLASS /* 23 */
+} ical_class;
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user);
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp);
+
+char* icalclassify_class_to_string(ical_class iclass);
+
+
+#endif /* ICALCLASSIFY_H*/
+
+
+                                    
+
+
diff --git a/libical/src/libicalss/icalcstp.c b/libical/src/libicalss/icalcstp.c
new file mode 100644
index 0000000..ed62b40
--- a/dev/null
+++ b/libical/src/libicalss/icalcstp.c
@@ -0,0 +1,122 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstps.c
+    CREATOR: ebusboom 23 Jun 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalcstp.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include <unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+
+struct command_map {
+        enum icalcstp_command command;
+        char *str;
+} command_map[] = 
+{
+    {ICAL_ABORT_COMMAND,"ABORT"},
+    {ICAL_AUTHENTICATE_COMMAND,"AUTHENTICATE"},
+    {ICAL_CAPABILITY_COMMAND,"CAPABILITY"},
+    {ICAL_CONTINUE_COMMAND,"CONTINUE"},
+    {ICAL_CALIDEXPAND_COMMAND,"CALIDEXPAND"},
+    {ICAL_IDENTIFY_COMMAND,"IDENTIFY"},
+    {ICAL_DISCONNECT_COMMAND,"DISCONNECT"},
+    {ICAL_SENDDATA_COMMAND,"SENDDATA"},
+    {ICAL_STARTTLS_COMMAND,"STARTTLS"},
+    {ICAL_UPNEXPAND_COMMAND,"UPNEXPAND"},
+    {ICAL_UNKNOWN_COMMAND,"UNKNOWN"}
+};
+
+
+icalcstp_command icalcstp_line_command(char* line)
+{
+    int i;
+
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
+
+        if(strncmp(line, command_map[i].str, l) == 0){
+            return command_map[i].command;
+        }
+    
+    }
+
+    return ICAL_UNKNOWN_COMMAND;
+}
+
+icalrequeststatus icalcstp_line_response_code(char* line)
+{
+    struct icalreqstattype rs; 
+
+    rs = icalreqstattype_from_string(line);
+
+    return rs.code;
+}
+
+int icalcstp_line_is_endofdata(char* line)
+{
+    if(line[0] == '.' && line[1] == '\n'){
+        return 1;
+    }
+
+    return 0;
+
+}
+
+int icalcstp_line_is_mime(char* line)
+{
+  return 0;
+}
+
+
+const char* icalcstp_command_to_string(icalcstp_command command){
+
+    int i;
+
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
+
+        if(command_map[i].command == command){
+            return command_map[i].str;
+        }
+    
+    }
+
+    return command_map[i].str;
+
+}
+
diff --git a/libical/src/libicalss/icalcstp.h b/libical/src/libicalss/icalcstp.h
new file mode 100644
index 0000000..dfc3618
--- a/dev/null
+++ b/libical/src/libicalss/icalcstp.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstp.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTP_H
+#define ICALCSTP_H
+
+#include "ical.h"
+
+
+/* Connection state, from the state machine in RFC2445 */
+enum cstps_state {
+    NO_STATE,
+    CONNECTED,
+    AUTHENTICATED,
+    IDENTIFIED,
+    DISCONNECTED,
+    RECEIVE
+};
+
+/* CSTP Commands that a client can issue to a server */
+typedef enum icalcstp_command {
+    ICAL_ABORT_COMMAND,
+    ICAL_AUTHENTICATE_COMMAND,
+    ICAL_CAPABILITY_COMMAND,
+    ICAL_CONTINUE_COMMAND,
+    ICAL_CALIDEXPAND_COMMAND,
+    ICAL_IDENTIFY_COMMAND,
+    ICAL_DISCONNECT_COMMAND,
+    ICAL_SENDDATA_COMMAND,
+    ICAL_STARTTLS_COMMAND,
+    ICAL_UPNEXPAND_COMMAND,
+    ICAL_COMPLETE_COMMAND,
+    ICAL_UNKNOWN_COMMAND
+} icalcstp_command;
+
+
+
+/* A statement is a combination of command or response code and a
+   component that the server and client exchage with each other. */
+struct icalcstp_statement {
+    icalcstp_command command;
+    char* str_data; /* If non-NUll use as arguments to command */
+    int int_data; /* If non-NULL use as arguments to command */
+
+    icalrequeststatus code;
+
+    icalcomponent* data;
+};
+
+const char* icalcstp_command_to_string(icalcstp_command command);
+icalcstp_command icalcstp_string_to_command(const char* str);
+
+#endif /* !ICALCSTP_H */
+
+
+
diff --git a/libical/src/libicalss/icalcstpclient.c b/libical/src/libicalss/icalcstpclient.c
new file mode 100644
index 0000000..03a70dd
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpclient.c
@@ -0,0 +1,350 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstps.c
+    CREATOR: ebusboom 23 Jun 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpclient.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include<unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+#define EOL "\n"
+
+
+/* Client state machine */
+
+typedef enum icalcstpc_line_type {
+    ICALCSTPC_RESPONSE_CODE_LINE,
+    ICALCSTPC_TERMINATOR_LINE,
+    ICALCSTPC_APPLICATION_DATA_LINE
+} icalcstpc_line_type;
+
+typedef enum icalcstpc_state {
+    ICALCSTPC_SEND_STATE,
+    ICALCSTPC_RESPONSE_CODE_STATE,
+    ICALCSTPC_RESPONSE_DATA_STATE
+} icalcstpc_state;
+
+
+
+struct icalcstpc_impl {
+    int timeout;
+    icalparser *parser;
+    icalcstp_command command;
+    icalcstpc_state state;
+    char* next_output;
+    char* next_input;
+};
+
+icalcstpc* icalcstpc_new()
+{
+    struct icalcstpc_impl *impl;
+
+    impl = malloc(sizeof(struct icalcstpc_impl));
+    
+    if(impl == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(impl,0,sizeof(struct icalcstpc_impl));
+
+    return impl;
+}
+
+void icalcstpc_free(icalcstpc* cstpc)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstpc;
+
+    if(impl->next_output != 0){
+        free(impl->next_output);
+    }
+
+    if(impl->next_input != 0){
+        free(impl->next_input);
+    }
+    
+    
+    if(impl->parser != 0){
+        icalparser_free(impl->parser);
+    }
+}
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char * line)
+{
+    char* out;
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    if(impl->next_output == 0){
+        return 0;
+    }
+    
+    out = impl->next_output;
+
+    impl->next_output = 0;
+
+    icalmemory_add_tmp_buffer(out);
+
+    return out;
+}
+
+/* process the next string sent by the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char* line)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+    icalcstpc_line_type line_type;
+
+    if(icalcstp_line_is_endofdata(line) || line == 0){
+        return 0;
+    }
+
+    switch (impl->command){
+    case ICAL_ABORT_COMMAND:{
+        break;
+    }
+    case ICAL_AUTHENTICATE_COMMAND:{
+        break;
+    }
+    case ICAL_CAPABILITY_COMMAND:{
+        break;
+    }
+    case ICAL_CONTINUE_COMMAND:{
+        break;
+    }
+    case ICAL_CALIDEXPAND_COMMAND:{
+        break;
+    }
+    case ICAL_IDENTIFY_COMMAND:{
+        break;
+    }
+    case ICAL_DISCONNECT_COMMAND:{
+        break;
+    }
+    case ICAL_SENDDATA_COMMAND:{
+        break;
+    }
+    case ICAL_STARTTLS_COMMAND:{
+        break;
+    }
+    case ICAL_UPNEXPAND_COMMAND:{
+        break;
+    }
+    case ICAL_COMPLETE_COMMAND:{
+        break;
+    }
+    case ICAL_UNKNOWN_COMMAND:{
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+}
+
+
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+icalerrorenum icalcstpc_abort(icalcstpc* cstp)
+{
+    struct icalcstpc_impl* impl = (struct icalcstpc_impl*)cstp;
+    
+    icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+
+    impl->next_output = "ABORT\n";
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpclient_setup_output(icalcstpc* cstp, size_t sz)
+{
+   struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+   if(impl->next_output != 0){
+       icalerror_set_errno(ICAL_USAGE_ERROR);
+       return ICAL_USAGE_ERROR;
+   }
+
+   impl->next_output = malloc(sz);
+
+   if(impl->next_output == 0){
+       icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+       return ICAL_NEWFAILED_ERROR;
+   }
+   
+   return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* data, char* f(char*))
+{
+   struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+   char* command_str;
+   icalerrorenum error;
+   size_t sz;
+
+   icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(mechanism!=0,"mechanism",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(data!=0,"data",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(f!=0,"f",ICAL_BADARG_ERROR);
+
+   impl->command = ICAL_AUTHENTICATE_COMMAND;
+
+   command_str = icalcstp_command_to_string(impl->command);
+
+   sz = strlen(command_str) + strlen(mechanism) + strlen(data) + 4;
+
+   if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+       return error;
+   }
+
+   sprintf(impl->next_output,"%s %s %s%s",command_str,mechanism,data,EOL);
+
+   return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_capability(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+    char* command_str;
+    icalerrorenum error;
+    size_t sz;
+
+    icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+    
+    impl->command = ICAL_CAPABILITY_COMMAND;
+    
+    command_str = icalcstp_command_to_string(impl->command);
+
+    sz = strlen(command_str);
+    
+    if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+        return error;
+    }
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_CALIDEXPAND_COMMAND;
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_CONTINUE_COMMAND;
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_DISCONNECT_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_IDENTIFY_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* data, char * f(char*))
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_STARTTLS_COMMAND;
+    
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_UPNEXPAND_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_SENDDATA_COMMAND;
+    
+    return ICAL_NO_ERROR;
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalcstpclient.h b/libical/src/libicalss/icalcstpclient.h
new file mode 100644
index 0000000..8d9d0c9
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpclient.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpclient.h
+  CREATOR: eric 4 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPC_H
+#define ICALCSTPC_H
+
+#include "ical.h"
+#include "icalcstp.h"
+
+/********************** Client (Sender) Interfaces **************************/
+
+/* How to use: 
+
+   1) Construct a new icalcstpc
+   2) Issue a command by calling one of the command routines. 
+   3) Repeat until both call icalcstpc_next_output and
+   icalcstpc_next_input return 0:
+     3a) Call icalcstpc_next_output. Send string to server. 
+     3b) Get string from server, & give to icalcstp_next_input()
+   4) Iterate with icalcstpc_first_response & icalcstp_next_response to 
+   get the servers responses
+   5) Repeat at #2
+*/
+
+
+typedef void icalcstpc;
+
+/* Response code sent by the server. */
+        typedef struct icalcstpc_response {
+    icalrequeststatus code;
+    char *arg; /* These strings are owned by libical */
+    char *debug_text;
+    char *more_text;
+    void* result;
+} icalcstpc_response;
+
+
+icalcstpc* icalcstpc_new();
+
+void icalcstpc_free(icalcstpc* cstpc);
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
+
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char* line);
+
+/* process the next string from the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char * line);
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
+
+/* Issue a command */
+icalerrorenum icalcstpc_abort(icalcstpc* cstp);
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* init_data, char* f(char*) );
+icalerrorenum icalcstpc_capability(icalcstpc* cstp);
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time);
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp);
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id);
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* init_data, char* f(char*));
+icalerrorenum icalcstpc_senddata(icalcstpc* cstp, unsigned int time,
+                                icalcomponent *comp);
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp);
+
+
+#endif /* !ICALCSTPC_H */
+
+
+
diff --git a/libical/src/libicalss/icalcstpserver.c b/libical/src/libicalss/icalcstpserver.c
new file mode 100644
index 0000000..cd8b3bb
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpserver.c
@@ -0,0 +1,285 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstpserver.c
+    CREATOR: ebusboom 13 Feb 01
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpserver.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include<unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+
+
+struct icalcstps_impl {
+        int timeout;
+        icalparser *parser;
+        enum cstps_state major_state;
+        struct icalcstps_commandfp commandfp;
+};
+
+
+
+
+/* This state machine is a Mealy-type: actions occur on the
+   transitions, not in the states.
+   
+   Here is the state machine diagram from the CAP draft:
+
+
+        STARTTLS /
+        CAPABILITY
+       +-------+
+       |       |                       +---------------+
+       |   +-----------+ AUTHENTICATE  |               |
+       +-->| Connected |-------------->| Authenticated |
+           +-----------+               |               |
+             |                         +---------------+
+             |                              |
+             |                              |
+             |                              |
+             |                              |       +-----+ STARTTLS /
+             |                              V       |     | CAPABILITY /
+             |                         +---------------+  | IDENTIFY
+             |                         |               |<-+
+             |                         |   Identified  |<----+
+             |                +--------|               |     |
+             |                |        +---------------+     | command
+             |                |             |                | completes
+             V                |DISCONNECT   |                |
+           +--------------+   |             |SENDDATA        |
+           | Disconnected |<--+             |                |
+           +--------------+                 |                | ABORT
+                     A                      |                |
+                     |                      V                |
+                     |     DISCONNECT     +---------------+  |
+                     +--------------------|    Receive    |--+
+                                          |               |<--+
+                                          +---------------+   |
+                                                         |    | CONTINUTE
+                                                         +----+
+
+   In this implmenetation, the transition from CONNECTED to IDENTIFIED
+   is non-standard. The spec specifies that on the ATHENTICATE
+   command, the machine transitions from CONNECTED to AUTHENTICATED,
+   and then immediately goes to IDENTIFIED. This makes AUTHENTICATED a
+   useless state, so I removed it */
+
+struct state_table {
+        enum cstps_state major_state;
+        enum icalcstp_command command;
+        void (*action)();
+        enum cstps_state next_state;
+
+} server_state_table[] = 
+{
+    { CONNECTED, ICAL_CAPABILITY_COMMAND , 0, CONNECTED},
+    { CONNECTED, ICAL_AUTHENTICATE_COMMAND , 0,  IDENTIFIED}, /* Non-standard */
+    { IDENTIFIED, ICAL_STARTTLS_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_IDENTIFY_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_CAPABILITY_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_SENDDATA_COMMAND, 0, RECEIVE},
+    { IDENTIFIED, ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+    { DISCONNECTED, 0, 0, 0},
+    { RECEIVE,  ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+    { RECEIVE,  ICAL_CONTINUE_COMMAND, 0, RECEIVE},
+    { RECEIVE,  ICAL_ABORT_COMMAND , 0, IDENTIFIED},
+    { RECEIVE,  ICAL_COMPLETE_COMMAND , 0, IDENTIFIED}
+};
+
+
+/**********************************************************************/
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp cfp)
+{
+    struct icalcstps_impl* impl;
+
+    if ( ( impl = (struct icalcstps_impl*)
+           malloc(sizeof(struct icalcstps_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    impl->commandfp = cfp;
+    impl->timeout = 10;
+
+    return (icalcstps*)impl;
+
+}
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec) 
+{
+    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+
+    icalerror_check_arg_rz( (cstp!=0), "cstp");
+
+    impl->timeout = sec;
+
+    return sec;
+}
+
+        typedef struct icalcstps_response {
+        icalrequeststatus code;
+        char caluid[1024];
+        void* result;
+} icalcstps_response;
+
+
+icalerrorenum prep_abort(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_authenticate(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_capability(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_calidexpand(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_continue(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_disconnect(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_identify(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_starttls(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_upnexpand(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_sendata(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+
+char* icalcstps_process_incoming(icalcstps* cstp, char* input)
+{
+    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+    char *i;
+    char *cmd_or_resp;
+    char *data;
+    char *input_cpy;
+    icalerrorenum error;
+
+    icalerror_check_arg_rz(cstp !=0,"cstp");
+    icalerror_check_arg_rz(input !=0,"input");
+
+    if ((input_cpy = (char*)strdup(input)) == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    i = (char*)strstr(" ",input_cpy);
+
+    cmd_or_resp = input_cpy;
+
+    if (i != 0){
+        *i = '\0';
+        data = ++i;
+    } else {
+        data = 0;
+    }
+
+    printf("cmd: %s\n",cmd_or_resp);
+    printf("data: %s\n",data);
+        
+    /* extract the command, look up in the state table, and dispatch
+       to the proper handler */    
+
+    if(strcmp(cmd_or_resp,"ABORT") == 0){
+                error = prep_abort(impl,data);
+    } else if(strcmp(cmd_or_resp,"AUTHENTICATE") == 0){
+        error = prep_authenticate(impl,data);
+    } else if(strcmp(cmd_or_resp,"CAPABILITY") == 0){
+        error = prep_capability(impl,data);
+    } else if(strcmp(cmd_or_resp,"CALIDEXPAND") == 0){
+        error = prep_calidexpand(impl,data);
+    } else if(strcmp(cmd_or_resp,"CONTINUE") == 0){
+        error = prep_continue(impl,data);
+    } else if(strcmp(cmd_or_resp,"DISCONNECT") == 0){
+        error = prep_disconnect(impl,data);
+    } else if(strcmp(cmd_or_resp,"IDENTIFY") == 0){
+        error = prep_identify(impl,data);
+    } else if(strcmp(cmd_or_resp,"STARTTLS") == 0){
+        error = prep_starttls(impl,data);
+    } else if(strcmp(cmd_or_resp,"UPNEXPAND") == 0){
+        error = prep_upnexpand(impl,data);
+    } else if(strcmp(cmd_or_resp,"SENDDATA") == 0){
+        error = prep_sendata(impl,data);
+    }
+    
+    return 0;
+}
+
+    /* Read data until we get a end of data marker */
+
+
+
+struct icalcstps_server_stubs {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism, 
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time, 
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command, 
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};
+
diff --git a/libical/src/libicalss/icalcstpserver.h b/libical/src/libicalss/icalcstpserver.h
new file mode 100644
index 0000000..6fa2254
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpserver.h
@@ -0,0 +1,101 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpserver.h
+  CREATOR: eric 13 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPS_H
+#define ICALCSTPS_H
+
+#include "ical.h"
+
+
+/********************** Server (Reciever) Interfaces *************************/
+
+/* On the server side, the caller will recieve data from the incoming
+   socket and pass it to icalcstps_next_input. The caller then takes
+   the return from icalcstps_next_outpu and sends it out through the
+   socket. This gives the caller a point of control. If the cstp code
+   connected to the socket itself, it would be hard for the caller to
+   do anything else after the cstp code was started.
+
+   All of the server and client command routines will generate
+   response codes. On the server side, these responses will be turned
+   into text and sent to the client. On the client side, the reponse
+   is the one sent from the server.
+
+   Since each command can return multiple responses, the responses are
+   stored in the icalcstps object and are accesses by
+   icalcstps_first_response() and icalcstps_next_response()
+
+   How to use: 
+
+   1) Construct a new icalcstps, bound to your code via stubs
+   2) Repeat forever:
+     2a) Get string from client & give to icalcstps_next_input()
+     2b) Repeat until icalcstp_next_output returns 0:
+       2b1) Call icalcstps_next_output. 
+       2b2) Send string to client.
+*/
+
+
+
+typedef void icalcstps;
+
+/* Pointers to the rountines that
+   icalcstps_process_incoming will call when it recognizes a CSTP
+   command in the data. BTW, the CONTINUE command is named 'cont'
+   because 'continue' is a C keyword */
+
+struct icalcstps_commandfp {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};                                                        
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp stubs);
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec);
+
+/* Get the next string to send to the client */
+char* icalcstps_next_output(icalcstps* cstp);
+
+/* process the next string from the client */ 
+int icalcstps_next_input(icalcstps* cstp);
+
+#endif /* ICALCSTPS */
diff --git a/libical/src/libicalss/icaldirset.c b/libical/src/libicalss/icaldirset.c
new file mode 100644
index 0000000..b6cb673
--- a/dev/null
+++ b/libical/src/libicalss/icaldirset.c
@@ -0,0 +1,777 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icaldirset.c
+    CREATOR: eric 28 November 1999
+  
+    $Id$
+    $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+    The Original Code is eric. The Initial Developer of the Original
+    Code is Eric Busboom
+
+
+    ======================================================================*/
+
+
+/*
+ 
+  icaldirset manages a database of ical components and offers
+  interfaces for reading, writting and searching for components.
+
+  icaldirset groups components in to clusters based on their DTSTAMP
+  time -- all components that start in the same month are grouped
+  together in a single file. All files in a sotre are kept in a single
+  directory. 
+
+  The primary interfaces are icaldirset_first and icaldirset_next. These
+  routine iterate through all of the components in the store, subject
+  to the current gauge. A gauge is an icalcomponent that is tested
+  against other componets for a match. If a gauge has been set with
+  icaldirset_select, icaldirset_first and icaldirset_next will only
+  return componentes that match the gauge.
+
+  The Store generated UIDs for all objects that are stored if they do
+  not already have a UID. The UID is the name of the cluster (month &
+  year as MMYYYY) plus a unique serial number. The serial number is
+  stored as a property of the cluster.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icaldirset.h"
+#include "pvl.h" 
+#include "icalparser.h"
+#include "icaldirset.h"
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+#include "icalgauge.h"
+
+#include <limits.h> /* For PATH_MAX */
+#include <errno.h>
+#include <sys/types.h> /* for opendir() */
+#include <sys/stat.h> /* for stat */
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <dirent.h> /* for opendir() */
+#include <unistd.h>
+#include <sys/utsname.h> /* for uname */
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <time.h> /* for clock() */
+#include <stdlib.h> /* for rand(), srand() */
+#include <string.h> /* for strdup */
+#include "icaldirsetimpl.h"
+
+
+struct icaldirset_impl* icaldirset_new_impl()
+{
+    struct icaldirset_impl* impl;
+
+    if ( ( impl = (struct icaldirset_impl*)
+           malloc(sizeof(struct icaldirset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    strcpy(impl->id,ICALDIRSET_ID);
+
+    return impl;
+}
+
+const char* icaldirset_path(icaldirset* cluster)
+{
+    struct icaldirset_impl *impl = icaldirset_new_impl();
+
+    return impl->dir;
+
+}
+
+void icaldirset_mark(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalfileset_mark(impl->cluster);
+}
+
+
+icalerrorenum icaldirset_commit(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    return icalfileset_commit(impl->cluster);
+
+}
+
+void icaldirset_lock(const char* dir)
+{
+}
+
+
+void icaldirset_unlock(const char* dir)
+{
+}
+
+/* Load the contents of the store directory into the store's internal directory list*/
+icalerrorenum icaldirset_read_directory(struct icaldirset_impl* impl)
+{
+#ifndef _QTWIN_
+    struct dirent *de;
+    DIR* dp;
+    char *str;
+ 
+    dp = opendir(impl->dir);
+   
+    if ( dp == 0) {
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+    }
+
+    /* clear contents of directory list */
+    while((str = pvl_pop(impl->directory))){
+        free(str);
+    }
+    
+    /* load all of the cluster names in the directory list */
+    for(de = readdir(dp);
+        de != 0;
+        de = readdir(dp)){
+
+        /* Remove known directory names  '.' and '..'*/
+        if (strcmp(de->d_name,".") == 0 ||
+            strcmp(de->d_name,"..") == 0 ){
+            continue;
+        }
+
+                pvl_push(impl->directory, (void*)strdup(de->d_name));
+    }
+
+    closedir(dp);
+
+    return ICAL_NO_ERROR;
+#else
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+#endif
+}
+
+icaldirset* icaldirset_new(const char* dir)
+{
+    struct icaldirset_impl *impl = icaldirset_new_impl();
+    struct stat sbuf;
+
+    if (impl == 0){
+        return 0;
+    }
+
+    icalerror_check_arg_rz( (dir!=0), "dir");
+
+    if (stat(dir,&sbuf) != 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return 0;
+    }
+    
+#ifndef _QTWIN_
+    /* dir is not the name of a direectory*/
+    if (!S_ISDIR(sbuf.st_mode)){ 
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return 0;
+            }    
+#endif
+
+    icaldirset_lock(dir);
+
+    impl = icaldirset_new_impl();
+
+    if (impl ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    impl->directory = pvl_newlist();
+    impl->directory_iterator = 0;
+    impl->dir = (char*)strdup(dir);
+    impl->gauge = 0;
+    impl->first_component = 0;
+    impl->cluster = 0;
+
+    icaldirset_read_directory(impl);
+
+    return (icaldirset*) impl;
+}
+
+void icaldirset_free(icaldirset* s)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)s;
+    char* str;
+
+    icaldirset_unlock(impl->dir);
+
+    if(impl->dir !=0){
+        free(impl->dir);
+    }
+
+    if(impl->gauge !=0){
+        icalcomponent_free(impl->gauge);
+    }
+
+    if(impl->cluster !=0){
+        icalfileset_free(impl->cluster);
+    }
+
+    while(impl->directory !=0 &&  (str=pvl_pop(impl->directory)) != 0){
+        free(str);
+    }
+
+    if(impl->directory != 0){
+        pvl_free(impl->directory);
+    }
+
+    impl->directory = 0;
+    impl->directory_iterator = 0;
+    impl->dir = 0;
+    impl->gauge = 0;
+    impl->first_component = 0;
+
+    free(impl);
+
+}
+
+/* icaldirset_next_uid_number updates a serial number in the Store
+   directory in a file called SEQUENCE */
+
+int icaldirset_next_uid_number(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    char sequence = 0;
+    char temp[128];
+    char filename[ICAL_PATH_MAX];
+    char *r;
+    FILE *f;
+    struct stat sbuf;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+
+    sprintf(filename,"%s/%s",impl->dir,"SEQUENCE");
+
+    /* Create the file if it does not exist.*/
+#ifndef _QTWIN_
+    if (stat(filename,&sbuf) == -1 || !S_ISREG(sbuf.st_mode)){
+#else
+    if (stat(filename,&sbuf) == -1){
+#endif
+
+        f = fopen(filename,"w");
+        if (f != 0){
+            fprintf(f,"0");
+            fclose(f);
+        } else {
+            icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number");
+            return 0;
+        }
+        
+    }
+    
+    if ( (f = fopen(filename,"r+")) != 0){
+
+        rewind(f);
+        r = fgets(temp,128,f);
+
+        if (r == 0){
+            sequence = 1;
+        } else {
+            sequence = atoi(temp)+1;
+        }
+
+        rewind(f);
+
+        fprintf(f,"%d",sequence);
+
+        fclose(f);
+
+        return sequence;
+        
+    } else {
+        icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number");
+        return 0;
+    }
+
+}
+
+icalerrorenum icaldirset_next_cluster(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    char path[ICAL_PATH_MAX];
+
+    if (impl->directory_iterator == 0){
+        icalerror_set_errno(ICAL_INTERNAL_ERROR);
+        return ICAL_INTERNAL_ERROR;
+            }    
+    impl->directory_iterator = pvl_next(impl->directory_iterator);
+
+    if (impl->directory_iterator == 0){
+        /* There are no more clusters */
+        if(impl->cluster != 0){
+            icalfileset_free(impl->cluster);
+            impl->cluster = 0;
+        }
+        return ICAL_NO_ERROR;
+    }
+            
+    sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+    icalfileset_free(impl->cluster);
+
+    impl->cluster = icalfileset_new(path);
+
+    return icalerrno;
+}
+
+void icaldirset_add_uid(icaldirset* store, icaldirset* comp)
+{
+#ifndef _QTWIN_
+
+    char uidstring[ICAL_PATH_MAX];
+    icalproperty *uid;
+    struct utsname unamebuf;
+
+    icalerror_check_arg_rv( (store!=0), "store");
+    icalerror_check_arg_rv( (comp!=0), "comp");
+
+    uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY);
+    
+    if (uid == 0) {
+        
+        uname(&unamebuf);
+        
+        sprintf(uidstring,"%d-%s",(int)getpid(),unamebuf.nodename);
+        
+        uid = icalproperty_new_uid(uidstring);
+        icalcomponent_add_property(comp,uid);
+    } else {
+        
+        strcpy(uidstring,icalproperty_get_uid(uid));
+    }
+
+#endif
+}
+
+
+/* This assumes that the top level component is a VCALENDAR, and there
+   is an inner component of type VEVENT, VTODO or VJOURNAL. The inner
+   component must have a DTAMP property */
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icaldirset* comp)
+{
+    struct icaldirset_impl *impl;
+    char clustername[ICAL_PATH_MAX];
+    icalproperty *dt;
+    icalvalue *v;
+    struct icaltimetype tm;
+    icalerrorenum error = ICAL_NO_ERROR;
+    icalcomponent *inner;
+
+    impl = (struct icaldirset_impl*)store;
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (comp!=0), "comp");
+
+    errno = 0;
+    
+    icaldirset_add_uid(store,comp);
+
+    /* Determine which cluster this object belongs in. This is a HACK */
+
+    for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+        inner != 0;
+        inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+  
+        dt = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
+         
+        if (dt != 0){
+            break; 
+                }
+    }
+
+    if (dt == 0){
+
+        for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+            inner != 0;
+            inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+            
+            dt = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
+            
+            if (dt != 0){
+                break; 
+                    }
+        }
+
+    }
+
+    if (dt == 0){
+
+
+        icalerror_warn("The component does not have a DTSTAMP or DTSTART property, so it cannot be added to the store");
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return ICAL_BADARG_ERROR;
+    }
+
+    v = icalproperty_get_value(dt);
+
+    tm = icalvalue_get_datetime(v);
+
+    snprintf(clustername,ICAL_PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month);
+
+    /* Load the cluster and insert the object */
+
+    if(impl->cluster != 0 && 
+       strcmp(clustername,icalfileset_path(impl->cluster)) != 0 ){
+        icalfileset_free(impl->cluster);
+        impl->cluster = 0;
+    }
+
+    if (impl->cluster == 0){
+        impl->cluster = icalfileset_new(clustername);
+
+        if (impl->cluster == 0){
+            error = icalerrno;
+        }
+    }
+    
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return error;
+    }
+
+    /* Add the component to the cluster */
+
+    icalfileset_add_component(impl->cluster,comp);
+    
+    icalfileset_mark(impl->cluster);
+
+    return ICAL_NO_ERROR;    
+}
+
+/* Remove a component in the current cluster. HACK. This routine is a
+   "friend" of icalfileset, and breaks its encapsulation. It was
+   either do it this way, or add several layers of interfaces that had
+   no other use.  */
+icalerrorenum icaldirset_remove_component(icaldirset* store, icaldirset* comp)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    struct icalfileset_impl *filesetimpl = 
+        (struct icalfileset_impl*)impl->cluster;
+
+    icalcomponent *filecomp = filesetimpl->cluster;
+
+    icalcompiter i;
+    int found = 0;
+
+    icalerror_check_arg_re((store!=0),"store",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((comp!=0),"comp",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((impl->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR);
+
+    for(i = icalcomponent_begin_component(filecomp,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *this = icalcompiter_deref(&i);
+
+        if (this == comp){
+            found = 1;
+            break;
+        }
+    }
+
+    if (found != 1){
+        icalerror_warn("icaldirset_remove_component: component is not part of current cluster");
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return ICAL_USAGE_ERROR;
+    }
+
+    icalfileset_remove_component(impl->cluster,comp);
+
+    icalfileset_mark(impl->cluster);
+
+    /* If the removal emptied the fileset, get the next fileset */
+    if( icalfileset_count_components(impl->cluster,ICAL_ANY_COMPONENT)==0){
+        
+        icalerrorenum error = icaldirset_next_cluster(store);
+
+        if(impl->cluster != 0 && error == ICAL_NO_ERROR){
+            icalfileset_get_first_component(impl->cluster);
+        } else {
+            /* HACK. Not strictly correct for impl->cluster==0 */
+            return error;
+        }
+    } else {
+        /* Do nothing */
+    }
+
+    return ICAL_NO_ERROR;
+}
+
+
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind)
+{
+    /* HACK, not implemented */
+    
+    assert(0);
+
+    return 0;
+}
+
+
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c)
+{
+    fprintf(stderr," icaldirset_fetch_match is not implemented\n");
+    assert(0);
+}
+
+
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid)
+{
+    icalcomponent *gauge;
+    icalcomponent *old_gauge;
+    icalcomponent *c;
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (uid!=0), "uid");
+
+    gauge = 
+        icalcomponent_vanew(
+            ICAL_VCALENDAR_COMPONENT,
+            icalcomponent_vanew(
+                ICAL_VEVENT_COMPONENT,  
+                icalproperty_vanew_uid(
+                    uid,
+                    icalparameter_new_xliccomparetype(
+                        ICAL_XLICCOMPARETYPE_EQUAL),
+                    0),
+                0),
+            0);
+
+    old_gauge = impl->gauge;
+    impl->gauge = gauge;
+
+    c= icaldirset_get_first_component(store);
+
+    impl->gauge = old_gauge;
+
+    icalcomponent_free(gauge);
+
+    return c;
+}
+
+
+int icaldirset_has_uid(icaldirset* store, const char* uid)
+{
+    icalcomponent *c;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (uid!=0), "uid");
+    
+    /* HACK. This is a temporary implementation. _has_uid should use a
+       database, and _fetch should use _has_uid, not the other way
+       around */
+    c = icaldirset_fetch(store,uid);
+
+    return c!=0;
+
+}
+
+
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge)
+ {
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalerror_check_arg_re( (store!=0), "store",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re( (gauge!=0), "gauge",ICAL_BADARG_ERROR);
+
+    if (!icalcomponent_is_valid(gauge)){
+        return ICAL_BADARG_ERROR;
+    }
+
+    impl->gauge = gauge;
+
+    return ICAL_NO_ERROR;
+}
+
+
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *old,
+                               icalcomponent *new)
+{
+    assert(0);
+    return ICAL_NO_ERROR; /* HACK, not implemented */
+
+}
+
+
+void icaldirset_clear(icaldirset* store)
+{
+
+    assert(0);
+    return;
+    /* HACK, not implemented */
+}
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    if(impl->cluster == 0){
+        icaldirset_get_first_component(store);
+    }
+
+    return icalfileset_get_current_component(impl->cluster);
+
+}
+
+
+icalcomponent* icaldirset_get_first_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    icalerrorenum error;
+    char path[ICAL_PATH_MAX];
+
+    error = icaldirset_read_directory(impl);
+
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return 0;
+    }
+
+    impl->directory_iterator = pvl_head(impl->directory);
+    
+    if (impl->directory_iterator == 0){
+        icalerror_set_errno(error);
+        return 0;
+    }
+    
+    snprintf(path,ICAL_PATH_MAX,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+    /* If the next cluster we need is different than the current cluster, 
+       delete the current one and get a new one */
+
+    if(impl->cluster != 0 && strcmp(path,icalfileset_path(impl->cluster)) != 0 ){
+        icalfileset_free(impl->cluster);
+        impl->cluster = 0;
+    }
+    
+    if (impl->cluster == 0){
+        impl->cluster = icalfileset_new(path);
+
+        if (impl->cluster == 0){
+            error = icalerrno;
+        }
+    } 
+
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return 0;
+    }
+
+    impl->first_component = 1;
+
+    return icaldirset_get_next_component(store);
+}
+
+icalcomponent* icaldirset_get_next_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl;
+    icalcomponent *c;
+    icalerrorenum error;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+
+    impl = (struct icaldirset_impl*)store;
+
+    if(impl->cluster == 0){
+
+        icalerror_warn("icaldirset_get_next_component called with a NULL cluster (Caller must call icaldirset_get_first_component first");
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return 0;
+
+    }
+
+    /* Set the component iterator for the following for loop */
+    if (impl->first_component == 1){
+        icalfileset_get_first_component(impl->cluster);
+        impl->first_component = 0;
+    } else {
+        icalfileset_get_next_component(impl->cluster);
+    }
+
+
+    while(1){
+        /* Iterate through all of the objects in the cluster*/
+        for( c = icalfileset_get_current_component(impl->cluster);
+             c != 0;
+             c = icalfileset_get_next_component(impl->cluster)){
+            
+            /* If there is a gauge defined and the component does not
+               pass the gauge, skip the rest of the loop */
+
+#if 0 /* HACK */
+            if (impl->gauge != 0 && icalgauge_test(c,impl->gauge) == 0){
+                continue;
+            }
+#else
+            assert(0); /* icalgauge_test needs to be fixed */
+#endif
+            /* Either there is no gauge, or the component passed the
+               gauge, so return it*/
+
+            return c;
+        }
+
+        /* Fell through the loop, so the component we want is not
+           in this cluster. Load a new cluster and try again.*/
+
+        error = icaldirset_next_cluster(store);
+
+        if(impl->cluster == 0 || error != ICAL_NO_ERROR){
+            /* No more clusters */
+            return 0;
+        } else {
+            c = icalfileset_get_first_component(impl->cluster);
+
+            return c;
+        }
+        
+    }
+
+    return 0; /* Should never get here */
+}
+
+   
+
+
+
+
+        
diff --git a/libical/src/libicalss/icaldirset.h b/libical/src/libicalss/icaldirset.h
new file mode 100644
index 0000000..7d205ec
--- a/dev/null
+++ b/libical/src/libicalss/icaldirset.h
@@ -0,0 +1,82 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaldirset.h
+ CREATOR: eric 28 November 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDIRSET_H
+#define ICALDIRSET_H
+
+#include "ical.h"
+
+/* icaldirset Routines for storing, fetching, and searching for ical
+ * objects in a database */
+
+typedef void icaldirset;
+
+
+icaldirset* icaldirset_new(const char* path);
+
+void icaldirset_free(icaldirset* store);
+
+const char* icaldirset_path(icaldirset* store);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icaldirset_mark(icaldirset* store);
+icalerrorenum icaldirset_commit(icaldirset* store); 
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icalcomponent* comp);
+icalerrorenum icaldirset_remove_component(icaldirset* store, icalcomponent* comp);
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind);
+
+/* Restrict the component returned by icaldirset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge);
+void icaldirset_clear(icaldirset* store);
+
+/* Get a component by uid */
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid);
+int icaldirset_has_uid(icaldirset* store, const char* uid);
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store);
+icalcomponent* icaldirset_get_first_component(icaldirset* store);
+icalcomponent* icaldirset_get_next_component(icaldirset* store);
+
+#endif /* !ICALDIRSET_H */
+
+
+
diff --git a/libical/src/libicalss/icaldirsetimpl.h b/libical/src/libicalss/icaldirsetimpl.h
new file mode 100644
index 0000000..0e69ba2
--- a/dev/null
+++ b/libical/src/libicalss/icaldirsetimpl.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icaldirsetimpl.h
+  CREATOR: eric 21 Aug 2000
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+/* This definition is in its own file so it can be kept out of the
+   main header file, but used by "friend classes" like icalset*/
+
+#define ICALDIRSET_ID "dset"
+
+struct icaldirset_impl 
+{
+        char id[5]; /* "dset" */
+        char* dir;
+        icalcomponent* gauge;
+        icaldirset* cluster;
+        int first_component;
+        pvl_list directory;
+        pvl_elem directory_iterator;
+};
diff --git a/libical/src/libicalss/icalfileset.c b/libical/src/libicalss/icalfileset.c
new file mode 100644
index 0000000..943071d
--- a/dev/null
+++ b/libical/src/libicalss/icalfileset.c
@@ -0,0 +1,659 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalfileset.c
+  CREATOR: eric 23 December 1999
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <fcntl.h> /* For open() flags and mode */
+#include <sys/types.h> /* For open() flags and mode */
+#include <sys/stat.h> /* For open() flags and mode */
+
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+//
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+//extern int errno;
+
+int icalfileset_lock(icalfileset *cluster);
+int icalfileset_unlock(icalfileset *cluster);
+icalerrorenum icalfileset_read_file(icalfileset* cluster, mode_t mode);
+int icalfileset_filesize(icalfileset* cluster);
+
+icalerrorenum icalfileset_create_cluster(const char *path);
+
+icalfileset* icalfileset_new_impl()
+{
+    struct icalfileset_impl* impl;
+  
+    if ( ( impl = (struct icalfileset_impl*)
+           malloc(sizeof(struct icalfileset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
+        return 0;
+    }
+  
+    memset(impl,0,sizeof(struct icalfileset_impl));
+  
+    strcpy(impl->id,ICALFILESET_ID);
+  
+    return impl;
+}
+
+
+icalfileset* icalfileset_new(const char* path)
+{
+    return icalfileset_new_open(path, O_RDWR|O_CREAT, 0664);
+}
+
+icalfileset* icalfileset_new_open(const char* path, int flags, mode_t mode)
+{
+    struct icalfileset_impl *impl = icalfileset_new_impl(); 
+    struct icaltimetype tt;
+    off_t cluster_file_size;
+
+    memset(&tt,0,sizeof(struct icaltimetype));
+
+    icalerror_clear_errno();
+    icalerror_check_arg_rz( (path!=0), "path");
+
+    if (impl == 0){
+        return 0;
+    }
+
+    impl->path = strdup(path); 
+
+    cluster_file_size = icalfileset_filesize(impl);
+        
+    if(cluster_file_size < 0){
+        icalfileset_free(impl);
+        return 0;
+    } 
+
+    impl->fd = open(impl->path,flags, mode);
+    
+    if (impl->fd < 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        icalfileset_free(impl);
+        return 0;
+    }
+
+    icalfileset_lock(impl);
+    
+    if(cluster_file_size > 0 ){
+        icalerrorenum error;
+        if((error = icalfileset_read_file(impl,mode))!= ICAL_NO_ERROR){
+            icalfileset_free(impl);
+            return 0;
+        }
+    }
+ 
+    if(impl->cluster == 0){
+        impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+    }      
+    
+    return impl;
+}
+
+char* icalfileset_read_from_file(char *s, size_t size, void *d)
+{
+    
+    char* p = s;
+    int fd = (int)d;
+
+    /* Simulate fgets -- read single characters and stop at '\n' */
+
+    for(p=s; p<s+size-1;p++){
+        
+        if(read(fd,p,1) != 1 || *p=='\n'){
+            p++;
+            break;
+        } 
+    }
+
+    *p = '\0';
+    
+    if(*s == 0){
+        return 0;
+    } else {
+        return s;
+    }
+
+}
+
+
+icalerrorenum icalfileset_read_file(icalfileset* cluster,mode_t mode)
+{
+
+    icalparser *parser;
+  
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    
+    parser = icalparser_new();
+    icalparser_set_gen_data(parser,(void*)impl->fd);
+    impl->cluster = icalparser_parse(parser,icalfileset_read_from_file);
+    icalparser_free(parser);
+
+    if (impl->cluster == 0 || icalerrno != ICAL_NO_ERROR){
+        icalerror_set_errno(ICAL_PARSE_ERROR);
+        return ICAL_PARSE_ERROR;
+    }
+  
+    if (icalcomponent_isa(impl->cluster) != ICAL_XROOT_COMPONENT){
+        /* The parser got a single component, so it did not put it in
+           an XROOT. */
+        icalcomponent *cl = impl->cluster;
+        impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+        icalcomponent_add_component(impl->cluster,cl);
+    }
+
+    return ICAL_NO_ERROR;
+
+}
+
+int icalfileset_filesize(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    int cluster_file_size;
+    struct stat sbuf;
+
+    if (stat(impl->path,&sbuf) != 0){
+        
+        /* A file by the given name does not exist, or there was
+           another error */
+        cluster_file_size = 0;
+        if (errno == ENOENT) {
+            /* It was because the file does not exist */
+            return 0;
+        } else {
+            /* It was because of another error */
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return -1;
+        }
+    } else {
+        /* A file by the given name exists, but is it a regular file? */
+        
+#ifndef _QTWIN_
+        if (!S_ISREG(sbuf.st_mode)){ 
+            /* Nope, not a regular file */
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return -1;
+        } else {
+            /* Lets assume that it is a file of the right type */
+            return sbuf.st_size;
+        }
+#else
+            return sbuf.st_size;
+#endif
+        
+    }
+
+    /*return -1; not reached*/
+}
+
+void icalfileset_free(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rv((cluster!=0),"cluster");
+
+    if (impl->cluster != 0){
+        icalfileset_commit(cluster);
+        icalcomponent_free(impl->cluster);
+        impl->cluster=0;
+    }
+
+    if(impl->fd > 0){
+        icalfileset_unlock(impl);
+        close(impl->fd);
+        impl->fd = -1;
+    }
+
+    if(impl->path != 0){
+        free(impl->path);
+        impl->path = 0;
+    }
+
+    free(impl);
+}
+
+const char* icalfileset_path(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    return impl->path;
+}
+
+
+int icalfileset_lock(icalfileset *cluster)
+{
+#ifndef _WIN32
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    struct flock lock;
+    int rtrn;
+
+    icalerror_check_arg_rz((impl->fd>0),"impl->fd");
+    errno = 0;
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    rtrn = fcntl(impl->fd, F_SETLKW, &lock);
+
+    return rtrn;
+#else
+    return -1;
+#endif
+}
+
+int icalfileset_unlock(icalfileset *cluster)
+{
+#ifndef _WIN32
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    struct flock lock;
+    icalerror_check_arg_rz((impl->fd>0),"impl->fd");
+
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    return (fcntl(impl->fd, F_UNLCK, &lock)); 
+#else
+  return -1;
+#endif
+}
+
+#ifdef ICAL_SAFESAVES
+int icalfileset_safe_saves=1;
+#else
+int icalfileset_safe_saves=0;
+#endif
+
+icalerrorenum icalfileset_commit(icalfileset* cluster)
+{
+    char tmp[ICAL_PATH_MAX]; 
+    char *str;
+    icalcomponent *c;
+    off_t write_size=0;
+    
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    
+    icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);  
+    
+    icalerror_check_arg_re((impl->fd>0),"impl->fd is invalid",
+                           ICAL_INTERNAL_ERROR) ;
+
+    if (impl->changed == 0 ){
+        return ICAL_NO_ERROR;
+    }
+    
+    if(icalfileset_safe_saves == 1){
+        snprintf(tmp,ICAL_PATH_MAX,"cp %s %s.bak",impl->path,impl->path);
+        
+        if(system(tmp) < 0){
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return ICAL_FILE_ERROR;
+        }
+    }
+
+    if(lseek(impl->fd,SEEK_SET,0) < 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+    }
+    
+    for(c = icalcomponent_get_first_component(impl->cluster,ICAL_ANY_COMPONENT);
+        c != 0;
+        c = icalcomponent_get_next_component(impl->cluster,ICAL_ANY_COMPONENT)){
+        int sz;
+
+        str = icalcomponent_as_ical_string(c);
+    
+        sz=write(impl->fd,str,strlen(str));
+
+        if ( sz != strlen(str)){
+            perror("write");
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return ICAL_FILE_ERROR;
+        }
+
+        write_size += sz;
+    }
+    
+    impl->changed = 0;    
+
+#ifndef _QTWIN_
+    if(ftruncate(impl->fd,write_size) < 0){
+        return ICAL_FILE_ERROR;
+    }
+#endif
+    
+    return ICAL_NO_ERROR;
+    
+} 
+
+void icalfileset_mark(icalfileset* cluster){
+
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rv((impl!=0),"cluster");
+
+    impl->changed = 1;
+
+}
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster){
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);
+
+    return impl->cluster;
+}
+
+
+/* manipulate the components in the cluster */
+
+icalerrorenum icalfileset_add_component(icalfileset *cluster,
+                                        icalcomponent* child)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((cluster!=0),"cluster", ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
+
+    icalcomponent_add_component(impl->cluster,child);
+
+    icalfileset_mark(cluster);
+
+    return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalfileset_remove_component(icalfileset *cluster,
+                                           icalcomponent* child)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((cluster!=0),"cluster",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
+
+    icalcomponent_remove_component(impl->cluster,child);
+
+    icalfileset_mark(cluster);
+
+    return ICAL_NO_ERROR;
+}
+
+int icalfileset_count_components(icalfileset *cluster,
+                                 icalcomponent_kind kind)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    if(cluster == 0){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return -1;
+    }
+
+    return icalcomponent_count_components(impl->cluster,kind);
+}
+
+icalerrorenum icalfileset_select(icalfileset* set, icalgauge* gauge)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)set;
+
+    icalerror_check_arg_re(gauge!=0,"guage",ICAL_BADARG_ERROR);
+
+    impl->gauge = gauge;
+
+    return ICAL_NO_ERROR;
+}
+
+void icalfileset_clear(icalfileset* gauge)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)gauge;
+    
+    impl->gauge = 0;
+
+}
+
+icalcomponent* icalfileset_fetch(icalfileset* store,const char* uid)
+{
+    icalcompiter i;    
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)store;
+    
+    for(i = icalcomponent_begin_component(impl->cluster,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *this = icalcompiter_deref(&i);
+        icalcomponent *inner = icalcomponent_get_first_real_component(this);
+        icalcomponent *p;
+        const char *this_uid;
+
+        if(inner != 0){
+            p = icalcomponent_get_first_property(inner,ICAL_UID_PROPERTY);
+            this_uid = icalproperty_get_uid(p);
+
+            if(this_uid==0){
+                icalerror_warn("icalfileset_fetch found a component with no UID");
+                continue;
+            }
+
+            if (strcmp(uid,this_uid)==0){
+                return this;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int icalfileset_has_uid(icalfileset* store,const char* uid)
+{
+    assert(0); /* HACK, not implemented */
+    return 0;
+}
+
+/******* support routines for icalfileset_fetch_match *********/
+
+struct icalfileset_id{
+    char* uid;
+    char* recurrence_id;
+    int sequence;
+};
+
+void icalfileset_id_free(struct icalfileset_id *id)
+{
+    if(id->recurrence_id != 0){
+        free(id->recurrence_id);
+    }
+
+    if(id->uid != 0){
+        free(id->uid);
+    }
+
+}
+
+struct icalfileset_id icalfileset_get_id(icalcomponent* comp)
+{
+
+    icalcomponent *inner;
+    struct icalfileset_id id;
+    icalproperty *p;
+
+    inner = icalcomponent_get_first_real_component(comp);
+    
+    p = icalcomponent_get_first_property(inner, ICAL_UID_PROPERTY);
+
+    assert(p!= 0);
+
+    id.uid = strdup(icalproperty_get_uid(p));
+
+    p = icalcomponent_get_first_property(inner, ICAL_SEQUENCE_PROPERTY);
+
+    if(p == 0) {
+        id.sequence = 0;
+    } else { 
+        id.sequence = icalproperty_get_sequence(p);
+    }
+
+    p = icalcomponent_get_first_property(inner, ICAL_RECURRENCEID_PROPERTY);
+
+    if (p == 0){
+        id.recurrence_id = 0;
+    } else {
+        icalvalue *v;
+        v = icalproperty_get_value(p);
+        id.recurrence_id = strdup(icalvalue_as_ical_string(v));
+
+        assert(id.recurrence_id != 0);
+    }
+
+    return id;
+}
+
+/* Find the component that is related to the given
+   component. Currently, it just matches based on UID and
+   RECURRENCE-ID */
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *comp)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)set;
+    icalcompiter i;    
+
+    struct icalfileset_id comp_id, match_id;
+    
+    comp_id = icalfileset_get_id(comp);
+
+    for(i = icalcomponent_begin_component(impl->cluster,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *match = icalcompiter_deref(&i);
+
+        match_id = icalfileset_get_id(match);
+
+        if(strcmp(comp_id.uid, match_id.uid) == 0 &&
+           ( comp_id.recurrence_id ==0 || 
+             strcmp(comp_id.recurrence_id, match_id.recurrence_id) ==0 )){
+
+            /* HACK. What to do with SEQUENCE? */
+
+            icalfileset_id_free(&match_id);
+            icalfileset_id_free(&comp_id);
+            return match;
+            
+        }
+        
+        icalfileset_id_free(&match_id);
+    }
+
+    icalfileset_id_free(&comp_id);
+    return 0;
+
+}
+
+
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *old,
+                                 icalcomponent *new)
+{
+    assert(0); /* HACK, not implemented */
+    return ICAL_NO_ERROR;
+}
+
+
+/* Iterate through components */
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    return icalcomponent_get_current_component(impl->cluster);
+}
+
+
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+    icalcomponent *c=0;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    do {
+        if (c == 0){
+            c = icalcomponent_get_first_component(impl->cluster,
+                                                  ICAL_ANY_COMPONENT);
+        } else {
+            c = icalcomponent_get_next_component(impl->cluster,
+                                                 ICAL_ANY_COMPONENT);
+        }
+
+        if(c != 0 && (impl->gauge == 0 ||
+                      icalgauge_compare(impl->gauge,c) == 1)){
+            return c;
+        }
+
+    } while(c != 0);
+
+
+    return 0;
+}
+
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+    icalcomponent *c;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+    
+    do {
+        c = icalcomponent_get_next_component(impl->cluster,
+                                             ICAL_ANY_COMPONENT);
+
+        if(c != 0 && (impl->gauge == 0 ||
+                      icalgauge_compare(impl->gauge,c) == 1)){
+            return c;
+        }
+        
+    } while(c != 0);
+    
+    
+    return 0;
+}
+
diff --git a/libical/src/libicalss/icalfileset.h b/libical/src/libicalss/icalfileset.h
new file mode 100644
index 0000000..51254d2
--- a/dev/null
+++ b/libical/src/libicalss/icalfileset.h
@@ -0,0 +1,107 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalfileset.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALFILESET_H
+#define ICALFILESET_H
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalset.h"
+#include "icalgauge.h"
+
+extern int icalfileset_safe_saves;
+
+typedef void icalfileset;
+
+
+/* icalfileset
+   icalfilesetfile
+   icalfilesetdir
+*/
+
+
+icalfileset* icalfileset_new(const char* path);
+
+#ifdef _WIN32
+#define mode_t int
+#endif
+
+/* Like _new, but takes open() flags for opening the file */
+icalfileset* icalfileset_new_open(const char* path, 
+                                  int flags, mode_t mode);
+
+void icalfileset_free(icalfileset* cluster);
+
+const char* icalfileset_path(icalfileset* cluster);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately. */
+void icalfileset_mark(icalfileset* cluster);
+icalerrorenum icalfileset_commit(icalfileset* cluster); 
+
+icalerrorenum icalfileset_add_component(icalfileset* cluster,
+                                        icalcomponent* child);
+
+icalerrorenum icalfileset_remove_component(icalfileset* cluster,
+                                           icalcomponent* child);
+
+int icalfileset_count_components(icalfileset* cluster,
+                                 icalcomponent_kind kind);
+
+/* Restrict the component returned by icalfileset_first, _next to those
+   that pass the gauge. _clear removes the gauge */
+icalerrorenum icalfileset_select(icalfileset* store, icalgauge* gauge);
+void icalfileset_clear(icalfileset* store);
+
+/* Get and search for a component by uid */
+icalcomponent* icalfileset_fetch(icalfileset* cluster, const char* uid);
+int icalfileset_has_uid(icalfileset* cluster, const char* uid);
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *c);
+
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *oldcomp,
+                               icalcomponent *newcomp);
+
+/* Iterate through components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster);
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster);
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster);
+/* Return a reference to the internal component. You probably should
+   not be using this. */
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster);
+
+
+#endif /* !ICALFILESET_H */
+
+
+
diff --git a/libical/src/libicalss/icalfilesetimpl.h b/libical/src/libicalss/icalfilesetimpl.h
new file mode 100644
index 0000000..fcd3415
--- a/dev/null
+++ b/libical/src/libicalss/icalfilesetimpl.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalfilesetimpl.h
+  CREATOR: eric 23 December 1999
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalgauge.h"
+
+/* This definition is in its own file so it can be kept out of the
+   main header file, but used by "friend classes" like icaldirset*/
+
+#define ICALFILESET_ID "fset"
+
+struct icalfileset_impl {
+
+  char id[5]; /*fset*/
+  char *path;
+  icalcomponent* cluster;
+  icalgauge* gauge;
+  int changed;
+  int fd; /* file descriptor */
+};
+
diff --git a/libical/src/libicalss/icalgauge.c b/libical/src/libicalss/icalgauge.c
new file mode 100644
index 0000000..b958ecf
--- a/dev/null
+++ b/libical/src/libicalss/icalgauge.c
@@ -0,0 +1,447 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.c
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#include "ical.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+#include <stdlib.h>
+
+extern char* input_buffer;
+extern char* input_buffer_p;
+int ssparse(void);
+
+struct icalgauge_impl *icalss_yy_gauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql)
+{
+    struct icalgauge_impl *impl;
+
+    int r;
+    
+    if ( ( impl = (struct icalgauge_impl*)
+           malloc(sizeof(struct icalgauge_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    impl->select = pvl_newlist();
+    impl->from = pvl_newlist();
+    impl->where = pvl_newlist();
+
+    icalss_yy_gauge = impl;
+
+    input_buffer_p = input_buffer = sql;
+    r = ssparse();
+
+    return impl;
+}
+
+
+void icalgauge_free(icalgauge* gauge)
+{
+      struct icalgauge_impl *impl =  (struct icalgauge_impl*)gauge;
+      struct icalgauge_where *w;
+
+      assert(impl->select != 0);
+      assert(impl->where != 0);
+      assert(impl->from != 0);
+
+      if(impl->select){
+          while( (w=pvl_pop(impl->select)) != 0){
+              if(w->value != 0){
+                  free(w->value);
+              }
+              free(w);
+          }
+          pvl_free(impl->select);
+      }
+
+      if(impl->where){
+          while( (w=pvl_pop(impl->where)) != 0){
+              
+              if(w->value != 0){
+                  free(w->value);
+              }
+              free(w);
+          }
+          pvl_free(impl->where);
+      }
+
+      if(impl->from){
+          pvl_free(impl->from);
+      }
+      
+}
+
+/* Convert a VQUERY component into a gauge */
+icalcomponent* icalgauge_make_gauge(icalcomponent* query);
+
+/* icaldirset_test compares a component against a gauge, and returns
+   true if the component passes the test 
+
+   The gauge is a VCALENDAR component that specifies how to test the
+   target components. The guage holds a collection of VEVENT, VTODO or
+   VJOURNAL sub-components. Each of the sub-components has a
+   collection of properties that are compared to corresponding
+   properties in the target component, according to the
+   X-LIC-COMPARETYPE parameters to the gauge's properties.
+
+   When a gauge has several sub-components, the results of testing the
+   target against each of them is ORed together - the target
+   component will pass if it matches any of the sub-components in the
+   gauge. However, the results of matching the properties in a
+   sub-component are ANDed -- the target must match every property in
+   a gauge sub-component to match the sub-component.
+
+   Here is an example:
+
+   BEGIN:XROOT
+   DTSTART;X-LIC-COMPARETYPE=LESS:19981025T020000
+   ORGANIZER;X-LIC-COMPARETYPE=EQUAL:mrbig@host.com 
+   END:XROOT
+   BEGIN:XROOT
+   LOCATION;X-LIC-COMPARETYPE=EQUAL:McNary's Pub
+   END:XROOT
+
+   This gauge has two sub-components; one which will match a VEVENT
+   based on start time, and organizer, and another that matches based
+   on LOCATION. A target component will pass the test if it matched
+   either of the sub-components.
+   
+  */
+
+
+int icalgauge_compare_recurse(icalcomponent* comp, icalcomponent* gauge)
+{
+    int pass = 1,localpass = 0;
+    icalproperty *p;
+    icalcomponent *child,*subgauge; 
+    icalcomponent_kind gaugekind, compkind;
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+
+    gaugekind = icalcomponent_isa(gauge);
+    compkind = icalcomponent_isa(comp);
+
+    if( ! (gaugekind == compkind || gaugekind == ICAL_ANY_COMPONENT) ){
+        return 0;
+    }   
+
+    /* Test properties. For each property in the gauge, search through
+       the component for a similar property. If one is found, compare
+       the two properties value with the comparison specified in the
+       gauge with the X-LIC-COMPARETYPE parameter */
+    
+    for(p = icalcomponent_get_first_property(gauge,ICAL_ANY_PROPERTY);
+        p != 0;
+        p = icalcomponent_get_next_property(gauge,ICAL_ANY_PROPERTY)){
+        
+        icalproperty* targetprop; 
+        icalparameter* compareparam;
+        icalparameter_xliccomparetype compare;
+        int rel; /* The relationship between the gauge and target values.*/
+        
+        /* Extract the comparison type from the gauge. If there is no
+           comparison type, assume that it is "EQUAL" */
+        
+        compareparam = icalproperty_get_first_parameter(
+            p,
+            ICAL_XLICCOMPARETYPE_PARAMETER);
+        
+        if (compareparam!=0){
+            compare = icalparameter_get_xliccomparetype(compareparam);
+        } else {
+            compare = ICAL_XLICCOMPARETYPE_EQUAL;
+        }
+        
+        /* Find a property in the component that has the same type
+           as the gauge property. HACK -- multiples of a single
+           property type in the gauge will match only the first
+           instance in the component */
+        
+        targetprop = icalcomponent_get_first_property(comp,
+                                                      icalproperty_isa(p));
+        
+        if(targetprop != 0){
+        
+            /* Compare the values of the gauge property and the target
+               property */
+            
+            rel = icalvalue_compare(icalproperty_get_value(p),
+                                    icalproperty_get_value(targetprop));
+            
+            /* Now see if the comparison is equavalent to the comparison
+               specified in the gauge */
+            
+            if (rel == compare){ 
+                localpass++; 
+            } else if (compare == ICAL_XLICCOMPARETYPE_LESSEQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_LESS ||
+                         rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+                localpass++;
+            } else if (compare == ICAL_XLICCOMPARETYPE_GREATEREQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+                         rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+                localpass++;
+            } else if (compare == ICAL_XLICCOMPARETYPE_NOTEQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+                         rel == ICAL_XLICCOMPARETYPE_LESS)) {
+                localpass++;
+            } else {
+                localpass = 0;
+            }
+            
+            pass = pass && (localpass>0);
+        }
+    }
+    
+    /* Test subcomponents. Look for a child component that has a
+       counterpart in the gauge. If one is found, recursively call
+       icaldirset_test */
+    
+    for(subgauge = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT);
+        subgauge != 0;
+        subgauge = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){
+        
+        gaugekind = icalcomponent_isa(subgauge);
+
+        if (gaugekind == ICAL_ANY_COMPONENT){
+            child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+        } else {
+            child = icalcomponent_get_first_component(comp,gaugekind);
+        }
+        
+        if(child !=0){
+            localpass = icalgauge_compare_recurse(child,subgauge);
+            pass = pass && localpass;
+        } else {
+            pass = 0;
+        }
+    }
+    
+    return pass;   
+}
+
+
+int icalgauge_compare(icalgauge* gauge,icalcomponent* comp)
+{
+
+    struct icalgauge_impl *impl = (struct icalgauge_impl*)gauge;
+    icalcomponent *inner; 
+    int local_pass = 0;
+    int last_clause = 1, this_clause = 1;
+    pvl_elem e;
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+    
+    inner = icalcomponent_get_first_real_component(comp);
+
+    if(inner == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+
+    /* Check that this component is one of the FROM types */
+    local_pass = 0;
+    for(e = pvl_head(impl->from);e!=0;e=pvl_next(e)){
+        icalcomponent_kind k = (icalcomponent_kind)pvl_data(e);
+
+        if(k == icalcomponent_isa(inner)){
+            local_pass=1;
+        }
+    }
+    
+    if(local_pass == 0){
+        return 0;
+    }
+
+    
+    /* Check each where clause against the component */
+    for(e = pvl_head(impl->where);e!=0;e=pvl_next(e)){
+        struct icalgauge_where *w = pvl_data(e);
+        icalcomponent *sub_comp;
+        icalvalue *v;
+        icalproperty *prop;
+        icalvalue_kind vk;
+
+        if(w->prop == ICAL_NO_PROPERTY || w->value == 0){
+            icalerror_set_errno(ICAL_INTERNAL_ERROR);
+            return 0;
+        }
+
+        /* First, create a value from the gauge */
+        vk = icalenum_property_kind_to_value_kind(w->prop);
+
+        if(vk == ICAL_NO_VALUE){
+            icalerror_set_errno(ICAL_INTERNAL_ERROR);
+            return 0;
+        }
+
+        v = icalvalue_new_from_string(vk,w->value);
+
+        if (v == 0){
+            /* Keep error set by icalvalue_from-string*/
+            return 0;
+        }
+            
+        /* Now find the corresponding property in the component,
+           descending into a sub-component if necessary */
+
+        if(w->comp == ICAL_NO_COMPONENT){
+            sub_comp = inner;
+        } else {
+            sub_comp = icalcomponent_get_first_component(inner,w->comp);
+            if(sub_comp == 0){
+                return 0;
+            }
+                }   
+
+        this_clause = 0;
+        local_pass = 0;
+        for(prop = icalcomponent_get_first_property(sub_comp,w->prop);
+            prop != 0;
+            prop = icalcomponent_get_next_property(sub_comp,w->prop)){
+            icalvalue* prop_value;
+            icalgaugecompare relation;
+
+            prop_value = icalproperty_get_value(prop);
+
+            relation = (icalgaugecompare)icalvalue_compare(prop_value,v);
+            
+            if (relation  == w->compare){ 
+                local_pass++; 
+            } else if (w->compare == ICALGAUGECOMPARE_LESSEQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_LESS ||
+                         relation  == ICALGAUGECOMPARE_EQUAL)) {
+                local_pass++;
+            } else if (w->compare == ICALGAUGECOMPARE_GREATEREQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_GREATER ||
+                         relation  == ICALGAUGECOMPARE_EQUAL)) {
+                local_pass++;
+            } else if (w->compare == ICALGAUGECOMPARE_NOTEQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_GREATER ||
+                         relation  == ICALGAUGECOMPARE_LESS)) {
+                local_pass++;
+            } else {
+                local_pass = 0;
+            }
+        }
+    
+        this_clause = local_pass > 0 ? 1 : 0;
+
+        /* Now look at the logic operator for this clause to see how
+           the value should be merge with the previous clause */
+
+        if(w->logic == ICALGAUGELOGIC_AND){
+            last_clause = this_clause && last_clause;
+        } else if(w->logic == ICALGAUGELOGIC_AND) {
+            last_clause = this_clause || last_clause;
+        } else {
+            last_clause = this_clause;
+        }
+    }
+
+    return last_clause;
+
+}
+    
+
+void icalgauge_dump(icalcomponent* gauge)
+{
+
+    pvl_elem *p;
+    struct icalgauge_impl *impl = (struct icalgauge_impl*)gauge;
+  
+  
+    printf("--- Select ---\n");
+    for(p = pvl_head(impl->select);p!=0;p=pvl_next(p)){
+        struct icalgauge_where *w = pvl_data(p);
+
+        if(w->comp != ICAL_NO_COMPONENT){
+            printf("%s ",icalenum_component_kind_to_string(w->comp));
+        }
+
+        if(w->prop != ICAL_NO_PROPERTY){
+            printf("%s ",icalenum_property_kind_to_string(w->prop));
+        }
+        
+        if (w->compare != ICALGAUGECOMPARE_NONE){
+            printf("%d ",w->compare);
+        }
+
+
+        if (w->value!=0){
+            printf("%s",w->value);
+        }
+
+
+        printf("\n");
+    }
+
+    printf("--- From ---\n");
+    for(p = pvl_head(impl->from);p!=0;p=pvl_next(p)){
+        icalcomponent_kind k = (icalcomponent_kind)pvl_data(p);
+
+        printf("%s\n",icalenum_component_kind_to_string(k));
+    }
+
+    printf("--- Where ---\n");
+    for(p = pvl_head(impl->where);p!=0;p=pvl_next(p)){
+        struct icalgauge_where *w = pvl_data(p);
+
+        if(w->logic != ICALGAUGELOGIC_NONE){
+            printf("%d ",w->logic);
+        }
+        
+        if(w->comp != ICAL_NO_COMPONENT){
+            printf("%s ",icalenum_component_kind_to_string(w->comp));
+        }
+
+        if(w->prop != ICAL_NO_PROPERTY){
+            printf("%s ",icalenum_property_kind_to_string(w->prop));
+        }
+        
+        if (w->compare != ICALGAUGECOMPARE_NONE){
+            printf("%d ",w->compare);
+        }
+
+
+        if (w->value!=0){
+            printf("%s",w->value);
+        }
+
+
+        printf("\n");
+    }
+
+    
+}
+
diff --git a/libical/src/libicalss/icalgauge.h b/libical/src/libicalss/icalgauge.h
new file mode 100644
index 0000000..1caf0ac
--- a/dev/null
+++ b/libical/src/libicalss/icalgauge.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALGAUGE_H
+#define ICALGAUGE_H
+
+typedef void icalgauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql);
+
+void icalgauge_free(icalgauge* gauge);
+
+char* icalgauge_as_sql(icalcomponent* gauge);
+
+void icalgauge_dump(icalcomponent* gauge);
+
+/* Return true is comp matches the gauge. The component must be in
+   cannonical form -- a VCALENDAR with one VEVENT, VTODO or VJOURNAL
+   sub component */
+int icalgauge_compare(icalgauge* g, icalcomponent* comp);
+
+/* Clone the component, but only return the properties specified in
+   the gauge */
+icalcomponent* icalgauge_new_clone(icalgauge* g, icalcomponent* comp);
+
+#endif /* ICALGAUGE_H*/
diff --git a/libical/src/libicalss/icalgaugeimpl.h b/libical/src/libicalss/icalgaugeimpl.h
new file mode 100644
index 0000000..73a2813
--- a/dev/null
+++ b/libical/src/libicalss/icalgaugeimpl.h
@@ -0,0 +1,63 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgaugeimpl.h
+ CREATOR: eric 09 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+======================================================================*/
+
+#include "ical.h"
+
+#include "pvl.h" 
+
+typedef enum icalgaugecompare {
+    ICALGAUGECOMPARE_EQUAL=ICAL_XLICCOMPARETYPE_EQUAL,
+    ICALGAUGECOMPARE_LESS=ICAL_XLICCOMPARETYPE_LESS,
+    ICALGAUGECOMPARE_LESSEQUAL=ICAL_XLICCOMPARETYPE_LESSEQUAL,
+    ICALGAUGECOMPARE_GREATER=ICAL_XLICCOMPARETYPE_GREATER,
+    ICALGAUGECOMPARE_GREATEREQUAL=ICAL_XLICCOMPARETYPE_GREATEREQUAL,
+    ICALGAUGECOMPARE_NOTEQUAL=ICAL_XLICCOMPARETYPE_NOTEQUAL,
+    ICALGAUGECOMPARE_REGEX=ICAL_XLICCOMPARETYPE_REGEX,
+    ICALGAUGECOMPARE_NONE=0
+} icalgaugecompare;
+
+typedef enum icalgaugelogic {
+    ICALGAUGELOGIC_NONE,
+    ICALGAUGELOGIC_AND,
+    ICALGAUGELOGIC_OR
+} icalgaugelogic;
+    
+
+struct icalgauge_where {
+        icalgaugelogic logic;
+        icalcomponent_kind comp;
+        icalproperty_kind prop;
+        icalgaugecompare compare;
+        char* value;
+};
+
+struct icalgauge_impl
+{
+
+        pvl_list select; /*Of icalgaugecompare, using only prop and comp fields*/
+        pvl_list from; /* List of component_kinds, as integers */
+        pvl_list where; /* List of icalgaugecompare */
+};
+
+
diff --git a/libical/src/libicalss/icalmessage.c b/libical/src/libicalss/icalmessage.c
new file mode 100644
index 0000000..d5c57c1
--- a/dev/null
+++ b/libical/src/libicalss/icalmessage.c
@@ -0,0 +1,373 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalmessage.c
+    CREATOR: ebusboom 07 Nov 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalmessage.h"
+#include "icalenums.h"
+#include <ctype.h>  /* for tolower()*/
+#include <string.h> /* for strstr */
+#include <stdlib.h> /* for free(), malloc() */
+icalcomponent* icalmessage_get_inner(icalcomponent* comp)
+{
+    if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
+        return icalcomponent_get_first_real_component(comp);
+    } else {
+        return comp;
+    }
+}
+
+char* lowercase(const char* str)
+{
+    char* p = 0;
+    char* n = icalmemory_strdup(str);
+
+    if(str ==0){
+        return 0;
+    }
+
+    for(p = n; *p!=0; p++){
+        *p = tolower(*p);
+    }
+
+    return n;
+}
+
+icalproperty* icalmessage_find_attendee(icalcomponent* comp, const char* user)
+{
+    icalcomponent *inner = icalmessage_get_inner(comp);
+    icalproperty *p,*attendee = 0;
+    char* luser = lowercase(user);
+
+    for(p = icalcomponent_get_first_property(inner, ICAL_ATTENDEE_PROPERTY);
+        p != 0;
+        p = icalcomponent_get_next_property(inner, ICAL_ATTENDEE_PROPERTY)
+        ){
+
+        char* lattendee;
+
+        lattendee = lowercase(icalproperty_get_attendee(p));
+
+        if (strstr(lattendee,user) != 0){
+            attendee = p;
+            break;
+        }
+
+        free(lattendee);
+
+    }
+    
+    free(luser);
+
+    return attendee;
+
+}
+
+void icalmessage_copy_properties(icalcomponent* to, icalcomponent* from, 
+                icalproperty_kind kind)
+{
+    icalcomponent *to_inner = icalmessage_get_inner(to);
+    icalcomponent *from_inner = icalmessage_get_inner(from);
+
+    if (to_inner == 0 && from_inner == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return;
+    }
+
+    if(!icalcomponent_get_first_property(from_inner,kind)){
+        return;
+    }
+
+    icalcomponent_add_property(to_inner,
+               icalproperty_new_clone(
+                   icalcomponent_get_first_property(
+                       from_inner,
+                       kind)
+                   )
+        );
+}
+
+icalcomponent *icalmessage_new_reply_base(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+    icalproperty *attendee;
+    char tmp[45];
+
+    icalcomponent *reply = icalcomponent_vanew(
+        ICAL_VCALENDAR_COMPONENT,
+        icalproperty_new_method(ICAL_METHOD_REPLY),
+        icalcomponent_vanew(
+            ICAL_VEVENT_COMPONENT,
+            icalproperty_new_dtstamp(icaltime_from_timet(time(0),0)),
+            0),
+        0);
+
+    icalcomponent *inner = icalmessage_get_inner(reply);
+
+    icalerror_check_arg_rz(c,"c");
+
+    icalmessage_copy_properties(reply,c,ICAL_UID_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_ORGANIZER_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_RECURRENCEID_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_SUMMARY_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_SEQUENCE_PROPERTY);
+
+    icalcomponent_set_dtstamp(reply,icaltime_from_timet(time(0),0));
+
+    if(msg != 0){
+        icalcomponent_add_property(inner,icalproperty_new_comment(msg));
+    }
+
+    /* Copy this user's attendee property */
+
+    attendee = icalmessage_find_attendee(c,user);
+
+    if (attendee == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        icalcomponent_free(reply);
+        return 0;
+    }
+
+    icalcomponent_add_property(inner,icalproperty_new_clone(attendee));
+
+    /* Add PRODID and VERSION */
+
+    icalcomponent_add_property(reply,icalproperty_new_version("2.0"));
+    
+    sprintf(tmp,
+           "-//SoftwareStudio//NONSGML %s %s //EN",PACKAGE,VERSION);
+    icalcomponent_add_property(reply,icalproperty_new_prodid(tmp));
+
+    return reply;
+
+}
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+
+    if(reply == 0){
+        return 0;
+    }
+
+    inner  = icalmessage_get_inner(reply);
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_ACCEPTED));
+
+    return reply;
+}
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    if(reply == 0){
+        return 0;
+    }
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DECLINED));
+
+    return reply;
+}
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg)
+{
+    icalcomponent *reply;
+
+    icalerror_check_arg_rz(oldc,"oldc");
+    icalerror_check_arg_rz(newc,"newc");
+    
+    reply = icalcomponent_new_clone(newc);
+
+    icalcomponent_set_method(reply,ICAL_METHOD_COUNTER);
+
+    return newc;
+
+}
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+
+    reply =  icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    if(reply == 0){
+        return 0;
+    }
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED));
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_delegatedto(delegatee));
+
+    return reply;
+
+}
+
+icalcomponent* icalmessage_new_delegate_request(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+
+    reply =  icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+
+    if(reply == 0){
+        return 0;
+    }
+
+    icalcomponent_set_method(reply,ICAL_METHOD_REQUEST);
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED));
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_delegatedto(delegatee));
+
+    icalcomponent_add_property(
+        inner,
+        icalproperty_vanew_attendee(
+            delegatee,
+            icalparameter_new_delegatedfrom(
+                icalproperty_get_attendee(attendee)
+                ),
+            0
+            )
+        );
+             
+
+    return reply;
+
+}
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus code)
+{
+    icalcomponent *reply;
+    icalcomponent *inner, *cinner;
+    struct icalreqstattype rs;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    cinner = icalmessage_get_inner(c);
+    if(reply == 0){
+        return 0;
+    }
+
+    if( code != ICAL_UNKNOWN_STATUS){
+        rs.code = code;
+        rs.debug = debug;
+        
+        icalcomponent_add_property(inner, 
+                                   icalproperty_new_requeststatus(rs));
+    } else { /*  code == ICAL_UNKNOWN_STATUS */ 
+
+        /* Copy all of the request status properties */
+        icalproperty *p;
+        for(p = icalcomponent_get_first_property(cinner,
+                                                 ICAL_REQUESTSTATUS_PROPERTY);
+            p != 0;
+            p = icalcomponent_get_next_property(cinner,
+                                                ICAL_REQUESTSTATUS_PROPERTY)){
+
+            
+            icalcomponent_add_property(inner,icalproperty_new_clone(p));
+        }
+    }
+
+    return reply;
+}
diff --git a/libical/src/libicalss/icalmessage.h b/libical/src/libicalss/icalmessage.h
new file mode 100644
index 0000000..24f1c9f
--- a/dev/null
+++ b/libical/src/libicalss/icalmessage.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmessage.h
+ CREATOR: eric 07 Nov 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#include "ical.h"
+
+#ifndef ICALMESSAGE_H
+#define ICALMESSAGE_H
+
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c, 
+                                            const char* user,
+                                            const char* msg);
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg);
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg);
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus rs);
+
+
+#endif /* ICALMESSAGE_H*/
diff --git a/libical/src/libicalss/icalset.c b/libical/src/libicalss/icalset.c
new file mode 100644
index 0000000..2120609
--- a/dev/null
+++ b/libical/src/libicalss/icalset.c
@@ -0,0 +1,367 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.c
+ CREATOR: eric 17 Jul 2000
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegates) include:
+ 
+    icalfileset   Store components in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#include "ical.h"
+#include "icalset.h"
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+#include "icaldirset.h"
+#include "icaldirsetimpl.h"
+#include <stdlib.h>
+/*#include "icalheapset.h"*/
+/*#include "icalmysqlset.h"*/
+
+#define ICALSET_ID "set "
+
+struct icalset_fp {
+        void (*free)(icalset* set);
+        const char* (*path)(icalset* set);
+        void (*mark)(icalset* set);
+        icalerrorenum (*commit)(icalset* set); 
+        icalerrorenum (*add_component)(icalset* set, icalcomponent* comp);
+        icalerrorenum (*remove_component)(icalset* set, icalcomponent* comp);
+        int (*count_components)(icalset* set,
+                             icalcomponent_kind kind);
+        icalerrorenum (*select)(icalset* set, icalcomponent* gauge);
+        void (*clear)(icalset* set);
+        icalcomponent* (*fetch)(icalset* set, const char* uid);
+        icalcomponent* (*fetch_match)(icalset* set, icalcomponent *comp);
+        int (*has_uid)(icalset* set, const char* uid);
+        icalerrorenum (*modify)(icalset* set, icalcomponent *old,
+                                     icalcomponent *new);
+                icalcomponent* (*get_current_component)(icalset* set);
+        icalcomponent* (*get_first_component)(icalset* set);
+        icalcomponent* (*get_next_component)(icalset* set);
+};
+
+struct icalset_fp icalset_dirset_fp = {
+    icaldirset_free,
+    icaldirset_path,
+    icaldirset_mark,
+    icaldirset_commit,
+    icaldirset_add_component,
+    icaldirset_remove_component,
+    icaldirset_count_components,
+    icaldirset_select,
+    icaldirset_clear,
+    icaldirset_fetch,
+    icaldirset_fetch_match,
+    icaldirset_has_uid,
+    icaldirset_modify,
+    icaldirset_get_current_component,
+    icaldirset_get_first_component,
+    icaldirset_get_next_component
+};
+
+
+struct icalset_fp icalset_fileset_fp = {
+    icalfileset_free,
+    icalfileset_path,
+    icalfileset_mark,
+    icalfileset_commit,
+    icalfileset_add_component,
+    icalfileset_remove_component,
+    icalfileset_count_components,
+    icalfileset_select,
+    icalfileset_clear,
+    icalfileset_fetch,
+    icalfileset_fetch_match,
+    icalfileset_has_uid,
+    icalfileset_modify,
+    icalfileset_get_current_component,
+    icalfileset_get_first_component,
+    icalfileset_get_next_component
+};
+
+struct icalset_impl {
+
+        char id[5]; /* "set " */
+
+        void *derived_impl;
+        struct icalset_fp *fp;
+};
+
+/* Figure out what was actually passed in as the set. This could be a
+   set or and of the derived types such as dirset or fileset. Note
+   this routine returns a value, not a reference, to avoid memory
+   leaks in the methods */
+struct icalset_impl icalset_get_impl(icalset* set)
+{
+    struct icalset_impl  impl;
+
+    memset(&impl,0,sizeof(impl));
+    icalerror_check_arg_re( (set!=0),"set",impl);
+
+    if(strcmp((char*)set,ICALSET_ID)==0) {
+        /* It is actually a set, so just sent the reference back out. */
+        return *(struct icalset_impl*)set;
+    } else if(strcmp((char*)set,ICALFILESET_ID)==0) {
+        /* Make a new set from the fileset */
+        impl.fp = &icalset_fileset_fp;
+        impl.derived_impl = set;
+        strcpy(impl.id,ICALFILESET_ID);/* HACK. Is this necessary? */
+        return impl;
+    } else if(strcmp((char*)set,ICALDIRSET_ID)==0) {
+        /* Make a new set from the dirset */
+        impl.fp = &icalset_dirset_fp;
+        impl.derived_impl = set;
+        strcpy(impl.id,ICALDIRSET_ID);/* HACK. Is this necessary? */
+        return impl;
+    } else {
+        /* The type of set is unknown, so throw an error */
+        icalerror_assert((0),"Unknown set type");
+        return impl;
+    }
+}
+
+
+struct icalset_impl* icalset_new_impl()
+{
+    
+    struct icalset_impl* impl;
+
+    if ( ( impl = (struct icalset_impl*)
+           malloc(sizeof(struct icalset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    strcpy(impl->id,ICALSET_ID);
+
+    impl->derived_impl = 0;
+    impl->fp = 0;
+
+    return impl;
+}
+
+struct icalset_impl* icalset_new_file_from_ref(icalfileset *fset)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+    icalerror_check_arg_rz( (fset!=0),"fset");
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->derived_impl = fset;
+
+    if (impl->derived_impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->fp = &icalset_fileset_fp;
+
+    return (struct icalset_impl*)impl;
+}
+
+icalset* icalset_new_file(const char* path)
+{
+    icalfileset *fset = icalfileset_new(path);
+
+    if(fset == 0){
+        return 0;
+    }
+
+    return (icalset*)icalset_new_file_from_ref(fset);
+}
+
+icalset* icalset_new_dir_from_ref(icaldirset *dset)
+{
+
+    struct icalset_impl *impl = icalset_new_impl();
+
+    icalerror_check_arg_rz( (dset!=0),"dset");
+
+    if(impl == 0){
+        return 0;
+    }
+
+    impl->derived_impl = dset;
+
+    if (impl->derived_impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->fp = &icalset_dirset_fp;
+
+    return impl;
+}
+
+icalset* icalset_new_dir(const char* path)
+{
+    icaldirset *dset = icaldirset_new(path);
+
+    if(dset == 0){
+        return 0;
+    }
+
+    return icalset_new_dir_from_ref(dset);
+}
+
+icalset* icalset_new_heap(void)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    return 0;
+}
+
+icalset* icalset_new_mysql(const char* path)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    return 0;
+}
+
+void icalset_free(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->free))(impl.derived_impl);
+
+   if(strcmp((char*)set,ICALSET_ID)) {    
+       free(set);
+   }
+}
+
+const char* icalset_path(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->path))(impl.derived_impl);
+}
+
+void icalset_mark(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->mark))(impl.derived_impl);
+}
+
+icalerrorenum icalset_commit(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->commit))(impl.derived_impl);
+}
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->add_component))(impl.derived_impl,comp);
+}
+
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->remove_component))(impl.derived_impl,comp);
+}
+
+int icalset_count_components(icalset* set,icalcomponent_kind kind)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->count_components))(impl.derived_impl,kind);
+}
+
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->select))(impl.derived_impl,gauge);
+}
+
+void icalset_clear(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->clear))(impl.derived_impl);
+}
+
+icalcomponent* icalset_fetch(icalset* set, const char* uid)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->fetch))(impl.derived_impl,uid);
+}
+
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->fetch_match))(impl.derived_impl,comp);
+}
+
+
+int icalset_has_uid(icalset* set, const char* uid)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->has_uid))(impl.derived_impl,uid);
+}
+
+icalerrorenum icalset_modify(icalset* set, icalcomponent *old,
+                               icalcomponent *new)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->modify))(impl.derived_impl,old,new);
+}
+
+icalcomponent* icalset_get_current_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_current_component))(impl.derived_impl);
+}
+
+icalcomponent* icalset_get_first_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_first_component))(impl.derived_impl);
+}
+
+icalcomponent* icalset_get_next_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_next_component))(impl.derived_impl);
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalset.h b/libical/src/libicalss/icalset.h
new file mode 100644
index 0000000..7b083da
--- a/dev/null
+++ b/libical/src/libicalss/icalset.h
@@ -0,0 +1,111 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.h
+ CREATOR: eric 28 November 1999
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegatees) include:
+ 
+    icalfileset   Store componetns in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALSET_H
+#define ICALSET_H
+
+#include <limits.h> /* For PATH_MAX */
+#include "ical.h"
+#include "icalerror.h"
+
+#ifdef PATH_MAX
+#define ICAL_PATH_MAX PATH_MAX
+#else
+#define ICAL_PATH_MAX 1024
+#endif
+
+
+
+
+typedef void icalset;
+
+typedef enum icalset_kind {
+    ICAL_FILE_SET,
+    ICAL_DIR_SET,
+    ICAL_HEAP_SET,
+    ICAL_MYSQL_SET,
+    ICAL_CAP_SET
+} icalset_kind;
+
+
+/* Create a specific derived type of set */
+icalset* icalset_new_file(const char* path);
+icalset* icalset_new_dir(const char* path);
+icalset* icalset_new_heap(void);
+icalset* icalset_new_mysql(const char* path);
+/*icalset* icalset_new_cap(icalcstp* cstp);*/
+
+void icalset_free(icalset* set);
+
+const char* icalset_path(icalset* set);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icalset_mark(icalset* set);
+icalerrorenum icalset_commit(icalset* set); 
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp);
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp);
+
+int icalset_count_components(icalset* set,
+                             icalcomponent_kind kind);
+
+/* Restrict the component returned by icalset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge);
+void icalset_clear_select(icalset* set);
+
+/* Get a component by uid */
+icalcomponent* icalset_fetch(icalset* set, const char* uid);
+int icalset_has_uid(icalset* set, const char* uid);
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalset_modify(icalset* set, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalset_get_current_component(icalset* set);
+icalcomponent* icalset_get_first_component(icalset* set);
+icalcomponent* icalset_get_next_component(icalset* set);
+
+#endif /* !ICALSET_H */
+
+
+
diff --git a/libical/src/libicalss/icalspanlist.c b/libical/src/libicalss/icalspanlist.c
new file mode 100644
index 0000000..cab6a81
--- a/dev/null
+++ b/libical/src/libicalss/icalspanlist.c
@@ -0,0 +1,309 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalspanlist.c
+    CREATOR: ebusboom 23 aug 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalspanlist.h"
+#include "pvl.h" 
+#include <stdlib.h> /* for free and malloc */
+
+struct icalspanlist_impl {
+        pvl_list spans;
+};
+
+int compare_span(void* a, void* b)
+{
+    struct icaltime_span *span_a = (struct icaltime_span *)a ;
+    struct icaltime_span *span_b = (struct icaltime_span *)b ;
+    
+    if(span_a->start == span_b->start){
+        return 0;
+    } else if(span_a->start < span_b->start){
+        return -1;
+    }  else { /*if(span_a->start > span->b.start)*/
+        return 1;
+    }
+}
+
+icalcomponent* icalspanlist_get_inner(icalcomponent* comp)
+{
+    if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
+        return icalcomponent_get_first_real_component(comp);
+    } else {
+        return comp;
+    }
+}
+
+
+void print_span(int c, struct icaltime_span span );
+
+    
+/* Make a free list from a set of component */
+icalspanlist* icalspanlist_new(icalset *set, 
+                               struct icaltimetype start,
+                               struct icaltimetype end)
+{
+    struct icaltime_span range;
+    pvl_elem itr;
+    icalcomponent *c,*inner;
+    icalcomponent_kind kind, inner_kind;
+    struct icalspanlist_impl *sl; 
+    struct icaltime_span *freetime;
+
+    if ( ( sl = (struct icalspanlist_impl*)
+           malloc(sizeof(struct icalspanlist_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    sl->spans =  pvl_newlist();
+
+    range.start = icaltime_as_timet(start);
+    range.end = icaltime_as_timet(end);
+
+    printf("Range start: %s",ctime(&range.start));
+    printf("Range end  : %s",ctime(&range.end));
+
+
+    /* Get a list of spans of busy time from the events in the set
+       and order the spans based on the start time */
+
+   for(c = icalset_get_first_component(set);
+        c != 0;
+        c = icalset_get_next_component(set)){
+
+       struct icaltime_span span;
+
+       kind  = icalcomponent_isa(c);
+       inner = icalcomponent_get_inner(c);
+
+       if(!inner){
+           continue;
+       }
+
+       inner_kind = icalcomponent_isa(inner);
+
+       if( kind != ICAL_VEVENT_COMPONENT &&
+           inner_kind != ICAL_VEVENT_COMPONENT){
+           continue;
+       }
+       
+       icalerror_clear_errno();
+
+        span = icalcomponent_get_span(c);
+        span.is_busy = 1;
+
+        if(icalerrno != ICAL_NO_ERROR){
+            continue;
+        }
+
+        if ((range.start < span.end && icaltime_is_null_time(end)) ||
+            (range.start < span.end && range.end > span.start )){
+            
+            struct icaltime_span *s;
+
+            if ((s=(struct icaltime_span *)
+                 malloc(sizeof(struct icaltime_span))) == 0){
+                icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+                return 0;
+            }
+
+            memcpy(s,&span,sizeof(span));
+                
+            pvl_insert_ordered(sl->spans,compare_span,(void*)s);
+
+        }
+    }
+    
+    /* Now Fill in the free time spans. loop through the spans. if the
+       start of the range is not within the span, create a free entry
+       that runs from the start of the range to the start of the
+       span. */
+
+     for( itr = pvl_head(sl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        struct icaltime_span *s = (icalproperty*)pvl_data(itr);
+
+        if ((freetime=(struct icaltime_span *)
+             malloc(sizeof(struct icaltime_span))) == 0){
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return 0;
+            }
+
+        if(range.start < s->start){
+            freetime->start = range.start; 
+            freetime->end = s->start;
+            
+            freetime->is_busy = 0;
+
+
+            pvl_insert_ordered(sl->spans,compare_span,(void*)freetime);
+        } else {
+            free(freetime);
+        }
+        
+        range.start = s->end;
+    }
+     
+     /* If the end of the range is null, then assume that everything
+        after the last item in the calendar is open and add a span
+        that indicates this */
+
+     if( icaltime_is_null_time(end)){
+         struct icaltime_span* last_span;
+
+         last_span = pvl_data(pvl_tail(sl->spans));
+
+         if (last_span != 0){
+
+             if ((freetime=(struct icaltime_span *)
+                  malloc(sizeof(struct icaltime_span))) == 0){
+                 icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+                 return 0;
+                     }
+        
+             freetime->is_busy = 0;
+             freetime->start = last_span->end;
+             freetime->end = freetime->start;
+             pvl_insert_ordered(sl->spans,compare_span,(void*)freetime);
+         }
+     }
+
+
+     return sl;
+
+}
+
+void icalspanlist_free(icalspanlist* s)
+{
+    struct icaltime_span *span;
+    struct icalspanlist_impl* impl = (struct icalspanlist_impl*)s;
+    
+    while( (span=pvl_pop(impl->spans)) != 0){
+        free(span);
+    }
+    
+    pvl_free(impl->spans);
+    
+    impl->spans = 0;
+}
+
+
+void icalspanlist_dump(icalspanlist* s){
+
+     int i = 0;
+     struct icalspanlist_impl* sl = (struct icalspanlist_impl*)s;
+     pvl_elem itr;
+
+     for( itr = pvl_head(sl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        struct icaltime_span *s = (icalproperty*)pvl_data(itr);
+        
+        printf("#%02d %d start: %s",++i,s->is_busy,ctime(&s->start));
+        printf("      end  : %s",ctime(&s->end));
+
+    }
+}
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t)
+{
+     struct icalspanlist_impl* impl = (struct icalspanlist_impl*)sl;
+     pvl_elem itr;
+     struct icalperiodtype period;
+     struct icaltime_span *s;
+
+     time_t rangett= icaltime_as_timet(t);
+
+     period.start = icaltime_null_time();
+     period.end = icaltime_null_time();
+
+     /* Is the reference time before the first span? If so, assume
+        that the reference time is free */
+     itr = pvl_head(impl->spans);
+     s = (icalproperty*)pvl_data(itr);
+
+     if (s == 0){
+         /* No elements in span */
+         return period;
+     }
+
+     if(rangett <s->start ){
+         /* End of period is start of first span if span is busy, end
+            of the span if it is free */
+         period.start =  t;
+
+         if (s->is_busy == 0){
+             period.end =  icaltime_from_timet(s->start,0);
+         } else {
+             period.end =  icaltime_from_timet(s->end,0);
+         }
+
+         return period;
+     }
+
+     /* Otherwise, find the first free span that contains the
+        reference time. */
+
+     for( itr = pvl_head(impl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        s = (icalproperty*)pvl_data(itr);
+
+        if(s->is_busy == 0 && s->start >= rangett && 
+            ( rangett < s->end || s->end == s->start)){
+
+            if (rangett < s->start){
+                period.start = icaltime_from_timet(s->start,0);
+            } else {
+                period.start = icaltime_from_timet(rangett,0);
+            }
+            
+            period.end = icaltime_from_timet(s->end,0);
+
+            return period;
+        }
+                        
+    }
+
+     period.start = icaltime_null_time();
+     period.end = icaltime_null_time();
+
+     return period;
+}
+
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
diff --git a/libical/src/libicalss/icalspanlist.h b/libical/src/libicalss/icalspanlist.h
new file mode 100644
index 0000000..83cb1c8
--- a/dev/null
+++ b/libical/src/libicalss/icalspanlist.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalspanlist.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+#ifndef ICALSPANLIST_H
+#define ICALSPANLIST_H
+
+#include "ical.h"
+#include "icalset.h"
+
+typedef void icalspanlist;
+
+/* Make a free list from a set of component. Start and end should be in UTC */
+icalspanlist* icalspanlist_new(icalset *set, 
+                                struct icaltimetype start,
+                                struct icaltimetype end);
+
+void icalspanlist_free(icalspanlist* spl);
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+/* Get first free or busy time after time t. all times are in UTC */
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
+void icalspanlist_dump(icalspanlist* s);
+
+#endif
+                                    
+
+
diff --git a/libical/src/libicalss/icalss.h b/libical/src/libicalss/icalss.h
new file mode 100644
index 0000000..cd07919
--- a/dev/null
+++ b/libical/src/libicalss/icalss.h
@@ -0,0 +1,885 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALGAUGE_H
+#define ICALGAUGE_H
+
+typedef void icalgauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql);
+
+void icalgauge_free(icalgauge* gauge);
+
+char* icalgauge_as_sql(icalcomponent* gauge);
+
+void icalgauge_dump(icalcomponent* gauge);
+
+/* Return true is comp matches the gauge. The component must be in
+   cannonical form -- a VCALENDAR with one VEVENT, VTODO or VJOURNAL
+   sub component */
+int icalgauge_compare(icalgauge* g, icalcomponent* comp);
+
+/* Clone the component, but only return the properties specified in
+   the gauge */
+icalcomponent* icalgauge_new_clone(icalgauge* g, icalcomponent* comp);
+
+#endif /* ICALGAUGE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.h
+ CREATOR: eric 28 November 1999
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegatees) include:
+ 
+    icalfileset   Store componetns in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALSET_H
+#define ICALSET_H
+
+#include <limits.h> /* For PATH_MAX */
+
+#ifdef PATH_MAX
+#define ICAL_PATH_MAX PATH_MAX
+#else
+#define ICAL_PATH_MAX 1024
+#endif
+
+
+#ifdef _WIN32
+#define mode_t int
+#endif
+
+
+
+typedef void icalset;
+
+typedef enum icalset_kind {
+    ICAL_FILE_SET,
+    ICAL_DIR_SET,
+    ICAL_HEAP_SET,
+    ICAL_MYSQL_SET,
+    ICAL_CAP_SET
+} icalset_kind;
+
+
+/* Create a specific derived type of set */
+icalset* icalset_new_file(const char* path);
+icalset* icalset_new_dir(const char* path);
+icalset* icalset_new_heap(void);
+icalset* icalset_new_mysql(const char* path);
+/*icalset* icalset_new_cap(icalcstp* cstp);*/
+
+void icalset_free(icalset* set);
+
+const char* icalset_path(icalset* set);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icalset_mark(icalset* set);
+icalerrorenum icalset_commit(icalset* set); 
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp);
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp);
+
+int icalset_count_components(icalset* set,
+                             icalcomponent_kind kind);
+
+/* Restrict the component returned by icalset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge);
+void icalset_clear_select(icalset* set);
+
+/* Get a component by uid */
+icalcomponent* icalset_fetch(icalset* set, const char* uid);
+int icalset_has_uid(icalset* set, const char* uid);
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalset_modify(icalset* set, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalset_get_current_component(icalset* set);
+icalcomponent* icalset_get_first_component(icalset* set);
+icalcomponent* icalset_get_next_component(icalset* set);
+
+#endif /* !ICALSET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalfileset.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALFILESET_H
+#define ICALFILESET_H
+
+#include <sys/types.h> /* For open() flags and mode */
+#include <sys/stat.h> /* For open() flags and mode */
+#include <fcntl.h> /* For open() flags and mode */
+
+extern int icalfileset_safe_saves;
+
+typedef void icalfileset;
+
+
+/* icalfileset
+   icalfilesetfile
+   icalfilesetdir
+*/
+
+
+icalfileset* icalfileset_new(const char* path);
+
+/* Like _new, but takes open() flags for opening the file */
+icalfileset* icalfileset_new_open(const char* path, 
+                                  int flags, mode_t mode);
+
+void icalfileset_free(icalfileset* cluster);
+
+const char* icalfileset_path(icalfileset* cluster);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately. */
+void icalfileset_mark(icalfileset* cluster);
+icalerrorenum icalfileset_commit(icalfileset* cluster); 
+
+icalerrorenum icalfileset_add_component(icalfileset* cluster,
+                                        icalcomponent* child);
+
+icalerrorenum icalfileset_remove_component(icalfileset* cluster,
+                                           icalcomponent* child);
+
+int icalfileset_count_components(icalfileset* cluster,
+                                 icalcomponent_kind kind);
+
+/* Restrict the component returned by icalfileset_first, _next to those
+   that pass the gauge. _clear removes the gauge */
+icalerrorenum icalfileset_select(icalfileset* store, icalgauge* gauge);
+void icalfileset_clear(icalfileset* store);
+
+/* Get and search for a component by uid */
+icalcomponent* icalfileset_fetch(icalfileset* cluster, const char* uid);
+int icalfileset_has_uid(icalfileset* cluster, const char* uid);
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *c);
+
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *oldcomp,
+                               icalcomponent *newcomp);
+
+/* Iterate through components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster);
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster);
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster);
+/* Return a reference to the internal component. You probably should
+   not be using this. */
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster);
+
+
+#endif /* !ICALFILESET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaldirset.h
+ CREATOR: eric 28 November 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDIRSET_H
+#define ICALDIRSET_H
+
+
+/* icaldirset Routines for storing, fetching, and searching for ical
+ * objects in a database */
+
+typedef void icaldirset;
+
+
+icaldirset* icaldirset_new(const char* path);
+
+void icaldirset_free(icaldirset* store);
+
+const char* icaldirset_path(icaldirset* store);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icaldirset_mark(icaldirset* store);
+icalerrorenum icaldirset_commit(icaldirset* store); 
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icalcomponent* comp);
+icalerrorenum icaldirset_remove_component(icaldirset* store, icalcomponent* comp);
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind);
+
+/* Restrict the component returned by icaldirset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge);
+void icaldirset_clear(icaldirset* store);
+
+/* Get a component by uid */
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid);
+int icaldirset_has_uid(icaldirset* store, const char* uid);
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store);
+icalcomponent* icaldirset_get_first_component(icaldirset* store);
+icalcomponent* icaldirset_get_next_component(icaldirset* store);
+
+#endif /* !ICALDIRSET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcalendar.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCALENDAR_H
+#define ICALCALENDAR_H
+
+
+/* icalcalendar
+ * Routines for storing calendar data in a file system. The calendar 
+ * has two icaldirsets, one for incoming components and one for booked
+ * components. It also has interfaces to access the free/busy list
+ * and a list of calendar properties */
+
+typedef  void icalcalendar;
+
+icalcalendar* icalcalendar_new(char* dir);
+
+void icalcalendar_free(icalcalendar* calendar);
+
+int icalcalendar_lock(icalcalendar* calendar);
+
+int icalcalendar_unlock(icalcalendar* calendar);
+
+int icalcalendar_islocked(icalcalendar* calendar);
+
+int icalcalendar_ownlock(icalcalendar* calendar);
+
+icalset* icalcalendar_get_booked(icalcalendar* calendar);
+
+icalset* icalcalendar_get_incoming(icalcalendar* calendar);
+
+icalset* icalcalendar_get_properties(icalcalendar* calendar);
+
+icalset* icalcalendar_get_freebusy(icalcalendar* calendar);
+
+
+#endif /* !ICALCALENDAR_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalclassify.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#ifndef ICALCLASSIFY_H
+#define ICALCLASSIFY_H
+
+
+
+typedef enum icalclass {
+    ICAL_NO_CLASS,
+    ICAL_PUBLISH_NEW_CLASS,
+    ICAL_PUBLISH_UPDATE_CLASS,
+    ICAL_PUBLISH_FREEBUSY_CLASS,
+    ICAL_REQUEST_NEW_CLASS,
+    ICAL_REQUEST_UPDATE_CLASS,
+    ICAL_REQUEST_RESCHEDULE_CLASS,
+    ICAL_REQUEST_DELEGATE_CLASS,
+    ICAL_REQUEST_NEW_ORGANIZER_CLASS,
+    ICAL_REQUEST_FORWARD_CLASS,
+    ICAL_REQUEST_STATUS_CLASS,
+    ICAL_REQUEST_FREEBUSY_CLASS,
+    ICAL_REPLY_ACCEPT_CLASS,
+    ICAL_REPLY_DECLINE_CLASS,
+    ICAL_REPLY_DELEGATE_CLASS,
+    ICAL_REPLY_CRASHER_ACCEPT_CLASS,
+    ICAL_REPLY_CRASHER_DECLINE_CLASS,
+    ICAL_ADD_INSTANCE_CLASS,
+    ICAL_CANCEL_EVENT_CLASS,
+    ICAL_CANCEL_INSTANCE_CLASS,
+    ICAL_CANCEL_ALL_CLASS,
+    ICAL_REFRESH_CLASS,
+    ICAL_COUNTER_CLASS,
+    ICAL_DECLINECOUNTER_CLASS,
+    ICAL_MALFORMED_CLASS, 
+    ICAL_OBSOLETE_CLASS, /* 21 */
+    ICAL_MISSEQUENCED_CLASS, /* 22 */
+    ICAL_UNKNOWN_CLASS /* 23 */
+} ical_class;
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user);
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp);
+
+char* icalclassify_class_to_string(ical_class iclass);
+
+
+#endif /* ICALCLASSIFY_H*/
+
+
+                                    
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalspanlist.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+#ifndef ICALSPANLIST_H
+#define ICALSPANLIST_H
+
+
+typedef void icalspanlist;
+
+/* Make a free list from a set of component. Start and end should be in UTC */
+icalspanlist* icalspanlist_new(icalset *set, 
+                                struct icaltimetype start,
+                                struct icaltimetype end);
+
+void icalspanlist_free(icalspanlist* spl);
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+/* Get first free or busy time after time t. all times are in UTC */
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
+void icalspanlist_dump(icalspanlist* s);
+
+#endif
+                                    
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmessage.h
+ CREATOR: eric 07 Nov 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+
+#ifndef ICALMESSAGE_H
+#define ICALMESSAGE_H
+
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c, 
+                                            const char* user,
+                                            const char* msg);
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg);
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg);
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus rs);
+
+
+#endif /* ICALMESSAGE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstp.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTP_H
+#define ICALCSTP_H
+
+
+
+/* Connection state, from the state machine in RFC2445 */
+enum cstps_state {
+    NO_STATE,
+    CONNECTED,
+    AUTHENTICATED,
+    IDENTIFIED,
+    DISCONNECTED,
+    RECEIVE
+};
+
+/* CSTP Commands that a client can issue to a server */
+typedef enum icalcstp_command {
+    ICAL_ABORT_COMMAND,
+    ICAL_AUTHENTICATE_COMMAND,
+    ICAL_CAPABILITY_COMMAND,
+    ICAL_CONTINUE_COMMAND,
+    ICAL_CALIDEXPAND_COMMAND,
+    ICAL_IDENTIFY_COMMAND,
+    ICAL_DISCONNECT_COMMAND,
+    ICAL_SENDDATA_COMMAND,
+    ICAL_STARTTLS_COMMAND,
+    ICAL_UPNEXPAND_COMMAND,
+    ICAL_COMPLETE_COMMAND,
+    ICAL_UNKNOWN_COMMAND
+} icalcstp_command;
+
+
+
+/* A statement is a combination of command or response code and a
+   component that the server and client exchage with each other. */
+struct icalcstp_statement {
+    icalcstp_command command;
+    char* str_data; /* If non-NUll use as arguments to command */
+    int int_data; /* If non-NULL use as arguments to command */
+
+    icalrequeststatus code;
+
+    icalcomponent* data;
+};
+
+const char* icalcstp_command_to_string(icalcstp_command command);
+icalcstp_command icalcstp_string_to_command(const char* str);
+
+#endif /* !ICALCSTP_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpclient.h
+  CREATOR: eric 4 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPC_H
+#define ICALCSTPC_H
+
+
+/********************** Client (Sender) Interfaces **************************/
+
+/* How to use: 
+
+   1) Construct a new icalcstpc
+   2) Issue a command by calling one of the command routines. 
+   3) Repeat until both call icalcstpc_next_output and
+   icalcstpc_next_input return 0:
+     3a) Call icalcstpc_next_output. Send string to server. 
+     3b) Get string from server, & give to icalcstp_next_input()
+   4) Iterate with icalcstpc_first_response & icalcstp_next_response to 
+   get the servers responses
+   5) Repeat at #2
+*/
+
+
+typedef void icalcstpc;
+
+/* Response code sent by the server. */
+        typedef struct icalcstpc_response {
+    icalrequeststatus code;
+    char *arg; /* These strings are owned by libical */
+    char *debug_text;
+    char *more_text;
+    void* result;
+} icalcstpc_response;
+
+
+icalcstpc* icalcstpc_new();
+
+void icalcstpc_free(icalcstpc* cstpc);
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
+
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char* line);
+
+/* process the next string from the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char * line);
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
+
+/* Issue a command */
+icalerrorenum icalcstpc_abort(icalcstpc* cstp);
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* init_data, char* f(char*) );
+icalerrorenum icalcstpc_capability(icalcstpc* cstp);
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time);
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp);
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id);
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* init_data, char* f(char*));
+icalerrorenum icalcstpc_senddata(icalcstpc* cstp, unsigned int time,
+                                icalcomponent *comp);
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp);
+
+
+#endif /* !ICALCSTPC_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpserver.h
+  CREATOR: eric 13 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPS_H
+#define ICALCSTPS_H
+
+
+
+/********************** Server (Reciever) Interfaces *************************/
+
+/* On the server side, the caller will recieve data from the incoming
+   socket and pass it to icalcstps_next_input. The caller then takes
+   the return from icalcstps_next_outpu and sends it out through the
+   socket. This gives the caller a point of control. If the cstp code
+   connected to the socket itself, it would be hard for the caller to
+   do anything else after the cstp code was started.
+
+   All of the server and client command routines will generate
+   response codes. On the server side, these responses will be turned
+   into text and sent to the client. On the client side, the reponse
+   is the one sent from the server.
+
+   Since each command can return multiple responses, the responses are
+   stored in the icalcstps object and are accesses by
+   icalcstps_first_response() and icalcstps_next_response()
+
+   How to use: 
+
+   1) Construct a new icalcstps, bound to your code via stubs
+   2) Repeat forever:
+     2a) Get string from client & give to icalcstps_next_input()
+     2b) Repeat until icalcstp_next_output returns 0:
+       2b1) Call icalcstps_next_output. 
+       2b2) Send string to client.
+*/
+
+
+
+typedef void icalcstps;
+
+/* Pointers to the rountines that
+   icalcstps_process_incoming will call when it recognizes a CSTP
+   command in the data. BTW, the CONTINUE command is named 'cont'
+   because 'continue' is a C keyword */
+
+struct icalcstps_commandfp {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};                                                        
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp stubs);
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec);
+
+/* Get the next string to send to the client */
+char* icalcstps_next_output(icalcstps* cstp);
+
+/* process the next string from the client */ 
+int icalcstps_next_input(icalcstps* cstp);
+
+#endif /* ICALCSTPS */
diff --git a/libical/src/libicalss/icalsslexer.c b/libical/src/libicalss/icalsslexer.c
new file mode 100644
index 0000000..e10bcd3
--- a/dev/null
+++ b/libical/src/libicalss/icalsslexer.c
@@ -0,0 +1,1713 @@
+#define yy_create_buffer ss_create_buffer
+#define yy_delete_buffer ss_delete_buffer
+#define yy_scan_buffer ss_scan_buffer
+#define yy_scan_string ss_scan_string
+#define yy_scan_bytes ss_scan_bytes
+#define yy_flex_debug ss_flex_debug
+#define yy_init_buffer ss_init_buffer
+#define yy_flush_buffer ss_flush_buffer
+#define yy_load_buffer_state ss_load_buffer_state
+#define yy_switch_to_buffer ss_switch_to_buffer
+#define yyin ssin
+#define yyleng ssleng
+#define yylex sslex
+#define yyout ssout
+#define yyrestart ssrestart
+#define yytext sstext
+#define yywrap sswrap
+
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+        #else/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+        #endif/* __STDC__ */
+        #endif/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+         * if ( condition_holds )
+         *      yyless( 5 );
+         *else
+         *      do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                *yy_cp = yy_hold_char; \
+                YY_RESTORE_YY_MORE_OFFSET \
+                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+                } \
+        while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+        {
+        FILE *yy_input_file;
+
+                char *yy_ch_buf;        /* input buffer */
+                char *yy_buf_pos;       /* current position in input buffer */
+
+        /* Size of input buffer in bytes, not including room for EOB
+         * characters.
+         */
+        yy_size_t yy_buf_size;
+
+        /* Number of characters read into yy_ch_buf, not including EOB
+         * characters.
+         */
+        int yy_n_chars;
+
+        /* Whether we "own" the buffer - i.e., we know we created it,
+         * and can realloc() it to grow it, and should free() it to
+         * delete it.
+         */
+        int yy_is_our_buffer;
+
+        /* Whether this is an "interactive" input source; if so, and
+         * if we're using stdio for input, then we want to use getc()
+         * instead of fread(), to make sure we stop fetching input after
+         * each newline.
+         */
+        int yy_is_interactive;
+
+        /* Whether we're considered to be at the beginning of a line.
+         * If so, '^' rules will be active on the next match, otherwise
+         * not.
+         */
+        int yy_at_bol;
+
+        /* Whether to try to fill the input buffer when we reach the
+         * end of it.
+         */
+        int yy_fill_buffer;
+
+        int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+        /* When an EOF's been seen but there's still some text to process
+         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+         * shouldn't try reading from the input source any more.  We might
+         * still have a bunch of tokens to match, though, because of
+         * possible backing-up.
+         *
+         * When we actually see the EOF, we change the status to "new"
+         * (via yyrestart()), so that the user can continue scanning by
+         * just pointing yyin at a new input file.
+         */
+#define YY_BUFFER_EOF_PENDING 2
+        };
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+        static int yy_n_chars;  /* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+        static int yy_init = 1;         /* whether we need to initialize */
+        static int yy_start = 0;/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_is_interactive = is_interactive; \
+        }
+
+#define yy_set_bol(at_bol) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_at_bol = at_bol; \
+        }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char yytext[];
+
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+        yytext_ptr = yy_bp; \
+        yyleng = (int) (yy_cp - yy_bp); \
+        yy_hold_char = *yy_cp; \
+        *yy_cp = '\0'; \
+        if ( yyleng >= YYLMAX ) \
+                YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
+        yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \
+        yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 19
+#define YY_END_OF_BUFFER 20
+static yyconst short int yy_accept[47] =
+    {   0,
+        0,    0,    0,    0,    0,    0,   20,   18,   14,   14,
+       18,   13,   17,    4,   15,    7,    5,    8,   17,   17,
+       17,   17,   17,   14,    6,    0,   17,    9,   10,   17,
+       17,   12,   17,   17,   16,   11,   17,   17,   17,    2,
+       17,   17,   17,    3,    1,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    1,    1,    1,    1,    1,    5,    1,
+        1,    6,    1,    7,    6,    6,    1,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    1,    8,    9,
+       10,   11,    1,    1,   12,    6,   13,   14,   15,   16,
+        6,   17,    6,    6,    6,   18,   19,   20,   21,    6,
+        6,   22,   23,   24,    6,    6,   25,    6,    6,    6,
+        1,    1,    1,    1,    1,    1,   12,    6,   13,   14,
+
+       15,   16,    6,   17,    6,    6,    6,   18,   19,   20,
+       21,    6,    6,   22,   23,   24,    6,    6,   25,    6,
+        6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst int yy_meta[26] =
+    {   0,
+        1,    1,    1,    1,    1,    2,    1,    1,    1,    1,
+        1,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2
+    } ;
+
+static yyconst short int yy_base[49] =
+    {   0,
+        0,    0,    0,    0,    0,    0,   53,   54,   24,   26,
+       42,    0,    0,   54,   54,   41,   54,   40,   29,   26,
+       25,   31,   28,   28,   54,   39,    0,   54,   54,   29,
+       21,    0,   23,   25,   54,    0,   20,   23,   15,    0,
+       23,   20,   10,    0,    0,   54,   31,   30
+    } ;
+
+static yyconst short int yy_def[49] =
+    {   0,
+       46,    1,    1,    1,    1,    1,   46,   46,   46,   46,
+       46,   47,   48,   46,   46,   46,   46,   46,   48,   48,
+       48,   48,   48,   46,   46,   47,   48,   46,   46,   48,
+       48,   48,   48,   48,   46,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,    0,   46,   46
+    } ;
+
+static yyconst short int yy_nxt[80] =
+    {   0,
+        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
+       18,   19,   13,   13,   13,   20,   13,   13,   13,   13,
+       21,   13,   22,   13,   23,   24,   24,   24,   24,   24,
+       24,   27,   26,   45,   44,   43,   42,   41,   40,   39,
+       38,   37,   36,   35,   34,   33,   32,   31,   30,   29,
+       28,   25,   46,    7,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46
+    } ;
+
+static yyconst short int yy_chk[80] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    9,    9,   10,   10,   24,
+       24,   48,   47,   43,   42,   41,   39,   38,   37,   34,
+       33,   31,   30,   26,   23,   22,   21,   20,   19,   18,
+       16,   11,    7,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#ifndef YYLMAX
+#define YYLMAX 8192
+#endif
+
+char yytext[YYLMAX];
+char *yytext_ptr;
+#line 1 "icalsslexer.l"
+#define INITIAL 0
+#line 2 "icalsslexer.l"
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalsslexer.l
+  CREATOR: eric 8 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include "icalssyacc.h"
+#include "icalgaugeimpl.h"
+#include "assert.h"
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input();
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+
+#undef SS_FATAL_ERROR
+#define SS_FATAL_ERROR(msg) sserror(msg)
+
+
+#define sql 1
+#define string_value 2
+
+#line 465 "icalsslexer.c"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+        if ( yy_current_buffer->yy_is_interactive ) \
+                { \
+                int c = '*', n; \
+                for ( n = 0; n < max_size && \
+                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                        buf[n] = (char) c; \
+                if ( c == '\n' ) \
+                        buf[n++] = (char) c; \
+                if ( c == EOF && ferror( yyin ) ) \
+                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                result = n; \
+                } \
+        else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+                  && ferror( yyin ) ) \
+                YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+        YY_USER_ACTION
+
+YY_DECL
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp = NULL, *yy_bp = NULL;
+        register int yy_act;
+
+#line 69 "icalsslexer.l"
+
+
+
+
+
+
+#line 623 "icalsslexer.c"
+
+        if ( yy_init )
+                {
+                yy_init = 0;
+
+#ifdef YY_USER_INIT
+                YY_USER_INIT;
+#endif
+
+                if ( ! yy_start )
+                                yy_start = 1;/* first start state */
+
+                if ( ! yyin )
+                        yyin = stdin;
+
+                if ( ! yyout )
+                        yyout = stdout;
+
+                if ( ! yy_current_buffer )
+                        yy_current_buffer =
+                                yy_create_buffer( yyin, YY_BUF_SIZE );
+
+                yy_load_buffer_state();
+                }
+
+                while ( 1 )     /* loops until end-of-file is reached */
+                {
+                yy_cp = yy_c_buf_p;
+
+                /* Support of yytext. */
+                *yy_cp = yy_hold_char;
+
+                /* yy_bp points to the position in yy_ch_buf of the start of
+                 * the current run.
+                 */
+                yy_bp = yy_cp;
+
+                yy_current_state = yy_start;
+yy_match:
+                do
+                        {
+                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                        if ( yy_accept[yy_current_state] )
+                                {
+                                yy_last_accepting_state = yy_current_state;
+                                yy_last_accepting_cpos = yy_cp;
+                                }
+                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                                {
+                                yy_current_state = (int) yy_def[yy_current_state];
+                                if ( yy_current_state >= 47 )
+                                        yy_c = yy_meta[(unsigned int) yy_c];
+                                }
+                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                        ++yy_cp;
+                        }
+                while ( yy_base[yy_current_state] != 54 );
+
+yy_find_action:
+                yy_act = yy_accept[yy_current_state];
+                if ( yy_act == 0 )
+                        { /* have to back up */
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        yy_act = yy_accept[yy_current_state];
+                        }
+
+                YY_DO_BEFORE_ACTION;
+
+
+        do_action:/* This label is used only to access EOF actions. */
+
+
+                switch ( yy_act )
+        { /* beginning of action switch */
+                        case 0: /* must back up */
+                        /* undo the effects of YY_DO_BEFORE_ACTION */
+                        *yy_cp = yy_hold_char;
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 75 "icalsslexer.l"
+{ return SELECT; }
+        YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 76 "icalsslexer.l"
+{ return FROM; }
+        YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 77 "icalsslexer.l"
+{ return WHERE; }
+        YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 78 "icalsslexer.l"
+{ return COMMA; }
+        YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 79 "icalsslexer.l"
+{ return EQUALS; }
+        YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 80 "icalsslexer.l"
+{ return NOTEQUALS; }
+        YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 81 "icalsslexer.l"
+{ return LESS; }
+        YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 82 "icalsslexer.l"
+{ return GREATER; }
+        YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 83 "icalsslexer.l"
+{ return LESSEQUALS; }
+        YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 84 "icalsslexer.l"
+{ return GREATEREQUALS; }
+        YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 85 "icalsslexer.l"
+{ return AND; }
+        YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 86 "icalsslexer.l"
+{ return OR; }
+        YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 87 "icalsslexer.l"
+{ return QUOTE; }
+        YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 88 "icalsslexer.l"
+        ;               
+        YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 89 "icalsslexer.l"
+{ return EOL; }
+        YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 90 "icalsslexer.l"
+{
+        int c = input();
+        unput(c);
+        if(c!='\''){
+                sslval.v_string= icalmemory_tmp_copy(sstext);
+                return STRING;
+        } else {
+                /*ssmore();*/
+        }
+}
+        YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 101 "icalsslexer.l"
+{ sslval.v_string= icalmemory_tmp_copy(sstext);
+                          return STRING; }
+        YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 105 "icalsslexer.l"
+{ return yytext[0]; }
+        YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 107 "icalsslexer.l"
+ECHO;
+        YY_BREAK
+#line 811 "icalsslexer.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(sql):
+case YY_STATE_EOF(string_value):
+        yyterminate();
+
+        case YY_END_OF_BUFFER:
+                {
+                /* Amount of text matched not including the EOB char. */
+                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+                /* Undo the effects of YY_DO_BEFORE_ACTION. */
+                *yy_cp = yy_hold_char;
+                YY_RESTORE_YY_MORE_OFFSET
+
+                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+                        {
+                        /* We're scanning a new file or input source.  It's
+                         * possible that this happened because the user
+                         * just pointed yyin at a new source and called
+                         * yylex().  If so, then we have to assure
+                         * consistency between yy_current_buffer and our
+                         * globals.  Here is the right place to do so, because
+                         * this is the first action (other than possibly a
+                         * back-up) that will match for the new input source.
+                         */
+                        yy_n_chars = yy_current_buffer->yy_n_chars;
+                        yy_current_buffer->yy_input_file = yyin;
+                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                        }
+
+                /* Note that here we test for yy_c_buf_p "<=" to the position
+                 * of the first EOB in the buffer, since yy_c_buf_p will
+                 * already have been incremented past the NUL character
+                 * (since all states make transitions on EOB to the
+                 * end-of-buffer state).  Contrast this with the test
+                 * in input().
+                 */
+                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        { /* This was really a NUL. */
+                        yy_state_type yy_next_state;
+
+                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+                        yy_current_state = yy_get_previous_state();
+
+                        /* Okay, we're now positioned to make the NUL
+                         * transition.  We couldn't have
+                         * yy_get_previous_state() go ahead and do it
+                         * for us because it doesn't know how to deal
+                         * with the possibility of jamming (and we don't
+                         * want to build jamming into it because then it
+                         * will run more slowly).
+                         */
+
+                        yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                        yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+                        if ( yy_next_state )
+                                {
+                                /* Consume the NUL. */
+                                yy_cp = ++yy_c_buf_p;
+                                yy_current_state = yy_next_state;
+                                goto yy_match;
+                                }
+
+                        else
+                                {
+                                yy_cp = yy_c_buf_p;
+                                goto yy_find_action;
+                                }
+                        }
+
+                else switch ( yy_get_next_buffer() )
+                        {
+                        case EOB_ACT_END_OF_FILE:
+                                {
+                                yy_did_buffer_switch_on_eof = 0;
+
+                                if ( yywrap() )
+                                        {
+                                        /* Note: because we've taken care in
+                                         * yy_get_next_buffer() to have set up
+                                         * yytext, we can now set up
+                                         * yy_c_buf_p so that if some total
+                                         * hoser (like flex itself) wants to
+                                         * call the scanner after we return the
+                                         * YY_NULL, it'll still work - another
+                                         * YY_NULL will get returned.
+                                         */
+                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+                                        yy_act = YY_STATE_EOF(YY_START);
+                                        goto do_action;
+                                        }
+
+                                else
+                                        {
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+                                        }
+                                break;
+                                }
+
+                        case EOB_ACT_CONTINUE_SCAN:
+                                yy_c_buf_p =
+                                        yytext_ptr + yy_amount_of_matched_text;
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_match;
+
+                        case EOB_ACT_LAST_MATCH:
+                                yy_c_buf_p =
+                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_find_action;
+                        }
+                break;
+                }
+
+        default:
+                YY_FATAL_ERROR(
+                        "fatal flex scanner internal error--no action found" );
+        } /* end of action switch */
+                } /* end of scanning one token */
+        } /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+         *EOB_ACT_LAST_MATCH -
+         *EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+         *EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+        {
+        register char *dest = yy_current_buffer->yy_ch_buf;
+        register char *source = yytext_ptr;
+        register int number_to_move, i;
+        int ret_val;
+
+        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+                YY_FATAL_ERROR(
+                "fatal flex scanner internal error--end of buffer missed" );
+
+        if ( yy_current_buffer->yy_fill_buffer == 0 )
+                { /* Don't try to fill the buffer, so this is an EOF. */
+                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+                        {
+                        /* We matched a single character, the EOB, so
+                         * treat this as a final EOF.
+                         */
+                        return EOB_ACT_END_OF_FILE;
+                        }
+
+                else
+                        {
+                        /* We matched some text prior to the EOB, first
+                         * process it.
+                         */
+                        return EOB_ACT_LAST_MATCH;
+                        }
+                }
+
+        /* Try to read more data. */
+
+        /* First move last chars to start of buffer. */
+        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+        for ( i = 0; i < number_to_move; ++i )
+                *(dest++) = *(source++);
+
+        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+                /* don't do the read, it's not guaranteed to return an EOF,
+                 * just force an EOF
+                 */
+                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+
+        else
+                {
+                int num_to_read =
+                        yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+                while ( num_to_read <= 0 )
+                        { /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+                        YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+                        /* just a shorter name for the current buffer */
+                        YY_BUFFER_STATE b = yy_current_buffer;
+
+                        int yy_c_buf_p_offset =
+                                (int) (yy_c_buf_p - b->yy_ch_buf);
+
+                        if ( b->yy_is_our_buffer )
+                                {
+                                int new_size = b->yy_buf_size * 2;
+
+                                if ( new_size <= 0 )
+                                        b->yy_buf_size += b->yy_buf_size / 8;
+                                else
+                                        b->yy_buf_size *= 2;
+
+                                b->yy_ch_buf = (char *)
+                                        /* Include room in for 2 EOB chars. */
+                                        yy_flex_realloc( (void *) b->yy_ch_buf,
+                                                         b->yy_buf_size + 2 );
+                                }
+                        else
+                                /* Can't grow it, we don't own it. */
+                                b->yy_ch_buf = 0;
+
+                        if ( ! b->yy_ch_buf )
+                                YY_FATAL_ERROR(
+                                "fatal error - scanner input buffer overflow" );
+
+                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                        num_to_read = yy_current_buffer->yy_buf_size -
+                                                number_to_move - 1;
+#endif
+                        }
+
+                if ( num_to_read > YY_READ_BUF_SIZE )
+                        num_to_read = YY_READ_BUF_SIZE;
+
+                /* Read in more data. */
+                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+                        yy_n_chars, num_to_read );
+
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        if ( yy_n_chars == 0 )
+                {
+                if ( number_to_move == YY_MORE_ADJ )
+                        {
+                        ret_val = EOB_ACT_END_OF_FILE;
+                        yyrestart( yyin );
+                        }
+
+                else
+                        {
+                        ret_val = EOB_ACT_LAST_MATCH;
+                        yy_current_buffer->yy_buffer_status =
+                                YY_BUFFER_EOF_PENDING;
+                        }
+                }
+
+        else
+                ret_val = EOB_ACT_CONTINUE_SCAN;
+
+        yy_n_chars += number_to_move;
+        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+        return ret_val;
+        }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp;
+
+        yy_current_state = yy_start;
+
+        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+                {
+                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+                if ( yy_accept[yy_current_state] )
+                        {
+                        yy_last_accepting_state = yy_current_state;
+                        yy_last_accepting_cpos = yy_cp;
+                        }
+                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                        {
+                        yy_current_state = (int) yy_def[yy_current_state];
+                        if ( yy_current_state >= 47 )
+                                yy_c = yy_meta[(unsigned int) yy_c];
+                        }
+                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                }
+
+        return yy_current_state;
+        }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+         *next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+        {
+        register int yy_is_jam;
+        register char *yy_cp = yy_c_buf_p;
+
+        register YY_CHAR yy_c = 1;
+        if ( yy_accept[yy_current_state] )
+                {
+                yy_last_accepting_state = yy_current_state;
+                yy_last_accepting_cpos = yy_cp;
+                }
+        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                {
+                yy_current_state = (int) yy_def[yy_current_state];
+                if ( yy_current_state >= 47 )
+                        yy_c = yy_meta[(unsigned int) yy_c];
+                }
+        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+        yy_is_jam = (yy_current_state == 46);
+
+        return yy_is_jam ? 0 : yy_current_state;
+        }
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+        {
+        register char *yy_cp = yy_c_buf_p;
+
+        /* undo effects of setting up yytext */
+        *yy_cp = yy_hold_char;
+
+        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                { /* need to shift things up to make room */
+                /* +2 for EOB chars. */
+                register int number_to_move = yy_n_chars + 2;
+                register char *dest = &yy_current_buffer->yy_ch_buf[
+                                        yy_current_buffer->yy_buf_size + 2];
+                register char *source =
+                                &yy_current_buffer->yy_ch_buf[number_to_move];
+
+                while ( source > yy_current_buffer->yy_ch_buf )
+                        *--dest = *--source;
+
+                yy_cp += (int) (dest - source);
+                yy_bp += (int) (dest - source);
+                yy_current_buffer->yy_n_chars =
+                        yy_n_chars = yy_current_buffer->yy_buf_size;
+
+                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
+                }
+
+        *--yy_cp = (char) c;
+
+
+        yytext_ptr = yy_bp;
+        yy_hold_char = *yy_cp;
+        yy_c_buf_p = yy_cp;
+        }
+        #endif/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+        {
+        int c;
+
+        *yy_c_buf_p = yy_hold_char;
+
+        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+                {
+                /* yy_c_buf_p now points to the character we want to return.
+                 * If this occurs *before* the EOB characters, then it's a
+                 * valid NUL; if not, then we've hit the end of the buffer.
+                 */
+                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        /* This was really a NUL. */
+                        *yy_c_buf_p = '\0';
+
+                else
+                        { /* need more input */
+                        int offset = yy_c_buf_p - yytext_ptr;
+                        ++yy_c_buf_p;
+
+                        switch ( yy_get_next_buffer() )
+                                {
+                                case EOB_ACT_LAST_MATCH:
+                                        /* This happens because yy_g_n_b()
+                                         * sees that we've accumulated a
+                                         * token and flags that we need to
+                                         * try matching the token before
+                                         * proceeding.  But for input(),
+                                         * there's no matching to consider.
+                                         * So convert the EOB_ACT_LAST_MATCH
+                                         * to EOB_ACT_END_OF_FILE.
+                                         */
+
+                                        /* Reset buffer status. */
+                                        yyrestart( yyin );
+
+                                        /* fall through */
+
+                                case EOB_ACT_END_OF_FILE:
+                                        {
+                                        if ( yywrap() )
+                                                return EOF;
+
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+#ifdef __cplusplus
+                                        return yyinput();
+#else
+                                        return input();
+#endif
+                                        }
+
+                                case EOB_ACT_CONTINUE_SCAN:
+                                        yy_c_buf_p = yytext_ptr + offset;
+                                        break;
+                                }
+                        }
+                }
+
+                c = *(unsigned char *) yy_c_buf_p;/* cast for 8-bit char's */
+                *yy_c_buf_p = '\0';/* preserve yytext */
+        yy_hold_char = *++yy_c_buf_p;
+
+
+        return c;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+        {
+        if ( ! yy_current_buffer )
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+        yy_init_buffer( yy_current_buffer, input_file );
+        yy_load_buffer_state();
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+        {
+        if ( yy_current_buffer == new_buffer )
+                return;
+
+        if ( yy_current_buffer )
+                {
+                /* Flush out information for old buffer. */
+                *yy_c_buf_p = yy_hold_char;
+                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        yy_current_buffer = new_buffer;
+        yy_load_buffer_state();
+
+        /* We don't actually know whether we did this switch during
+         * EOF (yywrap()) processing, but the only time this flag
+         * is looked at is after yywrap() is called, so it's safe
+         * to go ahead and always set it.
+         */
+        yy_did_buffer_switch_on_eof = 1;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+        {
+        yy_n_chars = yy_current_buffer->yy_n_chars;
+        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+        yyin = yy_current_buffer->yy_input_file;
+        yy_hold_char = *yy_c_buf_p;
+        }
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_buf_size = size;
+
+        /* yy_ch_buf has to be 2 characters longer than the size given because
+         * we need to put in 2 end-of-buffer characters.
+         */
+        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+        if ( ! b->yy_ch_buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_is_our_buffer = 1;
+
+        yy_init_buffer( b, file );
+
+        return b;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+        {
+        if ( ! b )
+                return;
+
+        if ( b == yy_current_buffer )
+                yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+        if ( b->yy_is_our_buffer )
+                yy_flex_free( (void *) b->yy_ch_buf );
+
+        yy_flex_free( (void *) b );
+        }
+
+
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+        {
+        yy_flush_buffer( b );
+
+        b->yy_input_file = file;
+        b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+        b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+        b->yy_is_interactive = 0;
+#else
+
+#ifdef _QTWIN_
+        b->yy_is_interactive = file ? (_isatty( fileno(file) ) > 0) : 0;
+#else
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+
+#endif
+#endif
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+        {
+        if ( ! b )
+                return;
+
+        b->yy_n_chars = 0;
+
+        /* We always need two end-of-buffer characters.  The first causes
+         * a transition to the end-of-buffer state.  The second causes
+         * a jam in that state.
+         */
+        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+        b->yy_buf_pos = &b->yy_ch_buf[0];
+
+        b->yy_at_bol = 1;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        if ( b == yy_current_buffer )
+                yy_load_buffer_state();
+        }
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        if ( size < 2 ||
+             base[size-2] != YY_END_OF_BUFFER_CHAR ||
+             base[size-1] != YY_END_OF_BUFFER_CHAR )
+                /* They forgot to leave room for the EOB's. */
+                return 0;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+                b->yy_buf_size = size - 2;/* "- 2" to take care of EOB's */
+        b->yy_buf_pos = b->yy_ch_buf = base;
+        b->yy_is_our_buffer = 0;
+        b->yy_input_file = 0;
+        b->yy_n_chars = b->yy_buf_size;
+        b->yy_is_interactive = 0;
+        b->yy_at_bol = 1;
+        b->yy_fill_buffer = 0;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        yy_switch_to_buffer( b );
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+        {
+        int len;
+        for ( len = 0; yy_str[len]; ++len )
+                ;
+
+        return yy_scan_bytes( yy_str, len );
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+        {
+        YY_BUFFER_STATE b;
+        char *buf;
+        yy_size_t n;
+        int i;
+
+        /* Get memory for full buffer, including space for trailing EOB's. */
+        n = len + 2;
+        buf = (char *) yy_flex_alloc( n );
+        if ( ! buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+        for ( i = 0; i < len; ++i )
+                buf[i] = bytes[i];
+
+        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+        b = yy_scan_buffer( buf, n );
+        if ( ! b )
+                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+        /* It's okay to grow etc. this buffer, and we should throw it
+         * away when we're done.
+         */
+        b->yy_is_our_buffer = 1;
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+        {
+        if ( yy_start_stack_ptr >= yy_start_stack_depth )
+                {
+                yy_size_t new_size;
+
+                yy_start_stack_depth += YY_START_STACK_INCR;
+                new_size = yy_start_stack_depth * sizeof( int );
+
+                if ( ! yy_start_stack )
+                        yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+                else
+                        yy_start_stack = (int *) yy_flex_realloc(
+                                        (void *) yy_start_stack, new_size );
+
+                if ( ! yy_start_stack )
+                        YY_FATAL_ERROR(
+                        "out of memory expanding start-condition stack" );
+                }
+
+        yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+        BEGIN(new_state);
+        }
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+        {
+        if ( --yy_start_stack_ptr < 0 )
+                YY_FATAL_ERROR( "start-condition stack underflow" );
+
+        BEGIN(yy_start_stack[yy_start_stack_ptr]);
+        }
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+        {
+        return yy_start_stack[yy_start_stack_ptr - 1];
+        }
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+        {
+        (void) fprintf( stderr, "%s\n", msg );
+        exit( YY_EXIT_FAILURE );
+        }
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                yytext[yyleng] = yy_hold_char; \
+                yy_c_buf_p = yytext + n; \
+                yy_hold_char = *yy_c_buf_p; \
+                *yy_c_buf_p = '\0'; \
+                yyleng = n; \
+                } \
+        while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+        {
+        register int i;
+        for ( i = 0; i < n; ++i )
+                s1[i] = s2[i];
+        }
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+        {
+        register int n;
+        for ( n = 0; s[n]; ++n )
+                ;
+
+        return n;
+        }
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+        {
+        return (void *) malloc( size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+        {
+        /* The cast to (char *) in the following accommodates both
+         * implementations that use char* generic pointers, and those
+         * that use void* generic pointers.  It works with the latter
+         * because both ANSI C and C++ allow castless assignment from
+         * any pointer type to void*, and deal with argument conversions
+         * as though doing an assignment.
+         */
+        return (void *) realloc( (char *) ptr, size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+        {
+        free( ptr );
+        }
+
+#if YY_MAIN
+int main()
+        {
+        yylex();
+        return 0;
+        }
+#endif
+#line 107 "icalsslexer.l"
+
+
+int sswrap()
+{
+     return 1;
+}
+
diff --git a/libical/src/libicalss/icalsslexer.l b/libical/src/libicalss/icalsslexer.l
new file mode 100644
index 0000000..58aa162
--- a/dev/null
+++ b/libical/src/libicalss/icalsslexer.l
@@ -0,0 +1,113 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalsslexer.l
+  CREATOR: eric 8 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include "icalssyacc.h"
+#include "icalgaugeimpl.h"
+#include "assert.h"
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input();
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+
+#undef SS_FATAL_ERROR
+#define SS_FATAL_ERROR(msg) sserror(msg)
+
+
+%}
+
+        crlf    \x0D?\x0A
+        space   [ ]
+        qsafechar[^\x00-\x1F\"]
+        safechar[^\x00-\x1F\"\:\;\,]
+        tsafechar[\x20-\x21\x23-\x2B\x2D-\x39\x3C-\x5B\x5D-\x7E]
+        valuechar[^\x00-\x08\x10-\x1F]
+        xname   X-[a-zA-Z0-9\-]+
+xname2          [a-zA-Z0-9\-\ ]
+        paramtext{safechar}+
+        value   {valuechar}+
+        quotedstring\"{qsafechar}+\"
+        digit   [0-9]
+
+%array /* Make yytext an array. Slow, but handy. HACK */
+
+%option caseless
+
+%s sql string_value
+
+
+
+%%
+
+%{
+%}
+
+
+        SELECT          { return SELECT; }
+        FROM            { return FROM; }
+        WHERE           { return WHERE; }
+        ,               { return COMMA; }
+        "="             { return EQUALS; }
+        "!="            { return NOTEQUALS; }
+        "<"             { return LESS; }
+        ">"             { return GREATER; }
+        "<="            { return LESSEQUALS; }
+        ">="            { return GREATEREQUALS; }
+        AND             { return AND; }
+        OR              { return OR; }
+\'                      { return QUOTE; }
+        [ \t\n\r]+ ;            
+        ;               { return EOL; }
+\'[\*A-Za-z0-9\-\.]+\' {
+        int c = input();
+        unput(c);
+        if(c!='\''){
+                sslval.v_string= icalmemory_tmp_copy(sstext);
+                return STRING;
+        } else {
+                /*ssmore();*/
+        }
+}
+
+        [\*A-Za-z0-9\-\.]+      { sslval.v_string= icalmemory_tmp_copy(sstext);
+                          return STRING; }
+
+
+        .               { return yytext[0]; }
+
+%% 
+
+int sswrap()
+{
+     return 1;
+}
+
diff --git a/libical/src/libicalss/icalssyacc.c b/libical/src/libicalss/icalssyacc.c
new file mode 100644
index 0000000..943123e
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.c
@@ -0,0 +1,1381 @@
+/* A Bison parser, made from icalssyacc.y
+   by GNU bison 1.35.  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define yyparse ssparse
+#define yylex sslex
+#define yyerror sserror
+#define yylval sslval
+#define yychar sschar
+#define yydebug ssdebug
+#define yynerrs ssnerrs
+        # define        STRING257
+        # define        SELECT258
+        # define        FROM259
+        # define        WHERE260
+        # define        COMMA261
+        # define        QUOTE262
+        # define        EQUALS263
+        # define        NOTEQUALS264
+        # define        LESS265
+        # define        GREATER266
+        # define        LESSEQUALS267
+        # define        GREATEREQUALS268
+        # define        AND269
+        # define        OR270
+        # define        EOL271
+        # define        END272
+
+#line 1 "icalssyacc.y"
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalssyacc.y
+  CREATOR: eric 08 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include <limits.h> /* for SHRT_MAX*/
+#include "ical.h"
+#include "pvl.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+
+
+extern struct icalgauge_impl *icalss_yy_gauge;
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* prop, 
+        icalgaugecompare compare , char* value);
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1);
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1);
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l);
+void sserror(char *s); /* Don't know why I need this.... */
+
+
+
+
+#line 52 "icalssyacc.y"
+#ifndef YYSTYPE
+typedef union {
+        char* v_string;
+} yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+
+
+        #define         YYFINAL         34
+        #define         YYFLAG  -32768
+        #define         YYNTBASE19
+
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
+#define YYTRANSLATE(x) ((unsigned)(x) <= 272 ? yytranslate[x] : 24)
+
+/* 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
+};
+
+#if YYDEBUG
+static const short yyprhs[] =
+{
+       0,     0,     7,     9,    11,    15,    17,    21,    22,    26,
+      30,    34,    38,    42,    46,    48,    52
+};
+static const short yyrhs[] =
+{
+       4,    20,     5,    21,     6,    23,     0,     1,     0,     3,
+       0,    20,     7,     3,     0,     3,     0,    21,     7,     3,
+       0,     0,     3,     9,     3,     0,     3,    10,     3,     0,
+       3,    11,     3,     0,     3,    12,     3,     0,     3,    13,
+       3,     0,     3,    14,     3,     0,    22,     0,    23,    15,
+      22,     0,    23,    16,    22,     0
+};
+
+#endif
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const short yyrline[] =
+{
+       0,    63,    64,    70,    72,    76,    78,    81,    83,    85,
+      86,    87,    88,    89,    92,    94,    95
+};
+#endif
+
+
+#if (YYDEBUG) || defined YYERROR_VERBOSE
+
+/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
+static const char *const yytname[] =
+{
+  "$", "error", "$undefined.", "STRING", "SELECT", "FROM", "WHERE", "COMMA", 
+  "QUOTE", "EQUALS", "NOTEQUALS", "LESS", "GREATER", "LESSEQUALS", 
+  "GREATEREQUALS", "AND", "OR", "EOL", "END", "query_min", "select_list", 
+  "from_list", "where_clause", "where_list", 0
+};
+#endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const short yyr1[] =
+{
+       0,    19,    19,    20,    20,    21,    21,    22,    22,    22,
+      22,    22,    22,    22,    23,    23,    23
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const short yyr2[] =
+{
+       0,     6,     1,     1,     3,     1,     3,     0,     3,     3,
+       3,     3,     3,     3,     1,     3,     3
+};
+
+/* 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,     2,     0,     3,     0,     0,     0,     5,     0,     4,
+       7,     0,     0,    14,     1,     6,     0,     0,     0,     0,
+       0,     0,     7,     7,     8,     9,    10,    11,    12,    13,
+      15,    16,     0,     0,     0
+};
+
+static const short yydefgoto[] =
+{
+      32,     4,     8,    13,    14
+};
+
+static const short yypact[] =
+{
+       5,-32768,     4,-32768,     3,     8,    15,-32768,     6,-32768,
+      16,    17,    -9,-32768,    -1,-32768,    18,    19,    20,    21,
+      22,    23,    16,    16,-32768,-32768,-32768,-32768,-32768,-32768,
+  -32768,-32768,    27,    28,-32768
+};
+
+static const short yypgoto[] =
+{
+  -32768,-32768,-32768,    -6,-32768
+};
+
+
+        #define         YYLAST  28
+
+
+static const short yytable[] =
+{
+      16,    17,    18,    19,    20,    21,     1,     3,     5,     2,
+       6,     7,    10,    11,    22,    23,    30,    31,     9,    12,
+      15,    24,    25,    26,    27,    28,    29,    33,    34
+};
+
+static const short yycheck[] =
+{
+       9,    10,    11,    12,    13,    14,     1,     3,     5,     4,
+       7,     3,     6,     7,    15,    16,    22,    23,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     0,     0
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "/usr/share/bison/bison.simple"
+
+/* Skeleton output parser for bison,
+
+   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.  */
+
+/* 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)
+
+#endif
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#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
+
+        #define yyerrok         (yyerrstatus = 0)
+        #define yyclearin(yychar = YYEMPTY)
+        #define YYEMPTY         -2
+        #define YYEOF   0
+        #define YYACCEPTgoto 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.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+        #define YYFAIL  goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+        #define YYBACKUP(Token, Value)                          \
+        do                                                      \
+          if (yychar == YYEMPTY && yylen == 1)                  \
+            {                                                   \
+              yychar = (Token);                                         \
+              yylval = (Value);                                         \
+              yychar1 = YYTRANSLATE (yychar);                   \
+              YYPOPSTACK;                                       \
+              goto yybackup;                                    \
+            }                                                   \
+          else                                                  \
+            {                                                   \
+              yyerror ("syntax error: cannot back up");                 \
+              YYERROR;                                          \
+            }                                                   \
+while (0)
+
+        #define YYTERROR1
+        #define YYERRCODE256
+
+
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+   are run).
+
+   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 YYLLOC_DEFAULT
+        # define YYLLOC_DEFAULT(Current, Rhs, N)       \
+           Current.last_line   = Rhs[N].last_line;\
+   Current.last_column = Rhs[N].last_column;
+#endif
+
+
+/* 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.  */
+        #ifndefYYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* 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
+#endif
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+#ifdef YYERROR_VERBOSE
+
+# 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;
+
+  while (*yys++ != '\0')
+    continue;
+
+  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 *yyd = yydest;
+  register const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+#endif
+
+#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
+# 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.  */
+#ifdef __GNUC__
+# ifdef YYPARSE_PARAM
+int yyparse (void *);
+# 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_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. */
+          shortyyssa[YYINITDEPTH];
+  short *yyss = yyssa;
+  register short *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  register YYSTYPE *yyvsp;
+
+#if YYLSP_NEEDED
+  /* The location stack.  */
+  YYLTYPE yylsa[YYINITDEPTH];
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+#endif
+
+#if YYLSP_NEEDED
+# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+# define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+
+  /* 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;
+
+  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;
+  yyvsp = yyvs;
+#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++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* 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)
+        goto yyoverflowlab;
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        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 + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+      yylsp = yyls + yysize - 1;
+#endif
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyssp >= yyss + yystacksize - 1)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto 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)
+    {
+      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 */
+
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE (yychar);
+
+#if YYDEBUG
+     /* We have to keep this `#if YYDEBUG', since we use variables
+        which are defined only if `YYDEBUG' is set.  */
+      if (yydebug)
+        {
+          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
+          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.  */
+  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;
+#if YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* 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 yyi;
+
+      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+                 yyn, yyrline[yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      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 64 "icalssyacc.y"
+{ 
+                 icalparser_clear_flex_input();
+                 yyclearin;
+           }
+    break;
+case 3:
+#line 71 "icalssyacc.y"
+{ssyacc_add_select(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 4:
+#line 72 "icalssyacc.y"
+{ssyacc_add_select(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 5:
+#line 77 "icalssyacc.y"
+{ssyacc_add_from(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 6:
+#line 78 "icalssyacc.y"
+{ssyacc_add_from(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 8:
+#line 83 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_EQUAL,yyvsp[0].v_string); }
+    break;
+case 9:
+#line 85 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_NOTEQUAL,yyvsp[0].v_string); }
+    break;
+case 10:
+#line 86 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_LESS,yyvsp[0].v_string); }
+    break;
+case 11:
+#line 87 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_GREATER,yyvsp[0].v_string); }
+    break;
+case 12:
+#line 88 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_LESSEQUAL,yyvsp[0].v_string); }
+    break;
+case 13:
+#line 89 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_GREATEREQUAL,yyvsp[0].v_string); }
+    break;
+case 14:
+#line 93 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_NONE);}
+    break;
+case 15:
+#line 94 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_AND);}
+    break;
+case 16:
+#line 95 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_OR);}
+    break;
+}
+
+#line 705 "/usr/share/bison/bison.simple"
+
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#if YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG
+  if (yydebug)
+    {
+      short *yyssp1 = yyss - 1;
+      YYFPRINTF (stderr, "state stack now");
+      while (yyssp1 != yyssp)
+        YYFPRINTF (stderr, " %d", *++yyssp1);
+      YYFPRINTF (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+#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.  */
+
+  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 |
+`------------------------------------*/
+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)
+        {
+          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)
+            {
+              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+              yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
+
+              if (yycount < 5)
+                {
+                  yycount = 0;
+                  for (yyx = yyn < 0 ? -yyn : 0;
+                       yyx < (int) (sizeof (yytname) / sizeof (char *));
+                       yyx++)
+                    if (yycheck[yyx + yyn] == yyx)
+                      {
+                        const char *yyq = ! yycount ? ", expecting " : " or ";
+                        yyp = yystpcpy (yyp, yyq);
+                        yyp = yystpcpy (yyp, yytname[yyx]);
+                        yycount++;
+                      }
+                }
+              yyerror (yymsg);
+              YYSTACK_FREE (yymsg);
+            }
+          else
+            yyerror ("parse error; also virtual memory exhausted");
+        }
+      else
+#endif /* defined (YYERROR_VERBOSE) */
+        yyerror ("parse error");
+    }
+  goto yyerrlab1;
+
+
+/*--------------------------------------------------.
+| 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.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+        YYABORT;
+      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+                  yychar, yytname[yychar1]));
+      yychar = YYEMPTY;
+    }
+
+  /* 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:
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+
+  /* 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                                                    |
+`---------------------------------------------------------------*/
+yyerrpop:
+  if (yyssp == yyss)
+    YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#if YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG
+  if (yydebug)
+    {
+      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;
+
+  YYDPRINTF ((stderr, "Shifting error token, "));
+
+  *++yyvsp = yylval;
+#if YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| 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 yyresult;
+}
+#line 99 "icalssyacc.y"
+
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* str1, 
+        icalgaugecompare compare , char* value_str)
+{
+
+    struct icalgauge_where *where;
+    char *compstr, *propstr, *c, *s,*l;
+    
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* remove enclosing quotes */
+    s = value_str;
+    if(*s == '\''){
+        s++;
+    }
+    l = s+strlen(s)-1;
+    if(*l == '\''){
+        *l=0;
+    }
+        
+    where->value = strdup(s);
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+    where->prop = icalenum_string_to_property_kind(propstr);    
+
+    where->compare = compare;
+
+    if(where->value == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        free(where->value);
+        return;
+    }
+
+    pvl_push(impl->where,where);
+}
+
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l)
+{
+    pvl_elem e = pvl_tail(impl->where);
+    struct icalgauge_where *where = pvl_data(e);
+
+    where->logic = l;
+   
+}
+
+
+
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1)
+{
+    char *c, *compstr, *propstr;
+    struct icalgauge_where *where;
+    
+    /* Uses only the prop and comp fields of the where structure */
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+
+    /* If the property was '*', then accept all properties */
+    if(strcmp("*",propstr) == 0) {
+                where->prop = ICAL_ANY_PROPERTY;     
+    } else {
+        where->prop = icalenum_string_to_property_kind(propstr);    
+    }
+    
+
+    if(where->prop == ICAL_NO_PROPERTY){
+        icalgauge_free(where);
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    pvl_push(impl->select,where);
+}
+
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1)
+{
+    icalcomponent_kind ckind;
+
+    ckind = icalenum_string_to_component_kind(str1);
+
+    if(ckind == ICAL_NO_COMPONENT){
+        assert(0);
+    }
+
+    pvl_push(impl->from,(void*)ckind);
+
+}
+
+
+void sserror(char *s){
+    fprintf(stderr,"Parse error \'%s\'\n", s);
+}
diff --git a/libical/src/libicalss/icalssyacc.h b/libical/src/libicalss/icalssyacc.h
new file mode 100644
index 0000000..7d42f3c
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.h
@@ -0,0 +1,31 @@
+#ifndef BISON_ICALSSYACC_H
+# define BISON_ICALSSYACC_H
+
+#ifndef YYSTYPE
+typedef union {
+        char* v_string;
+} yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+        # define        STRING257
+        # define        SELECT258
+        # define        FROM259
+        # define        WHERE260
+        # define        COMMA261
+        # define        QUOTE262
+        # define        EQUALS263
+        # define        NOTEQUALS264
+        # define        LESS265
+        # define        GREATER266
+        # define        LESSEQUALS267
+        # define        GREATEREQUALS268
+        # define        AND269
+        # define        OR270
+        # define        EOL271
+        # define        END272
+
+
+extern YYSTYPE sslval;
+
+#endif /* not BISON_ICALSSYACC_H */
diff --git a/libical/src/libicalss/icalssyacc.y b/libical/src/libicalss/icalssyacc.y
new file mode 100644
index 0000000..6482b58
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.y
@@ -0,0 +1,245 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalssyacc.y
+  CREATOR: eric 08 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include <limits.h> /* for SHRT_MAX*/
+#include "ical.h"
+#include "pvl.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+
+
+extern struct icalgauge_impl *icalss_yy_gauge;
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* prop, 
+        icalgaugecompare compare , char* value);
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1);
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1);
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l);
+void sserror(char *s); /* Don't know why I need this.... */
+
+
+
+%}
+
+%union {
+        char* v_string;
+}
+
+
+%token <v_string> STRING
+%token SELECT FROM WHERE COMMA QUOTE EQUALS NOTEQUALS  LESS GREATER LESSEQUALS
+%token GREATEREQUALS AND OR EOL END
+
+%%
+
+query_min: SELECT select_list FROM from_list WHERE where_list
+           | error { 
+                 icalparser_clear_flex_input();
+                 yyclearin;
+                   }
+                   ;
+
+select_list:
+        STRING {ssyacc_add_select(icalss_yy_gauge,$1);}
+        | select_list COMMA STRING {ssyacc_add_select(icalss_yy_gauge,$3);}
+        ;
+
+
+from_list:
+        STRING {ssyacc_add_from(icalss_yy_gauge,$1);}
+        | from_list COMMA STRING {ssyacc_add_from(icalss_yy_gauge,$3);}
+        ;
+
+where_clause:
+        /* Empty */
+        | STRING EQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_EQUAL,$3); }
+        
+        | STRING NOTEQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_NOTEQUAL,$3); }
+        | STRING LESS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_LESS,$3); }
+        | STRING GREATER STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_GREATER,$3); }
+        | STRING LESSEQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_LESSEQUAL,$3); }
+        | STRING GREATEREQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_GREATEREQUAL,$3); }
+        ;
+
+where_list:
+        where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_NONE);}
+        | where_list AND where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_AND);} 
+        | where_list OR where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_OR);}
+        ;
+
+
+%%
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* str1, 
+        icalgaugecompare compare , char* value_str)
+{
+
+    struct icalgauge_where *where;
+    char *compstr, *propstr, *c, *s,*l;
+    
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* remove enclosing quotes */
+    s = value_str;
+    if(*s == '\''){
+        s++;
+    }
+    l = s+strlen(s)-1;
+    if(*l == '\''){
+        *l=0;
+    }
+        
+    where->value = strdup(s);
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+    where->prop = icalenum_string_to_property_kind(propstr);    
+
+    where->compare = compare;
+
+    if(where->value == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        free(where->value);
+        return;
+    }
+
+    pvl_push(impl->where,where);
+}
+
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l)
+{
+    pvl_elem e = pvl_tail(impl->where);
+    struct icalgauge_where *where = pvl_data(e);
+
+    where->logic = l;
+   
+}
+
+
+
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1)
+{
+    char *c, *compstr, *propstr;
+    struct icalgauge_where *where;
+    
+    /* Uses only the prop and comp fields of the where structure */
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+
+    /* If the property was '*', then accept all properties */
+    if(strcmp("*",propstr) == 0) {
+                where->prop = ICAL_ANY_PROPERTY;     
+    } else {
+        where->prop = icalenum_string_to_property_kind(propstr);    
+    }
+    
+
+    if(where->prop == ICAL_NO_PROPERTY){
+        icalgauge_free(where);
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    pvl_push(impl->select,where);
+}
+
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1)
+{
+    icalcomponent_kind ckind;
+
+    ckind = icalenum_string_to_component_kind(str1);
+
+    if(ckind == ICAL_NO_COMPONENT){
+        assert(0);
+    }
+
+    pvl_push(impl->from,(void*)ckind);
+
+}
+
+
+void sserror(char *s){
+    fprintf(stderr,"Parse error \'%s\'\n", s);
+}
diff --git a/libical/src/libicalss/libicalss.pro b/libical/src/libicalss/libicalss.pro
new file mode 100644
index 0000000..a5cc80c
--- a/dev/null
+++ b/libical/src/libicalss/libicalss.pro
@@ -0,0 +1,43 @@
+include(../../../variables.pri)
+
+        TEMPLATE= lib
+
+TARGET          = icalss
+DESTDIR = ../../lib
+        CONFIG  += staticlib
+win32: DEFINES += _WIN32  _QTWIN_
+        HEADERS         = icalcalendar.h \
+                  icalclassify.h \
+                  icalcstp.h \
+                  icalcstpclient.h \
+                  icalcstpserver.h \
+                  icaldirset.h \
+                  icaldirsetimpl.h \
+                  icalfileset.h \
+                  icalfilesetimpl.h \
+                  icalgauge.h \
+                  icalgaugeimpl.h \
+                  icalmessage.h \
+                  icalset.h \
+                  icalspanlist.h \
+                  icalssyacc.h \
+                  config.h
+                  
+        SOURCES         = icalclassify.c \
+                  icalcstp.c \
+                  icalcstpclient.c \
+                  icalcstpserver.c \
+                  icaldirset.c \
+                  icalfileset.c \
+                  icalgauge.c \
+                  icalmessage.c \
+                  icalset.c \
+                  icalspanlist.c \
+                  icalsslexer.c \
+                  icalssyacc.c
+                  
+        INTERFACES= 
+
+INCLUDEPATH     += ../libical
+
+DEFINES += HAVE_CONFIG_H
diff --git a/libical/src/libicalss/libicalssE.pro b/libical/src/libicalss/libicalssE.pro
new file mode 100644
index 0000000..57d60bd
--- a/dev/null
+++ b/libical/src/libicalss/libicalssE.pro
@@ -0,0 +1,45 @@
+        TEMPLATE= lib
+        CONFIG  += warn_on  staticlib
+INCLUDEPATH     += ../libical
+INCLUDEPATH     += .
+DEFINES += HAVE_CONFIG_H
+OBJECTS_DIR = obj/$(PLATFORM)
+MOC_DIR = moc/$(PLATFORM)
+DESTDIR=../../lib/$(PLATFORM)
+TARGET          = icalss
+
+INTERFACES = \
+
+HEADERS = \
+ config.h \
+ icalcalendar.h \
+ icalclassify.h \
+ icalcstp.h \
+ icalcstpclient.h \
+ icalcstpserver.h \
+ icaldirset.h \
+ icaldirsetimpl.h \
+ icalfileset.h \
+ icalfilesetimpl.h \
+ icalgauge.h \
+ icalgaugeimpl.h \
+ icalmessage.h \
+ icalset.h \
+ icalspanlist.h \
+ icalss.h \
+ icalssyacc.h \
+
+SOURCES = \
+ icalclassify.c \
+ icalcstp.c \
+ icalcstpclient.c \
+ icalcstpserver.c \
+ icaldirset.c \
+ icalfileset.c \
+ icalgauge.c \
+ icalmessage.c \
+ icalset.c \
+ icalspanlist.c \
+ icalsslexer.c \
+ icalssyacc.c \
+