Fixes for base64 decoding and encoding of vCard

4 files changed, 28 insertions, 35 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
@@ -380,129 +380,129 @@ todoitem:
 	;

 

 %%

 /*------------------------------------*/

 static int pushVObject(const char *prop)

     {

     VObject *newObj;

     if (ObjStackTop == MAXLEVEL)

 	return FALSE;

 

     ObjStack[++ObjStackTop] = curObj;

 

     if (curObj) {

         newObj = addProp(curObj,prop);

         curObj = newObj;

 	}

     else

 	curObj = newVObject(prop);

 

     return TRUE;

     }

 

 

 /*---------------------------------------*/

 /* This pops the recently built vCard off the stack and returns it. */

 static VObject* popVObject()

     {

     VObject *oldObj;

     if (ObjStackTop < 0) {

 	yyerror("pop on empty Object Stack\n");

 	return 0;

 	}

     oldObj = curObj;

     curObj = ObjStack[ObjStackTop--];

 

     return oldObj;

     }

 

 

 static void enterValues(const char *value)

     {

     if (fieldedProp && *fieldedProp) {

 	if (value) {

 	    addPropValue(curProp,*fieldedProp,value);

 	    }

 	/* else this field is empty, advance to next field */

 	fieldedProp++;

 	}

     else {

 	if (value) {

 	    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;

 

 static void lexPushMode(enum LexMode mode)

     {

     if (lexBuf.lexModeStackTop == (MAX_LEX_MODE_STACK_SIZE-1))

 	yyerror("lexical context stack overflow");

     else {

 	lexBuf.lexModeStack[++lexBuf.lexModeStackTop] = mode;

 	}

     }

 

 static void lexPopMode(int top)

     {

     /* special case of pop for ease of error recovery -- this

 	version will never underflow */

     if (top)

 	lexBuf.lexModeStackTop = 0;

@@ -752,352 +752,351 @@ static char* lexGet1Value() {
 		lexPushLookaheadc('\n');

 		break;

 		}

 	    }

 	else {

 	    lexAppendc(c);

 	    lexSkipLookahead();

 	    }

 	c = lexLookahead();

 	}

     lexAppendc(0);

     handleMoreRFC822LineBreak(c);

     return c==EOF?0:lexStr();

     }

 #endif

 

 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') {

+			    lexSkipWhite();

+			    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();

-#if 0		
-		yylval.str = p;

-		return STRING;

-#endif		
+		yylval.str = NULL;

+		return lexGetDataFromBase64() ? STRING : 0;

 		}

 	    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': {

 		    ++mime_lineNum;

 		    continue;

 		    }

 		case EOF: return 0;

 		    break;

 		default: {

 		    lexPushLookaheadc(c);

 		    if (isalnum(c)) {

 			char *t = lexGetWord();

 			yylval.str = t;

 			if (!qstricmp(t, "begin")) {

 			    return match_begin_end_name(0);

 			    }

 			else if (!qstricmp(t,"end")) {

 			    return match_begin_end_name(1);

 			    }

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
@@ -400,129 +400,129 @@ YYSTYPE yyvs[YYSTACKSIZE];
 #define yystacksize YYSTACKSIZE
 #line 382 "backend/vcc.y"
 

 /*------------------------------------*/

 static int pushVObject(const char *prop)

     {

     VObject *newObj;

     if (ObjStackTop == MAXLEVEL)

 	return FALSE;

 

     ObjStack[++ObjStackTop] = curObj;

 

     if (curObj) {

         newObj = addProp(curObj,prop);

         curObj = newObj;

 	}

     else

 	curObj = newVObject(prop);

 

     return TRUE;

     }

 

 

 /*---------------------------------------*/

 /* This pops the recently built vCard off the stack and returns it. */

 static VObject* popVObject()

     {

     VObject *oldObj;

     if (ObjStackTop < 0) {

 	yyerror("pop on empty Object Stack\n");

 	return 0;

 	}

     oldObj = curObj;

     curObj = ObjStack[ObjStackTop--];

 

     return oldObj;

     }

 

 

 static void enterValues(const char *value)

     {

     if (fieldedProp && *fieldedProp) {

 	if (value) {

 	    addPropValue(curProp,*fieldedProp,value);

 	    }

 	/* else this field is empty, advance to next field */

 	fieldedProp++;

 	}

     else {

 	if (value) {

 	    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;

 

 static void lexPushMode(enum LexMode mode)

     {

     if (lexBuf.lexModeStackTop == (MAX_LEX_MODE_STACK_SIZE-1))

 	yyerror("lexical context stack overflow");

     else {

 	lexBuf.lexModeStack[++lexBuf.lexModeStackTop] = mode;

 	}

     }

 

 static void lexPopMode(int top)

     {

     /* special case of pop for ease of error recovery -- this

 	version will never underflow */

     if (top)

 	lexBuf.lexModeStackTop = 0;

@@ -772,352 +772,351 @@ static char* lexGet1Value() {
 		lexPushLookaheadc('\n');

 		break;

 		}

 	    }

 	else {

 	    lexAppendc(c);

 	    lexSkipLookahead();

 	    }

 	c = lexLookahead();

 	}

     lexAppendc(0);

     handleMoreRFC822LineBreak(c);

     return c==EOF?0:lexStr();

     }

 #endif

 

 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') {

+			    lexSkipWhite();

+			    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();

-#if 0
-		yylval.str = p;

-		return STRING;

-#endif		
+		yylval.str = NULL;

+		return lexGetDataFromBase64() ? STRING : 0;

 		}

 	    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': {

 		    ++mime_lineNum;

 		    continue;

 		    }

 		case EOF: return 0;

 		    break;

 		default: {

 		    lexPushLookaheadc(c);

 		    if (isalnum(c)) {

 			char *t = lexGetWord();

 			yylval.str = t;

 			if (!qstricmp(t, "begin")) {

 			    return match_begin_end_name(0);

 			    }

 			else if (!qstricmp(t,"end")) {

 			    return match_begin_end_name(1);

 			    }

@@ -1177,129 +1176,129 @@ DLLEXPORT(VObject*) Parse_MIME_FromFile(CFile *file)
     startPos = file->GetPosition();

     if (!(result = Parse_MIMEHelper()))

 	file->Seek(startPos, CFile::begin);

     return result;

     }

 

 #else

 

 VObject* Parse_MIME_FromFile(FILE *file)

     {

     VObject *result;	

     long startPos;

 

     initLex(0,(unsigned long)-1,file);

     startPos = ftell(file);

     if (!(result = Parse_MIMEHelper())) {

 	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
     }
     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
     {
 #if YYDEBUG
         if (yydebug)
             printf("%sdebug: state %d, shifting to state %d\n",
                     YYPREFIX, yystate, yytable[yyn]);
 #endif
         if (yyssp >= yyss + yystacksize - 1)
         {
             goto yyoverflow;
         }
         *++yyssp = yystate = yytable[yyn];
         *++yyvsp = yylval;
         yychar = (-1);
         if (yyerrflag > 0)  --yyerrflag;
@@ -1477,121 +1476,121 @@ break;
 case 31:
 #line 319 "backend/vcc.y"
 { if (!pushVObject(VCCalProp)) YYERROR; }
 break;
 case 32:
 #line 321 "backend/vcc.y"
 { yyval.vobj = popVObject(); }
 break;
 case 38:
 #line 336 "backend/vcc.y"
 {

 	lexPushMode(L_VEVENT);

 	if (!pushVObject(VCEventProp)) YYERROR;

 	}
 break;
 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;
     goto yyloop;
 yyoverflow:
     yyerror("yacc stack overflow");
 yyabort:
     return (1);
 yyaccept:
     return (0);
 }
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,111 +1,109 @@
 /***************************************************************************
 (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 <malloc.h>
-#endif
+#include <stdlib.h>
 
 #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;
 
 
 
 /*----------------------------------------------------------------------
    The following functions involve with memory allocation:
 	newVObject
 	deleteVObject
 	dupStr
 	deleteStr
 	newStrItem
 	deleteStrItem
    ----------------------------------------------------------------------*/
 
 DLLEXPORT(VObject*) newVObject_(const char *id)
 {
     VObject *p = (VObject*)malloc(sizeof(VObject));
     p->next = 0;
@@ -696,129 +694,128 @@ static struct PreDefProp propNames[] = {
     { VCExpectProp, 0, 0, 0 },
     { VCExtAddressProp, 0, 0, 0 },
     { VCFamilyNameProp, 0, 0, 0 },
     { VCFaxProp, 0, 0, 0 },
     { VCFullNameProp, 0, 0, 0 },
     { VCGeoLocationProp, 0, 0, 0 },
     { VCGeoProp, 0, 0, 0 },
     { VCGIFProp, 0, 0, 0 },
     { VCGivenNameProp, 0, 0, 0 },
     { VCGroupingProp, 0, 0, 0 },
     { VCHomeProp, 0, 0, 0 },
     { VCIBMMailProp, 0, 0, 0 },
     { VCInlineProp, 0, 0, 0 },
     { VCInternationalProp, 0, 0, 0 },
     { VCInternetProp, 0, 0, 0 },
     { VCISDNProp, 0, 0, 0 },
     { 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;
 	
     for (i = 0; propNames[i].name; i++)
 	if (qstricmp(str, propNames[i].name) == 0) {
 	    return &propNames[i];
 	    }
     
     return 0;
 }
 
 
 DLLEXPORT(const char*) lookupProp_(const char* str)
 {
     int i;
 	
     for (i = 0; propNames[i].name; i++)
 	if (qstricmp(str, propNames[i].name) == 0) {
 	    const char* s;
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
@@ -38,131 +38,129 @@ DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable.
 
 /*
 
 The vCard/vCalendar C interface is implemented in the set
 of files as follows:
 
 vcc.y, yacc source, and vcc.c, the yacc output you will use
 implements the core parser
 
 vobject.c implements an API that insulates the caller from
 the parser and changes in the vCard/vCalendar BNF
 
 port.h defines compilation environment dependent stuff
 
 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 <qglobal.h>
-
+#include <qtopia/global.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 FALSE	0
 #endif
 #ifndef TRUE
 #define TRUE	1
 #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"
 #define VCCISProp				"CIS"
 #define VCCityProp				"L"
 #define VCClassProp				"CLASS"
 #define VCCommentProp			"NOTE"
 #define VCCompletedProp			"COMPLETED"
 #define VCContentIDProp			"CONTENT-ID"
 #define VCCountryNameProp		"C"
 #define VCDAlarmProp			"DALARM"
 #define VCDataSizeProp			"DATASIZE"
 #define VCDayLightProp			"DAYLIGHT"
 #define VCDCreatedProp			"DCREATED"
 #define VCDeliveryLabelProp     "LABEL"
 #define VCDescriptionProp		"DESCRIPTION"
 #define VCDIBProp				"DIB"
 #define VCDisplayStringProp		"DISPLAYSTRING"
 #define VCDomesticProp			"DOM"