src/common/regex.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/regex.cpp
   3 // Purpose:     regular expression matching
   4 // Author:      Karsten Ballüder and Vadim Zeitlin
   5 // Modified by:
   6 // Created:     13.07.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 Karsten Ballüder <ballueder@gmx.net>
   9 //                  2001 Vadim Zeitlin <vadim@wxwindows.org>
  10 // Licence:     wxWindows licence
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #ifdef __GNUG__
  22     #pragma implementation "regex.h"
  23 #endif
  24
  25 // For compilers that support precompilation, includes "wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 #if wxUSE_REGEX
  33
  34 #ifndef WX_PRECOMP
  35     #include "wx/object.h"
  36     #include "wx/string.h"
  37     #include "wx/log.h"
  38     #include "wx/intl.h"
  39 #endif //WX_PRECOMP
  40
  41 // FreeBSD & Watcom require this, it probably doesn't hurt for others
  42 #if defined(__UNIX__) || defined(__WATCOMC__) || defined(__DIGITALMARS__)
  43     #include <sys/types.h>
  44 #endif
  45
  46 #include <regex.h>
  47
  48 #include "wx/regex.h"
  49
  50 // ----------------------------------------------------------------------------
  51 // private classes
  52 // ----------------------------------------------------------------------------
  53
  54 // the real implementation of wxRegEx
  55 class wxRegExImpl
  56 {
  57 public:
  58     // ctor and dtor
  59     wxRegExImpl();
  60     ~wxRegExImpl();
  61
  62     // return TRUE if Compile() had been called successfully
  63     bool IsValid() const { return m_isCompiled; }
  64
  65     // RE operations
  66     bool Compile(const wxString& expr, int flags = 0);
  67     bool Matches(const wxChar *str, int flags = 0) const;
  68     bool GetMatch(size_t *start, size_t *len, size_t index = 0) const;
  69     int Replace(wxString *pattern, const wxString& replacement,
  70                 size_t maxMatches = 0) const;
  71
  72 private:
  73     // return the string containing the error message for the given err code
  74     wxString GetErrorMsg(int errorcode) const;
  75
  76     // init the members
  77     void Init()
  78     {
  79         m_isCompiled = FALSE;
  80         m_Matches = NULL;
  81         m_nMatches = 0;
  82     }
  83
  84     // free the RE if compiled
  85     void Free()
  86     {
  87         if ( IsValid() )
  88         {
  89             regfree(&m_RegEx);
  90         }
  91
  92         delete [] m_Matches;
  93     }
  94
  95     // free the RE if any and reinit the members
  96     void Reinit()
  97     {
  98         Free();
  99         Init();
 100     }
 101
 102
 103     // compiled RE
 104     regex_t     m_RegEx;
 105
 106     // the subexpressions data
 107     regmatch_t *m_Matches;
 108     size_t      m_nMatches;
 109
 110     // TRUE if m_RegEx is valid
 111     bool        m_isCompiled;
 112 };
 113
 114 // ============================================================================
 115 // implementation
 116 // ============================================================================
 117
 118 // ----------------------------------------------------------------------------
 119 // wxRegExImpl
 120 // ----------------------------------------------------------------------------
 121
 122 wxRegExImpl::wxRegExImpl()
 123 {
 124     Init();
 125 }
 126
 127 wxRegExImpl::~wxRegExImpl()
 128 {
 129     Free();
 130 }
 131
 132 wxString wxRegExImpl::GetErrorMsg(int errorcode) const
 133 {
 134     wxString msg;
 135
 136     // first get the string length needed
 137     int len = regerror(errorcode, &m_RegEx, NULL, 0);
 138     if ( len > 0 )
 139     {
 140         len++;
 141
 142 #if wxUSE_UNICODE
 143         wxCharBuffer buf(len);
 144
 145         (void)regerror(errorcode, &m_RegEx, (char *)buf.data(), len);
 146
 147         msg = wxString(buf.data(), wxConvLibc);
 148 #else // !Unicode
 149         (void)regerror(errorcode, &m_RegEx, msg.GetWriteBuf(len), len);
 150
 151         msg.UngetWriteBuf();
 152 #endif // Unicode/!Unicode
 153     }
 154     else // regerror() returned 0
 155     {
 156         msg = _("unknown error");
 157     }
 158
 159     return msg;
 160 }
 161
 162 bool wxRegExImpl::Compile(const wxString& expr, int flags)
 163 {
 164     Reinit();
 165
 166     // translate our flags to regcomp() ones
 167     wxASSERT_MSG( !(flags &
 168                         ~(wxRE_BASIC | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),
 169                   _T("unrecognized flags in wxRegEx::Compile") );
 170
 171     int flagsRE = 0;
 172     if ( !(flags & wxRE_BASIC) )
 173         flagsRE |= REG_EXTENDED;
 174     if ( flags & wxRE_ICASE )
 175         flagsRE |= REG_ICASE;
 176     if ( flags & wxRE_NOSUB )
 177         flagsRE |= REG_NOSUB;
 178     if ( flags & wxRE_NEWLINE )
 179         flagsRE |= REG_NEWLINE;
 180
 181     // compile it
 182     int errorcode = regcomp(&m_RegEx, expr.mb_str(), flagsRE);
 183     if ( errorcode )
 184     {
 185         wxLogError(_("Invalid regular expression '%s': %s"),
 186                    expr.c_str(), GetErrorMsg(errorcode).c_str());
 187
 188         m_isCompiled = FALSE;
 189     }
 190     else // ok
 191     {
 192         // don't allocate the matches array now, but do it later if necessary
 193         if ( flags & wxRE_NOSUB )
 194         {
 195             // we don't need it at all
 196             m_nMatches = 0;
 197         }
 198         else
 199         {
 200             // we will alloc the array later (only if really needed) but count
 201             // the number of sub-expressions in the regex right now
 202
 203             // there is always one for the whole expression
 204             m_nMatches = 1;
 205
 206             // and some more for bracketed subexperessions
 207             const wxChar *cptr = expr.c_str();
 208             wxChar prev = _T('\0');
 209             while ( *cptr != _T('\0') )
 210             {
 211                 // is this a subexpr start, i.e. "(" for extended regex or
 212                 // "\(" for a basic one?
 213                 if ( *cptr == _T('(') &&
 214                      (flags & wxRE_BASIC ? prev == _T('\\')
 215                                          : prev != _T('\\')) )
 216                 {
 217                     m_nMatches++;
 218                 }
 219
 220                 prev = *cptr;
 221                 cptr++;
 222             }
 223         }
 224
 225         m_isCompiled = TRUE;
 226     }
 227
 228     return IsValid();
 229 }
 230
 231 bool wxRegExImpl::Matches(const wxChar *str, int flags) const
 232 {
 233     wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
 234
 235     // translate our flags to regexec() ones
 236     wxASSERT_MSG( !(flags & ~(wxRE_NOTBOL | wxRE_NOTEOL)),
 237                   _T("unrecognized flags in wxRegEx::Matches") );
 238
 239     int flagsRE = 0;
 240     if ( flags & wxRE_NOTBOL )
 241         flagsRE |= REG_NOTBOL;
 242     if ( flags & wxRE_NOTEOL )
 243         flagsRE |= REG_NOTEOL;
 244
 245     // allocate matches array if needed
 246     wxRegExImpl *self = wxConstCast(this, wxRegExImpl);
 247     if ( !m_Matches && m_nMatches )
 248     {
 249         self->m_Matches = new regmatch_t[m_nMatches];
 250     }
 251
 252     // do match it
 253     int rc = regexec(&self->m_RegEx, wxConvertWX2MB(str), m_nMatches, m_Matches, flagsRE);
 254
 255     switch ( rc )
 256     {
 257         case 0:
 258             // matched successfully
 259             return TRUE;
 260
 261         default:
 262             // an error occured
 263             wxLogError(_("Failed to match '%s' in regular expression: %s"),
 264                        str, GetErrorMsg(rc).c_str());
 265             // fall through
 266
 267         case REG_NOMATCH:
 268             // no match
 269             return FALSE;
 270     }
 271 }
 272
 273 bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) const
 274 {
 275     wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
 276     wxCHECK_MSG( m_Matches, FALSE, _T("can't use with wxRE_NOSUB") );
 277     wxCHECK_MSG( index < m_nMatches, FALSE, _T("invalid match index") );
 278
 279     const regmatch_t& match = m_Matches[index];
 280
 281     if ( start )
 282         *start = match.rm_so;
 283     if ( len )
 284         *len = match.rm_eo - match.rm_so;
 285
 286     return TRUE;
 287 }
 288
 289 int wxRegExImpl::Replace(wxString *text,
 290                          const wxString& replacement,
 291                          size_t maxMatches) const
 292 {
 293     wxCHECK_MSG( text, -1, _T("NULL text in wxRegEx::Replace") );
 294     wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
 295
 296     // the replacement text
 297     wxString textNew;
 298
 299     // attempt at optimization: don't iterate over the string if it doesn't
 300     // contain back references at all
 301     bool mayHaveBackrefs =
 302         replacement.find_first_of(_T("\\&")) != wxString::npos;
 303
 304     if ( !mayHaveBackrefs )
 305     {
 306         textNew = replacement;
 307     }
 308
 309     // the position where we start looking for the match
 310     //
 311     // NB: initial version had a nasty bug because it used a wxChar* instead of
 312     //     an index but the problem is that replace() in the loop invalidates
 313     //     all pointers into the string so we have to use indices instead
 314     size_t matchStart = 0;
 315
 316     // number of replacement made: we won't make more than maxMatches of them
 317     // (unless maxMatches is 0 which doesn't limit the number of replacements)
 318     size_t countRepl = 0;
 319
 320     // note that "^" shouldn't match after the first call to Matches() so we
 321     // use wxRE_NOTBOL to prevent it from happening
 322     while ( (!maxMatches || countRepl < maxMatches) &&
 323             Matches(text->c_str() + matchStart, countRepl ? wxRE_NOTBOL : 0) )
 324     {
 325         // the string possibly contains back references: we need to calculate
 326         // the replacement text anew after each match
 327         if ( mayHaveBackrefs )
 328         {
 329             mayHaveBackrefs = FALSE;
 330             textNew.clear();
 331             textNew.reserve(replacement.length());
 332
 333             for ( const wxChar *p = replacement.c_str(); *p; p++ )
 334             {
 335                 size_t index = (size_t)-1;
 336
 337                 if ( *p == _T('\\') )
 338                 {
 339                     if ( wxIsdigit(*++p) )
 340                     {
 341                         // back reference
 342                         wxChar *end;
 343                         index = (size_t)wxStrtoul(p, &end, 10);
 344                         p = end - 1; // -1 to compensate for p++ in the loop
 345                     }
 346                     //else: backslash used as escape character
 347                 }
 348                 else if ( *p == _T('&') )
 349                 {
 350                     // treat this as "\0" for compatbility with ed and such
 351                     index = 0;
 352                 }
 353
 354                 // do we have a back reference?
 355                 if ( index != (size_t)-1 )
 356                 {
 357                     // yes, get its text
 358                     size_t start, len;
 359                     if ( !GetMatch(&start, &len, index) )
 360                     {
 361                         wxFAIL_MSG( _T("invalid back reference") );
 362
 363                         // just eat it...
 364                     }
 365                     else
 366                     {
 367                         textNew += wxString(text->c_str() + matchStart + start,
 368                                             len);
 369
 370                         mayHaveBackrefs = TRUE;
 371                     }
 372                 }
 373                 else // ordinary character
 374                 {
 375                     textNew += *p;
 376                 }
 377             }
 378         }
 379
 380         size_t start, len;
 381         if ( !GetMatch(&start, &len) )
 382         {
 383             // we did have match as Matches() returned true above!
 384             wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );
 385
 386             return -1;
 387         }
 388
 389         matchStart += start;
 390         text->replace(matchStart, len, textNew);
 391
 392         countRepl++;
 393
 394         matchStart += textNew.length();
 395     }
 396
 397     return countRepl;
 398 }
 399
 400 // ----------------------------------------------------------------------------
 401 // wxRegEx: all methods are mostly forwarded to wxRegExImpl
 402 // ----------------------------------------------------------------------------
 403
 404 void wxRegEx::Init()
 405 {
 406     m_impl = NULL;
 407 }
 408
 409
 410 wxRegEx::~wxRegEx()
 411 {
 412     delete m_impl;
 413 }
 414
 415 bool wxRegEx::Compile(const wxString& expr, int flags)
 416 {
 417     if ( !m_impl )
 418     {
 419         m_impl = new wxRegExImpl;
 420     }
 421
 422     if ( !m_impl->Compile(expr, flags) )
 423     {
 424         // error message already given in wxRegExImpl::Compile
 425         delete m_impl;
 426         m_impl = NULL;
 427
 428         return FALSE;
 429     }
 430
 431     return TRUE;
 432 }
 433
 434 bool wxRegEx::Matches(const wxChar *str, int flags) const
 435 {
 436     wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
 437
 438     return m_impl->Matches(str, flags);
 439 }
 440
 441 bool wxRegEx::GetMatch(size_t *start, size_t *len, size_t index) const
 442 {
 443     wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
 444
 445     return m_impl->GetMatch(start, len, index);
 446 }
 447
 448 wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
 449 {
 450     size_t start, len;
 451     if ( !GetMatch(&start, &len, index) )
 452         return wxEmptyString;
 453
 454     return text.Mid(start, len);
 455 }
 456
 457 int wxRegEx::Replace(wxString *pattern,
 458                      const wxString& replacement,
 459                      size_t maxMatches) const
 460 {
 461     wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
 462
 463     return m_impl->Replace(pattern, replacement, maxMatches);
 464 }
 465
 466 #endif // wxUSE_REGEX