Made a Regex class that wraps either boost::regex or wxRegEx (split from ScriptRegex).

Use Regex for keywords.

git-svn-id: svn://svn.code.sf.net/p/magicseteditor/code/trunk@1196 0fc631ac-6414-0410-93d0-97cfa31319b6

src/util/prec.hpp

@@ -28,7 +28,7 @@
 #include <wx/wx.h>
 #include <wx/image.h>
 #include <wx/datetime.h>
-#include <wx/regex.h>
+#include <wx/regex.h> // TODO : remove, see regex.hpp
 
 // Std headers
 #include <vector>
@@ -78,6 +78,15 @@ class FileName : public wxString {
 #include "locale.hpp"
 #include "error.hpp"
 #include "reflect.hpp"
+#include "regex.hpp"
+
+#ifdef _MSC_VER
+//# pragma conform(forScope,on)    // in "for(int x=..);" x goes out of scope after the for
+// somehow forScope pragma doesn't work in precompiled headers, use this hack instead:
+#ifdef _DEBUG
+	#define for if(false);else for
+#endif
+#endif
 
 // ----------------------------------------------------------------------------- : EOF
 #endif

src/util/regex.cpp

@@ -0,0 +1,48 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2008 Twan van Laarhoven and "coppro"              |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <util/prec.hpp>
+#include <util/regex.hpp>
+#include <util/error.hpp>
+
+#if USE_BOOST_REGEX
+// ----------------------------------------------------------------------------- : Regex : boost
+
+void Regex::assign(const String& code) {
+	// compile string
+	try {
+		regex.assign(code.begin(),code.end());
+	} catch (const boost::regex_error& e) {
+		/// TODO: be more precise
+		throw ScriptError(String::Format(_("Error while compiling regular expression: '%s'\nAt position: %d\n%s"),
+		                  code.c_str(), e.position(), String(e.what(), IF_UNICODE(wxConvUTF8,String::npos))));
+	}
+}
+
+void Regex::replace_all(String* input, const String& format) {
+	//std::basic_string<Char> fmt; format_string(format,fmt);
+	std::basic_string<Char> fmt(format.begin(),format.end());
+	String output;
+	regex_replace(insert_iterator<String>(output, output.end()),
+	              input->begin(), input->end(), regex, fmt, boost::format_sed);
+	*input = output;
+}
+
+#else // USE_BOOST_REGEX
+// ----------------------------------------------------------------------------- : Regex : wx
+
+void Regex::assign(const String& code) {
+	// compile string
+	if (!regex.Compile(code, wxRE_ADVANCED)) {
+		throw ScriptError(_("Error while compiling regular expression: '") + code + _("'"));
+	}
+	assert(regex.IsValid());
+}
+
+#endif // USE_BOOST_REGEX
+// ----------------------------------------------------------------------------- : Regex : common

src/util/regex.hpp

@@ -0,0 +1,157 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2008 Twan van Laarhoven and "coppro"              |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+#ifndef HEADER_UTIL_REGEX
+#define HEADER_UTIL_REGEX
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <util/prec.hpp>
+
+// Use boost::regex as opposed to wxRegex
+/* 2008-09-01:
+ *     Script profiling shows that the boost library is significantly faster:
+ *     When loading a large magic set (which calls ScriptManager::updateAll):
+ *            function      Calls   wxRegEx    boost
+ *            ------------------------------------------------------------------
+ *            replace        3791   0.38607    0.20857
+ *            filter_text      11   0.32251    0.02446
+ *
+ *            (times are avarage over all calls, in ms)
+ */
+#define USE_BOOST_REGEX 1
+
+#if USE_BOOST_REGEX
+	#include <boost/regex.hpp>
+	#include <boost/regex/pattern_except.hpp>
+#endif
+
+// ----------------------------------------------------------------------------- : Boost implementation
+
+#if USE_BOOST_REGEX
+	/// Our own regular expression wrapper
+	/** Suppors both boost::regex and wxRegEx.
+	 *  Has an interface like boost::regex, but compatible with wxStrings.
+	 */
+	class Regex {
+	  public:
+		struct Results : public boost::match_results<const Char*> {
+			/// Get a sub match
+			inline String str(int sub = 0) const {
+				const_reference v = (*this)[sub];
+				return String(v.first, v.second);
+			}
+			/// Format a replacement string
+			inline String format(const String& format) const {
+				std::basic_string<Char> fmt(format.begin(),format.end());
+				String output;
+				boost::match_results<const Char*>::format(
+					insert_iterator<String>(output, output.end()), fmt, boost::format_sed);
+				return output;
+			}
+		};
+		
+		void assign(const String& code);
+		inline bool matches(const String& str) const {
+			return regex_search(str.begin(), str.end(), regex);
+		}
+		inline bool matches(Results& results, const String& str) const {
+			return regex_search(str.begin(), str.end(), results, regex);
+		}
+		inline bool matches(Results& results, const Char* begin, const Char* end) const {
+			return regex_search(begin, end, results, regex);
+		}
+		void replace_all(String* input, const String& format);
+		
+		inline bool empty() const {
+			return regex.empty();
+		}
+		
+	  private:
+		boost::basic_regex<Char> regex; ///< The regular expression
+	};
+
+// ----------------------------------------------------------------------------- : Wx implementation
+#else
+	/// Our own regular expression wrapper
+	/** Suppors both boost::regex and wxRegEx.
+	 *  Has an interface like boost::regex.
+	 */
+	class Regex 
+	  public:
+		// Interface for compatability with boost::regex
+		class Results {
+		  public:
+			typedef pair<const Char*,const Char*> value_type; // (begin,end)
+			typedef value_type const_reference;
+			/// Number of submatches (+1 for the total match)
+			inline size_t size() const { return regex->GetMatchCount(); }
+			/// Get a submatch
+			inline value_type operator [] (int sub) const {
+				size_t pos, length;
+				bool ok = regex->GetMatch(&pos, &length, sub);
+				assert(ok);
+				return make_pair(begin + pos, begin + pos + length);
+			}
+			inline size_t position(int sub = 0) const {
+				size_t pos, length;
+				bool ok = regex->GetMatch(&pos, &length, sub);
+				assert(ok);
+				return pos;
+			}
+			inline size_t length(int sub = 0) const {
+				size_t pos, length;
+				bool ok = regex->GetMatch(&pos, &length, sub);
+				assert(ok);
+				return length;
+			}
+			/// Get a sub match
+			inline String str(int sub = 0) const {
+				const_reference v = (*this)[sub];
+				return String(v.first, v.second);
+			}
+			/// Format a replacement string
+			inline String format(const String& format) const {
+				const_reference v = (*this)[0];
+				String inside(v.first, v.second);
+				regex->ReplaceFirst(&inside, format);
+				return inside;
+			}
+		  private:
+			wxRegEx*    regex;
+			const Char* begin;
+			friend class ScriptRegex;
+		};
+		
+		void assign(const String& code);
+		inline bool matches(const String& str) const {
+			return regex.Matches(str);
+		}
+		inline bool matches(Results& results, const String& str) const {
+			results.regex = &regex;
+			results.begin = str.begin();
+			return regex.Matches(str);
+		}
+		inline bool matches(Results& results, const Char* begin, const Char* end) const {
+			results.regex = &regex;
+			results.begin = begin;
+			return regex.Matches(begin, 0, end - begin);
+		}
+		inline void replace_all(String* input, const String& format) {
+			regex.Replace(input, format);
+		}
+		inline bool empty() const {
+			return !regex.IsValid();
+		}
+		
+	  private:
+		wxRegEx regex; ///< The regular expression
+	};
+
+#endif
+
+// ----------------------------------------------------------------------------- : EOF
+#endif