474 lines
13 KiB
C
474 lines
13 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 1998-2003, 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"
|
|
|
|
#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);
|
|
|
|
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. */
|
|
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);
|
|
|
|
if (c == U_EOF) {
|
|
return U_EOF;
|
|
}
|
|
|
|
switch (c) {
|
|
case SLASH:
|
|
seekUntilNewline(buf, NULL, status);
|
|
break;
|
|
|
|
case ASTERISK:
|
|
c2 = ucbuf_getc(buf, status);
|
|
if(c2== ASTERISK){
|
|
/* parse multi-line comment and store it in token*/
|
|
seekUntilEndOfComment(buf, token, status);
|
|
}else{
|
|
ucbuf_ungetc(c, buf);
|
|
seekUntilEndOfComment(buf, NULL, status);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ucbuf_ungetc(c, buf);
|
|
/* 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");
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|