356 lines
11 KiB
C++
356 lines
11 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1999-2011, International Business Machines Corporation
|
|
* and others. All Rights Reserved.
|
|
**********************************************************************
|
|
* Date Name Description
|
|
* 11/17/99 aliu Creation.
|
|
**********************************************************************
|
|
*/
|
|
#ifndef RBT_PARS_H
|
|
#define RBT_PARS_H
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_TRANSLITERATION
|
|
#ifdef __cplusplus
|
|
|
|
#include "unicode/uobject.h"
|
|
#include "unicode/parseerr.h"
|
|
#include "unicode/unorm.h"
|
|
#include "rbt.h"
|
|
#include "hash.h"
|
|
#include "uvector.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
class TransliterationRuleData;
|
|
class UnicodeFunctor;
|
|
class ParseData;
|
|
class RuleHalf;
|
|
class ParsePosition;
|
|
class StringMatcher;
|
|
|
|
class TransliteratorParser : public UMemory {
|
|
|
|
public:
|
|
|
|
/**
|
|
* A Vector of TransliterationRuleData objects, one for each discrete group
|
|
* of rules in the rule set
|
|
*/
|
|
UVector dataVector;
|
|
|
|
/**
|
|
* PUBLIC data member.
|
|
* A Vector of UnicodeStrings containing all of the ID blocks in the rule set
|
|
*/
|
|
UVector idBlockVector;
|
|
|
|
/**
|
|
* PUBLIC data member containing the parsed compound filter, if any.
|
|
*/
|
|
UnicodeSet* compoundFilter;
|
|
|
|
private:
|
|
|
|
/**
|
|
* The current data object for which we are parsing rules
|
|
*/
|
|
TransliterationRuleData* curData;
|
|
|
|
UTransDirection direction;
|
|
|
|
/**
|
|
* Parse error information.
|
|
*/
|
|
UParseError parseError;
|
|
|
|
/**
|
|
* Temporary symbol table used during parsing.
|
|
*/
|
|
ParseData* parseData;
|
|
|
|
/**
|
|
* Temporary vector of matcher variables. When parsing is complete, this
|
|
* is copied into the array data.variables. As with data.variables,
|
|
* element 0 corresponds to character data.variablesBase.
|
|
*/
|
|
UVector variablesVector;
|
|
|
|
/**
|
|
* Temporary table of variable names. When parsing is complete, this is
|
|
* copied into data.variableNames.
|
|
*/
|
|
Hashtable variableNames;
|
|
|
|
/**
|
|
* String of standins for segments. Used during the parsing of a single
|
|
* rule. segmentStandins.charAt(0) is the standin for "$1" and corresponds
|
|
* to StringMatcher object segmentObjects.elementAt(0), etc.
|
|
*/
|
|
UnicodeString segmentStandins;
|
|
|
|
/**
|
|
* Vector of StringMatcher objects for segments. Used during the
|
|
* parsing of a single rule.
|
|
* segmentStandins.charAt(0) is the standin for "$1" and corresponds
|
|
* to StringMatcher object segmentObjects.elementAt(0), etc.
|
|
*/
|
|
UVector segmentObjects;
|
|
|
|
/**
|
|
* The next available stand-in for variables. This starts at some point in
|
|
* the private use area (discovered dynamically) and increments up toward
|
|
* <code>variableLimit</code>. At any point during parsing, available
|
|
* variables are <code>variableNext..variableLimit-1</code>.
|
|
*/
|
|
UChar variableNext;
|
|
|
|
/**
|
|
* The last available stand-in for variables. This is discovered
|
|
* dynamically. At any point during parsing, available variables are
|
|
* <code>variableNext..variableLimit-1</code>.
|
|
*/
|
|
UChar variableLimit;
|
|
|
|
/**
|
|
* When we encounter an undefined variable, we do not immediately signal
|
|
* an error, in case we are defining this variable, e.g., "$a = [a-z];".
|
|
* Instead, we save the name of the undefined variable, and substitute
|
|
* in the placeholder char variableLimit - 1, and decrement
|
|
* variableLimit.
|
|
*/
|
|
UnicodeString undefinedVariableName;
|
|
|
|
/**
|
|
* The stand-in character for the 'dot' set, represented by '.' in
|
|
* patterns. This is allocated the first time it is needed, and
|
|
* reused thereafter.
|
|
*/
|
|
UChar dotStandIn;
|
|
|
|
public:
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
TransliteratorParser(UErrorCode &statusReturn);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~TransliteratorParser();
|
|
|
|
/**
|
|
* 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 after construction.
|
|
*
|
|
* Parse the given rules, in the given direction. After this call
|
|
* returns, query the public data members for results. The caller
|
|
* owns the 'data' and 'compoundFilter' data members after this
|
|
* call returns.
|
|
* @param rules rules, separated by ';'
|
|
* @param direction either FORWARD or REVERSE.
|
|
* @param pe Struct to recieve information on position
|
|
* of error if an error is encountered
|
|
* @param ec Output param set to success/failure code.
|
|
*/
|
|
void parse(const UnicodeString& rules,
|
|
UTransDirection direction,
|
|
UParseError& pe,
|
|
UErrorCode& ec);
|
|
|
|
/**
|
|
* Return the compound filter parsed by parse(). Caller owns result.
|
|
* @return the compound filter parsed by parse().
|
|
*/
|
|
UnicodeSet* orphanCompoundFilter();
|
|
|
|
private:
|
|
|
|
/**
|
|
* Return a representation of this transliterator as source rules.
|
|
* @param rules Output param to receive the rules.
|
|
* @param direction either FORWARD or REVERSE.
|
|
*/
|
|
void parseRules(const UnicodeString& rules,
|
|
UTransDirection direction,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* 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.
|
|
* @param rules Output param to receive the rules.
|
|
* @param pos the starting position.
|
|
* @param limit pointer past the last character of the rule.
|
|
* @return the index after the last character parsed.
|
|
*/
|
|
int32_t parseRule(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status);
|
|
|
|
/**
|
|
* Set the variable range to [start, end] (inclusive).
|
|
* @param start the start value of the range.
|
|
* @param end the end value of the range.
|
|
*/
|
|
void setVariableRange(int32_t start, int32_t end, UErrorCode& status);
|
|
|
|
/**
|
|
* 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.
|
|
* @param ch the given character.
|
|
* @return True, if the given character is NOT within the variable range.
|
|
*/
|
|
UBool checkVariableRange(UChar32 ch) const;
|
|
|
|
/**
|
|
* Set the maximum backup to 'backup', in response to a pragma
|
|
* statement.
|
|
* @param backup the new value to be set.
|
|
*/
|
|
void pragmaMaximumBackup(int32_t backup);
|
|
|
|
/**
|
|
* Begin normalizing all rules using the given mode, in response
|
|
* to a pragma statement.
|
|
* @param mode the given mode.
|
|
*/
|
|
void pragmaNormalizeRules(UNormalizationMode mode);
|
|
|
|
/**
|
|
* 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.
|
|
* @return true if the given rule looks like a pragma.
|
|
*/
|
|
static UBool resemblesPragma(const UnicodeString& rule, int32_t pos, int32_t limit);
|
|
|
|
/**
|
|
* 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 parsePragma(const UnicodeString& rule, int32_t pos, int32_t limit, UErrorCode& status);
|
|
|
|
/**
|
|
* 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 parseErrorCode error code.
|
|
* @param msg error description.
|
|
* @param start position of first character of current rule.
|
|
* @return start position of first character of current rule.
|
|
*/
|
|
int32_t syntaxError(UErrorCode parseErrorCode, const UnicodeString&, int32_t start,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Parse a UnicodeSet out, store it, and return the stand-in character
|
|
* used to represent it.
|
|
*
|
|
* @param rule the rule for UnicodeSet.
|
|
* @param pos the position in pattern at which to start parsing.
|
|
* @return the stand-in character used to represent it.
|
|
*/
|
|
UChar parseSet(const UnicodeString& rule,
|
|
ParsePosition& pos,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Generate and return a stand-in for a new UnicodeFunctor. Store
|
|
* the matcher (adopt it).
|
|
* @param adopted the UnicodeFunctor to be adopted.
|
|
* @return a stand-in for a new UnicodeFunctor.
|
|
*/
|
|
UChar generateStandInFor(UnicodeFunctor* adopted, UErrorCode& status);
|
|
|
|
/**
|
|
* Return the standin for segment seg (1-based).
|
|
* @param seg the given segment.
|
|
* @return the standIn character for the given segment.
|
|
*/
|
|
UChar getSegmentStandin(int32_t seg, UErrorCode& status);
|
|
|
|
/**
|
|
* Set the object for segment seg (1-based).
|
|
* @param seg the given segment.
|
|
* @param adopted the StringMatcher to be adopted.
|
|
*/
|
|
void setSegmentObject(int32_t seg, StringMatcher* adopted, UErrorCode& status);
|
|
|
|
/**
|
|
* Return the stand-in for the dot set. It is allocated the first
|
|
* time and reused thereafter.
|
|
* @return the stand-in for the dot set.
|
|
*/
|
|
UChar getDotStandIn(UErrorCode& status);
|
|
|
|
/**
|
|
* Append the value of the given variable name to the given
|
|
* UnicodeString.
|
|
* @param name the variable name to be appended.
|
|
* @param buf the given UnicodeString to append to.
|
|
*/
|
|
void appendVariableDef(const UnicodeString& name,
|
|
UnicodeString& buf,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Glue method to get around access restrictions in C++.
|
|
*/
|
|
/*static Transliterator* createBasicInstance(const UnicodeString& id,
|
|
const UnicodeString* canonID);*/
|
|
|
|
friend class RuleHalf;
|
|
|
|
// Disallowed methods; no impl.
|
|
/**
|
|
* Copy constructor
|
|
*/
|
|
TransliteratorParser(const TransliteratorParser&);
|
|
|
|
/**
|
|
* Assignment operator
|
|
*/
|
|
TransliteratorParser& operator=(const TransliteratorParser&);
|
|
};
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif /* #ifdef __cplusplus */
|
|
|
|
/**
|
|
* Strip/convert the following from the transliterator rules:
|
|
* comments
|
|
* newlines
|
|
* white space at the beginning and end of a line
|
|
* unescape \u notation
|
|
*
|
|
* The target must be equal in size as the source.
|
|
* @internal
|
|
*/
|
|
U_CAPI int32_t
|
|
utrans_stripRules(const UChar *source, int32_t sourceLen, UChar *target, UErrorCode *status);
|
|
|
|
#endif /* #if !UCONFIG_NO_TRANSLITERATION */
|
|
|
|
#endif
|