Replacement of internal RegEx with PCRE2

The pattern and replacement matching behaviour has been changed purely
due to the nature of switching to a standards-compliant library.

One mistake in the previous behaviour was that named groups didn't have
a number. This has been corrected.

As names are actually just an alias of numbered groups,
RegExMatch::get_name_dict() is now get_names() and is a dict
referring to the group number it represents.

Duplicate names are enabled and the with the first matching instance
used.

Due the lack of a suitable equivalent in PCRE2, RegExMatch::expand() was
removed.

3 files changed, 341 insertions, 1313 deletions

diff --git a/modules/regex/SCsub b/modules/regex/SCsub
index 0882406761..0fbdf97620 100644
--- a/modules/regex/SCsub
+++ b/modules/regex/SCsub
@@ -1,7 +1,50 @@
 #!/usr/bin/env python
 
 Import('env')
+Import('env_modules')
 
-env.add_source_files(env.modules_sources, "*.cpp")
+env_regex = env_modules.Clone()
+env_regex.Append(CPPFLAGS=["-DPCRE2_CODE_UNIT_WIDTH=0"])
+env_regex.add_source_files(env.modules_sources, "*.cpp")
 
-Export('env')
+if (env['builtin_pcre2'] != 'no'):
+    thirdparty_dir = "#thirdparty/pcre2/src/"
+    thirdparty_flags = ["-DPCRE2_STATIC", "-DHAVE_CONFIG_H", "-DSUPPORT_JIT"]
+    thirdparty_sources = [
+        "pcre2_auto_possess.c",
+        "pcre2_chartables.c",
+        "pcre2_compile.c",
+        "pcre2_config.c",
+        "pcre2_context.c",
+        "pcre2_dfa_match.c",
+        "pcre2_error.c",
+        "pcre2_find_bracket.c",
+        "pcre2_jit_compile.c",
+        "pcre2_maketables.c",
+        "pcre2_match.c",
+        "pcre2_match_data.c",
+        "pcre2_newline.c",
+        "pcre2_ord2utf.c",
+        "pcre2_pattern_info.c",
+        "pcre2_serialize.c",
+        "pcre2_string_utils.c",
+        "pcre2_study.c",
+        "pcre2_substitute.c",
+        "pcre2_substring.c",
+        "pcre2_tables.c",
+        "pcre2_ucd.c",
+        "pcre2_valid_utf.c",
+        "pcre2_xclass.c",
+    ]
+    thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
+    env_regex.Append(CPPPATH=[thirdparty_dir])
+    env_regex.Append(CPPFLAGS=thirdparty_flags)
+    def pcre2_builtin(width):
+        env_pcre2 = env_modules.Clone()
+        env_pcre2["OBJSUFFIX"] = "_" + width + env_pcre2["OBJSUFFIX"]
+        env_pcre2.Append(CPPPATH=[thirdparty_dir])
+        env_pcre2.add_source_files(env.modules_sources, thirdparty_sources)
+        env_pcre2.Append(CPPFLAGS=thirdparty_flags)
+        env_pcre2.Append(CPPFLAGS=["-DPCRE2_CODE_UNIT_WIDTH=" + width])
+    pcre2_builtin("16")
+    pcre2_builtin("32")
diff --git a/modules/regex/regex.cpp b/modules/regex/regex.cpp
index c728657d6b..323ae2d3c7 100644
--- a/modules/regex/regex.cpp
+++ b/modules/regex/regex.cpp
@@ -29,1479 +29,469 @@
 /*************************************************************************/
 
 #include "regex.h"
-#include <wchar.h>
-#include <wctype.h>
-
-static int RegEx_hex2int(const CharType c) {
-	if ('0' <= c && c <= '9')
-		return int(c - '0');
-	else if ('a' <= c && c <= 'f')
-		return int(c - 'a') + 10;
-	else if ('A' <= c && c <= 'F')
-		return int(c - 'A') + 10;
-	return -1;
-}
-
-struct RegExSearch {
-
-	Ref<RegExMatch> match;
-	const CharType *str;
-	int end;
-	int eof;
-
-	// For standard quantifier behaviour, test_parent is used to check the
-	// rest of the pattern. If the pattern matches, to prevent the parent
-	// from testing again, the complete flag is used as a shortcut out.
-	bool complete;
-
-	// With lookahead, the position needs to rewind to its starting position
-	// when test_parent is used. Due to functional programming, this state
-	// has to be kept as a parameter.
-	Vector<int> lookahead_pos;
-
-	CharType at(int p_pos) {
-		return str[p_pos];
-	}
-
-	RegExSearch(Ref<RegExMatch> &p_match, int p_end, int p_lookahead)
-		: match(p_match) {
-
-		str = p_match->string.c_str();
-		end = p_end;
-		eof = p_match->string.length();
-		complete = false;
-		lookahead_pos.resize(p_lookahead);
-	}
-};
-
-struct RegExNode {
-
-	RegExNode *next;
-	RegExNode *previous;
-	RegExNode *parent;
-	bool quantifiable;
-	int length;
-
-	RegExNode() {
-
-		next = NULL;
-		previous = NULL;
-		parent = NULL;
-		quantifiable = false;
-		length = -1;
-	}
-
-	virtual ~RegExNode() {
-
-		if (next)
-			memdelete(next);
-	}
+#include "core/os/memory.h"
 
-	// For avoiding RTTI
-	virtual bool is_look_behind() { return false; }
-
-	virtual int test(RegExSearch &s, int pos) const {
-
-		return next ? next->test(s, pos) : -1;
-	}
-
-	virtual int test_parent(RegExSearch &s, int pos) const {
-
-		if (next)
-			pos = next->test(s, pos);
-
-		if (pos >= 0) {
-			s.complete = true;
-			if (parent)
-				pos = parent->test_parent(s, pos);
-		}
-
-		if (pos < 0)
-			s.complete = false;
-
-		return pos;
-	}
-
-	void increment_length(int amount, bool subtract = false) {
-
-		if (amount >= 0 && length >= 0) {
-			if (!subtract)
-				length += amount;
-			else
-				length -= amount;
-		} else {
-			length = -1;
-		}
+extern "C" {
+#include <pcre2.h>
+}
 
-		if (parent)
-			parent->increment_length(amount, subtract);
-	}
-};
+static void *_regex_malloc(PCRE2_SIZE size, void *user) {
 
-struct RegExNodeChar : public RegExNode {
+	return memalloc(size);
+}
 
-	CharType ch;
+static void _regex_free(void *ptr, void *user) {
 
-	RegExNodeChar(CharType p_char) {
+	memfree(ptr);
+}
 
-		length = 1;
-		quantifiable = true;
-		ch = p_char;
-	}
+int RegExMatch::_find(const Variant &p_name) const {
 
-	virtual int test(RegExSearch &s, int pos) const {
+	if (p_name.is_num()) {
 
-		if (s.end <= pos || 0 > pos || s.at(pos) != ch)
+		int i = (int)p_name;
+		if (i >= data.size())
 			return -1;
+		return i;
 
-		return next ? next->test(s, pos + 1) : pos + 1;
-	}
+	} else if (p_name.get_type() == Variant::STRING) {
 
-	static CharType parse_escape(const CharType *&c) {
-
-		int point = 0;
-		switch (c[1]) {
-			case 'x':
-				for (int i = 2; i <= 3; ++i) {
-					int res = RegEx_hex2int(c[i]);
-					if (res == -1)
-						return '\0';
-					point = (point << 4) + res;
-				}
-				c = &c[3];
-				return CharType(point);
-			case 'u':
-				for (int i = 2; i <= 5; ++i) {
-					int res = RegEx_hex2int(c[i]);
-					if (res == -1)
-						return '\0';
-					point = (point << 4) + res;
-				}
-				c = &c[5];
-				return CharType(point);
-			case '0': ++c; return '\0';
-			case 'a': ++c; return '\a';
-			case 'e': ++c; return '\e';
-			case 'f': ++c; return '\f';
-			case 'n': ++c; return '\n';
-			case 'r': ++c; return '\r';
-			case 't': ++c; return '\t';
-			case 'v': ++c; return '\v';
-			case 'b': ++c; return '\b';
-			default: break;
-		}
-		return (++c)[0];
+		const Map<String, int>::Element *found = names.find((String)p_name);
+		if (found)
+			return found->value();
 	}
-};
 
-struct RegExNodeRange : public RegExNode {
+	return -1;
+}
 
-	CharType start;
-	CharType end;
+String RegExMatch::get_subject() const {
 
-	RegExNodeRange(CharType p_start, CharType p_end) {
+	return subject;
+}
 
-		length = 1;
-		quantifiable = true;
-		start = p_start;
-		end = p_end;
-	}
+int RegExMatch::get_group_count() const {
 
-	virtual int test(RegExSearch &s, int pos) const {
+	if (data.size() == 0)
+		return 0;
+	return data.size() - 1;
+}
 
-		if (s.end <= pos || 0 > pos)
-			return -1;
+Dictionary RegExMatch::get_names() const {
 
-		CharType c = s.at(pos);
-		if (c < start || end < c)
-			return -1;
+	Dictionary result;
 
-		return next ? next->test(s, pos + 1) : pos + 1;
+	for (const Map<String, int>::Element *i = names.front(); i != NULL; i = i->next()) {
+		result[i->key()] = i->value();
 	}
-};
-
-struct RegExNodeShorthand : public RegExNode {
 
-	CharType repr;
+	return result;
+}
 
-	RegExNodeShorthand(CharType p_repr) {
+Array RegExMatch::get_strings() const {
 
-		length = 1;
-		quantifiable = true;
-		repr = p_repr;
-	}
+	Array result;
 
-	virtual int test(RegExSearch &s, int pos) const {
+	int size = data.size();
 
-		if (s.end <= pos || 0 > pos)
-			return -1;
+	for (int i = 0; i < size; i++) {
 
-		bool found = false;
-		bool invert = false;
-		CharType c = s.at(pos);
-		switch (repr) {
-			case '.':
-				found = true;
-				break;
-			case 'W':
-				invert = true;
-			case 'w':
-				found = (c == '_' || iswalnum(c) != 0);
-				break;
-			case 'D':
-				invert = true;
-			case 'd':
-				found = ('0' <= c && c <= '9');
-				break;
-			case 'S':
-				invert = true;
-			case 's':
-				found = (iswspace(c) != 0);
-				break;
-			default:
-				break;
-		}
+		int start = data[i].start;
 
-		if (found == invert)
-			return -1;
-
-		return next ? next->test(s, pos + 1) : pos + 1;
-	}
-};
-
-struct RegExNodeClass : public RegExNode {
-
-	enum Type {
-		Type_none,
-		Type_alnum,
-		Type_alpha,
-		Type_ascii,
-		Type_blank,
-		Type_cntrl,
-		Type_digit,
-		Type_graph,
-		Type_lower,
-		Type_print,
-		Type_punct,
-		Type_space,
-		Type_upper,
-		Type_xdigit,
-		Type_word
-	};
-
-	Type type;
-
-	bool test_class(CharType c) const {
-
-		static Vector<CharType> REGEX_NODE_SPACE = String(" \t\r\n\f");
-		static Vector<CharType> REGEX_NODE_PUNCT = String("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
-
-		switch (type) {
-			case Type_alnum:
-				if ('0' <= c && c <= '9') return true;
-				if ('a' <= c && c <= 'z') return true;
-				if ('A' <= c && c <= 'Z') return true;
-				return false;
-			case Type_alpha:
-				if ('a' <= c && c <= 'z') return true;
-				if ('A' <= c && c <= 'Z') return true;
-				return false;
-			case Type_ascii:
-				return (0x00 <= c && c <= 0x7F);
-			case Type_blank:
-				return (c == ' ' || c == '\t');
-			case Type_cntrl:
-				return ((0x00 <= c && c <= 0x1F) || c == 0x7F);
-			case Type_digit:
-				return ('0' <= c && c <= '9');
-			case Type_graph:
-				return (0x20 < c && c < 0x7F);
-			case Type_lower:
-				return ('a' <= c && c <= 'z');
-			case Type_print:
-				return (0x20 < c && c < 0x7f);
-			case Type_punct:
-				return (REGEX_NODE_PUNCT.find(c) >= 0);
-			case Type_space:
-				return (REGEX_NODE_SPACE.find(c) >= 0);
-			case Type_upper:
-				return ('A' <= c && c <= 'Z');
-			case Type_xdigit:
-				if ('0' <= c && c <= '9') return true;
-				if ('a' <= c && c <= 'f') return true;
-				if ('A' <= c && c <= 'F') return true;
-				return false;
-			case Type_word:
-				if ('0' <= c && c <= '9') return true;
-				if ('a' <= c && c <= 'z') return true;
-				if ('A' <= c && c <= 'Z') return true;
-				return (c == '_');
-			default:
-				return false;
+		if (start == -1) {
+			result.append(String());
+			continue;
 		}
-		return false;
-	}
-
-	RegExNodeClass(Type p_type) {
-
-		length = 1;
-		quantifiable = true;
-		type = p_type;
-	}
-
-	virtual int test(RegExSearch &s, int pos) const {
-
-		if (s.end <= pos || 0 > pos)
-			return -1;
-
-		if (!test_class(s.at(pos)))
-			return -1;
-
-		return next ? next->test(s, pos + 1) : pos + 1;
-	}
-
-#define REGEX_CMP_CLASS(POS, NAME) \
-	if (cmp_class(POS, #NAME)) return Type_##NAME
-
-	static Type parse_type(const CharType *&p_pos) {
-
-		REGEX_CMP_CLASS(p_pos, alnum);
-		REGEX_CMP_CLASS(p_pos, alpha);
-		REGEX_CMP_CLASS(p_pos, ascii);
-		REGEX_CMP_CLASS(p_pos, blank);
-		REGEX_CMP_CLASS(p_pos, cntrl);
-		REGEX_CMP_CLASS(p_pos, digit);
-		REGEX_CMP_CLASS(p_pos, graph);
-		REGEX_CMP_CLASS(p_pos, lower);
-		REGEX_CMP_CLASS(p_pos, print);
-		REGEX_CMP_CLASS(p_pos, punct);
-		REGEX_CMP_CLASS(p_pos, space);
-		REGEX_CMP_CLASS(p_pos, upper);
-		REGEX_CMP_CLASS(p_pos, xdigit);
-		REGEX_CMP_CLASS(p_pos, word);
-		return Type_none;
-	}
-
-	static bool cmp_class(const CharType *&p_pos, const char *p_text) {
-
-		unsigned int i = 0;
-		for (i = 0; p_text[i] != '\0'; ++i)
-			if (p_pos[i] != p_text[i])
-				return false;
-
-		if (p_pos[i++] != ':' || p_pos[i] != ']')
-			return false;
-
-		p_pos = &p_pos[i];
-		return true;
-	}
-};
-
-struct RegExNodeAnchorStart : public RegExNode {
 
-	RegExNodeAnchorStart() {
+		int length = data[i].end - start;
 
-		length = 0;
+		result.append(subject.substr(start, length));
 	}
 
-	virtual int test(RegExSearch &s, int pos) const {
+	return result;
+}
 
-		if (pos != 0)
-			return -1;
+String RegExMatch::get_string(const Variant &p_name) const {
 
-		return next ? next->test(s, pos) : pos;
-	}
-};
+	int id = _find(p_name);
 
-struct RegExNodeAnchorEnd : public RegExNode {
+	if (id < 0)
+		return String();
 
-	RegExNodeAnchorEnd() {
+	int start = data[id].start;
 
-		length = 0;
-	}
+	if (start == -1)
+		return String();
 
-	virtual int test(RegExSearch &s, int pos) const {
+	int length = data[id].end - start;
 
-		if (pos != s.eof)
-			return -1;
+	return subject.substr(start, length);
+}
 
-		return next ? next->test(s, pos) : pos;
-	}
-};
+int RegExMatch::get_start(const Variant &p_name) const {
 
-struct RegExNodeWordBoundary : public RegExNode {
+	int id = _find(p_name);
 
-	bool inverse;
+	if (id < 0)
+		return -1;
 
-	RegExNodeWordBoundary(bool p_inverse) {
+	return data[id].start;
+}
 
-		length = 0;
-		inverse = p_inverse;
-	}
+int RegExMatch::get_end(const Variant &p_name) const {
 
-	virtual int test(RegExSearch &s, int pos) const {
+	int id = _find(p_name);
 
-		bool left = false;
-		bool right = false;
+	if (id < 0)
+		return -1;
 
-		if (pos != 0) {
-			CharType c = s.at(pos - 1);
-			if (c == '_' || iswalnum(c))
-				left = true;
-		}
+	return data[id].end;
+}
 
-		if (pos != s.eof) {
-			CharType c = s.at(pos);
-			if (c == '_' || iswalnum(c))
-				right = true;
-		}
+void RegExMatch::_bind_methods() {
 
-		if ((left == right) != inverse)
-			return -1;
+	ClassDB::bind_method(D_METHOD("get_subject"), &RegExMatch::get_subject);
+	ClassDB::bind_method(D_METHOD("get_group_count"), &RegExMatch::get_group_count);
+	ClassDB::bind_method(D_METHOD("get_names"), &RegExMatch::get_names);
+	ClassDB::bind_method(D_METHOD("get_strings"), &RegExMatch::get_strings);
+	ClassDB::bind_method(D_METHOD("get_string", "name"), &RegExMatch::get_string, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_start", "name"), &RegExMatch::get_start, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_end", "name"), &RegExMatch::get_end, DEFVAL(0));
+}
 
-		return next ? next->test(s, pos) : pos;
-	}
-};
+void RegEx::_pattern_info(uint32_t what, void *where) const {
 
-struct RegExNodeQuantifier : public RegExNode {
+	if (sizeof(CharType) == 2) {
 
-	int min;
-	int max;
-	bool greedy;
-	RegExNode *child;
+		pcre2_pattern_info_16((pcre2_code_16 *)code, what, where);
 
-	RegExNodeQuantifier(int p_min, int p_max) {
+	} else {
 
-		min = p_min;
-		max = p_max;
-		greedy = true;
-		child = NULL;
+		pcre2_pattern_info_32((pcre2_code_32 *)code, what, where);
 	}
+}
 
-	~RegExNodeQuantifier() {
-
-		if (child)
-			memdelete(child);
-	}
+void RegEx::clear() {
 
-	virtual int test(RegExSearch &s, int pos) const {
+	if (sizeof(CharType) == 2) {
 
-		return test_step(s, pos, 0, pos);
-	}
+		if (code)
+			pcre2_code_free_16((pcre2_code_16 *)code);
 
-	virtual int test_parent(RegExSearch &s, int pos) const {
+	} else {
 
-		s.complete = false;
-		return pos;
+		if (code)
+			pcre2_code_free_32((pcre2_code_32 *)code);
 	}
+}
 
-	int test_step(RegExSearch &s, int pos, int level, int start) const {
-
-		if (pos > s.end)
-			return -1;
-
-		if (!greedy && level > min) {
-			int res = next ? next->test(s, pos) : pos;
-			if (s.complete)
-				return res;
-
-			if (res >= 0 && parent->test_parent(s, res) >= 0)
-				return res;
-		}
-
-		if (max >= 0 && level > max)
-			return -1;
+Error RegEx::compile(const String &p_pattern) {
 
-		int res = pos;
-		if (level >= 1) {
-			if (level > min + 1 && pos == start)
-				return -1;
+	pattern = p_pattern;
+	clear();
 
-			res = child->test(s, pos);
-			if (s.complete)
-				return res;
-		}
+	int err;
+	PCRE2_SIZE offset;
+	uint32_t flags = PCRE2_DUPNAMES;
 
-		if (res >= 0) {
+	if (sizeof(CharType) == 2) {
 
-			int res_step = test_step(s, res, level + 1, start);
-			if (res_step >= 0)
-				return res_step;
+		pcre2_general_context_16 *gctx = (pcre2_general_context_16 *)general_ctx;
+		pcre2_compile_context_16 *cctx = pcre2_compile_context_create_16(gctx);
+		PCRE2_SPTR16 p = (PCRE2_SPTR16)pattern.c_str();
 
-			if (greedy && level >= min) {
-				if (next)
-					res = next->test(s, res);
-				if (s.complete)
-					return res;
+		code = pcre2_compile_16(p, pattern.length(), flags, &err, &offset, cctx);
 
-				if (res >= 0 && parent->test_parent(s, res) >= 0)
-					return res;
-			}
+		if (!code) {
+			PCRE2_UCHAR16 buf[256];
+			pcre2_get_error_message_16(err, buf, 256);
+			String message = String::num(offset) + ": " + String((const CharType *)buf);
+			ERR_PRINT(message.utf8());
+			return FAILED;
 		}
-		return -1;
-	}
-};
-
-struct RegExNodeBackReference : public RegExNode {
 
-	int id;
+	} else {
 
-	RegExNodeBackReference(int p_id) {
-
-		length = -1;
-		quantifiable = true;
-		id = p_id;
-	}
+		pcre2_general_context_32 *gctx = (pcre2_general_context_32 *)general_ctx;
+		pcre2_compile_context_32 *cctx = pcre2_compile_context_create_32(gctx);
+		PCRE2_SPTR32 p = (PCRE2_SPTR32)pattern.c_str();
 
-	virtual int test(RegExSearch &s, int pos) const {
+		code = pcre2_compile_32(p, pattern.length(), flags, &err, &offset, cctx);
 
-		RegExMatch::Group &ref = s.match->captures[id];
-		for (int i = 0; i < ref.length; ++i) {
-
-			if (pos + i >= s.end)
-				return -1;
-
-			if (s.at(ref.start + i) != s.at(pos + i))
-				return -1;
+		if (!code) {
+			PCRE2_UCHAR32 buf[256];
+			pcre2_get_error_message_32(err, buf, 256);
+			String message = String::num(offset) + ": " + String((const CharType *)buf);
+			ERR_PRINT(message.utf8());
+			return FAILED;
 		}
-		return next ? next->test(s, pos + ref.length) : pos + ref.length;
 	}
-};
-
-struct RegExNodeGroup : public RegExNode {
-
-	bool inverse;
-	bool reset_pos;
-	Vector<RegExNode *> childset;
-	RegExNode *back;
-
-	RegExNodeGroup() {
-
-		length = 0;
-		quantifiable = true;
-		inverse = false;
-		reset_pos = false;
-		back = NULL;
-	}
-
-	virtual ~RegExNodeGroup() {
-
-		for (int i = 0; i < childset.size(); ++i)
-			memdelete(childset[i]);
-	}
-
-	virtual void test_success(RegExSearch &s, int pos) const {
+	return OK;
+}
 
-		return;
-	}
+Ref<RegExMatch> RegEx::search(const String &p_subject, int p_offset, int p_end) const {
 
-	virtual int test(RegExSearch &s, int pos) const {
+	ERR_FAIL_COND_V(!is_valid(), NULL);
 
-		for (int i = 0; i < childset.size(); ++i) {
+	Ref<RegExMatch> result = memnew(RegExMatch);
 
-			s.complete = false;
+	int length = p_subject.length();
+	if (p_end >= 0 && p_end < length)
+		length = p_end;
 
-			int res = childset[i]->test(s, pos);
+	if (sizeof(CharType) == 2) {
 
-			if (inverse) {
-				s.complete = false;
-				if (res < 0)
-					res = pos + 1;
-				else
-					return -1;
+		pcre2_code_16 *c = (pcre2_code_16 *)code;
+		pcre2_general_context_16 *gctx = (pcre2_general_context_16 *)general_ctx;
+		pcre2_match_context_16 *mctx = pcre2_match_context_create_16(gctx);
+		PCRE2_SPTR16 s = (PCRE2_SPTR16)p_subject.c_str();
 
-				if (i + 1 < childset.size())
-					continue;
-			}
+		pcre2_match_data_16 *match = pcre2_match_data_create_from_pattern_16(c, gctx);
 
-			if (s.complete)
-				return res;
+		int res = pcre2_match_16(c, s, length, p_offset, 0, match, mctx);
 
-			if (res >= 0) {
-				if (reset_pos)
-					res = pos;
-				this->test_success(s, res);
-				return next ? next->test(s, res) : res;
-			}
+		if (res < 0) {
+			pcre2_match_data_free_16(match);
+			return NULL;
 		}
-		return -1;
-	}
-
-	void add_child(RegExNode *node) {
 
-		node->parent = this;
-		node->previous = back;
+		uint32_t size = pcre2_get_ovector_count_16(match);
+		PCRE2_SIZE *ovector = pcre2_get_ovector_pointer_16(match);
 
-		if (back)
-			back->next = node;
-		else
-			childset.push_back(node);
+		result->data.resize(size);
 
-		increment_length(node->length);
+		for (uint32_t i = 0; i < size; i++) {
 
-		back = node;
-	}
-
-	void add_childset() {
-
-		if (childset.size() > 0)
-			length = -1;
-		back = NULL;
-	}
-
-	RegExNode *swap_back(RegExNode *node) {
-
-		RegExNode *old = back;
-
-		if (old) {
-			if (!old->previous)
-				childset.remove(childset.size() - 1);
-			back = old->previous;
-			increment_length(old->length, true);
+			result->data[i].start = ovector[i * 2];
+			result->data[i].end = ovector[i * 2 + 1];
 		}
 
-		add_child(node);
+		pcre2_match_data_free_16(match);
+		pcre2_match_context_free_16(mctx);
 
-		return old;
-	}
-};
+	} else {
 
-struct RegExNodeCapturing : public RegExNodeGroup {
+		pcre2_code_32 *c = (pcre2_code_32 *)code;
+		pcre2_general_context_32 *gctx = (pcre2_general_context_32 *)general_ctx;
+		pcre2_match_context_32 *mctx = pcre2_match_context_create_32(gctx);
+		PCRE2_SPTR32 s = (PCRE2_SPTR32)p_subject.c_str();
 
-	int id;
+		pcre2_match_data_32 *match = pcre2_match_data_create_from_pattern_32(c, gctx);
 
-	RegExNodeCapturing(int p_id = 0) {
+		int res = pcre2_match_32(c, s, length, p_offset, 0, match, mctx);
 
-		id = p_id;
-	}
-
-	virtual void test_success(RegExSearch &s, int pos) const {
-
-		RegExMatch::Group &ref = s.match->captures[id];
-		ref.length = pos - ref.start;
-	}
-
-	virtual int test(RegExSearch &s, int pos) const {
-
-		RegExMatch::Group &ref = s.match->captures[id];
-		int old_start = ref.start;
-		ref.start = pos;
-
-		int res = RegExNodeGroup::test(s, pos);
-
-		if (res < 0)
-			ref.start = old_start;
-		return res;
-	}
-
-	virtual int test_parent(RegExSearch &s, int pos) const {
-
-		RegExMatch::Group &ref = s.match->captures[id];
-		ref.length = pos - ref.start;
-		return RegExNode::test_parent(s, pos);
-	}
-
-	static Variant parse_name(const CharType *&c, bool p_allow_numeric) {
-
-		if (c[1] == '0') {
-			return -1;
-		} else if ('1' <= c[1] && c[1] <= '9') {
-			if (!p_allow_numeric)
-				return -1;
-			int res = (++c)[0] - '0';
-			while ('0' <= c[1] && c[1] <= '9')
-				res = res * 10 + int((++c)[0] - '0');
-			if ((++c)[0] != '>')
-				return -1;
-			return res;
-		} else if (iswalnum(c[1])) {
-			String res(++c, 1);
-			while (iswalnum(c[1]))
-				res += String(++c, 1);
-			if ((++c)[0] != '>')
-				return -1;
-			return res;
+		if (res < 0) {
+			pcre2_match_data_free_32(match);
+			return NULL;
 		}
-		return -1;
-	}
-};
-
-struct RegExNodeLookAhead : public RegExNodeGroup {
-
-	int id;
 
-	RegExNodeLookAhead(bool p_inverse, int p_id = 0) {
+		uint32_t size = pcre2_get_ovector_count_32(match);
+		PCRE2_SIZE *ovector = pcre2_get_ovector_pointer_32(match);
 
-		quantifiable = false;
-		inverse = p_inverse;
-		reset_pos = true;
-		id = p_id;
-	}
-
-	virtual int test(RegExSearch &s, int pos) const {
+		result->data.resize(size);
 
-		s.lookahead_pos[id] = pos;
-		return RegExNodeGroup::test(s, pos);
-	}
+		for (uint32_t i = 0; i < size; i++) {
 
-	virtual int test_parent(RegExSearch &s, int pos) const {
+			result->data[i].start = ovector[i * 2];
+			result->data[i].end = ovector[i * 2 + 1];
+		}
 
-		return RegExNode::test_parent(s, s.lookahead_pos[id]);
+		pcre2_match_data_free_32(match);
+		pcre2_match_context_free_32(mctx);
 	}
-};
 
-struct RegExNodeLookBehind : public RegExNodeGroup {
+	result->subject = p_subject;
 
-	RegExNodeLookBehind(bool p_inverse, int p_id = 0) {
+	uint32_t count;
+	const CharType *table;
+	uint32_t entry_size;
 
-		quantifiable = false;
-		inverse = p_inverse;
-		reset_pos = true;
-	}
+	_pattern_info(PCRE2_INFO_NAMECOUNT, &count);
+	_pattern_info(PCRE2_INFO_NAMETABLE, &table);
+	_pattern_info(PCRE2_INFO_NAMEENTRYSIZE, &entry_size);
 
-	virtual bool is_look_behind() { return true; }
+	for (int i = 0; i < count; i++) {
 
-	virtual int test(RegExSearch &s, int pos) const {
+		CharType id = table[i * entry_size];
+		if (result->data[id].start == -1)
+			continue;
+		String name = &table[i * entry_size + 1];
+		if (result->names.has(name))
+			continue;
 
-		if (pos < length)
-			return -1;
-		return RegExNodeGroup::test(s, pos - length);
+		result->names.insert(name, id);
 	}
-};
 
-struct RegExNodeBracket : public RegExNode {
+	return result;
+}
 
-	bool inverse;
-	Vector<RegExNode *> children;
+String RegEx::sub(const String &p_subject, const String &p_replacement, bool p_all, int p_offset, int p_end) const {
 
-	RegExNodeBracket() {
+	ERR_FAIL_COND_V(!is_valid(), String());
 
-		length = 1;
-		quantifiable = true;
-		inverse = false;
-	}
+	String output;
+	output.resize(p_subject.length());
 
-	virtual ~RegExNodeBracket() {
+	uint32_t flags = PCRE2_SUBSTITUTE_OVERFLOW_LENGTH;
+	if (p_all)
+		flags |= PCRE2_SUBSTITUTE_GLOBAL;
 
-		for (int i = 0; i < children.size(); ++i)
-			memdelete(children[i]);
-	}
+	PCRE2_SIZE olength = output.length();
 
-	virtual int test(RegExSearch &s, int pos) const {
+	PCRE2_SIZE length = p_subject.length();
+	if (p_end >= 0 && p_end < length)
+		length = p_end;
 
-		for (int i = 0; i < children.size(); ++i) {
+	if (sizeof(CharType) == 2) {
 
-			int res = children[i]->test(s, pos);
+		pcre2_code_16 *c = (pcre2_code_16 *)code;
+		pcre2_general_context_16 *gctx = (pcre2_general_context_16 *)general_ctx;
+		pcre2_match_context_16 *mctx = pcre2_match_context_create_16(gctx);
+		PCRE2_SPTR16 s = (PCRE2_SPTR16)p_subject.c_str();
+		PCRE2_SPTR16 r = (PCRE2_SPTR16)p_replacement.c_str();
+		PCRE2_UCHAR16 *o = (PCRE2_UCHAR16 *)output.c_str();
 
-			if (inverse) {
-				if (res < 0)
-					res = pos + 1;
-				else
-					return -1;
+		pcre2_match_data_16 *match = pcre2_match_data_create_from_pattern_16(c, gctx);
 
-				if (i + 1 < children.size())
-					continue;
-			}
+		int res = pcre2_substitute_16(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength);
 
-			if (res >= 0)
-				return next ? next->test(s, res) : res;
+		if (res == PCRE2_ERROR_NOMEMORY) {
+			output.resize(olength);
+			o = (PCRE2_UCHAR16 *)output.c_str();
+			res = pcre2_substitute_16(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength);
 		}
-		return -1;
-	}
 
-	void add_child(RegExNode *node) {
-
-		node->parent = this;
-		children.push_back(node);
-	}
+		pcre2_match_data_free_16(match);
+		pcre2_match_context_free_16(mctx);
 
-	void pop_back() {
-
-		memdelete(children[children.size() - 1]);
-		children.remove(children.size() - 1);
-	}
-};
-
-#define REGEX_EXPAND_FAIL(MSG) \
-	{                          \
-		ERR_PRINT(MSG);        \
-		return String();       \
-	}
-
-String RegExMatch::expand(const String &p_template) const {
-
-	String res;
-	for (const CharType *c = p_template.c_str(); *c != '\0'; ++c) {
-		if (c[0] == '\\') {
-			if (('1' <= c[1] && c[1] <= '9') || (c[1] == 'g' && c[2] == '{')) {
-
-				int ref = 0;
-				bool unclosed = false;
-
-				if (c[1] == 'g') {
-					unclosed = true;
-					c = &c[2];
-				}
-
-				while ('0' <= c[1] && c[1] <= '9') {
-					ref = ref * 10 + int(c[1] - '0');
-					++c;
-				}
-
-				if (unclosed) {
-					if (c[1] != '}')
-						REGEX_EXPAND_FAIL("unclosed backreference '{'");
-					++c;
-				}
-
-				res += get_string(ref);
-
-			} else if (c[1] == 'g' && c[2] == '<') {
-
-				const CharType *d = &c[2];
+		if (res < 0)
+			return String();
 
-				Variant name = RegExNodeCapturing::parse_name(d, true);
-				if (name == Variant(-1))
-					REGEX_EXPAND_FAIL("unrecognised character for group name");
+	} else {
 
-				c = d;
+		pcre2_code_32 *c = (pcre2_code_32 *)code;
+		pcre2_general_context_32 *gctx = (pcre2_general_context_32 *)general_ctx;
+		pcre2_match_context_32 *mctx = pcre2_match_context_create_32(gctx);
+		PCRE2_SPTR32 s = (PCRE2_SPTR32)p_subject.c_str();
+		PCRE2_SPTR32 r = (PCRE2_SPTR32)p_replacement.c_str();
+		PCRE2_UCHAR32 *o = (PCRE2_UCHAR32 *)output.c_str();
 
-				res += get_string(name);
+		pcre2_match_data_32 *match = pcre2_match_data_create_from_pattern_32(c, gctx);
 
-			} else {
+		int res = pcre2_substitute_32(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength);
 
-				const CharType *d = c;
-				CharType ch = RegExNodeChar::parse_escape(d);
-				if (c == d)
-					REGEX_EXPAND_FAIL("invalid escape token");
-				res += String(&ch, 1);
-				c = d;
-			}
-		} else {
-			res += String(c, 1);
+		if (res == PCRE2_ERROR_NOMEMORY) {
+			output.resize(olength);
+			o = (PCRE2_UCHAR32 *)output.c_str();
+			res = pcre2_substitute_32(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength);
 		}
-	}
-	return res;
-}
 
-int RegExMatch::get_group_count() const {
+		pcre2_match_data_free_32(match);
+		pcre2_match_context_free_32(mctx);
 
-	int count = 0;
-	for (int i = 1; i < captures.size(); ++i)
-		if (captures[i].name.get_type() == Variant::INT)
-			++count;
-	return count;
-}
-
-Array RegExMatch::get_group_array() const {
-
-	Array res;
-	for (int i = 1; i < captures.size(); ++i) {
-		const RegExMatch::Group &capture = captures[i];
-		if (capture.name.get_type() != Variant::INT)
-			continue;
-
-		if (capture.start >= 0)
-			res.push_back(string.substr(capture.start, capture.length));
-		else
-			res.push_back(String());
-	}
-	return res;
-}
-
-Array RegExMatch::get_names() const {
-
-	Array res;
-	for (int i = 1; i < captures.size(); ++i)
-		if (captures[i].name.get_type() == Variant::STRING)
-			res.push_back(captures[i].name);
-	return res;
-}
-
-Dictionary RegExMatch::get_name_dict() const {
-
-	Dictionary res;
-	for (int i = 1; i < captures.size(); ++i) {
-		const RegExMatch::Group &capture = captures[i];
-		if (capture.name.get_type() != Variant::STRING)
-			continue;
-
-		if (capture.start >= 0)
-			res[capture.name] = string.substr(capture.start, capture.length);
-		else
-			res[capture.name] = String();
-	}
-	return res;
-}
-
-String RegExMatch::get_string(const Variant &p_name) const {
-
-	for (int i = 0; i < captures.size(); ++i) {
-
-		const RegExMatch::Group &capture = captures[i];
-
-		if (capture.name != p_name)
-			continue;
-
-		if (capture.start == -1)
+		if (res < 0)
 			return String();
-
-		return string.substr(capture.start, capture.length);
 	}
-	return String();
-}
-
-int RegExMatch::get_start(const Variant &p_name) const {
 
-	for (int i = 0; i < captures.size(); ++i)
-		if (captures[i].name == p_name)
-			return captures[i].start;
-	return -1;
+	return output;
 }
 
-int RegExMatch::get_end(const Variant &p_name) const {
+bool RegEx::is_valid() const {
 
-	for (int i = 0; i < captures.size(); ++i)
-		if (captures[i].name == p_name)
-			return captures[i].start + captures[i].length;
-	return -1;
+	return (code != NULL);
 }
 
-RegExMatch::RegExMatch() {
-}
+String RegEx::get_pattern() const {
 
-static bool RegEx_is_shorthand(CharType ch) {
-
-	switch (ch) {
-		case 'w':
-		case 'W':
-		case 'd':
-		case 'D':
-		case 's':
-		case 'S':
-			return true;
-		default:
-			break;
-	}
-	return false;
+	return pattern;
 }
 
-#define REGEX_COMPILE_FAIL(MSG) \
-	{                           \
-		ERR_PRINT(MSG);         \
-		clear();                \
-		return FAILED;          \
-	}
+int RegEx::get_group_count() const {
 
-Error RegEx::compile(const String &p_pattern) {
+	ERR_FAIL_COND_V(!is_valid(), 0);
 
-	ERR_FAIL_COND_V(p_pattern.length() == 0, FAILED);
+	uint32_t count;
 
-	if (pattern == p_pattern && root)
-		return OK;
+	_pattern_info(PCRE2_INFO_CAPTURECOUNT, &count);
 
-	clear();
-	pattern = p_pattern;
-	group_names.push_back(0);
-	RegExNodeGroup *root_group = memnew(RegExNodeCapturing(0));
-	root = root_group;
-	Vector<RegExNodeGroup *> stack;
-	stack.push_back(root_group);
-	int lookahead_level = 0;
-	int numeric_groups = 0;
-	const int numeric_max = 9;
-
-	for (const CharType *c = p_pattern.c_str(); *c != '\0'; ++c) {
-
-		switch (c[0]) {
-			case '(':
-				if (c[1] == '?') {
-
-					RegExNodeGroup *group = NULL;
-					switch (c[2]) {
-						case ':':
-							c = &c[2];
-							group = memnew(RegExNodeGroup());
-							break;
-						case '!':
-						case '=':
-							group = memnew(RegExNodeLookAhead((c[2] == '!'), lookahead_level++));
-							if (lookahead_depth < lookahead_level)
-								lookahead_depth = lookahead_level;
-							c = &c[2];
-							break;
-						case '<':
-							if (c[3] == '!' || c[3] == '=') {
-								group = memnew(RegExNodeLookBehind((c[3] == '!'), lookahead_level++));
-								c = &c[3];
-							}
-							break;
-						case 'P':
-							if (c[3] == '<') {
-								const CharType *d = &c[3];
-								Variant name = RegExNodeCapturing::parse_name(d, false);
-								if (name == Variant(-1))
-									REGEX_COMPILE_FAIL("unrecognised character for group name");
-								group = memnew(RegExNodeCapturing(group_names.size()));
-								group_names.push_back(name);
-								c = d;
-							}
-						default:
-							break;
-					}
-					if (!group)
-						REGEX_COMPILE_FAIL("unrecognised qualifier for group");
-					stack[0]->add_child(group);
-					stack.insert(0, group);
-
-				} else if (numeric_groups < numeric_max) {
-
-					RegExNodeCapturing *group = memnew(RegExNodeCapturing(group_names.size()));
-					group_names.push_back(++numeric_groups);
-					stack[0]->add_child(group);
-					stack.insert(0, group);
-
-				} else {
-
-					RegExNodeGroup *group = memnew(RegExNodeGroup());
-					stack[0]->add_child(group);
-					stack.insert(0, group);
-				}
-				break;
-			case ')':
-				if (stack.size() == 1)
-					REGEX_COMPILE_FAIL("unexpected ')'");
-				stack.remove(0);
-				break;
-			case '\\':
-				if (('1' <= c[1] && c[1] <= '9') || (c[1] == 'g' && c[2] == '{')) {
-
-					int ref = 0;
-					bool unclosed = false;
-
-					if (c[1] == 'g') {
-						unclosed = true;
-						c = &c[2];
-					}
-
-					while ('0' <= c[1] && c[1] <= '9') {
-						ref = ref * 10 + int(c[1] - '0');
-						++c;
-					}
-
-					if (unclosed) {
-						if (c[1] != '}')
-							REGEX_COMPILE_FAIL("unclosed backreference '{'");
-						++c;
-					}
-
-					if (ref > numeric_groups || ref <= 0)
-						REGEX_COMPILE_FAIL("backreference not found");
-
-					for (int i = 0; i < stack.size(); ++i)
-						if (stack[i]->is_look_behind())
-							REGEX_COMPILE_FAIL("backreferences inside lookbehind not supported");
-
-					for (int i = 0; i < group_names.size(); ++i) {
-						if (group_names[i].get_type() == Variant::INT && int(group_names[i]) == ref) {
-							ref = group_names[i];
-							break;
-						}
-					}
-
-					stack[0]->add_child(memnew(RegExNodeBackReference(ref)));
-				}
-				if (c[1] == 'g' && c[2] == '<') {
-
-					const CharType *d = &c[2];
-
-					Variant name = RegExNodeCapturing::parse_name(d, true);
-					if (name == Variant(-1))
-						REGEX_COMPILE_FAIL("unrecognised character for group name");
-
-					c = d;
-
-					for (int i = 0; i < stack.size(); ++i)
-						if (stack[i]->is_look_behind())
-							REGEX_COMPILE_FAIL("backreferences inside lookbehind not supported");
-
-					int ref = -1;
-
-					for (int i = 0; i < group_names.size(); ++i) {
-						if (group_names[i].get_type() == Variant::INT && int(group_names[i]) == ref) {
-							ref = group_names[i];
-							break;
-						}
-					}
-
-					if (ref == -1)
-						REGEX_COMPILE_FAIL("backreference not found");
-
-					stack[0]->add_child(memnew(RegExNodeBackReference(ref)));
-
-				} else if (c[1] == 'b' || c[1] == 'B') {
-
-					stack[0]->add_child(memnew(RegExNodeWordBoundary(*(++c) == 'B')));
-
-				} else if (RegEx_is_shorthand(c[1])) {
-
-					stack[0]->add_child(memnew(RegExNodeShorthand(*(++c))));
-
-				} else {
-
-					const CharType *d = c;
-					CharType ch = RegExNodeChar::parse_escape(d);
-					if (c == d)
-						REGEX_COMPILE_FAIL("invalid escape token");
-					stack[0]->add_child(memnew(RegExNodeChar(ch)));
-					c = d;
-				}
-				break;
-			case '[': {
-				RegExNodeBracket *bracket = memnew(RegExNodeBracket());
-				stack[0]->add_child(bracket);
-				if (c[1] == '^') {
-					bracket->inverse = true;
-					++c;
-				}
-				bool first_child = true;
-				CharType previous_child;
-				bool previous_child_single = false;
-				while (true) {
-					++c;
-					if (!first_child && c[0] == ']') {
-
-						break;
-
-					} else if (c[0] == '\0') {
-
-						REGEX_COMPILE_FAIL("unclosed bracket expression '['");
-
-					} else if (c[0] == '\\') {
-
-						if (RegEx_is_shorthand(c[1])) {
-							bracket->add_child(memnew(RegExNodeShorthand(*(++c))));
-						} else {
-							const CharType *d = c;
-							CharType ch = RegExNodeChar::parse_escape(d);
-							if (c == d)
-								REGEX_COMPILE_FAIL("invalid escape token");
-							bracket->add_child(memnew(RegExNodeChar(ch)));
-							c = d;
-							previous_child = ch;
-							previous_child_single = true;
-						}
-
-					} else if (c[0] == ']' && c[1] == ':') {
-
-						const CharType *d = &c[2];
-						RegExNodeClass::Type type = RegExNodeClass::parse_type(d);
-						if (type != RegExNodeClass::Type_none) {
-
-							c = d;
-							previous_child_single = false;
-
-						} else {
-
-							bracket->add_child(memnew(RegExNodeChar('[')));
-							previous_child = '[';
-							previous_child_single = true;
-						}
-					} else if (previous_child_single && c[0] == '-') {
-
-						if (c[1] != '\0' && c[1] != ']') {
-
-							CharType next;
-
-							if (c[1] == '\\') {
-								const CharType *d = ++c;
-								next = RegExNodeChar::parse_escape(d);
-								if (c == d)
-									REGEX_COMPILE_FAIL("invalid escape token");
-							} else {
-								next = *(++c);
-							}
-
-							if (next < previous_child)
-								REGEX_COMPILE_FAIL("text range out of order");
-
-							bracket->pop_back();
-							bracket->add_child(memnew(RegExNodeRange(previous_child, next)));
-							previous_child_single = false;
-						} else {
-
-							bracket->add_child(memnew(RegExNodeChar('-')));
-							previous_child = '-';
-							previous_child_single = true;
-						}
-					} else {
-
-						bracket->add_child(memnew(RegExNodeChar(c[0])));
-						previous_child = c[0];
-						previous_child_single = true;
-					}
-					first_child = false;
-				}
-			} break;
-			case '|':
-				for (int i = 0; i < stack.size(); ++i)
-					if (stack[i]->is_look_behind())
-						REGEX_COMPILE_FAIL("alternations inside lookbehind not supported");
-				stack[0]->add_childset();
-				break;
-			case '^':
-				stack[0]->add_child(memnew(RegExNodeAnchorStart()));
-				break;
-			case '$':
-				stack[0]->add_child(memnew(RegExNodeAnchorEnd()));
-				break;
-			case '.':
-				stack[0]->add_child(memnew(RegExNodeShorthand('.')));
-				break;
-			case '?':
-			case '*':
-			case '+':
-			case '{': {
-				int min_val = 0;
-				int max_val = -1;
-				bool valid = true;
-				const CharType *d = c;
-				bool max_set = true;
-				switch (c[0]) {
-					case '?':
-						min_val = 0;
-						max_val = 1;
-						break;
-					case '*':
-						min_val = 0;
-						max_val = -1;
-						break;
-					case '+':
-						min_val = 1;
-						max_val = -1;
-						break;
-					case '{':
-						max_set = false;
-						while (valid) {
-							++d;
-							if (d[0] == '}') {
-								break;
-							} else if (d[0] == ',') {
-								max_set = true;
-							} else if ('0' <= d[0] && d[0] <= '9') {
-								if (max_set) {
-									if (max_val < 0)
-										max_val = int(d[0] - '0');
-									else
-										max_val = max_val * 10 + int(d[0] - '0');
-								} else {
-									min_val = min_val * 10 + int(d[0] - '0');
-								}
-							} else {
-								valid = false;
-							}
-						}
-						break;
-					default:
-						break;
-				}
-
-				if (!max_set)
-					max_val = min_val;
-
-				if (valid) {
-
-					c = d;
-
-					if (stack[0]->back == NULL || !stack[0]->back->quantifiable)
-						REGEX_COMPILE_FAIL("element not quantifiable");
-
-					if (min_val != max_val)
-						for (int i = 0; i < stack.size(); ++i)
-							if (stack[i]->is_look_behind())
-								REGEX_COMPILE_FAIL("variable length quantifiers inside lookbehind not supported");
-
-					RegExNodeQuantifier *quant = memnew(RegExNodeQuantifier(min_val, max_val));
-					quant->child = stack[0]->swap_back(quant);
-					quant->child->previous = NULL;
-					quant->child->parent = quant;
-
-					if (min_val == max_val && quant->child->length >= 0)
-						quant->length = max_val * quant->child->length;
-
-					if (c[1] == '?') {
-						quant->greedy = false;
-						++c;
-					}
-					break;
-				}
-			}
-			default:
-				stack[0]->add_child(memnew(RegExNodeChar(c[0])));
-				break;
-		}
-	}
-	if (stack.size() > 1)
-		REGEX_COMPILE_FAIL("unclosed group '('");
-	return OK;
+	return count;
 }
 
-Ref<RegExMatch> RegEx::search(const String &p_text, int p_start, int p_end) const {
-
-	ERR_FAIL_COND_V(!is_valid(), NULL);
-	ERR_FAIL_COND_V(p_start < 0, NULL);
-	ERR_FAIL_COND_V(p_start >= p_text.length(), NULL);
-	ERR_FAIL_COND_V(p_end > p_text.length(), NULL);
-	ERR_FAIL_COND_V(p_end != -1 && p_end < p_start, NULL);
+Array RegEx::get_names() const {
 
-	Ref<RegExMatch> res = memnew(RegExMatch());
+	Array result;
 
-	for (int i = 0; i < group_names.size(); ++i) {
-		RegExMatch::Group group;
-		group.name = group_names[i];
-		res->captures.push_back(group);
-	}
+	ERR_FAIL_COND_V(!is_valid(), result);
 
-	res->string = p_text;
+	uint32_t count;
+	const CharType *table;
+	uint32_t entry_size;
 
-	if (p_end == -1)
-		p_end = p_text.length();
+	_pattern_info(PCRE2_INFO_NAMECOUNT, &count);
+	_pattern_info(PCRE2_INFO_NAMETABLE, &table);
+	_pattern_info(PCRE2_INFO_NAMEENTRYSIZE, &entry_size);
 
-	RegExSearch s(res, p_end, lookahead_depth);
+	for (int i = 0; i < count; i++) {
 
-	for (int i = p_start; i <= s.end; ++i) {
-		for (int c = 0; c < group_names.size(); ++c) {
-			res->captures[c].start = -1;
-			res->captures[c].length = 0;
+		String name = &table[i * entry_size + 1];
+		if (result.find(name) < 0) {
+			result.append(name);
 		}
-		if (root->test(s, i) >= 0)
-			break;
 	}
 
-	if (res->captures[0].start >= 0)
-		return res;
-	return NULL;
+	return result;
 }
 
-String RegEx::sub(const String &p_text, const String &p_replacement, bool p_all, int p_start, int p_end) const {
-
-	ERR_FAIL_COND_V(!is_valid(), p_text);
-	ERR_FAIL_COND_V(p_start < 0, p_text);
-	ERR_FAIL_COND_V(p_start >= p_text.length(), p_text);
-	ERR_FAIL_COND_V(p_end > p_text.length(), p_text);
-	ERR_FAIL_COND_V(p_end != -1 && p_end < p_start, p_text);
-
-	String text = p_text;
-	int start = p_start;
-
-	if (p_end == -1)
-		p_end = p_text.length();
-
-	while (start < text.length() && (p_all || start == p_start)) {
-
-		Ref<RegExMatch> m = search(text, start, p_end);
-
-		RegExMatch::Group &s = m->captures[0];
-
-		if (s.start < 0)
-			break;
-
-		String res = text.substr(0, s.start) + m->expand(p_replacement);
-
-		start = res.length();
+RegEx::RegEx() {
 
-		if (s.length == 0)
-			++start;
+	if (sizeof(CharType) == 2) {
 
-		int sub_end = s.start + s.length;
-		if (sub_end < text.length())
-			res += text.substr(sub_end, text.length() - sub_end);
+		general_ctx = pcre2_general_context_create_16(&_regex_malloc, &_regex_free, NULL);
 
-		p_end += res.length() - text.length();
+	} else {
 
-		text = res;
+		general_ctx = pcre2_general_context_create_32(&_regex_malloc, &_regex_free, NULL);
 	}
-	return text;
+	code = NULL;
 }
 
-void RegEx::clear() {
-
-	if (root)
-		memdelete(root);
-
-	root = NULL;
-	group_names.clear();
-	lookahead_depth = 0;
-}
-
-bool RegEx::is_valid() const {
-
-	return (root != NULL);
-}
-
-String RegEx::get_pattern() const {
-
-	return pattern;
-}
-
-int RegEx::get_group_count() const {
-
-	int count = 0;
-	for (int i = 1; i < group_names.size(); ++i)
-		if (group_names[i].get_type() == Variant::INT)
-			++count;
-	return count;
-}
-
-Array RegEx::get_names() const {
+RegEx::RegEx(const String &p_pattern) {
 
-	Array res;
-	for (int i = 1; i < group_names.size(); ++i)
-		if (group_names[i].get_type() == Variant::STRING)
-			res.push_back(group_names[i]);
-	return res;
-}
+	if (sizeof(CharType) == 2) {
 
-RegEx::RegEx() {
+		general_ctx = pcre2_general_context_create_16(&_regex_malloc, &_regex_free, NULL);
 
-	root = NULL;
-	lookahead_depth = 0;
-}
+	} else {
 
-RegEx::RegEx(const String &p_pattern) {
-
-	root = NULL;
+		general_ctx = pcre2_general_context_create_32(&_regex_malloc, &_regex_free, NULL);
+	}
+	code = NULL;
 	compile(p_pattern);
 }
 
 RegEx::~RegEx() {
 
-	if (root)
-		memdelete(root);
-}
+	if (sizeof(CharType) == 2) {
 
-void RegExMatch::_bind_methods() {
+		if (code)
+			pcre2_code_free_16((pcre2_code_16 *)code);
+		pcre2_general_context_free_16((pcre2_general_context_16 *)general_ctx);
 
-	ClassDB::bind_method(D_METHOD("expand", "template"), &RegExMatch::expand);
-	ClassDB::bind_method(D_METHOD("get_group_count"), &RegExMatch::get_group_count);
-	ClassDB::bind_method(D_METHOD("get_group_array"), &RegExMatch::get_group_array);
-	ClassDB::bind_method(D_METHOD("get_names"), &RegExMatch::get_names);
-	ClassDB::bind_method(D_METHOD("get_name_dict"), &RegExMatch::get_name_dict);
-	ClassDB::bind_method(D_METHOD("get_string", "name"), &RegExMatch::get_string, DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_start", "name"), &RegExMatch::get_start, DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_end", "name"), &RegExMatch::get_end, DEFVAL(0));
+	} else {
+
+		if (code)
+			pcre2_code_free_32((pcre2_code_32 *)code);
+		pcre2_general_context_free_32((pcre2_general_context_32 *)general_ctx);
+	}
 }
 
 void RegEx::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("clear"), &RegEx::clear);
 	ClassDB::bind_method(D_METHOD("compile", "pattern"), &RegEx::compile);
-	ClassDB::bind_method(D_METHOD("search", "text", "start", "end"), &RegEx::search, DEFVAL(0), DEFVAL(-1));
-	ClassDB::bind_method(D_METHOD("sub", "text", "replacement", "all", "start", "end"), &RegEx::sub, DEFVAL(false), DEFVAL(0), DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("search", "subject", "offset", "end"), &RegEx::search, DEFVAL(0), DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("sub", "subject", "replacement", "all", "offset", "end"), &RegEx::sub, DEFVAL(false), DEFVAL(0), DEFVAL(-1));
 	ClassDB::bind_method(D_METHOD("is_valid"), &RegEx::is_valid);
 	ClassDB::bind_method(D_METHOD("get_pattern"), &RegEx::get_pattern);
 	ClassDB::bind_method(D_METHOD("get_group_count"), &RegEx::get_group_count);
 	ClassDB::bind_method(D_METHOD("get_names"), &RegEx::get_names);
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "pattern"), "compile", "get_pattern");
 }
diff --git a/modules/regex/regex.h b/modules/regex/regex.h
index 106d2649a5..f09826932d 100644
--- a/modules/regex/regex.h
+++ b/modules/regex/regex.h
@@ -31,59 +31,53 @@
 #ifndef REGEX_H
 #define REGEX_H
 
+#include "core/array.h"
 #include "core/dictionary.h"
+#include "core/map.h"
 #include "core/reference.h"
-#include "core/resource.h"
 #include "core/ustring.h"
 #include "core/vector.h"
 
-class RegExNode;
-
 class RegExMatch : public Reference {
 
 	GDCLASS(RegExMatch, Reference);
 
-	struct Group {
-		Variant name;
+	struct Range {
 		int start;
-		int length;
+		int end;
 	};
 
-	Vector<Group> captures;
-	String string;
+	String subject;
+	Vector<Range> data;
+	Map<String, int> names;
 
 	friend class RegEx;
-	friend class RegExSearch;
-	friend class RegExNodeCapturing;
-	friend class RegExNodeBackReference;
 
 protected:
 	static void _bind_methods();
 
-public:
-	String expand(const String &p_template) const;
+	int _find(const Variant &p_name) const;
 
+public:
+	String get_subject() const;
 	int get_group_count() const;
-	Array get_group_array() const;
-
-	Array get_names() const;
-	Dictionary get_name_dict() const;
+	Dictionary get_names() const;
 
+	Array get_strings() const;
 	String get_string(const Variant &p_name) const;
 	int get_start(const Variant &p_name) const;
 	int get_end(const Variant &p_name) const;
-
-	RegExMatch();
 };
 
-class RegEx : public Resource {
+class RegEx : public Reference {
 
-	GDCLASS(RegEx, Resource);
+	GDCLASS(RegEx, Reference);
 
-	RegExNode *root;
-	Vector<Variant> group_names;
+	void *general_ctx;
+	void *code;
 	String pattern;
-	int lookahead_depth;
+
+	void _pattern_info(uint32_t what, void *where) const;
 
 protected:
 	static void _bind_methods();
@@ -91,9 +85,10 @@ protected:
 public:
 	void clear();
 	Error compile(const String &p_pattern);
+	void _init(const String &p_pattern = "");
 
-	Ref<RegExMatch> search(const String &p_text, int p_start = 0, int p_end = -1) const;
-	String sub(const String &p_text, const String &p_replacement, bool p_all = false, int p_start = 0, int p_end = -1) const;
+	Ref<RegExMatch> search(const String &p_subject, int offset = 0, int end = -1) const;
+	String sub(const String &p_subject, const String &p_replacement, bool p_all = false, int p_start = 0, int p_end = -1) const;
 
 	bool is_valid() const;
 	String get_pattern() const;