Regex.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <string.h>     // for strlen
#include <exception>    // runtime_error
 
#include <dcl/Regex.h>
#include <dcl/Charset.h>
#include <dcl/Array.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/Regex.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(RegexException, Exception)
 
RegexException::RegexException(const char* _name, const char* _what)
    : Exception(NULL)
{
    StringBuilder sb;
    sb.append(AsciiDecoder::decode(_name))
        .append(__T(":"))
        .append(AsciiDecoder::decode(_what));
    __message = sb.toString();
}
 
String RegexException::toString() const
{
    return __message;
}
 
Regex::MatchResults::MatchResults()
{
    __results = NULL;
    __size = 0;
}
 
Regex::MatchResults::~MatchResults()
{
    if (__results) {
        __matches_free(__results);
//      __results = NULL;
    }
}
 
void Regex::MatchResults::attach(match_result* _results, size_t _size)
{
    __DCL_ASSERT(_results != NULL);
 
    if (__results) {
        __matches_free(__results);
    }
    __results = _results;
    __size = _size;
}
 
const match_result& Regex::MatchResults::operator [] (size_t _index) const
    __DCL_THROWS1(InvalidIndexException*)
{
    __DCL_ASSERT(__results != NULL);
 
    if (!(_index < __size)) {
        throw(new InvalidIndexException(0, (ssize_t)(__size - 1), _index));
    }
    return __results[_index];
}
 
Regex::~Regex()
{
    if (__handle) {
        __regex_destroy(__handle);
//      __handle = NULL;
    }
}
 
Regex::Regex()
{
    __handle = NULL;
}
 
Regex::Regex(const wchar_t* _pattern, size_t _n,
        unsigned int _flags) // = 0)
    __DCL_THROWS1(RegexException*)
{
    __handle = NULL;
    compile(_pattern, _n, _flags);
}
 
Regex::Regex(const String& _pattern, unsigned int _flags) // = 0)
    __DCL_THROWS1(RegexException*)
{
    __handle = NULL;
    compile(_pattern.data(), _pattern.length(), _flags);
}
 
void Regex::compile(const wchar_t* _pattern, size_t _n,
        unsigned int _flags) // = 0);
    __DCL_THROWS1(RegexException*)
{
    if (!__handle) {
        __handle = __regex_create();
    }
 
    try {
        __regex_compile(__handle, _pattern, _n, _flags);
    }
//  catch (boost::bad_expression& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
bool Regex::search(const wchar_t* _begin, const wchar_t* _end,
        unsigned int _flags)
    __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    bool r = false;
    try {
        r = __regex_search(__handle, _begin, _end, _flags);
    }
//  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
 
    return r;
}
 
bool Regex::search(const wchar_t* _begin, const wchar_t* _end,
        Regex::MatchResults& _results, unsigned int _flags) // = 0)
    __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    try {
        match_result* results = NULL;
        size_t n = __regex_search(__handle, _begin, _end, &results, _flags);
        if (n) {
            _results.attach(results, n);
            return true;
        }
    }
//  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
 
    return false;
}
 
bool Regex::match(const wchar_t* _begin, const wchar_t* _end,
        unsigned int _flags)
    __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    bool r = false;
    try {
        r = __regex_match(__handle, _begin, _end, _flags);
    }
//  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
 
    return r;
}
 
bool Regex::match(const wchar_t* _begin, const wchar_t* _end,
        Regex::MatchResults& _results, unsigned int _flags) // = 0)
    __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT(__handle != NULL);
 
    try {
        match_result* results = NULL;
        size_t n = __regex_match(__handle, _begin, _end, &results, _flags);
        if (n) {
            _results.attach(results, n);
            return true;
        }
    }
//  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
 
    return false;
}
 
String Regex::replace(
    const String& _string,
    const String& _replacement,
    size_t _limit
) __DCL_THROWS1(RegexException*)
{
    const wchar_t* _begin = _string.data();
    const wchar_t* _end = _string.data() + _string.length();
    StringBuilder r;
 
    MatchResults results;
    while (_begin < _end && 0 < _limit && search(_begin, _end, results)) {
        r.append(_begin, results[0].first);
        r.append(_replacement);
 
        _limit--;
        _begin = results[0].second;
    }
 
    if (_begin < _end) {
        r.append(_begin, _end);
    }
 
    return r;
}
 
size_t Regex::split(
    const wchar_t* _begin, const wchar_t* _end,
    StringArray& _results,
    size_t _limit       // = (size_t)-1 // unlimited
) __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT(_begin != NULL && _end != NULL);
    __DCL_ASSERT(_begin <= _end);
 
    MatchResults results;
    while(_begin < _end && _limit > 0 && search(_begin, _end, results)) {
        _results.add(String(_begin, results[0].first - _begin));
 
        _limit--;
        _begin = results[0].second;
    }
 
    if (_begin < _end) {
        _results.add(String(_end, _end - _begin));
    }
 
    return _results.size();
}
 
bool Regex::test(
    const wchar_t* _regex,
    const wchar_t* _string,
    bool _icase // = false
) __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    __DCL_ASSERT_PARAM(_string != NULL);
    return __regex_search(
        _regex, _regex + String::length(_regex),
        _string, _string + String::length(_string),
        _icase
    ) != (size_t)-1;
}
 
bool Regex::test(
    const char* _regex,
    const char* _string,
    bool _icase // = false
) __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    __DCL_ASSERT_PARAM(_string != NULL);
    return __regex_search(
        _regex, _regex + ByteString::length(_regex),
        _string, _string + ByteString::length(_string),
        _icase
    ) != (size_t)-1;;
}
 
__DCL_END_NAMESPACE