4 files changed, 32 insertions, 39 deletions
diff --git a/library/backend/vcc.y b/library/backend/vcc.y
index 4c79368..bec2955 100644
--- a/library/backend/vcc.y
+++ b/library/backend/vcc.y
@@ -396,97 +396,97 @@ static int pushVObject(const char *prop)
    else
        curObj = newVObject(prop);
    return TRUE;
    }
 /*---------------------------------------*/
 /* This pops the recently built vCard off the stack and returns it. */
 static VObject* popVObject()
    {
    VObject *oldObj;
    if (ObjStackTop < 0) {
        yyerror("pop on empty Object Stack\n");
        return 0;
        }
    oldObj = curObj;
    curObj = ObjStack[ObjStackTop--];
    return oldObj;
    }
 static void enterValues(const char *value)
    {
    if (fieldedProp && *fieldedProp) {
        if (value) {
            addPropValue(curProp,*fieldedProp,value);
            }
        /* else this field is empty, advance to next field */
        fieldedProp++;
        }
    else {
        if (value) {
            setVObjectStringZValue_(curProp,strdup( value ));
            }
        }
    deleteStr(value);
    }
 static void enterProps(const char *s)
    {
    curProp = addGroup(curObj,s);
    deleteStr(s);
    }
 static void enterAttr(const char *s1, const char *s2)
    {
-    const char *p1, *p2;
+    const char *p1, *p2=0;
    p1 = lookupProp_(s1);
    if (s2) {
        VObject *a;
        p2 = lookupProp_(s2);
        a = addProp(curProp,p1);
        setVObjectStringZValue(a,p2);
        }
    else
        addProp(curProp,p1);
    if (qstricmp(p1,VCBase64Prop) == 0 || (s2 && qstricmp(p2,VCBase64Prop)==0))
        lexPushMode(L_BASE64);
    else if (qstricmp(p1,VCQuotedPrintableProp) == 0
            || (s2 && qstricmp(p2,VCQuotedPrintableProp)==0))
        lexPushMode(L_QUOTED_PRINTABLE);
    deleteStr(s1); deleteStr(s2);
    }
 #define MAX_LEX_LOOKAHEAD_0 32
 #define MAX_LEX_LOOKAHEAD 64
 #define MAX_LEX_MODE_STACK_SIZE 10
 #define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop])
 struct LexBuf {
        /* input */
 #ifdef INCLUDEMFC
    CFile *inputFile;
 #else
    FILE *inputFile;
 #endif
    char *inputString;
    unsigned long curPos;
    unsigned long inputLen;
        /* lookahead buffer */
        /*   -- lookahead buffer is short instead of char so that EOF
         /      can be represented correctly.
        */
    unsigned long len;
    short buf[MAX_LEX_LOOKAHEAD];
    unsigned long getPtr;
        /* context stack */
    unsigned long lexModeStackTop;
    enum LexMode lexModeStack[MAX_LEX_MODE_STACK_SIZE];
        /* token buffer */
    unsigned long maxToken;
    char *strs;
    unsigned long strsLen;
    } lexBuf;
@@ -768,320 +768,319 @@ static char* lexGet1Value() {
 static int match_begin_name(int end) {
    char *n = lexLookaheadWord();
    int token = ID;
    if (n) {
        if (!qstricmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD;
        else if (!qstricmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL;
        else if (!qstricmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT;
        else if (!qstricmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO;
        deleteStr(n);
        return token;
        }
    return 0;
    }
 #ifdef INCLUDEMFC
 void initLex(const char *inputstring, unsigned long inputlen, CFile *inputfile)
 #else
 void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile)
 #endif
    {
    // initialize lex mode stack
    lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL;
    // iniatialize lex buffer.
    lexBuf.inputString = (char*) inputstring;
    lexBuf.inputLen = inputlen;
    lexBuf.curPos = 0;
    lexBuf.inputFile = inputfile;
    lexBuf.len = 0;
    lexBuf.getPtr = 0;
    lexBuf.maxToken = MAXTOKEN;
    lexBuf.strs = (char*)malloc(MAXTOKEN);
    lexBuf.strsLen = 0;
    }
 static void finiLex() {
    free(lexBuf.strs);
    }
 /*-----------------------------------*/
 /* This parses and converts the base64 format for binary encoding into
 * a decoded buffer (allocated with new).  See RFC 1521.
 */
-static char * lexGetDataFromBase64()
+static int lexGetDataFromBase64()
    {
    unsigned long bytesLen = 0, bytesMax = 0;
    int quadIx = 0, pad = 0;
    unsigned long trip = 0;
    unsigned char b;
    int c;
    unsigned char *bytes = NULL;
    unsigned char *oldBytes = NULL;
    DBG_(("db: lexGetDataFromBase64\n"));
    while (1) {
        c = lexGetc();
+        lexSkipWhite();
        if (c == '\n') {
            ++mime_lineNum;
            if (lexLookahead() == '\n') {
                /* a '\n' character by itself means end of data */
                break;
                }
            else continue; /* ignore '\n' */
            }
        else {
            if ((c >= 'A') && (c <= 'Z'))
                b = (unsigned char)(c - 'A');
            else if ((c >= 'a') && (c <= 'z'))
                b = (unsigned char)(c - 'a') + 26;
            else if ((c >= '0') && (c <= '9'))
                b = (unsigned char)(c - '0') + 52;
            else if (c == '+')
                b = 62;
            else if (c == '/')
                b = 63;
            else if (c == '=') {
                b = 0;
                pad++;
-            } else if ((c == ' ') || (c == '\t')) {
-                continue;
            } else { /* error condition */
                if (bytes) free(bytes);
                else if (oldBytes) free(oldBytes);
                // error recovery: skip until 2 adjacent newlines.
                DBG_(("db: invalid character 0x%x '%c'\n", c,c));
                if (c != EOF)  {
                    c = lexGetc();
                    while (c != EOF) {
-                        if (c == '\n' && lexLookahead() == '\n') {
+                        if (c == '\n') {
-                            ++mime_lineNum;
+                            lexSkipWhite();
-                            break;
+                            if(lexLookahead() == '\n') {
+                                ++mime_lineNum;
+                                break;
+                                }
                            }
                        c = lexGetc();
                        }
                    }
-                return NULL;
+                return c != EOF;
                }
            trip = (trip << 6) | b;
            if (++quadIx == 4) {
                unsigned char outBytes[3];
                int numOut;
                int i;
                for (i = 0; i < 3; i++) {
                    outBytes[2-i] = (unsigned char)(trip & 0xFF);
                    trip >>= 8;
                    }
                numOut = 3 - pad;
                if (bytesLen + numOut > bytesMax) {
                    if (!bytes) {
                        bytesMax = 1024;
                        bytes = (unsigned char*)malloc((size_t)bytesMax);
                        }
                    else {
                        bytesMax <<= 2;
                        oldBytes = bytes;
                        bytes = (unsigned char*)realloc(bytes,(size_t)bytesMax);
                        }
                    if (bytes == 0) {
                        mime_error("out of memory while processing BASE64 data\n");
                        }
                    }
                if (bytes) {
                    memcpy(bytes + bytesLen, outBytes, numOut);
                    bytesLen += numOut;
                    }
                trip = 0;
                quadIx = 0;
                }
            }
        } /* while */
    DBG_(("db: bytesLen = %d\n",  bytesLen));
    /* kludge: all this won't be necessary if we have tree form
        representation */
    if (bytes) {
        setValueWithSize(curProp,bytes,(unsigned int)bytesLen);
        free(bytes);
        }
    else if (oldBytes) {
        setValueWithSize(curProp,oldBytes,(unsigned int)bytesLen);
        free(oldBytes);
        }
-    return 0;
+    return bytesLen;
    }
 static int match_begin_end_name(int end) {
    int token;
    lexSkipWhite();
    if (lexLookahead() != ':') return ID;
    lexSkipLookahead();
    lexSkipWhite();
    token = match_begin_name(end);
    if (token == ID) {
        lexPushLookaheadc(':');
        DBG_(("db: ID '%s'\n", yylval.str));
        return ID;
        }
    else if (token != 0) {
        lexSkipLookaheadWord();
        deleteStr(yylval.str);
        DBG_(("db: begin/end %d\n", token));
        return token;
        }
    return 0;
    }
 static char* lexGetQuotedPrintable()
 {
    int c;
    lexSkipWhite();
    c = lexLookahead();
    lexClearToken();
-    while (c != EOF && c != ';') {
+    while (c != EOF && (c != ';' || !fieldedProp)) {
        if (c == '\n') {
            // break, leave '\n' on remaining chars.
            break;
        } else if (c == '=') {
            int cur = 0;
            int next;
            lexSkipLookahead(); // skip '='
            next = lexLookahead();
            if (next == '\n') {
                // skip and only skip the \n
                lexSkipLookahead(); 
                c = lexLookahead();
                ++mime_lineNum; // aid in error reporting
                continue;
            } else if (next >= '0' && next <= '9') {
                cur = next - '0';
            } else if (next >= 'A' && next <= 'F') {
                cur = next - 'A' + 10;
            } else {
                // we have been sent buggy stuff. doesn't matter
                // what we do so long as we keep going.
                // should probably spit an error here
                lexSkipLookahead(); 
                c = lexLookahead();
                continue;
            }
            lexSkipLookahead(); // skip A-Z0-9
            next = lexLookahead();
            cur = cur * 16;
            // this time really just expecting 0-9A-F
            if (next >= '0' && next <= '9') {
                cur += next - '0';
            } else if (next >= 'A' && next <= 'F') {
                cur += next - 'A' + 10;
            } else {
                // we have been sent buggy stuff. doesn't matter
                // what we do so long as we keep going.
                // should probably spit an error here
                lexSkipLookahead(); 
                c = lexLookahead();
                continue;
            }
            // got a valid escaped =.  append it.
            lexSkipLookahead(); // skip second 0-9A-F
            lexAppendc(cur);
        } else {
            lexSkipLookahead(); // skip whatever we just read.
            lexAppendc(c); // and append it.
        }
        c = lexLookahead();
    }
    lexAppendc(0);
    return c==EOF?0:lexStr();
 }
 static int yylex() {
    int lexmode = LEXMODE();
    if (lexmode == L_VALUES) {
        int c = lexGetc();
        if (c == ';' && fieldedProp) {
            DBG_(("db: SEMICOLON\n"));
            lexPushLookaheadc(c);
            handleMoreRFC822LineBreak(c);
            lexSkipLookahead();
            return SEMICOLON;
            }
        else if (strchr("\n",c)) {
            ++mime_lineNum;
            /* consume all line separator(s) adjacent to each other */
            c = lexLookahead();
            while (strchr("\n",c)) {
                lexSkipLookahead();
                c = lexLookahead();
                ++mime_lineNum;
                }
            DBG_(("db: LINESEP\n"));
            return LINESEP;
            }
        else {
            char *p = 0;
            lexPushLookaheadc(c);
            if (lexWithinMode(L_BASE64)) {
                /* get each char and convert to bin on the fly... */
-                p = lexGetDataFromBase64();
+                yylval.str = NULL;
-        #if 0   
+                return lexGetDataFromBase64() ? STRING : 0;
-                yylval.str = p;
-                return STRING;
-        #endif  
                }
            else if (lexWithinMode(L_QUOTED_PRINTABLE)) {
                p = lexGetQuotedPrintable();
                }
            else {
 #ifdef _SUPPORT_LINE_FOLDING
                p = lexGet1Value();
 #else
                p = lexGetStrUntil(";\n");
 #endif
                }
            if (p) {
                DBG_(("db: STRING: '%s'\n", p));
                yylval.str = p;
                return STRING;
                }
            else return 0;
            }
        }
    else {
        /* normal mode */
        while (1) {
            int c = lexGetc();
            switch(c) {
                case ':': {
                    /* consume all line separator(s) adjacent to each other */
                    /* ignoring linesep immediately after colon. */
                    /* I don't see this in the spec, and it breaks null values -- WA
                    c = lexLookahead();
                    while (strchr("\n",c)) {
                        lexSkipLookahead();
                        c = lexLookahead();
                        ++mime_lineNum;
                        }
                    */
                    DBG_(("db: COLON\n"));
                    return COLON;
                    }
                case ';':
                    DBG_(("db: SEMICOLON\n"));
                    return SEMICOLON;
                case '=':
                    DBG_(("db: EQ\n"));
                    return EQ;
                /* ignore whitespace in this mode */
                case '\t':
                case ' ': continue;
                case '\n': {
diff --git a/library/backend/vcc_yacc.cpp b/library/backend/vcc_yacc.cpp
index 5f53aef..4006bc2 100644
--- a/library/backend/vcc_yacc.cpp
+++ b/library/backend/vcc_yacc.cpp
@@ -416,97 +416,97 @@ static int pushVObject(const char *prop)
    else
        curObj = newVObject(prop);
    return TRUE;
    }
 /*---------------------------------------*/
 /* This pops the recently built vCard off the stack and returns it. */
 static VObject* popVObject()
    {
    VObject *oldObj;
    if (ObjStackTop < 0) {
        yyerror("pop on empty Object Stack\n");
        return 0;
        }
    oldObj = curObj;
    curObj = ObjStack[ObjStackTop--];
    return oldObj;
    }
 static void enterValues(const char *value)
    {
    if (fieldedProp && *fieldedProp) {
        if (value) {
            addPropValue(curProp,*fieldedProp,value);
            }
        /* else this field is empty, advance to next field */
        fieldedProp++;
        }
    else {
        if (value) {
            setVObjectStringZValue_(curProp,strdup( value ));
            }
        }
    deleteStr(value);
    }
 static void enterProps(const char *s)
    {
    curProp = addGroup(curObj,s);
    deleteStr(s);
    }
 static void enterAttr(const char *s1, const char *s2)
    {
-    const char *p1, *p2;
+    const char *p1, *p2=0;
    p1 = lookupProp_(s1);
    if (s2) {
        VObject *a;
        p2 = lookupProp_(s2);
        a = addProp(curProp,p1);
        setVObjectStringZValue(a,p2);
        }
    else
        addProp(curProp,p1);
    if (qstricmp(p1,VCBase64Prop) == 0 || (s2 && qstricmp(p2,VCBase64Prop)==0))
        lexPushMode(L_BASE64);
    else if (qstricmp(p1,VCQuotedPrintableProp) == 0
            || (s2 && qstricmp(p2,VCQuotedPrintableProp)==0))
        lexPushMode(L_QUOTED_PRINTABLE);
    deleteStr(s1); deleteStr(s2);
    }
 #define MAX_LEX_LOOKAHEAD_0 32
 #define MAX_LEX_LOOKAHEAD 64
 #define MAX_LEX_MODE_STACK_SIZE 10
 #define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop])
 struct LexBuf {
        /* input */
 #ifdef INCLUDEMFC
    CFile *inputFile;
 #else
    FILE *inputFile;
 #endif
    char *inputString;
    unsigned long curPos;
    unsigned long inputLen;
        /* lookahead buffer */
        /*   -- lookahead buffer is short instead of char so that EOF
         /      can be represented correctly.
        */
    unsigned long len;
    short buf[MAX_LEX_LOOKAHEAD];
    unsigned long getPtr;
        /* context stack */
    unsigned long lexModeStackTop;
    enum LexMode lexModeStack[MAX_LEX_MODE_STACK_SIZE];
        /* token buffer */
    unsigned long maxToken;
    char *strs;
    unsigned long strsLen;
    } lexBuf;
@@ -788,320 +788,319 @@ static char* lexGet1Value() {
 static int match_begin_name(int end) {
    char *n = lexLookaheadWord();
    int token = ID;
    if (n) {
        if (!qstricmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD;
        else if (!qstricmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL;
        else if (!qstricmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT;
        else if (!qstricmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO;
        deleteStr(n);
        return token;
        }
    return 0;
    }
 #ifdef INCLUDEMFC
 void initLex(const char *inputstring, unsigned long inputlen, CFile *inputfile)
 #else
 void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile)
 #endif
    {
    // initialize lex mode stack
    lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL;
    // iniatialize lex buffer.
    lexBuf.inputString = (char*) inputstring;
    lexBuf.inputLen = inputlen;
    lexBuf.curPos = 0;
    lexBuf.inputFile = inputfile;
    lexBuf.len = 0;
    lexBuf.getPtr = 0;
    lexBuf.maxToken = MAXTOKEN;
    lexBuf.strs = (char*)malloc(MAXTOKEN);
    lexBuf.strsLen = 0;
    }
 static void finiLex() {
    free(lexBuf.strs);
    }
 /*-----------------------------------*/
 /* This parses and converts the base64 format for binary encoding into
 * a decoded buffer (allocated with new).  See RFC 1521.
 */
-static char * lexGetDataFromBase64()
+static int lexGetDataFromBase64()
    {
    unsigned long bytesLen = 0, bytesMax = 0;
    int quadIx = 0, pad = 0;
    unsigned long trip = 0;
    unsigned char b;
    int c;
    unsigned char *bytes = NULL;
    unsigned char *oldBytes = NULL;
    DBG_(("db: lexGetDataFromBase64\n"));
    while (1) {
        c = lexGetc();
+        lexSkipWhite();
        if (c == '\n') {
            ++mime_lineNum;
            if (lexLookahead() == '\n') {
                /* a '\n' character by itself means end of data */
                break;
                }
            else continue; /* ignore '\n' */
            }
        else {
            if ((c >= 'A') && (c <= 'Z'))
                b = (unsigned char)(c - 'A');
            else if ((c >= 'a') && (c <= 'z'))
                b = (unsigned char)(c - 'a') + 26;
            else if ((c >= '0') && (c <= '9'))
                b = (unsigned char)(c - '0') + 52;
            else if (c == '+')
                b = 62;
            else if (c == '/')
                b = 63;
            else if (c == '=') {
                b = 0;
                pad++;
-            } else if ((c == ' ') || (c == '\t')) {
-                continue;
            } else { /* error condition */
                if (bytes) free(bytes);
                else if (oldBytes) free(oldBytes);
                // error recovery: skip until 2 adjacent newlines.
                DBG_(("db: invalid character 0x%x '%c'\n", c,c));
                if (c != EOF)  {
                    c = lexGetc();
                    while (c != EOF) {
-                        if (c == '\n' && lexLookahead() == '\n') {
+                        if (c == '\n') {
-                            ++mime_lineNum;
+                            lexSkipWhite();
-                            break;
+                            if(lexLookahead() == '\n') {
+                                ++mime_lineNum;
+                                break;
+                                }
                            }
                        c = lexGetc();
                        }
                    }
-                return NULL;
+                return c != EOF;
                }
            trip = (trip << 6) | b;
            if (++quadIx == 4) {
                unsigned char outBytes[3];
                int numOut;
                int i;
                for (i = 0; i < 3; i++) {
                    outBytes[2-i] = (unsigned char)(trip & 0xFF);
                    trip >>= 8;
                    }
                numOut = 3 - pad;
                if (bytesLen + numOut > bytesMax) {
                    if (!bytes) {
                        bytesMax = 1024;
                        bytes = (unsigned char*)malloc((size_t)bytesMax);
                        }
                    else {
                        bytesMax <<= 2;
                        oldBytes = bytes;
                        bytes = (unsigned char*)realloc(bytes,(size_t)bytesMax);
                        }
                    if (bytes == 0) {
                        mime_error("out of memory while processing BASE64 data\n");
                        }
                    }
                if (bytes) {
                    memcpy(bytes + bytesLen, outBytes, numOut);
                    bytesLen += numOut;
                    }
                trip = 0;
                quadIx = 0;
                }
            }
        } /* while */
    DBG_(("db: bytesLen = %d\n",  bytesLen));
    /* kludge: all this won't be necessary if we have tree form
        representation */
    if (bytes) {
        setValueWithSize(curProp,bytes,(unsigned int)bytesLen);
        free(bytes);
        }
    else if (oldBytes) {
        setValueWithSize(curProp,oldBytes,(unsigned int)bytesLen);
        free(oldBytes);
        }
-    return 0;
+    return bytesLen;
    }
 static int match_begin_end_name(int end) {
    int token;
    lexSkipWhite();
    if (lexLookahead() != ':') return ID;
    lexSkipLookahead();
    lexSkipWhite();
    token = match_begin_name(end);
    if (token == ID) {
        lexPushLookaheadc(':');
        DBG_(("db: ID '%s'\n", yylval.str));
        return ID;
        }
    else if (token != 0) {
        lexSkipLookaheadWord();
        deleteStr(yylval.str);
        DBG_(("db: begin/end %d\n", token));
        return token;
        }
    return 0;
    }
 static char* lexGetQuotedPrintable()
 {
    int c;
    lexSkipWhite();
    c = lexLookahead();
    lexClearToken();
-    while (c != EOF && c != ';') {
+    while (c != EOF && (c != ';' || !fieldedProp)) {
        if (c == '\n') {
            // break, leave '\n' on remaining chars.
            break;
        } else if (c == '=') {
            int cur = 0;
            int next;
            lexSkipLookahead(); // skip '='
            next = lexLookahead();
            if (next == '\n') {
                // skip and only skip the \n
                lexSkipLookahead(); 
                c = lexLookahead();
                ++mime_lineNum; // aid in error reporting
                continue;
            } else if (next >= '0' && next <= '9') {
                cur = next - '0';
            } else if (next >= 'A' && next <= 'F') {
                cur = next - 'A' + 10;
            } else {
                // we have been sent buggy stuff. doesn't matter
                // what we do so long as we keep going.
                // should probably spit an error here
                lexSkipLookahead(); 
                c = lexLookahead();
                continue;
            }
            lexSkipLookahead(); // skip A-Z0-9
            next = lexLookahead();
            cur = cur * 16;
            // this time really just expecting 0-9A-F
            if (next >= '0' && next <= '9') {
                cur += next - '0';
            } else if (next >= 'A' && next <= 'F') {
                cur += next - 'A' + 10;
            } else {
                // we have been sent buggy stuff. doesn't matter
                // what we do so long as we keep going.
                // should probably spit an error here
                lexSkipLookahead(); 
                c = lexLookahead();
                continue;
            }
            // got a valid escaped =.  append it.
            lexSkipLookahead(); // skip second 0-9A-F
            lexAppendc(cur);
        } else {
            lexSkipLookahead(); // skip whatever we just read.
            lexAppendc(c); // and append it.
        }
        c = lexLookahead();
    }
    lexAppendc(0);
    return c==EOF?0:lexStr();
 }
 static int yylex() {
    int lexmode = LEXMODE();
    if (lexmode == L_VALUES) {
        int c = lexGetc();
        if (c == ';' && fieldedProp) {
            DBG_(("db: SEMICOLON\n"));
            lexPushLookaheadc(c);
            handleMoreRFC822LineBreak(c);
            lexSkipLookahead();
            return SEMICOLON;
            }
        else if (strchr("\n",c)) {
            ++mime_lineNum;
            /* consume all line separator(s) adjacent to each other */
            c = lexLookahead();
            while (strchr("\n",c)) {
                lexSkipLookahead();
                c = lexLookahead();
                ++mime_lineNum;
                }
            DBG_(("db: LINESEP\n"));
            return LINESEP;
            }
        else {
            char *p = 0;
            lexPushLookaheadc(c);
            if (lexWithinMode(L_BASE64)) {
                /* get each char and convert to bin on the fly... */
-                p = lexGetDataFromBase64();
+                yylval.str = NULL;
-#if 0
+                return lexGetDataFromBase64() ? STRING : 0;
-                yylval.str = p;
-                return STRING;
-        #endif  
                }
            else if (lexWithinMode(L_QUOTED_PRINTABLE)) {
                p = lexGetQuotedPrintable();
                }
            else {
 #ifdef _SUPPORT_LINE_FOLDING
                p = lexGet1Value();
 #else
                p = lexGetStrUntil(";\n");
 #endif
                }
            if (p) {
                DBG_(("db: STRING: '%s'\n", p));
                yylval.str = p;
                return STRING;
                }
            else return 0;
            }
        }
    else {
        /* normal mode */
        while (1) {
            int c = lexGetc();
            switch(c) {
                case ':': {
                    /* consume all line separator(s) adjacent to each other */
                    /* ignoring linesep immediately after colon. */
                    /* I don't see this in the spec, and it breaks null values -- WA
                    c = lexLookahead();
                    while (strchr("\n",c)) {
                        lexSkipLookahead();
                        c = lexLookahead();
                        ++mime_lineNum;
                        }
                    */
                    DBG_(("db: COLON\n"));
                    return COLON;
                    }
                case ';':
                    DBG_(("db: SEMICOLON\n"));
                    return SEMICOLON;
                case '=':
                    DBG_(("db: EQ\n"));
                    return EQ;
                /* ignore whitespace in this mode */
                case '\t':
                case ' ': continue;
                case '\n': {
@@ -1193,97 +1192,97 @@ VObject* Parse_MIME_FromFile(FILE *file)
        fseek(file,startPos,SEEK_SET);
        }
    return result;
    }
 DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname)
    {
    FILE *fp = fopen(fname,"r");
    if (fp) {
        VObject* o = Parse_MIME_FromFile(fp);
        fclose(fp);
        return o;
        }
    else {
        char msg[80];
        sprintf(msg, "can't open file '%s' for reading\n", fname);
        mime_error_(msg);
        return 0;
        }
    }
 #endif
 /*-------------------------------------*/
 static MimeErrorHandler mimeErrorHandler;
 DLLEXPORT(void) registerMimeErrorHandler(MimeErrorHandler me)
    {
    mimeErrorHandler = me;
    }
 void mime_error(char *s)
    {
    char msg[256];
    if (mimeErrorHandler) {
        sprintf(msg,"%s at line %d", s, mime_lineNum);
        mimeErrorHandler(msg);
        }
    }
 void mime_error_(char *s)
    {
    if (mimeErrorHandler) {
        mimeErrorHandler(s);
        }
    }
-#line 1240 "y.tab.c"
+#line 1241 "y.tab.c"
 #define YYABORT goto yyabort
 #define YYREJECT goto yyabort
 #define YYACCEPT goto yyaccept
 #define YYERROR goto yyerrlab
 int
 #if defined(__STDC__)
 yyparse(void)
 #else
 yyparse()
 #endif
 {
    register int yym, yyn, yystate;
 #if YYDEBUG
    register char *yys;
    extern char *getenv();
    if (yys = getenv("YYDEBUG"))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
 #endif
    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;
 yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
 #if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
 #endif
    }
@@ -1493,97 +1492,97 @@ case 39:
 #line 342 "backend/vcc.y"
 {
        lexPopMode(0);
        popVObject();
        }
 break;
 case 40:
 #line 347 "backend/vcc.y"
 {
        lexPushMode(L_VEVENT);
        if (!pushVObject(VCEventProp)) YYERROR;
        }
 break;
 case 41:
 #line 352 "backend/vcc.y"
 {
        lexPopMode(0);
        popVObject();
        }
 break;
 case 42:
 #line 360 "backend/vcc.y"
 {
        lexPushMode(L_VTODO);
        if (!pushVObject(VCTodoProp)) YYERROR;
        }
 break;
 case 43:
 #line 366 "backend/vcc.y"
 {
        lexPopMode(0);
        popVObject();
        }
 break;
 case 44:
 #line 371 "backend/vcc.y"
 {
        lexPushMode(L_VTODO);
        if (!pushVObject(VCTodoProp)) YYERROR;
        }
 break;
 case 45:
 #line 376 "backend/vcc.y"
 {
        lexPopMode(0);
        popVObject();
        }
 break;
-#line 1540 "y.tab.c"
+#line 1541 "y.tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
 #if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
 #endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
 #if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
 #endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
 #if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
 to state %d\n", YYPREFIX, *yyssp, yystate);
 #endif
    if (yyssp >= yyss + yystacksize - 1)
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
diff --git a/library/backend/vobject.cpp b/library/backend/vobject.cpp
index 4c8de70..9263c3a 100644
--- a/library/backend/vobject.cpp
+++ b/library/backend/vobject.cpp
@@ -1,95 +1,93 @@
 /***************************************************************************
 (C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International             
 Business Machines Corporation and Siemens Rolm Communications Inc.             
                                                                               
 For purposes of this license notice, the term Licensors shall mean,            
 collectively, Apple Computer, Inc., AT&T Corp., International                  
 Business Machines Corporation and Siemens Rolm Communications Inc.             
 The term Licensor shall mean any of the Licensors.                             
                                                                               
 Subject to acceptance of the following conditions, permission is hereby        
 granted by Licensors without the need for written agreement and without        
 license or royalty fees, to use, copy, modify and distribute this              
 software for any purpose.                                                      
                                                                               
 The above copyright notice and the following four paragraphs must be           
 reproduced in all copies of this software and any software including           
 this software.                                                                 
                                                                               
 THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE       
 ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR       
 MODIFICATIONS.                                                                 
                                                                               
 IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT,              
 INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT         
 OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH         
 DAMAGE.                                                                        
                                                                               
 EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED,       
 INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE            
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR             
 PURPOSE.                                                                       
 The software is provided with RESTRICTED RIGHTS.  Use, duplication, or         
 disclosure by the government are subject to restrictions set forth in          
 DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.                         
 ***************************************************************************/
 /*
 * src: vobject.c
 * doc: vobject and APIs to construct vobject, APIs pretty print 
 * vobject, and convert a vobject into its textual representation.
 */
-        #ifndef MWERKS
+#include <stdlib.h>
-#include <malloc.h>
-#endif
 #include <qtopia/config.h>
 #include "vobject_p.h"
 #include "qfiledirect_p.h"
 #include <string.h>
 #include <stdio.h>
 #include <fcntl.h>
 //#include <io.h>
        #define NAME_OF(o)                      o->id
        #define VALUE_TYPE(o)           o->valType
        #define STRINGZ_VALUE_OF(o)     o->val.strs
        #define INTEGER_VALUE_OF(o)     o->val.i
        #define LONG_VALUE_OF(o)        o->val.l
        #define ANY_VALUE_OF(o)                 o->val.any
        #define VOBJECT_VALUE_OF(o)     o->val.vobj
 static char vobj_cs[10];
 static enum { EightBit, QuotedPrintable, Base64 } vobj_enc=EightBit;
 static const char *vobj_enc_s=0;
 typedef union ValueItem {
    const char *strs;
    unsigned int i;
    unsigned long l;
    void *any;
    VObject *vobj;
    } ValueItem;
 struct VObject {
    VObject *next;
    const char *id;
    VObject *prop;
    unsigned short valType;
    ValueItem val;
    };
 typedef struct StrItem StrItem;
 struct StrItem {
    StrItem *next;
    const char *s;
    unsigned int refCnt;
    };
 DLLEXPORT(const char**) fieldedProp;
@@ -712,97 +710,96 @@ static struct PreDefProp propNames[] = {
    { VCJPEGProp, 0, 0, 0 },
    { VCLanguageProp, 0, 0, 0 },
    { VCLastModifiedProp, 0, 0, 0 },
    { VCLastRevisedProp, 0, 0, 0 },
    { VCLocationProp, 0, 0, 0 },
    { VCLogoProp, 0, 0, 0 },
    { VCMailerProp, 0, 0, 0 },
    { VCMAlarmProp, 0, MAlarmFields, 0 },
    { VCMCIMailProp, 0, 0, 0 },
    { VCMessageProp, 0, 0, 0 },
    { VCMETProp, 0, 0, 0 },
    { VCModemProp, 0, 0, 0 },
    { VCMPEG2Prop, 0, 0, 0 },
    { VCMPEGProp, 0, 0, 0 },
    { VCMSNProp, 0, 0, 0 },
    { VCNamePrefixesProp, 0, 0, 0 },
    { VCNameProp, 0, nameFields, 0 },
    { VCNameSuffixesProp, 0, 0, 0 },
    { VCNoteProp, 0, 0, 0 },
    { VCOrgNameProp, 0, 0, 0 },
    { VCOrgProp, 0, orgFields, 0 },
    { VCOrgUnit2Prop, 0, 0, 0 },
    { VCOrgUnit3Prop, 0, 0, 0 },
    { VCOrgUnit4Prop, 0, 0, 0 },
    { VCOrgUnitProp, 0, 0, 0 },
    { VCPagerProp, 0, 0, 0 },
    { VCPAlarmProp, 0, PAlarmFields, 0 },
    { VCParcelProp, 0, 0, 0 },
    { VCPartProp, 0, 0, 0 },
    { VCPCMProp, 0, 0, 0 },
    { VCPDFProp, 0, 0, 0 },
    { VCPGPProp, 0, 0, 0 },
    { VCPhotoProp, 0, 0, 0 },
    { VCPICTProp, 0, 0, 0 },
    { VCPMBProp, 0, 0, 0 },
    { VCPostalBoxProp, 0, 0, 0 },
    { VCPostalCodeProp, 0, 0, 0 },
    { VCPostalProp, 0, 0, 0 },
    { VCPowerShareProp, 0, 0, 0 },
    { VCPreferredProp, 0, 0, 0 },
    { VCPriorityProp, 0, 0, 0 },
    { VCProcedureNameProp, 0, 0, 0 },
    { VCProdIdProp, 0, 0, 0 },
    { VCProdigyProp, 0, 0, 0 },
    { VCPronunciationProp, 0, 0, 0 },
    { VCPSProp, 0, 0, 0 },
    { VCPublicKeyProp, 0, 0, 0 },
    { VCQPProp, VCQuotedPrintableProp, 0, 0 },
-    { VCQPProp, VCBase64Prop, 0, 0 },
    { VCQuickTimeProp, 0, 0, 0 },
    { VCQuotedPrintableProp, 0, 0, 0 },
    { VCRDateProp, 0, 0, 0 },
    { VCRegionProp, 0, 0, 0 },
    { VCRelatedToProp, 0, 0, 0 },
    { VCRepeatCountProp, 0, 0, 0 },
    { VCResourcesProp, 0, 0, 0 },
    { VCRNumProp, 0, 0, 0 },
    { VCRoleProp, 0, 0, 0 },
    { VCRRuleProp, 0, 0, 0 },
    { VCRSVPProp, 0, 0, 0 },
    { VCRunTimeProp, 0, 0, 0 },
    { VCSequenceProp, 0, 0, 0 },
    { VCSnoozeTimeProp, 0, 0, 0 },
    { VCStartProp, 0, 0, 0 },
    { VCStatusProp, 0, 0, 0 },
    { VCStreetAddressProp, 0, 0, 0 },
    { VCSubTypeProp, 0, 0, 0 },
    { VCSummaryProp, 0, 0, 0 },
    { VCTelephoneProp, 0, 0, 0 },
    { VCTIFFProp, 0, 0, 0 },
    { VCTimeZoneProp, 0, 0, 0 },
    { VCTitleProp, 0, 0, 0 },
    { VCTLXProp, 0, 0, 0 },
    { VCTodoProp, 0, 0, PD_BEGIN },
    { VCTranspProp, 0, 0, 0 },
    { VCUniqueStringProp, 0, 0, 0 },
    { VCURLProp, 0, 0, 0 },
    { VCURLValueProp, 0, 0, 0 },
    { VCValueProp, 0, 0, 0 },
    { VCVersionProp, 0, 0, 0 },
    { VCVideoProp, 0, 0, 0 },
    { VCVoiceProp, 0, 0, 0 },
    { VCWAVEProp, 0, 0, 0 },
    { VCWMFProp, 0, 0, 0 },
    { VCWorkProp, 0, 0, 0 },
    { VCX400Prop, 0, 0, 0 },
    { VCX509Prop, 0, 0, 0 },
    { VCXRuleProp, 0, 0, 0 },
    { 0,0,0,0 }
    };
 static struct PreDefProp* lookupPropInfo(const char* str)
 {
    /* brute force for now, could use a hash table here. */
    int i;
        
diff --git a/library/backend/vobject_p.h b/library/backend/vobject_p.h
index f969898..3c9d0d3 100644
--- a/library/backend/vobject_p.h
+++ b/library/backend/vobject_p.h
@@ -54,99 +54,97 @@ vcc.h and vobject.h are header files for their .c counterparts
 vcaltmp.h and vcaltmp.c implement vCalendar "macro" functions
 which you may find useful.
 test.c is a standalone test driver that exercises some of
 the features of the APIs provided. Invoke test.exe on a
 VCARD/VCALENDAR input text file and you will see the pretty
 print output of the internal representation (this pretty print
 output should give you a good idea of how the internal
 representation looks like -- there is one such output in the
 following too). Also, a file with the .out suffix is generated
 to show that the internal representation can be written back
 in the original text format.
 For more information on this API see the readme.txt file
 which accompanied this distribution.
  Also visit:
                http://www.versit.com
                http://www.ralden.com
 */
 // No tr() anywhere in this file
 #ifndef __VOBJECT_H__
 #define __VOBJECT_H__ 1
 #include <qstring.h>
        #define         vCardClipboardFormat    "+//ISBN 1-887687-00-9::versit::PDI//vCard"
        #define         vCalendarClipboardFormat"+//ISBN 1-887687-00-9::versit::PDI//vCalendar"
 /* The above strings vCardClipboardFormat and vCalendarClipboardFormat
 are globally unique IDs which can be used to generate clipboard format
 ID's as per the requirements of a specific platform. For example, in
 Windows they are used as the parameter in a call to RegisterClipboardFormat.
 For example:
  CLIPFORMAT foo = RegisterClipboardFormat(vCardClipboardFormat);
 */
        #define vCardMimeType   "text/x-vCard"
        #define vCalendarMimeType"text/x-vCalendar"
 #undef DLLEXPORT
-        //#include <qtopia/qpeglobal.h>
+#include <qtopia/global.h>
-#include <qglobal.h>
 #if defined(QTOPIA_MAKEDLL)
 #define DLLEXPORT(t)   __declspec(dllexport) t
 #elif defined(QTOPIA_DLL)
 #define DLLEXPORT(t)   __declspec(dllimport) t
 #else
 #define DLLEXPORT(t) t
 #endif
 #ifndef FALSE
        #define FALSE0
 #endif
 #ifndef TRUE
        #define TRUE1
 #endif
 #include <stdlib.h>
 #include <stdio.h>
        #define VC7bitProp                      "7BIT"
        #define VC8bitProp                      "8BIT"
        #define VCAAlarmProp            "AALARM"
        #define VCAdditionalNamesProp"ADDN"
        #define VCAdrProp                       "ADR"
        #define VCAgentProp                     "AGENT"
        #define VCAIFFProp                      "AIFF"
        #define VCAOLProp                       "AOL"
        #define VCAppleLinkProp                 "APPLELINK"
        #define VCAttachProp            "ATTACH"
        #define VCAttendeeProp          "ATTENDEE"
        #define VCATTMailProp           "ATTMAIL"
        #define VCAudioContentProp      "AUDIOCONTENT"
        #define VCAVIProp                       "AVI"
        #define VCBase64Prop            "BASE64"
        #define VCBBSProp                       "BBS"
        #define VCBirthDateProp                 "BDAY"
        #define VCBMPProp                       "BMP"
        #define VCBodyProp                      "BODY"
        #define VCBusinessRoleProp      "ROLE"
        #define VCCalProp                       "VCALENDAR"
        #define VCCaptionProp           "CAP"
        #define VCCardProp                      "VCARD"
        #define VCCarProp                       "CAR"
        #define VCCategoriesProp        "CATEGORIES"
        #define VCCellularProp          "CELL"
        #define VCCGMProp                       "CGM"
        #define VCCharSetProp           "CHARSET"
        #define VCCIDProp                       "CID"