---

pcre++.h

Go to the documentation of this file.

/*
 *
 *  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-2003 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>
 *
 *
 */

#ifndef HAVE_PCRE_PP_H
#define HAVE_PCRE_PP_H

#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <stdexcept>
#include <iostream>


extern "C" {
  #include <pcre.h>
  #include <locale.h>
}

namespace pcrepp {

#ifdef DEBUG
#define __pcredebug cerr << "(pcre++ DEBUG) " << __LINE__ << ": " 
#else
#define __pcredebug if(0) cerr 
#endif

#define PCRE_GLOBAL 0x10000


class Pcre {
 private:
  std::string _expression;   /* the given regular expression */
  unsigned int _flags;       /* the given flags, 0 if not defined */
  bool case_t, global_t;     /* internal compile flags, used by replace() and split() */
  pcre *p_pcre;              /* pcre object pointer */
  pcre_extra *p_pcre_extra;  /* stuff required by pcre lib */
  int sub_len;
  int *sub_vec;
  int erroffset;
  char *err_str;
  std::vector<std::string> *resultset;          /* store substrings, if any */
  bool _have_paren;          /* indicate wether we have already parentesis applied in replace */

  const unsigned char *tables; /* locale tables */

  bool did_match;            
  int  num_matches;          
  /* reset all counters and free objects, prepare for another search */
  void reset();

  /* compile the pattern */
  void Compile(int flags);

  /* do the actual search, will be called by the public ::search(..) methods */
  bool dosearch(const std::string& stuff, int OffSet);

  /* do the actual split() job, called by the various wrapper split() methods */
  std::vector<std::string> _split(const std::string& piece, int limit, int start_offset, int end_offset);
  
  /* replace $1 .. $n with the corresponding substring, used by replace() */
  std::string _replace_vars(const std::string& piece);

  /* init pointers with NULL */
  void zero();

  std::map<std::string,std::string> info();
  std::string info(int what);

 public:

  class exception : public std::runtime_error {
  private:
    std::string translate(int num) {
      std::string msg;
      switch(num) {
      case -1: msg = "PCRE_ERROR_NOMATCH";      break;
      case -2: msg = "PCRE_ERROR_NULL";         break;
      case -3: msg = "PCRE_ERROR_BADOPTION";    break;
      case -4: msg = "PCRE_ERROR_BADMAGIC";     break;
      case -5: msg = "PCRE_ERROR_UNKNOWN_NODE"; break;
      case -6: msg = "PCRE_ERROR_NOMEMORY";     break;
      case -7: msg = "PCRE_ERROR_NOSUBSTRING";  break;
        // pcre4-HINT: add PCRE_ERROR_MATCHLIMIT support
      }
      return msg;
    }
  public:
    exception(const std::string & msg) : runtime_error(msg) { }
    exception(int num) : runtime_error(translate(num)) { }
  };


  Pcre();

  Pcre(const std::string& expression);

  Pcre(const std::string& expression, const std::string& flags);

  Pcre(const std::string& expression, unsigned int flags);

  Pcre(const Pcre &P);

  const Pcre& operator = (const std::string& expression); 

  const Pcre& operator = (const Pcre &P);

  ~Pcre();

  bool search(const std::string& stuff);

  bool search(const std::string& stuff, int OffSet);

  std::vector<std::string>* get_sub_strings() const;

  std::string get_match(int pos) const;

  int get_match_start(int pos) const;

  int get_match_end(int pos) const;




  int get_match_start() const;

  int get_match_end() const;




  size_t get_match_length(int pos) const;

  bool matched() const { return did_match; };

  int  matches() const { return num_matches; }


  std::vector<std::string> split(const std::string& piece);

  std::vector<std::string> split(const std::string& piece, int limit);

  std::vector<std::string> split(const std::string& piece, int limit, int start_offset);

  std::vector<std::string> split(const std::string& piece, int limit, int start_offset, int end_offset);

  std::vector<std::string> split(const std::string& piece, std::vector<int> positions);

  std::string replace(const std::string& piece, const std::string& with);

  pcre* get_pcre();

  pcre_extra* get_pcre_extra();

  void study();

  bool setlocale(const char* locale);

  std::string operator[](int index) {
    return get_match(index);
  }
}; 

} // end namespace pcre

#endif // HAVE_PCRE_PP_H

---