root/rxstring/trunk/rxstring.cpp @ 672

/* $Id$ $URL$ */
#include "rxstring.h"

/**\file rxstring.cpp
 * Definition of the RxString class and helper functions.
 * \author Trent Apted <tapted@it.usyd.edu.au>
 * $Revision$
 * $Date$
 */

#ifdef HAVE_SYSREGEX_H
#define my_regerror regerror
#define my_regcomp regcomp
#define my_regfree regfree
#define my_regexec regexec
#endif

/** returns !isspace(c), and is a function (not a macro) */
static bool nonspace(char c) {
    return !std::isspace(c);
}

/** fill \a buf with a string describing the regex error */
static void fill_error(RxString &buf, int err_code, regex_t *rxbuf) {
    size_t buf_sz = my_regerror(err_code, rxbuf, 0, 0);
    char *errbuf = new char[buf_sz];
    my_regerror(err_code, rxbuf, errbuf, buf_sz);
    buf = errbuf;
    delete[] errbuf;
}

const RxString RxString::NO_MATCH = "";

RxString::Regex::Regex(const RxString& regstr, RxString *err_string, int cflags) {
    if (!RxString::compile(*this, regstr, err_string, cflags)) {
        /* fail -- throw? */
    }
}

RxString &RxString::trim() {
    erase(begin(), find_if(&nonspace));
    erase(find_last_not_if(&nonspace), end());
    return *this;
}

RxString RxString::matchn(const RxString &regex,
                          unsigned n,
                          RxString *err_string,
                          int cflags,
                          int eflags) const {
    match_vec_type matches;
    match(regex, &matches, err_string, cflags, eflags);
    if (n < matches.size())
        return matches[n];
    else if (!matches.empty())
        return matches[0];
    else
        return NO_MATCH;
}


RxString RxString::matchn(const my_regex_t  &regex, unsigned n, RxString *err_string, int eflags) const {
    match_vec_type matches;
    match(regex, &matches, err_string, eflags);
    if (n < matches.size())
        return matches[n];
    else if (!matches.empty())
        return matches[0];
    else
        return NO_MATCH;
}

bool RxString::compile(my_regex_t &regex,
                       const RxString &regstr,
                       RxString *err_string,
                       int cflags) {
    int err = 0;
    cflags |= REG_EXTENDED;
    cflags &= ~REG_NOSUB;

    /* compile */
    if ((err = my_regcomp(&regex.rx, regstr.c_str(), cflags))) {
        if (err_string)
            fill_error(*err_string, err, &regex.rx);
        my_regfree(&regex.rx);
        return 0;
    }
    regex.nmatch = regstr.count_char('(') + 1;
    return true;
}

size_t RxString::match(const RxString &regex,
                       match_vec_type *matches /*=0*/,
                       RxString *err_string /*= 0*/,
                       int cflags /*=REG_EXTENDED*/,
                       int eflags /*=0*/
                      ) const {
    my_regex_t preg;
    int err = 0;
    if (matches) {
        cflags |= REG_EXTENDED;
        cflags &= ~REG_NOSUB;
    }
    /* compile */
    if ((err = my_regcomp(&preg.rx, regex.c_str(), cflags))) {
        if (err_string)
            fill_error(*err_string, err, &preg.rx);
        my_regfree(&preg.rx);
        return 0;
    }
    preg.nmatch = regex.count_char('(') + 1;
    size_t ret = match(preg, matches, err_string, eflags);
    my_regfree(&preg.rx);
    return ret;
}

size_t RxString::match(const my_regex_t &preg,
                       match_vec_type *matches,
                       RxString *err_string,
                       int eflags
                      ) const {

    /* execute */
    const char *strbuf = c_str();
    int err = 0;
    unsigned nmatch = preg.nmatch;
    regmatch_t *pmatch = 0;
    if (nmatch)
        pmatch = new regmatch_t[nmatch];
    if ((err = my_regexec(&preg.rx, strbuf, nmatch, pmatch, eflags))) {
        if (nmatch)
            delete[] pmatch;
        if (err_string)
            *err_string = "<<NO_MATCH>>";
        return 0;
    }

    /* fill matches */
    size_t nmatches = 0;
    if (matches) {
        for (size_t i = 0; i < nmatch; ++i) {
            if (pmatch[i].rm_so >= 0) {
                matches->push_back(RxString(substr(pmatch[i].rm_so, pmatch[i].rm_eo-pmatch[i].rm_so)));
                ++nmatches;
            } else {
                matches->push_back(NO_MATCH);
            }
        }
    } else {
        nmatches = 1;
    }

    /* cleanup */
    if (nmatch)
        delete[] pmatch;
    return nmatches;
}

RxString &RxString::append_line(std::istream& in /*=cin*/, const char eol /*='\n'*/) {
    char c;
    while (in && in.get(c) && c != eol)
        *this += c;
    return *this;
}


std::string::size_type RxString::count_char(value_type val) const {
    return std::count(begin(), end(), val);
}

RxString &RxString::toTitleCase() {
    iterator b = begin();
    iterator e = end();
    bool sp = true;
    for (; b != e; ++b) {
        if (sp)
            *b = std::toupper(*b);
//        else
//            *b = std::tolower(*b);
        sp = std::isspace(*b);
    }
    return *this;
}

/** toupper is a macro, so we need this function for std::transform */
static inline char my_toupper(char c) {
    return toupper(c);
}

/** tolower is a macro, so we need this function for std::transform */
static inline char my_tolower(char c) {
    return tolower(c);
}

RxString &RxString::toUpper() {
    std::transform(begin(), end(), begin(), &my_toupper);
    return *this;
}
RxString &RxString::toLower() {
    std::transform(begin(), end(), begin(), &my_tolower);
    return *this;
}