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
33U_NAMESPACE_BEGIN
34
35class RBBIRuleScanner;
36struct RBBIRuleTableEl;
37class RBBISetBuilder;
38class RBBINode;
39class 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//--------------------------------------------------------------------------------
49class RBBISymbolTableEntry : public UMemory { // The symbol table hash table contains one
50public: // of these structs for each entry.
51 RBBISymbolTableEntry();
52 UnicodeString key;
53 RBBINode *val;
54 ~RBBISymbolTableEntry();
55
56private:
57 RBBISymbolTableEntry(const RBBISymbolTableEntry &other); // forbid copying of this class
58 RBBISymbolTableEntry &operator=(const RBBISymbolTableEntry &other); // forbid copying of this class
59};
60
61
62class RBBISymbolTable : public UMemory, public SymbolTable {
63private:
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
74public:
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
97private:
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//--------------------------------------------------------------------------------
108class RBBIRuleBuilder : public UMemory {
109public:
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
119public:
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..
179private:
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//----------------------------------------------------------------------------
202struct 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 */
210typedef 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
230U_NAMESPACE_END
231
232#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
233
234#endif
235
236
237
238