chain< string > * csdbg::string::split ( const string &  exp, bool  imatch = true, bool  icase = false  ) const

virtual

Tokenize using a POSIX extended regular expression.

Parameters

[in]	exp	the delimiter expression
[in]	imatch	false to include the actual matches in the result
[in]	icase	true to ignore case sensitivity

Returns

the list of tokens (heap allocated)

Exceptions

std::bad_alloc
csdbg::exception

Definition at line 642 of file string.cpp.

References csdbg::chain< T >::add(), cstr(), likely, m_data, m_length, match(), string(), and unlikely.

Referenced by csdbg::parser::parse(), and csdbg::plugin::resolve().

{
  chain<string> *tokens = NULL;
  string *word = NULL;
  regex_t regexp;

  /* If an exception occurs, release resources and rethrow it */
  try {
    tokens = new chain<string>;

    /* Compile the regular expression */
    i32 flags = REG_EXTENDED;
    if ( unlikely(icase) )
      flags |= REG_ICASE;

    i32 retval = regcomp(&regexp, exp.cstr(), flags);
    if ( unlikely(retval != 0) ) {
      i32 len = regerror(retval, &regexp, NULL, 0);
      i8 errbuf[len];
      regerror(retval, &regexp, errbuf, len);

      throw exception(
        "failed to compile regexp '%s' (regex errno %d - %s)",
        exp.cstr(),
        retval,
        errbuf
      );
    }

    regmatch_t match;
    regoff_t offset = 0;
    i32 len = m_length;
    do {
      bool found = !regexec(&regexp, m_data + offset, 1, &match, 0);

      /*
       * The delimiter pattern is found. The left token is from the beginning of
       * the text plus an offset, to the beginning of the matched text. The
       * right token is from the end of the matched text to the end of the text
       * or to the beginning of the next matched text. This will be evaluated on
       * the next loop pass
       */
      if ( likely(found) ) {
        i32 bgn = match.rm_so;
        i32 end = match.rm_eo;
        if ( unlikely(end == 0) )
          throw exception("logic error in regular expression '%s'", exp.cstr());

        word = new string("%.*s", bgn, m_data + offset);
        tokens->add(word);
        word = NULL;

        if ( unlikely(!imatch) ) {
          word = new string("%.*s", end - bgn, m_data + offset + bgn);
          tokens->add(word);
          word = NULL;
        }

        offset += end;
        if ( unlikely(offset > len) )
          break;
      }

      /*
       * The pattern isn't found. That means that either the delimiter was never
       * in the text, so the whole text is the one and only token, or there is
       * some text after the last delimiter. In that case this trailing text is
       * the last token
       */
      else if ( likely(offset <= len) ) {
        word = new string(m_data + offset);
        tokens->add(word);
        word = NULL;
        break;
      }

      /* No more tokens */
      else
        break;
    }

    while ( likely(true) );

    regfree(&regexp);
    return tokens;
  }

  catch (...) {
    delete tokens;
    delete word;
    regfree(&regexp);
    throw;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: