pcrecpp.cc

   1 // Copyright (c) 2010, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // Author: Sanjay Ghemawat
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <ctype.h>
  39 #include <limits.h>      /* for SHRT_MIN, USHRT_MAX, etc */
  40 #include <assert.h>
  41 #include <errno.h>
  42 #include <string>
  43 #include <algorithm>
  44
  45 #include "pcrecpp_internal.h"
  46 #include "pcre.h"
  47 #include "pcrecpp.h"
  48 #include "pcre_stringpiece.h"
  49
  50
  51 namespace pcrecpp {
  52
  53 // Maximum number of args we can set
  54 static const int kMaxArgs = 16;
  55 static const int kVecSize = (1 + kMaxArgs) * 3;  // results + PCRE workspace
  56
  57 // Special object that stands-in for no argument
  58 Arg RE::no_arg((void*)NULL);
  59
  60 // This is for ABI compatibility with old versions of pcre (pre-7.6),
  61 // which defined a global no_arg variable instead of putting it in the
  62 // RE class.  This works on GCC >= 3, at least.  It definitely works
  63 // for ELF, but may not for other object formats (Mach-O, for
  64 // instance, does not support aliases.)  We could probably have a more
  65 // inclusive test if we ever needed it.  (Note that not only the
  66 // __attribute__ syntax, but also __USER_LABEL_PREFIX__, are
  67 // gnu-specific.)
  68 #if defined(__GNUC__) && __GNUC__ >= 3 && defined(__ELF__)
  69 # define ULP_AS_STRING(x)            ULP_AS_STRING_INTERNAL(x)
  70 # define ULP_AS_STRING_INTERNAL(x)   #x
  71 # define USER_LABEL_PREFIX_STR       ULP_AS_STRING(__USER_LABEL_PREFIX__)
  72 extern Arg no_arg
  73   __attribute__((alias(USER_LABEL_PREFIX_STR "_ZN7pcrecpp2RE6no_argE")));
  74 #endif
  75
  76 // If a regular expression has no error, its error_ field points here
  77 static const string empty_string;
  78
  79 // If the user doesn't ask for any options, we just use this one
  80 static RE_Options default_options;
  81
  82 void RE::Init(const string& pat, const RE_Options* options) {
  83   pattern_ = pat;
  84   if (options == NULL) {
  85     options_ = default_options;
  86   } else {
  87     options_ = *options;
  88   }
  89   error_ = &empty_string;
  90   re_full_ = NULL;
  91   re_partial_ = NULL;
  92
  93   re_partial_ = Compile(UNANCHORED);
  94   if (re_partial_ != NULL) {
  95     re_full_ = Compile(ANCHOR_BOTH);
  96   }
  97 }
  98
  99 void RE::Cleanup() {
 100   if (re_full_ != NULL)         (*pcre_free)(re_full_);
 101   if (re_partial_ != NULL)      (*pcre_free)(re_partial_);
 102   if (error_ != &empty_string)  delete error_;
 103 }
 104
 105
 106 RE::~RE() {
 107   Cleanup();
 108 }
 109
 110
 111 pcre* RE::Compile(Anchor anchor) {
 112   // First, convert RE_Options into pcre options
 113   int pcre_options = 0;
 114   pcre_options = options_.all_options();
 115
 116   // Special treatment for anchoring.  This is needed because at
 117   // runtime pcre only provides an option for anchoring at the
 118   // beginning of a string (unless you use offset).
 119   //
 120   // There are three types of anchoring we want:
 121   //    UNANCHORED      Compile the original pattern, and use
 122   //                    a pcre unanchored match.
 123   //    ANCHOR_START    Compile the original pattern, and use
 124   //                    a pcre anchored match.
 125   //    ANCHOR_BOTH     Tack a "\z" to the end of the original pattern
 126   //                    and use a pcre anchored match.
 127
 128   const char* compile_error;
 129   int eoffset;
 130   pcre* re;
 131   if (anchor != ANCHOR_BOTH) {
 132     re = pcre_compile(pattern_.c_str(), pcre_options,
 133                       &compile_error, &eoffset, NULL);
 134   } else {
 135     // Tack a '\z' at the end of RE.  Parenthesize it first so that
 136     // the '\z' applies to all top-level alternatives in the regexp.
 137     string wrapped = "(?:";  // A non-counting grouping operator
 138     wrapped += pattern_;
 139     wrapped += ")\\z";
 140     re = pcre_compile(wrapped.c_str(), pcre_options,
 141                       &compile_error, &eoffset, NULL);
 142   }
 143   if (re == NULL) {
 144     if (error_ == &empty_string) error_ = new string(compile_error);
 145   }
 146   return re;
 147 }
 148
 149 /***** Matching interfaces *****/
 150
 151 bool RE::FullMatch(const StringPiece& text,
 152                    const Arg& ptr1,
 153                    const Arg& ptr2,
 154                    const Arg& ptr3,
 155                    const Arg& ptr4,
 156                    const Arg& ptr5,
 157                    const Arg& ptr6,
 158                    const Arg& ptr7,
 159                    const Arg& ptr8,
 160                    const Arg& ptr9,
 161                    const Arg& ptr10,
 162                    const Arg& ptr11,
 163                    const Arg& ptr12,
 164                    const Arg& ptr13,
 165                    const Arg& ptr14,
 166                    const Arg& ptr15,
 167                    const Arg& ptr16) const {
 168   const Arg* args[kMaxArgs];
 169   int n = 0;
 170   if (&ptr1  == &no_arg) goto done; args[n++] = &ptr1;
 171   if (&ptr2  == &no_arg) goto done; args[n++] = &ptr2;
 172   if (&ptr3  == &no_arg) goto done; args[n++] = &ptr3;
 173   if (&ptr4  == &no_arg) goto done; args[n++] = &ptr4;
 174   if (&ptr5  == &no_arg) goto done; args[n++] = &ptr5;
 175   if (&ptr6  == &no_arg) goto done; args[n++] = &ptr6;
 176   if (&ptr7  == &no_arg) goto done; args[n++] = &ptr7;
 177   if (&ptr8  == &no_arg) goto done; args[n++] = &ptr8;
 178   if (&ptr9  == &no_arg) goto done; args[n++] = &ptr9;
 179   if (&ptr10 == &no_arg) goto done; args[n++] = &ptr10;
 180   if (&ptr11 == &no_arg) goto done; args[n++] = &ptr11;
 181   if (&ptr12 == &no_arg) goto done; args[n++] = &ptr12;
 182   if (&ptr13 == &no_arg) goto done; args[n++] = &ptr13;
 183   if (&ptr14 == &no_arg) goto done; args[n++] = &ptr14;
 184   if (&ptr15 == &no_arg) goto done; args[n++] = &ptr15;
 185   if (&ptr16 == &no_arg) goto done; args[n++] = &ptr16;
 186  done:
 187
 188   int consumed;
 189   int vec[kVecSize];
 190   return DoMatchImpl(text, ANCHOR_BOTH, &consumed, args, n, vec, kVecSize);
 191 }
 192
 193 bool RE::PartialMatch(const StringPiece& text,
 194                       const Arg& ptr1,
 195                       const Arg& ptr2,
 196                       const Arg& ptr3,
 197                       const Arg& ptr4,
 198                       const Arg& ptr5,
 199                       const Arg& ptr6,
 200                       const Arg& ptr7,
 201                       const Arg& ptr8,
 202                       const Arg& ptr9,
 203                       const Arg& ptr10,
 204                       const Arg& ptr11,
 205                       const Arg& ptr12,
 206                       const Arg& ptr13,
 207                       const Arg& ptr14,
 208                       const Arg& ptr15,
 209                       const Arg& ptr16) const {
 210   const Arg* args[kMaxArgs];
 211   int n = 0;
 212   if (&ptr1  == &no_arg) goto done; args[n++] = &ptr1;
 213   if (&ptr2  == &no_arg) goto done; args[n++] = &ptr2;
 214   if (&ptr3  == &no_arg) goto done; args[n++] = &ptr3;
 215   if (&ptr4  == &no_arg) goto done; args[n++] = &ptr4;
 216   if (&ptr5  == &no_arg) goto done; args[n++] = &ptr5;
 217   if (&ptr6  == &no_arg) goto done; args[n++] = &ptr6;
 218   if (&ptr7  == &no_arg) goto done; args[n++] = &ptr7;
 219   if (&ptr8  == &no_arg) goto done; args[n++] = &ptr8;
 220   if (&ptr9  == &no_arg) goto done; args[n++] = &ptr9;
 221   if (&ptr10 == &no_arg) goto done; args[n++] = &ptr10;
 222   if (&ptr11 == &no_arg) goto done; args[n++] = &ptr11;
 223   if (&ptr12 == &no_arg) goto done; args[n++] = &ptr12;
 224   if (&ptr13 == &no_arg) goto done; args[n++] = &ptr13;
 225   if (&ptr14 == &no_arg) goto done; args[n++] = &ptr14;
 226   if (&ptr15 == &no_arg) goto done; args[n++] = &ptr15;
 227   if (&ptr16 == &no_arg) goto done; args[n++] = &ptr16;
 228  done:
 229
 230   int consumed;
 231   int vec[kVecSize];
 232   return DoMatchImpl(text, UNANCHORED, &consumed, args, n, vec, kVecSize);
 233 }
 234
 235 bool RE::Consume(StringPiece* input,
 236                  const Arg& ptr1,
 237                  const Arg& ptr2,
 238                  const Arg& ptr3,
 239                  const Arg& ptr4,
 240                  const Arg& ptr5,
 241                  const Arg& ptr6,
 242                  const Arg& ptr7,
 243                  const Arg& ptr8,
 244                  const Arg& ptr9,
 245                  const Arg& ptr10,
 246                  const Arg& ptr11,
 247                  const Arg& ptr12,
 248                  const Arg& ptr13,
 249                  const Arg& ptr14,
 250                  const Arg& ptr15,
 251                  const Arg& ptr16) const {
 252   const Arg* args[kMaxArgs];
 253   int n = 0;
 254   if (&ptr1  == &no_arg) goto done; args[n++] = &ptr1;
 255   if (&ptr2  == &no_arg) goto done; args[n++] = &ptr2;
 256   if (&ptr3  == &no_arg) goto done; args[n++] = &ptr3;
 257   if (&ptr4  == &no_arg) goto done; args[n++] = &ptr4;
 258   if (&ptr5  == &no_arg) goto done; args[n++] = &ptr5;
 259   if (&ptr6  == &no_arg) goto done; args[n++] = &ptr6;
 260   if (&ptr7  == &no_arg) goto done; args[n++] = &ptr7;
 261   if (&ptr8  == &no_arg) goto done; args[n++] = &ptr8;
 262   if (&ptr9  == &no_arg) goto done; args[n++] = &ptr9;
 263   if (&ptr10 == &no_arg) goto done; args[n++] = &ptr10;
 264   if (&ptr11 == &no_arg) goto done; args[n++] = &ptr11;
 265   if (&ptr12 == &no_arg) goto done; args[n++] = &ptr12;
 266   if (&ptr13 == &no_arg) goto done; args[n++] = &ptr13;
 267   if (&ptr14 == &no_arg) goto done; args[n++] = &ptr14;
 268   if (&ptr15 == &no_arg) goto done; args[n++] = &ptr15;
 269   if (&ptr16 == &no_arg) goto done; args[n++] = &ptr16;
 270  done:
 271
 272   int consumed;
 273   int vec[kVecSize];
 274   if (DoMatchImpl(*input, ANCHOR_START, &consumed,
 275                   args, n, vec, kVecSize)) {
 276     input->remove_prefix(consumed);
 277     return true;
 278   } else {
 279     return false;
 280   }
 281 }
 282
 283 bool RE::FindAndConsume(StringPiece* input,
 284                         const Arg& ptr1,
 285                         const Arg& ptr2,
 286                         const Arg& ptr3,
 287                         const Arg& ptr4,
 288                         const Arg& ptr5,
 289                         const Arg& ptr6,
 290                         const Arg& ptr7,
 291                         const Arg& ptr8,
 292                         const Arg& ptr9,
 293                         const Arg& ptr10,
 294                         const Arg& ptr11,
 295                         const Arg& ptr12,
 296                         const Arg& ptr13,
 297                         const Arg& ptr14,
 298                         const Arg& ptr15,
 299                         const Arg& ptr16) const {
 300   const Arg* args[kMaxArgs];
 301   int n = 0;
 302   if (&ptr1  == &no_arg) goto done; args[n++] = &ptr1;
 303   if (&ptr2  == &no_arg) goto done; args[n++] = &ptr2;
 304   if (&ptr3  == &no_arg) goto done; args[n++] = &ptr3;
 305   if (&ptr4  == &no_arg) goto done; args[n++] = &ptr4;
 306   if (&ptr5  == &no_arg) goto done; args[n++] = &ptr5;
 307   if (&ptr6  == &no_arg) goto done; args[n++] = &ptr6;
 308   if (&ptr7  == &no_arg) goto done; args[n++] = &ptr7;
 309   if (&ptr8  == &no_arg) goto done; args[n++] = &ptr8;
 310   if (&ptr9  == &no_arg) goto done; args[n++] = &ptr9;
 311   if (&ptr10 == &no_arg) goto done; args[n++] = &ptr10;
 312   if (&ptr11 == &no_arg) goto done; args[n++] = &ptr11;
 313   if (&ptr12 == &no_arg) goto done; args[n++] = &ptr12;
 314   if (&ptr13 == &no_arg) goto done; args[n++] = &ptr13;
 315   if (&ptr14 == &no_arg) goto done; args[n++] = &ptr14;
 316   if (&ptr15 == &no_arg) goto done; args[n++] = &ptr15;
 317   if (&ptr16 == &no_arg) goto done; args[n++] = &ptr16;
 318  done:
 319
 320   int consumed;
 321   int vec[kVecSize];
 322   if (DoMatchImpl(*input, UNANCHORED, &consumed,
 323                   args, n, vec, kVecSize)) {
 324     input->remove_prefix(consumed);
 325     return true;
 326   } else {
 327     return false;
 328   }
 329 }
 330
 331 bool RE::Replace(const StringPiece& rewrite,
 332                  string *str) const {
 333   int vec[kVecSize];
 334   int matches = TryMatch(*str, 0, UNANCHORED, true, vec, kVecSize);
 335   if (matches == 0)
 336     return false;
 337
 338   string s;
 339   if (!Rewrite(&s, rewrite, *str, vec, matches))
 340     return false;
 341
 342   assert(vec[0] >= 0);
 343   assert(vec[1] >= 0);
 344   str->replace(vec[0], vec[1] - vec[0], s);
 345   return true;
 346 }
 347
 348 // Returns PCRE_NEWLINE_CRLF, PCRE_NEWLINE_CR, or PCRE_NEWLINE_LF.
 349 // Note that PCRE_NEWLINE_CRLF is defined to be P_N_CR | P_N_LF.
 350 // Modified by PH to add PCRE_NEWLINE_ANY and PCRE_NEWLINE_ANYCRLF.
 351
 352 static int NewlineMode(int pcre_options) {
 353   // TODO: if we can make it threadsafe, cache this var
 354   int newline_mode = 0;
 355   /* if (newline_mode) return newline_mode; */  // do this once it's cached
 356   if (pcre_options & (PCRE_NEWLINE_CRLF|PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|
 357                       PCRE_NEWLINE_ANY|PCRE_NEWLINE_ANYCRLF)) {
 358     newline_mode = (pcre_options &
 359                     (PCRE_NEWLINE_CRLF|PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|
 360                      PCRE_NEWLINE_ANY|PCRE_NEWLINE_ANYCRLF));
 361   } else {
 362     int newline;
 363     pcre_config(PCRE_CONFIG_NEWLINE, &newline);
 364     if (newline == 10)
 365       newline_mode = PCRE_NEWLINE_LF;
 366     else if (newline == 13)
 367       newline_mode = PCRE_NEWLINE_CR;
 368     else if (newline == 3338)
 369       newline_mode = PCRE_NEWLINE_CRLF;
 370     else if (newline == -1)
 371       newline_mode = PCRE_NEWLINE_ANY;
 372     else if (newline == -2)
 373       newline_mode = PCRE_NEWLINE_ANYCRLF;
 374     else
 375       assert(NULL == "Unexpected return value from pcre_config(NEWLINE)");
 376   }
 377   return newline_mode;
 378 }
 379
 380 int RE::GlobalReplace(const StringPiece& rewrite,
 381                       string *str) const {
 382   int count = 0;
 383   int vec[kVecSize];
 384   string out;
 385   int start = 0;
 386   int lastend = -1;
 387   bool last_match_was_empty_string = false;
 388
 389   while (start <= static_cast<int>(str->length())) {
 390     // If the previous match was for the empty string, we shouldn't
 391     // just match again: we'll match in the same way and get an
 392     // infinite loop.  Instead, we do the match in a special way:
 393     // anchored -- to force another try at the same position --
 394     // and with a flag saying that this time, ignore empty matches.
 395     // If this special match returns, that means there's a non-empty
 396     // match at this position as well, and we can continue.  If not,
 397     // we do what perl does, and just advance by one.
 398     // Notice that perl prints '@@@' for this;
 399     //    perl -le '$_ = "aa"; s/b*|aa/@/g; print'
 400     int matches;
 401     if (last_match_was_empty_string) {
 402       matches = TryMatch(*str, start, ANCHOR_START, false, vec, kVecSize);
 403       if (matches <= 0) {
 404         int matchend = start + 1;     // advance one character.
 405         // If the current char is CR and we're in CRLF mode, skip LF too.
 406         // Note it's better to call pcre_fullinfo() than to examine
 407         // all_options(), since options_ could have changed bewteen
 408         // compile-time and now, but this is simpler and safe enough.
 409         // Modified by PH to add ANY and ANYCRLF.
 410         if (matchend < static_cast<int>(str->length()) &&
 411             (*str)[start] == '\r' && (*str)[matchend] == '\n' &&
 412             (NewlineMode(options_.all_options()) == PCRE_NEWLINE_CRLF ||
 413              NewlineMode(options_.all_options()) == PCRE_NEWLINE_ANY ||
 414              NewlineMode(options_.all_options()) == PCRE_NEWLINE_ANYCRLF)) {
 415           matchend++;
 416         }
 417         // We also need to advance more than one char if we're in utf8 mode.
 418 #ifdef SUPPORT_UTF8
 419         if (options_.utf8()) {
 420           while (matchend < static_cast<int>(str->length()) &&
 421                  ((*str)[matchend] & 0xc0) == 0x80)
 422             matchend++;
 423         }
 424 #endif
 425         if (start < static_cast<int>(str->length()))
 426           out.append(*str, start, matchend - start);
 427         start = matchend;
 428         last_match_was_empty_string = false;
 429         continue;
 430       }
 431     } else {
 432       matches = TryMatch(*str, start, UNANCHORED, true, vec, kVecSize);
 433       if (matches <= 0)
 434         break;
 435     }
 436     int matchstart = vec[0], matchend = vec[1];
 437     assert(matchstart >= start);
 438     assert(matchend >= matchstart);
 439     out.append(*str, start, matchstart - start);
 440     Rewrite(&out, rewrite, *str, vec, matches);
 441     start = matchend;
 442     lastend = matchend;
 443     count++;
 444     last_match_was_empty_string = (matchstart == matchend);
 445   }
 446
 447   if (count == 0)
 448     return 0;
 449
 450   if (start < static_cast<int>(str->length()))
 451     out.append(*str, start, str->length() - start);
 452   swap(out, *str);
 453   return count;
 454 }
 455
 456 bool RE::Extract(const StringPiece& rewrite,
 457                  const StringPiece& text,
 458                  string *out) const {
 459   int vec[kVecSize];
 460   int matches = TryMatch(text, 0, UNANCHORED, true, vec, kVecSize);
 461   if (matches == 0)
 462     return false;
 463   out->erase();
 464   return Rewrite(out, rewrite, text, vec, matches);
 465 }
 466
 467 /*static*/ string RE::QuoteMeta(const StringPiece& unquoted) {
 468   string result;
 469
 470   // Escape any ascii character not in [A-Za-z_0-9].
 471   //
 472   // Note that it's legal to escape a character even if it has no
 473   // special meaning in a regular expression -- so this function does
 474   // that.  (This also makes it identical to the perl function of the
 475   // same name; see `perldoc -f quotemeta`.)  The one exception is
 476   // escaping NUL: rather than doing backslash + NUL, like perl does,
 477   // we do '\0', because pcre itself doesn't take embedded NUL chars.
 478   for (int ii = 0; ii < unquoted.size(); ++ii) {
 479     // Note that using 'isalnum' here raises the benchmark time from
 480     // 32ns to 58ns:
 481     if (unquoted[ii] == '\0') {
 482       result += "\\0";
 483     } else if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') &&
 484                (unquoted[ii] < 'A' || unquoted[ii] > 'Z') &&
 485                (unquoted[ii] < '0' || unquoted[ii] > '9') &&
 486                unquoted[ii] != '_' &&
 487                // If this is the part of a UTF8 or Latin1 character, we need
 488                // to copy this byte without escaping.  Experimentally this is
 489                // what works correctly with the regexp library.
 490                !(unquoted[ii] & 128)) {
 491       result += '\\';
 492       result += unquoted[ii];
 493     } else {
 494       result += unquoted[ii];
 495     }
 496   }
 497
 498   return result;
 499 }
 500
 501 /***** Actual matching and rewriting code *****/
 502
 503 int RE::TryMatch(const StringPiece& text,
 504                  int startpos,
 505                  Anchor anchor,
 506                  bool empty_ok,
 507                  int *vec,
 508                  int vecsize) const {
 509   pcre* re = (anchor == ANCHOR_BOTH) ? re_full_ : re_partial_;
 510   if (re == NULL) {
 511     //fprintf(stderr, "Matching against invalid re: %s\n", error_->c_str());
 512     return 0;
 513   }
 514
 515   pcre_extra extra = { 0, 0, 0, 0, 0, 0 };
 516   if (options_.match_limit() > 0) {
 517     extra.flags |= PCRE_EXTRA_MATCH_LIMIT;
 518     extra.match_limit = options_.match_limit();
 519   }
 520   if (options_.match_limit_recursion() > 0) {
 521     extra.flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
 522     extra.match_limit_recursion = options_.match_limit_recursion();
 523   }
 524
 525   int options = 0;
 526   if (anchor != UNANCHORED)
 527     options |= PCRE_ANCHORED;
 528   if (!empty_ok)
 529     options |= PCRE_NOTEMPTY;
 530
 531   int rc = pcre_exec(re,              // The regular expression object
 532                      &extra,
 533                      (text.data() == NULL) ? "" : text.data(),
 534                      text.size(),
 535                      startpos,
 536                      options,
 537                      vec,
 538                      vecsize);
 539
 540   // Handle errors
 541   if (rc == PCRE_ERROR_NOMATCH) {
 542     return 0;
 543   } else if (rc < 0) {
 544     //fprintf(stderr, "Unexpected return code: %d when matching '%s'\n",
 545     //        re, pattern_.c_str());
 546     return 0;
 547   } else if (rc == 0) {
 548     // pcre_exec() returns 0 as a special case when the number of
 549     // capturing subpatterns exceeds the size of the vector.
 550     // When this happens, there is a match and the output vector
 551     // is filled, but we miss out on the positions of the extra subpatterns.
 552     rc = vecsize / 2;
 553   }
 554
 555   return rc;
 556 }
 557
 558 bool RE::DoMatchImpl(const StringPiece& text,
 559                      Anchor anchor,
 560                      int* consumed,
 561                      const Arg* const* args,
 562                      int n,
 563                      int* vec,
 564                      int vecsize) const {
 565   assert((1 + n) * 3 <= vecsize);  // results + PCRE workspace
 566   int matches = TryMatch(text, 0, anchor, true, vec, vecsize);
 567   assert(matches >= 0);  // TryMatch never returns negatives
 568   if (matches == 0)
 569     return false;
 570
 571   *consumed = vec[1];
 572
 573   if (n == 0 || args == NULL) {
 574     // We are not interested in results
 575     return true;
 576   }
 577
 578   if (NumberOfCapturingGroups() < n) {
 579     // RE has fewer capturing groups than number of arg pointers passed in
 580     return false;
 581   }
 582
 583   // If we got here, we must have matched the whole pattern.
 584   // We do not need (can not do) any more checks on the value of 'matches' here
 585   // -- see the comment for TryMatch.
 586   for (int i = 0; i < n; i++) {
 587     const int start = vec[2*(i+1)];
 588     const int limit = vec[2*(i+1)+1];
 589     if (!args[i]->Parse(text.data() + start, limit-start)) {
 590       // TODO: Should we indicate what the error was?
 591       return false;
 592     }
 593   }
 594
 595   return true;
 596 }
 597
 598 bool RE::DoMatch(const StringPiece& text,
 599                  Anchor anchor,
 600                  int* consumed,
 601                  const Arg* const args[],
 602                  int n) const {
 603   assert(n >= 0);
 604   size_t const vecsize = (1 + n) * 3;  // results + PCRE workspace
 605                                        // (as for kVecSize)
 606   int space[21];   // use stack allocation for small vecsize (common case)
 607   int* vec = vecsize <= 21 ? space : new int[vecsize];
 608   bool retval = DoMatchImpl(text, anchor, consumed, args, n, vec, (int)vecsize);
 609   if (vec != space) delete [] vec;
 610   return retval;
 611 }
 612
 613 bool RE::Rewrite(string *out, const StringPiece &rewrite,
 614                  const StringPiece &text, int *vec, int veclen) const {
 615   for (const char *s = rewrite.data(), *end = s + rewrite.size();
 616        s < end; s++) {
 617     int c = *s;
 618     if (c == '\\') {
 619       c = *++s;
 620       if (isdigit(c)) {
 621         int n = (c - '0');
 622         if (n >= veclen) {
 623           //fprintf(stderr, requested group %d in regexp %.*s\n",
 624           //        n, rewrite.size(), rewrite.data());
 625           return false;
 626         }
 627         int start = vec[2 * n];
 628         if (start >= 0)
 629           out->append(text.data() + start, vec[2 * n + 1] - start);
 630       } else if (c == '\\') {
 631         *out += '\\';
 632       } else {
 633         //fprintf(stderr, "invalid rewrite pattern: %.*s\n",
 634         //        rewrite.size(), rewrite.data());
 635         return false;
 636       }
 637     } else {
 638       *out += c;
 639     }
 640   }
 641   return true;
 642 }
 643
 644 // Return the number of capturing subpatterns, or -1 if the
 645 // regexp wasn't valid on construction.
 646 int RE::NumberOfCapturingGroups() const {
 647   if (re_partial_ == NULL) return -1;
 648
 649   int result;
 650   int pcre_retval = pcre_fullinfo(re_partial_,  // The regular expression object
 651                                   NULL,         // We did not study the pattern
 652                                   PCRE_INFO_CAPTURECOUNT,
 653                                   &result);
 654   assert(pcre_retval == 0);
 655   return result;
 656 }
 657
 658 /***** Parsers for various types *****/
 659
 660 bool Arg::parse_null(const char* str, int n, void* dest) {
 661   // We fail if somebody asked us to store into a non-NULL void* pointer
 662   return (dest == NULL);
 663 }
 664
 665 bool Arg::parse_string(const char* str, int n, void* dest) {
 666   if (dest == NULL) return true;
 667   reinterpret_cast<string*>(dest)->assign(str, n);
 668   return true;
 669 }
 670
 671 bool Arg::parse_stringpiece(const char* str, int n, void* dest) {
 672   if (dest == NULL) return true;
 673   reinterpret_cast<StringPiece*>(dest)->set(str, n);
 674   return true;
 675 }
 676
 677 bool Arg::parse_char(const char* str, int n, void* dest) {
 678   if (n != 1) return false;
 679   if (dest == NULL) return true;
 680   *(reinterpret_cast<char*>(dest)) = str[0];
 681   return true;
 682 }
 683
 684 bool Arg::parse_uchar(const char* str, int n, void* dest) {
 685   if (n != 1) return false;
 686   if (dest == NULL) return true;
 687   *(reinterpret_cast<unsigned char*>(dest)) = str[0];
 688   return true;
 689 }
 690
 691 // Largest number spec that we are willing to parse
 692 static const int kMaxNumberLength = 32;
 693
 694 // REQUIRES "buf" must have length at least kMaxNumberLength+1
 695 // REQUIRES "n > 0"
 696 // Copies "str" into "buf" and null-terminates if necessary.
 697 // Returns one of:
 698 //      a. "str" if no termination is needed
 699 //      b. "buf" if the string was copied and null-terminated
 700 //      c. "" if the input was invalid and has no hope of being parsed
 701 static const char* TerminateNumber(char* buf, const char* str, int n) {
 702   if ((n > 0) && isspace(*str)) {
 703     // We are less forgiving than the strtoxxx() routines and do not
 704     // allow leading spaces.
 705     return "";
 706   }
 707
 708   // See if the character right after the input text may potentially
 709   // look like a digit.
 710   if (isdigit(str[n]) ||
 711       ((str[n] >= 'a') && (str[n] <= 'f')) ||
 712       ((str[n] >= 'A') && (str[n] <= 'F'))) {
 713     if (n > kMaxNumberLength) return ""; // Input too big to be a valid number
 714     memcpy(buf, str, n);
 715     buf[n] = '\0';
 716     return buf;
 717   } else {
 718     // We can parse right out of the supplied string, so return it.
 719     return str;
 720   }
 721 }
 722
 723 bool Arg::parse_long_radix(const char* str,
 724                            int n,
 725                            void* dest,
 726                            int radix) {
 727   if (n == 0) return false;
 728   char buf[kMaxNumberLength+1];
 729   str = TerminateNumber(buf, str, n);
 730   char* end;
 731   errno = 0;
 732   long r = strtol(str, &end, radix);
 733   if (end != str + n) return false;   // Leftover junk
 734   if (errno) return false;
 735   if (dest == NULL) return true;
 736   *(reinterpret_cast<long*>(dest)) = r;
 737   return true;
 738 }
 739
 740 bool Arg::parse_ulong_radix(const char* str,
 741                             int n,
 742                             void* dest,
 743                             int radix) {
 744   if (n == 0) return false;
 745   char buf[kMaxNumberLength+1];
 746   str = TerminateNumber(buf, str, n);
 747   if (str[0] == '-') return false;    // strtoul() on a negative number?!
 748   char* end;
 749   errno = 0;
 750   unsigned long r = strtoul(str, &end, radix);
 751   if (end != str + n) return false;   // Leftover junk
 752   if (errno) return false;
 753   if (dest == NULL) return true;
 754   *(reinterpret_cast<unsigned long*>(dest)) = r;
 755   return true;
 756 }
 757
 758 bool Arg::parse_short_radix(const char* str,
 759                             int n,
 760                             void* dest,
 761                             int radix) {
 762   long r;
 763   if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse
 764   if (r < SHRT_MIN || r > SHRT_MAX) return false;       // Out of range
 765   if (dest == NULL) return true;
 766   *(reinterpret_cast<short*>(dest)) = static_cast<short>(r);
 767   return true;
 768 }
 769
 770 bool Arg::parse_ushort_radix(const char* str,
 771                              int n,
 772                              void* dest,
 773                              int radix) {
 774   unsigned long r;
 775   if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse
 776   if (r > USHRT_MAX) return false;                      // Out of range
 777   if (dest == NULL) return true;
 778   *(reinterpret_cast<unsigned short*>(dest)) = static_cast<unsigned short>(r);
 779   return true;
 780 }
 781
 782 bool Arg::parse_int_radix(const char* str,
 783                           int n,
 784                           void* dest,
 785                           int radix) {
 786   long r;
 787   if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse
 788   if (r < INT_MIN || r > INT_MAX) return false;         // Out of range
 789   if (dest == NULL) return true;
 790   *(reinterpret_cast<int*>(dest)) = r;
 791   return true;
 792 }
 793
 794 bool Arg::parse_uint_radix(const char* str,
 795                            int n,
 796                            void* dest,
 797                            int radix) {
 798   unsigned long r;
 799   if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse
 800   if (r > UINT_MAX) return false;                       // Out of range
 801   if (dest == NULL) return true;
 802   *(reinterpret_cast<unsigned int*>(dest)) = r;
 803   return true;
 804 }
 805
 806 bool Arg::parse_longlong_radix(const char* str,
 807                                int n,
 808                                void* dest,
 809                                int radix) {
 810 #ifndef HAVE_LONG_LONG
 811   return false;
 812 #else
 813   if (n == 0) return false;
 814   char buf[kMaxNumberLength+1];
 815   str = TerminateNumber(buf, str, n);
 816   char* end;
 817   errno = 0;
 818 #if defined HAVE_STRTOQ
 819   long long r = strtoq(str, &end, radix);
 820 #elif defined HAVE_STRTOLL
 821   long long r = strtoll(str, &end, radix);
 822 #elif defined HAVE__STRTOI64
 823   long long r = _strtoi64(str, &end, radix);
 824 #elif defined HAVE_STRTOIMAX
 825   long long r = strtoimax(str, &end, radix);
 826 #else
 827 #error parse_longlong_radix: cannot convert input to a long-long
 828 #endif
 829   if (end != str + n) return false;   // Leftover junk
 830   if (errno) return false;
 831   if (dest == NULL) return true;
 832   *(reinterpret_cast<long long*>(dest)) = r;
 833   return true;
 834 #endif   /* HAVE_LONG_LONG */
 835 }
 836
 837 bool Arg::parse_ulonglong_radix(const char* str,
 838                                 int n,
 839                                 void* dest,
 840                                 int radix) {
 841 #ifndef HAVE_UNSIGNED_LONG_LONG
 842   return false;
 843 #else
 844   if (n == 0) return false;
 845   char buf[kMaxNumberLength+1];
 846   str = TerminateNumber(buf, str, n);
 847   if (str[0] == '-') return false;    // strtoull() on a negative number?!
 848   char* end;
 849   errno = 0;
 850 #if defined HAVE_STRTOQ
 851   unsigned long long r = strtouq(str, &end, radix);
 852 #elif defined HAVE_STRTOLL
 853   unsigned long long r = strtoull(str, &end, radix);
 854 #elif defined HAVE__STRTOI64
 855   unsigned long long r = _strtoui64(str, &end, radix);
 856 #elif defined HAVE_STRTOIMAX
 857   unsigned long long r = strtoumax(str, &end, radix);
 858 #else
 859 #error parse_ulonglong_radix: cannot convert input to a long-long
 860 #endif
 861   if (end != str + n) return false;   // Leftover junk
 862   if (errno) return false;
 863   if (dest == NULL) return true;
 864   *(reinterpret_cast<unsigned long long*>(dest)) = r;
 865   return true;
 866 #endif   /* HAVE_UNSIGNED_LONG_LONG */
 867 }
 868
 869 bool Arg::parse_double(const char* str, int n, void* dest) {
 870   if (n == 0) return false;
 871   static const int kMaxLength = 200;
 872   char buf[kMaxLength];
 873   if (n >= kMaxLength) return false;
 874   memcpy(buf, str, n);
 875   buf[n] = '\0';
 876   errno = 0;
 877   char* end;
 878   double r = strtod(buf, &end);
 879   if (end != buf + n) return false;   // Leftover junk
 880   if (errno) return false;
 881   if (dest == NULL) return true;
 882   *(reinterpret_cast<double*>(dest)) = r;
 883   return true;
 884 }
 885
 886 bool Arg::parse_float(const char* str, int n, void* dest) {
 887   double r;
 888   if (!parse_double(str, n, &r)) return false;
 889   if (dest == NULL) return true;
 890   *(reinterpret_cast<float*>(dest)) = static_cast<float>(r);
 891   return true;
 892 }
 893
 894
 895 #define DEFINE_INTEGER_PARSERS(name)                                    \
 896   bool Arg::parse_##name(const char* str, int n, void* dest) {          \
 897     return parse_##name##_radix(str, n, dest, 10);                      \
 898   }                                                                     \
 899   bool Arg::parse_##name##_hex(const char* str, int n, void* dest) {    \
 900     return parse_##name##_radix(str, n, dest, 16);                      \
 901   }                                                                     \
 902   bool Arg::parse_##name##_octal(const char* str, int n, void* dest) {  \
 903     return parse_##name##_radix(str, n, dest, 8);                       \
 904   }                                                                     \
 905   bool Arg::parse_##name##_cradix(const char* str, int n, void* dest) { \
 906     return parse_##name##_radix(str, n, dest, 0);                       \
 907   }
 908
 909 DEFINE_INTEGER_PARSERS(short)      /*                                   */
 910 DEFINE_INTEGER_PARSERS(ushort)     /*                                   */
 911 DEFINE_INTEGER_PARSERS(int)        /* Don't use semicolons after these  */
 912 DEFINE_INTEGER_PARSERS(uint)       /* statements because they can cause */
 913 DEFINE_INTEGER_PARSERS(long)       /* compiler warnings if the checking */
 914 DEFINE_INTEGER_PARSERS(ulong)      /* level is turned up high enough.   */
 915 DEFINE_INTEGER_PARSERS(longlong)   /*                                   */
 916 DEFINE_INTEGER_PARSERS(ulonglong)  /*                                   */
 917
 918 #undef DEFINE_INTEGER_PARSERS
 919
 920 }   // namespace pcrecpp