Enter your search terms GNU-Darwin Web Submit search form

pcre++.cc Go to the documentation of this file. /* * * $Id: pcre++.cc,v 1.2 2002/01/02 01:25:30 zarahg Exp $ * * This file is part of the PCRE++ Class Library. * * By accessing this software, PCRE++, you are duly informed * of and agree to be bound by the conditions described below * in this notice: * * This software product, PCRE++, is developed by Thomas Linden * and copyrighted (C) 2002 by Thomas Linden, with all rights * reserved. * * There is no charge for PCRE++ software. You can redistribute * it and/or modify it under the terms of the GNU Lesser General * Public License, which is incorporated by reference herein. * * PCRE++ is distributed WITHOUT ANY WARRANTY, IMPLIED OR EXPRESS, * OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE or that * the use of it will not infringe on any third party's intellec- * tual property rights. * * You should have received a copy of the GNU Lesser General Public * License along with PCRE++. Copies can also be obtained from: * * http://www.gnu.org/licenses/lgpl.txt * * or by writing to: * * Free Software Foundation, Inc. * 59 Temple Place, Suite 330 * Boston, MA 02111-1307 * USA * * Or contact: * * "Thomas Linden" <tom@daemon.de> * * */ #include "pcre++.h" /* * CONSTRUCTORS */ Pcre::Pcre(const string& expression) { _expression = expression; _flags = 0; case_t = global_t = false; zero(); Compile(0); } Pcre::Pcre(const string& expression, const string& flags) { _expression = expression; unsigned int FLAG = 0; for(unsigned int flag=0; flag<flags.length(); flag++) { switch(flags[flag]) { case 'i': FLAG |= PCRE_CASELESS; case_t = true; break; case 'm': FLAG |= PCRE_MULTILINE; break; case 's': FLAG |= PCRE_DOTALL; break; case 'x': FLAG |= PCRE_EXTENDED; break; case 'g': global_t = true; break; } } _flags = FLAG; zero(); Compile(FLAG); } Pcre::Pcre(const Pcre &P) { _expression = P._expression; _flags = P._flags; case_t = P.case_t; global_t = P.global_t; zero(); Compile(_flags); } Pcre::Pcre() { zero(); } /* * Destructor */ Pcre::~Pcre() { /* avoid deleting of uninitialized pointers */ if (p_pcre != NULL) { pcre_free(p_pcre); } if (p_pcre_extra != NULL) { pcre_free(p_pcre_extra); } if(sub_vec != NULL) { delete[] sub_vec; } if(num_matches > 0) { delete resultset; } if(err_str != NULL) { delete err_str; } } /* * operator= definitions */ const Pcre& Pcre::operator = (const string& expression) { /* reset the object and re-intialize it */ reset(); _expression = expression; _flags = 0; case_t = global_t = false; Compile(0); return *this; } const Pcre& Pcre::operator = (const Pcre &P) { reset(); _expression = P._expression; _flags = P._flags; case_t = P.case_t; global_t = P.global_t; zero(); Compile(_flags); return *this; } /* * mem resetting methods */ void Pcre::zero() { /* what happens if p_pcre is already allocated? hm ... */ p_pcre_extra = NULL; p_pcre = NULL; sub_vec = NULL; resultset = NULL; err_str = NULL; num_matches = -1; } void Pcre::reset() { did_match = false; num_matches = -1; } /* * compile the expression */ void Pcre::Compile(int flags) { p_pcre = pcre_compile((char *)_expression.c_str(), flags, (const char **)(&err_str), &erroffset, NULL); if(p_pcre == NULL) { /* umh, that's odd, the parser should not fail at all */ string Error = err_str; throw exception("pcre_compile(..) failed: " + Error); } /* calculate the number of substrings we are willing to catch */ int where; int info = pcre_fullinfo( p_pcre, p_pcre_extra, PCRE_INFO_CAPTURECOUNT, &where); if(info == 0) { sub_len = (where +2) * 3; /* see "man pcre" for the exact formula */ } else { throw exception(info); } reset(); } /* * API methods */ bool Pcre::search(const string& stuff, int OffSet) { return dosearch(stuff, OffSet); } bool Pcre::search(const string& stuff) { return dosearch(stuff, 0); } bool Pcre::dosearch(const string& stuff, int OffSet) { reset(); sub_vec = new int[sub_len]; int num = pcre_exec(p_pcre, p_pcre_extra, (char *)stuff.c_str(), (int)stuff.length(), OffSet, 0, (int *)sub_vec, sub_len); if(num < 0) { /* no match at all */ return false; } else if(num == 0) { /* vector too small, there were too many substrings in stuff */ return false; } else if(num == 1) { /* we had a match, but without substrings */ did_match = true; num_matches = 0; return true; } else if(num > 1) { /* we had matching substrings */ resultset = new Array; const char **stringlist; did_match = true; num_matches = num - 1; int res = pcre_get_substring_list((char *)stuff.c_str(), sub_vec, num, &stringlist); if(res == 0) { for(int i=1; i<num; i++) { resultset->push_back(stringlist[i]); } pcre_free_substring_list(stringlist); } else { throw exception(res); } return true; } else { /* some other uncommon error occured */ return false; } } Array* Pcre::get_sub_strings() { if(resultset != NULL) return resultset; else return NULL; } string Pcre::get_match(int pos) { if(pos >= 0 && pos < num_matches) { ArrayIterator P = resultset->begin() + pos; return *P; } else { throw exception("out of range"); } } int Pcre::get_match_start() { if (sub_vec) return sub_vec[0]; else return -1; } int Pcre::get_match_end() { if (sub_vec) return sub_vec[1] - 1; else return -1; } int Pcre::get_match_start(int pos) { if(pos >= 0 && pos <= num_matches) { /* * sub_vec[0] and [1] is the start/end of the entire string. */ return sub_vec[ (++pos) * 2 ]; } else { throw exception("out of range"); } } int Pcre::get_match_end(int pos) { if(pos >= 0 && pos <= num_matches) { /* * the end offset of a subpattern points to * the first offset of the next substring, * therefore -1 */ return sub_vec[ ((++pos) * 2) + 1 ] - 1; } else { throw exception("out of range"); } } size_t Pcre::get_match_length(int pos) { if(pos >= 0 && pos < num_matches) { ArrayIterator P = resultset->begin() + pos; return P->length(); } else { throw exception("out of range"); } } Array Pcre::_split(const string& piece, int limit, int start_offset, int end_offset) { Array Splitted; /* _expression will be used as delimiter */ if(_expression.length() == 1) { /* use the plain c++ way, ignore the pre-compiled p_pcre */ string buffer, _delimiter, _piece; char z; if(case_t) { z = toupper(_expression[0]); for(size_t pos=0; pos < piece.length(); pos++) { _piece += (char)toupper(piece[pos]); } } else { z = _expression[0]; _piece = piece; } for(size_t pos=0; pos<piece.length(); pos++) { if(_piece[pos] == z) { Splitted.push_back(buffer); buffer = ""; } else { buffer += piece[pos]; } } if(buffer != "") { Splitted.push_back(buffer); } } else { /* use the regex way */ if(_expression[0] != '(' && _expression[ _expression.length() ] != ')' ) { /* oh, oh - the pre-compiled expression does not contain brackets */ pcre_free(p_pcre); pcre_free(p_pcre_extra); pcre *_p = NULL; pcre_extra *_e = NULL;; p_pcre = _p; p_pcre_extra = _e; _expression = "(" + _expression + ")"; Compile(_flags); } int num_pieces=0, pos=0, piece_end = 0, piece_start = 0; for(;;) { if(search(piece, pos) == true) { if(matches() > 0) { piece_end = get_match_start(0) - 1; piece_start = pos; pos = piece_end + 1 + get_match_length(0); string junk(piece, piece_start, (piece_end - piece_start)+1); num_pieces++; if( (limit != 0 && num_pieces < limit) || limit == 0) { if( (start_offset != 0 && num_pieces >= start_offset) || start_offset == 0) { if( (end_offset != 0 && num_pieces <= end_offset) || end_offset == 0) { /* we are within the allowed range, so just add the grab */ Splitted.push_back(junk); } } } } } else { /* the rest of the string, there are no more delimiters */ string junk(piece, pos, (piece.length() - pos)); num_pieces++; if( (limit != 0 && num_pieces < limit) || limit == 0) { if( (start_offset != 0 && num_pieces >= start_offset) || start_offset == 0) { if( (end_offset != 0 && num_pieces <= end_offset) || end_offset == 0) { /* we are within the allowed range, so just add the grab */ Splitted.push_back(junk); } } } break; } } // for() } // if(_expression.length() return Splitted; } Array Pcre::split(const string& piece) { return _split(piece, 0, 0, 0); } Array Pcre::split(const string& piece, int limit) { return _split(piece, limit, 0, 0); } Array Pcre::split(const string& piece, int limit, int start_offset) { return _split(piece, limit, start_offset, 0); } Array Pcre::split(const string& piece, int limit, int start_offset, int end_offset) { return _split(piece, limit, start_offset, end_offset); } Array Pcre::split(const string& piece, vector<int> positions) { Array PreSplitted = _split(piece, 0, 0, 0); Array Splitted; for(vector<int>::iterator vecIt=positions.begin(); vecIt != positions.end(); ++vecIt) { Splitted.push_back(PreSplitted[*vecIt]); } return Splitted; } string Pcre::replace(const string& piece, const string& with) { string Replaced(piece); /* * very first job: look, if the expression already contains * braces, if yes, do not add braces, else, do it */ Pcre braces("[^\\\\]\\(.*[^\\\\]\\)"); // perlish: [^\\]\(.*[^\\]\) if(! braces.search(_expression)) { // if(_expression[0] != '(' && _expression[ _expression.length() ] != ')' ) { /* oh, oh - the pre-compiled expression does not contain brackets */ /* recreate the p_pcre* objects to avoid memory leaks */ pcre_free(p_pcre); pcre_free(p_pcre_extra); pcre *_p = NULL; pcre_extra *_e = NULL;; p_pcre = _p; p_pcre_extra = _e; _expression = "(" + _expression + ")"; Compile(_flags); } if(search(piece)) { /* we found at least one match */ string use_with = _replace_vars(with); if(!global_t) { /* * only once, use the entire match * Patch submitted by Mark Carrington <mark@mutantpenguin.co.uk> */ if(matched() && matches() >= 1) { int len = get_match_end() - get_match_start() + 1; Replaced.replace(get_match_start(0), len, use_with); } } else { /* * global replace. * * We need to keep checking the line after it is modified to see the next match. * Especially \s is something of a bitch as it can be a newline, return carriage, * space, tab, etc ... so we have to keep searching for the next type. * Patch submitted by Jim Hull <imaginos@imaginos.net> */ string sLeftOver = Replaced; int iCurPosition = 0; while( search( sLeftOver ) ) { if( matched() && matches() >= 1 ) { int len = 0; string lookfor; lookfor.erase(); int match_pos; for (match_pos = 0; match_pos < matches(); match_pos++) { len += ((get_match_end(match_pos) - get_match_start(match_pos)) + 1); lookfor += get_match(match_pos); } match_pos = Replaced.find( lookfor, iCurPosition ); Replaced.replace(match_pos, len, use_with); iCurPosition = ( match_pos + use_with.length() ); sLeftOver = Replaced.substr( iCurPosition, string::npos ); } } } } return Replaced; } string Pcre::_replace_vars(const string& piece) { Pcre dollar("\\$[0-9]+"); string with = piece; if(dollar.search(with)) { for(int index=0; index < num_matches; index++) { /* do it for each existing sub string */ string sub = get_match(index); // what "$1" resulted ostringstream num; num << index+1; string dollar_num = "(\\$" + num.str() + ")"; Pcre subsplit(dollar_num); // "\\$1" // normally 2 (or more) parts, the one in front of and the other one after "$1" Array splitted = subsplit.split(with); string Replaced; for(size_t pos=0; pos < splitted.size(); pos++) { if(pos == (splitted.size() - 1)) Replaced += splitted[pos]; else Replaced += splitted[pos] + sub; } with = Replaced; // well, one part is done } return with; } else { /* hm, no $[0-9]+ stuff, so just return it untouched */ return with; } }