libregex/op_regex.h

/**
 * @file op_regex.h
 * This file contains various definitions and interface for a
 * lightweight wrapper around libc regex, providing match
 * and replace facility.
 *
 * @remark Copyright 2003 OProfile authors
 * @remark Read the file COPYING
 * @remark Idea comes from TextFilt project <http://textfilt.sourceforge.net>
 *
 * @author Philippe Elie
 */

#ifndef OP_REGEX_H
#define OP_REGEX_H

// required by posix before including regex.h
#include <sys/types.h>
#include <regex.h>

#include <string>
#include <vector>
#include <map>

#include "op_exception.h"

/**
 * ill formed regular expression or expression throw such exception
 */
struct bad_regex : op_exception {
	bad_regex(std::string const & pattern);
};

/**
 * lightweight encapsulation of regex lib search and replace
 *
 * See stl.pat for further details and examples of used syntax.
 */
class regular_expression_replace {
public:
	/**
	 * @param limit limit on number of search and replace done
	 * @param limit_defs_expansion limit on number of expansion done
	 *  during replacement of regular definition name by their expansion
	 *
	 * build an object holding regular defintion and regular expression
	 * & replace, preparing it for substitution ala sed
	 */
	regular_expression_replace(size_t limit = 100,
				   size_t limit_defs_expansion = 100);
	~regular_expression_replace();

	/**
	 * @param name a regular definition name
	 * @param replace the string to subsitute in other regular definition
	 * or regular exepression when this regular defintion name is
	 * encoutered.
	 */
	void add_definition(std::string const & name,
			    std::string const & replace);
	/**
	 * @param pattern a regular expression pattern, POSIX extended notation
	 * @param replace the replace string to use when this regular
	 *  expression is matched
	 *
	 * You can imbed regular definition in pattern but not in replace.
	 */
	void add_pattern(std::string const & pattern,
			 std::string const & replace);

	/**
	 * @param str the input/output string where we search pattern and
	 * replace them.
	 *
	 * Execute loop at max limit time on the set of regular expression
	 *
	 * Return true if too many match occur and replacing has been stopped
	 * due to reach limit_defs_expansion. You can test if some pattern has
	 * been matched by saving the input string and comparing it to the new
	 * value. There is no way to detect s/a/a because the output string
	 * will be identical to the input string.
	 */
	bool execute(std::string & str) const;
private:
	struct replace_t {
		// when this regexp is matched
		regex_t regexp;
		// replace the matched part with this string
		std::string replace;
	};

	// helper to execute
	bool do_execute(std::string & str, replace_t const & regexp) const;
	void do_replace(std::string & str, std::string const & replace,
			regmatch_t const * match) const;

	// helper to add_definition() and add_pattern()
	std::string expand_string(std::string const & input);

	// helper to add_pattern
	std::string substitute_definition(std::string const & pattern);

	// return the match of throw if idx is invalid
	regmatch_t const & get_match(regmatch_t const * match, char idx) const;

	// don't increase too, it have direct impact on performance. This limit
	// the number of grouping expression allowed in a regular expression
	// Note than you can use grouping match operator > 9 only in the
	// replace rule not in match regular expression since POSIX don't allow
	// more than \9 in matching sequence.
	static const size_t max_match = 16;

	size_t limit;
	size_t limit_defs_expansion;
	std::vector<replace_t> regex_replace;
	/// dictionary of regular definition
	typedef std::map<std::string, std::string> defs_dict;
	defs_dict defs;
};

/**
 * @param regex the regular_expression_replace to fill
 * @param filename the filename from where the deifnition and pattern are read
 *
 * add to regex pattern and regular definition read from the given file
 */
void setup_regex(regular_expression_replace& regex,
		 std::string const & filename);

#endif /* !OP_REGEX_H */