Fix bugs #6078 and #9364

[lyx.git] / src / support / regex.h

diff --git a/src/support/regex.h b/src/support/regex.h
index 0826c9724ce6e82743e8bce9a6db0a4e1351fcfb..dd4875e35fe587370b9f02a7832036aa3d783ec6 100644 (file)
--- a/src/support/regex.h
+++ b/src/support/regex.h
@@ -12,52 +12,87 @@
 #ifndef LYX_REGEXP_H
 #define LYX_REGEXP_H
 
-#include "checktr1.h"
+#if defined(LYX_USE_CXX11) && defined(LYX_USE_STD_REGEX)
+#  include <regex>
+#  ifdef _MSC_VER
+namespace lyx {
+  // inheriting 'private' to see which functions are used and if there are
+  // other ECMAScrip defaults
+  // FIXME: Is this really needed?
+  //        If yes, then the MSVC regex implementation is not standard-conforming.
+  class regex : private std::regex
+  {
+  public:
+    regex() {}
+    regex(const regex& rhs) : std::regex(rhs) {}
+    template<class T>
+    regex(T t) : std::regex(t, std::regex_constants::grep) {}
+    template<class T>
+    void assign(T t) { std::regex::assign(t, std::regex_constants::grep); }
+    template<class T, class V>
+    void assign(T t, V v) { std::regex::assign(t, v); }
+    const std::regex& toStd() const { return *this; }
+  };
+  template<class T>
+  bool regex_match(T t, const regex& r) { return std::regex_match(t, r.toStd()); }
+  template<class T, class V>
+  bool regex_match(T t, V v, const regex& r) { return std::regex_match(t, v, r.toStd()); }
+  template<class T, class V, class U, class H>
+  bool regex_match(T t, V v, H h, const regex& r, U u) { return std::regex_match(t, v, h, r.toStd(), u); }
+  template<class T, class V>
+  std::string regex_replace(T t, const regex& r, V v) { return std::regex_replace(t, r.toStd(), v); }
+  //template<class T, class V, class U, class H>
+  //std::string regex_replace(T t, V v, U u, const regex& r, H h) { return std::regex_replace(t, v, u, r.toStd(), h); }
+  template<class T>
+  bool regex_search(T t, const regex& r) { return std::regex_search(t, r.toStd()); }
+  template<class T, class V>
+  bool regex_search(T t, V v, const regex& r) { return std::regex_search(t, v, r.toStd()); }
+  template<class T, class V, class U>
+  bool regex_search(T t, V v, U u, const regex& r) { return std::regex_search(t, v, u, r.toStd()); }
 
-
-#define LYX_REGEX_TO_LYX(X) \
-    using X::regex; \
-    using X::smatch; \
-    using X::regex_replace; \
-    using X::basic_regex; \
-    using X::regex_error; \
-    using X::regex_search; \
-    using X::sregex_iterator; \
-    using X::match_results; \
-    \
-    namespace regex_constants \
-    { \
-        using namespace X::regex_constants; \
-        using X::regex_constants::match_flag_type; \
-    } \
-
-
-
-// TODO: only tested with msvc10
-#if defined(LYX_USE_TR1) && defined(_MSC_VER)
-
-#ifdef _MSC_VER
-#include <regex>
-#define match_partial _Match_partial // why is match_partial not public?
+  struct sregex_iterator : std::sregex_iterator
+  {
+    sregex_iterator() {}
+    template<class T, class V>
+    sregex_iterator(T t, V v, const regex& r) : std::sregex_iterator(t, v, r.toStd()) {}
+  };
+}
+#  else
+// <regex> in gcc is unusable in versions less than 4.9.0
+// see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53631
+#  define LR_NS std
+namespace lyx {
+using LR_NS::regex;
+using LR_NS::regex_match;
+using LR_NS::sregex_iterator;
+}
+#  endif
 #else
-#include <tr1/regexp>
-#endif
-
-namespace lyx
-{
-    LYX_REGEX_TO_LYX(std::tr1);    
+#  include <boost/regex.hpp>
+#  define LR_NS boost
+namespace lyx {
+using LR_NS::regex;
+using LR_NS::regex_match;
+using LR_NS::sregex_iterator;
 }
+#endif
 
-#else 
-
-#include "boost/regex.hpp"
+namespace lyx {
+using LR_NS::smatch;
+using LR_NS::regex_replace;
+using LR_NS::basic_regex;
+using LR_NS::regex_error;
+using LR_NS::regex_search;
+using LR_NS::match_results;
 
-namespace lyx
+namespace regex_constants
 {
-    LYX_REGEX_TO_LYX(boost);
+using namespace LR_NS::regex_constants;
+using LR_NS::regex_constants::match_flag_type;
 }
 
-#endif
+}
 
+#undef LR_NS
 
 #endif