RegEx re-implemented as a module

Re-wrote nrex as a module using godot-specific parts and new
features:

 * Added string substitutions.
 * Named groups are now supported.
 * Removed use of mutable variables in RegEx. RegExMatch is returned
   instead.

6 files changed, 1668 insertions, 0 deletions

diff --git a/modules/regex/SCsub b/modules/regex/SCsub
new file mode 100644
index 0000000000..0882406761
--- /dev/null
+++ b/modules/regex/SCsub
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+Import('env')
+
+env.add_source_files(env.modules_sources, "*.cpp")
+
+Export('env')
diff --git a/modules/regex/config.py b/modules/regex/config.py
new file mode 100644
index 0000000000..667b5d8ba6
--- /dev/null
+++ b/modules/regex/config.py
@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+def can_build(platform):
+    return True
+
+def configure(env):
+    pass
+
diff --git a/modules/regex/regex.cpp b/modules/regex/regex.cpp
new file mode 100644
index 0000000000..8f26d764c4
--- /dev/null
+++ b/modules/regex/regex.cpp
@@ -0,0 +1,1465 @@
+/*************************************************************************/
+/*  regex.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "regex.h"
+#include <wctype.h>
+#include <wchar.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);
+	}
+
+	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;
+		}
+
+		if (parent)
+			parent->increment_length(amount, subtract);
+
+	}
+
+};
+
+struct RegExNodeChar : public RegExNode {
+
+	CharType ch;
+
+	RegExNodeChar(CharType p_char) {
+
+		length = 1;
+		quantifiable = true;
+		ch = p_char;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (s.end <= pos || 0 > pos || s.at(pos) != ch)
+			return -1;
+
+		return next ? next->test(s, pos + 1) : pos + 1;
+	}
+
+	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];
+	}
+};
+
+struct RegExNodeRange : public RegExNode {
+
+	CharType start;
+	CharType end;
+
+	RegExNodeRange(CharType p_start, CharType p_end) {
+
+		length = 1;
+		quantifiable = true;
+		start = p_start;
+		end = p_end;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (s.end <= pos || 0 > pos)
+			return -1;
+
+		CharType c = s.at(pos);
+		if (c < start || end < c)
+			return -1;
+
+		return next ? next->test(s, pos + 1) : pos + 1;
+	}
+};
+
+struct RegExNodeShorthand : public RegExNode {
+
+	CharType repr;
+
+	RegExNodeShorthand(CharType p_repr) {
+
+		length = 1;
+		quantifiable = true;
+		repr = p_repr;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (s.end <= pos || 0 > pos)
+			return -1;
+
+		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;
+		}
+
+		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 (0x1F < c && c < 0x1F);
+			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;
+		}
+		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() {
+
+		length = 0;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (pos != 0)
+			return -1;
+
+		return next ? next->test(s, pos) : pos;
+	}
+};
+
+struct RegExNodeAnchorEnd : public RegExNode {
+
+	RegExNodeAnchorEnd() {
+
+		length = 0;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (pos != s.eof)
+			return -1;
+
+		return next ? next->test(s, pos) : pos;
+	}
+};
+
+struct RegExNodeWordBoundary : public RegExNode {
+
+	bool inverse;
+
+	RegExNodeWordBoundary(bool p_inverse) {
+
+		length = 0;
+		inverse = p_inverse;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		bool left = false;
+		bool right = false;
+
+		if (pos != 0) {
+			CharType c = s.at(pos - 1);
+			if (c == '_' || iswalnum(c))
+				left = true;
+		}
+
+		if (pos != s.eof) {
+			CharType c = s.at(pos);
+			if (c == '_' || iswalnum(c))
+				right = true;
+		}
+
+		if ((left == right) != inverse)
+			return -1;
+
+		return next ? next->test(s, pos) : pos;
+	}
+};
+
+struct RegExNodeQuantifier : public RegExNode {
+
+	int min;
+	int max;
+	bool greedy;
+	RegExNode* child;
+
+	RegExNodeQuantifier(int p_min, int p_max) {
+
+		min = p_min;
+		max = p_max;
+		greedy = true;
+		child = NULL;
+	}
+
+	~RegExNodeQuantifier() {
+
+		if (child)
+			memdelete(child);
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		return test_step(s, pos, 0, pos);
+	}
+
+	virtual int test_parent(RegExSearch& s, int pos) const {
+
+		s.complete = false;
+		return pos;
+	}
+
+	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;
+
+		int res = pos;
+		if (level >= 1) {
+			if (level > min + 1 && pos == start)
+				return -1;
+
+			res = child->test(s, pos);
+			if (s.complete)
+				return res;
+		}
+
+		if (res >= 0) {
+
+			int res_step = test_step(s, res, level + 1, start);
+			if (res_step >= 0)
+				return res_step;
+
+			if (greedy && level >= min) {
+				if (next)
+					res = next->test(s, res);
+				if (s.complete)
+					return res;
+
+				if (res >= 0 && parent->test_parent(s, res) >= 0)
+					return res;
+			}
+		}
+		return -1;
+	}
+};
+
+struct RegExNodeBackReference : public RegExNode {
+
+	int id;
+
+	RegExNodeBackReference(int p_id) {
+
+		length = -1;
+		quantifiable = true;
+		id = p_id;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		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;
+		}
+		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 int test(RegExSearch& s, int pos) const {
+
+		for (int i = 0; i < childset.size(); ++i) {
+
+			s.complete = false;
+
+			int res = childset[i]->test(s, pos);
+
+			if (s.complete)
+				return res;
+
+			if (inverse) {
+				if (res < 0)
+					res = pos + 1;
+				else
+					return -1;
+
+				if (i + 1 < childset.size())
+					continue;
+			}
+
+			if (res >= 0) {
+				if (reset_pos)
+					res = pos;
+				return next ? next->test(s, res) : res;
+			}
+		}
+		return -1;
+	}
+
+	void add_child(RegExNode* node) {
+
+		node->parent = this;
+		node->previous = back;
+
+		if (back)
+			back->next = node;
+		else
+			childset.push_back(node);
+
+		increment_length(node->length);
+
+		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);
+		}
+
+		add_child(node);
+
+		return old;
+	}
+};
+
+struct RegExNodeCapturing : public RegExNodeGroup {
+
+	int id;
+
+	RegExNodeCapturing(int p_id = 0) {
+
+		id = p_id;
+	}
+
+	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) {
+			if (!s.complete)
+				ref.length = res - pos;
+		} else {
+			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;
+		}
+		return -1;
+	}
+};
+
+struct RegExNodeLookAhead : public RegExNodeGroup {
+
+	int id;
+
+	RegExNodeLookAhead(bool p_inverse, int p_id = 0) {
+
+		quantifiable = false;
+		inverse = p_inverse;
+		reset_pos = true;
+		id = p_id;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		s.lookahead_pos[id] = pos;
+		return RegExNodeGroup::test(s, pos);
+	}
+
+	virtual int test_parent(RegExSearch& s, int pos) const {
+
+		return RegExNode::test_parent(s, s.lookahead_pos[id]);
+	}
+};
+
+struct RegExNodeLookBehind : public RegExNodeGroup {
+
+	RegExNodeLookBehind(bool p_inverse, int p_id = 0) {
+
+		quantifiable = false;
+		inverse = p_inverse;
+		reset_pos = true;
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		if (pos < length)
+			return -1;
+		return RegExNodeGroup::test(s, pos - length);
+	}
+};
+
+struct RegExNodeBracket : public RegExNode {
+
+	bool inverse;
+	Vector<RegExNode*> children;
+
+	RegExNodeBracket() {
+
+		length = 1;
+		quantifiable = true;
+		inverse = false;
+	}
+
+	virtual ~RegExNodeBracket() {
+
+		for (int i = 0; i < children.size(); ++i)
+			memdelete(children[i]);
+	}
+
+	virtual int test(RegExSearch& s, int pos) const {
+
+		for (int i = 0; i < children.size(); ++i) {
+
+			int res = children[i]->test(s, pos);
+
+			if (inverse) {
+				if (res < 0)
+					res = pos + 1;
+				else
+					return -1;
+
+				if (i + 1 < children.size())
+					continue;
+			}
+
+			if (res >= 0)
+				return next ? next->test(s, res) : res;
+		}
+		return -1;
+	}
+
+	void add_child(RegExNode* node) {
+
+		node->parent = this;
+		children.push_back(node);
+	}
+
+	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];
+
+				Variant name = RegExNodeCapturing::parse_name(d, true);
+				if (name == Variant(-1))
+					REGEX_EXPAND_FAIL("unrecognised character for group name");
+
+				c = d;
+
+				res += get_string(name);
+
+			} else {
+
+				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);
+		}
+	}
+	return res;
+}
+
+int RegExMatch::get_group_count() const {
+
+	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)
+			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;
+}
+
+int RegExMatch::get_end(const Variant& p_name) const {
+
+	for (int i = 0; i < captures.size(); ++i)
+		if (captures[i].name == p_name)
+			return captures[i].start + captures[i].length;
+	return -1;
+}
+
+RegExMatch::RegExMatch() {
+
+}
+
+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;
+}
+
+#define REGEX_COMPILE_FAIL(MSG)\
+{\
+	ERR_PRINT(MSG);\
+	clear();\
+	return FAILED;\
+}
+
+Error RegEx::compile(const String& p_pattern) {
+
+	if (pattern == p_pattern)
+		return OK;
+
+	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 (dynamic_cast<RegExNodeLookBehind*>(stack[i]))
+							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 (dynamic_cast<RegExNodeLookBehind*>(stack[i]))
+							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 (dynamic_cast<RegExNodeLookBehind*>(stack[i]))
+						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 (dynamic_cast<RegExNodeLookBehind*>(stack[i]))
+									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;
+}
+
+Ref<RegExMatch> RegEx::search(const String& p_text, int p_start, int p_end) const {
+
+	Ref<RegExMatch> res = memnew(RegExMatch());
+
+	for (int i = 0; i < group_names.size(); ++i) {
+		RegExMatch::Group group;
+		group.name = group_names[i];
+		res->captures.push_back(group);
+	}
+
+	res->string = p_text;
+
+	if (p_end < p_start || p_end > p_text.length())
+		p_end = p_text.length();
+
+	RegExSearch s(res, p_end, lookahead_depth);
+
+	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;
+		}
+		if (root->test(s, i) >= 0)
+			break;
+	}
+
+	if (res->captures[0].start >= 0)
+		return res;
+	return NULL;
+}
+
+String RegEx::sub(const String& p_text, const String& p_template, int p_start, int p_end) const {
+
+	Ref<RegExMatch> m = search(p_text, p_start, p_end);
+	RegExMatch::Group& s = m->captures[0];
+	if (s.start >= 0) {
+		String res = p_text.substr(0, s.start) + m->expand(p_template);
+		int end = s.start + s.length;
+		if (end < p_text.length())
+			res += p_text.substr(end, p_text.length() - end);
+		return res;
+	}
+	return p_text;
+}
+
+void RegEx::clear() {
+
+	if (root)
+		memdelete(root);
+
+	pattern.clear();
+	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 {
+
+	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;
+}
+
+RegEx::RegEx() {
+
+	root = NULL;
+	lookahead_depth = 0;
+}
+
+RegEx::RegEx(const String& p_pattern) {
+
+	root = NULL;
+	compile(p_pattern);
+}
+
+RegEx::~RegEx() {
+
+	if (root)
+		memdelete(root);
+}
+
+void RegExMatch::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("expand","template"),&RegExMatch::expand);
+	ObjectTypeDB::bind_method(_MD("get_group_count"),&RegExMatch::get_group_count);
+	ObjectTypeDB::bind_method(_MD("get_group_array"),&RegExMatch::get_group_array);
+	ObjectTypeDB::bind_method(_MD("get_names"),&RegExMatch::get_names);
+	ObjectTypeDB::bind_method(_MD("get_name_dict"),&RegExMatch::get_name_dict);
+	ObjectTypeDB::bind_method(_MD("get_string","name"),&RegExMatch::get_string, DEFVAL(0));
+	ObjectTypeDB::bind_method(_MD("get_start","name"),&RegExMatch::get_start, DEFVAL(0));
+	ObjectTypeDB::bind_method(_MD("get_end","name"),&RegExMatch::get_end, DEFVAL(0));
+}
+
+void RegEx::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("clear"),&RegEx::clear);
+	ObjectTypeDB::bind_method(_MD("compile","pattern"),&RegEx::compile);
+	ObjectTypeDB::bind_method(_MD("search","text","start","end"),&RegEx::search, DEFVAL(0), DEFVAL(-1));
+	ObjectTypeDB::bind_method(_MD("sub","text","template","start","end"),&RegEx::sub, DEFVAL(0), DEFVAL(-1));
+	ObjectTypeDB::bind_method(_MD("is_valid"),&RegEx::is_valid);
+	ObjectTypeDB::bind_method(_MD("get_pattern"),&RegEx::get_pattern);
+	ObjectTypeDB::bind_method(_MD("get_group_count"),&RegEx::get_group_count);
+	ObjectTypeDB::bind_method(_MD("get_names"),&RegEx::get_names);
+}
+
diff --git a/modules/regex/regex.h b/modules/regex/regex.h
new file mode 100644
index 0000000000..283368c34f
--- /dev/null
+++ b/modules/regex/regex.h
@@ -0,0 +1,114 @@
+/*************************************************************************/
+/*  regex.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef REGEX_H
+#define REGEX_H
+
+#include "core/vector.h"
+#include "core/ustring.h"
+#include "core/dictionary.h"
+#include "core/reference.h"
+#include "core/resource.h"
+
+class RegExNode;
+
+class RegExMatch : public Reference {
+
+	OBJ_TYPE(RegExMatch, Reference);
+
+	struct Group {
+		Variant name;
+		int start;
+		int length;
+	};
+
+	Vector<Group> captures;
+	String string;
+
+	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 get_group_count() const;
+	Array get_group_array() const;
+
+	Array get_names() const;
+	Dictionary get_name_dict() 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 Reference {
+
+	OBJ_TYPE(RegEx, Reference);
+
+	RegExNode* root;
+	Vector<Variant> group_names;
+	String pattern;
+	int lookahead_depth;
+
+protected:
+
+	static void _bind_methods();
+
+public:
+
+	void clear();
+	Error compile(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_template, int p_start = 0, int p_end = -1) const;
+
+	bool is_valid() const;
+	String get_pattern() const;
+	int get_group_count() const;
+	Array get_names() const;
+
+	RegEx();
+	RegEx(const String& p_pattern);
+	~RegEx();
+
+};
+
+#endif // REGEX_H
+
diff --git a/modules/regex/register_types.cpp b/modules/regex/register_types.cpp
new file mode 100644
index 0000000000..050cf3efff
--- /dev/null
+++ b/modules/regex/register_types.cpp
@@ -0,0 +1,43 @@
+/*************************************************************************/
+/*  register_types.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "register_types.h"
+#include "object_type_db.h"
+#include "regex.h"
+
+void register_regex_types() {
+
+	ObjectTypeDB::register_type<RegExMatch>();
+	ObjectTypeDB::register_type<RegEx>();
+}
+
+void unregister_regex_types() {
+
+}
+
diff --git a/modules/regex/register_types.h b/modules/regex/register_types.h
new file mode 100644
index 0000000000..df3b508e14
--- /dev/null
+++ b/modules/regex/register_types.h
@@ -0,0 +1,31 @@
+/*************************************************************************/
+/*  register_types.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+void register_regex_types();
+void unregister_regex_types();