pcre.h revision 2ee91b4af4353b9e6a9d591c32fedfc58fd4ef35
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> 166namespace re2 { 167const bool UsingPCRE = true; 168} // namespace re2 169#else 170namespace re2 { 171const bool UsingPCRE = false; 172struct pcre; 173struct pcre_extra { int flags, match_limit, match_limit_recursion; }; 174#define pcre_free(x) {} 175#define PCRE_EXTRA_MATCH_LIMIT 0 176#define PCRE_EXTRA_MATCH_LIMIT_RECURSION 0 177#define PCRE_ANCHORED 0 178#define PCRE_NOTEMPTY 0 179#define PCRE_ERROR_NOMATCH 1 180#define PCRE_ERROR_MATCHLIMIT 2 181#define PCRE_ERROR_RECURSIONLIMIT 3 182#define PCRE_INFO_CAPTURECOUNT 0 183#define pcre_compile(a,b,c,d,e) ({ (void)(a); (void)(b); *(c)=""; *(d)=0; (void)(e); ((pcre*)0); }) 184#define pcre_exec(a, b, c, d, e, f, g, h) ({ (void)(a); (void)(b); (void)(c); (void)(d); (void)(e); (void)(f); (void)(g); (void)(h); 0; }) 185#define pcre_fullinfo(a, b, c, d) ({ (void)(a); (void)(b); (void)(c); *(d) = 0; 0; }) 186} // namespace re2 187#endif 188 189namespace re2 { 190 191class PCRE_Options; 192 193// Interface for regular expression matching. Also corresponds to a 194// pre-compiled regular expression. An "PCRE" object is safe for 195// concurrent use by multiple threads. 196class PCRE { 197 public: 198 // We convert user-passed pointers into special Arg objects 199 class Arg; 200 201 // Marks end of arg list. 202 // ONLY USE IN OPTIONAL ARG DEFAULTS. 203 // DO NOT PASS EXPLICITLY. 204 static Arg no_more_args; 205 206 // Options are same value as those in pcre. We provide them here 207 // to avoid users needing to include pcre.h and also to isolate 208 // users from pcre should we change the underlying library. 209 // Only those needed by Google programs are exposed here to 210 // avoid collision with options employed internally by regexp.cc 211 // Note that some options have equivalents that can be specified in 212 // the regexp itself. For example, prefixing your regexp with 213 // "(?s)" has the same effect as the PCRE_DOTALL option. 214 enum Option { 215 None = 0x0000, 216 UTF8 = 0x0800, // == PCRE_UTF8 217 EnabledCompileOptions = UTF8, 218 EnabledExecOptions = 0x0000, // TODO: use to replace anchor flag 219 }; 220 221 // We provide implicit conversions from strings so that users can 222 // pass in a string or a "const char*" wherever an "PCRE" is expected. 223 PCRE(const char* pattern); 224 PCRE(const char* pattern, Option option); 225 PCRE(const string& pattern); 226 PCRE(const string& pattern, Option option); 227 PCRE(const char *pattern, const PCRE_Options& re_option); 228 PCRE(const string& pattern, const PCRE_Options& re_option); 229 230 ~PCRE(); 231 232 // The string specification for this PCRE. E.g. 233 // PCRE re("ab*c?d+"); 234 // re.pattern(); // "ab*c?d+" 235 const string& pattern() const { return pattern_; } 236 237 // If PCRE could not be created properly, returns an error string. 238 // Else returns the empty string. 239 const string& error() const { return *error_; } 240 241 // Whether the PCRE has hit a match limit during execution. 242 // Not thread safe. Intended only for testing. 243 // If hitting match limits is a problem, 244 // you should be using PCRE2 (re2/re2.h) 245 // instead of checking this flag. 246 bool HitLimit(); 247 void ClearHitLimit(); 248 249 /***** The useful part: the matching interface *****/ 250 251 // Matches "text" against "pattern". If pointer arguments are 252 // supplied, copies matched sub-patterns into them. 253 // 254 // You can pass in a "const char*" or a "string" for "text". 255 // You can pass in a "const char*" or a "string" or a "PCRE" for "pattern". 256 // 257 // The provided pointer arguments can be pointers to any scalar numeric 258 // type, or one of: 259 // string (matched piece is copied to string) 260 // StringPiece (StringPiece is mutated to point to matched piece) 261 // T (where "bool T::ParseFrom(const char*, int)" exists) 262 // (void*)NULL (the corresponding matched sub-pattern is not copied) 263 // 264 // Returns true iff all of the following conditions are satisfied: 265 // a. "text" matches "pattern" exactly 266 // b. The number of matched sub-patterns is >= number of supplied pointers 267 // c. The "i"th argument has a suitable type for holding the 268 // string captured as the "i"th sub-pattern. If you pass in 269 // NULL for the "i"th argument, or pass fewer arguments than 270 // number of sub-patterns, "i"th captured sub-pattern is 271 // ignored. 272 // 273 // CAVEAT: An optional sub-pattern that does not exist in the 274 // matched string is assigned the empty string. Therefore, the 275 // following will return false (because the empty string is not a 276 // valid number): 277 // int number; 278 // PCRE::FullMatch("abc", "[a-z]+(\\d+)?", &number); 279 struct FullMatchFunctor { 280 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args 281 const Arg& ptr1 = no_more_args, 282 const Arg& ptr2 = no_more_args, 283 const Arg& ptr3 = no_more_args, 284 const Arg& ptr4 = no_more_args, 285 const Arg& ptr5 = no_more_args, 286 const Arg& ptr6 = no_more_args, 287 const Arg& ptr7 = no_more_args, 288 const Arg& ptr8 = no_more_args, 289 const Arg& ptr9 = no_more_args, 290 const Arg& ptr10 = no_more_args, 291 const Arg& ptr11 = no_more_args, 292 const Arg& ptr12 = no_more_args, 293 const Arg& ptr13 = no_more_args, 294 const Arg& ptr14 = no_more_args, 295 const Arg& ptr15 = no_more_args, 296 const Arg& ptr16 = no_more_args) const; 297 }; 298 299 static const FullMatchFunctor FullMatch; 300 301 // Exactly like FullMatch(), except that "pattern" is allowed to match 302 // a substring of "text". 303 struct PartialMatchFunctor { 304 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args 305 const Arg& ptr1 = no_more_args, 306 const Arg& ptr2 = no_more_args, 307 const Arg& ptr3 = no_more_args, 308 const Arg& ptr4 = no_more_args, 309 const Arg& ptr5 = no_more_args, 310 const Arg& ptr6 = no_more_args, 311 const Arg& ptr7 = no_more_args, 312 const Arg& ptr8 = no_more_args, 313 const Arg& ptr9 = no_more_args, 314 const Arg& ptr10 = no_more_args, 315 const Arg& ptr11 = no_more_args, 316 const Arg& ptr12 = no_more_args, 317 const Arg& ptr13 = no_more_args, 318 const Arg& ptr14 = no_more_args, 319 const Arg& ptr15 = no_more_args, 320 const Arg& ptr16 = no_more_args) const; 321 }; 322 323 static const PartialMatchFunctor PartialMatch; 324 325 // Like FullMatch() and PartialMatch(), except that pattern has to 326 // match a prefix of "text", and "input" is advanced past the matched 327 // text. Note: "input" is modified iff this routine returns true. 328 struct ConsumeFunctor { 329 bool operator ()(StringPiece* input, const PCRE& pattern, // 3..16 args 330 const Arg& ptr1 = no_more_args, 331 const Arg& ptr2 = no_more_args, 332 const Arg& ptr3 = no_more_args, 333 const Arg& ptr4 = no_more_args, 334 const Arg& ptr5 = no_more_args, 335 const Arg& ptr6 = no_more_args, 336 const Arg& ptr7 = no_more_args, 337 const Arg& ptr8 = no_more_args, 338 const Arg& ptr9 = no_more_args, 339 const Arg& ptr10 = no_more_args, 340 const Arg& ptr11 = no_more_args, 341 const Arg& ptr12 = no_more_args, 342 const Arg& ptr13 = no_more_args, 343 const Arg& ptr14 = no_more_args, 344 const Arg& ptr15 = no_more_args, 345 const Arg& ptr16 = no_more_args) const; 346 }; 347 348 static const ConsumeFunctor Consume; 349 350 // Like Consume(..), but does not anchor the match at the beginning of the 351 // string. That is, "pattern" need not start its match at the beginning of 352 // "input". For example, "FindAndConsume(s, "(\\w+)", &word)" finds the next 353 // word in "s" and stores it in "word". 354 struct FindAndConsumeFunctor { 355 bool operator ()(StringPiece* input, const PCRE& pattern, 356 const Arg& ptr1 = no_more_args, 357 const Arg& ptr2 = no_more_args, 358 const Arg& ptr3 = no_more_args, 359 const Arg& ptr4 = no_more_args, 360 const Arg& ptr5 = no_more_args, 361 const Arg& ptr6 = no_more_args, 362 const Arg& ptr7 = no_more_args, 363 const Arg& ptr8 = no_more_args, 364 const Arg& ptr9 = no_more_args, 365 const Arg& ptr10 = no_more_args, 366 const Arg& ptr11 = no_more_args, 367 const Arg& ptr12 = no_more_args, 368 const Arg& ptr13 = no_more_args, 369 const Arg& ptr14 = no_more_args, 370 const Arg& ptr15 = no_more_args, 371 const Arg& ptr16 = no_more_args) const; 372 }; 373 374 static const FindAndConsumeFunctor FindAndConsume; 375 376 // Replace the first match of "pattern" in "str" with "rewrite". 377 // Within "rewrite", backslash-escaped digits (\1 to \9) can be 378 // used to insert text matching corresponding parenthesized group 379 // from the pattern. \0 in "rewrite" refers to the entire matching 380 // text. E.g., 381 // 382 // string s = "yabba dabba doo"; 383 // CHECK(PCRE::Replace(&s, "b+", "d")); 384 // 385 // will leave "s" containing "yada dabba doo" 386 // 387 // Returns true if the pattern matches and a replacement occurs, 388 // false otherwise. 389 static bool Replace(string *str, 390 const PCRE& pattern, 391 const StringPiece& rewrite); 392 393 // Like Replace(), except replaces all occurrences of the pattern in 394 // the string with the rewrite. Replacements are not subject to 395 // re-matching. E.g., 396 // 397 // string s = "yabba dabba doo"; 398 // CHECK(PCRE::GlobalReplace(&s, "b+", "d")); 399 // 400 // will leave "s" containing "yada dada doo" 401 // 402 // Returns the number of replacements made. 403 static int GlobalReplace(string *str, 404 const PCRE& pattern, 405 const StringPiece& rewrite); 406 407 // Like Replace, except that if the pattern matches, "rewrite" 408 // is copied into "out" with substitutions. The non-matching 409 // portions of "text" are ignored. 410 // 411 // Returns true iff a match occurred and the extraction happened 412 // successfully; if no match occurs, the string is left unaffected. 413 static bool Extract(const StringPiece &text, 414 const PCRE& pattern, 415 const StringPiece &rewrite, 416 string *out); 417 418 // Check that the given @p rewrite string is suitable for use with 419 // this PCRE. It checks that: 420 // * The PCRE has enough parenthesized subexpressions to satisfy all 421 // of the \N tokens in @p rewrite, and 422 // * The @p rewrite string doesn't have any syntax errors 423 // ('\' followed by anything besides [0-9] and '\'). 424 // Making this test will guarantee that "replace" and "extract" 425 // operations won't LOG(ERROR) or fail because of a bad rewrite 426 // string. 427 // @param rewrite The proposed rewrite string. 428 // @param error An error message is recorded here, iff we return false. 429 // Otherwise, it is unchanged. 430 // @return true, iff @p rewrite is suitable for use with the PCRE. 431 bool CheckRewriteString(const StringPiece& rewrite, string* error) const; 432 433 // Returns a copy of 'unquoted' with all potentially meaningful 434 // regexp characters backslash-escaped. The returned string, used 435 // as a regular expression, will exactly match the original string. 436 // For example, 437 // 1.5-2.0? 438 // becomes: 439 // 1\.5\-2\.0\? 440 static string QuoteMeta(const StringPiece& unquoted); 441 442 /***** Generic matching interface (not so nice to use) *****/ 443 444 // Type of match (TODO: Should be restructured as an Option) 445 enum Anchor { 446 UNANCHORED, // No anchoring 447 ANCHOR_START, // Anchor at start only 448 ANCHOR_BOTH, // Anchor at start and end 449 }; 450 451 // General matching routine. Stores the length of the match in 452 // "*consumed" if successful. 453 bool DoMatch(const StringPiece& text, 454 Anchor anchor, 455 int* consumed, 456 const Arg* const* args, int n) const; 457 458 // Return the number of capturing subpatterns, or -1 if the 459 // regexp wasn't valid on construction. 460 int NumberOfCapturingGroups() const; 461 462 private: 463 void Init(const char* pattern, Option option, int match_limit, 464 int stack_limit, bool report_errors); 465 466 // Match against "text", filling in "vec" (up to "vecsize" * 2/3) with 467 // pairs of integers for the beginning and end positions of matched 468 // text. The first pair corresponds to the entire matched text; 469 // subsequent pairs correspond, in order, to parentheses-captured 470 // matches. Returns the number of pairs (one more than the number of 471 // the last subpattern with a match) if matching was successful 472 // and zero if the match failed. 473 // I.e. for PCRE("(foo)|(bar)|(baz)") it will return 2, 3, and 4 when matching 474 // against "foo", "bar", and "baz" respectively. 475 // When matching PCRE("(foo)|hello") against "hello", it will return 1. 476 // But the values for all subpattern are filled in into "vec". 477 int TryMatch(const StringPiece& text, 478 int startpos, 479 Anchor anchor, 480 bool empty_ok, 481 int *vec, 482 int vecsize) const; 483 484 // Append the "rewrite" string, with backslash subsitutions from "text" 485 // and "vec", to string "out". 486 bool Rewrite(string *out, 487 const StringPiece &rewrite, 488 const StringPiece &text, 489 int *vec, 490 int veclen) const; 491 492 // internal implementation for DoMatch 493 bool DoMatchImpl(const StringPiece& text, 494 Anchor anchor, 495 int* consumed, 496 const Arg* const args[], 497 int n, 498 int* vec, 499 int vecsize) const; 500 501 // Compile the regexp for the specified anchoring mode 502 pcre* Compile(Anchor anchor); 503 504 string pattern_; 505 Option options_; 506 pcre* re_full_; // For full matches 507 pcre* re_partial_; // For partial matches 508 const string* error_; // Error indicator (or empty string) 509 bool report_errors_; // Silences error logging if false 510 int match_limit_; // Limit on execution resources 511 int stack_limit_; // Limit on stack resources (bytes) 512 mutable int32_t hit_limit_; // Hit limit during execution (bool)? 513 DISALLOW_EVIL_CONSTRUCTORS(PCRE); 514}; 515 516// PCRE_Options allow you to set the PCRE::Options, plus any pcre 517// "extra" options. The only extras are match_limit, which limits 518// the CPU time of a match, and stack_limit, which limits the 519// stack usage. Setting a limit to <= 0 lets PCRE pick a sensible default 520// that should not cause too many problems in production code. 521// If PCRE hits a limit during a match, it may return a false negative, 522// but (hopefully) it won't crash. 523// 524// NOTE: If you are handling regular expressions specified by 525// (external or internal) users, rather than hard-coded ones, 526// you should be using PCRE2, which uses an alternate implementation 527// that avoids these issues. See http://go/re2quick. 528class PCRE_Options { 529 public: 530 // constructor 531 PCRE_Options() : option_(PCRE::None), match_limit_(0), stack_limit_(0), report_errors_(true) {} 532 // accessors 533 PCRE::Option option() const { return option_; } 534 void set_option(PCRE::Option option) { 535 option_ = option; 536 } 537 int match_limit() const { return match_limit_; } 538 void set_match_limit(int match_limit) { 539 match_limit_ = match_limit; 540 } 541 int stack_limit() const { return stack_limit_; } 542 void set_stack_limit(int stack_limit) { 543 stack_limit_ = stack_limit; 544 } 545 546 // If the regular expression is malformed, an error message will be printed 547 // iff report_errors() is true. Default: true. 548 bool report_errors() const { return report_errors_; } 549 void set_report_errors(bool report_errors) { 550 report_errors_ = report_errors; 551 } 552 private: 553 PCRE::Option option_; 554 int match_limit_; 555 int stack_limit_; 556 bool report_errors_; 557}; 558 559 560/***** Implementation details *****/ 561 562// Hex/Octal/Binary? 563 564// Special class for parsing into objects that define a ParseFrom() method 565template <class T> 566class _PCRE_MatchObject { 567 public: 568 static inline bool Parse(const char* str, int n, void* dest) { 569 if (dest == NULL) return true; 570 T* object = reinterpret_cast<T*>(dest); 571 return object->ParseFrom(str, n); 572 } 573}; 574 575class PCRE::Arg { 576 public: 577 // Empty constructor so we can declare arrays of PCRE::Arg 578 Arg(); 579 580 // Constructor specially designed for NULL arguments 581 Arg(void*); 582 583 typedef bool (*Parser)(const char* str, int n, void* dest); 584 585// Type-specific parsers 586#define MAKE_PARSER(type,name) \ 587 Arg(type* p) : arg_(p), parser_(name) { } \ 588 Arg(type* p, Parser parser) : arg_(p), parser_(parser) { } \ 589 590 591 MAKE_PARSER(char, parse_char); 592 MAKE_PARSER(unsigned char, parse_uchar); 593 MAKE_PARSER(short, parse_short); 594 MAKE_PARSER(unsigned short, parse_ushort); 595 MAKE_PARSER(int, parse_int); 596 MAKE_PARSER(unsigned int, parse_uint); 597 MAKE_PARSER(long, parse_long); 598 MAKE_PARSER(unsigned long, parse_ulong); 599 MAKE_PARSER(long long, parse_longlong); 600 MAKE_PARSER(unsigned long long, parse_ulonglong); 601 MAKE_PARSER(float, parse_float); 602 MAKE_PARSER(double, parse_double); 603 MAKE_PARSER(string, parse_string); 604 MAKE_PARSER(StringPiece, parse_stringpiece); 605 606#undef MAKE_PARSER 607 608 // Generic constructor 609 template <class T> Arg(T*, Parser parser); 610 // Generic constructor template 611 template <class T> Arg(T* p) 612 : arg_(p), parser_(_PCRE_MatchObject<T>::Parse) { 613 } 614 615 // Parse the data 616 bool Parse(const char* str, int n) const; 617 618 private: 619 void* arg_; 620 Parser parser_; 621 622 static bool parse_null (const char* str, int n, void* dest); 623 static bool parse_char (const char* str, int n, void* dest); 624 static bool parse_uchar (const char* str, int n, void* dest); 625 static bool parse_float (const char* str, int n, void* dest); 626 static bool parse_double (const char* str, int n, void* dest); 627 static bool parse_string (const char* str, int n, void* dest); 628 static bool parse_stringpiece (const char* str, int n, void* dest); 629 630#define DECLARE_INTEGER_PARSER(name) \ 631 private: \ 632 static bool parse_ ## name(const char* str, int n, void* dest); \ 633 static bool parse_ ## name ## _radix( \ 634 const char* str, int n, void* dest, int radix); \ 635 public: \ 636 static bool parse_ ## name ## _hex(const char* str, int n, void* dest); \ 637 static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \ 638 static bool parse_ ## name ## _cradix(const char* str, int n, void* dest) 639 640 DECLARE_INTEGER_PARSER(short); 641 DECLARE_INTEGER_PARSER(ushort); 642 DECLARE_INTEGER_PARSER(int); 643 DECLARE_INTEGER_PARSER(uint); 644 DECLARE_INTEGER_PARSER(long); 645 DECLARE_INTEGER_PARSER(ulong); 646 DECLARE_INTEGER_PARSER(longlong); 647 DECLARE_INTEGER_PARSER(ulonglong); 648 649#undef DECLARE_INTEGER_PARSER 650}; 651 652inline PCRE::Arg::Arg() : arg_(NULL), parser_(parse_null) { } 653inline PCRE::Arg::Arg(void* p) : arg_(p), parser_(parse_null) { } 654 655inline bool PCRE::Arg::Parse(const char* str, int n) const { 656 return (*parser_)(str, n, arg_); 657} 658 659// This part of the parser, appropriate only for ints, deals with bases 660#define MAKE_INTEGER_PARSER(type, name) \ 661 inline PCRE::Arg Hex(type* ptr) { \ 662 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _hex); } \ 663 inline PCRE::Arg Octal(type* ptr) { \ 664 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _octal); } \ 665 inline PCRE::Arg CRadix(type* ptr) { \ 666 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _cradix); } 667 668MAKE_INTEGER_PARSER(short, short); 669MAKE_INTEGER_PARSER(unsigned short, ushort); 670MAKE_INTEGER_PARSER(int, int); 671MAKE_INTEGER_PARSER(unsigned int, uint); 672MAKE_INTEGER_PARSER(long, long); 673MAKE_INTEGER_PARSER(unsigned long, ulong); 674MAKE_INTEGER_PARSER(long long, longlong); 675MAKE_INTEGER_PARSER(unsigned long long, ulonglong); 676 677#undef MAKE_INTEGER_PARSER 678 679} // namespace re2 680