Remove INJECT_EVENTS permissions from test APKs.
[chromium-blink-merge.git] / third_party / re2 / util / pcre.h
blob771ac91a7e51439fc9be3c6861b10b67d67c74d7
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.
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.
9 // C++ interface to the pcre regular-expression library. PCRE supports
10 // Perl-style regular expressions (with extensions like \d, \w, \s,
11 // ...).
13 // -----------------------------------------------------------------------
14 // REGEXP SYNTAX:
16 // This module uses the pcre library and hence supports its syntax
17 // for regular expressions:
19 // http://www.google.com/search?q=pcre
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:
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
32 // -----------------------------------------------------------------------
33 // MATCHING INTERFACE:
35 // The "FullMatch" operation checks that supplied text matches a
36 // supplied pattern exactly.
38 // Example: successful match
39 // CHECK(PCRE::FullMatch("hello", "h.*o"));
41 // Example: unsuccessful match (requires full match):
42 // CHECK(!PCRE::FullMatch("hello", "e"));
44 // -----------------------------------------------------------------------
45 // UTF-8 AND THE MATCHING INTERFACE:
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.
56 // Example:
57 // PCRE re(utf8_pattern, PCRE::UTF8);
58 // CHECK(PCRE::FullMatch(utf8_string, re));
60 // -----------------------------------------------------------------------
61 // MATCHING WITH SUB-STRING EXTRACTION:
63 // You can supply extra pointer arguments to extract matched subpieces.
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));
70 // Example: fails because string cannot be stored in integer
71 // CHECK(!PCRE::FullMatch("ruby", "(.*)", &i));
73 // Example: fails because there aren't enough sub-patterns:
74 // CHECK(!PCRE::FullMatch("ruby:1234", "\\w+:\\d+", &s));
76 // Example: does not try to extract any extra sub-patterns
77 // CHECK(PCRE::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
79 // Example: does not try to extract into NULL
80 // CHECK(PCRE::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i));
82 // Example: integer overflow causes failure
83 // CHECK(!PCRE::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i));
85 // -----------------------------------------------------------------------
86 // PARTIAL MATCHES
88 // You can use the "PartialMatch" operation when you want the pattern
89 // to match any substring of the text.
91 // Example: simple search for a string:
92 // CHECK(PCRE::PartialMatch("hello", "ell"));
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);
99 // -----------------------------------------------------------------------
100 // PPCRE-COMPILED PCREGULAR EXPPCRESSIONS
102 // PCRE makes it easy to use any string as a regular expression, without
103 // requiring a separate compilation step.
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.
109 // Example: precompile pattern for faster matching:
110 // PCRE pattern("h.*o");
111 // while (ReadLine(&str)) {
112 // if (PCRE::FullMatch(str, pattern)) ...;
113 // }
115 // -----------------------------------------------------------------------
116 // SCANNING TEXT INCPCREMENTALLY
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.
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
127 // string var;
128 // int value;
129 // while (PCRE::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) {
130 // ...;
131 // }
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.
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)
145 // -----------------------------------------------------------------------
146 // PARSING HEX/OCTAL/C-RADIX NUMBERS
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.
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.
161 #include "util/util.h"
162 #include "re2/stringpiece.h"
164 #ifdef USEPCRE
165 #include <pcre.h>
166 namespace re2 {
167 const bool UsingPCRE = true;
168 } // namespace re2
169 #else
170 namespace re2 {
171 const bool UsingPCRE = false;
172 struct pcre;
173 struct 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 #ifndef WIN32
184 #define pcre_compile(a,b,c,d,e) ({ (void)(a); (void)(b); *(c)=""; *(d)=0; (void)(e); ((pcre*)0); })
185 #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; })
186 #define pcre_fullinfo(a, b, c, d) ({ (void)(a); (void)(b); (void)(c); *(d) = 0; 0; })
187 #else
188 #define pcre_compile(a,b,c,d,e) NULL
189 #define pcre_exec(a, b, c, d, e, f, g, h) NULL
190 #define pcre_fullinfo(a, b, c, d) NULL
191 #endif
192 } // namespace re2
193 #endif
195 namespace re2 {
197 class PCRE_Options;
199 // Interface for regular expression matching. Also corresponds to a
200 // pre-compiled regular expression. An "PCRE" object is safe for
201 // concurrent use by multiple threads.
202 class PCRE {
203 public:
204 // We convert user-passed pointers into special Arg objects
205 class Arg;
207 // Marks end of arg list.
208 // ONLY USE IN OPTIONAL ARG DEFAULTS.
209 // DO NOT PASS EXPLICITLY.
210 static Arg no_more_args;
212 // Options are same value as those in pcre. We provide them here
213 // to avoid users needing to include pcre.h and also to isolate
214 // users from pcre should we change the underlying library.
215 // Only those needed by Google programs are exposed here to
216 // avoid collision with options employed internally by regexp.cc
217 // Note that some options have equivalents that can be specified in
218 // the regexp itself. For example, prefixing your regexp with
219 // "(?s)" has the same effect as the PCRE_DOTALL option.
220 enum Option {
221 None = 0x0000,
222 UTF8 = 0x0800, // == PCRE_UTF8
223 EnabledCompileOptions = UTF8,
224 EnabledExecOptions = 0x0000, // TODO: use to replace anchor flag
227 // We provide implicit conversions from strings so that users can
228 // pass in a string or a "const char*" wherever an "PCRE" is expected.
229 PCRE(const char* pattern);
230 PCRE(const char* pattern, Option option);
231 PCRE(const string& pattern);
232 PCRE(const string& pattern, Option option);
233 PCRE(const char *pattern, const PCRE_Options& re_option);
234 PCRE(const string& pattern, const PCRE_Options& re_option);
236 ~PCRE();
238 // The string specification for this PCRE. E.g.
239 // PCRE re("ab*c?d+");
240 // re.pattern(); // "ab*c?d+"
241 const string& pattern() const { return pattern_; }
243 // If PCRE could not be created properly, returns an error string.
244 // Else returns the empty string.
245 const string& error() const { return *error_; }
247 // Whether the PCRE has hit a match limit during execution.
248 // Not thread safe. Intended only for testing.
249 // If hitting match limits is a problem,
250 // you should be using PCRE2 (re2/re2.h)
251 // instead of checking this flag.
252 bool HitLimit();
253 void ClearHitLimit();
255 /***** The useful part: the matching interface *****/
257 // Matches "text" against "pattern". If pointer arguments are
258 // supplied, copies matched sub-patterns into them.
260 // You can pass in a "const char*" or a "string" for "text".
261 // You can pass in a "const char*" or a "string" or a "PCRE" for "pattern".
263 // The provided pointer arguments can be pointers to any scalar numeric
264 // type, or one of:
265 // string (matched piece is copied to string)
266 // StringPiece (StringPiece is mutated to point to matched piece)
267 // T (where "bool T::ParseFrom(const char*, int)" exists)
268 // (void*)NULL (the corresponding matched sub-pattern is not copied)
270 // Returns true iff all of the following conditions are satisfied:
271 // a. "text" matches "pattern" exactly
272 // b. The number of matched sub-patterns is >= number of supplied pointers
273 // c. The "i"th argument has a suitable type for holding the
274 // string captured as the "i"th sub-pattern. If you pass in
275 // NULL for the "i"th argument, or pass fewer arguments than
276 // number of sub-patterns, "i"th captured sub-pattern is
277 // ignored.
279 // CAVEAT: An optional sub-pattern that does not exist in the
280 // matched string is assigned the empty string. Therefore, the
281 // following will return false (because the empty string is not a
282 // valid number):
283 // int number;
284 // PCRE::FullMatch("abc", "[a-z]+(\\d+)?", &number);
285 struct FullMatchFunctor {
286 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args
287 const Arg& ptr1 = no_more_args,
288 const Arg& ptr2 = no_more_args,
289 const Arg& ptr3 = no_more_args,
290 const Arg& ptr4 = no_more_args,
291 const Arg& ptr5 = no_more_args,
292 const Arg& ptr6 = no_more_args,
293 const Arg& ptr7 = no_more_args,
294 const Arg& ptr8 = no_more_args,
295 const Arg& ptr9 = no_more_args,
296 const Arg& ptr10 = no_more_args,
297 const Arg& ptr11 = no_more_args,
298 const Arg& ptr12 = no_more_args,
299 const Arg& ptr13 = no_more_args,
300 const Arg& ptr14 = no_more_args,
301 const Arg& ptr15 = no_more_args,
302 const Arg& ptr16 = no_more_args) const;
305 static const FullMatchFunctor FullMatch;
307 // Exactly like FullMatch(), except that "pattern" is allowed to match
308 // a substring of "text".
309 struct PartialMatchFunctor {
310 bool operator ()(const StringPiece& text, const PCRE& re, // 3..16 args
311 const Arg& ptr1 = no_more_args,
312 const Arg& ptr2 = no_more_args,
313 const Arg& ptr3 = no_more_args,
314 const Arg& ptr4 = no_more_args,
315 const Arg& ptr5 = no_more_args,
316 const Arg& ptr6 = no_more_args,
317 const Arg& ptr7 = no_more_args,
318 const Arg& ptr8 = no_more_args,
319 const Arg& ptr9 = no_more_args,
320 const Arg& ptr10 = no_more_args,
321 const Arg& ptr11 = no_more_args,
322 const Arg& ptr12 = no_more_args,
323 const Arg& ptr13 = no_more_args,
324 const Arg& ptr14 = no_more_args,
325 const Arg& ptr15 = no_more_args,
326 const Arg& ptr16 = no_more_args) const;
329 static const PartialMatchFunctor PartialMatch;
331 // Like FullMatch() and PartialMatch(), except that pattern has to
332 // match a prefix of "text", and "input" is advanced past the matched
333 // text. Note: "input" is modified iff this routine returns true.
334 struct ConsumeFunctor {
335 bool operator ()(StringPiece* input, const PCRE& pattern, // 3..16 args
336 const Arg& ptr1 = no_more_args,
337 const Arg& ptr2 = no_more_args,
338 const Arg& ptr3 = no_more_args,
339 const Arg& ptr4 = no_more_args,
340 const Arg& ptr5 = no_more_args,
341 const Arg& ptr6 = no_more_args,
342 const Arg& ptr7 = no_more_args,
343 const Arg& ptr8 = no_more_args,
344 const Arg& ptr9 = no_more_args,
345 const Arg& ptr10 = no_more_args,
346 const Arg& ptr11 = no_more_args,
347 const Arg& ptr12 = no_more_args,
348 const Arg& ptr13 = no_more_args,
349 const Arg& ptr14 = no_more_args,
350 const Arg& ptr15 = no_more_args,
351 const Arg& ptr16 = no_more_args) const;
354 static const ConsumeFunctor Consume;
356 // Like Consume(..), but does not anchor the match at the beginning of the
357 // string. That is, "pattern" need not start its match at the beginning of
358 // "input". For example, "FindAndConsume(s, "(\\w+)", &word)" finds the next
359 // word in "s" and stores it in "word".
360 struct FindAndConsumeFunctor {
361 bool operator ()(StringPiece* input, const PCRE& pattern,
362 const Arg& ptr1 = no_more_args,
363 const Arg& ptr2 = no_more_args,
364 const Arg& ptr3 = no_more_args,
365 const Arg& ptr4 = no_more_args,
366 const Arg& ptr5 = no_more_args,
367 const Arg& ptr6 = no_more_args,
368 const Arg& ptr7 = no_more_args,
369 const Arg& ptr8 = no_more_args,
370 const Arg& ptr9 = no_more_args,
371 const Arg& ptr10 = no_more_args,
372 const Arg& ptr11 = no_more_args,
373 const Arg& ptr12 = no_more_args,
374 const Arg& ptr13 = no_more_args,
375 const Arg& ptr14 = no_more_args,
376 const Arg& ptr15 = no_more_args,
377 const Arg& ptr16 = no_more_args) const;
380 static const FindAndConsumeFunctor FindAndConsume;
382 // Replace the first match of "pattern" in "str" with "rewrite".
383 // Within "rewrite", backslash-escaped digits (\1 to \9) can be
384 // used to insert text matching corresponding parenthesized group
385 // from the pattern. \0 in "rewrite" refers to the entire matching
386 // text. E.g.,
388 // string s = "yabba dabba doo";
389 // CHECK(PCRE::Replace(&s, "b+", "d"));
391 // will leave "s" containing "yada dabba doo"
393 // Returns true if the pattern matches and a replacement occurs,
394 // false otherwise.
395 static bool Replace(string *str,
396 const PCRE& pattern,
397 const StringPiece& rewrite);
399 // Like Replace(), except replaces all occurrences of the pattern in
400 // the string with the rewrite. Replacements are not subject to
401 // re-matching. E.g.,
403 // string s = "yabba dabba doo";
404 // CHECK(PCRE::GlobalReplace(&s, "b+", "d"));
406 // will leave "s" containing "yada dada doo"
408 // Returns the number of replacements made.
409 static int GlobalReplace(string *str,
410 const PCRE& pattern,
411 const StringPiece& rewrite);
413 // Like Replace, except that if the pattern matches, "rewrite"
414 // is copied into "out" with substitutions. The non-matching
415 // portions of "text" are ignored.
417 // Returns true iff a match occurred and the extraction happened
418 // successfully; if no match occurs, the string is left unaffected.
419 static bool Extract(const StringPiece &text,
420 const PCRE& pattern,
421 const StringPiece &rewrite,
422 string *out);
424 // Check that the given @p rewrite string is suitable for use with
425 // this PCRE. It checks that:
426 // * The PCRE has enough parenthesized subexpressions to satisfy all
427 // of the \N tokens in @p rewrite, and
428 // * The @p rewrite string doesn't have any syntax errors
429 // ('\' followed by anything besides [0-9] and '\').
430 // Making this test will guarantee that "replace" and "extract"
431 // operations won't LOG(ERROR) or fail because of a bad rewrite
432 // string.
433 // @param rewrite The proposed rewrite string.
434 // @param error An error message is recorded here, iff we return false.
435 // Otherwise, it is unchanged.
436 // @return true, iff @p rewrite is suitable for use with the PCRE.
437 bool CheckRewriteString(const StringPiece& rewrite, string* error) const;
439 // Returns a copy of 'unquoted' with all potentially meaningful
440 // regexp characters backslash-escaped. The returned string, used
441 // as a regular expression, will exactly match the original string.
442 // For example,
443 // 1.5-2.0?
444 // becomes:
445 // 1\.5\-2\.0\?
446 static string QuoteMeta(const StringPiece& unquoted);
448 /***** Generic matching interface (not so nice to use) *****/
450 // Type of match (TODO: Should be restructured as an Option)
451 enum Anchor {
452 UNANCHORED, // No anchoring
453 ANCHOR_START, // Anchor at start only
454 ANCHOR_BOTH, // Anchor at start and end
457 // General matching routine. Stores the length of the match in
458 // "*consumed" if successful.
459 bool DoMatch(const StringPiece& text,
460 Anchor anchor,
461 int* consumed,
462 const Arg* const* args, int n) const;
464 // Return the number of capturing subpatterns, or -1 if the
465 // regexp wasn't valid on construction.
466 int NumberOfCapturingGroups() const;
468 private:
469 void Init(const char* pattern, Option option, int match_limit,
470 int stack_limit, bool report_errors);
472 // Match against "text", filling in "vec" (up to "vecsize" * 2/3) with
473 // pairs of integers for the beginning and end positions of matched
474 // text. The first pair corresponds to the entire matched text;
475 // subsequent pairs correspond, in order, to parentheses-captured
476 // matches. Returns the number of pairs (one more than the number of
477 // the last subpattern with a match) if matching was successful
478 // and zero if the match failed.
479 // I.e. for PCRE("(foo)|(bar)|(baz)") it will return 2, 3, and 4 when matching
480 // against "foo", "bar", and "baz" respectively.
481 // When matching PCRE("(foo)|hello") against "hello", it will return 1.
482 // But the values for all subpattern are filled in into "vec".
483 int TryMatch(const StringPiece& text,
484 int startpos,
485 Anchor anchor,
486 bool empty_ok,
487 int *vec,
488 int vecsize) const;
490 // Append the "rewrite" string, with backslash subsitutions from "text"
491 // and "vec", to string "out".
492 bool Rewrite(string *out,
493 const StringPiece &rewrite,
494 const StringPiece &text,
495 int *vec,
496 int veclen) const;
498 // internal implementation for DoMatch
499 bool DoMatchImpl(const StringPiece& text,
500 Anchor anchor,
501 int* consumed,
502 const Arg* const args[],
503 int n,
504 int* vec,
505 int vecsize) const;
507 // Compile the regexp for the specified anchoring mode
508 pcre* Compile(Anchor anchor);
510 string pattern_;
511 Option options_;
512 pcre* re_full_; // For full matches
513 pcre* re_partial_; // For partial matches
514 const string* error_; // Error indicator (or empty string)
515 bool report_errors_; // Silences error logging if false
516 int match_limit_; // Limit on execution resources
517 int stack_limit_; // Limit on stack resources (bytes)
518 mutable int32_t hit_limit_; // Hit limit during execution (bool)?
519 DISALLOW_EVIL_CONSTRUCTORS(PCRE);
522 // PCRE_Options allow you to set the PCRE::Options, plus any pcre
523 // "extra" options. The only extras are match_limit, which limits
524 // the CPU time of a match, and stack_limit, which limits the
525 // stack usage. Setting a limit to <= 0 lets PCRE pick a sensible default
526 // that should not cause too many problems in production code.
527 // If PCRE hits a limit during a match, it may return a false negative,
528 // but (hopefully) it won't crash.
530 // NOTE: If you are handling regular expressions specified by
531 // (external or internal) users, rather than hard-coded ones,
532 // you should be using PCRE2, which uses an alternate implementation
533 // that avoids these issues. See http://go/re2quick.
534 class PCRE_Options {
535 public:
536 // constructor
537 PCRE_Options() : option_(PCRE::None), match_limit_(0), stack_limit_(0), report_errors_(true) {}
538 // accessors
539 PCRE::Option option() const { return option_; }
540 void set_option(PCRE::Option option) {
541 option_ = option;
543 int match_limit() const { return match_limit_; }
544 void set_match_limit(int match_limit) {
545 match_limit_ = match_limit;
547 int stack_limit() const { return stack_limit_; }
548 void set_stack_limit(int stack_limit) {
549 stack_limit_ = stack_limit;
552 // If the regular expression is malformed, an error message will be printed
553 // iff report_errors() is true. Default: true.
554 bool report_errors() const { return report_errors_; }
555 void set_report_errors(bool report_errors) {
556 report_errors_ = report_errors;
558 private:
559 PCRE::Option option_;
560 int match_limit_;
561 int stack_limit_;
562 bool report_errors_;
566 /***** Implementation details *****/
568 // Hex/Octal/Binary?
570 // Special class for parsing into objects that define a ParseFrom() method
571 template <class T>
572 class _PCRE_MatchObject {
573 public:
574 static inline bool Parse(const char* str, int n, void* dest) {
575 if (dest == NULL) return true;
576 T* object = reinterpret_cast<T*>(dest);
577 return object->ParseFrom(str, n);
581 class PCRE::Arg {
582 public:
583 // Empty constructor so we can declare arrays of PCRE::Arg
584 Arg();
586 // Constructor specially designed for NULL arguments
587 Arg(void*);
589 typedef bool (*Parser)(const char* str, int n, void* dest);
591 // Type-specific parsers
592 #define MAKE_PARSER(type,name) \
593 Arg(type* p) : arg_(p), parser_(name) { } \
594 Arg(type* p, Parser parser) : arg_(p), parser_(parser) { } \
597 MAKE_PARSER(char, parse_char);
598 MAKE_PARSER(unsigned char, parse_uchar);
599 MAKE_PARSER(short, parse_short);
600 MAKE_PARSER(unsigned short, parse_ushort);
601 MAKE_PARSER(int, parse_int);
602 MAKE_PARSER(unsigned int, parse_uint);
603 MAKE_PARSER(long, parse_long);
604 MAKE_PARSER(unsigned long, parse_ulong);
605 MAKE_PARSER(long long, parse_longlong);
606 MAKE_PARSER(unsigned long long, parse_ulonglong);
607 MAKE_PARSER(float, parse_float);
608 MAKE_PARSER(double, parse_double);
609 MAKE_PARSER(string, parse_string);
610 MAKE_PARSER(StringPiece, parse_stringpiece);
612 #undef MAKE_PARSER
614 // Generic constructor
615 template <class T> Arg(T*, Parser parser);
616 // Generic constructor template
617 template <class T> Arg(T* p)
618 : arg_(p), parser_(_PCRE_MatchObject<T>::Parse) {
621 // Parse the data
622 bool Parse(const char* str, int n) const;
624 private:
625 void* arg_;
626 Parser parser_;
628 static bool parse_null (const char* str, int n, void* dest);
629 static bool parse_char (const char* str, int n, void* dest);
630 static bool parse_uchar (const char* str, int n, void* dest);
631 static bool parse_float (const char* str, int n, void* dest);
632 static bool parse_double (const char* str, int n, void* dest);
633 static bool parse_string (const char* str, int n, void* dest);
634 static bool parse_stringpiece (const char* str, int n, void* dest);
636 #define DECLARE_INTEGER_PARSER(name) \
637 private: \
638 static bool parse_ ## name(const char* str, int n, void* dest); \
639 static bool parse_ ## name ## _radix( \
640 const char* str, int n, void* dest, int radix); \
641 public: \
642 static bool parse_ ## name ## _hex(const char* str, int n, void* dest); \
643 static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \
644 static bool parse_ ## name ## _cradix(const char* str, int n, void* dest)
646 DECLARE_INTEGER_PARSER(short);
647 DECLARE_INTEGER_PARSER(ushort);
648 DECLARE_INTEGER_PARSER(int);
649 DECLARE_INTEGER_PARSER(uint);
650 DECLARE_INTEGER_PARSER(long);
651 DECLARE_INTEGER_PARSER(ulong);
652 DECLARE_INTEGER_PARSER(longlong);
653 DECLARE_INTEGER_PARSER(ulonglong);
655 #undef DECLARE_INTEGER_PARSER
658 inline PCRE::Arg::Arg() : arg_(NULL), parser_(parse_null) { }
659 inline PCRE::Arg::Arg(void* p) : arg_(p), parser_(parse_null) { }
661 inline bool PCRE::Arg::Parse(const char* str, int n) const {
662 return (*parser_)(str, n, arg_);
665 // This part of the parser, appropriate only for ints, deals with bases
666 #define MAKE_INTEGER_PARSER(type, name) \
667 inline PCRE::Arg Hex(type* ptr) { \
668 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _hex); } \
669 inline PCRE::Arg Octal(type* ptr) { \
670 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _octal); } \
671 inline PCRE::Arg CRadix(type* ptr) { \
672 return PCRE::Arg(ptr, PCRE::Arg::parse_ ## name ## _cradix); }
674 MAKE_INTEGER_PARSER(short, short);
675 MAKE_INTEGER_PARSER(unsigned short, ushort);
676 MAKE_INTEGER_PARSER(int, int);
677 MAKE_INTEGER_PARSER(unsigned int, uint);
678 MAKE_INTEGER_PARSER(long, long);
679 MAKE_INTEGER_PARSER(unsigned long, ulong);
680 MAKE_INTEGER_PARSER(long long, longlong);
681 MAKE_INTEGER_PARSER(unsigned long long, ulonglong);
683 #undef MAKE_INTEGER_PARSER
685 } // namespace re2