| 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 |
|---|
Chromium Code Reviews
Issue 1544433002:
Replace RE2 import with a dependency (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master