1 // © 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 // 4 // rbbirb.h 5 // 6 // Copyright (C) 2002-2008, International Business Machines Corporation and others. 7 // All Rights Reserved. 8 // 9 // This file contains declarations for several classes from the 10 // Rule Based Break Iterator rule builder. 11 // 12 13 14 #ifndef RBBIRB_H 15 #define RBBIRB_H 16 17 #include "unicode/utypes.h" 18 19 #if !UCONFIG_NO_BREAK_ITERATION 20 21 #include <utility> 22 23 #include "unicode/uobject.h" 24 #include "unicode/rbbi.h" 25 #include "unicode/uniset.h" 26 #include "unicode/parseerr.h" 27 #include "uhash.h" 28 #include "uvector.h" 29 #include "unicode/symtable.h"// For UnicodeSet parsing, is the interface that 30 // looks up references to $variables within a set. 31 32 33 U_NAMESPACE_BEGIN 34 35 class RBBIRuleScanner; 36 struct RBBIRuleTableEl; 37 class RBBISetBuilder; 38 class RBBINode; 39 class RBBITableBuilder; 40 41 42 43 //-------------------------------------------------------------------------------- 44 // 45 // RBBISymbolTable. Implements SymbolTable interface that is used by the 46 // UnicodeSet parser to resolve references to $variables. 47 // 48 //-------------------------------------------------------------------------------- 49 class RBBISymbolTableEntry : public UMemory { // The symbol table hash table contains one 50 public: // of these structs for each entry. 51 RBBISymbolTableEntry(); 52 UnicodeString key; 53 RBBINode *val; 54 ~RBBISymbolTableEntry(); 55 56 private: 57 RBBISymbolTableEntry(const RBBISymbolTableEntry &other); // forbid copying of this class 58 RBBISymbolTableEntry &operator=(const RBBISymbolTableEntry &other); // forbid copying of this class 59 }; 60 61 62 class RBBISymbolTable : public UMemory, public SymbolTable { 63 private: 64 const UnicodeString &fRules; 65 UHashtable *fHashTable; 66 RBBIRuleScanner *fRuleScanner; 67 68 // These next two fields are part of the mechanism for passing references to 69 // already-constructed UnicodeSets back to the UnicodeSet constructor 70 // when the pattern includes $variable references. 71 const UnicodeString ffffString; // = "/uffff" 72 UnicodeSet *fCachedSetLookup; 73 74 public: 75 // API inherited from class SymbolTable 76 virtual const UnicodeString* lookup(const UnicodeString& s) const; 77 virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const; 78 virtual UnicodeString parseReference(const UnicodeString& text, 79 ParsePosition& pos, int32_t limit) const; 80 81 // Additional Functions 82 RBBISymbolTable(RBBIRuleScanner *, const UnicodeString &fRules, UErrorCode &status); 83 virtual ~RBBISymbolTable(); 84 85 virtual RBBINode *lookupNode(const UnicodeString &key) const; 86 virtual void addEntry (const UnicodeString &key, RBBINode *val, UErrorCode &err); 87 88 #ifdef RBBI_DEBUG 89 virtual void rbbiSymtablePrint() const; 90 #else 91 // A do-nothing inline function for non-debug builds. Member funcs can't be empty 92 // or the call sites won't compile. 93 int32_t fFakeField; 94 #define rbbiSymtablePrint() fFakeField=0; 95 #endif 96 97 private: 98 RBBISymbolTable(const RBBISymbolTable &other); // forbid copying of this class 99 RBBISymbolTable &operator=(const RBBISymbolTable &other); // forbid copying of this class 100 }; 101 102 103 //-------------------------------------------------------------------------------- 104 // 105 // class RBBIRuleBuilder The top-level class handling RBBI rule compiling. 106 // 107 //-------------------------------------------------------------------------------- 108 class RBBIRuleBuilder : public UMemory { 109 public: 110 111 // Create a rule based break iterator from a set of rules. 112 // This function is the main entry point into the rule builder. The 113 // public ICU API for creating RBBIs uses this function to do the actual work. 114 // 115 static BreakIterator * createRuleBasedBreakIterator( const UnicodeString &rules, 116 UParseError *parseError, 117 UErrorCode &status); 118 119 public: 120 // The "public" functions and data members that appear below are accessed 121 // (and shared) by the various parts that make up the rule builder. They 122 // are NOT intended to be accessed by anything outside of the 123 // rule builder implementation. 124 RBBIRuleBuilder(const UnicodeString &rules, 125 UParseError *parseErr, 126 UErrorCode &status 127 ); 128 129 virtual ~RBBIRuleBuilder(); 130 131 /** 132 * Build the state tables and char class Trie from the source rules. 133 */ 134 RBBIDataHeader *build(UErrorCode &status); 135 136 137 /** 138 * Fold together redundant character classes (table columns) and 139 * redundant states (table rows). Done after initial table generation, 140 * before serializing the result. 141 */ 142 void optimizeTables(); 143 144 char *fDebugEnv; // controls debug trace output 145 UErrorCode *fStatus; // Error reporting. Keeping status 146 UParseError *fParseError; // here avoids passing it everywhere. 147 const UnicodeString &fRules; // The rule string that we are compiling 148 UnicodeString fStrippedRules; // The rule string, with comments stripped. 149 150 RBBIRuleScanner *fScanner; // The scanner. 151 RBBINode *fForwardTree; // The parse trees, generated by the scanner, 152 RBBINode *fReverseTree; // then manipulated by subsequent steps. 153 RBBINode *fSafeFwdTree; 154 RBBINode *fSafeRevTree; 155 156 RBBINode **fDefaultTree; // For rules not qualified with a ! 157 // the tree to which they belong to. 158 159 UBool fChainRules; // True for chained Unicode TR style rules. 160 // False for traditional regexp rules. 161 162 UBool fLBCMNoChain; // True: suppress chaining of rules on 163 // chars with LineBreak property == CM. 164 165 UBool fLookAheadHardBreak; // True: Look ahead matches cause an 166 // immediate break, no continuing for the 167 // longest match. 168 169 RBBISetBuilder *fSetBuilder; // Set and Character Category builder. 170 UVector *fUSetNodes; // Vector of all uset nodes. 171 172 RBBITableBuilder *fForwardTable; // State transition table, build time form. 173 174 UVector *fRuleStatusVals; // The values that can be returned 175 // from getRuleStatus(). 176 177 RBBIDataHeader *flattenData(); // Create the flattened (runtime format) 178 // data tables.. 179 private: 180 RBBIRuleBuilder(const RBBIRuleBuilder &other); // forbid copying of this class 181 RBBIRuleBuilder &operator=(const RBBIRuleBuilder &other); // forbid copying of this class 182 }; 183 184 185 186 187 //---------------------------------------------------------------------------- 188 // 189 // RBBISetTableEl is an entry in the hash table of UnicodeSets that have 190 // been encountered. The val Node will be of nodetype uset 191 // and contain pointers to the actual UnicodeSets. 192 // The Key is the source string for initializing the set. 193 // 194 // The hash table is used to avoid creating duplicate 195 // unnamed (not $var references) UnicodeSets. 196 // 197 // Memory Management: 198 // The Hash Table owns these RBBISetTableEl structs and 199 // the key strings. It does NOT own the val nodes. 200 // 201 //---------------------------------------------------------------------------- 202 struct RBBISetTableEl { 203 UnicodeString *key; 204 RBBINode *val; 205 }; 206 207 /** 208 * A pair of ints, used to bundle pairs of states or pairs of character classes. 209 */ 210 typedef std::pair<int32_t, int32_t> IntPair; 211 212 213 //---------------------------------------------------------------------------- 214 // 215 // RBBIDebugPrintf Printf equivalent, for debugging output. 216 // Conditional compilation of the implementation lets us 217 // get rid of the stdio dependency in environments where it 218 // is unavailable. 219 // 220 //---------------------------------------------------------------------------- 221 #ifdef RBBI_DEBUG 222 #include <stdio.h> 223 #define RBBIDebugPrintf printf 224 #define RBBIDebugPuts puts 225 #else 226 #undef RBBIDebugPrintf 227 #define RBBIDebugPuts(arg) 228 #endif 229 230 U_NAMESPACE_END 231 232 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ 233 234 #endif 235 236 237 238