1 //
2 // Copyright (C) 2002-2015 International Business Machines Corporation
3 // and others. All rights reserved.
4 //
5 // file: regeximp.h
6 //
7 // ICU Regular Expressions,
8 // Definitions of constant values used in the compiled form of
9 // a regular expression pattern.
10 //
11
12 #ifndef _REGEXIMP_H
13 #define _REGEXIMP_H
14
15 #include "unicode/utypes.h"
16 #include "unicode/uobject.h"
17 #include "unicode/uniset.h"
18 #include "unicode/utext.h"
19
20 #include "cmemory.h"
21 #include "ucase.h"
22
23 U_NAMESPACE_BEGIN
24
25 // For debugging, define REGEX_DEBUG
26 // To define with configure,
27 // CPPFLAGS="-DREGEX_DEBUG" ./runConfigureICU --enable-debug --disable-release Linux
28
29 #ifdef REGEX_DEBUG
30 //
31 // debugging options. Enable one or more of the three #defines immediately following
32 //
33
34 //#define REGEX_SCAN_DEBUG
35 #define REGEX_DUMP_DEBUG
36 #define REGEX_RUN_DEBUG
37
38 // End of #defines inteded to be directly set.
39
40 #include <stdio.h>
41 #endif
42
43 #ifdef REGEX_SCAN_DEBUG
44 #define REGEX_SCAN_DEBUG_PRINTF(a) printf a
45 #else
46 #define REGEX_SCAN_DEBUG_PRINTF(a)
47 #endif
48
49
50 //
51 // Opcode types In the compiled form of the regexp, these are the type, or opcodes,
52 // of the entries.
53 //
54 enum {
55 URX_RESERVED_OP = 0, // For multi-operand ops, most non-first words.
56 URX_RESERVED_OP_N = 255, // For multi-operand ops, negative operand values.
57 URX_BACKTRACK = 1, // Force a backtrack, as if a match test had failed.
58 URX_END = 2,
59 URX_ONECHAR = 3, // Value field is the 21 bit unicode char to match
60 URX_STRING = 4, // Value field is index of string start
61 URX_STRING_LEN = 5, // Value field is string length (code units)
62 URX_STATE_SAVE = 6, // Value field is pattern position to push
63 URX_NOP = 7,
64 URX_START_CAPTURE = 8, // Value field is capture group number.
65 URX_END_CAPTURE = 9, // Value field is capture group number
66 URX_STATIC_SETREF = 10, // Value field is index of set in array of sets.
67 URX_SETREF = 11, // Value field is index of set in array of sets.
68 URX_DOTANY = 12,
69 URX_JMP = 13, // Value field is destination position in
70 // the pattern.
71 URX_FAIL = 14, // Stop match operation, No match.
72
73 URX_JMP_SAV = 15, // Operand: JMP destination location
74 URX_BACKSLASH_B = 16, // Value field: 0: \b 1: \B
75 URX_BACKSLASH_G = 17,
76 URX_JMP_SAV_X = 18, // Conditional JMP_SAV,
77 // Used in (x)+, breaks loop on zero length match.
78 // Operand: Jmp destination.
79 URX_BACKSLASH_X = 19,
80 URX_BACKSLASH_Z = 20, // \z Unconditional end of line.
81
82 URX_DOTANY_ALL = 21, // ., in the . matches any mode.
83 URX_BACKSLASH_D = 22, // Value field: 0: \d 1: \D
84 URX_CARET = 23, // Value field: 1: multi-line mode.
85 URX_DOLLAR = 24, // Also for \Z
86
87 URX_CTR_INIT = 25, // Counter Inits for {Interval} loops.
88 URX_CTR_INIT_NG = 26, // 2 kinds, normal and non-greedy.
89 // These are 4 word opcodes. See description.
90 // First Operand: Data loc of counter variable
91 // 2nd Operand: Pat loc of the URX_CTR_LOOPx
92 // at the end of the loop.
93 // 3rd Operand: Minimum count.
94 // 4th Operand: Max count, -1 for unbounded.
95
96 URX_DOTANY_UNIX = 27, // '.' operator in UNIX_LINES mode, only \n marks end of line.
97
98 URX_CTR_LOOP = 28, // Loop Ops for {interval} loops.
99 URX_CTR_LOOP_NG = 29, // Also in three flavors.
100 // Operand is loc of corresponding CTR_INIT.
101
102 URX_CARET_M_UNIX = 30, // '^' operator, test for start of line in multi-line
103 // plus UNIX_LINES mode.
104
105 URX_RELOC_OPRND = 31, // Operand value in multi-operand ops that refers
106 // back into compiled pattern code, and thus must
107 // be relocated when inserting/deleting ops in code.
108
109 URX_STO_SP = 32, // Store the stack ptr. Operand is location within
110 // matcher data (not stack data) to store it.
111 URX_LD_SP = 33, // Load the stack pointer. Operand is location
112 // to load from.
113 URX_BACKREF = 34, // Back Reference. Parameter is the index of the
114 // capture group variables in the state stack frame.
115 URX_STO_INP_LOC = 35, // Store the input location. Operand is location
116 // within the matcher stack frame.
117 URX_JMPX = 36, // Conditional JMP.
118 // First Operand: JMP target location.
119 // Second Operand: Data location containing an
120 // input position. If current input position ==
121 // saved input position, FAIL rather than taking
122 // the JMP
123 URX_LA_START = 37, // Starting a LookAround expression.
124 // Save InputPos and SP in static data.
125 // Operand: Static data offset for the save
126 URX_LA_END = 38, // Ending a Lookaround expression.
127 // Restore InputPos and Stack to saved values.
128 // Operand: Static data offset for saved data.
129 URX_ONECHAR_I = 39, // Test for case-insensitive match of a literal character.
130 // Operand: the literal char.
131 URX_STRING_I = 40, // Case insensitive string compare.
132 // First Operand: Index of start of string in string literals
133 // Second Operand (next word in compiled code):
134 // the length of the string.
135 URX_BACKREF_I = 41, // Case insensitive back reference.
136 // Parameter is the index of the
137 // capture group variables in the state stack frame.
138 URX_DOLLAR_M = 42, // $ in multi-line mode.
139 URX_CARET_M = 43, // ^ in multi-line mode.
140 URX_LB_START = 44, // LookBehind Start.
141 // Paramater is data location
142 URX_LB_CONT = 45, // LookBehind Continue.
143 // Param 0: the data location
144 // Param 1: The minimum length of the look-behind match
145 // Param 2: The max length of the look-behind match
146 URX_LB_END = 46, // LookBehind End.
147 // Parameter is the data location.
148 // Check that match ended at the right spot,
149 // Restore original input string len.
150 URX_LBN_CONT = 47, // Negative LookBehind Continue
151 // Param 0: the data location
152 // Param 1: The minimum length of the look-behind match
153 // Param 2: The max length of the look-behind match
154 // Param 3: The pattern loc following the look-behind block.
155 URX_LBN_END = 48, // Negative LookBehind end
156 // Parameter is the data location.
157 // Check that the match ended at the right spot.
158 URX_STAT_SETREF_N = 49, // Reference to a prebuilt set (e.g. \w), negated
159 // Operand is index of set in array of sets.
160 URX_LOOP_SR_I = 50, // Init a [set]* loop.
161 // Operand is the sets index in array of user sets.
162 URX_LOOP_C = 51, // Continue a [set]* or OneChar* loop.
163 // Operand is a matcher static data location.
164 // Must always immediately follow LOOP_x_I instruction.
165 URX_LOOP_DOT_I = 52, // .*, initialization of the optimized loop.
166 // Operand value:
167 // bit 0:
168 // 0: Normal (. doesn't match new-line) mode.
169 // 1: . matches new-line mode.
170 // bit 1: controls what new-lines are recognized by this operation.
171 // 0: All Unicode New-lines
172 // 1: UNIX_LINES, \u000a only.
173 URX_BACKSLASH_BU = 53, // \b or \B in UREGEX_UWORD mode, using Unicode style
174 // word boundaries.
175 URX_DOLLAR_D = 54, // $ end of input test, in UNIX_LINES mode.
176 URX_DOLLAR_MD = 55, // $ end of input test, in MULTI_LINE and UNIX_LINES mode.
177 URX_BACKSLASH_H = 56, // Value field: 0: \h 1: \H
178 URX_BACKSLASH_R = 57, // Any line break sequence.
179 URX_BACKSLASH_V = 58 // Value field: 0: \v 1: \V
180
181 };
182
183 // Keep this list of opcode names in sync with the above enum
184 // Used for debug printing only.
185 #define URX_OPCODE_NAMES \
186 " ", \
187 "BACKTRACK", \
188 "END", \
189 "ONECHAR", \
190 "STRING", \
191 "STRING_LEN", \
192 "STATE_SAVE", \
193 "NOP", \
194 "START_CAPTURE", \
195 "END_CAPTURE", \
196 "URX_STATIC_SETREF", \
197 "SETREF", \
198 "DOTANY", \
199 "JMP", \
200 "FAIL", \
201 "JMP_SAV", \
202 "BACKSLASH_B", \
203 "BACKSLASH_G", \
204 "JMP_SAV_X", \
205 "BACKSLASH_X", \
206 "BACKSLASH_Z", \
207 "DOTANY_ALL", \
208 "BACKSLASH_D", \
209 "CARET", \
210 "DOLLAR", \
211 "CTR_INIT", \
212 "CTR_INIT_NG", \
213 "DOTANY_UNIX", \
214 "CTR_LOOP", \
215 "CTR_LOOP_NG", \
216 "URX_CARET_M_UNIX", \
217 "RELOC_OPRND", \
218 "STO_SP", \
219 "LD_SP", \
220 "BACKREF", \
221 "STO_INP_LOC", \
222 "JMPX", \
223 "LA_START", \
224 "LA_END", \
225 "ONECHAR_I", \
226 "STRING_I", \
227 "BACKREF_I", \
228 "DOLLAR_M", \
229 "CARET_M", \
230 "LB_START", \
231 "LB_CONT", \
232 "LB_END", \
233 "LBN_CONT", \
234 "LBN_END", \
235 "STAT_SETREF_N", \
236 "LOOP_SR_I", \
237 "LOOP_C", \
238 "LOOP_DOT_I", \
239 "BACKSLASH_BU", \
240 "DOLLAR_D", \
241 "DOLLAR_MD", \
242 "URX_BACKSLASH_H", \
243 "URX_BACKSLASH_R", \
244 "URX_BACKSLASH_V"
245
246
247 //
248 // Convenience macros for assembling and disassembling a compiled operation.
249 //
250 #define URX_TYPE(x) ((uint32_t)(x) >> 24)
251 #define URX_VAL(x) ((x) & 0xffffff)
252
253
254 //
255 // Access to Unicode Sets composite character properties
256 // The sets are accessed by the match engine for things like \w (word boundary)
257 //
258 enum {
259 URX_ISWORD_SET = 1,
260 URX_ISALNUM_SET = 2,
261 URX_ISALPHA_SET = 3,
262 URX_ISSPACE_SET = 4,
263
264 URX_GC_NORMAL, // Sets for finding grapheme cluster boundaries.
265 URX_GC_EXTEND,
266 URX_GC_CONTROL,
267 URX_GC_L,
268 URX_GC_LV,
269 URX_GC_LVT,
270 URX_GC_V,
271 URX_GC_T,
272
273 URX_LAST_SET,
274
275 URX_NEG_SET = 0x800000 // Flag bit to reverse sense of set
276 // membership test.
277 };
278
279
280 //
281 // Match Engine State Stack Frame Layout.
282 //
283 struct REStackFrame {
284 // Header
285 int64_t fInputIdx; // Position of next character in the input string
286 int64_t fPatIdx; // Position of next Op in the compiled pattern
287 // (int64_t for UVector64, values fit in an int32_t)
288 // Remainder
289 int64_t fExtra[1]; // Extra state, for capture group start/ends
290 // atomic parentheses, repeat counts, etc.
291 // Locations assigned at pattern compile time.
292 // Variable-length array.
293 };
294 // number of UVector elements in the header
295 #define RESTACKFRAME_HDRCOUNT 2
296
297 //
298 // Start-Of-Match type. Used by find() to quickly scan to positions where a
299 // match might start before firing up the full match engine.
300 //
301 enum StartOfMatch {
302 START_NO_INFO, // No hint available.
303 START_CHAR, // Match starts with a literal code point.
304 START_SET, // Match starts with something matching a set.
305 START_START, // Match starts at start of buffer only (^ or \A)
306 START_LINE, // Match starts with ^ in multi-line mode.
307 START_STRING // Match starts with a literal string.
308 };
309
310 #define START_OF_MATCH_STR(v) ((v)==START_NO_INFO? "START_NO_INFO" : \
311 (v)==START_CHAR? "START_CHAR" : \
312 (v)==START_SET? "START_SET" : \
313 (v)==START_START? "START_START" : \
314 (v)==START_LINE? "START_LINE" : \
315 (v)==START_STRING? "START_STRING" : \
316 "ILLEGAL")
317
318 //
319 // 8 bit set, to fast-path latin-1 set membership tests.
320 //
321 struct Regex8BitSet : public UMemory {
322 inline Regex8BitSet();
323 inline void operator = (const Regex8BitSet &s);
324 inline void init(const UnicodeSet *src);
325 inline UBool contains(UChar32 c);
326 inline void add(UChar32 c);
327 int8_t d[32];
328 };
329
Regex8BitSet()330 inline Regex8BitSet::Regex8BitSet() {
331 uprv_memset(d, 0, sizeof(d));
332 }
333
contains(UChar32 c)334 inline UBool Regex8BitSet::contains(UChar32 c) {
335 // No bounds checking! This is deliberate.
336 return ((d[c>>3] & 1 <<(c&7)) != 0);
337 }
338
add(UChar32 c)339 inline void Regex8BitSet::add(UChar32 c) {
340 d[c>>3] |= 1 << (c&7);
341 }
342
init(const UnicodeSet * s)343 inline void Regex8BitSet::init(const UnicodeSet *s) {
344 if (s != NULL) {
345 for (int32_t i=0; i<=255; i++) {
346 if (s->contains(i)) {
347 this->add(i);
348 }
349 }
350 }
351 }
352
353 inline void Regex8BitSet::operator = (const Regex8BitSet &s) {
354 uprv_memcpy(d, s.d, sizeof(d));
355 }
356
357
358 // Case folded UText Iterator helper class.
359 // Wraps a UText, provides a case-folded enumeration over its contents.
360 // Used in implementing case insensitive matching constructs.
361 // Implementation in rematch.cpp
362
363 class CaseFoldingUTextIterator: public UMemory {
364 public:
365 CaseFoldingUTextIterator(UText &text);
366 ~CaseFoldingUTextIterator();
367
368 UChar32 next(); // Next case folded character
369
370 UBool inExpansion(); // True if last char returned from next() and the
371 // next to be returned both originated from a string
372 // folding of the same code point from the orignal UText.
373 private:
374 UText &fUText;
375 const UCaseProps *fcsp;
376 const UChar *fFoldChars;
377 int32_t fFoldLength;
378 int32_t fFoldIndex;
379
380 };
381
382
383 // Case folded UChar * string iterator.
384 // Wraps a UChar *, provides a case-folded enumeration over its contents.
385 // Used in implementing case insensitive matching constructs.
386 // Implementation in rematch.cpp
387
388 class CaseFoldingUCharIterator: public UMemory {
389 public:
390 CaseFoldingUCharIterator(const UChar *chars, int64_t start, int64_t limit);
391 ~CaseFoldingUCharIterator();
392
393 UChar32 next(); // Next case folded character
394
395 UBool inExpansion(); // True if last char returned from next() and the
396 // next to be returned both originated from a string
397 // folding of the same code point from the orignal UText.
398
399 int64_t getIndex(); // Return the current input buffer index.
400
401 private:
402 const UChar *fChars;
403 int64_t fIndex;
404 int64_t fLimit;
405 const UCaseProps *fcsp;
406 const UChar *fFoldChars;
407 int32_t fFoldLength;
408 int32_t fFoldIndex;
409
410 };
411
412 U_NAMESPACE_END
413 #endif
414
415