OLD | NEW |
| (Empty) |
1 // Copyright 2003-2010 Google Inc. All Rights Reserved. | |
2 // Use of this source code is governed by a BSD-style | |
3 // license that can be found in the LICENSE file. | |
4 | |
5 // This is a variant of PCRE's pcrecpp.h, originally written at Google. | |
6 // The main changes are the addition of the HitLimit method and | |
7 // compilation as PCRE in namespace re2. | |
8 | |
9 // C++ interface to the pcre regular-expression library. PCRE supports | |
10 // Perl-style regular expressions (with extensions like \d, \w, \s, | |
11 // ...). | |
12 // | |
13 // ----------------------------------------------------------------------- | |
14 // REGEXP SYNTAX: | |
15 // | |
16 // This module uses the pcre library and hence supports its syntax | |
17 // for regular expressions: | |
18 // | |
19 // http://www.google.com/search?q=pcre | |
20 // | |
21 // The syntax is pretty similar to Perl's. For those not familiar | |
22 // with Perl's regular expressions, here are some examples of the most | |
23 // commonly used extensions: | |
24 // | |
25 // "hello (\\w+) world" -- \w matches a "word" character | |
26 // "version (\\d+)" -- \d matches a digit | |
27 // "hello\\s+world" -- \s matches any whitespace character | |
28 // "\\b(\\w+)\\b" -- \b matches empty string at a word boundary | |
29 // "(?i)hello" -- (?i) turns on case-insensitive matching | |
30 // "/\\*(.*?)\\*/" -- .*? matches . minimum no. of times possible | |
31 // | |
32 // ----------------------------------------------------------------------- | |
33 // MATCHING INTERFACE: | |
34 // | |
35 // The "FullMatch" operation checks that supplied text matches a | |
36 // supplied pattern exactly. | |
37 // | |
38 // Example: successful match | |
39 // CHECK(PCRE::FullMatch("hello", "h.*o")); | |
40 // | |
41 // Example: unsuccessful match (requires full match): | |
42 // CHECK(!PCRE::FullMatch("hello", "e")); | |
43 // | |
44 // ----------------------------------------------------------------------- | |
45 // UTF-8 AND THE MATCHING INTERFACE: | |
46 // | |
47 // By default, pattern and text are plain text, one byte per character. | |
48 // The UTF8 flag, passed to the constructor, causes both pattern | |
49 // and string to be treated as UTF-8 text, still a byte stream but | |
50 // potentially multiple bytes per character. In practice, the text | |
51 // is likelier to be UTF-8 than the pattern, but the match returned | |
52 // may depend on the UTF8 flag, so always use it when matching | |
53 // UTF8 text. E.g., "." will match one byte normally but with UTF8 | |
54 // set may match up to three bytes of a multi-byte character. | |
55 // | |
56 // Example: | |
57 // PCRE re(utf8_pattern, PCRE::UTF8); | |
58 // CHECK(PCRE::FullMatch(utf8_string, re)); | |
59 // | |
60 // ----------------------------------------------------------------------- | |
61 // MATCHING WITH SUB-STRING EXTRACTION: | |
62 // | |
63 // You can supply extra pointer arguments to extract matched subpieces. | |
64 // | |
65 // Example: extracts "ruby" into "s" and 1234 into "i" | |
66 // int i; | |
67 // string s; | |
68 // CHECK(PCRE::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i)); | |
69 // | |
70 // Example: fails because string cannot be stored in integer | |
71 // CHECK(!PCRE::FullMatch("ruby", "(.*)", &i)); | |
72 // | |
73 // Example: fails because there aren't enough sub-patterns: | |
74 // CHECK(!PCRE::FullMatch("ruby:1234", "\\w+:\\d+", &s)); | |
75 // | |
76 // Example: does not try to extract any extra sub-patterns | |
77 // CHECK(PCRE::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s)); | |
78 // | |
79 // Example: does not try to extract into NULL | |
80 // CHECK(PCRE::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i)); | |
81 // | |
82 // Example: integer overflow causes failure | |
83 // CHECK(!PCRE::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i)); | |
84 // | |
85 // ----------------------------------------------------------------------- | |
86 // PARTIAL MATCHES | |
87 // | |
88 // You can use the "PartialMatch" operation when you want the pattern | |
89 // to match any substring of the text. | |
90 // | |
91 // Example: simple search for a string: | |
92 // CHECK(PCRE::PartialMatch("hello", "ell")); | |
93 // | |
94 // Example: find first number in a string | |
95 // int number; | |
96 // CHECK(PCRE::PartialMatch("x*100 + 20", "(\\d+)", &number)); | |
97 // CHECK_EQ(number, 100); | |
98 // | |
99 // ----------------------------------------------------------------------- | |
100 // PPCRE-COMPILED PCREGULAR EXPPCRESSIONS | |
101 // | |
102 // PCRE makes it easy to use any string as a regular expression, without | |
103 // requiring a separate compilation step. | |
104 // | |
105 // If speed is of the essence, you can create a pre-compiled "PCRE" | |
106 // object from the pattern and use it multiple times. If you do so, | |
107 // you can typically parse text faster than with sscanf. | |
108 // | |
109 // Example: precompile pattern for faster matching: | |
110 // PCRE pattern("h.*o"); | |
111 // while (ReadLine(&str)) { | |
112 // if (PCRE::FullMatch(str, pattern)) ...; | |
113 // } | |
114 // | |
115 // ----------------------------------------------------------------------- | |
116 // SCANNING TEXT INCPCREMENTALLY | |
117 // | |
118 // The "Consume" operation may be useful if you want to repeatedly | |
119 // match regular expressions at the front of a string and skip over | |
120 // them as they match. This requires use of the "StringPiece" type, | |
121 // which represents a sub-range of a real string. | |
122 // | |
123 // Example: read lines of the form "var = value" from a string. | |
124 // string contents = ...; // Fill string somehow | |
125 // StringPiece input(contents); // Wrap a StringPiece around it | |
126 // | |
127 // string var; | |
128 // int value; | |
129 // while (PCRE::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) { | |
130 // ...; | |
131 // } | |
132 // | |
133 // Each successful call to "Consume" will set "var/value", and also | |
134 // advance "input" so it points past the matched text. Note that if the | |
135 // regular expression matches an empty string, input will advance | |
136 // by 0 bytes. If the regular expression being used might match | |
137 // an empty string, the loop body must check for this case and either | |
138 // advance the string or break out of the loop. | |
139 // | |
140 // The "FindAndConsume" operation is similar to "Consume" but does not | |
141 // anchor your match at the beginning of the string. For example, you | |
142 // could extract all words from a string by repeatedly calling | |
143 // PCRE::FindAndConsume(&input, "(\\w+)", &word) | |
144 // | |
145 // ----------------------------------------------------------------------- | |
146 // PARSING HEX/OCTAL/C-RADIX NUMBERS | |
147 // | |
148 // By default, if you pass a pointer to a numeric value, the | |
149 // corresponding text is interpreted as a base-10 number. You can | |
150 // instead wrap the pointer with a call to one of the operators Hex(), | |
151 // Octal(), or CRadix() to interpret the text in another base. The | |
152 // CRadix operator interprets C-style "0" (base-8) and "0x" (base-16) | |
153 // prefixes, but defaults to base-10. | |
154 // | |
155 // Example: | |
156 // int a, b, c, d; | |
157 // CHECK(PCRE::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)", | |
158 // Octal(&a), Hex(&b), CRadix(&c), CRadix(&d)); | |
159 // will leave 64 in a, b, c, and d. | |
160 | |
161 #include "util/util.h" | |
162 #include "re2/stringpiece.h" | |
163 | |
164 #ifdef USEPCRE | |
165 #include <pcre.h> | |
166 namespace re2 { | |
167 const bool UsingPCRE = true; | |
168 } // namespace re2 | |
169 #else | |
170 struct pcre; // opaque | |
171 namespace re2 { | |
172 const bool UsingPCRE = false; | |
173 } // namespace re2 | |
174 #endif | |
175 | |
176 namespace re2 { | |
177 | |
178 class PCRE_Options; | |
179 | |
180 // Interface for regular expression matching. Also corresponds to a | |
181 // pre-compiled regular expression. An "PCRE" object is safe for | |
182 // concurrent use by multiple threads. | |
183 class PCRE { | |
184 public: | |
185 // We convert user-passed pointers into special Arg objects | |
186 class Arg; | |
187 | |
188 // Marks end of arg list. | |
189 // ONLY USE IN OPTIONAL ARG DEFAULTS. | |
190 // DO NOT PASS EXPLICITLY. | |
191 static Arg no_more_args; | |
192 | |
193 // Options are same value as those in pcre. We provide them here | |
194 // to avoid users needing to include pcre.h and also to isolate | |
195 // users from pcre should we change the underlying library. | |
196 // Only those needed by Google programs are exposed here to | |
197 // avoid collision with options employed internally by regexp.cc | |
198 // Note that some options have equivalents that can be specified in | |
199 // the regexp itself. For example, prefixing your regexp with | |
200 // "(?s)" has the same effect as the PCRE_DOTALL option. | |
201 enum Option { | |
202 None = 0x0000, | |
203 UTF8 = 0x0800, // == PCRE_UTF8 | |
204 EnabledCompileOptions = UTF8, | |
205 EnabledExecOptions = 0x0000, // TODO: use to replace anchor flag | |
206 }; | |
207 | |
208 // We provide implicit conversions from strings so that users can | |
209 // pass in a string or a "const char*" wherever an "PCRE" is expected. | |
210 PCRE(const char* pattern); | |
211 PCRE(const char* pattern, Option option); | |
212 PCRE(const string& pattern); | |
213 PCRE(const string& pattern, Option option); | |
214 PCRE(const char *pattern, const PCRE_Options& re_option); | |
215 PCRE(const string& pattern, const PCRE_Options& re_option); | |
216 | |
217 ~PCRE(); | |
218 | |
219 // The string specification for this PCRE. E.g. | |
220 // PCRE re("ab*c?d+"); | |
221 // re.pattern(); // "ab*c?d+" | |
222 const string& pattern() const { return pattern_; } | |
223 | |
224 // If PCRE could not be created properly, returns an error string. | |
225 // Else returns the empty string. | |
226 const string& error() const { return *error_; } | |
227 | |
228 // Whether the PCRE has hit a match limit during execution. | |
229 // Not thread safe. Intended only for testing. | |
230 // If hitting match limits is a problem, | |
231 // you should be using PCRE2 (re2/re2.h) | |
232 // instead of checking this flag. | |
233 bool HitLimit(); | |
234 void ClearHitLimit(); | |
235 | |
236 /***** The useful part: the matching interface *****/ | |
237 | |
238 // Matches "text" against "pattern". If pointer arguments are | |
239 // supplied, copies matched sub-patterns into them. | |
240 // | |
241 // You can pass in a "const char*" or a "string" for "text". | |
242 // You can pass in a "const char*" or a "string" or a "PCRE" for "pattern". | |
243 // | |
244 // The provided pointer arguments can be pointers to any scalar numeric | |
245 // type, or one of: | |
246 // string (matched piece is copied to string) | |
247 // StringPiece (StringPiece is mutated to point to matched piece) | |
248 // T (where "bool T::ParseFrom(const char*, int)" exists) | |
249 // (void*)NULL (the corresponding matched sub-pattern is not copied) | |
250 // | |
251 // Returns true iff all of the following conditions are satisfied: | |
252 // a. "text" matches "pattern" exactly | |
253 // b. The number of matched sub-patterns is >= number of supplied pointers | |
254 // c. The "i"th argument has a suitable type for holding the | |
255 // string captured as the "i"th sub-pattern. If you pass in | |
256 // NULL for the "i"th argument, or pass fewer arguments than | |
257 // number of sub-patterns, "i"th captured sub-pattern is | |
258 // ignored. | |
259 // | |
260 // CAVEAT: An optional sub-pattern that does not exist in the | |
261 // matched string is assigned the empty string. Therefore, the | |
262 // following will return false (because the empty string is not a | |
263 // valid number): | |
264 // int number; | |
265 // PCRE::FullMatch("abc", "[a-z]+(\\d+)?", &number); | |
266 struct FullMatchFunctor { | |
267 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args | |
268 const Arg& ptr1 = no_more_args, | |
269 const Arg& ptr2 = no_more_args, | |
270 const Arg& ptr3 = no_more_args, | |
271 const Arg& ptr4 = no_more_args, | |
272 const Arg& ptr5 = no_more_args, | |
273 const Arg& ptr6 = no_more_args, | |
274 const Arg& ptr7 = no_more_args, | |
275 const Arg& ptr8 = no_more_args, | |
276 const Arg& ptr9 = no_more_args, | |
277 const Arg& ptr10 = no_more_args, | |
278 const Arg& ptr11 = no_more_args, | |
279 const Arg& ptr12 = no_more_args, | |
280 const Arg& ptr13 = no_more_args, | |
281 const Arg& ptr14 = no_more_args, | |
282 const Arg& ptr15 = no_more_args, | |
283 const Arg& ptr16 = no_more_args) const; | |
284 }; | |
285 | |
286 static const FullMatchFunctor FullMatch; | |
287 | |
288 // Exactly like FullMatch(), except that "pattern" is allowed to match | |
289 // a substring of "text". | |
290 struct PartialMatchFunctor { | |
291 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args | |
292 const Arg& ptr1 = no_more_args, | |
293 const Arg& ptr2 = no_more_args, | |
294 const Arg& ptr3 = no_more_args, | |
295 const Arg& ptr4 = no_more_args, | |
296 const Arg& ptr5 = no_more_args, | |
297 const Arg& ptr6 = no_more_args, | |
298 const Arg& ptr7 = no_more_args, | |
299 const Arg& ptr8 = no_more_args, | |
300 const Arg& ptr9 = no_more_args, | |
301 const Arg& ptr10 = no_more_args, | |
302 const Arg& ptr11 = no_more_args, | |
303 const Arg& ptr12 = no_more_args, | |
304 const Arg& ptr13 = no_more_args, | |
305 const Arg& ptr14 = no_more_args, | |
306 const Arg& ptr15 = no_more_args, | |
307 const Arg& ptr16 = no_more_args) const; | |
308 }; | |
309 | |
310 static const PartialMatchFunctor PartialMatch; | |
311 | |
312 // Like FullMatch() and PartialMatch(), except that pattern has to | |
313 // match a prefix of "text", and "input" is advanced past the matched | |
314 // text. Note: "input" is modified iff this routine returns true. | |
315 struct ConsumeFunctor { | |
316 bool operator ()(StringPiece* input, const PCRE& pattern, // 3..16 args | |
317 const Arg& ptr1 = no_more_args, | |
318 const Arg& ptr2 = no_more_args, | |
319 const Arg& ptr3 = no_more_args, | |
320 const Arg& ptr4 = no_more_args, | |
321 const Arg& ptr5 = no_more_args, | |
322 const Arg& ptr6 = no_more_args, | |
323 const Arg& ptr7 = no_more_args, | |
324 const Arg& ptr8 = no_more_args, | |
325 const Arg& ptr9 = no_more_args, | |
326 const Arg& ptr10 = no_more_args, | |
327 const Arg& ptr11 = no_more_args, | |
328 const Arg& ptr12 = no_more_args, | |
329 const Arg& ptr13 = no_more_args, | |
330 const Arg& ptr14 = no_more_args, | |
331 const Arg& ptr15 = no_more_args, | |
332 const Arg& ptr16 = no_more_args) const; | |
333 }; | |
334 | |
335 static const ConsumeFunctor Consume; | |
336 | |
337 // Like Consume(..), but does not anchor the match at the beginning of the | |
338 // string. That is, "pattern" need not start its match at the beginning of | |
339 // "input". For example, "FindAndConsume(s, "(\\w+)", &word)" finds the next | |
340 // word in "s" and stores it in "word". | |
341 struct FindAndConsumeFunctor { | |
342 bool operator ()(StringPiece* input, const PCRE& pattern, | |
343 const Arg& ptr1 = no_more_args, | |
344 const Arg& ptr2 = no_more_args, | |
345 const Arg& ptr3 = no_more_args, | |
346 const Arg& ptr4 = no_more_args, | |
347 const Arg& ptr5 = no_more_args, | |
348 const Arg& ptr6 = no_more_args, | |
349 const Arg& ptr7 = no_more_args, | |
350 const Arg& ptr8 = no_more_args, | |
351 const Arg& ptr9 = no_more_args, | |
352 const Arg& ptr10 = no_more_args, | |
353 const Arg& ptr11 = no_more_args, | |
354 const Arg& ptr12 = no_more_args, | |
355 const Arg& ptr13 = no_more_args, | |
356 const Arg& ptr14 = no_more_args, | |
357 const Arg& ptr15 = no_more_args, | |
358 const Arg& ptr16 = no_more_args) const; | |
359 }; | |
360 | |
361 static const FindAndConsumeFunctor FindAndConsume; | |
362 | |
363 // Replace the first match of "pattern" in "str" with "rewrite". | |
364 // Within "rewrite", backslash-escaped digits (\1 to \9) can be | |
365 // used to insert text matching corresponding parenthesized group | |
366 // from the pattern. \0 in "rewrite" refers to the entire matching | |
367 // text. E.g., | |
368 // | |
369 // string s = "yabba dabba doo"; | |
370 // CHECK(PCRE::Replace(&s, "b+", "d")); | |
371 // | |
372 // will leave "s" containing "yada dabba doo" | |
373 // | |
374 // Returns true if the pattern matches and a replacement occurs, | |
375 // false otherwise. | |
376 static bool Replace(string *str, | |
377 const PCRE& pattern, | |
378 const StringPiece& rewrite); | |
379 | |
380 // Like Replace(), except replaces all occurrences of the pattern in | |
381 // the string with the rewrite. Replacements are not subject to | |
382 // re-matching. E.g., | |
383 // | |
384 // string s = "yabba dabba doo"; | |
385 // CHECK(PCRE::GlobalReplace(&s, "b+", "d")); | |
386 // | |
387 // will leave "s" containing "yada dada doo" | |
388 // | |
389 // Returns the number of replacements made. | |
390 static int GlobalReplace(string *str, | |
391 const PCRE& pattern, | |
392 const StringPiece& rewrite); | |
393 | |
394 // Like Replace, except that if the pattern matches, "rewrite" | |
395 // is copied into "out" with substitutions. The non-matching | |
396 // portions of "text" are ignored. | |
397 // | |
398 // Returns true iff a match occurred and the extraction happened | |
399 // successfully; if no match occurs, the string is left unaffected. | |
400 static bool Extract(const StringPiece &text, | |
401 const PCRE& pattern, | |
402 const StringPiece &rewrite, | |
403 string *out); | |
404 | |
405 // Check that the given @p rewrite string is suitable for use with | |
406 // this PCRE. It checks that: | |
407 // * The PCRE has enough parenthesized subexpressions to satisfy all | |
408 // of the \N tokens in @p rewrite, and | |
409 // * The @p rewrite string doesn't have any syntax errors | |
410 // ('\' followed by anything besides [0-9] and '\'). | |
411 // Making this test will guarantee that "replace" and "extract" | |
412 // operations won't LOG(ERROR) or fail because of a bad rewrite | |
413 // string. | |
414 // @param rewrite The proposed rewrite string. | |
415 // @param error An error message is recorded here, iff we return false. | |
416 // Otherwise, it is unchanged. | |
417 // @return true, iff @p rewrite is suitable for use with the PCRE. | |
418 bool CheckRewriteString(const StringPiece& rewrite, string* error) const; | |
419 | |
420 // Returns a copy of 'unquoted' with all potentially meaningful | |
421 // regexp characters backslash-escaped. The returned string, used | |
422 // as a regular expression, will exactly match the original string. | |
423 // For example, | |
424 // 1.5-2.0? | |
425 // becomes: | |
426 // 1\.5\-2\.0\? | |
427 static string QuoteMeta(const StringPiece& unquoted); | |
428 | |
429 /***** Generic matching interface (not so nice to use) *****/ | |
430 | |
431 // Type of match (TODO: Should be restructured as an Option) | |
432 enum Anchor { | |
433 UNANCHORED, // No anchoring | |
434 ANCHOR_START, // Anchor at start only | |
435 ANCHOR_BOTH, // Anchor at start and end | |
436 }; | |
437 | |
438 // General matching routine. Stores the length of the match in | |
439 // "*consumed" if successful. | |
440 bool DoMatch(const StringPiece& text, | |
441 Anchor anchor, | |
442 int* consumed, | |
443 const Arg* const* args, int n) const; | |
444 | |
445 // Return the number of capturing subpatterns, or -1 if the | |
446 // regexp wasn't valid on construction. | |
447 int NumberOfCapturingGroups() const; | |
448 | |
449 private: | |
450 void Init(const char* pattern, Option option, int match_limit, | |
451 int stack_limit, bool report_errors); | |
452 | |
453 // Match against "text", filling in "vec" (up to "vecsize" * 2/3) with | |
454 // pairs of integers for the beginning and end positions of matched | |
455 // text. The first pair corresponds to the entire matched text; | |
456 // subsequent pairs correspond, in order, to parentheses-captured | |
457 // matches. Returns the number of pairs (one more than the number of | |
458 // the last subpattern with a match) if matching was successful | |
459 // and zero if the match failed. | |
460 // I.e. for PCRE("(foo)|(bar)|(baz)") it will return 2, 3, and 4 when matching | |
461 // against "foo", "bar", and "baz" respectively. | |
462 // When matching PCRE("(foo)|hello") against "hello", it will return 1. | |
463 // But the values for all subpattern are filled in into "vec". | |
464 int TryMatch(const StringPiece& text, | |
465 int startpos, | |
466 Anchor anchor, | |
467 bool empty_ok, | |
468 int *vec, | |
469 int vecsize) const; | |
470 | |
471 // Append the "rewrite" string, with backslash subsitutions from "text" | |
472 // and "vec", to string "out". | |
473 bool Rewrite(string *out, | |
474 const StringPiece &rewrite, | |
475 const StringPiece &text, | |
476 int *vec, | |
477 int veclen) const; | |
478 | |
479 // internal implementation for DoMatch | |
480 bool DoMatchImpl(const StringPiece& text, | |
481 Anchor anchor, | |
482 int* consumed, | |
483 const Arg* const args[], | |
484 int n, | |
485 int* vec, | |
486 int vecsize) const; | |
487 | |
488 // Compile the regexp for the specified anchoring mode | |
489 pcre* Compile(Anchor anchor); | |
490 | |
491 string pattern_; | |
492 Option options_; | |
493 pcre* re_full_; // For full matches | |
494 pcre* re_partial_; // For partial matches | |
495 const string* error_; // Error indicator (or empty string) | |
496 bool report_errors_; // Silences error logging if false | |
497 int match_limit_; // Limit on execution resources | |
498 int stack_limit_; // Limit on stack resources (bytes) | |
499 mutable int32_t hit_limit_; // Hit limit during execution (bool)? | |
500 DISALLOW_COPY_AND_ASSIGN(PCRE); | |
501 }; | |
502 | |
503 // PCRE_Options allow you to set the PCRE::Options, plus any pcre | |
504 // "extra" options. The only extras are match_limit, which limits | |
505 // the CPU time of a match, and stack_limit, which limits the | |
506 // stack usage. Setting a limit to <= 0 lets PCRE pick a sensible default | |
507 // that should not cause too many problems in production code. | |
508 // If PCRE hits a limit during a match, it may return a false negative, | |
509 // but (hopefully) it won't crash. | |
510 // | |
511 // NOTE: If you are handling regular expressions specified by | |
512 // (external or internal) users, rather than hard-coded ones, | |
513 // you should be using PCRE2, which uses an alternate implementation | |
514 // that avoids these issues. See http://go/re2quick. | |
515 class PCRE_Options { | |
516 public: | |
517 // constructor | |
518 PCRE_Options() : option_(PCRE::None), match_limit_(0), stack_limit_(0), report
_errors_(true) {} | |
519 // accessors | |
520 PCRE::Option option() const { return option_; } | |
521 void set_option(PCRE::Option option) { | |
522 option_ = option; | |
523 } | |
524 int match_limit() const { return match_limit_; } | |
525 void set_match_limit(int match_limit) { | |
526 match_limit_ = match_limit; | |
527 } | |
528 int stack_limit() const { return stack_limit_; } | |
529 void set_stack_limit(int stack_limit) { | |
530 stack_limit_ = stack_limit; | |
531 } | |
532 | |
533 // If the regular expression is malformed, an error message will be printed | |
534 // iff report_errors() is true. Default: true. | |
535 bool report_errors() const { return report_errors_; } | |
536 void set_report_errors(bool report_errors) { | |
537 report_errors_ = report_errors; | |
538 } | |
539 private: | |
540 PCRE::Option option_; | |
541 int match_limit_; | |
542 int stack_limit_; | |
543 bool report_errors_; | |
544 }; | |
545 | |
546 | |
547 /***** Implementation details *****/ | |
548 | |
549 // Hex/Octal/Binary? | |
550 | |
551 // Special class for parsing into objects that define a ParseFrom() method | |
552 template <class T> | |
553 class _PCRE_MatchObject { | |
554 public: | |
555 static inline bool Parse(const char* str, int n, void* dest) { | |
556 if (dest == NULL) return true; | |
557 T* object = reinterpret_cast<T*>(dest); | |
558 return object->ParseFrom(str, n); | |
559 } | |
560 }; | |
561 | |
562 class PCRE::Arg { | |
563 public: | |
564 // Empty constructor so we can declare arrays of PCRE::Arg | |
565 Arg(); | |
566 | |
567 // Constructor specially designed for NULL arguments | |
568 Arg(void*); | |
569 | |
570 typedef bool (*Parser)(const char* str, int n, void* dest); | |
571 | |
572 // Type-specific parsers | |
573 #define MAKE_PARSER(type,name) \ | |
574 Arg(type* p) : arg_(p), parser_(name) { } \ | |
575 Arg(type* p, Parser parser) : arg_(p), parser_(parser) { } \ | |
576 | |
577 | |
578 MAKE_PARSER(char, parse_char); | |
579 MAKE_PARSER(unsigned char, parse_uchar); | |
580 MAKE_PARSER(short, parse_short); | |
581 MAKE_PARSER(unsigned short, parse_ushort); | |
582 MAKE_PARSER(int, parse_int); | |
583 MAKE_PARSER(unsigned int, parse_uint); | |
584 MAKE_PARSER(long, parse_long); | |
585 MAKE_PARSER(unsigned long, parse_ulong); | |
586 MAKE_PARSER(long long, parse_longlong); | |
587 MAKE_PARSER(unsigned long long, parse_ulonglong); | |
588 MAKE_PARSER(float, parse_float); | |
589 MAKE_PARSER(double, parse_double); | |
590 MAKE_PARSER(string, parse_string); | |
591 MAKE_PARSER(StringPiece, parse_stringpiece); | |
592 | |
593 #undef MAKE_PARSER | |
594 | |
595 // Generic constructor | |
596 template <class T> Arg(T*, Parser parser); | |
597 // Generic constructor template | |
598 template <class T> Arg(T* p) | |
599 : arg_(p), parser_(_PCRE_MatchObject<T>::Parse) { | |
600 } | |
601 | |
602 // Parse the data | |
603 bool Parse(const char* str, int n) const; | |
604 | |
605 private: | |
606 void* arg_; | |
607 Parser parser_; | |
608 | |
609 static bool parse_null (const char* str, int n, void* dest); | |
610 static bool parse_char (const char* str, int n, void* dest); | |
611 static bool parse_uchar (const char* str, int n, void* dest); | |
612 static bool parse_float (const char* str, int n, void* dest); | |
613 static bool parse_double (const char* str, int n, void* dest); | |
614 static bool parse_string (const char* str, int n, void* dest); | |
615 static bool parse_stringpiece (const char* str, int n, void* dest); | |
616 | |
617 #define DECLARE_INTEGER_PARSER(name) \ | |
618 private: \ | |
619 static bool parse_ ## name(const char* str, int n, void* dest); \ | |
620 static bool parse_ ## name ## _radix( \ | |
621 const char* str, int n, void* dest, int radix); \ | |
622 public: \ | |
623 static bool parse_ ## name ## _hex(const char* str, int n, void* dest); \ | |
624 static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \ | |
625 static bool parse_ ## name ## _cradix(const char* str, int n, void* dest) | |
626 | |
627 DECLARE_INTEGER_PARSER(short); | |
628 DECLARE_INTEGER_PARSER(ushort); | |
629 DECLARE_INTEGER_PARSER(int); | |
630 DECLARE_INTEGER_PARSER(uint); | |
631 DECLARE_INTEGER_PARSER(long); | |
632 DECLARE_INTEGER_PARSER(ulong); | |
633 DECLARE_INTEGER_PARSER(longlong); | |
634 DECLARE_INTEGER_PARSER(ulonglong); | |
635 | |
636 #undef DECLARE_INTEGER_PARSER | |
637 }; | |
638 | |
639 inline PCRE::Arg::Arg() : arg_(NULL), parser_(parse_null) { } | |
640 inline PCRE::Arg::Arg(void* p) : arg_(p), parser_(parse_null) { } | |
641 | |
642 inline bool PCRE::Arg::Parse(const char* str, int n) const { | |
643 return (*parser_)(str, n, arg_); | |
644 } | |
645 | |
646 // This part of the parser, appropriate only for ints, deals with bases | |
647 #define MAKE_INTEGER_PARSER(type, name) \ | |
648 inline PCRE::Arg Hex(type* ptr) { \ | |
649 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _hex); } \ | |
650 inline PCRE::Arg Octal(type* ptr) { \ | |
651 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _octal); } \ | |
652 inline PCRE::Arg CRadix(type* ptr) { \ | |
653 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _cradix); } | |
654 | |
655 MAKE_INTEGER_PARSER(short, short); | |
656 MAKE_INTEGER_PARSER(unsigned short, ushort); | |
657 MAKE_INTEGER_PARSER(int, int); | |
658 MAKE_INTEGER_PARSER(unsigned int, uint); | |
659 MAKE_INTEGER_PARSER(long, long); | |
660 MAKE_INTEGER_PARSER(unsigned long, ulong); | |
661 MAKE_INTEGER_PARSER(long long, longlong); | |
662 MAKE_INTEGER_PARSER(unsigned long long, ulonglong); | |
663 | |
664 #undef MAKE_INTEGER_PARSER | |
665 | |
666 } // namespace re2 | |
OLD | NEW |