1 files changed, 2 insertions, 1 deletions

diff --git a/libkcal/versit/vcc.c b/libkcal/versit/vcc.c
index 9be752d..5413813 100644
--- a/libkcal/versit/vcc.c
+++ b/libkcal/versit/vcc.c
@@ -1669,193 +1669,194 @@ static int lexGeta()
     ++lexBuf.len;
     return (lexBuf.buf[lexBuf.getPtr] = lexGetc_());
     }
 
 static int lexGeta_(int i)
     {
     ++lexBuf.len;
     return (lexBuf.buf[(lexBuf.getPtr+i)%MAX_LEX_LOOKAHEAD] = lexGetc_());
     }
 
 static void lexSkipLookahead() {
     if (lexBuf.len > 0 && lexBuf.buf[lexBuf.getPtr]!=EOF) {
 	/* don't skip EOF. */
         lexBuf.getPtr = (lexBuf.getPtr + 1) % MAX_LEX_LOOKAHEAD;
 	lexBuf.len--;
         }
     }
 
 static int lexLookahead() {
     int c = (lexBuf.len)?
 	lexBuf.buf[lexBuf.getPtr]:
 	lexGeta();
     /* do the \r\n -> \n or \r -> \n translation here */
     if (c == '\r') {
 	int a = (lexBuf.len>1)?
 	    lexBuf.buf[(lexBuf.getPtr+1)%MAX_LEX_LOOKAHEAD]:
 	    lexGeta_(1);
 	if (a == '\n') {
 	    lexSkipLookahead();
 	    }
 	lexBuf.buf[lexBuf.getPtr] = c = '\n';
 	}
     else if (c == '\n') {
 	int a = (lexBuf.len>1)?
 	    lexBuf.buf[lexBuf.getPtr+1]:
 	    lexGeta_(1);
 	if (a == '\r') {
 	    lexSkipLookahead();
 	    }
 	lexBuf.buf[lexBuf.getPtr] = '\n';
 	}
     return c;
     }
 
 static int lexGetc() {
     int c = lexLookahead();
     if (lexBuf.len > 0 && lexBuf.buf[lexBuf.getPtr]!=EOF) {
 	/* EOF will remain in lookahead buffer */
         lexBuf.getPtr = (lexBuf.getPtr + 1) % MAX_LEX_LOOKAHEAD;
 	lexBuf.len--;
         }
     return c;
     }
 
 static void lexSkipLookaheadWord() {
     if (lexBuf.strsLen <= lexBuf.len) {
 	lexBuf.len -= lexBuf.strsLen;
 	lexBuf.getPtr = (lexBuf.getPtr + lexBuf.strsLen) % MAX_LEX_LOOKAHEAD;
 	}
     }
 
 static void lexClearToken()
     {
     lexBuf.strsLen = 0;
     }
 
 static void lexAppendc(int c)
     {
     lexBuf.strs[lexBuf.strsLen] = c;
     /* append up to zero termination */
     if (c == 0) return;
     lexBuf.strsLen++;
     if (lexBuf.strsLen > lexBuf.maxToken) {
 	/* double the token string size */
 	lexBuf.maxToken <<= 1;
 	lexBuf.strs = (char*) realloc(lexBuf.strs,(size_t)lexBuf.maxToken);
 	}
     }
 
 static char* lexStr() {
     return dupStr(lexBuf.strs,(size_t)lexBuf.strsLen+1);
     }
 
 static void lexSkipWhite() {
     int c = lexLookahead();
     while (c == ' ' || c == '\t') {
 	lexSkipLookahead();
 	c = lexLookahead();
 	}
     }
 
 static char* lexGetWord() {
     int c;
     lexSkipWhite();
     lexClearToken();
     c = lexLookahead();
-    while (c != EOF && !strchr("\t\n ;:=",c)) {
+    // LR while (c != EOF && !strchr("\t\n ;:=",c)) {
+    while (c != EOF && !strchr("\t\n;:=",c)) {
 	lexAppendc(c);
 	lexSkipLookahead();
 	c = lexLookahead();
 	}
     lexAppendc(0);
     return lexStr();
     }
 
 static void lexPushLookaheadc(int c) {
     int putptr;
     /* can't putback EOF, because it never leaves lookahead buffer */
     if (c == EOF) return;
     putptr = (int)lexBuf.getPtr - 1;
     if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD;
     lexBuf.getPtr = putptr;
     lexBuf.buf[putptr] = c;
     lexBuf.len += 1;
     }
 
 static char* lexLookaheadWord() {
     /* this function can lookahead word with max size of MAX_LEX_LOOKAHEAD_0
      /  and thing bigger than that will stop the lookahead and return 0;
      / leading white spaces are not recoverable.
      */
     int c;
     int len = 0;
     int curgetptr = 0;
     lexSkipWhite();
     lexClearToken();
     curgetptr = (int)lexBuf.getPtr;	/* remember! */
     while (len < (MAX_LEX_LOOKAHEAD_0)) {
 	c = lexGetc();
 	len++;
 	if (c == EOF || strchr("\t\n ;:=", c)) {
 	    lexAppendc(0);
 	    /* restore lookahead buf. */
 	    lexBuf.len += len;
 	    lexBuf.getPtr = curgetptr;
 	    return lexStr();
 	    }
         else
 	    lexAppendc(c);
 	}
     lexBuf.len += len;	/* char that has been moved to lookahead buffer */
     lexBuf.getPtr = curgetptr;
     return 0;
     }
 
 #ifdef _SUPPORT_LINE_FOLDING
 static void handleMoreRFC822LineBreak(int c) {
     /* suport RFC 822 line break in cases like
      *	ADR: foo;
      *    morefoo;
      *    more foo;
      */
     if (c == ';') {
 	int a;
 	lexSkipLookahead();
 	/* skip white spaces */
 	a = lexLookahead();
 	while (a == ' ' || a == '\t') {
 	    lexSkipLookahead();
 	    a = lexLookahead();
 	    }
 	if (a == '\n') {
 	    lexSkipLookahead();
 	    a = lexLookahead();
 	    if (a == ' ' || a == '\t') {
 		/* continuation, throw away all the \n and spaces read so
 		 * far
 		 */
 		lexSkipWhite();
 		lexPushLookaheadc(';');
 		}
 	    else {
 		lexPushLookaheadc('\n');
 		lexPushLookaheadc(';');
 		}
 	    }
 	else {
 	    lexPushLookaheadc(';');
 	    }
 	}
     }
 
 static char* lexGet1Value() {
     int c;
     lexSkipWhite();
     c = lexLookahead();
     lexClearToken();
     while (c != EOF && c != ';') {
 	if (c == '\n') {
 	    int a;
 	    lexSkipLookahead();
 	    a  = lexLookahead();
 	    if (a == ' ' || a == '\t') {