[vte/wip/regex-builtins: 39/39] lib: Add builtin regexes



commit 018c85164a21bc0de0e57b7e5428748b87c6fca0
Author: Christian Persch <chpe src gnome org>
Date:   Sun Feb 23 18:51:22 2020 +0100

    lib: Add builtin regexes
    
    Add builin regexes to recognise URLs, copied from gnome-terminal.
    
    https://gitlab.gnome.org/GNOME/vte/issues/114

 doc/reference/vte-sections.txt |   5 +
 meson.build                    |   2 +-
 src/app/app.cc                 |  41 ++-
 src/fwd.hh                     |   1 +
 src/meson.build                |  24 +-
 src/regex-builtins-patterns.hh | 151 +++++++++++
 src/regex-builtins.cc          | 103 +++++++
 src/regex-builtins.hh          |  80 ++++++
 src/regex-test.cc              | 604 +++++++++++++++++++++++++++++++++++++++++
 src/regex.cc                   |  11 +
 src/regex.hh                   |   1 +
 src/vte.cc                     |  39 ++-
 src/vte/vteenums.h             |  14 +
 src/vte/vteterminal.h          |   4 +
 src/vtedefines.hh              |   1 +
 src/vtegtk.cc                  |  75 ++++-
 src/vteinternal.hh             |   6 +
 src/vteregex.cc                |   6 +-
 18 files changed, 1142 insertions(+), 26 deletions(-)
---
diff --git a/doc/reference/vte-sections.txt b/doc/reference/vte-sections.txt
index 20067c88..62322663 100644
--- a/doc/reference/vte-sections.txt
+++ b/doc/reference/vte-sections.txt
@@ -6,6 +6,7 @@ VteCursorBlinkMode
 VteCursorShape
 VteEraseBinding
 VteTextBlinkMode
+VteBuiltinMatchTag
 VteFormat
 VteWriteFlags
 VteSelectionFunc
@@ -71,8 +72,10 @@ vte_terminal_get_text_range
 vte_terminal_get_cursor_position
 vte_terminal_hyperlink_check_event
 vte_terminal_match_add_regex
+vte_terminal_match_add_builtins
 vte_terminal_match_remove
 vte_terminal_match_remove_all
+vte_terminal_match_remove_builtins
 vte_terminal_match_check
 vte_terminal_match_check_event
 vte_terminal_match_set_cursor_name
@@ -118,6 +121,8 @@ VTE_TYPE_ERASE_BINDING
 vte_erase_binding_get_type
 VTE_TYPE_TEXT_BLINK_MODE
 vte_text_blink_mode_get_type
+VTE_TYPE_BUILTIN_MATCH_TAGS
+vte_builtin_match_tags_get_type
 VTE_TYPE_FORMAT
 vte_format_get_type
 VTE_TYPE_WRITE_FLAGS
diff --git a/meson.build b/meson.build
index 0b99c7d2..265784ae 100644
--- a/meson.build
+++ b/meson.build
@@ -33,7 +33,7 @@ project(
 
 gtk3_req_version          = '3.20.0'
 gtk3_min_req_version      = '3.18'
-gtk3_max_allowed_version  = '3.20'
+gtk3_max_allowed_version  = '3.24'
 gtk4_req_version          = '4.0.0'
 
 fribidi_req_version       = '1.0.0'
diff --git a/src/app/app.cc b/src/app/app.cc
index 0c7eed5d..fe67b4e9 100644
--- a/src/app/app.cc
+++ b/src/app/app.cc
@@ -980,8 +980,7 @@ struct _VteappWindowClass {
 static GType vteapp_window_get_type(void);
 
 static char const* const builtin_dingus[] = {
-        
"(((gopher|news|telnet|nntp|file|http|ftp|https)://)|(www|ftp)[-A-Za-z0-9]*\\.)[-A-Za-z0-9\\.]+(:[0-9]*)?",
-        
"(((gopher|news|telnet|nntp|file|http|ftp|https)://)|(www|ftp)[-A-Za-z0-9]*\\.)[-A-Za-z0-9\\.]+(:[0-9]*)?/[-A-Za-z0-9_\\$\\.\\+\\!\\*\\(\\),;:@&=\\?/~\\#\\%]*[^]'\\.}>\\)
 ,\\\"]",
+        "(foo|bar|baz)+",
         nullptr,
 };
 
@@ -1374,6 +1373,29 @@ window_action_copy_match_cb(GSimpleAction* action,
         gtk_clipboard_set_text(window->clipboard, str, len);
 }
 
+static void
+window_action_open_uri_cb(GSimpleAction* action,
+                          GVariant* parameter,
+                          void* data)
+{
+        VteappWindow* window = VTEAPP_WINDOW(data);
+        auto len = size_t{};
+        auto str = g_variant_get_string(parameter, &len);
+        GError* err{nullptr};
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+        if (!gtk_show_uri_on_window(GTK_WINDOW(window),
+#else
+        if (!gtk_show_uri(gtk_widget_get_screen(GTK_WIDGET(window)),
+#endif
+                                    str,
+                                    gtk_get_current_event_time(),
+                                    &err)) {
+                verbose_printerr("Opening URI \"%s\" failed: %s\n", str, err->message);
+                g_error_free(err);
+        }
+}
+
 static void
 window_action_paste_cb(GSimpleAction* action,
                        GVariant* parameter,
@@ -1454,7 +1476,8 @@ vteapp_window_show_context_menu(VteappWindow* window,
                         g_object_unref(item);
                 }
 
-                auto match = vte_terminal_match_check_event(window->terminal, event, nullptr);
+                auto tag = int{-1};
+                auto match = vte_terminal_match_check_event(window->terminal, event, &tag);
                 if (match != nullptr) {
                         verbose_print("Match: %s\n", match);
                         GVariant* target = g_variant_new_string(match);
@@ -1463,6 +1486,13 @@ vteapp_window_show_context_menu(VteappWindow* window,
                         g_menu_append_item(menu, item);
                         g_object_unref(item);
                 }
+                if (match != nullptr && tag == VTE_BUILTIN_MATCH_TAG_URI) {
+                        GVariant* target = g_variant_new_string(match);
+                        auto item = g_menu_item_new("_Open URI", nullptr);
+                        g_menu_item_set_action_and_target_value(item, "win.open-uri", target);
+                        g_menu_append_item(menu, item);
+                        g_object_unref(item);
+                }
 
                 /* Test extra match API */
                 static const char extra_pattern[] = "(\\d+)\\s*(\\w+)";
@@ -1809,6 +1839,7 @@ vteapp_window_constructed(GObject *object)
         GActionEntry const entries[] = {
                 { "copy",        window_action_copy_cb,       "s", nullptr, nullptr },
                 { "copy-match",  window_action_copy_match_cb, "s", nullptr, nullptr },
+                { "open-uri",    window_action_open_uri_cb,   "s", nullptr, nullptr },
                 { "paste",       window_action_paste_cb,  nullptr, nullptr, nullptr },
                 { "reset",       window_action_reset_cb,      "b", nullptr, nullptr },
                 { "find",        window_action_find_cb,   nullptr, nullptr, nullptr },
@@ -1928,8 +1959,10 @@ vteapp_window_constructed(GObject *object)
                 gtk_widget_set_opacity (GTK_WIDGET (window), options.get_alpha());
 
         /* Dingus */
-        if (!options.no_builtin_dingus)
+        if (!options.no_builtin_dingus) {
                 vteapp_window_add_dingus(window, builtin_dingus);
+                vte_terminal_match_add_builtins(window->terminal);
+        }
         if (options.dingus != nullptr)
                 vteapp_window_add_dingus(window, options.dingus);
 
diff --git a/src/fwd.hh b/src/fwd.hh
index 11525a98..6d52f8a7 100644
--- a/src/fwd.hh
+++ b/src/fwd.hh
@@ -22,6 +22,7 @@ namespace vte {
 namespace base {
 
 class Pty;
+class RegexBuiltins;
 
 } // namespace base
 
diff --git a/src/meson.build b/src/meson.build
index 79d4a702..8e99a7a9 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -76,7 +76,12 @@ pty_sources = files(
 
 regex_sources = files(
   'regex.cc',
-  'regex.hh'
+  'regex.hh',
+  'regex-builtins.cc',
+  'regex-builtins.hh',
+  'regex-builtins-patterns.hh',
+  'vteregex.cc',
+  'vteregexinternal.hh',
 )
 
 systemd_sources = files(
@@ -99,6 +104,7 @@ libvte_common_sources = debug_sources + glib_glue_sources + modes_sources + pars
   'chunk.cc',
   'chunk.hh',
   'color-triple.hh',
+  'fwd.hh',
   'keymap.cc',
   'keymap.h',
   'reaper.cc',
@@ -118,8 +124,6 @@ libvte_common_sources = debug_sources + glib_glue_sources + modes_sources + pars
   'vtegtk.hh',
   'vteinternal.hh',
   'vtepcre2.h',
-  'vteregex.cc',
-  'vteregexinternal.hh',
   'vterowdata.cc',
   'vterowdata.hh',
   'vteseq.cc',
@@ -436,6 +440,19 @@ test_refptr = executable(
   install: false,
 )
 
+test_regex_sources = regex_sources + files(
+  'regex-test.cc',
+)
+
+test_regex = executable(
+  'test-regex',
+  sources: test_regex_sources,
+  dependencies: [glib_dep, gobject_dep, pcre2_dep,],
+  cpp_args: ['-DVTE_COMPILATION',],
+  include_directories: top_inc,
+  install: false,
+)
+
 test_tabstops_sources = files(
   'tabstops-test.cc',
   'tabstops.hh'
@@ -503,6 +520,7 @@ test_units = [
   ['parser', test_parser],
   ['reaper', test_reaper],
   ['refptr', test_refptr],
+  ['regex', test_regex],
   ['stream', test_stream],
   ['tabstops', test_tabstops],
   ['utf8', test_utf8],
diff --git a/src/regex-builtins-patterns.hh b/src/regex-builtins-patterns.hh
new file mode 100644
index 00000000..cc531b50
--- /dev/null
+++ b/src/regex-builtins-patterns.hh
@@ -0,0 +1,151 @@
+/*
+ * Copyright © 2015 Egmont Koblinger
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Mini style-guide:
+ *
+ * #define'd fragments should preferably have an outermost group, for the
+ * exact same reason as why usually in C/C++ #define's the values are enclosed
+ * in parentheses: that is, so that you don't get surprised when you use the
+ * macro and append a quantifier.
+ *
+ * For repeated fragments prefer regex-style (?(DEFINE)(?<NAME>(...))) and use
+ * as (?&NAME), so that the regex string and the compiled regex object is
+ * smaller.
+ *
+ * Build small blocks, comment and unittest them heavily.
+ *
+ * Use free-spacing mode for improved readability. The hardest to read is
+ * which additional characters belong to a "(?" prefix. To improve
+ * readability, place a space after this, and for symmetry, before the closing
+ * parenthesis. Also place a space around "|" characters. No space before
+ * quantifiers. Try to be consistent with the existing style (yes I know the
+ * existing style is not consistent either, but please do your best).
+ *
+ * See http://www.rexegg.com/regex-disambiguation.html for all the "(?"
+ * syntaxes.
+ */
+
+#pragma once
+
+/* Lookbehind to see if there's a preceding apostrophe */
+#define APOS_START_DEF "(?<APOS_START>(?<='))?"
+
+#define SCHEME "(?ix: news | telnet | nntp | https? | ftps? | sftp | webcal )"
+
+#define USERCHARS "-+.[:alnum:]"
+/* Nonempty username, e.g. "john.smith" */
+#define USER "[" USERCHARS "]+"
+
+#define PASSCHARS_CLASS "[-[:alnum:]\\Q,?;.:/!%$^*&~\"#'\\E]"
+/* Optional colon-prefixed password. I guess empty password should be allowed, right? E.g. ":secret", ":", 
"" */
+#define PASS "(?x: :" PASSCHARS_CLASS "* )?"
+
+/* Optional at-terminated username (with perhaps a password too), e.g. "joe@", "pete:secret@", "" */
+#define USERPASS "(?:" USER PASS "@)?"
+
+/* S4: IPv4 segment (number between 0 and 255) with lookahead at the end so that we don't match "25" in the 
string "256".
+   The lookahead could go to the last segment of IPv4 only but this construct allows nicer unittesting. */
+#define S4_DEF "(?(DEFINE)(?<S4>(?x: (?: [0-9] | [1-9][0-9] | 1[0-9]{2} | 2[0-4][0-9] | 25[0-5] ) (?! [0-9] 
) )))"
+
+/* IPV4: Decimal IPv4, e.g. "1.2.3.4", with lookahead (implemented in S4) at the end so that we don't match 
"192.168.1.123" in the string "192.168.1.1234". */
+#define IPV4_DEF S4_DEF "(?(DEFINE)(?<IPV4>(?x: (?: (?&S4) \\. ){3} (?&S4) )))"
+
+/* IPv6, including embedded IPv4, e.g. "::1", "dead:beef::1.2.3.4".
+ * Lookahead for the next char not being a dot or digit, so it doesn't get stuck matching "dead:beef::1" in 
"dead:beef::1.2.3.4".
+ * This is not required since the surrounding brackets would trigger backtracking, but it allows nicer 
unittesting.
+ * TODO: more strict check (right number of colons, etc.)
+ * TODO: add zone_id: RFC 4007 section 11, RFC 6874 */
+
+/* S6: IPv6 segment, S6C: IPv6 segment followed by a comma, CS6: comma followed by an IPv6 segment */
+#define S6_DEF "(?(DEFINE)(?<S6>[[:xdigit:]]{1,4})(?<CS6>:(?&S6))(?<S6C>(?&S6):))"
+
+/* No :: shorthand */
+#define IPV6_FULL  "(?x: (?&S6C){7} (?&S6) )"
+/* Begins with :: */
+#define IPV6_LEFT  "(?x: : (?&CS6){1,7} )"
+/* :: somewhere in the middle - use negative lookahead to make sure there aren't too many colons in total */
+#define IPV6_MID   "(?x: (?! (?: [[:xdigit:]]*: ){8} ) (?&S6C){1,6} (?&CS6){1,6} )"
+/* Ends with :: */
+#define IPV6_RIGHT "(?x: (?&S6C){1,7} : )"
+/* Is "::" and nothing more */
+#define IPV6_NULL  "(?x: :: )"
+
+/* The same ones for IPv4-embedded notation, without the actual IPv4 part */
+#define IPV6V4_FULL  "(?x: (?&S6C){6} )"
+#define IPV6V4_LEFT  "(?x: :: (?&S6C){0,5} )"  /* includes "::<ipv4>" */
+#define IPV6V4_MID   "(?x: (?! (?: [[:xdigit:]]*: ){7} ) (?&S6C){1,4} (?&CS6){1,4} ) :"
+#define IPV6V4_RIGHT "(?x: (?&S6C){1,5} : )"
+
+/* IPV6: An IPv6 address (possibly with an embedded IPv4).
+ * This macro defines both IPV4 and IPV6, since the latter one requires the former. */
+#define IP_DEF IPV4_DEF S6_DEF "(?(DEFINE)(?<IPV6>(?x: (?: " IPV6_NULL " | " IPV6_LEFT " | " IPV6_MID " | " 
IPV6_RIGHT " | " IPV6_FULL " | (?: " IPV6V4_FULL " | " IPV6V4_LEFT " | " IPV6V4_MID " | " IPV6V4_RIGHT " ) 
(?&IPV4) ) (?! [.:[:xdigit:]] ) )))"
+
+/* Either an alphanumeric character or dash; or if [negative lookahead] not ASCII
+ * then any graphical Unicode character.
+ * A segment can consist entirely of numbers.
+ * (Note: PCRE doesn't support character class subtraction/intersection.) */
+#define HOSTNAMESEGMENTCHARS_CLASS "(?x: [-[:alnum:]] | (?! [[:ascii:]] ) [[:graph:]] )"
+
+/* A hostname of at least 1 component. The last component cannot be entirely numbers.
+ * E.g. "foo", "example.com", "1234.com", but not "foo.123" */
+#define HOSTNAME1 "(?x: (?: " HOSTNAMESEGMENTCHARS_CLASS "+ \\. )* " HOSTNAMESEGMENTCHARS_CLASS "* (?! [0-9] 
) " HOSTNAMESEGMENTCHARS_CLASS "+ )"
+
+/* A hostname of at least 2 components. The last component cannot be entirely numbers.
+ * E.g. "example.com", "1234.com", but not "1234.56" */
+#define HOSTNAME2 "(?x: (?: " HOSTNAMESEGMENTCHARS_CLASS "+ \\.)+ " HOSTNAME1 " )"
+
+/* For URL: Hostname, IPv4, or bracket-enclosed IPv6, e.g. "example.com", "1.2.3.4", "[::1]" */
+#define URL_HOST "(?x: " HOSTNAME1 " | (?&IPV4) | \\[ (?&IPV6) \\] )"
+
+/* For e-mail: Hostname of at least two segments, or bracket-enclosed IPv4 or IPv6, e.g. "example.com", 
"[1.2.3.4]", "[::1]".
+ * Technically an e-mail with a single-component hostname might be valid on a local network, but let's avoid 
tons of false positives (e.g. in a typical shell prompt). */
+#define EMAIL_HOST "(?x: " HOSTNAME2 " | \\[ (?: (?&IPV4) | (?&IPV6) ) \\] )"
+
+/* Number between 1 and 65535, with lookahead at the end so that we don't match "6789" in the string "67890",
+   and in turn we don't eventually match "http://host:6789"; in "http://host:67890";. */
+#define N_1_65535 "(?x: (?: [1-9][0-9]{0,3} | [1-5][0-9]{4} | 6[0-4][0-9]{3} | 65[0-4][0-9]{2} | 
655[0-2][0-9] | 6553[0-5] ) (?! [0-9] ) )"
+
+/* Optional colon-prefixed port, e.g. ":1080", "" */
+#define PORT "(?x: \\:" N_1_65535 " )?"
+
+/* Omit the parentheses, see below */
+#define PATHCHARS_CLASS "[-[:alnum:]\\Q_$.+!*,:;@&=?/~#|%'\\E]"
+/* Chars to end a URL. Apostrophe only allowed if there wasn't one in front of the URL, see bug 448044 */
+#define PATHTERM_CLASS        "[-[:alnum:]\\Q_$+*:@&=/~#|%'\\E]"
+#define PATHTERM_NOAPOS_CLASS "[-[:alnum:]\\Q_$+*:@&=/~#|%\\E]"
+
+/* Recursive definition of PATH that allows parentheses and square brackets only if balanced, see bug 
763980. */
+#define PATH_INNER_DEF "(?(DEFINE)(?<PATH_INNER>(?x: (?: " PATHCHARS_CLASS "* (?: \\( (?&PATH_INNER) \\) | 
\\[ (?&PATH_INNER) \\] ) )* " PATHCHARS_CLASS "* )))"
+/* Same as above, but the last character (if exists and is not a parenthesis) must be from PATHTERM_CLASS. */
+#define PATH_DEF "(?(DEFINE)(?<PATH>(?x: (?: " PATHCHARS_CLASS "* (?: \\( (?&PATH_INNER) \\) | \\[ 
(?&PATH_INNER) \\] ) )* (?: " PATHCHARS_CLASS "* (?(<APOS_START>)" PATHTERM_NOAPOS_CLASS "|" PATHTERM_CLASS 
") )? )))"
+
+#define URLPATH "(?x: /(?&PATH) )?"
+#define VOIP_PATH "(?x: [;?](?&PATH) )?"
+
+/* Now let's put these fragments together */
+
+#define DEFS APOS_START_DEF IP_DEF PATH_INNER_DEF PATH_DEF
+
+#define REGEX_URL_AS_IS  DEFS SCHEME "://" USERPASS URL_HOST PORT URLPATH
+/* TODO: also support file:/etc/passwd */
+#define REGEX_URL_FILE   DEFS "(?ix: file:/ (?: / (?: " HOSTNAME1 " )? / )? (?! / ) )(?&PATH)"
+/* Lookbehind so that we don't catch "abc.www.foo.bar", bug 739757. Lookahead for www/ftp for convenience 
(so that we can reuse HOSTNAME1). */
+#define REGEX_URL_HTTP   DEFS "(?<!(?:" HOSTNAMESEGMENTCHARS_CLASS "|[.]))(?=(?i:www|ftp))" HOSTNAME1 PORT 
URLPATH
+#define REGEX_URL_VOIP   DEFS "(?i:h323:|sips?:)" USERPASS URL_HOST PORT VOIP_PATH
+#define REGEX_EMAIL      DEFS "(?i:mailto:)?" USER "@" EMAIL_HOST
+#define REGEX_NEWS_MAN   "(?i:news:|man:|info:)[-[:alnum:]\\Q^_{|}~!\"#$%&'()*+,./;:=?`\\E]+"
diff --git a/src/regex-builtins.cc b/src/regex-builtins.cc
new file mode 100644
index 00000000..7fcb5128
--- /dev/null
+++ b/src/regex-builtins.cc
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2019 Christian Persch
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <glib.h>
+
+#include "regex.hh"
+#include "regex-builtins.hh"
+#include "regex-builtins-patterns.hh"
+
+#include "vtepcre2.h"
+
+namespace vte::base {
+
+RegexBuiltins::RegexBuiltins()
+{
+        m_builtins.reserve(8);
+
+        compile_builtin(REGEX_URL_AS_IS, InternalBuiltinsTag::eURL);
+        compile_builtin(REGEX_URL_HTTP,  InternalBuiltinsTag::eHTTP);
+        compile_builtin(REGEX_URL_FILE,  InternalBuiltinsTag::eFILE);
+        compile_builtin(REGEX_URL_VOIP,  InternalBuiltinsTag::eVOIP);
+        compile_builtin(REGEX_EMAIL,     InternalBuiltinsTag::eEMAIL);
+        compile_builtin(REGEX_NEWS_MAN,  InternalBuiltinsTag::eNEWS_MAN);
+}
+
+void
+RegexBuiltins::compile_builtin(std::string_view const& pattern,
+                               InternalBuiltinsTag tag)
+{
+        GError* error{nullptr};
+        auto regex = Regex::compile(Regex::Purpose::eMatch,
+                                    pattern,
+                                    PCRE2_UTF | PCRE2_UCP | PCRE2_NO_UTF_CHECK | PCRE2_MULTILINE,
+                                    &error);
+        if (error) {
+                g_printerr("Failed to compile builtin regex %d: %s\n", int(tag), error->message);
+                g_error_free(error);
+                return;
+        }
+
+        regex->jit(PCRE2_JIT_COMPLETE, &error);
+        if (error) {
+                g_printerr("Failed to complete JIT compile builtin regex %d: %s\n", int(tag), 
error->message);
+                g_clear_error(&error);
+        }
+
+        regex->jit(PCRE2_JIT_PARTIAL_SOFT, &error);
+        if (error) {
+                g_printerr("Failed to partial-soft JIT compile builtin regex %d: %s\n", int(tag), 
error->message);
+                g_clear_error(&error);
+        }
+
+        m_builtins.emplace_back(take_ref(regex), int(tag));
+}
+
+int
+RegexBuiltins::transform_match(char*& match,
+                               int tag) const noexcept
+{
+        switch (InternalBuiltinsTag(tag)) {
+        case InternalBuiltinsTag::eURL:
+        case InternalBuiltinsTag::eFILE:
+        case InternalBuiltinsTag::eNEWS_MAN:
+        case InternalBuiltinsTag::eVOIP:
+                /* No transformation */
+                return int(BuiltinsTag::eURI);
+
+        case InternalBuiltinsTag::eHTTP: {
+                auto v = match;
+                match = g_strdup_printf("http://%s";, match);
+                g_free(v);
+                return int(BuiltinsTag::eURI);
+        }
+
+        case InternalBuiltinsTag::eEMAIL:
+                if (g_ascii_strncasecmp ("mailto:";, match, 7) != 0) {
+                        auto v = match;
+                        match = g_strdup_printf ("mailto:%s";, match);
+                        g_free(v);
+                }
+                return int(BuiltinsTag::eURI);
+        }
+
+        return -1;
+}
+
+} // namespace vte::base
diff --git a/src/regex-builtins.hh b/src/regex-builtins.hh
new file mode 100644
index 00000000..f0b69864
--- /dev/null
+++ b/src/regex-builtins.hh
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2019 Christian Persch
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "regex.hh"
+#include "refptr.hh"
+
+namespace vte {
+
+namespace base {
+
+class RegexBuiltins {
+private:
+        static inline std::weak_ptr<RegexBuiltins> s_weak_ptr{};
+
+        std::vector<std::pair<RefPtr<Regex>, int>> m_builtins{};
+
+        enum class InternalBuiltinsTag : int {
+                eURL      = -2,
+                eHTTP     = -3,
+                eFILE     = -4,
+                eVOIP     = -5,
+                eEMAIL    = -6,
+                eNEWS_MAN = -7
+        };
+
+        void compile_builtin(std::string_view const& pattern,
+                             InternalBuiltinsTag tag) noexcept;
+
+public:
+        // these must have the same values as the public VteBuiltinMatchTag
+        enum class BuiltinsTag : int {
+                eURI = -2
+        };
+
+        RegexBuiltins();
+        ~RegexBuiltins() { }
+        RegexBuiltins(RegexBuiltins const&) = delete;
+        RegexBuiltins(RegexBuiltins&&) = delete;
+
+        RegexBuiltins& operator= (RegexBuiltins const&) = delete;
+        RegexBuiltins& operator= (RegexBuiltins&&) = delete;
+
+        inline constexpr auto const& builtins() const noexcept { return m_builtins; }
+
+        int transform_match(char*& match,
+                            int tag) const noexcept;
+
+        static std::shared_ptr<RegexBuiltins> get()
+        {
+                auto inst = s_weak_ptr.lock();
+                if (!inst)
+                        s_weak_ptr = inst = std::make_shared<RegexBuiltins>();
+                return inst;
+        }
+};
+
+} // namespace base
+
+} // namespace vte
diff --git a/src/regex-test.cc b/src/regex-test.cc
new file mode 100644
index 00000000..138b564e
--- /dev/null
+++ b/src/regex-test.cc
@@ -0,0 +1,604 @@
+/*
+ * Copyright © 2015 Egmont Koblinger
+ * Copyright © 2019 Christian Persch
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <glib.h>
+#include <locale.h>
+
+#include <cstdint>
+#include <cstdlib>
+
+#include <string>
+
+#include "regex.hh"
+#include "regex-builtins-patterns.hh"
+
+auto pcre2test = bool{false};
+auto pcre2_atleast_10_34 = bool{false};
+
+/* Shorthand for expecting the pattern to match the entire input string */
+#define ENTIRE ((char *) 1)
+
+static pcre2_match_context_8*
+create_match_context()
+{
+        pcre2_match_context_8 *match_context;
+
+        match_context = pcre2_match_context_create_8(nullptr /* general context */);
+        pcre2_set_match_limit_8(match_context, 65536); /* should be plenty */
+        pcre2_set_recursion_limit_8(match_context, 64); /* should be plenty */
+
+        return match_context;
+}
+
+static char*
+get_match(decltype(&pcre2_match_8) match_fn,
+          vte::base::Regex const* regex,
+          uint32_t match_flags,
+          char const* subject)
+{
+        auto match_context = create_match_context();
+        auto match_data = pcre2_match_data_create_8(256 /* should be plenty */,
+                                                    nullptr /* general context */);
+
+        auto r = match_fn(regex->code(),
+                          (PCRE2_SPTR8)subject,
+                          strlen(subject),
+                          0, /* start offset */
+                          match_flags |
+                          PCRE2_NO_UTF_CHECK,
+                          match_data,
+                          match_context);
+
+        char* match;
+        if (r == PCRE2_ERROR_NOMATCH) {
+                match = nullptr;
+        } else if (r < 0) {
+                /* Error */
+                PCRE2_UCHAR8 buf[256];
+                int n = pcre2_get_error_message_8(r, buf, sizeof(buf));
+                g_assert_true(n >= 0);
+                g_printerr("PCRE2 error %d: %s\n", r, buf);
+
+                match = nullptr;
+        } else {
+                /* has match */
+                auto const* ovector = pcre2_get_ovector_pointer_8(match_data);
+                auto const so = ovector[0];
+                auto const eo = ovector[1];
+                if (so == PCRE2_UNSET || eo == PCRE2_UNSET)
+                        match = nullptr;
+                else
+                        match = g_strndup(subject + so, eo - so);
+        }
+
+        pcre2_match_data_free_8(match_data);
+        pcre2_match_context_free_8(match_context);
+
+        return match;
+}
+
+struct TestData {
+        char const* pattern;
+        char const* string;
+        char const* expected;
+        uint32_t match_flags;
+};
+
+static std::string
+escape_slash(std::string str)
+{
+        std::string escaped;
+        for (auto const c : str) {
+                if (c == '/')
+                        escaped.append("\\/");
+                else if (c == '\\')
+                        escaped.append("\\\\");
+                else
+                        escaped.push_back(c);
+        }
+
+        return escaped;
+}
+
+static std::string
+flags_to_string(uint32_t flags)
+{
+        std::string str;
+
+        if (flags & PCRE2_ANCHORED)
+                str.append("anchored,");
+
+        return str;
+}
+
+static void
+print_testdata(TestData* data,
+               int line)
+{
+        auto patstr = escape_slash(data->pattern);
+        auto flagstr = flags_to_string(data->match_flags);
+
+        g_print("# Line: %d\n"
+                "# Expected match: '%s'\n"
+                "/%s/%s\n"
+                "    %s\\=\n"
+                "\n",
+                line,
+                data->expected ? data->expected : "No match",
+                patstr.c_str(), flagstr.c_str(),
+                data->string);
+}
+
+static void
+assert_match_test(void const* ptr)
+{
+        TestData const* data = (TestData*)ptr;
+
+        GError *error{nullptr};
+        auto regex = vte::base::Regex::compile(vte::base::Regex::Purpose::eMatch,
+                                               data->pattern,
+                                               PCRE2_UTF | PCRE2_NO_UTF_CHECK |
+                                               PCRE2_UCP |
+                                               PCRE2_MULTILINE |
+                                               /* Pass match_flags here as compile flags, since
+                                                * otherwise some JITed regex tests fail because
+                                                * ANCHORED is ignored when passed to
+                                                * pcre2_jit_match_8.
+                                                */
+                                               data->match_flags,
+                                               &error);
+        g_assert_no_error(error);
+        g_assert_nonnull(regex);
+
+        auto match = get_match(&pcre2_match_8, regex, data->match_flags, data->string);
+
+        g_assert_cmpstr(match, ==, data->expected);
+        g_free(match);
+
+        if (vte::base::Regex::check_pcre_config_jit()) {
+                regex->jit(PCRE2_JIT_COMPLETE, &error);
+                g_assert_no_error(error);
+                regex->jit(PCRE2_JIT_PARTIAL_SOFT, &error);
+                g_assert_no_error(error);
+                regex->jit(PCRE2_JIT_PARTIAL_HARD, &error);
+                g_assert_no_error(error);
+
+                match = get_match(&pcre2_jit_match_8, regex, data->match_flags, data->string);
+                g_assert_cmpstr(match, ==, data->expected);
+                g_free(match);
+        }
+
+        regex->unref();
+}
+
+static void
+assert_match(char const* pattern,
+             char const* string,
+             char const* expected,
+             uint32_t match_flags = 0u,
+             int line = __builtin_LINE())
+{
+        TestData* data = g_new(TestData, 1);
+        data->pattern = pattern;
+        data->string = string;
+        data->expected = expected == ENTIRE ? string : expected;
+        data->match_flags = match_flags;
+
+        char* path = g_strdup_printf("/vte/regex/builtins/%d", line);
+        g_test_add_data_func_full(path, data, assert_match_test, (GDestroyNotify)g_free);
+        g_free(path);
+
+        if (pcre2test)
+                print_testdata(data, line);
+}
+
+static void
+assert_match_anchored(char const* pattern,
+                      char const* string,
+                      char const* expected,
+                      int line = __builtin_LINE())
+{
+        assert_match(pattern, string, expected, PCRE2_ANCHORED, line);
+}
+
+static void
+setup_regex_builtins_tests(void)
+{
+  /* SCHEME is case insensitive */
+  assert_match_anchored (SCHEME, "http",  ENTIRE);
+  assert_match_anchored (SCHEME, "HTTPS", ENTIRE);
+
+  /* USER is nonempty, alphanumeric, dot, plus and dash */
+  assert_match_anchored (USER, "",              NULL);
+  assert_match_anchored (USER, "dr.john-smith", ENTIRE);
+  assert_match_anchored (USER, "abc+def@ghi",   "abc+def");
+
+  /* PASS is optional colon-prefixed value, allowing quite some characters, but definitely not @ */
+  assert_match_anchored (PASS, "",          ENTIRE);
+  assert_match_anchored (PASS, "nocolon",   "");
+  assert_match_anchored (PASS, ":s3cr3T",   ENTIRE);
+  assert_match_anchored (PASS, ":$?#@host", ":$?#");
+
+  /* Hostname of at least 1 component, containing at least one non-digit in at least one of the segments */
+  assert_match_anchored (HOSTNAME1, "example.com",       ENTIRE);
+  assert_match_anchored (HOSTNAME1, "a-b.c-d",           ENTIRE);
+  assert_match_anchored (HOSTNAME1, "a_b",               "a");    /* TODO: can/should we totally abort here? 
*/
+  assert_match_anchored (HOSTNAME1, "déjà-vu.com",       ENTIRE);
+  assert_match_anchored (HOSTNAME1, "➡.ws",              ENTIRE);
+  assert_match_anchored (HOSTNAME1, "cömbining-áccents", ENTIRE);
+  assert_match_anchored (HOSTNAME1, "12",                NULL);
+  assert_match_anchored (HOSTNAME1, "12.34",             NULL);
+  assert_match_anchored (HOSTNAME1, "12.ab",             ENTIRE);
+//  assert_match_anchored (HOSTNAME1, "ab.12",             NULL);  /* errr... could we fail here?? */
+
+  /* Hostname of at least 2 components, containing at least one non-digit in at least one of the segments */
+  assert_match_anchored (HOSTNAME2, "example.com",       ENTIRE);
+  assert_match_anchored (HOSTNAME2, "example",           NULL);
+  assert_match_anchored (HOSTNAME2, "12",                NULL);
+  assert_match_anchored (HOSTNAME2, "12.34",             NULL);
+  assert_match_anchored (HOSTNAME2, "12.ab",             ENTIRE);
+  assert_match_anchored (HOSTNAME2, "ab.12",             NULL);
+//  assert_match_anchored (HOSTNAME2, "ab.cd.12",          NULL);  /* errr... could we fail here?? */
+
+  /* IPv4 segment (number between 0 and 255) */
+  assert_match_anchored (DEFS "(?&S4)", "0",    ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "1",    ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "9",    ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "10",   ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "99",   ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "100",  ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "200",  ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "250",  ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "255",  ENTIRE);
+  assert_match_anchored (DEFS "(?&S4)", "256",  NULL);
+  assert_match_anchored (DEFS "(?&S4)", "260",  NULL);
+  assert_match_anchored (DEFS "(?&S4)", "300",  NULL);
+  assert_match_anchored (DEFS "(?&S4)", "1000", NULL);
+  assert_match_anchored (DEFS "(?&S4)", "",     NULL);
+  assert_match_anchored (DEFS "(?&S4)", "a1b",  NULL);
+
+  /* IPv4 addresses */
+  assert_match_anchored (DEFS "(?&IPV4)", "11.22.33.44",    ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV4)", "0.1.254.255",    ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV4)", "75.150.225.300", NULL);
+  assert_match_anchored (DEFS "(?&IPV4)", "1.2.3.4.5",      "1.2.3.4");  /* we could also bail out and not 
match at all */
+
+  /* IPv6 addresses */
+  assert_match_anchored (DEFS "(?&IPV6)", "11:::22",                           NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22::33:44::55:66",               NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "dead::beef",                        ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV6)", "faded::bee",                        NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "live::pork",                        NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "::1",                               ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV6)", "11::22:33::44",                     NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:::33",                        NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "dead:beef::192.168.1.1",            ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV6)", "192.168.1.1",                       NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77:87654",        NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22::33:45678",                   NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:192.168.1.12345", NULL);
+
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77",              NULL);   /* no :: */
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77:88",           ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77:88:99",        NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "::11:22:33:44:55:66:77",            ENTIRE); /* :: at the start */
+  assert_match_anchored (DEFS "(?&IPV6)", "::11:22:33:44:55:66:77:88",         NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33::44:55:66:77",             ENTIRE); /* :: in the middle 
*/
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33::44:55:66:77:88",          NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77::",            ENTIRE); /* :: at the end */
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77:88::",         NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "::",                                ENTIRE); /* :: only */
+
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:192.168.1.1",        NULL);   /* no :: */
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:192.168.1.1",     ENTIRE);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66:77:192.168.1.1",  NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "::11:22:33:44:55:192.168.1.1",      ENTIRE); /* :: at the start */
+  assert_match_anchored (DEFS "(?&IPV6)", "::11:22:33:44:55:66:192.168.1.1",   NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33::44:55:192.168.1.1",       ENTIRE); /* :: in the imddle 
*/
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33::44:55:66:192.168.1.1",    NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55::192.168.1.1",       ENTIRE); /* :: at the 
end(ish) */
+  assert_match_anchored (DEFS "(?&IPV6)", "11:22:33:44:55:66::192.168.1.1",    NULL);
+  assert_match_anchored (DEFS "(?&IPV6)", "::192.168.1.1",                     ENTIRE); /* :: only(ish) */
+
+  /* URL_HOST is either a hostname, or an IPv4 address, or a bracket-enclosed IPv6 address */
+  assert_match_anchored (DEFS URL_HOST, "example",       ENTIRE);
+  assert_match_anchored (DEFS URL_HOST, "example.com",   ENTIRE);
+  assert_match_anchored (DEFS URL_HOST, "11.22.33.44",   ENTIRE);
+  assert_match_anchored (DEFS URL_HOST, "[11.22.33.44]", NULL);
+  assert_match_anchored (DEFS URL_HOST, "dead::be:ef",   "dead");  /* TODO: can/should we totally abort 
here? */
+  assert_match_anchored (DEFS URL_HOST, "[dead::be:ef]", ENTIRE);
+
+  /* EMAIL_HOST is either an at least two-component hostname, or a bracket-enclosed IPv[46] address */
+  assert_match_anchored (DEFS EMAIL_HOST, "example",        NULL);
+  assert_match_anchored (DEFS EMAIL_HOST, "example.com",    ENTIRE);
+  assert_match_anchored (DEFS EMAIL_HOST, "11.22.33.44",    NULL);
+  assert_match_anchored (DEFS EMAIL_HOST, "[11.22.33.44]",  ENTIRE);
+  assert_match_anchored (DEFS EMAIL_HOST, "[11.22.33.456]", NULL);
+  assert_match_anchored (DEFS EMAIL_HOST, "dead::be:ef",    NULL);
+  assert_match_anchored (DEFS EMAIL_HOST, "[dead::be:ef]",  ENTIRE);
+
+  /* Number between 1 and 65535 (helper for port) */
+  assert_match_anchored (N_1_65535, "0",      NULL);
+  assert_match_anchored (N_1_65535, "1",      ENTIRE);
+  assert_match_anchored (N_1_65535, "10",     ENTIRE);
+  assert_match_anchored (N_1_65535, "100",    ENTIRE);
+  assert_match_anchored (N_1_65535, "1000",   ENTIRE);
+  assert_match_anchored (N_1_65535, "10000",  ENTIRE);
+  assert_match_anchored (N_1_65535, "60000",  ENTIRE);
+  assert_match_anchored (N_1_65535, "65000",  ENTIRE);
+  assert_match_anchored (N_1_65535, "65500",  ENTIRE);
+  assert_match_anchored (N_1_65535, "65530",  ENTIRE);
+  assert_match_anchored (N_1_65535, "65535",  ENTIRE);
+  assert_match_anchored (N_1_65535, "65536",  NULL);
+  assert_match_anchored (N_1_65535, "65540",  NULL);
+  assert_match_anchored (N_1_65535, "65600",  NULL);
+  assert_match_anchored (N_1_65535, "66000",  NULL);
+  assert_match_anchored (N_1_65535, "70000",  NULL);
+  assert_match_anchored (N_1_65535, "100000", NULL);
+  assert_match_anchored (N_1_65535, "",       NULL);
+  assert_match_anchored (N_1_65535, "a1b",    NULL);
+
+  /* PORT is an optional colon-prefixed value */
+  assert_match_anchored (PORT, "",       ENTIRE);
+  assert_match_anchored (PORT, ":1",     ENTIRE);
+  assert_match_anchored (PORT, ":65535", ENTIRE);
+  assert_match_anchored (PORT, ":65536", "");     /* TODO: can/should we totally abort here? */
+
+  /* Parentheses are only allowed in matching pairs, see bug 763980. */
+  /* TODO: add tests for PATHCHARS and PATHNONTERM; and/or URLPATH */
+  assert_match_anchored (DEFS URLPATH, "/ab/cd",       ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/ab/cd.html.", "/ab/cd.html");
+  assert_match_anchored (DEFS URLPATH, "/The_Offspring_(album)", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/The_Offspring)", "/The_Offspring");
+  assert_match_anchored (DEFS URLPATH, "/a((b(c)d)e(f))", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/a((b(c)d)e(f)))", "/a((b(c)d)e(f))");
+  assert_match_anchored (DEFS URLPATH, "/a(b).(c).", "/a(b).(c)");
+  assert_match_anchored (DEFS URLPATH, "/a.(b.(c.).).(d.(e.).).)", "/a.(b.(c.).).(d.(e.).)");
+  assert_match_anchored (DEFS URLPATH, "/a)b(c", "/a");
+  assert_match_anchored (DEFS URLPATH, "/.", "/");
+  assert_match_anchored (DEFS URLPATH, "/(.", "/");
+  assert_match_anchored (DEFS URLPATH, "/).", "/");
+  assert_match_anchored (DEFS URLPATH, "/().", "/()");
+  assert_match_anchored (DEFS URLPATH, "/", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/php?param[]=value1&param[]=value2", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/foo?param1[index1]=value1&param2[index2]=value2", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/[[[]][]]", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/[([])]([()])", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/([()])[([])]", ENTIRE);
+  assert_match_anchored (DEFS URLPATH, "/[(])", "/");
+  assert_match_anchored (DEFS URLPATH, "/([)]", "/");
+
+
+  /* Put the components together and test the big picture */
+
+  assert_match (REGEX_URL_AS_IS, "There's no URL here http:/foo",               NULL);
+  assert_match (REGEX_URL_AS_IS, "Visit http://example.com for details",        "http://example.com";);
+  assert_match (REGEX_URL_AS_IS, "Trailing dot http://foo/bar.html.";,           "http://foo/bar.html";);
+  assert_match (REGEX_URL_AS_IS, "Trailing ellipsis http://foo/bar.html...";,    "http://foo/bar.html";);
+  assert_match (REGEX_URL_AS_IS, "Trailing comma http://foo/bar,baz,";,          "http://foo/bar,baz";);
+  assert_match (REGEX_URL_AS_IS, "Trailing semicolon http://foo/bar;baz;";,      "http://foo/bar;baz";);
+  assert_match (REGEX_URL_AS_IS, "See <http://foo/bar>",                        "http://foo/bar";);
+  assert_match (REGEX_URL_AS_IS, "<http://foo.bar/asdf.qwer.html>",             
"http://foo.bar/asdf.qwer.html";);
+  assert_match (REGEX_URL_AS_IS, "Go to http://192.168.1.1.";,                   "http://192.168.1.1";);
+  assert_match (REGEX_URL_AS_IS, "If not, see <http://www.gnu.org/licenses/>.", 
"http://www.gnu.org/licenses/";);
+  assert_match (REGEX_URL_AS_IS, "<a href=\"http://foo/bar\";>foo</a>",          "http://foo/bar";);
+  assert_match (REGEX_URL_AS_IS, "<a href='http://foo/bar'>foo</a>",            "http://foo/bar";);
+  assert_match (REGEX_URL_AS_IS, "<url>http://foo/bar</url>",                   "http://foo/bar";);
+
+  assert_match (REGEX_URL_AS_IS, "http://";,          NULL);
+  assert_match (REGEX_URL_AS_IS, "http://a";,         ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://aa.";,       "http://aa";);
+  assert_match (REGEX_URL_AS_IS, "http://aa.b";,      ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://aa.bb";,     ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://aa.bb/c";,   ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://aa.bb/cc";,  ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://aa.bb/cc/";, ENTIRE);
+
+  assert_match (REGEX_URL_AS_IS, "HtTp://déjà-vu.com:10000/déjà/vu", ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "HTTP://joe:sEcReT@➡.ws:1080",      ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "https://cömbining-áccents";,        ENTIRE);
+
+  assert_match (REGEX_URL_AS_IS, "http://111.222.33.44";,                ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://111.222.33.44/";,               ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://111.222.33.44/foo";,            ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://1.2.3.4:5555/xyz";,             ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "https://[dead::beef]:12345/ipv6";,     ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "https://[dead::beef:11.22.33.44]";,    ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://1.2.3.4:";,                     "http://1.2.3.4";);  /* TODO: 
can/should we totally abort here? */
+  assert_match (REGEX_URL_AS_IS, "https://dead::beef/no-brackets-ipv6";, "https://dead";);    /* ditto */
+  assert_match (REGEX_URL_AS_IS, "http://111.222.333.444/";,             NULL);
+  assert_match (REGEX_URL_AS_IS, "http://1.2.3.4:70000";,                "http://1.2.3.4";);  /* TODO: 
can/should we totally abort here? */
+  assert_match (REGEX_URL_AS_IS, "http://[dead::beef:111.222.333.444]";, NULL);
+
+  /* Username, password */
+  assert_match (REGEX_URL_AS_IS, "http://joe example com",                 ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://user.name:sec ret host name",     ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://joe:secret@[::1]";,                ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://dudewithnopassword:@example.com";, ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://safeguy:!#$%^&*@host";,            ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http://invalidusername!@host";,           "http://invalidusername";);
+
+  assert_match (REGEX_URL_AS_IS, "http://ab.cd/ef?g=h&i=j|k=l#m=n:o=p", ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "http:///foo";,                         NULL);
+
+  /* Parentheses are only allowed in matching pairs, see bug 763980. */
+  assert_match (REGEX_URL_AS_IS, "https://en.wikipedia.org/wiki/The_Offspring_(album)", ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "[markdown](https://en.wikipedia.org/wiki/The_Offspring)", 
"https://en.wikipedia.org/wiki/The_Offspring";);
+  assert_match (REGEX_URL_AS_IS, "[markdown](https://en.wikipedia.org/wiki/The_Offspring_(album))", 
"https://en.wikipedia.org/wiki/The_Offspring_(album)");
+  assert_match (REGEX_URL_AS_IS, "[markdown](http://foo.bar/(a(b)c)d)e)f", "http://foo.bar/(a(b)c)d");
+  assert_match (REGEX_URL_AS_IS, "[markdown](http://foo.bar/a)b(c", "http://foo.bar/a";);
+
+  /* Apostrophes are allowed, except at trailing position if the URL is preceded by an apostrophe, see bug 
448044. */
+  assert_match (REGEX_URL_AS_IS, "https://en.wikipedia.org/wiki/Moore's_law", ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "<a href=\"https://en.wikipedia.org/wiki/Moore's_law\">", 
"https://en.wikipedia.org/wiki/Moore's_law");
+  assert_match (REGEX_URL_AS_IS, "https://en.wikipedia.org/wiki/Cryin'", ENTIRE);
+  assert_match (REGEX_URL_AS_IS, "<a href=\"https://en.wikipedia.org/wiki/Cryin'\">", 
"https://en.wikipedia.org/wiki/Cryin'");
+  assert_match (REGEX_URL_AS_IS, "<a href='https://en.wikipedia.org/wiki/Aerosmith'>", 
"https://en.wikipedia.org/wiki/Aerosmith";);
+
+  /* No scheme */
+  /* The following tests changed results in PCRE2 revision 1133
+   * [https://vcs.pcre.org/pcre2?view=revision&revision=1133] from
+   * passing to failing.
+   * FIXMEchpe!
+   */
+  if (!pcre2_atleast_10_34 || pcre2test) {
+  assert_match (REGEX_URL_HTTP, "www.foo.bar/baz",     ENTIRE);
+  assert_match (REGEX_URL_HTTP, "WWW3.foo.bar/baz",    ENTIRE);
+  assert_match (REGEX_URL_HTTP, "FTP.FOO.BAR/BAZ",     ENTIRE);  /* FIXME if no scheme is given and url 
starts with ftp, can we make the protocol ftp instead of http? */
+  assert_match (REGEX_URL_HTTP, "ftpxy.foo.bar/baz",   ENTIRE);
+  }
+  /* ... and this one from failing to passing */
+  if (pcre2_atleast_10_34 || pcre2test) {
+  assert_match (REGEX_URL_HTTP, "ftp.123/baz",         NULL);  /* errr... could we fail here?? */
+  }
+  assert_match (REGEX_URL_HTTP, "foo.bar/baz",         NULL);
+  assert_match (REGEX_URL_HTTP, "abc.www.foo.bar/baz", NULL);
+  assert_match (REGEX_URL_HTTP, "uvwww.foo.bar/baz",   NULL);
+  assert_match (REGEX_URL_HTTP, "xftp.foo.bar/baz",    NULL);
+
+  /* file:/ or file://(hostname)?/ */
+  assert_match (REGEX_URL_FILE, "file:",                NULL);
+  assert_match (REGEX_URL_FILE, "file:/",               ENTIRE);
+  assert_match (REGEX_URL_FILE, "file://",              NULL);
+  assert_match (REGEX_URL_FILE, "file:///",             ENTIRE);
+  assert_match (REGEX_URL_FILE, "file:////",            NULL);
+  assert_match (REGEX_URL_FILE, "file:etc/passwd",      NULL);
+  assert_match (REGEX_URL_FILE, "File:/etc/passwd",     ENTIRE);
+  assert_match (REGEX_URL_FILE, "FILE:///etc/passwd",   ENTIRE);
+  assert_match (REGEX_URL_FILE, "file:////etc/passwd",  NULL);
+  assert_match (REGEX_URL_FILE, "file://host.name",     NULL);
+  assert_match (REGEX_URL_FILE, "file://host.name/",    ENTIRE);
+  assert_match (REGEX_URL_FILE, "file://host.name/etc", ENTIRE);
+
+  assert_match (REGEX_URL_FILE, "See file:/.",             "file:/");
+  assert_match (REGEX_URL_FILE, "See file:///.",           "file:///");
+  assert_match (REGEX_URL_FILE, "See file:/lost+found.",   "file:/lost+found");
+  assert_match (REGEX_URL_FILE, "See file:///lost+found.", "file:///lost+found");
+
+  /* Email */
+  assert_match (REGEX_EMAIL, "Write to foo bar com.",        "foo bar com");
+  assert_match (REGEX_EMAIL, "Write to <foo bar com>",       "foo bar com");
+  assert_match (REGEX_EMAIL, "Write to mailto:foo bar com.", "mailto:foo bar com");
+  assert_match (REGEX_EMAIL, "Write to MAILTO:FOO BAR COM.", "MAILTO:FOO BAR COM");
+  assert_match (REGEX_EMAIL, "Write to foo@[1.2.3.4]",       "foo@[1.2.3.4]");
+  assert_match (REGEX_EMAIL, "Write to foo@[1.2.3.456]",     NULL);
+  assert_match (REGEX_EMAIL, "Write to foo@[1::2345]",       "foo@[1::2345]");
+  assert_match (REGEX_EMAIL, "Write to foo@[dead::beef]",    "foo@[dead::beef]");
+  assert_match (REGEX_EMAIL, "Write to foo@1.2.3.4",         NULL);
+  assert_match (REGEX_EMAIL, "Write to foo@1.2.3.456",       NULL);
+  assert_match (REGEX_EMAIL, "Write to foo@1::2345",         NULL);
+  assert_match (REGEX_EMAIL, "Write to foo@dead::beef",      NULL);
+  assert_match (REGEX_EMAIL, "<baz email=\"foo bar com\"/>", "foo bar com");
+  assert_match (REGEX_EMAIL, "<baz email='foo bar com'/>",   "foo bar com");
+  assert_match (REGEX_EMAIL, "<email>foo bar com</email>",   "foo bar com");
+
+  /* Sip, examples from rfc 3261 */
+  assert_match (REGEX_URL_VOIP, "sip:alice atlanta com;maddr=239.255.255.1;ttl=15",           ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sip:alice atlanta com",                                      ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sip:alice:secretword atlanta com;transport=tcp",             ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sips:alice atlanta com?subject=project%20x&priority=urgent", ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sip:+1-212-555-1212:1234 gateway com;user=phone",            ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sips:1212 gateway com",                                      ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sip:alice@192.0.2.4",                                        ENTIRE);
+  assert_match (REGEX_URL_VOIP, "sip:atlanta.com;method=REGISTER?to=alice%40atlanta.com",     ENTIRE);
+  assert_match (REGEX_URL_VOIP, "SIP:alice;day=tuesday atlanta com",                          ENTIRE);
+  assert_match (REGEX_URL_VOIP, "Dial sip:alice@192.0.2.4.",                                  
"sip:alice@192.0.2.4");
+
+  /* Extremely long match, bug 770147 */
+  assert_match (REGEX_URL_AS_IS, "http://www.example.com/ThisPathConsistsOfMoreThan1024Characters";
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+                                 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 
ENTIRE);
+}
+
+static void
+test_regex_unicode(void)
+{
+        GError* error{nullptr};
+        g_assert_true(vte::base::Regex::check_pcre_config_unicode(&error));
+        g_assert_no_error(error);
+}
+
+static bool
+parse_args(char*** argv,
+           int* argc,
+           GError** error)
+{
+        auto _pcre2test = gboolean{FALSE};
+        GOptionEntry const entries[] = {
+                { "pcre2test", 0, 0, G_OPTION_ARG_NONE, &_pcre2test,
+                  "Print tests in pcre2test format to stdout", nullptr },
+                { nullptr }
+        };
+
+        auto context = g_option_context_new(nullptr);
+        g_option_context_set_help_enabled(context, false);
+        g_option_context_set_ignore_unknown_options(context, true);
+        g_option_context_add_main_entries(context, entries, nullptr);
+
+        bool rv = g_option_context_parse(context, argc, argv, error);
+        g_option_context_free(context);
+
+        pcre2test = _pcre2test != false;
+        return rv;
+}
+
+int
+main(int argc,
+     char* argv[])
+{
+        setlocale(LC_ALL, "");
+
+        g_test_init(&argc, &argv, nullptr);
+
+        GError* err{nullptr};
+        if (!parse_args(&argv, &argc, &err)) {
+                g_printerr("Failed to parse arguments: %s\n", err->message);
+                g_error_free(err);
+                return EXIT_FAILURE;
+        }
+
+        auto version = vte::base::Regex::get_pcre_version();
+        pcre2_atleast_10_34 = strverscmp(version.c_str(), "10.34") > 0;
+
+        if (pcre2test)
+                g_print("#pattern multiline,ucp,utf,no_utf_check\n\n");
+
+        /* Build test suites */
+
+        g_test_add_func("/vte/regex/unicode", test_regex_unicode);
+
+        setup_regex_builtins_tests();
+
+        /* Run tests */
+
+        if (pcre2test)
+                return EXIT_SUCCESS;
+
+        return g_test_run();
+}
diff --git a/src/regex.cc b/src/regex.cc
index 52e4e0bf..b981affd 100644
--- a/src/regex.cc
+++ b/src/regex.cc
@@ -52,6 +52,17 @@ Regex::unref() noexcept
                 delete this;
 }
 
+std::string
+Regex::get_pcre_version()
+{
+        auto v = std::string{};
+        auto r = pcre2_config_8(PCRE2_CONFIG_VERSION, nullptr);
+        v.resize(r);
+        r = pcre2_config_8(PCRE2_CONFIG_VERSION, v.data());
+
+        return v;
+}
+
 bool
 Regex::check_pcre_config_unicode(GError** error)
 {
diff --git a/src/regex.hh b/src/regex.hh
index 8db3e158..7a3394be 100644
--- a/src/regex.hh
+++ b/src/regex.hh
@@ -36,6 +36,7 @@ public:
                eSearch,
         };
 
+        static std::string get_pcre_version();
         static bool check_pcre_config_unicode(GError** error);
         static bool check_pcre_config_jit(void);
         static Regex* compile(Purpose purpose,
diff --git a/src/vte.cc b/src/vte.cc
index 0977ff6c..fe349552 100644
--- a/src/vte.cc
+++ b/src/vte.cc
@@ -65,10 +65,13 @@
 #include "vtepty.h"
 #include "vtegtk.hh"
 
+#include "regex-builtins.hh"
+
 #ifdef WITH_A11Y
 #include "vteaccess.h"
 #endif
 
+#include <algorithm>
 #include <new> /* placement new */
 
 using namespace std::literals;
@@ -1027,6 +1030,28 @@ Terminal::regex_match_remove(int tag) noexcept
         match_regexes_writable().erase(i);
 }
 
+void
+Terminal::regex_match_add_builtins() noexcept
+{
+        auto& match_regexes = match_regexes_writable();
+        if (!m_match_regex_builtins)
+                m_match_regex_builtins = vte::base::RegexBuiltins::get();
+        for (auto const& [regex, tag] : m_match_regex_builtins->builtins()) {
+                match_regexes.emplace_back(make_ref(regex.get()),
+                                           0 /* match flags */,
+                                           VTE_MATCH_BUILTINS_CURSOR,
+                                           tag);
+        }
+}
+
+void
+Terminal::regex_match_remove_builtins() noexcept
+{
+        auto& match_regexes = match_regexes_writable();
+        std::remove_if(std::begin(match_regexes), std::end(match_regexes),
+                       [](MatchRegex const& rem) { return rem.tag() < 0; });
+}
+
 /*
  * match_rowcol_to_offset:
  * @terminal:
@@ -1406,7 +1431,7 @@ Terminal::match_check_internal(vte::grid::column_t column,
 char*
 Terminal::regex_match_check(vte::grid::column_t column,
                             vte::grid::row_t row,
-                            int* tag)
+                            int* tag_ptr)
 {
        long delta = m_screen->scroll_delta;
        _vte_debug_print(VTE_DEBUG_EVENTS | VTE_DEBUG_REGEX,
@@ -1429,8 +1454,16 @@ Terminal::regex_match_check(vte::grid::column_t column,
        _VTE_DEBUG_IF(VTE_DEBUG_EVENTS | VTE_DEBUG_REGEX) {
                if (ret != NULL) g_printerr("Matched `%s'.\n", ret);
        }
-        if (tag != nullptr)
-                *tag = (match != nullptr) ? match->tag() : -1;
+
+        int tag = -1;
+        if (match != nullptr) {
+                tag = match->tag();
+                if (tag < -1 && m_match_regex_builtins)
+                        tag = m_match_regex_builtins->transform_match(ret, tag);
+        }
+
+        if (tag_ptr != nullptr)
+                *tag_ptr = tag;
 
        return ret;
 }
diff --git a/src/vte/vteenums.h b/src/vte/vteenums.h
index 84d07a0d..607efe1d 100644
--- a/src/vte/vteenums.h
+++ b/src/vte/vteenums.h
@@ -177,6 +177,20 @@ typedef enum {
         VTE_FORMAT_HTML = 2
 } VteFormat;
 
+/**
+ * VteBuiltinMatchTag:
+ * @VTE_BUILTIN_MATCH_TAG_URI: the match is an URI as recognised by
+ *   the expressions added with vte_terminal_match_add_uris()
+ *
+ * An enumeration that will be returned from vte_terminal_match_check_event()
+ * if a builtin expression matched.
+ *
+ * Since: 0.60
+ */
+typedef enum {
+        VTE_BUILTIN_MATCH_TAG_URI = -2
+} VteBuiltinMatchTag;
+
 G_END_DECLS
 
 #endif /* __VTE_VTE_ENUMS_H__ */
diff --git a/src/vte/vteterminal.h b/src/vte/vteterminal.h
index 31012518..52a40630 100644
--- a/src/vte/vteterminal.h
+++ b/src/vte/vteterminal.h
@@ -382,6 +382,8 @@ _VTE_PUBLIC
 int vte_terminal_match_add_regex(VteTerminal *terminal,
                                  VteRegex *regex,
                                  guint32 flags) _VTE_GNUC_NONNULL(1) _VTE_GNUC_NONNULL(2);
+_VTE_PUBLIC
+void vte_terminal_match_add_builtins(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
 /* Set the cursor to be used when the pointer is over a given match. */
 _VTE_PUBLIC
 void vte_terminal_match_set_cursor_name(VteTerminal *terminal,
@@ -391,6 +393,8 @@ _VTE_PUBLIC
 void vte_terminal_match_remove(VteTerminal *terminal,
                                int tag) _VTE_GNUC_NONNULL(1);
 _VTE_PUBLIC
+void vte_terminal_match_remove_builtins(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
+_VTE_PUBLIC
 void vte_terminal_match_remove_all(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
 
 /* Check if a given cell on the screen contains part of a matched string.  If
diff --git a/src/vtedefines.hh b/src/vtedefines.hh
index df45ecf6..09ff9657 100644
--- a/src/vtedefines.hh
+++ b/src/vtedefines.hh
@@ -79,6 +79,7 @@
 #define VTE_MOUSING_CURSOR             GDK_LEFT_PTR
 #define VTE_HYPERLINK_CURSOR           GDK_HAND2
 #define VTE_HYPERLINK_CURSOR_DEBUG     GDK_SPIDER
+#define VTE_MATCH_BUILTINS_CURSOR       GDK_HAND2
 #define VTE_CHILD_INPUT_PRIORITY       G_PRIORITY_DEFAULT_IDLE
 #define VTE_CHILD_OUTPUT_PRIORITY      G_PRIORITY_HIGH
 #define VTE_MAX_INPUT_READ             0x1000
diff --git a/src/vtegtk.cc b/src/vtegtk.cc
index 8edb9d9b..1cd846c3 100644
--- a/src/vtegtk.cc
+++ b/src/vtegtk.cc
@@ -2150,13 +2150,20 @@ vte_terminal_match_add_gregex(VteTerminal *terminal,
  * vte_terminal_match_add_regex:
  * @terminal: a #VteTerminal
  * @regex: (transfer none): a #VteRegex
- * @flags: PCRE2 match flags, or 0
+ * @flags: PCRE2 match flags, or 0 to use the default flags
  *
  * 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.
  *
- * Returns: an integer associated with this expression
+ * When vte_terminal_match_check_event() returns a match for this regex, the
+ * returned tag will be the return value of this function.
+ *
+ * Note that the default flags only contain PCRE2_UTF (and some flags for internal use);
+ * if you want to match unicode properties, you need to pass PCRE2_UCP in @flags.
+ * See man:pcre2_compile(3) for more information on available flags.
+ *
+ * Returns: a nonnegative integer associated with this expression
  *
  * Since: 0.46
  */
@@ -2177,6 +2184,30 @@ vte_terminal_match_add_regex(VteTerminal *terminal,
                                      impl->regex_match_next_tag()).tag();
 }
 
+/**
+ * vte_terminal_match_add_builtins:
+ * @terminal: a #VteTerminal
+ *
+ * Adds regular expressions to recognise URIs 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.
+ *
+ * When vte_terminal_match_check_event() returns a match for this regex, the
+ * returned tag will a value from #VteBuiltinMatchTag.
+ *
+ * Use vte_terminal_match_remove_builtins() or vte_terminal_match_remove_all() to remove
+ * the matching expressions added by this function.
+ *
+ * Since: 0.60
+ */
+void
+vte_terminal_match_add_builtins(VteTerminal *terminal)
+{
+       g_return_if_fail(VTE_IS_TERMINAL(terminal));
+
+        IMPL(terminal)->regex_match_add_builtins();
+}
+
 /**
  * vte_terminal_match_check:
  * @terminal: a #VteTerminal
@@ -2217,20 +2248,24 @@ vte_terminal_match_check(VteTerminal *terminal,
  *
  * Checks if the text in and around the position of the event matches any of the
  * regular expressions previously set using vte_terminal_match_add().  If a
- * match exists, the text string is returned and if @tag is not %NULL, the number
- * associated with the matched regular expression will be stored in @tag.
+ * match exists, the text string is returned.
  *
- * If more than one regular expression has been set with
- * vte_terminal_match_add(), then expressions are checked in the order in
- * which they were added.
+ * If @tag is not %NULL, it will store the nonnegative integer associated with the
+ * matched regular expression, if it was added with vte_terminal_match_add_regex(),
+ * or a negative number from #VteBuiltinMatchTag if the matching regular expression
+ * is one added with vte_terminal_match_add_builtins() matched, or -1 if there is
+ * no match.
+ *
+ * Expressions are checked in the order in which they were added, returning the
+ * first match.
  *
  * Returns: (transfer full) (nullable): a newly allocated string which matches one of the previously
  *   set regular expressions, or %NULL if there is no match
  */
 char *
-vte_terminal_match_check_event(VteTerminal *terminal,
-                               GdkEvent *event,
-                               int *tag)
+vte_terminal_match_check_event(VteTerminal* terminal,
+                               GdkEvent* event,
+                               int* tag)
 {
         g_return_val_if_fail(VTE_IS_TERMINAL(terminal), FALSE);
         return IMPL(terminal)->regex_match_check(event, tag);
@@ -2398,19 +2433,35 @@ vte_terminal_match_set_cursor_name(VteTerminal *terminal,
 /**
  * vte_terminal_match_remove:
  * @terminal: a #VteTerminal
- * @tag: the tag of the regex to remove
+ * @tag: the nonnegative tag of the regex to remove
  *
  * Removes the regular expression which is associated with the given @tag from
  * the list of expressions which the terminal will highlight when the user
  * moves the mouse cursor over matching text.
  */
 void
-vte_terminal_match_remove(VteTerminal *terminal, int tag)
+vte_terminal_match_remove(VteTerminal *terminal,
+                          int tag)
 {
        g_return_if_fail(VTE_IS_TERMINAL(terminal));
         IMPL(terminal)->regex_match_remove(tag);
 }
 
+/**
+ * vte_terminal_match_remove_builtins:
+ * @terminal: a #VteTerminal
+ *
+ * Removes the regular expression added with vte_terminal_match_add_builtins().
+ *
+ * Since: 0.60
+ */
+void
+vte_terminal_match_remove_builtins(VteTerminal *terminal)
+{
+       g_return_if_fail(VTE_IS_TERMINAL(terminal));
+        IMPL(terminal)->regex_match_remove_builtins();
+}
+
 /**
  * vte_terminal_match_remove_all:
  * @terminal: a #VteTerminal
diff --git a/src/vteinternal.hh b/src/vteinternal.hh
index 93e90527..c64561d2 100644
--- a/src/vteinternal.hh
+++ b/src/vteinternal.hh
@@ -57,8 +57,10 @@
 #include "chunk.hh"
 #include "pty.hh"
 #include "utf8.hh"
+#include "fwd.hh"
 
 #include <list>
+#include <memory>
 #include <queue>
 #include <optional>
 #include <string>
@@ -615,6 +617,10 @@ public:
                 return match_regexes_writable().emplace_back(std::forward<Args>(args)...);
         }
 
+        std::shared_ptr<vte::base::RegexBuiltins> m_match_regex_builtins{};
+        void regex_match_add_builtins() noexcept;
+        void regex_match_remove_builtins() noexcept;
+
         char* m_match_contents;
         GArray* m_match_attributes;
         char* m_match;
diff --git a/src/vteregex.cc b/src/vteregex.cc
index 26a55b43..8d46f7b5 100644
--- a/src/vteregex.cc
+++ b/src/vteregex.cc
@@ -24,9 +24,9 @@
 
 #include "config.h"
 
-#include "vtemacros.h"
-#include "vteenums.h"
-#include "vteregex.h"
+#include "vte/vtemacros.h"
+#include "vte/vteenums.h"
+#include "vte/vteregex.h"
 #include "vtepcre2.h"
 
 #include "regex.hh"


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