/[pcre]/code/trunk/pcrecpp.cc
ViewVC logotype

Diff of /code/trunk/pcrecpp.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 77 by nigel, Sat Feb 24 21:40:45 2007 UTC revision 234 by ph10, Tue Sep 11 11:36:27 2007 UTC
# Line 29  Line 29 
29  //  //
30  // Author: Sanjay Ghemawat  // Author: Sanjay Ghemawat
31    
32    #ifdef HAVE_CONFIG_H
33    #include <config.h>
34    #endif
35    
36    #ifdef _WIN32
37    #define HAVE_STRTOQ 1
38    #define strtoll     _strtoui64
39    #define strtoull    _strtoi64
40    #endif
41    
42  #include <stdlib.h>  #include <stdlib.h>
43  #include <stdio.h>  #include <stdio.h>
44  #include <ctype.h>  #include <ctype.h>
# Line 36  Line 46 
46  #include <assert.h>  #include <assert.h>
47  #include <errno.h>  #include <errno.h>
48  #include <string>  #include <string>
49  #include "config.h"  #include <algorithm>
50  // We need this to compile the proper dll on windows/msys.  This is copied  
51  // from pcre_internal.h.  It would probably be better just to include that.  #include "pcrecpp_internal.h"
52  #define PCRE_DEFINITION  /* Win32 __declspec(export) trigger for .dll */  #include <pcre.h>
 #include "pcre.h"  
 #include "pcre_stringpiece.h"  
53  #include "pcrecpp.h"  #include "pcrecpp.h"
54    #include "pcre_stringpiece.h"
55    
56    
57  namespace pcrecpp {  namespace pcrecpp {
# Line 52  static const int kMaxArgs = 16; Line 61  static const int kMaxArgs = 16;
61  static const int kVecSize = (1 + kMaxArgs) * 3;  // results + PCRE workspace  static const int kVecSize = (1 + kMaxArgs) * 3;  // results + PCRE workspace
62    
63  // Special object that stands-in for no argument  // Special object that stands-in for no argument
64  Arg no_arg((void*)NULL);  PCRECPP_EXP_DEFN Arg no_arg((void*)NULL);
65    
66  // If a regular expression has no error, its error_ field points here  // If a regular expression has no error, its error_ field points here
67  static const string empty_string;  static const string empty_string;
# Line 60  static const string empty_string; Line 69  static const string empty_string;
69  // If the user doesn't ask for any options, we just use this one  // If the user doesn't ask for any options, we just use this one
70  static RE_Options default_options;  static RE_Options default_options;
71    
72  void RE::Init(const char* pat, const RE_Options* options) {  void RE::Init(const string& pat, const RE_Options* options) {
73    pattern_ = pat;    pattern_ = pat;
74    if (options == NULL) {    if (options == NULL) {
75      options_ = default_options;      options_ = default_options;
# Line 73  void RE::Init(const char* pat, const RE_ Line 82  void RE::Init(const char* pat, const RE_
82    
83    re_partial_ = Compile(UNANCHORED);    re_partial_ = Compile(UNANCHORED);
84    if (re_partial_ != NULL) {    if (re_partial_ != NULL) {
85      // Check for complicated patterns.  The following change is      re_full_ = Compile(ANCHOR_BOTH);
     // conservative in that it may treat some "simple" patterns  
     // as "complex" (e.g., if the vertical bar is in a character  
     // class or is escaped).  But it seems good enough.  
     if (strchr(pat, '|') == NULL) {  
       // Simple pattern: we can use position-based checks to perform  
       // fully anchored matches  
       re_full_ = re_partial_;  
     } else {  
       // We need a special pattern for anchored matches  
       re_full_ = Compile(ANCHOR_BOTH);  
     }  
86    }    }
87  }  }
88    
89    void RE::Cleanup() {
90      if (re_full_ != NULL)         (*pcre_free)(re_full_);
91      if (re_partial_ != NULL)      (*pcre_free)(re_partial_);
92      if (error_ != &empty_string)  delete error_;
93    }
94    
95    
96  RE::~RE() {  RE::~RE() {
97    if (re_full_ != NULL && re_full_ != re_partial_) (*pcre_free)(re_full_);    Cleanup();
   if (re_partial_ != NULL)                         (*pcre_free)(re_partial_);  
   if (error_ != &empty_string)                     delete error_;  
98  }  }
99    
100    
101  pcre* RE::Compile(Anchor anchor) {  pcre* RE::Compile(Anchor anchor) {
102    // First, convert RE_Options into pcre options    // First, convert RE_Options into pcre options
103    int pcre_options = 0;    int pcre_options = 0;
104    if (options_.utf8())    pcre_options = options_.all_options();
     pcre_options |= PCRE_UTF8;  
105    
106    // Special treatment for anchoring.  This is needed because at    // Special treatment for anchoring.  This is needed because at
107    // runtime pcre only provides an option for anchoring at the    // runtime pcre only provides an option for anchoring at the
# Line 332  bool RE::Replace(const StringPiece& rewr Line 335  bool RE::Replace(const StringPiece& rewr
335    return true;    return true;
336  }  }
337    
338    // Returns PCRE_NEWLINE_CRLF, PCRE_NEWLINE_CR, or PCRE_NEWLINE_LF.
339    // Note that PCRE_NEWLINE_CRLF is defined to be P_N_CR | P_N_LF.
340    static int NewlineMode(int pcre_options) {
341      // TODO: if we can make it threadsafe, cache this var
342      int newline_mode = 0;
343      /* if (newline_mode) return newline_mode; */  // do this once it's cached
344      if (pcre_options & (PCRE_NEWLINE_CRLF|PCRE_NEWLINE_CR|PCRE_NEWLINE_LF)) {
345        newline_mode = (pcre_options &
346                        (PCRE_NEWLINE_CRLF|PCRE_NEWLINE_CR|PCRE_NEWLINE_LF));
347      } else {
348        int newline;
349        pcre_config(PCRE_CONFIG_NEWLINE, &newline);
350        if (newline == 10)
351          newline_mode = PCRE_NEWLINE_LF;
352        else if (newline == 13)
353          newline_mode = PCRE_NEWLINE_CR;
354        else if (newline == 3338)
355          newline_mode = PCRE_NEWLINE_CRLF;
356        else
357          assert("" == "Unexpected return value from pcre_config(NEWLINE)");
358      }
359      return newline_mode;
360    }
361    
362  int RE::GlobalReplace(const StringPiece& rewrite,  int RE::GlobalReplace(const StringPiece& rewrite,
363                        string *str) const {                        string *str) const {
364    int count = 0;    int count = 0;
# Line 350  int RE::GlobalReplace(const StringPiece& Line 377  int RE::GlobalReplace(const StringPiece&
377      if (matchstart == matchend && matchstart == lastend) {      if (matchstart == matchend && matchstart == lastend) {
378        // advance one character if we matched an empty string at the same        // advance one character if we matched an empty string at the same
379        // place as the last match occurred        // place as the last match occurred
380        if (start < static_cast<int>(str->length()))        matchend = start + 1;
381          out.push_back((*str)[start]);        // If the current char is CR and we're in CRLF mode, skip LF too.
382        start++;        // Note it's better to call pcre_fullinfo() than to examine
383          // all_options(), since options_ could have changed bewteen
384          // compile-time and now, but this is simpler and safe enough.
385          if (start+1 < static_cast<int>(str->length()) &&
386              (*str)[start] == '\r' && (*str)[start+1] == '\n' &&
387              NewlineMode(options_.all_options()) == PCRE_NEWLINE_CRLF) {
388            matchend++;
389          }
390          // We also need to advance more than one char if we're in utf8 mode.
391    #ifdef SUPPORT_UTF8
392          if (options_.utf8()) {
393            while (matchend < static_cast<int>(str->length()) &&
394                   ((*str)[matchend] & 0xc0) == 0x80)
395              matchend++;
396          }
397    #endif
398          if (matchend <= static_cast<int>(str->length()))
399            out.append(*str, start, matchend - start);
400          start = matchend;
401      } else {      } else {
402        out.append(*str, start, matchstart - start);        out.append(*str, start, matchstart - start);
403        Rewrite(&out, rewrite, *str, vec, matches);        Rewrite(&out, rewrite, *str, vec, matches);
# Line 378  bool RE::Extract(const StringPiece& rewr Line 423  bool RE::Extract(const StringPiece& rewr
423    int matches = TryMatch(text, 0, UNANCHORED, vec, kVecSize);    int matches = TryMatch(text, 0, UNANCHORED, vec, kVecSize);
424    if (matches == 0)    if (matches == 0)
425      return false;      return false;
426    out->clear();    out->erase();
427    return Rewrite(out, rewrite, text, vec, matches);    return Rewrite(out, rewrite, text, vec, matches);
428  }  }
429    
430    /*static*/ string RE::QuoteMeta(const StringPiece& unquoted) {
431      string result;
432    
433      // Escape any ascii character not in [A-Za-z_0-9].
434      //
435      // Note that it's legal to escape a character even if it has no
436      // special meaning in a regular expression -- so this function does
437      // that.  (This also makes it identical to the perl function of the
438      // same name; see `perldoc -f quotemeta`.)
439      for (int ii = 0; ii < unquoted.size(); ++ii) {
440        // Note that using 'isalnum' here raises the benchmark time from
441        // 32ns to 58ns:
442        if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') &&
443            (unquoted[ii] < 'A' || unquoted[ii] > 'Z') &&
444            (unquoted[ii] < '0' || unquoted[ii] > '9') &&
445            unquoted[ii] != '_' &&
446            // If this is the part of a UTF8 or Latin1 character, we need
447            // to copy this byte without escaping.  Experimentally this is
448            // what works correctly with the regexp library.
449            !(unquoted[ii] & 128)) {
450          result += '\\';
451        }
452        result += unquoted[ii];
453      }
454    
455      return result;
456    }
457    
458  /***** Actual matching and rewriting code *****/  /***** Actual matching and rewriting code *****/
459    
460  int RE::TryMatch(const StringPiece& text,  int RE::TryMatch(const StringPiece& text,
# Line 395  int RE::TryMatch(const StringPiece& text Line 468  int RE::TryMatch(const StringPiece& text
468      return 0;      return 0;
469    }    }
470    
471    pcre_extra extra = { 0 };    pcre_extra extra = { 0, 0, 0, 0, 0, 0 };
472    if (options_.match_limit() > 0) {    if (options_.match_limit() > 0) {
473      extra.flags = PCRE_EXTRA_MATCH_LIMIT;      extra.flags |= PCRE_EXTRA_MATCH_LIMIT;
474      extra.match_limit = options_.match_limit();      extra.match_limit = options_.match_limit();
475    }    }
476      if (options_.match_limit_recursion() > 0) {
477        extra.flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
478        extra.match_limit_recursion = options_.match_limit_recursion();
479      }
480    int rc = pcre_exec(re,              // The regular expression object    int rc = pcre_exec(re,              // The regular expression object
481                       &extra,                       &extra,
482                       text.data(),                       (text.data() == NULL) ? "" : text.data(),
483                       text.size(),                       text.size(),
484                       startpos,                       startpos,
485                       (anchor == UNANCHORED) ? 0 : PCRE_ANCHORED,                       (anchor == UNANCHORED) ? 0 : PCRE_ANCHORED,
# Line 424  int RE::TryMatch(const StringPiece& text Line 501  int RE::TryMatch(const StringPiece& text
501      rc = vecsize / 2;      rc = vecsize / 2;
502    }    }
503    
   if ((anchor == ANCHOR_BOTH) && (re_full_ == re_partial_)) {  
     // We need an extra check to make sure that the match extended  
     // to the end of the input string  
     assert(vec[0] == 0);                 // PCRE_ANCHORED forces starting match  
     if (vec[1] != text.size()) return 0; // Did not get ending match  
   }  
   
504    return rc;    return rc;
505  }  }
506    
# Line 449  bool RE::DoMatchImpl(const StringPiece& Line 519  bool RE::DoMatchImpl(const StringPiece&
519    
520    *consumed = vec[1];    *consumed = vec[1];
521    
522    if (args == NULL) {    if (n == 0 || args == NULL) {
523      // We are not interested in results      // We are not interested in results
524      return true;      return true;
525    }    }
526    
527      if (NumberOfCapturingGroups() < n) {
528        // RE has fewer capturing groups than number of arg pointers passed in
529        return false;
530      }
531    
532    // If we got here, we must have matched the whole pattern.    // If we got here, we must have matched the whole pattern.
533    // We do not need (can not do) any more checks on the value of 'matches' here    // We do not need (can not do) any more checks on the value of 'matches' here
534    // -- see the comment for TryMatch.    // -- see the comment for TryMatch.
# Line 517  bool RE::Rewrite(string *out, const Stri Line 592  bool RE::Rewrite(string *out, const Stri
592    
593  // Return the number of capturing subpatterns, or -1 if the  // Return the number of capturing subpatterns, or -1 if the
594  // regexp wasn't valid on construction.  // regexp wasn't valid on construction.
595  int RE::NumberOfCapturingGroups() {  int RE::NumberOfCapturingGroups() const {
596    if (re_partial_ == NULL) return -1;    if (re_partial_ == NULL) return -1;
597    
598    int result;    int result;
# Line 613  bool Arg::parse_ulong_radix(const char* Line 688  bool Arg::parse_ulong_radix(const char*
688    if (n == 0) return false;    if (n == 0) return false;
689    char buf[kMaxNumberLength+1];    char buf[kMaxNumberLength+1];
690    str = TerminateNumber(buf, str, n);    str = TerminateNumber(buf, str, n);
691      if (str[0] == '-') return false;    // strtoul() on a negative number?!
692    char* end;    char* end;
693    errno = 0;    errno = 0;
694    unsigned long r = strtoul(str, &end, radix);    unsigned long r = strtoul(str, &end, radix);
# Line 702  bool Arg::parse_ulonglong_radix(const ch Line 778  bool Arg::parse_ulonglong_radix(const ch
778    if (n == 0) return false;    if (n == 0) return false;
779    char buf[kMaxNumberLength+1];    char buf[kMaxNumberLength+1];
780    str = TerminateNumber(buf, str, n);    str = TerminateNumber(buf, str, n);
781      if (str[0] == '-') return false;    // strtoull() on a negative number?!
782    char* end;    char* end;
783    errno = 0;    errno = 0;
784  #if defined HAVE_STRTOQ  #if defined HAVE_STRTOQ
# Line 756  bool Arg::parse_float(const char* str, i Line 833  bool Arg::parse_float(const char* str, i
833      return parse_##name##_radix(str, n, dest, 0);                       \      return parse_##name##_radix(str, n, dest, 0);                       \
834    }    }
835    
836  DEFINE_INTEGER_PARSERS(short);  DEFINE_INTEGER_PARSERS(short)      /*                                   */
837  DEFINE_INTEGER_PARSERS(ushort);  DEFINE_INTEGER_PARSERS(ushort)     /*                                   */
838  DEFINE_INTEGER_PARSERS(int);  DEFINE_INTEGER_PARSERS(int)        /* Don't use semicolons after these  */
839  DEFINE_INTEGER_PARSERS(uint);  DEFINE_INTEGER_PARSERS(uint)       /* statements because they can cause */
840  DEFINE_INTEGER_PARSERS(long);  DEFINE_INTEGER_PARSERS(long)       /* compiler warnings if the checking */
841  DEFINE_INTEGER_PARSERS(ulong);  DEFINE_INTEGER_PARSERS(ulong)      /* level is turned up high enough.   */
842  DEFINE_INTEGER_PARSERS(longlong);  DEFINE_INTEGER_PARSERS(longlong)   /*                                   */
843  DEFINE_INTEGER_PARSERS(ulonglong);  DEFINE_INTEGER_PARSERS(ulonglong)  /*                                   */
844    
845  #undef DEFINE_INTEGER_PARSERS  #undef DEFINE_INTEGER_PARSERS
846    

Legend:
Removed from v.77  
changed lines
  Added in v.234

  ViewVC Help
Powered by ViewVC 1.1.5