• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 //
4 //  regexcmp.h
5 //
6 //  Copyright (C) 2002-2016, International Business Machines Corporation and others.
7 //  All Rights Reserved.
8 //
9 //  This file contains declarations for the class RegexCompile
10 //
11 //  This class is internal to the regular expression implementation.
12 //  For the public Regular Expression API, see the file "unicode/regex.h"
13 //
14 
15 
16 #ifndef RBBISCAN_H
17 #define RBBISCAN_H
18 
19 #include "unicode/utypes.h"
20 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
21 
22 #include "unicode/parseerr.h"
23 #include "unicode/uniset.h"
24 #include "unicode/uobject.h"
25 #include "unicode/utext.h"
26 #include "uhash.h"
27 #include "uvector.h"
28 #include "uvectr32.h"
29 
30 
31 
32 U_NAMESPACE_BEGIN
33 
34 
35 //--------------------------------------------------------------------------------
36 //
37 //  class RegexCompile    Contains the regular expression compiler.
38 //
39 //--------------------------------------------------------------------------------
40 struct  RegexTableEl;
41 class   RegexPattern;
42 
43 
44 class U_I18N_API RegexCompile : public UMemory {
45 public:
46 
47     enum {
48         kStackSize = 100            // The size of the state stack for
49     };                              //   pattern parsing.  Corresponds roughly
50                                     //   to the depth of parentheses nesting
51                                     //   that is allowed in the rules.
52 
53     struct RegexPatternChar {
54         UChar32             fChar;
55         UBool               fQuoted;
56     };
57 
58     RegexCompile(RegexPattern *rp, UErrorCode &e);
59 
60     void       compile(const UnicodeString &pat, UParseError &pp, UErrorCode &e);
61     void       compile(UText *pat, UParseError &pp, UErrorCode &e);
62 
63 
64     virtual    ~RegexCompile();
65 
66     void        nextChar(RegexPatternChar &c);      // Get the next char from the input stream.
67 
68     static void cleanup();                       // Memory cleanup
69 
70 
71 
72     // Categories of parentheses in pattern.
73     //   The category is saved in the compile-time parentheses stack frame, and
74     //   determines the code to be generated when the matching close ) is encountered.
75     enum EParenClass {
76         plain        = -1,               // No special handling
77         capturing    = -2,
78         atomic       = -3,
79         lookAhead    = -4,
80         negLookAhead = -5,
81         flags        = -6,
82         lookBehind   = -7,
83         lookBehindN  = -8
84     };
85 
86 private:
87 
88 
89     UBool       doParseActions(int32_t a);
90     void        error(UErrorCode e);                   // error reporting convenience function.
91 
92     UChar32     nextCharLL();
93     UChar32     peekCharLL();
94     UnicodeSet  *scanProp();
95     UnicodeSet  *scanPosixProp();
96     void        handleCloseParen();
97     int32_t     blockTopLoc(UBool reserve);          // Locate a position in the compiled pattern
98                                                      //  at the top of the just completed block
99                                                      //  or operation, and optionally ensure that
100                                                      //  there is space to add an opcode there.
101     void        compileSet(UnicodeSet *theSet);      // Generate the compiled pattern for
102                                                      //   a reference to a UnicodeSet.
103     void        compileInterval(int32_t InitOp,      // Generate the code for a {min,max} quantifier.
104                                int32_t LoopOp);
105     UBool       compileInlineInterval();             // Generate inline code for a {min,max} quantifier
106     void        literalChar(UChar32 c);              // Compile a literal char
107     void        fixLiterals(UBool split=FALSE);      // Generate code for pending literal characters.
108     void        insertOp(int32_t where);             // Open up a slot for a new op in the
109                                                      //   generated code at the specified location.
110     void        appendOp(int32_t op);                // Append a new op to the compiled pattern.
111     void        appendOp(int32_t type, int32_t val); // Build & append a new op to the compiled pattern.
112     int32_t     buildOp(int32_t type, int32_t val);  // Construct a new pcode instruction.
113     int32_t     allocateData(int32_t size);          // Allocate space in the matcher data area.
114                                                      //   Return index of the newly allocated data.
115     int32_t     allocateStackData(int32_t size);     // Allocate space in the match back-track stack frame.
116                                                      //   Return offset index in the frame.
117     int32_t     minMatchLength(int32_t start,
118                                int32_t end);
119     int32_t     maxMatchLength(int32_t start,
120                                int32_t end);
121     void        matchStartType();
122     void        stripNOPs();
123 
124     void        setEval(int32_t op);
125     void        setPushOp(int32_t op);
126     UChar32     scanNamedChar();
127     UnicodeSet *createSetForProperty(const UnicodeString &propName, UBool negated);
128 
129 public:   // Public for testing only.
130     static void U_EXPORT2 findCaseInsensitiveStarters(UChar32 c, UnicodeSet *starterChars);
131 private:
132 
133 
134     UErrorCode                    *fStatus;
135     RegexPattern                  *fRXPat;
136     UParseError                   *fParseErr;
137 
138     //
139     //  Data associated with low level character scanning
140     //
141     int64_t                       fScanIndex;        // Index of current character being processed
142                                                      //   in the rule input string.
143     UBool                         fQuoteMode;        // Scan is in a \Q...\E quoted region
144     UBool                         fInBackslashQuote; // Scan is between a '\' and the following char.
145     UBool                         fEOLComments;      // When scan is just after '(?',  inhibit #... to
146                                                      //   end of line comments, in favor of (?#...) comments.
147     int64_t                       fLineNum;          // Line number in input file.
148     int64_t                       fCharNum;          // Char position within the line.
149     UChar32                       fLastChar;         // Previous char, needed to count CR-LF
150                                                      //   as a single line, not two.
151     UChar32                       fPeekChar;         // Saved char, if we've scanned ahead.
152 
153 
154     RegexPatternChar              fC;                // Current char for parse state machine
155                                                      //   processing.
156 
157     //
158     //   Data for the state machine that parses the regular expression.
159     //
160     RegexTableEl                  **fStateTable;     // State Transition Table for regex Rule
161                                                      //   parsing.  index by p[state][char-class]
162 
163     uint16_t                      fStack[kStackSize];  // State stack, holds state pushes
164     int32_t                       fStackPtr;           //  and pops as specified in the state
165                                                        //  transition rules.
166 
167     //
168     //  Data associated with the generation of the pcode for the match engine
169     //
170     int32_t                       fModeFlags;        // Match Flags.  (Case Insensitive, etc.)
171                                                      //   Always has high bit (31) set so that flag values
172                                                      //   on the paren stack are distinguished from relocatable
173                                                      //   pcode addresses.
174     int32_t                       fNewModeFlags;     // New flags, while compiling (?i, holds state
175                                                      //   until last flag is scanned.
176     UBool                         fSetModeFlag;      // true for (?ismx, false for (?-ismx
177 
178     UnicodeString                 fLiteralChars;     // Literal chars or strings from the pattern are accumulated here.
179                                                      //   Once completed, meaning that some non-literal pattern
180                                                      //   construct is encountered, the appropriate opcodes
181                                                      //   to match the literal will be generated, and this
182                                                      //   string will be cleared.
183 
184     int64_t                       fPatternLength;    // Length of the input pattern string.
185 
186     UVector32                     fParenStack;       // parentheses stack.  Each frame consists of
187                                                      //   the positions of compiled pattern operations
188                                                      //   needing fixup, followed by negative value.  The
189                                                      //   first entry in each frame is the position of the
190                                                      //   spot reserved for use when a quantifier
191                                                      //   needs to add a SAVE at the start of a (block)
192                                                      //   The negative value (-1, -2,...) indicates
193                                                      //   the kind of paren that opened the frame.  Some
194                                                      //   need special handling on close.
195 
196 
197     int32_t                       fMatchOpenParen;   // The position in the compiled pattern
198                                                      //   of the slot reserved for a state save
199                                                      //   at the start of the most recently processed
200                                                      //   parenthesized block. Updated when processing
201                                                      //   a close to the location for the corresponding open.
202 
203     int32_t                       fMatchCloseParen;  // The position in the pattern of the first
204                                                      //   location after the most recently processed
205                                                      //   parenthesized block.
206 
207     int32_t                       fIntervalLow;      // {lower, upper} interval quantifier values.
208     int32_t                       fIntervalUpper;    // Placed here temporarily, when pattern is
209                                                      //   initially scanned.  Each new interval
210                                                      //   encountered overwrites these values.
211                                                      //   -1 for the upper interval value means none
212                                                      //   was specified (unlimited occurences.)
213 
214     int64_t                       fNameStartPos;     // Starting position of a \N{NAME} name in a
215                                                      //   pattern, valid while remainder of name is
216                                                      //   scanned.
217 
218     UStack                        fSetStack;         // Stack of UnicodeSets, used while evaluating
219                                                      //   (at compile time) set expressions within
220                                                      //   the pattern.
221     UStack                        fSetOpStack;       // Stack of pending set operators (&&, --, union)
222 
223     UChar32                       fLastSetLiteral;   // The last single code point added to a set.
224                                                      //   needed when "-y" is scanned, and we need
225                                                      //   to turn "x-y" into a range.
226 
227     UnicodeString                *fCaptureName;      // Named Capture, the group name is built up
228                                                      //   in this string while being scanned.
229 };
230 
231 // Constant values to be pushed onto fSetOpStack while scanning & evalueating [set expressions]
232 //   The high 16 bits are the operator precedence, and the low 16 are a code for the operation itself.
233 
234 enum SetOperations {
235     setStart         = 0 << 16 | 1,
236     setEnd           = 1 << 16 | 2,
237     setNegation      = 2 << 16 | 3,
238     setCaseClose     = 2 << 16 | 9,
239     setDifference2   = 3 << 16 | 4,    // '--' set difference operator
240     setIntersection2 = 3 << 16 | 5,    // '&&' set intersection operator
241     setUnion         = 4 << 16 | 6,    // implicit union of adjacent items
242     setDifference1   = 4 << 16 | 7,    // '-', single dash difference op, for compatibility with old UnicodeSet.
243     setIntersection1 = 4 << 16 | 8     // '&', single amp intersection op, for compatibility with old UnicodeSet.
244     };
245 
246 U_NAMESPACE_END
247 #endif   // !UCONFIG_NO_REGULAR_EXPRESSIONS
248 #endif   // RBBISCAN_H
249