270 lines
8.4 KiB
C++
270 lines
8.4 KiB
C++
//
|
|
// 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 */
|