The Tor Browser: comparison intl/icu/source/common/rbbistbl.cpp

--1:000000000000
+:b20298067531
+//
+//  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 / file comparison

comparison: intl/icu/source/common/rbbistbl.cpp

intl/icu/source/common/rbbistbl.cpp