_regex.h File Reference

Go to the source code of this file.

Classes
struct	match_result

Typedefs
typedef void *	regex_handle

Enumerations
enum	regex_compile_flags { regex_icase = 0x0001 , regex_nosubs = 0x0002 , regex_newline = 0x0004 }
enum	regex_match_flags { regex_not_bol = 0x0001 , regex_not_eol = 0x0002 }

Functions
regex_handle	__regex_create ()
void	__regex_destroy (regex_handle _handle)
void	__regex_compile (regex_handle _handle, const wchar_t *_pattern, size_t _n, unsigned int _flags)
void	__matches_free (match_result *_results)
size_t	__regex_match (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, match_result **_results, unsigned int _flags)
bool	__regex_match (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, unsigned int _flags)
bool	__regex_search (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, match_result **_results, unsigned int _flags)
bool	__regex_search (regex_handle _handle, const wchar_t *_begin, const wchar_t *_end, unsigned int _flags)
bool	__regex_matches (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase) __DCL_THROWS1(RegexException *)
bool	__regex_matches (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
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 *)
size_t	__regex_search (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
String	__regex_substring (const wchar_t *_regex, const wchar_t *_regexend, const wchar_t *_begin, const wchar_t *_end, bool _icase) __DCL_THROWS1(RegexException *)
ByteString	__regex_substring (const char *_regex, const char *_regexend, const char *_begin, const char *_end, bool _icase) __DCL_THROWS1(RegexException *)
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 *)
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 *)
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 *)
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 *)

Typedef Documentation

regex_handle

typedef void* regex_handle

Definition at line 12 of file _regex.h.

Enumeration Type Documentation

regex_compile_flags

enum regex_compile_flags

Enumerator
regex_icase
regex_nosubs
regex_newline

Definition at line 17 of file _regex.h.

                         {
    regex_icase      = 0x0001,
    regex_nosubs    = 0x0002,
    regex_newline  = 0x0004
};

regex_match_flags

enum regex_match_flags

Enumerator
regex_not_bol
regex_not_eol

Definition at line 38 of file _regex.h.

                       {
    regex_not_bol  = 0x0001,
    regex_not_eol  = 0x0002
};

Function Documentation

__matches_free()

void __matches_free

(

match_result *

_results

)

Definition at line 81 of file _regex.cpp.

{
    free(_results);
//  delete[] _results;
}

__regex_compile()

void __regex_compile	(	regex_handle	_handle,
		const wchar_t *	_pattern,
		size_t	_n,
		unsigned int	_flags )

Definition at line 61 of file _regex.cpp.

{
    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;
}

__regex_create()

regex_handle __regex_create

(

)

Definition at line 43 of file _regex.cpp.

{
    //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;
}

__regex_destroy()

void __regex_destroy

(

regex_handle

_handle

)

Definition at line 53 of file _regex.cpp.

{
    //wregex* p = (wregex*)_handle;
    //p->~wregex();
    //free(p);
    delete (wregex*)_handle;
}

__regex_match() [1/2]

size_t __regex_match	(	regex_handle	_handle,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		match_result **	_results,
		unsigned int	_flags )

Definition at line 87 of file _regex.cpp.

{
    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;
}

__regex_match() [2/2]

bool __regex_match	(	regex_handle	_handle,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		unsigned int	_flags )

Definition at line 119 of file _regex.cpp.

{
    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;
}

__regex_matches() [1/2]

bool __regex_matches	(	const char *	_regex,
		const char *	_regexend,
		const char *	_begin,
		const char *	_end,
		bool	_icase )

Definition at line 212 of file _regex.cpp.

{
    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()));
    }
}

__regex_matches() [2/2]

bool __regex_matches	(	const wchar_t *	_regex,
		const wchar_t *	_regexend,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		bool	_icase )

Definition at line 187 of file _regex.cpp.

{
    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()));
    }
}

__regex_replace() [1/2]

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 )

Definition at line 408 of file _regex.cpp.

{
    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;
        }
 
        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()));
    }
}

__regex_replace() [2/2]

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 )

Definition at line 367 of file _regex.cpp.

{
    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;
        }
 
        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()));
    }
}

__regex_search() [1/4]

size_t __regex_search	(	const char *	_regex,
		const char *	_regexend,
		const char *	_begin,
		const char *	_end,
		bool	_icase )

Definition at line 269 of file _regex.cpp.

{
    // 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;
        __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;
}

__regex_search() [2/4]

size_t __regex_search	(	const wchar_t *	_regex,
		const wchar_t *	_regexend,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		bool	_icase )

Definition at line 237 of file _regex.cpp.

{
    // 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;
}

__regex_search() [3/4]

bool __regex_search	(	regex_handle	_handle,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		match_result **	_results,
		unsigned int	_flags )

Definition at line 137 of file _regex.cpp.

{
    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;
}

__regex_search() [4/4]

bool __regex_search	(	regex_handle	_handle,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		unsigned int	_flags )

Definition at line 169 of file _regex.cpp.

{
    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;
}

__regex_split() [1/2]

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 )

Definition at line 488 of file _regex.cpp.

{
    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;
        }
 
        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()));
    }
}

__regex_split() [2/2]

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 )

Definition at line 449 of file _regex.cpp.

{
    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;
        }
 
        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()));
    }
}

__regex_substring() [1/2]

ByteString __regex_substring	(	const char *	_regex,
		const char *	_regexend,
		const char *	_begin,
		const char *	_end,
		bool	_icase )

Definition at line 334 of file _regex.cpp.

{
    // 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;
}

__regex_substring() [2/2]

String __regex_substring	(	const wchar_t *	_regex,
		const wchar_t *	_regexend,
		const wchar_t *	_begin,
		const wchar_t *	_end,
		bool	_icase )

Definition at line 302 of file _regex.cpp.

{
    // 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;
}