/* | |
* Copyright (C) 2004, 2008, 2009 Apple Inc. All rights reserved. | |
* Copyright (C) 2008 Collabora Ltd. | |
* | |
* Redistribution and use in source and binary forms, with or without | |
* modification, are permitted provided that the following conditions | |
* are met: | |
* 1. Redistributions of source code must retain the above copyright | |
* notice, this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright | |
* notice, this list of conditions and the following disclaimer in the | |
* documentation and/or other materials provided with the distribution. | |
* | |
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY | |
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR | |
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | |
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
*/ | |
#include "config.h" | |
#include "RegularExpression.h" | |
#include "Logging.h" | |
#include <pcre/pcre.h> | |
namespace WebCore { | |
class RegularExpression::Private : public RefCounted<RegularExpression::Private> { | |
public: | |
static PassRefPtr<Private> create(const String& pattern, TextCaseSensitivity); | |
~Private(); | |
JSRegExp* regexp() const { return m_regexp; } | |
int lastMatchLength; | |
private: | |
Private(const String& pattern, TextCaseSensitivity); | |
static JSRegExp* compile(const String& pattern, TextCaseSensitivity); | |
JSRegExp* m_regexp; | |
}; | |
inline JSRegExp* RegularExpression::Private::compile(const String& pattern, TextCaseSensitivity caseSensitivity) | |
{ | |
const char* errorMessage; | |
JSRegExp* regexp = jsRegExpCompile(pattern.characters(), pattern.length(), | |
caseSensitivity == TextCaseSensitive ? JSRegExpDoNotIgnoreCase : JSRegExpIgnoreCase, JSRegExpSingleLine, | |
0, &errorMessage); | |
if (!regexp) | |
LOG_ERROR("RegularExpression: pcre_compile failed with '%s'", errorMessage); | |
return regexp; | |
} | |
inline RegularExpression::Private::Private(const String& pattern, TextCaseSensitivity caseSensitivity) | |
: lastMatchLength(-1) | |
, m_regexp(compile(pattern, caseSensitivity)) | |
{ | |
} | |
inline PassRefPtr<RegularExpression::Private> RegularExpression::Private::create(const String& pattern, TextCaseSensitivity caseSensitivity) | |
{ | |
return adoptRef(new Private(pattern, caseSensitivity)); | |
} | |
RegularExpression::Private::~Private() | |
{ | |
jsRegExpFree(m_regexp); | |
} | |
RegularExpression::RegularExpression(const String& pattern, TextCaseSensitivity caseSensitivity) | |
: d(Private::create(pattern, caseSensitivity)) | |
{ | |
} | |
RegularExpression::RegularExpression(const RegularExpression& re) | |
: d(re.d) | |
{ | |
} | |
RegularExpression::~RegularExpression() | |
{ | |
} | |
RegularExpression& RegularExpression::operator=(const RegularExpression& re) | |
{ | |
d = re.d; | |
return *this; | |
} | |
int RegularExpression::match(const String& str, int startFrom, int* matchLength) const | |
{ | |
if (!d->regexp()) | |
return -1; | |
if (str.isNull()) | |
return -1; | |
// First 2 offsets are start and end offsets; 3rd entry is used internally by pcre | |
static const size_t maxOffsets = 3; | |
int offsets[maxOffsets]; | |
int result = jsRegExpExecute(d->regexp(), str.characters(), str.length(), startFrom, offsets, maxOffsets); | |
if (result < 0) { | |
if (result != JSRegExpErrorNoMatch) | |
LOG_ERROR("RegularExpression: pcre_exec() failed with result %d", result); | |
d->lastMatchLength = -1; | |
return -1; | |
} | |
// 1 means 1 match; 0 means more than one match. First match is recorded in offsets. | |
d->lastMatchLength = offsets[1] - offsets[0]; | |
if (matchLength) | |
*matchLength = d->lastMatchLength; | |
return offsets[0]; | |
} | |
int RegularExpression::searchRev(const String& str) const | |
{ | |
// FIXME: This could be faster if it actually searched backwards. | |
// Instead, it just searches forwards, multiple times until it finds the last match. | |
int start = 0; | |
int pos; | |
int lastPos = -1; | |
int lastMatchLength = -1; | |
do { | |
int matchLength; | |
pos = match(str, start, &matchLength); | |
if (pos >= 0) { | |
if (pos + matchLength > lastPos + lastMatchLength) { | |
// replace last match if this one is later and not a subset of the last match | |
lastPos = pos; | |
lastMatchLength = matchLength; | |
} | |
start = pos + 1; | |
} | |
} while (pos != -1); | |
d->lastMatchLength = lastMatchLength; | |
return lastPos; | |
} | |
int RegularExpression::matchedLength() const | |
{ | |
return d->lastMatchLength; | |
} | |
void replace(String& string, const RegularExpression& target, const String& replacement) | |
{ | |
int index = 0; | |
while (index < static_cast<int>(string.length())) { | |
int matchLength; | |
index = target.match(string, index, &matchLength); | |
if (index < 0) | |
break; | |
string.replace(index, matchLength, replacement); | |
index += replacement.length(); | |
if (!matchLength) | |
break; // Avoid infinite loop on 0-length matches, e.g. [a-z]* | |
} | |
} | |
} // namespace WebCore |