_regex.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
#include <dcl/_regex.h>

 
#if 1
    #include <regex>
    using namespace std;
#else
    #include <boost/regex.hpp>
    using namespace boost;
#endif
 
#include <dcl/Object.h>
#include <dcl/Regex.h>
#include <dcl/String.h>
#include <dcl/Array.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/_regex.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
regex_handle __regex_create()
{
    //wregex* p = (wregex*)malloc(sizeof(wregex));
    //return new(p) wregex; 
    __DCL_DEBUG_ALLOC_ENTER;
    regex_handle r = (regex_handle)new wregex();
    __DCL_DEBUG_ALLOC_LEAVE;
    return r;
}
 
void __regex_destroy(regex_handle _handle)
{
    //wregex* p = (wregex*)_handle;
    //p->~wregex();
    //free(p);
#ifdef __DCL_DEBUG_DELETE
// MINGW64 g++ 은 overrided delete를 호출하지 않는다!
#define delete(_p) __DCL_DEBUG_DELETE(_p)
#endif
    delete ((wregex*)_handle);
#ifdef __DCL_DEBUG_DELETE
#undef delete
#endif
}
 
void __regex_compile(
    regex_handle _handle,
    const wchar_t* _pattern, size_t _n,
    unsigned int _flags
) // throws(boost::bad_expression&)
{
    wregex::flag_type flags = wregex::extended;// wregex::normal;
    if (_flags & regex_icase)
        flags |= wregex::icase;
    if (_flags & regex_nosubs)
        flags |= wregex::nosubs;
#if 0
    if (_flags & regex_newline)
        flags |= wregex::newline_alt;
#endif
    __DCL_DEBUG_ALLOC_ENTER;
    ((wregex*)_handle)->assign(_pattern, _pattern + _n, flags);
    __DCL_DEBUG_ALLOC_LEAVE;
}
 
void __matches_free(match_result* _results)
{
    free(_results);
//  delete[] _results;
}
 
size_t __regex_match(
    regex_handle _handle,
    const wchar_t* _begin, const wchar_t* _end,
    match_result** _results, unsigned int _flags
) // throws(std::runtime_error&)
{
    regex_constants::match_flag_type flags = regex_constants::match_default;
    if (_flags & regex_not_bol)
        flags |= regex_constants::match_not_bol;
    if (_flags & regex_not_eol)
        flags |= regex_constants::match_not_eol;
 
    wcmatch m;
    __DCL_DEBUG_ALLOC_ENTER;
    bool b = regex_match(_begin, _end, m, *((const wregex*)_handle), flags);
    __DCL_DEBUG_ALLOC_LEAVE;
    if (b) {
        match_result* match = (match_result*)malloc(sizeof(match_result) * m.size());
        for(size_t i = 0; i < m.size(); i++) {
            match[i].first = m[i].first;
            match[i].second = m[i].second;
            match[i].matched = m[i].matched;
        }
        *_results = match;
        return m.size();
    }
    *_results = NULL;
    return 0;
}
 
bool __regex_match(
    regex_handle _handle,
    const wchar_t* _begin, const wchar_t* _end,
    unsigned int _flags
) // throws(std::runtime_error&)
{
    regex_constants::match_flag_type flags = regex_constants::match_default;
    if (_flags & regex_not_bol)
        flags |= regex_constants::match_not_bol;
    if (_flags & regex_not_eol)
        flags |= regex_constants::match_not_eol;
 
    __DCL_DEBUG_ALLOC_ENTER;
    bool r = regex_match(_begin, _end, *(const wregex*)_handle, flags);
    __DCL_DEBUG_ALLOC_LEAVE;
    return r;
}
 
bool __regex_search(
    regex_handle _handle,
    const wchar_t* _begin, const wchar_t* _end,
    match_result** _results, unsigned int _flags
) // throws(std::runtime_error&)
{
    regex_constants::match_flag_type flags = regex_constants::match_default;
    if (_flags & regex_not_bol)
        flags |= regex_constants::match_not_bol;
    if (_flags & regex_not_eol)
        flags |= regex_constants::match_not_eol;
 
    wcmatch m;
    __DCL_DEBUG_ALLOC_ENTER;
    bool r = regex_search(_begin, _end, m, *((const wregex*)_handle), flags);
    __DCL_DEBUG_ALLOC_LEAVE;
    if (r) {
        match_result* match = (match_result*)malloc(sizeof(match_result) * m.size());
        for(size_t i = 0; i < m.size(); i++) {
            match[i].first = m[i].first;
            match[i].second = m[i].second;
            match[i].matched = m[i].matched;
        }
        *_results = match;
        return m.size();
    }
    *_results = NULL;
    return r;
}
 
bool __regex_search(
    regex_handle _handle,
    const wchar_t* _begin, const wchar_t* _end,
    unsigned int _flags
)   // throws(std::runtime_error&)
{
    regex_constants::match_flag_type flags = regex_constants::match_default;
    if (_flags & regex_not_bol)
        flags |= regex_constants::match_not_bol;
    if (_flags & regex_not_eol)
        flags |= regex_constants::match_not_eol;
 
    __DCL_DEBUG_ALLOC_ENTER;
    bool r = regex_search(_begin, _end, *(const wregex*)_handle, flags);
    __DCL_DEBUG_ALLOC_LEAVE;
    return r;
}
 
bool __regex_matches(
    const wchar_t* _regex, const wchar_t* _regexend,
    const wchar_t* _begin, const wchar_t* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        wregex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        bool r = regex_match(_begin, _end, re);
        __DCL_DEBUG_ALLOC_LEAVE;
        return r;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
bool __regex_matches(
    const char* _regex, const char* _regexend,
    const char* _begin, const char* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        regex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        bool r = regex_match(_begin, _end, re);
        __DCL_DEBUG_ALLOC_LEAVE;
        return r;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
size_t __regex_search(
    const wchar_t* _regex, const wchar_t* _regexend,
    const wchar_t* _begin, const wchar_t* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    // GNUC BUG!!
    // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    size_t r = (size_t)-1;
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        wregex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        wcmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        if (regex_search(_begin, _end, m, re)) {
            r = m[0].first - _begin;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
    return r;
}
 
size_t __regex_search(
    const char* _regex, const char* _regexend,
    const char* _begin, const char* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    // GNUC BUG!!
    // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    size_t r = (size_t)-1;
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        regex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        cmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        if (regex_search(_begin, _end, m, re)) {
            r = m[0].first - _begin;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
    return r;
}
 
String __regex_substring(
    const wchar_t* _regex, const wchar_t* _regexend,
    const wchar_t* _begin, const wchar_t* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    // GNUC BUG!!
    // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    String r;
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        wregex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        wcmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        if (regex_search(_begin, _end, m, re)) {
            r.assign(m[0].first, m[0].second);
        }
        __DCL_DEBUG_ALLOC_LEAVE;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
    return r;
}
 
ByteString __regex_substring(
    const char* _regex, const char* _regexend,
    const char* _begin, const char* _end,
    bool _icase
) __DCL_THROWS1(RegexException*)
{
    // GNUC BUG!!
    // regex re(_pattern, regex::extended | (_icase ? regex::icase : 0));
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    ByteString r;
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        regex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        cmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        __DCL_DEBUG_ALLOC_ENTER;
        if (regex_search(_begin, _end, m, re)) {
            r.assign(m[0].first, m[0].second);
        }
        __DCL_DEBUG_ALLOC_LEAVE;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
    return r;
}
 
String __regex_replace(
    const wchar_t* _regex, const wchar_t* _regexend,
    const wchar_t* _begin, const wchar_t* _end,
    const wchar_t* _replacement, const wchar_t* _replacementend,
    bool _icase,
    size_t _limit // = (size_t)-1
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        StringBuilder r;
        __DCL_DEBUG_ALLOC_ENTER;
        wregex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        wcmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
            __DCL_ASSERT(m.size() > 0);
            r.append(_begin, m[0].first)
                .append(_replacement, _replacementend);
 
            _limit--;
            _begin = m[0].second;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
        if (_begin < _end) {
            r.append(_begin, _end);
        }
 
        return r;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
ByteString __regex_replace(
    const char* _regex, const char* _regexend,
    const char* _begin, const char* _end,
    const char* _replacement, const char* _replacementend,
    bool _icase,
    size_t _limit // = (size_t)-1
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        ByteStringBuilder r;
        __DCL_DEBUG_ALLOC_ENTER;
        regex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        cmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
            __DCL_ASSERT(m.size() > 0);
            r.append(_begin, m[0].first)
                .append(_replacement, _replacementend);
 
            _limit--;
            _begin = m[0].second;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
        if (_begin < _end) {
            r.append(_begin, _end);
        }
 
        return r;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
StringArray& __regex_split(
    const wchar_t* _regex, const wchar_t* _regexend,
    const wchar_t* _begin, const wchar_t* _end,
    bool _icase,
    StringArray& _results,
    size_t _limit // = (size_t)-1
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        wregex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        wcmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
            __DCL_ASSERT(m.size() > 0);
            _results.add(String(_begin, m[0].first));
 
            _limit--;
            _begin = m[0].second;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
        if (_begin < _end) {
            _results.add(String(_begin, _end));
        }
 
        return _results;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
ByteStringArray& __regex_split(
    const char* _regex, const char* _regexend,
    const char* _begin, const char* _end,
    bool _icase,
    ByteStringArray& _results,
    size_t _limit // = (size_t)-1
) __DCL_THROWS1(RegexException*)
{
    regex::flag_type flags = regex::ECMAScript | regex::nosubs;
    if (_icase) {
        flags |= regex::icase;
    }
 
    try {
        __DCL_DEBUG_ALLOC_ENTER;
        regex re(_regex, _regexend, flags);
        __DCL_DEBUG_ALLOC_ENTER;
        cmatch m;
        __DCL_DEBUG_ALLOC_ENTER;
        while (_begin < _end && _limit && regex_search(_begin, _end, m, re)) {
            __DCL_ASSERT(m.size() > 0);
            _results.add(ByteString(_begin, m[0].first));
 
            _limit--;
            _begin = m[0].second;
        }
        __DCL_DEBUG_ALLOC_LEAVE;
        if (_begin < _end) {
            _results.add(ByteString(_begin, _end));
        }
 
        return _results;
    }
    //  catch (std::runtime_error& e)
    catch (std::exception& e) {
        throw(new RegexException(typeid(e).name(), e.what()));
    }
}
 
__DCL_END_NAMESPACE