1733 lines
61 KiB
C++
1733 lines
61 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1999-2008, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
* Date Name Description
|
|
* 11/17/99 aliu Creation.
|
|
**********************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_TRANSLITERATION
|
|
|
|
#include "unicode/uobject.h"
|
|
#include "unicode/parseerr.h"
|
|
#include "unicode/parsepos.h"
|
|
#include "unicode/putil.h"
|
|
#include "unicode/uchar.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/uniset.h"
|
|
#include "cstring.h"
|
|
#include "funcrepl.h"
|
|
#include "hash.h"
|
|
#include "quant.h"
|
|
#include "rbt.h"
|
|
#include "rbt_data.h"
|
|
#include "rbt_pars.h"
|
|
#include "rbt_rule.h"
|
|
#include "strmatch.h"
|
|
#include "strrepl.h"
|
|
#include "unicode/symtable.h"
|
|
#include "tridpars.h"
|
|
#include "uvector.h"
|
|
#include "hash.h"
|
|
#include "util.h"
|
|
#include "cmemory.h"
|
|
#include "uprops.h"
|
|
#include "putilimp.h"
|
|
|
|
// Operators
|
|
#define VARIABLE_DEF_OP ((UChar)0x003D) /*=*/
|
|
#define FORWARD_RULE_OP ((UChar)0x003E) /*>*/
|
|
#define REVERSE_RULE_OP ((UChar)0x003C) /*<*/
|
|
#define FWDREV_RULE_OP ((UChar)0x007E) /*~*/ // internal rep of <> op
|
|
|
|
// Other special characters
|
|
#define QUOTE ((UChar)0x0027) /*'*/
|
|
#define ESCAPE ((UChar)0x005C) /*\*/
|
|
#define END_OF_RULE ((UChar)0x003B) /*;*/
|
|
#define RULE_COMMENT_CHAR ((UChar)0x0023) /*#*/
|
|
|
|
#define SEGMENT_OPEN ((UChar)0x0028) /*(*/
|
|
#define SEGMENT_CLOSE ((UChar)0x0029) /*)*/
|
|
#define CONTEXT_ANTE ((UChar)0x007B) /*{*/
|
|
#define CONTEXT_POST ((UChar)0x007D) /*}*/
|
|
#define CURSOR_POS ((UChar)0x007C) /*|*/
|
|
#define CURSOR_OFFSET ((UChar)0x0040) /*@*/
|
|
#define ANCHOR_START ((UChar)0x005E) /*^*/
|
|
#define KLEENE_STAR ((UChar)0x002A) /***/
|
|
#define ONE_OR_MORE ((UChar)0x002B) /*+*/
|
|
#define ZERO_OR_ONE ((UChar)0x003F) /*?*/
|
|
|
|
#define DOT ((UChar)46) /*.*/
|
|
|
|
static const UChar DOT_SET[] = { // "[^[:Zp:][:Zl:]\r\n$]";
|
|
91, 94, 91, 58, 90, 112, 58, 93, 91, 58, 90,
|
|
108, 58, 93, 92, 114, 92, 110, 36, 93, 0
|
|
};
|
|
|
|
// A function is denoted &Source-Target/Variant(text)
|
|
#define FUNCTION ((UChar)38) /*&*/
|
|
|
|
// Aliases for some of the syntax characters. These are provided so
|
|
// transliteration rules can be expressed in XML without clashing with
|
|
// XML syntax characters '<', '>', and '&'.
|
|
#define ALT_REVERSE_RULE_OP ((UChar)0x2190) // Left Arrow
|
|
#define ALT_FORWARD_RULE_OP ((UChar)0x2192) // Right Arrow
|
|
#define ALT_FWDREV_RULE_OP ((UChar)0x2194) // Left Right Arrow
|
|
#define ALT_FUNCTION ((UChar)0x2206) // Increment (~Greek Capital Delta)
|
|
|
|
// Special characters disallowed at the top level
|
|
static const UChar ILLEGAL_TOP[] = {41,0}; // ")"
|
|
|
|
// Special characters disallowed within a segment
|
|
static const UChar ILLEGAL_SEG[] = {123,125,124,64,0}; // "{}|@"
|
|
|
|
// Special characters disallowed within a function argument
|
|
static const UChar ILLEGAL_FUNC[] = {94,40,46,42,43,63,123,125,124,64,0}; // "^(.*+?{}|@"
|
|
|
|
// By definition, the ANCHOR_END special character is a
|
|
// trailing SymbolTable.SYMBOL_REF character.
|
|
// private static final char ANCHOR_END = '$';
|
|
|
|
static const UChar gOPERATORS[] = { // "=><"
|
|
VARIABLE_DEF_OP, FORWARD_RULE_OP, REVERSE_RULE_OP,
|
|
ALT_FORWARD_RULE_OP, ALT_REVERSE_RULE_OP, ALT_FWDREV_RULE_OP,
|
|
0
|
|
};
|
|
|
|
static const UChar HALF_ENDERS[] = { // "=><;"
|
|
VARIABLE_DEF_OP, FORWARD_RULE_OP, REVERSE_RULE_OP,
|
|
ALT_FORWARD_RULE_OP, ALT_REVERSE_RULE_OP, ALT_FWDREV_RULE_OP,
|
|
END_OF_RULE,
|
|
0
|
|
};
|
|
|
|
// These are also used in Transliterator::toRules()
|
|
static const int32_t ID_TOKEN_LEN = 2;
|
|
static const UChar ID_TOKEN[] = { 0x3A, 0x3A }; // ':', ':'
|
|
|
|
/*
|
|
commented out until we do real ::BEGIN/::END functionality
|
|
static const int32_t BEGIN_TOKEN_LEN = 5;
|
|
static const UChar BEGIN_TOKEN[] = { 0x42, 0x45, 0x47, 0x49, 0x4e }; // 'BEGIN'
|
|
|
|
static const int32_t END_TOKEN_LEN = 3;
|
|
static const UChar END_TOKEN[] = { 0x45, 0x4e, 0x44 }; // 'END'
|
|
*/
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
//----------------------------------------------------------------------
|
|
// BEGIN ParseData
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* This class implements the SymbolTable interface. It is used
|
|
* during parsing to give UnicodeSet access to variables that
|
|
* have been defined so far. Note that it uses variablesVector,
|
|
* _not_ data.setVariables.
|
|
*/
|
|
class ParseData : public UMemory, public SymbolTable {
|
|
public:
|
|
const TransliterationRuleData* data; // alias
|
|
|
|
const UVector* variablesVector; // alias
|
|
|
|
const Hashtable* variableNames; // alias
|
|
|
|
ParseData(const TransliterationRuleData* data = 0,
|
|
const UVector* variablesVector = 0,
|
|
const Hashtable* variableNames = 0);
|
|
|
|
virtual const UnicodeString* lookup(const UnicodeString& s) const;
|
|
|
|
virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const;
|
|
|
|
virtual UnicodeString parseReference(const UnicodeString& text,
|
|
ParsePosition& pos, int32_t limit) const;
|
|
/**
|
|
* Return true if the given character is a matcher standin or a plain
|
|
* character (non standin).
|
|
*/
|
|
UBool isMatcher(UChar32 ch);
|
|
|
|
/**
|
|
* Return true if the given character is a replacer standin or a plain
|
|
* character (non standin).
|
|
*/
|
|
UBool isReplacer(UChar32 ch);
|
|
|
|
private:
|
|
ParseData(const ParseData &other); // forbid copying of this class
|
|
ParseData &operator=(const ParseData &other); // forbid copying of this class
|
|
};
|
|
|
|
ParseData::ParseData(const TransliterationRuleData* d,
|
|
const UVector* sets,
|
|
const Hashtable* vNames) :
|
|
data(d), variablesVector(sets), variableNames(vNames) {}
|
|
|
|
/**
|
|
* Implement SymbolTable API.
|
|
*/
|
|
const UnicodeString* ParseData::lookup(const UnicodeString& name) const {
|
|
return (const UnicodeString*) variableNames->get(name);
|
|
}
|
|
|
|
/**
|
|
* Implement SymbolTable API.
|
|
*/
|
|
const UnicodeFunctor* ParseData::lookupMatcher(UChar32 ch) const {
|
|
// Note that we cannot use data.lookupSet() because the
|
|
// set array has not been constructed yet.
|
|
const UnicodeFunctor* set = NULL;
|
|
int32_t i = ch - data->variablesBase;
|
|
if (i >= 0 && i < variablesVector->size()) {
|
|
int32_t i = ch - data->variablesBase;
|
|
set = (i < variablesVector->size()) ?
|
|
(UnicodeFunctor*) variablesVector->elementAt(i) : 0;
|
|
}
|
|
return set;
|
|
}
|
|
|
|
/**
|
|
* Implement SymbolTable API. Parse out a symbol reference
|
|
* name.
|
|
*/
|
|
UnicodeString ParseData::parseReference(const UnicodeString& text,
|
|
ParsePosition& pos, int32_t limit) const {
|
|
int32_t start = pos.getIndex();
|
|
int32_t i = start;
|
|
UnicodeString result;
|
|
while (i < limit) {
|
|
UChar c = text.charAt(i);
|
|
if ((i==start && !u_isIDStart(c)) || !u_isIDPart(c)) {
|
|
break;
|
|
}
|
|
++i;
|
|
}
|
|
if (i == start) { // No valid name chars
|
|
return result; // Indicate failure with empty string
|
|
}
|
|
pos.setIndex(i);
|
|
text.extractBetween(start, i, result);
|
|
return result;
|
|
}
|
|
|
|
UBool ParseData::isMatcher(UChar32 ch) {
|
|
// Note that we cannot use data.lookup() because the
|
|
// set array has not been constructed yet.
|
|
int32_t i = ch - data->variablesBase;
|
|
if (i >= 0 && i < variablesVector->size()) {
|
|
UnicodeFunctor *f = (UnicodeFunctor*) variablesVector->elementAt(i);
|
|
return f != NULL && f->toMatcher() != NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Return true if the given character is a replacer standin or a plain
|
|
* character (non standin).
|
|
*/
|
|
UBool ParseData::isReplacer(UChar32 ch) {
|
|
// Note that we cannot use data.lookup() because the
|
|
// set array has not been constructed yet.
|
|
int i = ch - data->variablesBase;
|
|
if (i >= 0 && i < variablesVector->size()) {
|
|
UnicodeFunctor *f = (UnicodeFunctor*) variablesVector->elementAt(i);
|
|
return f != NULL && f->toReplacer() != NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// BEGIN RuleHalf
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* A class representing one side of a rule. This class knows how to
|
|
* parse half of a rule. It is tightly coupled to the method
|
|
* RuleBasedTransliterator.Parser.parseRule().
|
|
*/
|
|
class RuleHalf : public UMemory {
|
|
|
|
public:
|
|
|
|
UnicodeString text;
|
|
|
|
int32_t cursor; // position of cursor in text
|
|
int32_t ante; // position of ante context marker '{' in text
|
|
int32_t post; // position of post context marker '}' in text
|
|
|
|
// Record the offset to the cursor either to the left or to the
|
|
// right of the key. This is indicated by characters on the output
|
|
// side that allow the cursor to be positioned arbitrarily within
|
|
// the matching text. For example, abc{def} > | @@@ xyz; changes
|
|
// def to xyz and moves the cursor to before abc. Offset characters
|
|
// must be at the start or end, and they cannot move the cursor past
|
|
// the ante- or postcontext text. Placeholders are only valid in
|
|
// output text. The length of the ante and post context is
|
|
// determined at runtime, because of supplementals and quantifiers.
|
|
int32_t cursorOffset; // only nonzero on output side
|
|
|
|
// Position of first CURSOR_OFFSET on _right_. This will be -1
|
|
// for |@, -2 for |@@, etc., and 1 for @|, 2 for @@|, etc.
|
|
int32_t cursorOffsetPos;
|
|
|
|
UBool anchorStart;
|
|
UBool anchorEnd;
|
|
|
|
/**
|
|
* The segment number from 1..n of the next '(' we see
|
|
* during parsing; 1-based.
|
|
*/
|
|
int32_t nextSegmentNumber;
|
|
|
|
TransliteratorParser& parser;
|
|
|
|
//--------------------------------------------------
|
|
// Methods
|
|
|
|
RuleHalf(TransliteratorParser& parser);
|
|
~RuleHalf();
|
|
|
|
int32_t parse(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status);
|
|
|
|
int32_t parseSection(const UnicodeString& rule, int32_t pos, int32_t limit,
|
|
UnicodeString& buf,
|
|
const UnicodeString& illegal,
|
|
UBool isSegment,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Remove context.
|
|
*/
|
|
void removeContext();
|
|
|
|
/**
|
|
* Return true if this half looks like valid output, that is, does not
|
|
* contain quantifiers or other special input-only elements.
|
|
*/
|
|
UBool isValidOutput(TransliteratorParser& parser);
|
|
|
|
/**
|
|
* Return true if this half looks like valid input, that is, does not
|
|
* contain functions or other special output-only elements.
|
|
*/
|
|
UBool isValidInput(TransliteratorParser& parser);
|
|
|
|
int syntaxError(UErrorCode code,
|
|
const UnicodeString& rule,
|
|
int32_t start,
|
|
UErrorCode& status) {
|
|
return parser.syntaxError(code, rule, start, status);
|
|
}
|
|
|
|
private:
|
|
// Disallowed methods; no impl.
|
|
RuleHalf(const RuleHalf&);
|
|
RuleHalf& operator=(const RuleHalf&);
|
|
};
|
|
|
|
RuleHalf::RuleHalf(TransliteratorParser& p) :
|
|
parser(p)
|
|
{
|
|
cursor = -1;
|
|
ante = -1;
|
|
post = -1;
|
|
cursorOffset = 0;
|
|
cursorOffsetPos = 0;
|
|
anchorStart = anchorEnd = FALSE;
|
|
nextSegmentNumber = 1;
|
|
}
|
|
|
|
RuleHalf::~RuleHalf() {
|
|
}
|
|
|
|
/**
|
|
* Parse one side of a rule, stopping at either the limit,
|
|
* the END_OF_RULE character, or an operator.
|
|
* @return the index after the terminating character, or
|
|
* if limit was reached, limit
|
|
*/
|
|
int32_t RuleHalf::parse(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status) {
|
|
int32_t start = pos;
|
|
text.truncate(0);
|
|
pos = parseSection(rule, pos, limit, text, ILLEGAL_TOP, FALSE, status);
|
|
|
|
if (cursorOffset > 0 && cursor != cursorOffsetPos) {
|
|
return syntaxError(U_MISPLACED_CURSOR_OFFSET, rule, start, status);
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Parse a section of one side of a rule, stopping at either
|
|
* the limit, the END_OF_RULE character, an operator, or a
|
|
* segment close character. This method parses both a
|
|
* top-level rule half and a segment within such a rule half.
|
|
* It calls itself recursively to parse segments and nested
|
|
* segments.
|
|
* @param buf buffer into which to accumulate the rule pattern
|
|
* characters, either literal characters from the rule or
|
|
* standins for UnicodeMatcher objects including segments.
|
|
* @param illegal the set of special characters that is illegal during
|
|
* this parse.
|
|
* @param isSegment if true, then we've already seen a '(' and
|
|
* pos on entry points right after it. Accumulate everything
|
|
* up to the closing ')', put it in a segment matcher object,
|
|
* generate a standin for it, and add the standin to buf. As
|
|
* a side effect, update the segments vector with a reference
|
|
* to the segment matcher. This works recursively for nested
|
|
* segments. If isSegment is false, just accumulate
|
|
* characters into buf.
|
|
* @return the index after the terminating character, or
|
|
* if limit was reached, limit
|
|
*/
|
|
int32_t RuleHalf::parseSection(const UnicodeString& rule, int32_t pos, int32_t limit,
|
|
UnicodeString& buf,
|
|
const UnicodeString& illegal,
|
|
UBool isSegment, UErrorCode& status) {
|
|
int32_t start = pos;
|
|
ParsePosition pp;
|
|
UnicodeString scratch;
|
|
UBool done = FALSE;
|
|
int32_t quoteStart = -1; // Most recent 'single quoted string'
|
|
int32_t quoteLimit = -1;
|
|
int32_t varStart = -1; // Most recent $variableReference
|
|
int32_t varLimit = -1;
|
|
int32_t bufStart = buf.length();
|
|
|
|
while (pos < limit && !done) {
|
|
// Since all syntax characters are in the BMP, fetching
|
|
// 16-bit code units suffices here.
|
|
UChar c = rule.charAt(pos++);
|
|
if (uprv_isRuleWhiteSpace(c)) {
|
|
// Ignore whitespace. Note that this is not Unicode
|
|
// spaces, but Java spaces -- a subset, representing
|
|
// whitespace likely to be seen in code.
|
|
continue;
|
|
}
|
|
if (u_strchr(HALF_ENDERS, c) != NULL) {
|
|
if (isSegment) {
|
|
// Unclosed segment
|
|
return syntaxError(U_UNCLOSED_SEGMENT, rule, start, status);
|
|
}
|
|
break;
|
|
}
|
|
if (anchorEnd) {
|
|
// Text after a presumed end anchor is a syntax err
|
|
return syntaxError(U_MALFORMED_VARIABLE_REFERENCE, rule, start, status);
|
|
}
|
|
if (UnicodeSet::resemblesPattern(rule, pos-1)) {
|
|
pp.setIndex(pos-1); // Backup to opening '['
|
|
buf.append(parser.parseSet(rule, pp, status));
|
|
if (U_FAILURE(status)) {
|
|
return syntaxError(U_MALFORMED_SET, rule, start, status);
|
|
}
|
|
pos = pp.getIndex();
|
|
continue;
|
|
}
|
|
// Handle escapes
|
|
if (c == ESCAPE) {
|
|
if (pos == limit) {
|
|
return syntaxError(U_TRAILING_BACKSLASH, rule, start, status);
|
|
}
|
|
UChar32 escaped = rule.unescapeAt(pos); // pos is already past '\\'
|
|
if (escaped == (UChar32) -1) {
|
|
return syntaxError(U_MALFORMED_UNICODE_ESCAPE, rule, start, status);
|
|
}
|
|
if (!parser.checkVariableRange(escaped)) {
|
|
return syntaxError(U_VARIABLE_RANGE_OVERLAP, rule, start, status);
|
|
}
|
|
buf.append(escaped);
|
|
continue;
|
|
}
|
|
// Handle quoted matter
|
|
if (c == QUOTE) {
|
|
int32_t iq = rule.indexOf(QUOTE, pos);
|
|
if (iq == pos) {
|
|
buf.append(c); // Parse [''] outside quotes as [']
|
|
++pos;
|
|
} else {
|
|
/* This loop picks up a run of quoted text of the
|
|
* form 'aaaa' each time through. If this run
|
|
* hasn't really ended ('aaaa''bbbb') then it keeps
|
|
* looping, each time adding on a new run. When it
|
|
* reaches the final quote it breaks.
|
|
*/
|
|
quoteStart = buf.length();
|
|
for (;;) {
|
|
if (iq < 0) {
|
|
return syntaxError(U_UNTERMINATED_QUOTE, rule, start, status);
|
|
}
|
|
scratch.truncate(0);
|
|
rule.extractBetween(pos, iq, scratch);
|
|
buf.append(scratch);
|
|
pos = iq+1;
|
|
if (pos < limit && rule.charAt(pos) == QUOTE) {
|
|
// Parse [''] inside quotes as [']
|
|
iq = rule.indexOf(QUOTE, pos+1);
|
|
// Continue looping
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
quoteLimit = buf.length();
|
|
|
|
for (iq=quoteStart; iq<quoteLimit; ++iq) {
|
|
if (!parser.checkVariableRange(buf.charAt(iq))) {
|
|
return syntaxError(U_VARIABLE_RANGE_OVERLAP, rule, start, status);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!parser.checkVariableRange(c)) {
|
|
return syntaxError(U_VARIABLE_RANGE_OVERLAP, rule, start, status);
|
|
}
|
|
|
|
if (illegal.indexOf(c) >= 0) {
|
|
syntaxError(U_ILLEGAL_CHARACTER, rule, start, status);
|
|
}
|
|
|
|
switch (c) {
|
|
|
|
//------------------------------------------------------
|
|
// Elements allowed within and out of segments
|
|
//------------------------------------------------------
|
|
case ANCHOR_START:
|
|
if (buf.length() == 0 && !anchorStart) {
|
|
anchorStart = TRUE;
|
|
} else {
|
|
return syntaxError(U_MISPLACED_ANCHOR_START,
|
|
rule, start, status);
|
|
}
|
|
break;
|
|
case SEGMENT_OPEN:
|
|
{
|
|
// bufSegStart is the offset in buf to the first
|
|
// character of the segment we are parsing.
|
|
int32_t bufSegStart = buf.length();
|
|
|
|
// Record segment number now, since nextSegmentNumber
|
|
// will be incremented during the call to parseSection
|
|
// if there are nested segments.
|
|
int32_t segmentNumber = nextSegmentNumber++; // 1-based
|
|
|
|
// Parse the segment
|
|
pos = parseSection(rule, pos, limit, buf, ILLEGAL_SEG, TRUE, status);
|
|
|
|
// After parsing a segment, the relevant characters are
|
|
// in buf, starting at offset bufSegStart. Extract them
|
|
// into a string matcher, and replace them with a
|
|
// standin for that matcher.
|
|
StringMatcher* m =
|
|
new StringMatcher(buf, bufSegStart, buf.length(),
|
|
segmentNumber, *parser.curData);
|
|
if (m == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
|
|
// Record and associate object and segment number
|
|
parser.setSegmentObject(segmentNumber, m, status);
|
|
buf.truncate(bufSegStart);
|
|
buf.append(parser.getSegmentStandin(segmentNumber, status));
|
|
}
|
|
break;
|
|
case FUNCTION:
|
|
case ALT_FUNCTION:
|
|
{
|
|
int32_t iref = pos;
|
|
TransliteratorIDParser::SingleID* single =
|
|
TransliteratorIDParser::parseFilterID(rule, iref);
|
|
// The next character MUST be a segment open
|
|
if (single == NULL ||
|
|
!ICU_Utility::parseChar(rule, iref, SEGMENT_OPEN)) {
|
|
return syntaxError(U_INVALID_FUNCTION, rule, start, status);
|
|
}
|
|
|
|
Transliterator *t = single->createInstance();
|
|
delete single;
|
|
if (t == NULL) {
|
|
return syntaxError(U_INVALID_FUNCTION, rule, start, status);
|
|
}
|
|
|
|
// bufSegStart is the offset in buf to the first
|
|
// character of the segment we are parsing.
|
|
int32_t bufSegStart = buf.length();
|
|
|
|
// Parse the segment
|
|
pos = parseSection(rule, iref, limit, buf, ILLEGAL_FUNC, TRUE, status);
|
|
|
|
// After parsing a segment, the relevant characters are
|
|
// in buf, starting at offset bufSegStart.
|
|
UnicodeString output;
|
|
buf.extractBetween(bufSegStart, buf.length(), output);
|
|
FunctionReplacer *r =
|
|
new FunctionReplacer(t, new StringReplacer(output, parser.curData));
|
|
if (r == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
|
|
// Replace the buffer contents with a stand-in
|
|
buf.truncate(bufSegStart);
|
|
buf.append(parser.generateStandInFor(r, status));
|
|
}
|
|
break;
|
|
case SymbolTable::SYMBOL_REF:
|
|
// Handle variable references and segment references "$1" .. "$9"
|
|
{
|
|
// A variable reference must be followed immediately
|
|
// by a Unicode identifier start and zero or more
|
|
// Unicode identifier part characters, or by a digit
|
|
// 1..9 if it is a segment reference.
|
|
if (pos == limit) {
|
|
// A variable ref character at the end acts as
|
|
// an anchor to the context limit, as in perl.
|
|
anchorEnd = TRUE;
|
|
break;
|
|
}
|
|
// Parse "$1" "$2" .. "$9" .. (no upper limit)
|
|
c = rule.charAt(pos);
|
|
int32_t r = u_digit(c, 10);
|
|
if (r >= 1 && r <= 9) {
|
|
r = ICU_Utility::parseNumber(rule, pos, 10);
|
|
if (r < 0) {
|
|
return syntaxError(U_UNDEFINED_SEGMENT_REFERENCE,
|
|
rule, start, status);
|
|
}
|
|
buf.append(parser.getSegmentStandin(r, status));
|
|
} else {
|
|
pp.setIndex(pos);
|
|
UnicodeString name = parser.parseData->
|
|
parseReference(rule, pp, limit);
|
|
if (name.length() == 0) {
|
|
// This means the '$' was not followed by a
|
|
// valid name. Try to interpret it as an
|
|
// end anchor then. If this also doesn't work
|
|
// (if we see a following character) then signal
|
|
// an error.
|
|
anchorEnd = TRUE;
|
|
break;
|
|
}
|
|
pos = pp.getIndex();
|
|
// If this is a variable definition statement,
|
|
// then the LHS variable will be undefined. In
|
|
// that case appendVariableDef() will append the
|
|
// special placeholder char variableLimit-1.
|
|
varStart = buf.length();
|
|
parser.appendVariableDef(name, buf, status);
|
|
varLimit = buf.length();
|
|
}
|
|
}
|
|
break;
|
|
case DOT:
|
|
buf.append(parser.getDotStandIn(status));
|
|
break;
|
|
case KLEENE_STAR:
|
|
case ONE_OR_MORE:
|
|
case ZERO_OR_ONE:
|
|
// Quantifiers. We handle single characters, quoted strings,
|
|
// variable references, and segments.
|
|
// a+ matches aaa
|
|
// 'foo'+ matches foofoofoo
|
|
// $v+ matches xyxyxy if $v == xy
|
|
// (seg)+ matches segsegseg
|
|
{
|
|
if (isSegment && buf.length() == bufStart) {
|
|
// The */+ immediately follows '('
|
|
return syntaxError(U_MISPLACED_QUANTIFIER, rule, start, status);
|
|
}
|
|
|
|
int32_t qstart, qlimit;
|
|
// The */+ follows an isolated character or quote
|
|
// or variable reference
|
|
if (buf.length() == quoteLimit) {
|
|
// The */+ follows a 'quoted string'
|
|
qstart = quoteStart;
|
|
qlimit = quoteLimit;
|
|
} else if (buf.length() == varLimit) {
|
|
// The */+ follows a $variableReference
|
|
qstart = varStart;
|
|
qlimit = varLimit;
|
|
} else {
|
|
// The */+ follows a single character, possibly
|
|
// a segment standin
|
|
qstart = buf.length() - 1;
|
|
qlimit = qstart + 1;
|
|
}
|
|
|
|
UnicodeFunctor *m =
|
|
new StringMatcher(buf, qstart, qlimit, 0, *parser.curData);
|
|
if (m == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
int32_t min = 0;
|
|
int32_t max = Quantifier::MAX;
|
|
switch (c) {
|
|
case ONE_OR_MORE:
|
|
min = 1;
|
|
break;
|
|
case ZERO_OR_ONE:
|
|
min = 0;
|
|
max = 1;
|
|
break;
|
|
// case KLEENE_STAR:
|
|
// do nothing -- min, max already set
|
|
}
|
|
m = new Quantifier(m, min, max);
|
|
if (m == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
buf.truncate(qstart);
|
|
buf.append(parser.generateStandInFor(m, status));
|
|
}
|
|
break;
|
|
|
|
//------------------------------------------------------
|
|
// Elements allowed ONLY WITHIN segments
|
|
//------------------------------------------------------
|
|
case SEGMENT_CLOSE:
|
|
// assert(isSegment);
|
|
// We're done parsing a segment.
|
|
done = TRUE;
|
|
break;
|
|
|
|
//------------------------------------------------------
|
|
// Elements allowed ONLY OUTSIDE segments
|
|
//------------------------------------------------------
|
|
case CONTEXT_ANTE:
|
|
if (ante >= 0) {
|
|
return syntaxError(U_MULTIPLE_ANTE_CONTEXTS, rule, start, status);
|
|
}
|
|
ante = buf.length();
|
|
break;
|
|
case CONTEXT_POST:
|
|
if (post >= 0) {
|
|
return syntaxError(U_MULTIPLE_POST_CONTEXTS, rule, start, status);
|
|
}
|
|
post = buf.length();
|
|
break;
|
|
case CURSOR_POS:
|
|
if (cursor >= 0) {
|
|
return syntaxError(U_MULTIPLE_CURSORS, rule, start, status);
|
|
}
|
|
cursor = buf.length();
|
|
break;
|
|
case CURSOR_OFFSET:
|
|
if (cursorOffset < 0) {
|
|
if (buf.length() > 0) {
|
|
return syntaxError(U_MISPLACED_CURSOR_OFFSET, rule, start, status);
|
|
}
|
|
--cursorOffset;
|
|
} else if (cursorOffset > 0) {
|
|
if (buf.length() != cursorOffsetPos || cursor >= 0) {
|
|
return syntaxError(U_MISPLACED_CURSOR_OFFSET, rule, start, status);
|
|
}
|
|
++cursorOffset;
|
|
} else {
|
|
if (cursor == 0 && buf.length() == 0) {
|
|
cursorOffset = -1;
|
|
} else if (cursor < 0) {
|
|
cursorOffsetPos = buf.length();
|
|
cursorOffset = 1;
|
|
} else {
|
|
return syntaxError(U_MISPLACED_CURSOR_OFFSET, rule, start, status);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
//------------------------------------------------------
|
|
// Non-special characters
|
|
//------------------------------------------------------
|
|
default:
|
|
// Disallow unquoted characters other than [0-9A-Za-z]
|
|
// in the printable ASCII range. These characters are
|
|
// reserved for possible future use.
|
|
if (c >= 0x0021 && c <= 0x007E &&
|
|
!((c >= 0x0030/*'0'*/ && c <= 0x0039/*'9'*/) ||
|
|
(c >= 0x0041/*'A'*/ && c <= 0x005A/*'Z'*/) ||
|
|
(c >= 0x0061/*'a'*/ && c <= 0x007A/*'z'*/))) {
|
|
return syntaxError(U_UNQUOTED_SPECIAL, rule, start, status);
|
|
}
|
|
buf.append(c);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Remove context.
|
|
*/
|
|
void RuleHalf::removeContext() {
|
|
//text = text.substring(ante < 0 ? 0 : ante,
|
|
// post < 0 ? text.length() : post);
|
|
if (post >= 0) {
|
|
text.remove(post);
|
|
}
|
|
if (ante >= 0) {
|
|
text.removeBetween(0, ante);
|
|
}
|
|
ante = post = -1;
|
|
anchorStart = anchorEnd = FALSE;
|
|
}
|
|
|
|
/**
|
|
* Return true if this half looks like valid output, that is, does not
|
|
* contain quantifiers or other special input-only elements.
|
|
*/
|
|
UBool RuleHalf::isValidOutput(TransliteratorParser& transParser) {
|
|
for (int32_t i=0; i<text.length(); ) {
|
|
UChar32 c = text.char32At(i);
|
|
i += UTF_CHAR_LENGTH(c);
|
|
if (!transParser.parseData->isReplacer(c)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Return true if this half looks like valid input, that is, does not
|
|
* contain functions or other special output-only elements.
|
|
*/
|
|
UBool RuleHalf::isValidInput(TransliteratorParser& transParser) {
|
|
for (int32_t i=0; i<text.length(); ) {
|
|
UChar32 c = text.char32At(i);
|
|
i += UTF_CHAR_LENGTH(c);
|
|
if (!transParser.parseData->isMatcher(c)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PUBLIC API
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
TransliteratorParser::TransliteratorParser(UErrorCode &statusReturn) :
|
|
dataVector(statusReturn),
|
|
idBlockVector(statusReturn),
|
|
variablesVector(statusReturn),
|
|
segmentObjects(statusReturn)
|
|
{
|
|
idBlockVector.setDeleter(uhash_deleteUnicodeString);
|
|
curData = NULL;
|
|
compoundFilter = NULL;
|
|
parseData = NULL;
|
|
variableNames.setValueDeleter(uhash_deleteUnicodeString);
|
|
}
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
TransliteratorParser::~TransliteratorParser() {
|
|
while (!dataVector.isEmpty())
|
|
delete (TransliterationRuleData*)(dataVector.orphanElementAt(0));
|
|
delete compoundFilter;
|
|
delete parseData;
|
|
while (!variablesVector.isEmpty())
|
|
delete (UnicodeFunctor*)variablesVector.orphanElementAt(0);
|
|
}
|
|
|
|
void
|
|
TransliteratorParser::parse(const UnicodeString& rules,
|
|
UTransDirection transDirection,
|
|
UParseError& pe,
|
|
UErrorCode& ec) {
|
|
if (U_SUCCESS(ec)) {
|
|
parseRules(rules, transDirection, ec);
|
|
pe = parseError;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the compound filter parsed by parse(). Caller owns result.
|
|
*/
|
|
UnicodeSet* TransliteratorParser::orphanCompoundFilter() {
|
|
UnicodeSet* f = compoundFilter;
|
|
compoundFilter = NULL;
|
|
return f;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Private implementation
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* Parse the given string as a sequence of rules, separated by newline
|
|
* characters ('\n'), and cause this object to implement those rules. Any
|
|
* previous rules are discarded. Typically this method is called exactly
|
|
* once, during construction.
|
|
* @exception IllegalArgumentException if there is a syntax error in the
|
|
* rules
|
|
*/
|
|
void TransliteratorParser::parseRules(const UnicodeString& rule,
|
|
UTransDirection theDirection,
|
|
UErrorCode& status)
|
|
{
|
|
// Clear error struct
|
|
uprv_memset(&parseError, 0, sizeof(parseError));
|
|
parseError.line = parseError.offset = -1;
|
|
|
|
UBool parsingIDs = TRUE;
|
|
int32_t ruleCount = 0;
|
|
|
|
while (!dataVector.isEmpty()) {
|
|
delete (TransliterationRuleData*)(dataVector.orphanElementAt(0));
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
|
|
idBlockVector.removeAllElements();
|
|
curData = NULL;
|
|
direction = theDirection;
|
|
ruleCount = 0;
|
|
|
|
delete compoundFilter;
|
|
compoundFilter = NULL;
|
|
|
|
while (!variablesVector.isEmpty()) {
|
|
delete (UnicodeFunctor*)variablesVector.orphanElementAt(0);
|
|
}
|
|
variableNames.removeAll();
|
|
parseData = new ParseData(0, &variablesVector, &variableNames);
|
|
if (parseData == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
|
|
dotStandIn = (UChar) -1;
|
|
|
|
UnicodeString *tempstr = NULL; // used for memory allocation error checking
|
|
UnicodeString str; // scratch
|
|
UnicodeString idBlockResult;
|
|
int32_t pos = 0;
|
|
int32_t limit = rule.length();
|
|
|
|
// The compound filter offset is an index into idBlockResult.
|
|
// If it is 0, then the compound filter occurred at the start,
|
|
// and it is the offset to the _start_ of the compound filter
|
|
// pattern. Otherwise it is the offset to the _limit_ of the
|
|
// compound filter pattern within idBlockResult.
|
|
compoundFilter = NULL;
|
|
int32_t compoundFilterOffset = -1;
|
|
|
|
while (pos < limit && U_SUCCESS(status)) {
|
|
UChar c = rule.charAt(pos++);
|
|
if (uprv_isRuleWhiteSpace(c)) {
|
|
// Ignore leading whitespace.
|
|
continue;
|
|
}
|
|
// Skip lines starting with the comment character
|
|
if (c == RULE_COMMENT_CHAR) {
|
|
pos = rule.indexOf((UChar)0x000A /*\n*/, pos) + 1;
|
|
if (pos == 0) {
|
|
break; // No "\n" found; rest of rule is a commnet
|
|
}
|
|
continue; // Either fall out or restart with next line
|
|
}
|
|
|
|
// skip empty rules
|
|
if (c == END_OF_RULE)
|
|
continue;
|
|
|
|
// keep track of how many rules we've seen
|
|
++ruleCount;
|
|
|
|
// We've found the start of a rule or ID. c is its first
|
|
// character, and pos points past c.
|
|
--pos;
|
|
// Look for an ID token. Must have at least ID_TOKEN_LEN + 1
|
|
// chars left.
|
|
if ((pos + ID_TOKEN_LEN + 1) <= limit &&
|
|
rule.compare(pos, ID_TOKEN_LEN, ID_TOKEN) == 0) {
|
|
pos += ID_TOKEN_LEN;
|
|
c = rule.charAt(pos);
|
|
while (uprv_isRuleWhiteSpace(c) && pos < limit) {
|
|
++pos;
|
|
c = rule.charAt(pos);
|
|
}
|
|
|
|
int32_t p = pos;
|
|
|
|
if (!parsingIDs) {
|
|
if (curData != NULL) {
|
|
if (direction == UTRANS_FORWARD)
|
|
dataVector.addElement(curData, status);
|
|
else
|
|
dataVector.insertElementAt(curData, 0, status);
|
|
curData = NULL;
|
|
}
|
|
parsingIDs = TRUE;
|
|
}
|
|
|
|
TransliteratorIDParser::SingleID* id =
|
|
TransliteratorIDParser::parseSingleID(rule, p, direction, status);
|
|
if (p != pos && ICU_Utility::parseChar(rule, p, END_OF_RULE)) {
|
|
// Successful ::ID parse.
|
|
|
|
if (direction == UTRANS_FORWARD) {
|
|
idBlockResult.append(id->canonID).append(END_OF_RULE);
|
|
} else {
|
|
idBlockResult.insert(0, END_OF_RULE);
|
|
idBlockResult.insert(0, id->canonID);
|
|
}
|
|
|
|
} else {
|
|
// Couldn't parse an ID. Try to parse a global filter
|
|
int32_t withParens = -1;
|
|
UnicodeSet* f = TransliteratorIDParser::parseGlobalFilter(rule, p, direction, withParens, NULL);
|
|
if (f != NULL) {
|
|
if (ICU_Utility::parseChar(rule, p, END_OF_RULE)
|
|
&& (direction == UTRANS_FORWARD) == (withParens == 0))
|
|
{
|
|
if (compoundFilter != NULL) {
|
|
// Multiple compound filters
|
|
syntaxError(U_MULTIPLE_COMPOUND_FILTERS, rule, pos, status);
|
|
delete f;
|
|
} else {
|
|
compoundFilter = f;
|
|
compoundFilterOffset = ruleCount;
|
|
}
|
|
} else {
|
|
delete f;
|
|
}
|
|
} else {
|
|
// Invalid ::id
|
|
// Can be parsed as neither an ID nor a global filter
|
|
syntaxError(U_INVALID_ID, rule, pos, status);
|
|
}
|
|
}
|
|
delete id;
|
|
pos = p;
|
|
} else {
|
|
if (parsingIDs) {
|
|
tempstr = new UnicodeString(idBlockResult);
|
|
// NULL pointer check
|
|
if (tempstr == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
if (direction == UTRANS_FORWARD)
|
|
idBlockVector.addElement(tempstr, status);
|
|
else
|
|
idBlockVector.insertElementAt(tempstr, 0, status);
|
|
idBlockResult.remove();
|
|
parsingIDs = FALSE;
|
|
curData = new TransliterationRuleData(status);
|
|
// NULL pointer check
|
|
if (curData == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
parseData->data = curData;
|
|
|
|
// By default, rules use part of the private use area
|
|
// E000..F8FF for variables and other stand-ins. Currently
|
|
// the range F000..F8FF is typically sufficient. The 'use
|
|
// variable range' pragma allows rule sets to modify this.
|
|
setVariableRange(0xF000, 0xF8FF, status);
|
|
}
|
|
|
|
if (resemblesPragma(rule, pos, limit)) {
|
|
int32_t ppp = parsePragma(rule, pos, limit, status);
|
|
if (ppp < 0) {
|
|
syntaxError(U_MALFORMED_PRAGMA, rule, pos, status);
|
|
}
|
|
pos = ppp;
|
|
// Parse a rule
|
|
} else {
|
|
pos = parseRule(rule, pos, limit, status);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (parsingIDs && idBlockResult.length() > 0) {
|
|
tempstr = new UnicodeString(idBlockResult);
|
|
// NULL pointer check
|
|
if (tempstr == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
if (direction == UTRANS_FORWARD)
|
|
idBlockVector.addElement(tempstr, status);
|
|
else
|
|
idBlockVector.insertElementAt(tempstr, 0, status);
|
|
}
|
|
else if (!parsingIDs && curData != NULL) {
|
|
if (direction == UTRANS_FORWARD)
|
|
dataVector.addElement(curData, status);
|
|
else
|
|
dataVector.insertElementAt(curData, 0, status);
|
|
}
|
|
|
|
if (U_SUCCESS(status)) {
|
|
// Convert the set vector to an array
|
|
int32_t i, dataVectorSize = dataVector.size();
|
|
for (i = 0; i < dataVectorSize; i++) {
|
|
TransliterationRuleData* data = (TransliterationRuleData*)dataVector.elementAt(i);
|
|
data->variablesLength = variablesVector.size();
|
|
if (data->variablesLength == 0) {
|
|
data->variables = 0;
|
|
} else {
|
|
data->variables = (UnicodeFunctor**)uprv_malloc(data->variablesLength * sizeof(UnicodeFunctor*));
|
|
// NULL pointer check
|
|
if (data->variables == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
data->variablesAreOwned = (i == 0);
|
|
}
|
|
|
|
for (int32_t j = 0; j < data->variablesLength; j++) {
|
|
data->variables[j] =
|
|
((UnicodeSet*)variablesVector.elementAt(j));
|
|
}
|
|
|
|
data->variableNames.removeAll();
|
|
int32_t pos = -1;
|
|
const UHashElement* he = variableNames.nextElement(pos);
|
|
while (he != NULL) {
|
|
UnicodeString* tempus = (UnicodeString*)(((UnicodeString*)(he->value.pointer))->clone());
|
|
if (tempus == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
data->variableNames.put(*((UnicodeString*)(he->key.pointer)),
|
|
tempus, status);
|
|
he = variableNames.nextElement(pos);
|
|
}
|
|
}
|
|
variablesVector.removeAllElements(); // keeps them from getting deleted when we succeed
|
|
|
|
// Index the rules
|
|
if (compoundFilter != NULL) {
|
|
if ((direction == UTRANS_FORWARD && compoundFilterOffset != 1) ||
|
|
(direction == UTRANS_REVERSE && compoundFilterOffset != ruleCount)) {
|
|
status = U_MISPLACED_COMPOUND_FILTER;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < dataVectorSize; i++) {
|
|
TransliterationRuleData* data = (TransliterationRuleData*)dataVector.elementAt(i);
|
|
data->ruleSet.freeze(parseError, status);
|
|
}
|
|
if (idBlockVector.size() == 1 && ((UnicodeString*)idBlockVector.elementAt(0))->isEmpty()) {
|
|
idBlockVector.removeElementAt(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the variable range to [start, end] (inclusive).
|
|
*/
|
|
void TransliteratorParser::setVariableRange(int32_t start, int32_t end, UErrorCode& status) {
|
|
if (start > end || start < 0 || end > 0xFFFF) {
|
|
status = U_MALFORMED_PRAGMA;
|
|
return;
|
|
}
|
|
|
|
curData->variablesBase = (UChar) start;
|
|
if (dataVector.size() == 0) {
|
|
variableNext = (UChar) start;
|
|
variableLimit = (UChar) (end + 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assert that the given character is NOT within the variable range.
|
|
* If it is, return FALSE. This is neccesary to ensure that the
|
|
* variable range does not overlap characters used in a rule.
|
|
*/
|
|
UBool TransliteratorParser::checkVariableRange(UChar32 ch) const {
|
|
return !(ch >= curData->variablesBase && ch < variableLimit);
|
|
}
|
|
|
|
/**
|
|
* Set the maximum backup to 'backup', in response to a pragma
|
|
* statement.
|
|
*/
|
|
void TransliteratorParser::pragmaMaximumBackup(int32_t /*backup*/) {
|
|
//TODO Finish
|
|
}
|
|
|
|
/**
|
|
* Begin normalizing all rules using the given mode, in response
|
|
* to a pragma statement.
|
|
*/
|
|
void TransliteratorParser::pragmaNormalizeRules(UNormalizationMode /*mode*/) {
|
|
//TODO Finish
|
|
}
|
|
|
|
static const UChar PRAGMA_USE[] = {0x75,0x73,0x65,0x20,0}; // "use "
|
|
|
|
static const UChar PRAGMA_VARIABLE_RANGE[] = {0x7E,0x76,0x61,0x72,0x69,0x61,0x62,0x6C,0x65,0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x23,0x20,0x23,0x7E,0x3B,0}; // "~variable range # #~;"
|
|
|
|
static const UChar PRAGMA_MAXIMUM_BACKUP[] = {0x7E,0x6D,0x61,0x78,0x69,0x6D,0x75,0x6D,0x20,0x62,0x61,0x63,0x6B,0x75,0x70,0x20,0x23,0x7E,0x3B,0}; // "~maximum backup #~;"
|
|
|
|
static const UChar PRAGMA_NFD_RULES[] = {0x7E,0x6E,0x66,0x64,0x20,0x72,0x75,0x6C,0x65,0x73,0x7E,0x3B,0}; // "~nfd rules~;"
|
|
|
|
static const UChar PRAGMA_NFC_RULES[] = {0x7E,0x6E,0x66,0x63,0x20,0x72,0x75,0x6C,0x65,0x73,0x7E,0x3B,0}; // "~nfc rules~;"
|
|
|
|
/**
|
|
* Return true if the given rule looks like a pragma.
|
|
* @param pos offset to the first non-whitespace character
|
|
* of the rule.
|
|
* @param limit pointer past the last character of the rule.
|
|
*/
|
|
UBool TransliteratorParser::resemblesPragma(const UnicodeString& rule, int32_t pos, int32_t limit) {
|
|
// Must start with /use\s/i
|
|
return ICU_Utility::parsePattern(rule, pos, limit, PRAGMA_USE, NULL) >= 0;
|
|
}
|
|
|
|
/**
|
|
* Parse a pragma. This method assumes resemblesPragma() has
|
|
* already returned true.
|
|
* @param pos offset to the first non-whitespace character
|
|
* of the rule.
|
|
* @param limit pointer past the last character of the rule.
|
|
* @return the position index after the final ';' of the pragma,
|
|
* or -1 on failure.
|
|
*/
|
|
int32_t TransliteratorParser::parsePragma(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status) {
|
|
int32_t array[2];
|
|
|
|
// resemblesPragma() has already returned true, so we
|
|
// know that pos points to /use\s/i; we can skip 4 characters
|
|
// immediately
|
|
pos += 4;
|
|
|
|
// Here are the pragmas we recognize:
|
|
// use variable range 0xE000 0xEFFF;
|
|
// use maximum backup 16;
|
|
// use nfd rules;
|
|
// use nfc rules;
|
|
int p = ICU_Utility::parsePattern(rule, pos, limit, PRAGMA_VARIABLE_RANGE, array);
|
|
if (p >= 0) {
|
|
setVariableRange(array[0], array[1], status);
|
|
return p;
|
|
}
|
|
|
|
p = ICU_Utility::parsePattern(rule, pos, limit, PRAGMA_MAXIMUM_BACKUP, array);
|
|
if (p >= 0) {
|
|
pragmaMaximumBackup(array[0]);
|
|
return p;
|
|
}
|
|
|
|
p = ICU_Utility::parsePattern(rule, pos, limit, PRAGMA_NFD_RULES, NULL);
|
|
if (p >= 0) {
|
|
pragmaNormalizeRules(UNORM_NFD);
|
|
return p;
|
|
}
|
|
|
|
p = ICU_Utility::parsePattern(rule, pos, limit, PRAGMA_NFC_RULES, NULL);
|
|
if (p >= 0) {
|
|
pragmaNormalizeRules(UNORM_NFC);
|
|
return p;
|
|
}
|
|
|
|
// Syntax error: unable to parse pragma
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* MAIN PARSER. Parse the next rule in the given rule string, starting
|
|
* at pos. Return the index after the last character parsed. Do not
|
|
* parse characters at or after limit.
|
|
*
|
|
* Important: The character at pos must be a non-whitespace character
|
|
* that is not the comment character.
|
|
*
|
|
* This method handles quoting, escaping, and whitespace removal. It
|
|
* parses the end-of-rule character. It recognizes context and cursor
|
|
* indicators. Once it does a lexical breakdown of the rule at pos, it
|
|
* creates a rule object and adds it to our rule list.
|
|
*/
|
|
int32_t TransliteratorParser::parseRule(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status) {
|
|
// Locate the left side, operator, and right side
|
|
int32_t start = pos;
|
|
UChar op = 0;
|
|
int32_t i;
|
|
|
|
// Set up segments data
|
|
segmentStandins.truncate(0);
|
|
segmentObjects.removeAllElements();
|
|
|
|
// Use pointers to automatics to make swapping possible.
|
|
RuleHalf _left(*this), _right(*this);
|
|
RuleHalf* left = &_left;
|
|
RuleHalf* right = &_right;
|
|
|
|
undefinedVariableName.remove();
|
|
pos = left->parse(rule, pos, limit, status);
|
|
if (U_FAILURE(status)) {
|
|
return start;
|
|
}
|
|
|
|
if (pos == limit || u_strchr(gOPERATORS, (op = rule.charAt(--pos))) == NULL) {
|
|
return syntaxError(U_MISSING_OPERATOR, rule, start, status);
|
|
}
|
|
++pos;
|
|
|
|
// Found an operator char. Check for forward-reverse operator.
|
|
if (op == REVERSE_RULE_OP &&
|
|
(pos < limit && rule.charAt(pos) == FORWARD_RULE_OP)) {
|
|
++pos;
|
|
op = FWDREV_RULE_OP;
|
|
}
|
|
|
|
// Translate alternate op characters.
|
|
switch (op) {
|
|
case ALT_FORWARD_RULE_OP:
|
|
op = FORWARD_RULE_OP;
|
|
break;
|
|
case ALT_REVERSE_RULE_OP:
|
|
op = REVERSE_RULE_OP;
|
|
break;
|
|
case ALT_FWDREV_RULE_OP:
|
|
op = FWDREV_RULE_OP;
|
|
break;
|
|
}
|
|
|
|
pos = right->parse(rule, pos, limit, status);
|
|
if (U_FAILURE(status)) {
|
|
return start;
|
|
}
|
|
|
|
if (pos < limit) {
|
|
if (rule.charAt(--pos) == END_OF_RULE) {
|
|
++pos;
|
|
} else {
|
|
// RuleHalf parser must have terminated at an operator
|
|
return syntaxError(U_UNQUOTED_SPECIAL, rule, start, status);
|
|
}
|
|
}
|
|
|
|
if (op == VARIABLE_DEF_OP) {
|
|
// LHS is the name. RHS is a single character, either a literal
|
|
// or a set (already parsed). If RHS is longer than one
|
|
// character, it is either a multi-character string, or multiple
|
|
// sets, or a mixture of chars and sets -- syntax error.
|
|
|
|
// We expect to see a single undefined variable (the one being
|
|
// defined).
|
|
if (undefinedVariableName.length() == 0) {
|
|
// "Missing '$' or duplicate definition"
|
|
return syntaxError(U_BAD_VARIABLE_DEFINITION, rule, start, status);
|
|
}
|
|
if (left->text.length() != 1 || left->text.charAt(0) != variableLimit) {
|
|
// "Malformed LHS"
|
|
return syntaxError(U_MALFORMED_VARIABLE_DEFINITION, rule, start, status);
|
|
}
|
|
if (left->anchorStart || left->anchorEnd ||
|
|
right->anchorStart || right->anchorEnd) {
|
|
return syntaxError(U_MALFORMED_VARIABLE_DEFINITION, rule, start, status);
|
|
}
|
|
// We allow anything on the right, including an empty string.
|
|
UnicodeString* value = new UnicodeString(right->text);
|
|
// NULL pointer check
|
|
if (value == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
variableNames.put(undefinedVariableName, value, status);
|
|
++variableLimit;
|
|
return pos;
|
|
}
|
|
|
|
// If this is not a variable definition rule, we shouldn't have
|
|
// any undefined variable names.
|
|
if (undefinedVariableName.length() != 0) {
|
|
return syntaxError(// "Undefined variable $" + undefinedVariableName,
|
|
U_UNDEFINED_VARIABLE,
|
|
rule, start, status);
|
|
}
|
|
|
|
// Verify segments
|
|
if (segmentStandins.length() > segmentObjects.size()) {
|
|
syntaxError(U_UNDEFINED_SEGMENT_REFERENCE, rule, start, status);
|
|
}
|
|
for (i=0; i<segmentStandins.length(); ++i) {
|
|
if (segmentStandins.charAt(i) == 0) {
|
|
syntaxError(U_INTERNAL_TRANSLITERATOR_ERROR, rule, start, status); // will never happen
|
|
}
|
|
}
|
|
for (i=0; i<segmentObjects.size(); ++i) {
|
|
if (segmentObjects.elementAt(i) == NULL) {
|
|
syntaxError(U_INTERNAL_TRANSLITERATOR_ERROR, rule, start, status); // will never happen
|
|
}
|
|
}
|
|
|
|
// If the direction we want doesn't match the rule
|
|
// direction, do nothing.
|
|
if (op != FWDREV_RULE_OP &&
|
|
((direction == UTRANS_FORWARD) != (op == FORWARD_RULE_OP))) {
|
|
return pos;
|
|
}
|
|
|
|
// Transform the rule into a forward rule by swapping the
|
|
// sides if necessary.
|
|
if (direction == UTRANS_REVERSE) {
|
|
left = &_right;
|
|
right = &_left;
|
|
}
|
|
|
|
// Remove non-applicable elements in forward-reverse
|
|
// rules. Bidirectional rules ignore elements that do not
|
|
// apply.
|
|
if (op == FWDREV_RULE_OP) {
|
|
right->removeContext();
|
|
left->cursor = -1;
|
|
left->cursorOffset = 0;
|
|
}
|
|
|
|
// Normalize context
|
|
if (left->ante < 0) {
|
|
left->ante = 0;
|
|
}
|
|
if (left->post < 0) {
|
|
left->post = left->text.length();
|
|
}
|
|
|
|
// Context is only allowed on the input side. Cursors are only
|
|
// allowed on the output side. Segment delimiters can only appear
|
|
// on the left, and references on the right. Cursor offset
|
|
// cannot appear without an explicit cursor. Cursor offset
|
|
// cannot place the cursor outside the limits of the context.
|
|
// Anchors are only allowed on the input side.
|
|
if (right->ante >= 0 || right->post >= 0 || left->cursor >= 0 ||
|
|
(right->cursorOffset != 0 && right->cursor < 0) ||
|
|
// - The following two checks were used to ensure that the
|
|
// - the cursor offset stayed within the ante- or postcontext.
|
|
// - However, with the addition of quantifiers, we have to
|
|
// - allow arbitrary cursor offsets and do runtime checking.
|
|
//(right->cursorOffset > (left->text.length() - left->post)) ||
|
|
//(-right->cursorOffset > left->ante) ||
|
|
right->anchorStart || right->anchorEnd ||
|
|
!left->isValidInput(*this) || !right->isValidOutput(*this) ||
|
|
left->ante > left->post) {
|
|
|
|
return syntaxError(U_MALFORMED_RULE, rule, start, status);
|
|
}
|
|
|
|
// Flatten segment objects vector to an array
|
|
UnicodeFunctor** segmentsArray = NULL;
|
|
if (segmentObjects.size() > 0) {
|
|
segmentsArray = (UnicodeFunctor **)uprv_malloc(segmentObjects.size() * sizeof(UnicodeFunctor *));
|
|
// Null pointer check
|
|
if (segmentsArray == NULL) {
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
segmentObjects.toArray((void**) segmentsArray);
|
|
}
|
|
TransliterationRule* temptr = new TransliterationRule(
|
|
left->text, left->ante, left->post,
|
|
right->text, right->cursor, right->cursorOffset,
|
|
segmentsArray,
|
|
segmentObjects.size(),
|
|
left->anchorStart, left->anchorEnd,
|
|
curData,
|
|
status);
|
|
//Null pointer check
|
|
if (temptr == NULL) {
|
|
uprv_free(segmentsArray);
|
|
return syntaxError(U_MEMORY_ALLOCATION_ERROR, rule, start, status);
|
|
}
|
|
|
|
curData->ruleSet.addRule(temptr, status);
|
|
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Called by main parser upon syntax error. Search the rule string
|
|
* for the probable end of the rule. Of course, if the error is that
|
|
* the end of rule marker is missing, then the rule end will not be found.
|
|
* In any case the rule start will be correctly reported.
|
|
* @param msg error description
|
|
* @param rule pattern string
|
|
* @param start position of first character of current rule
|
|
*/
|
|
int32_t TransliteratorParser::syntaxError(UErrorCode parseErrorCode,
|
|
const UnicodeString& rule,
|
|
int32_t pos,
|
|
UErrorCode& status)
|
|
{
|
|
parseError.offset = pos;
|
|
parseError.line = 0 ; /* we are not using line numbers */
|
|
|
|
// for pre-context
|
|
const int32_t LEN = U_PARSE_CONTEXT_LEN - 1;
|
|
int32_t start = uprv_max(pos - LEN, 0);
|
|
int32_t stop = pos;
|
|
|
|
rule.extract(start,stop-start,parseError.preContext);
|
|
//null terminate the buffer
|
|
parseError.preContext[stop-start] = 0;
|
|
|
|
//for post-context
|
|
start = pos;
|
|
stop = uprv_min(pos + LEN, rule.length());
|
|
|
|
rule.extract(start,stop-start,parseError.postContext);
|
|
//null terminate the buffer
|
|
parseError.postContext[stop-start]= 0;
|
|
|
|
status = (UErrorCode)parseErrorCode;
|
|
return pos;
|
|
|
|
}
|
|
|
|
/**
|
|
* Parse a UnicodeSet out, store it, and return the stand-in character
|
|
* used to represent it.
|
|
*/
|
|
UChar TransliteratorParser::parseSet(const UnicodeString& rule,
|
|
ParsePosition& pos,
|
|
UErrorCode& status) {
|
|
UnicodeSet* set = new UnicodeSet(rule, pos, USET_IGNORE_SPACE, parseData, status);
|
|
// Null pointer check
|
|
if (set == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return (UChar)0x0000; // Return empty character with error.
|
|
}
|
|
set->compact();
|
|
return generateStandInFor(set, status);
|
|
}
|
|
|
|
/**
|
|
* Generate and return a stand-in for a new UnicodeFunctor. Store
|
|
* the matcher (adopt it).
|
|
*/
|
|
UChar TransliteratorParser::generateStandInFor(UnicodeFunctor* adopted, UErrorCode& status) {
|
|
// assert(obj != null);
|
|
|
|
// Look up previous stand-in, if any. This is a short list
|
|
// (typical n is 0, 1, or 2); linear search is optimal.
|
|
for (int32_t i=0; i<variablesVector.size(); ++i) {
|
|
if (variablesVector.elementAt(i) == adopted) { // [sic] pointer comparison
|
|
return (UChar) (curData->variablesBase + i);
|
|
}
|
|
}
|
|
|
|
if (variableNext >= variableLimit) {
|
|
delete adopted;
|
|
status = U_VARIABLE_RANGE_EXHAUSTED;
|
|
return 0;
|
|
}
|
|
variablesVector.addElement(adopted, status);
|
|
return variableNext++;
|
|
}
|
|
|
|
/**
|
|
* Return the standin for segment seg (1-based).
|
|
*/
|
|
UChar TransliteratorParser::getSegmentStandin(int32_t seg, UErrorCode& status) {
|
|
// Special character used to indicate an empty spot
|
|
UChar empty = curData->variablesBase - 1;
|
|
while (segmentStandins.length() < seg) {
|
|
segmentStandins.append(empty);
|
|
}
|
|
UChar c = segmentStandins.charAt(seg-1);
|
|
if (c == empty) {
|
|
if (variableNext >= variableLimit) {
|
|
status = U_VARIABLE_RANGE_EXHAUSTED;
|
|
return 0;
|
|
}
|
|
c = variableNext++;
|
|
// Set a placeholder in the master variables vector that will be
|
|
// filled in later by setSegmentObject(). We know that we will get
|
|
// called first because setSegmentObject() will call us.
|
|
variablesVector.addElement((void*) NULL, status);
|
|
segmentStandins.setCharAt(seg-1, c);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* Set the object for segment seg (1-based).
|
|
*/
|
|
void TransliteratorParser::setSegmentObject(int32_t seg, StringMatcher* adopted, UErrorCode& status) {
|
|
// Since we call parseSection() recursively, nested
|
|
// segments will result in segment i+1 getting parsed
|
|
// and stored before segment i; be careful with the
|
|
// vector handling here.
|
|
if (segmentObjects.size() < seg) {
|
|
segmentObjects.setSize(seg, status);
|
|
}
|
|
int32_t index = getSegmentStandin(seg, status) - curData->variablesBase;
|
|
if (segmentObjects.elementAt(seg-1) != NULL ||
|
|
variablesVector.elementAt(index) != NULL) {
|
|
// should never happen
|
|
status = U_INTERNAL_TRANSLITERATOR_ERROR;
|
|
return;
|
|
}
|
|
segmentObjects.setElementAt(adopted, seg-1);
|
|
variablesVector.setElementAt(adopted, index);
|
|
}
|
|
|
|
/**
|
|
* Return the stand-in for the dot set. It is allocated the first
|
|
* time and reused thereafter.
|
|
*/
|
|
UChar TransliteratorParser::getDotStandIn(UErrorCode& status) {
|
|
if (dotStandIn == (UChar) -1) {
|
|
UnicodeSet* tempus = new UnicodeSet(DOT_SET, status);
|
|
// Null pointer check.
|
|
if (tempus == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return (UChar)0x0000;
|
|
}
|
|
dotStandIn = generateStandInFor(tempus, status);
|
|
}
|
|
return dotStandIn;
|
|
}
|
|
|
|
/**
|
|
* Append the value of the given variable name to the given
|
|
* UnicodeString.
|
|
*/
|
|
void TransliteratorParser::appendVariableDef(const UnicodeString& name,
|
|
UnicodeString& buf,
|
|
UErrorCode& status) {
|
|
const UnicodeString* s = (const UnicodeString*) variableNames.get(name);
|
|
if (s == NULL) {
|
|
// We allow one undefined variable so that variable definition
|
|
// statements work. For the first undefined variable we return
|
|
// the special placeholder variableLimit-1, and save the variable
|
|
// name.
|
|
if (undefinedVariableName.length() == 0) {
|
|
undefinedVariableName = name;
|
|
if (variableNext >= variableLimit) {
|
|
// throw new RuntimeException("Private use variables exhausted");
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
buf.append((UChar) --variableLimit);
|
|
} else {
|
|
//throw new IllegalArgumentException("Undefined variable $"
|
|
// + name);
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
} else {
|
|
buf.append(*s);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Glue method to get around access restrictions in C++.
|
|
*/
|
|
/*Transliterator* TransliteratorParser::createBasicInstance(const UnicodeString& id, const UnicodeString* canonID) {
|
|
return Transliterator::createBasicInstance(id, canonID);
|
|
}*/
|
|
|
|
U_NAMESPACE_END
|
|
|
|
U_CAPI int32_t
|
|
utrans_stripRules(const UChar *source, int32_t sourceLen, UChar *target, UErrorCode *status) {
|
|
U_NAMESPACE_USE
|
|
|
|
//const UChar *sourceStart = source;
|
|
const UChar *targetStart = target;
|
|
const UChar *sourceLimit = source+sourceLen;
|
|
UChar *targetLimit = target+sourceLen;
|
|
UChar32 c = 0;
|
|
UBool quoted = FALSE;
|
|
int32_t index;
|
|
|
|
uprv_memset(target, 0, sourceLen*U_SIZEOF_UCHAR);
|
|
|
|
/* read the rules into the buffer */
|
|
while (source < sourceLimit)
|
|
{
|
|
index=0;
|
|
U16_NEXT_UNSAFE(source, index, c);
|
|
source+=index;
|
|
if(c == QUOTE) {
|
|
quoted = (UBool)!quoted;
|
|
}
|
|
else if (!quoted) {
|
|
if (c == RULE_COMMENT_CHAR) {
|
|
/* skip comments and all preceding spaces */
|
|
while (targetStart < target && *(target - 1) == 0x0020) {
|
|
target--;
|
|
}
|
|
do {
|
|
c = *(source++);
|
|
}
|
|
while (c != CR && c != LF);
|
|
}
|
|
else if (c == ESCAPE) {
|
|
UChar32 c2 = *source;
|
|
if (c2 == CR || c2 == LF) {
|
|
/* A backslash at the end of a line. */
|
|
/* Since we're stripping lines, ignore the backslash. */
|
|
source++;
|
|
continue;
|
|
}
|
|
if (c2 == 0x0075 && source+5 < sourceLimit) { /* \u seen. \U isn't unescaped. */
|
|
int32_t escapeOffset = 0;
|
|
UnicodeString escapedStr(source, 5);
|
|
c2 = escapedStr.unescapeAt(escapeOffset);
|
|
|
|
if (c2 == (UChar32)0xFFFFFFFF || escapeOffset == 0)
|
|
{
|
|
*status = U_PARSE_ERROR;
|
|
return 0;
|
|
}
|
|
if (!uprv_isRuleWhiteSpace(c2) && !u_iscntrl(c2) && !u_ispunct(c2)) {
|
|
/* It was escaped for a reason. Write what it was suppose to be. */
|
|
source+=5;
|
|
c = c2;
|
|
}
|
|
}
|
|
else if (c2 == QUOTE) {
|
|
/* \' seen. Make sure we don't do anything when we see it again. */
|
|
quoted = (UBool)!quoted;
|
|
}
|
|
}
|
|
}
|
|
if (c == CR || c == LF)
|
|
{
|
|
/* ignore spaces carriage returns, and all leading spaces on the next line.
|
|
* and line feed unless in the form \uXXXX
|
|
*/
|
|
quoted = FALSE;
|
|
while (source < sourceLimit) {
|
|
c = *(source);
|
|
if (c != CR && c != LF && c != 0x0020) {
|
|
break;
|
|
}
|
|
source++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* Append UChar * after dissembling if c > 0xffff*/
|
|
index=0;
|
|
U16_APPEND_UNSAFE(target, index, c);
|
|
target+=index;
|
|
}
|
|
if (target < targetLimit) {
|
|
*target = 0;
|
|
}
|
|
return (int32_t)(target-targetStart);
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_TRANSLITERATION */
|