[vte] widget: Finish deprecation of GRegex taking APIs



commit a0bb8222f3a0a29e4f22817bf3d7053d185b7afb
Author: Christian Persch <chpe src gnome org>
Date:   Tue Nov 26 19:24:00 2019 +0100

    widget: Finish deprecation of GRegex taking APIs
    
    Using GRegex with vte has been deprecated since version 0.46.
    Now remove the internal translation from GRegex to PCRE2, making
    making all public API taking GRegex simple no-ops.

 src/app/app.cc          | 87 ++++++++++++++-----------------------------------
 src/regex.cc            |  1 -
 src/vtegtk.cc           | 34 +++----------------
 src/vteregex.cc         | 87 -------------------------------------------------
 src/vteregexinternal.hh |  6 ----
 5 files changed, 28 insertions(+), 187 deletions(-)
---
diff --git a/src/app/app.cc b/src/app/app.cc
index e554418e..495e3f41 100644
--- a/src/app/app.cc
+++ b/src/app/app.cc
@@ -61,7 +61,6 @@ public:
         gboolean object_notifications{false};
         gboolean reverse{false};
         gboolean test_mode{false};
-        gboolean use_gregex{false};
         gboolean version{false};
         gboolean whole_window_transparent{false};
         bool bg_color_set{false};
@@ -371,8 +370,6 @@ public:
                           "Specify a font to use", nullptr },
                         { "foreground-color", 0, 0, G_OPTION_ARG_CALLBACK, (void*)parse_fg_color,
                           "Set default foreground color", "COLOR" },
-                        { "gregex", 0, 0, G_OPTION_ARG_NONE, &use_gregex,
-                          "Use GRegex instead of PCRE2", nullptr },
                         { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry,
                           "Set the size (in characters) and position", "GEOMETRY" },
                         { "highlight-background-color", 0, 0, G_OPTION_ARG_CALLBACK, 
(void*)parse_hl_bg_color,
@@ -511,18 +508,6 @@ verbose_fprintf(FILE* fp,
 
 /* regex */
 
-static GRegex*
-compile_gregex(char const* pattern,
-               bool caseless,
-               GError** error)
-{
-        GRegexCompileFlags flags = GRegexCompileFlags(G_REGEX_OPTIMIZE |
-                                                      G_REGEX_MULTILINE |
-                                                      caseless ? G_REGEX_CASELESS : 0);
-
-        return g_regex_new(pattern, flags, GRegexMatchFlags(0), error);
-}
-
 static void
 jit_regex(VteRegex* regex,
           char const* pattern)
@@ -654,17 +639,10 @@ vteapp_search_popover_update_regex(VteappSearchPopover* popover)
         if (search_text[0] != '\0') {
                 GError* error = nullptr;
 
-                if (options.use_gregex) {
-                        auto regex = compile_gregex(pattern, caseless, &error);
-                        vte_terminal_search_set_gregex(popover->terminal, regex, GRegexMatchFlags(0));
-                        if (regex != nullptr)
-                                g_regex_unref(regex);
-                } else {
-                        auto regex = compile_regex_for_search(pattern, caseless, &error);
-                        vte_terminal_search_set_regex(popover->terminal, regex, 0);
-                        if (regex != nullptr)
-                                vte_regex_unref(regex);
-                }
+                auto regex = compile_regex_for_search(pattern, caseless, &error);
+                vte_terminal_search_set_regex(popover->terminal, regex, 0);
+                if (regex != nullptr)
+                        vte_regex_unref(regex);
 
                 if (error == nullptr) {
                         popover->has_regex = true;
@@ -1011,19 +989,10 @@ vteapp_window_add_dingus(VteappWindow* window,
         for (auto i = 0; dingus[i] != nullptr; i++) {
                 int tag = -1;
                 GError* error = nullptr;
-                if (options.use_gregex) {
-                        auto regex = compile_gregex(dingus[i], true, &error);
-                        if (regex) {
-                                tag = vte_terminal_match_add_gregex(window->terminal, regex,
-                                                                    GRegexMatchFlags(0));
-                                g_regex_unref(regex);
-                        }
-                } else {
-                        auto regex = compile_regex_for_match(dingus[i], true, &error);
-                        if (regex) {
-                                tag = vte_terminal_match_add_regex(window->terminal, regex, 0);
-                                vte_regex_unref(regex);
-                        }
+                auto regex = compile_regex_for_match(dingus[i], true, &error);
+                if (regex) {
+                        tag = vte_terminal_match_add_regex(window->terminal, regex, 0);
+                        vte_regex_unref(regex);
                 }
 
                 if (error != nullptr) {
@@ -1491,32 +1460,24 @@ vteapp_window_show_context_menu(VteappWindow* window,
                 static const char extra_pattern[] = "(\\d+)\\s*(\\w+)";
                 char* extra_match = nullptr;
                 char *extra_subst = nullptr;
-                if (options.use_gregex) {
-                        auto regex = compile_gregex(extra_pattern, false, nullptr);
-                        vte_terminal_event_check_gregex_simple(window->terminal, event,
-                                                               &regex, 1,
-                                                               GRegexMatchFlags(0),
-                                                               &extra_match);
-                        g_regex_unref(regex);
-                } else {
-                        auto regex = compile_regex_for_match(extra_pattern, false, nullptr);
-                        vte_terminal_event_check_regex_simple(window->terminal, event,
-                                                              &regex, 1, 0,
-                                                              &extra_match);
-
-                        GError *err = nullptr;
-                        if (extra_match != nullptr &&
-                            (extra_subst = vte_regex_substitute(regex, extra_match, "$2 $1",
-                                                                PCRE2_SUBSTITUTE_EXTENDED |
-                                                                PCRE2_SUBSTITUTE_GLOBAL,
-                                                                &err)) == nullptr) {
-                                verbose_printerr("Substitution failed: %s\n", err->message);
-                                g_error_free(err);
-                        }
-
-                        vte_regex_unref(regex);
+                GError* err = nullptr;
+                auto regex = compile_regex_for_match(extra_pattern, false, &err);
+                g_assert_no_error(err);
+                vte_terminal_event_check_regex_simple(window->terminal, event,
+                                                      &regex, 1, 0,
+                                                      &extra_match);
+
+                if (extra_match != nullptr &&
+                    (extra_subst = vte_regex_substitute(regex, extra_match, "$2 $1",
+                                                        PCRE2_SUBSTITUTE_EXTENDED |
+                                                        PCRE2_SUBSTITUTE_GLOBAL,
+                                                        &err)) == nullptr) {
+                        verbose_printerr("Substitution failed: %s\n", err->message);
+                        g_error_free(err);
                 }
 
+                vte_regex_unref(regex);
+
                 if (extra_match != nullptr) {
                         if (extra_subst != nullptr)
                                 verbose_print("%s match: %s => %s\n", extra_pattern, extra_match, 
extra_subst);
diff --git a/src/regex.cc b/src/regex.cc
index ee0a1fe3..b583c790 100644
--- a/src/regex.cc
+++ b/src/regex.cc
@@ -89,7 +89,6 @@ Regex::compile(Regex::Purpose purpose,
                uint32_t flags,
                GError** error)
 {
-
         assert(pattern != nullptr || pattern_length == 0);
         assert(error == nullptr || *error == nullptr);
 
diff --git a/src/vtegtk.cc b/src/vtegtk.cc
index 06116306..418564ef 100644
--- a/src/vtegtk.cc
+++ b/src/vtegtk.cc
@@ -2123,12 +2123,9 @@ vte_terminal_paste_primary(VteTerminal *terminal)
  * @gregex: a #GRegex
  * @gflags: the #GRegexMatchFlags to use when matching the regex
  *
- * Adds the regular expression @regex to the list of matching expressions.  When the
- * user moves the mouse cursor over a section of displayed text which matches
- * this expression, the text will be highlighted.
+ * This function does nothing since version 0.60.
  *
- * Returns: an integer associated with this expression, or -1 if @gregex could not be
- *   transformed into a #VteRegex or @gflags were incompatible
+ * Returns: -1
  *
  * Deprecated: 0.46: Use vte_terminal_match_add_regex() or vte_terminal_match_add_regex_full() instead.
  */
@@ -2137,16 +2134,7 @@ vte_terminal_match_add_gregex(VteTerminal *terminal,
                               GRegex *gregex,
                               GRegexMatchFlags gflags)
 {
-        g_return_val_if_fail(gregex != NULL, -1);
-
-        auto regex = _vte_regex_new_gregex(vte::base::Regex::Purpose::eMatch, gregex);
-        if (regex == nullptr)
-                return -1;
-
-        auto rv = vte_terminal_match_add_regex(terminal, regex,
-                                               _vte_regex_translate_gregex_match_flags(gflags));
-        vte_regex_unref(regex);
-        return rv;
+        return -1;
 }
 
 /**
@@ -2330,11 +2318,6 @@ vte_terminal_event_check_gregex_simple(VteTerminal *terminal,
                                        GRegexMatchFlags match_flags,
                                        char **matches)
 {
-        g_return_val_if_fail(VTE_IS_TERMINAL(terminal), FALSE);
-        g_return_val_if_fail(event != NULL, FALSE);
-        g_return_val_if_fail(regexes != NULL || n_regexes == 0, FALSE);
-        g_return_val_if_fail(matches != NULL, FALSE);
-
         return FALSE;
 }
 
@@ -2509,7 +2492,7 @@ vte_terminal_search_get_regex(VteTerminal *terminal)
  * @gregex: (allow-none): a #GRegex, or %NULL
  * @gflags: flags from #GRegexMatchFlags
  *
- * Sets the #GRegex regex to search for. Unsets the search regex when passed %NULL.
+ * This function does nothing since version 0.60.
  *
  * Deprecated: 0.46: use vte_terminal_search_set_regex() instead.
  */
@@ -2518,15 +2501,6 @@ vte_terminal_search_set_gregex (VteTerminal *terminal,
                                GRegex      *gregex,
                                 GRegexMatchFlags gflags)
 {
-        VteRegex *regex = nullptr;
-        if (gregex)
-                regex = _vte_regex_new_gregex(vte::base::Regex::Purpose::eSearch, gregex);
-
-        vte_terminal_search_set_regex(terminal, regex,
-                                      _vte_regex_translate_gregex_match_flags(gflags));
-
-        if (regex)
-                vte_regex_unref(regex);
 }
 
 /**
diff --git a/src/vteregex.cc b/src/vteregex.cc
index d95c77aa..6e336335 100644
--- a/src/vteregex.cc
+++ b/src/vteregex.cc
@@ -34,33 +34,6 @@
 
 #define IMPL(wrapper) (regex_from_wrapper(wrapper))
 
-/* GRegex translation */
-
-typedef struct {
-        guint32 gflag;
-        guint32 pflag;
-} FlagTranslation;
-
-static void
-translate_flags(FlagTranslation const* const table,
-                gsize table_len,
-                guint32 *gflagsptr /* inout */,
-                guint32 *pflagsptr /* inout */)
-{
-        auto gflags = *gflagsptr;
-        auto pflags = *pflagsptr;
-        for (guint i = 0; i < table_len; i++) {
-                auto gflag = table[i].gflag;
-                if ((gflags & gflag) == gflag) {
-                        pflags |= table[i].pflag;
-                        gflags &= ~gflag;
-                }
-        }
-
-        *gflagsptr = gflags;
-        *pflagsptr = pflags;
-}
-
 /* Type registration */
 
 #pragma GCC diagnostic push
@@ -117,66 +90,6 @@ vte_regex_new(vte::base::Regex::Purpose purpose,
         return wrapper_from_regex(vte::base::Regex::compile(purpose, pattern, pattern_length, flags, error));
 }
 
-VteRegex*
-_vte_regex_new_gregex(vte::base::Regex::Purpose purpose,
-                      GRegex *gregex)
-{
-        g_return_val_if_fail(gregex != NULL, NULL);
-
-        guint32 pflags = 0;
-
-        static FlagTranslation const table[] = {
-                { G_REGEX_CASELESS,        PCRE2_CASELESS        },
-                { G_REGEX_MULTILINE,       PCRE2_MULTILINE       },
-                { G_REGEX_DOTALL,          PCRE2_DOTALL          },
-                { G_REGEX_EXTENDED,        PCRE2_EXTENDED        },
-                { G_REGEX_ANCHORED,        PCRE2_ANCHORED        },
-                { G_REGEX_DOLLAR_ENDONLY,  PCRE2_DOLLAR_ENDONLY  },
-                { G_REGEX_UNGREEDY,        PCRE2_UNGREEDY        },
-                { G_REGEX_NO_AUTO_CAPTURE, PCRE2_NO_AUTO_CAPTURE },
-                { G_REGEX_OPTIMIZE,        0                     }, /* accepted but unused */
-                { G_REGEX_FIRSTLINE,       PCRE2_FIRSTLINE       },
-                { G_REGEX_DUPNAMES,        PCRE2_DUPNAMES        }
-        };
-
-        /* Always add the MULTILINE option */
-        guint32 gflags = g_regex_get_compile_flags(gregex) | G_REGEX_MULTILINE;
-        translate_flags(table, G_N_ELEMENTS(table), &gflags, &pflags);
-
-        if (gflags != 0) {
-                g_warning("Incompatible GRegex compile flags left untranslated: %08x", gflags);
-        }
-
-        GError* err = nullptr;
-        auto regex = vte_regex_new(purpose, g_regex_get_pattern(gregex), -1, pflags, &err);
-        if (regex == nullptr) {
-                g_warning("Failed to translated GRegex: %s", err->message);
-                g_error_free(err);
-        }
-        return regex;
-}
-
-guint32
-_vte_regex_translate_gregex_match_flags(GRegexMatchFlags flags)
-{
-        static FlagTranslation const table[] = {
-                { G_REGEX_MATCH_ANCHORED,         PCRE2_ANCHORED         },
-                { G_REGEX_MATCH_NOTBOL,           PCRE2_NOTBOL           },
-                { G_REGEX_MATCH_NOTEOL,           PCRE2_NOTEOL           },
-                { G_REGEX_MATCH_NOTEMPTY,         PCRE2_NOTEMPTY         },
-                { G_REGEX_MATCH_NOTEMPTY_ATSTART, PCRE2_NOTEMPTY_ATSTART }
-        };
-
-        guint32 gflags = flags;
-        guint32 pflags = 0;
-        translate_flags(table, G_N_ELEMENTS(table), &gflags, &pflags);
-        if (gflags != 0) {
-                g_warning("Incompatible GRegex match flags left untranslated: %08x", gflags);
-        }
-
-        return pflags;
-}
-
 /**
  * vte_regex_new_for_match:
  * @pattern: a regex pattern string
diff --git a/src/vteregexinternal.hh b/src/vteregexinternal.hh
index ac4e675d..8bc3952c 100644
--- a/src/vteregexinternal.hh
+++ b/src/vteregexinternal.hh
@@ -38,9 +38,3 @@ bool _vte_regex_has_purpose(VteRegex* regex,
                             vte::base::Regex::Purpose purpose);
 
 bool _vte_regex_has_multiline_compile_flag(VteRegex* regex);
-
-/* GRegex translation */
-VteRegex* _vte_regex_new_gregex(vte::base::Regex::Purpose purpose,
-                                GRegex* gregex);
-
-uint32_t _vte_regex_translate_gregex_match_flags(GRegexMatchFlags flags);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]