| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1998-2012, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * |
| * File read.c |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 05/26/99 stephen Creation. |
| * 5/10/01 Ram removed ustdio dependency |
| ******************************************************************************* |
| */ |
| |
| #include "read.h" |
| #include "errmsg.h" |
| #include "unicode/ustring.h" |
| #include "unicode/utf16.h" |
| |
| #define OPENBRACE 0x007B |
| #define CLOSEBRACE 0x007D |
| #define COMMA 0x002C |
| #define QUOTE 0x0022 |
| #define ESCAPE 0x005C |
| #define SLASH 0x002F |
| #define ASTERISK 0x002A |
| #define SPACE 0x0020 |
| #define COLON 0x003A |
| #define BADBOM 0xFFFE |
| #define CR 0x000D |
| #define LF 0x000A |
| |
| static int32_t lineCount; |
| |
| /* Protos */ |
| static enum ETokenType getStringToken(UCHARBUF *buf, |
| UChar32 initialChar, |
| struct UString *token, |
| UErrorCode *status); |
| |
| static UChar32 getNextChar (UCHARBUF *buf, UBool skipwhite, struct UString *token, UErrorCode *status); |
| static void seekUntilNewline (UCHARBUF *buf, struct UString *token, UErrorCode *status); |
| static void seekUntilEndOfComment (UCHARBUF *buf, struct UString *token, UErrorCode *status); |
| static UBool isWhitespace (UChar32 c); |
| static UBool isNewline (UChar32 c); |
| |
| U_CFUNC void resetLineNumber() { |
| lineCount = 1; |
| } |
| |
| /* Read and return the next token from the stream. If the token is of |
| type eString, fill in the token parameter with the token. If the |
| token is eError, then the status parameter will contain the |
| specific error. This will be eItemNotFound at the end of file, |
| indicating that all tokens have been returned. This method will |
| never return eString twice in a row; instead, multiple adjacent |
| string tokens will be merged into one, with no intervening |
| space. */ |
| U_CFUNC enum ETokenType |
| getNextToken(UCHARBUF* buf, |
| struct UString *token, |
| uint32_t *linenumber, /* out: linenumber of token */ |
| struct UString *comment, |
| UErrorCode *status) { |
| enum ETokenType result; |
| UChar32 c; |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| /* Skip whitespace */ |
| c = getNextChar(buf, TRUE, comment, status); |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| *linenumber = lineCount; |
| |
| switch(c) { |
| case BADBOM: |
| return TOK_ERROR; |
| case OPENBRACE: |
| return TOK_OPEN_BRACE; |
| case CLOSEBRACE: |
| return TOK_CLOSE_BRACE; |
| case COMMA: |
| return TOK_COMMA; |
| case U_EOF: |
| return TOK_EOF; |
| case COLON: |
| return TOK_COLON; |
| |
| default: |
| result = getStringToken(buf, c, token, status); |
| } |
| |
| *linenumber = lineCount; |
| return result; |
| } |
| |
| /* Copy a string token into the given UnicodeString. Upon entry, we |
| have already read the first character of the string token, which is |
| not a whitespace character (but may be a QUOTE or ESCAPE). This |
| function reads all subsequent characters that belong with this |
| string, and copy them into the token parameter. The other |
| important, and slightly convoluted purpose of this function is to |
| merge adjacent strings. It looks forward a bit, and if the next |
| non comment, non whitespace item is a string, it reads it in as |
| well. If two adjacent strings are quoted, they are merged without |
| intervening space. Otherwise a single SPACE character is |
| inserted. */ |
| static enum ETokenType getStringToken(UCHARBUF* buf, |
| UChar32 initialChar, |
| struct UString *token, |
| UErrorCode *status) { |
| UBool lastStringWasQuoted; |
| UChar32 c; |
| UChar target[3] = { '\0' }; |
| UChar *pTarget = target; |
| int len=0; |
| UBool isFollowingCharEscaped=FALSE; |
| UBool isNLUnescaped = FALSE; |
| UChar32 prevC=0; |
| |
| /* We are guaranteed on entry that initialChar is not a whitespace |
| character. If we are at the EOF, or have some other problem, it |
| doesn't matter; we still want to validly return the initialChar |
| (if nothing else) as a string token. */ |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| /* setup */ |
| lastStringWasQuoted = FALSE; |
| c = initialChar; |
| ustr_setlen(token, 0, status); |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| for (;;) { |
| if (c == QUOTE) { |
| if (!lastStringWasQuoted && token->fLength > 0) { |
| ustr_ucat(token, SPACE, status); |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| } |
| |
| lastStringWasQuoted = TRUE; |
| |
| for (;;) { |
| c = ucbuf_getc(buf,status); |
| |
| /* EOF reached */ |
| if (c == U_EOF) { |
| return TOK_EOF; |
| } |
| |
| /* Unterminated quoted strings */ |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| if (c == QUOTE && !isFollowingCharEscaped) { |
| break; |
| } |
| |
| if (c == ESCAPE && !isFollowingCharEscaped) { |
| pTarget = target; |
| c = unescape(buf, status); |
| |
| if (c == U_ERR) { |
| return TOK_ERROR; |
| } |
| if(c == CR || c == LF){ |
| isNLUnescaped = TRUE; |
| } |
| } |
| |
| if(c==ESCAPE && !isFollowingCharEscaped){ |
| isFollowingCharEscaped = TRUE; |
| }else{ |
| U_APPEND_CHAR32(c, pTarget,len); |
| pTarget = target; |
| ustr_uscat(token, pTarget,len, status); |
| isFollowingCharEscaped = FALSE; |
| len=0; |
| if(c == CR || c == LF){ |
| if(isNLUnescaped == FALSE && prevC!=CR){ |
| lineCount++; |
| } |
| isNLUnescaped = FALSE; |
| } |
| } |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| prevC = c; |
| } |
| } else { |
| if (token->fLength > 0) { |
| ustr_ucat(token, SPACE, status); |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| } |
| |
| if(lastStringWasQuoted){ |
| if(getShowWarning()){ |
| warning(lineCount, "Mixing quoted and unquoted strings"); |
| } |
| if(isStrict()){ |
| return TOK_ERROR; |
| } |
| |
| } |
| |
| lastStringWasQuoted = FALSE; |
| |
| /* if we reach here we are mixing |
| * quoted and unquoted strings |
| * warn in normal mode and error in |
| * pedantic mode |
| */ |
| |
| if (c == ESCAPE) { |
| pTarget = target; |
| c = unescape(buf, status); |
| |
| /* EOF reached */ |
| if (c == U_EOF) { |
| return TOK_ERROR; |
| } |
| } |
| |
| U_APPEND_CHAR32(c, pTarget,len); |
| pTarget = target; |
| ustr_uscat(token, pTarget,len, status); |
| len=0; |
| |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| |
| for (;;) { |
| /* DON'T skip whitespace */ |
| c = getNextChar(buf, FALSE, NULL, status); |
| |
| /* EOF reached */ |
| if (c == U_EOF) { |
| ucbuf_ungetc(c, buf); |
| return TOK_STRING; |
| } |
| |
| if (U_FAILURE(*status)) { |
| return TOK_STRING; |
| } |
| |
| if (c == QUOTE |
| || c == OPENBRACE |
| || c == CLOSEBRACE |
| || c == COMMA |
| || c == COLON) { |
| ucbuf_ungetc(c, buf); |
| break; |
| } |
| |
| if (isWhitespace(c)) { |
| break; |
| } |
| |
| if (c == ESCAPE) { |
| pTarget = target; |
| c = unescape(buf, status); |
| |
| if (c == U_ERR) { |
| return TOK_ERROR; |
| } |
| } |
| |
| U_APPEND_CHAR32(c, pTarget,len); |
| pTarget = target; |
| ustr_uscat(token, pTarget,len, status); |
| len=0; |
| if (U_FAILURE(*status)) { |
| return TOK_ERROR; |
| } |
| } |
| } |
| |
| /* DO skip whitespace */ |
| c = getNextChar(buf, TRUE, NULL, status); |
| |
| if (U_FAILURE(*status)) { |
| return TOK_STRING; |
| } |
| |
| if (c == OPENBRACE || c == CLOSEBRACE || c == COMMA || c == COLON) { |
| ucbuf_ungetc(c, buf); |
| return TOK_STRING; |
| } |
| } |
| } |
| |
| /* Retrieve the next character. If skipwhite is |
| true, whitespace is skipped as well. */ |
| static UChar32 getNextChar(UCHARBUF* buf, |
| UBool skipwhite, |
| struct UString *token, |
| UErrorCode *status) { |
| UChar32 c, c2; |
| |
| if (U_FAILURE(*status)) { |
| return U_EOF; |
| } |
| |
| for (;;) { |
| c = ucbuf_getc(buf,status); |
| |
| if (c == U_EOF) { |
| return U_EOF; |
| } |
| |
| if (skipwhite && isWhitespace(c)) { |
| continue; |
| } |
| |
| /* This also handles the get() failing case */ |
| if (c != SLASH) { |
| return c; |
| } |
| |
| c = ucbuf_getc(buf,status); /* "/c" */ |
| |
| if (c == U_EOF) { |
| return U_EOF; |
| } |
| |
| switch (c) { |
| case SLASH: /* "//" */ |
| seekUntilNewline(buf, NULL, status); |
| break; |
| |
| case ASTERISK: /* " / * " */ |
| c2 = ucbuf_getc(buf, status); /* "/ * c" */ |
| if(c2 == ASTERISK){ /* "/ * *" */ |
| /* parse multi-line comment and store it in token*/ |
| seekUntilEndOfComment(buf, token, status); |
| } else { |
| ucbuf_ungetc(c2, buf); /* c2 is the non-asterisk following "/ *". Include c2 back in buffer. */ |
| seekUntilEndOfComment(buf, NULL, status); |
| } |
| break; |
| |
| default: |
| ucbuf_ungetc(c, buf); /* "/c" - put back the c */ |
| /* If get() failed this is a NOP */ |
| return SLASH; |
| } |
| |
| } |
| } |
| |
| static void seekUntilNewline(UCHARBUF* buf, |
| struct UString *token, |
| UErrorCode *status) { |
| UChar32 c; |
| |
| if (U_FAILURE(*status)) { |
| return; |
| } |
| |
| do { |
| c = ucbuf_getc(buf,status); |
| /* add the char to token */ |
| if(token!=NULL){ |
| ustr_u32cat(token, c, status); |
| } |
| } while (!isNewline(c) && c != U_EOF && *status == U_ZERO_ERROR); |
| } |
| |
| static void seekUntilEndOfComment(UCHARBUF *buf, |
| struct UString *token, |
| UErrorCode *status) { |
| UChar32 c, d; |
| uint32_t line; |
| |
| if (U_FAILURE(*status)) { |
| return; |
| } |
| |
| line = lineCount; |
| |
| do { |
| c = ucbuf_getc(buf, status); |
| |
| if (c == ASTERISK) { |
| d = ucbuf_getc(buf, status); |
| |
| if (d != SLASH) { |
| ucbuf_ungetc(d, buf); |
| } else { |
| break; |
| } |
| } |
| /* add the char to token */ |
| if(token!=NULL){ |
| ustr_u32cat(token, c, status); |
| } |
| /* increment the lineCount */ |
| isNewline(c); |
| |
| } while (c != U_EOF && *status == U_ZERO_ERROR); |
| |
| if (c == U_EOF) { |
| *status = U_INVALID_FORMAT_ERROR; |
| error(line, "unterminated comment detected"); |
| } |
| } |
| |
| U_CFUNC UChar32 unescape(UCHARBUF *buf, UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return U_EOF; |
| } |
| |
| /* We expect to be called after the ESCAPE has been seen, but |
| * u_fgetcx needs an ESCAPE to do its magic. */ |
| ucbuf_ungetc(ESCAPE, buf); |
| |
| return ucbuf_getcx32(buf, status); |
| } |
| |
| static UBool isWhitespace(UChar32 c) { |
| switch (c) { |
| /* ' ', '\t', '\n', '\r', 0x2029, 0xFEFF */ |
| case 0x000A: |
| case 0x2029: |
| lineCount++; |
| case 0x000D: |
| case 0x0020: |
| case 0x0009: |
| case 0xFEFF: |
| return TRUE; |
| |
| default: |
| return FALSE; |
| } |
| } |
| |
| static UBool isNewline(UChar32 c) { |
| switch (c) { |
| /* '\n', '\r', 0x2029 */ |
| case 0x000A: |
| case 0x2029: |
| lineCount++; |
| case 0x000D: |
| return TRUE; |
| |
| default: |
| return FALSE; |
| } |
| } |
