The Tor Browser: intl/icu/source/common/rbbistbl.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/rbbistbl.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/rbbistbl.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 //
 //  file:  rbbistbl.cpp    Implementation of the ICU RBBISymbolTable class
 //
 /*
 ***************************************************************************
 *   Copyright (C) 2002-2011 International Business Machines Corporation
 *   and others. All rights reserved.
 ***************************************************************************
 */
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_BREAK_ITERATION
 #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 = -1;
     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 */

The Tor Browser / annotate

intl/icu/source/common/rbbistbl.cpp@fc2d59ddac77 (annotated)

intl/icu/source/common/rbbistbl.cpp