| // |
| // file: rbbistbl.cpp Implementation of the ICU RBBISymbolTable class |
| // |
| /* |
| *************************************************************************** |
| * Copyright (C) 2002-2014 International Business Machines Corporation |
| * and others. All rights reserved. |
| *************************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_BREAK_ITERATION |
| |
| #include "starboard/client_porting/poem/string_poem.h" |
| #include "unicode/unistr.h" |
| #include "unicode/uniset.h" |
| #include "unicode/uchar.h" |
| #include "unicode/parsepos.h" |
| |
| #include "umutex.h" |
| |
| #include "rbbirb.h" |
| #include "rbbinode.h" |
| |
| |
| // |
| // RBBISymbolTableEntry_deleter Used by the UHashTable to delete the contents |
| // when the hash table is deleted. |
| // |
| U_CDECL_BEGIN |
| static void U_CALLCONV RBBISymbolTableEntry_deleter(void *p) { |
| icu::RBBISymbolTableEntry *px = (icu::RBBISymbolTableEntry *)p; |
| delete px; |
| } |
| U_CDECL_END |
| |
| |
| |
| U_NAMESPACE_BEGIN |
| |
| RBBISymbolTable::RBBISymbolTable(RBBIRuleScanner *rs, const UnicodeString &rules, UErrorCode &status) |
| :fRules(rules), fRuleScanner(rs), ffffString(UChar(0xffff)) |
| { |
| fHashTable = NULL; |
| fCachedSetLookup = NULL; |
| |
| fHashTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status); |
| // uhash_open checks status |
| if (U_FAILURE(status)) { |
| return; |
| } |
| uhash_setValueDeleter(fHashTable, RBBISymbolTableEntry_deleter); |
| } |
| |
| |
| |
| RBBISymbolTable::~RBBISymbolTable() |
| { |
| uhash_close(fHashTable); |
| } |
| |
| |
| // |
| // RBBISymbolTable::lookup This function from the abstract symbol table inteface |
| // looks up a variable name and returns a UnicodeString |
| // containing the substitution text. |
| // |
| // The variable name does NOT include the leading $. |
| // |
| const UnicodeString *RBBISymbolTable::lookup(const UnicodeString& s) const |
| { |
| RBBISymbolTableEntry *el; |
| RBBINode *varRefNode; |
| RBBINode *exprNode; |
| RBBINode *usetNode; |
| const UnicodeString *retString; |
| RBBISymbolTable *This = (RBBISymbolTable *)this; // cast off const |
| |
| el = (RBBISymbolTableEntry *)uhash_get(fHashTable, &s); |
| if (el == NULL) { |
| return NULL; |
| } |
| |
| varRefNode = el->val; |
| exprNode = varRefNode->fLeftChild; // Root node of expression for variable |
| if (exprNode->fType == RBBINode::setRef) { |
| // The $variable refers to a single UnicodeSet |
| // return the ffffString, which will subsequently be interpreted as a |
| // stand-in character for the set by RBBISymbolTable::lookupMatcher() |
| usetNode = exprNode->fLeftChild; |
| This->fCachedSetLookup = usetNode->fInputSet; |
| retString = &ffffString; |
| } |
| else |
| { |
| // The variable refers to something other than just a set. |
| // return the original source string for the expression |
| retString = &exprNode->fText; |
| This->fCachedSetLookup = NULL; |
| } |
| return retString; |
| } |
| |
| |
| |
| // |
| // RBBISymbolTable::lookupMatcher This function from the abstract symbol table |
| // interface maps a single stand-in character to a |
| // pointer to a Unicode Set. The Unicode Set code uses this |
| // mechanism to get all references to the same $variable |
| // name to refer to a single common Unicode Set instance. |
| // |
| // This implementation cheats a little, and does not maintain a map of stand-in chars |
| // to sets. Instead, it takes advantage of the fact that the UnicodeSet |
| // constructor will always call this function right after calling lookup(), |
| // and we just need to remember what set to return between these two calls. |
| const UnicodeFunctor *RBBISymbolTable::lookupMatcher(UChar32 ch) const |
| { |
| UnicodeSet *retVal = NULL; |
| RBBISymbolTable *This = (RBBISymbolTable *)this; // cast off const |
| if (ch == 0xffff) { |
| retVal = fCachedSetLookup; |
| This->fCachedSetLookup = 0; |
| } |
| return retVal; |
| } |
| |
| // |
| // RBBISymbolTable::parseReference This function from the abstract symbol table interface |
| // looks for a $variable name in the source text. |
| // It does not look it up, only scans for it. |
| // It is used by the UnicodeSet parser. |
| // |
| // This implementation is lifted pretty much verbatim |
| // from the rules based transliterator implementation. |
| // I didn't see an obvious way of sharing it. |
| // |
| UnicodeString RBBISymbolTable::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; |
| } |
| |
| |
| |
| // |
| // RBBISymbolTable::lookupNode Given a key (a variable name), return the |
| // corresponding RBBI Node. If there is no entry |
| // in the table for this name, return NULL. |
| // |
| RBBINode *RBBISymbolTable::lookupNode(const UnicodeString &key) const{ |
| |
| RBBINode *retNode = NULL; |
| RBBISymbolTableEntry *el; |
| |
| el = (RBBISymbolTableEntry *)uhash_get(fHashTable, &key); |
| if (el != NULL) { |
| retNode = el->val; |
| } |
| return retNode; |
| } |
| |
| |
| // |
| // RBBISymbolTable::addEntry Add a new entry to the symbol table. |
| // Indicate an error if the name already exists - |
| // this will only occur in the case of duplicate |
| // variable assignments. |
| // |
| void RBBISymbolTable::addEntry (const UnicodeString &key, RBBINode *val, UErrorCode &err) { |
| RBBISymbolTableEntry *e; |
| /* test for buffer overflows */ |
| if (U_FAILURE(err)) { |
| return; |
| } |
| e = (RBBISymbolTableEntry *)uhash_get(fHashTable, &key); |
| if (e != NULL) { |
| err = U_BRK_VARIABLE_REDFINITION; |
| return; |
| } |
| |
| e = new RBBISymbolTableEntry; |
| if (e == NULL) { |
| err = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| e->key = key; |
| e->val = val; |
| uhash_put( fHashTable, &e->key, e, &err); |
| } |
| |
| |
| RBBISymbolTableEntry::RBBISymbolTableEntry() : UMemory(), key(), val(NULL) {} |
| |
| RBBISymbolTableEntry::~RBBISymbolTableEntry() { |
| // The "val" of a symbol table entry is a variable reference node. |
| // The l. child of the val is the rhs expression from the assignment. |
| // Unlike other node types, children of variable reference nodes are not |
| // automatically recursively deleted. We do it manually here. |
| delete val->fLeftChild; |
| val->fLeftChild = NULL; |
| |
| delete val; |
| |
| // Note: the key UnicodeString is destructed by virtue of being in the object by value. |
| } |
| |
| |
| // |
| // RBBISymbolTable::print Debugging function, dump out the symbol table contents. |
| // |
| #ifdef RBBI_DEBUG |
| void RBBISymbolTable::rbbiSymtablePrint() const { |
| RBBIDebugPrintf("Variable Definitions\n" |
| "Name Node Val String Val\n" |
| "----------------------------------------------------------------------\n"); |
| |
| int32_t pos = UHASH_FIRST; |
| const UHashElement *e = NULL; |
| for (;;) { |
| e = uhash_nextElement(fHashTable, &pos); |
| if (e == NULL ) { |
| break; |
| } |
| RBBISymbolTableEntry *s = (RBBISymbolTableEntry *)e->value.pointer; |
| |
| RBBI_DEBUG_printUnicodeString(s->key, 15); |
| RBBIDebugPrintf(" %8p ", (void *)s->val); |
| RBBI_DEBUG_printUnicodeString(s->val->fLeftChild->fText); |
| RBBIDebugPrintf("\n"); |
| } |
| |
| RBBIDebugPrintf("\nParsed Variable Definitions\n"); |
| pos = -1; |
| for (;;) { |
| e = uhash_nextElement(fHashTable, &pos); |
| if (e == NULL ) { |
| break; |
| } |
| RBBISymbolTableEntry *s = (RBBISymbolTableEntry *)e->value.pointer; |
| RBBI_DEBUG_printUnicodeString(s->key); |
| s->val->fLeftChild->printTree(TRUE); |
| RBBIDebugPrintf("\n"); |
| } |
| } |
| #endif |
| |
| |
| |
| |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ |
