Regex library Nrex initial port

17 files changed, 1254 insertions, 1206 deletions

diff --git a/bin/tests/test_string.cpp b/bin/tests/test_string.cpp
index 3c8d0f7d86..7b512a5d99 100644
--- a/bin/tests/test_string.cpp
+++ b/bin/tests/test_string.cpp
@@ -31,7 +31,7 @@
 //#include "math_funcs.h"
 #include <stdio.h>
 #include "os/os.h"
-#include "drivers/trex/regex.h"
+#include "drivers/nrex/regex.h"
 
 #include "test_string.h"
 
@@ -463,20 +463,16 @@ bool test_26() {
 
 	OS::get_singleton()->print("\n\nTest 26: RegEx\n");
 	RegEx regexp("(.*):(.*)");
-	List<String> captures;
 
-	bool match = regexp.match("name:password", &captures);
-	printf("\tmatch: %s\n", match?"true":"false");
+	bool res = regexp.match("name:password");
+	printf("\tmatch: %s\n", res?"true":"false");
 
-	printf("\t%i captures:\n", captures.size());
-	List<String>::Element *I = captures.front();
-	while (I) {
-
-		printf("%ls\n", I->get().c_str());
-
-		I = I->next();
-	};
-	return captures.size();
+	printf("\t%i captures:\n", regexp.get_capture_count());
+	for (int i = 0; i<regexp.get_capture_count(); i++)
+	{
+		printf("%ls\n", regexp.get_capture(i).c_str());
+	}
+	return res;
 };
 
 struct test_27_data {
diff --git a/drivers/SCsub b/drivers/SCsub
index 6ab0973625..3028139f50 100644
--- a/drivers/SCsub
+++ b/drivers/SCsub
@@ -29,7 +29,7 @@ if (env["openssl"]=="builtin"):
 
 SConscript("rtaudio/SCsub");
 SConscript("nedmalloc/SCsub");
-SConscript("trex/SCsub");
+SConscript("nrex/SCsub");
 SConscript("chibi/SCsub");
 if (env["vorbis"]=="yes" or env["speex"]=="yes" or env["theora"]=="yes"):
         SConscript("ogg/SCsub");
diff --git a/drivers/nrex/README.md b/drivers/nrex/README.md
new file mode 100644
index 0000000000..f150a5d76f
--- /dev/null
+++ b/drivers/nrex/README.md
@@ -0,0 +1,64 @@
+# NREX: Node RegEx
+
+Small node-based regular expression library. It only does text pattern
+matchhing, not replacement. To use add the files `nrex.hpp`, `nrex.cpp`
+and `nrex_config.h` to your project and follow the example:
+
+	nrex regex;
+	regex.compile("^(fo+)bar$");
+
+	nrex_result captures[regex.capture_size()];
+	if (regex.match("foobar", captures))
+	{
+		std::cout << captures[0].start << std::endl;
+		std::cout << captures[0].length << std::endl;
+	}
+
+More details about its use is documented in `nrex.hpp`
+
+Currently supported features:
+ * Capturing `()` and non-capturing `(?:)` groups
+ * Any character `.`
+ * Shorthand caracter classes `\w\W\s\S\d\D`
+ * User-defined character classes such as `[A-Za-z]`
+ * Simple quantifiers `?`, `*` and `+`
+ * Range quantifiers `{0,1}`
+ * Lazy (non-greedy) quantifiers `*?`
+ * Begining `^` and end `$` anchors
+ * Alternation `|`
+ * Backreferences `\1` to `\99`
+
+To do list:
+ * Unicode `\uFFFF` code points
+
+## License
+
+Copyright (c) 2015, Zher Huei Lee
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/drivers/trex/SCsub b/drivers/nrex/SCsub
index 877be8e3d9..2441d3061b 100644
--- a/drivers/trex/SCsub
+++ b/drivers/nrex/SCsub
@@ -2,8 +2,7 @@
 Import('env')
 
 sources = [
-
-	'trex.c',
+	'nrex.cpp',
 	'regex.cpp',
 ]
 env.add_source_files(env.drivers_sources, sources)
diff --git a/drivers/nrex/nrex.cpp b/drivers/nrex/nrex.cpp
new file mode 100644
index 0000000000..03e5334ed9
--- /dev/null
+++ b/drivers/nrex/nrex.cpp
@@ -0,0 +1,902 @@
+//  NREX: Node RegEx
+//
+//  Copyright (c) 2015, Zher Huei Lee
+//  All rights reserved.
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//   1. The origin of this software must not be misrepresented; you must not
+//      claim that you wrote the original software. If you use this software
+//      in a product, an acknowledgment in the product documentation would
+//      be appreciated but is not required.
+//
+//   2. Altered source versions must be plainly marked as such, and must not
+//      be misrepresented as being the original software.
+//
+//   3. This notice may not be removed or altered from any source
+//      distribution.
+//
+
+#include "nrex.hpp"
+
+#ifdef NREX_UNICODE
+#include <wctype.h>
+#include <wchar.h>
+#define NREX_ISALPHANUM iswalnum
+#define NREX_STRLEN wcslen
+#else
+#include <ctype.h>
+#include <string.h>
+#define NREX_ISALPHANUM isalnum
+#define NREX_STRLEN strlen
+#endif
+
+#ifdef NREX_THROW_ERROR
+#define NREX_COMPILE_ERROR(M) throw nrex_compile_error(M)
+#else
+#define NREX_COMPILE_ERROR(M) reset(); return false
+#endif
+
+#ifndef NREX_NEW
+#define NREX_NEW(X) new X
+#define NREX_NEW_ARRAY(X, N) new X[N]
+#define NREX_DELETE(X) delete X
+#define NREX_DELETE_ARRAY(X) delete[] X
+#endif
+
+template<typename T>
+class nrex_array
+{
+    private:
+        T* _data;
+        unsigned int _reserved;
+        unsigned int _size;
+    public:
+        nrex_array()
+            : _data(NREX_NEW_ARRAY(T, 2))
+            , _reserved(2)
+            , _size(0)
+        {
+        }
+
+        ~nrex_array()
+        {
+            NREX_DELETE_ARRAY(_data);
+        }
+
+        unsigned int size() const
+        {
+            return _size;
+        }
+
+        void reserve(unsigned int size)
+        {
+            T* old = _data;
+            _data = NREX_NEW_ARRAY(T, size);
+            _reserved = size;
+            for (unsigned int i = 0; i < _size; ++i)
+            {
+                _data[i] = old[i];
+            }
+            NREX_DELETE_ARRAY(old);
+        }
+
+        void push(T item)
+        {
+            if (_size == _reserved)
+            {
+                reserve(_reserved * 2);
+            }
+            _data[_size] = item;
+            _size++;
+        }
+
+        T& top()
+        {
+            return _data[_size - 1];
+        }
+
+        const T& operator[] (unsigned int i) const
+        {
+            return _data[i];
+        }
+
+        void pop()
+        {
+            if (_size > 0)
+            {
+                --_size;
+            }
+        }
+};
+
+static nrex_char nrex_unescape(nrex_char repr)
+{
+    switch (repr)
+    {
+        case '^': return '^';
+        case '$': return '$';
+        case '(': return '(';
+        case ')': return ')';
+        case '\\': return '\\';
+        case '.': return '.';
+        case '+': return '+';
+        case '*': return '*';
+        case '?': return '?';
+        case '-': return '-';
+        case 'a': return '\a';
+        case 'e': return '\e';
+        case 'f': return '\f';
+        case 'n': return '\n';
+        case 'r': return '\r';
+        case 't': return '\t';
+        case 'v': return '\v';
+    }
+    return 0;
+}
+
+struct nrex_search
+{
+    public:
+        const nrex_char* str;
+        nrex_result* captures;
+        int end;
+        bool complete;
+
+        nrex_char at(int pos)
+        {
+            return str[pos];
+        }
+
+        nrex_search(const nrex_char* str, nrex_result* captures)
+            : str(str)
+            , captures(captures)
+            , end(0)
+        {
+        }
+};
+
+struct nrex_node
+{
+        nrex_node* next;
+        nrex_node* previous;
+        nrex_node* parent;
+        bool quantifiable;
+
+        nrex_node(bool quantify = false)
+            : next(NULL)
+            , previous(NULL)
+            , parent(NULL)
+            , quantifiable(quantify)
+        {
+        }
+
+        virtual ~nrex_node()
+        {
+            if (next)
+            {
+                delete next;
+            }
+        }
+
+        virtual int test(nrex_search* s, int pos) const
+        {
+            return next ? next->test(s, pos) : -1;
+        }
+
+        virtual int test_parent(nrex_search* s, int pos) const
+        {
+            if (next)
+            {
+                pos = next->test(s, pos);
+            }
+            if (parent && pos >= 0)
+            {
+                pos = parent->test_parent(s, pos);
+            }
+            if (pos >= 0)
+            {
+                s->complete = true;
+            }
+            return pos;
+        }
+};
+
+struct nrex_node_group : public nrex_node
+{
+        int capturing;
+        bool negate;
+        nrex_array<nrex_node*> childset;
+        nrex_node* back;
+
+        nrex_node_group(int capturing)
+            : nrex_node(true)
+            , capturing(capturing)
+            , negate(false)
+            , back(NULL)
+        {
+        }
+
+        virtual ~nrex_node_group()
+        {
+            for (unsigned int i = 0; i < childset.size(); ++i)
+            {
+                delete childset[i];
+            }
+
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            if (capturing >= 0)
+            {
+                s->captures[capturing].start = pos;
+            }
+            for (unsigned int i = 0; i < childset.size(); ++i)
+            {
+                s->complete = false;
+                int res = childset[i]->test(s, pos);
+                if (s->complete)
+                {
+                    return res;
+                }
+                if ((res >= 0) != negate)
+                {
+                    if (capturing >= 0)
+                    {
+                        s->captures[capturing].length = res - pos;
+                    }
+                    return next ? next->test(s, res) : res;
+                }
+            }
+            return -1;
+        }
+
+        virtual int test_parent(nrex_search* s, int pos) const
+        {
+            if (capturing >= 0)
+            {
+                s->captures[capturing].length = pos - s->captures[capturing].start;
+            }
+            return nrex_node::test_parent(s, pos);
+        }
+
+        void add_childset()
+        {
+            back = NULL;
+        }
+
+        void add_child(nrex_node* node)
+        {
+            node->parent = this;
+            node->previous = back;
+            if (back)
+            {
+                back->next = node;
+            }
+            else
+            {
+                childset.push(node);
+            }
+            back = node;
+        }
+
+        nrex_node* swap_back(nrex_node* node)
+        {
+            if (!back)
+            {
+                add_child(node);
+                return NULL;
+            }
+            nrex_node* old = back;
+            if (!old->previous)
+            {
+                childset.pop();
+            }
+            back = old->previous;
+            add_child(node);
+            return old;
+        }
+};
+
+struct nrex_node_char : public nrex_node
+{
+        nrex_char ch;
+
+        nrex_node_char(nrex_char c)
+            : nrex_node(true)
+            , ch(c)
+        {
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            if (s->end == pos || s->at(pos) != ch)
+            {
+                return -1;
+            }
+            return next ? next->test(s, pos + 1) : pos + 1;
+        }
+};
+
+struct nrex_node_range : public nrex_node
+{
+        nrex_char start;
+        nrex_char end;
+
+        nrex_node_range(nrex_char s, nrex_char e)
+            : nrex_node(true)
+            , start(s)
+            , end(e)
+        {
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            if (s->end == pos)
+            {
+                return -1;
+            }
+            nrex_char c = s->at(pos);
+            if (c < start || end < c)
+            {
+                return -1;
+            }
+            return next ? next->test(s, pos + 1) : pos + 1;
+        }
+};
+
+static bool nrex_is_whitespace(nrex_char repr)
+{
+    switch (repr)
+    {
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+        case '\f':
+            return true;
+    }
+    return false;
+}
+
+static bool nrex_is_shorthand(nrex_char repr)
+{
+    switch (repr)
+    {
+        case 'W':
+        case 'w':
+        case 'D':
+        case 'd':
+        case 'S':
+        case 's':
+            return true;
+    }
+    return false;
+}
+
+struct nrex_node_shorthand : public nrex_node
+{
+        nrex_char repr;
+
+        nrex_node_shorthand(nrex_char c)
+            : nrex_node(true)
+            , repr(c)
+        {
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            if (s->end == pos)
+            {
+                return -1;
+            }
+            bool found = false;
+            bool invert = false;
+            nrex_char c = s->at(pos);
+            switch (repr)
+            {
+                case '.':
+                    found = true;
+                    break;
+                case 'W':
+                    invert = true;
+                case 'w':
+                    if (c == '_' || NREX_ISALPHANUM(c))
+                    {
+                        found = true;
+                    }
+                    break;
+                case 'D':
+                    invert = true;
+                case 'd':
+                    if ('0' <= c && c <= '9')
+                    {
+                        found = true;
+                    }
+                    break;
+                case 'S':
+                    invert = true;
+                case 's':
+                    if (nrex_is_whitespace(c))
+                    {
+                        found = true;
+                    }
+                    break;
+            }
+            if (found == invert)
+            {
+                return -1;
+            }
+            return next ? next->test(s, pos + 1) : pos + 1;
+        }
+};
+
+static bool nrex_is_quantifier(nrex_char repr)
+{
+    switch (repr)
+    {
+        case '?':
+        case '*':
+        case '+':
+        case '{':
+            return true;
+    }
+    return false;
+}
+
+struct nrex_node_quantifier : public nrex_node
+{
+        int min;
+        int max;
+        bool greedy;
+        nrex_node* child;
+
+        nrex_node_quantifier()
+            : nrex_node()
+            , min(0)
+            , max(0)
+            , greedy(true)
+            , child(NULL)
+        {
+        }
+
+        virtual ~nrex_node_quantifier()
+        {
+            if (child)
+            {
+                delete child;
+            }
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            nrex_array<int> backtrack;
+            backtrack.push(pos);
+            s->complete = false;
+            while (backtrack.top() <= s->end)
+            {
+                if (max >= 1 && backtrack.size() > (unsigned int)max)
+                {
+                    break;
+                }
+                if (!greedy && (unsigned int)min < backtrack.size())
+                {
+                    int res = backtrack.top();
+                    if (next)
+                    {
+                        res = next->test(s, res);
+                    }
+                    if (s->complete)
+                    {
+                        return res;
+                    }
+                    if (res >= 0 && parent->test_parent(s, res) >= 0)
+                    {
+                        return res;
+                    }
+                }
+                s->complete = false;
+                int res = child->test(s, backtrack.top());
+                if (s->complete)
+                {
+                    return res;
+                }
+                if (res < 0 || res == backtrack.top())
+                {
+                    break;
+                }
+                backtrack.push(res);
+            }
+            while (greedy && (unsigned int) min < backtrack.size())
+            {
+                s->complete = false;
+                int res = backtrack.top();
+                if (s->complete)
+                {
+                    return res;
+                }
+                if (next)
+                {
+                    res = next->test(s, res);
+                }
+                if (res >= 0 && parent->test_parent(s, res) >= 0)
+                {
+                    return res;
+                }
+                backtrack.pop();
+            }
+            return -1;
+        }
+};
+
+struct nrex_node_anchor : public nrex_node
+{
+        bool end;
+
+        nrex_node_anchor(bool end)
+            : nrex_node()
+            , end(end)
+        {
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            if (!end && pos != 0)
+            {
+                return -1;
+            }
+            else if (end && pos != s->end)
+            {
+                return -1;
+            }
+            return next ? next->test(s, pos) : pos;
+        }
+};
+
+struct nrex_node_backreference : public nrex_node
+{
+        int ref;
+
+        nrex_node_backreference(int ref)
+            : nrex_node(true)
+            , ref(ref)
+        {
+        }
+
+        int test(nrex_search* s, int pos) const
+        {
+            nrex_result& r = s->captures[ref];
+            for (int i = 0; i < r.length; ++i)
+            {
+                if (pos + i >= s->end)
+                {
+                    return -1;
+                }
+                if (s->at(r.start + i) != s->at(pos + i))
+                {
+                    return -1;
+                }
+            }
+            return next ? next->test(s, pos + r.length) : pos + r.length;
+        }
+};
+
+nrex::nrex()
+    : _capturing(0)
+    , _root(NULL)
+{
+}
+
+nrex::~nrex()
+{
+    if (_root)
+    {
+        delete _root;
+    }
+}
+
+bool nrex::valid() const
+{
+    return (_root != NULL);
+}
+
+void nrex::reset()
+{
+    _capturing = 0;
+    if (_root)
+    {
+        delete _root;
+    }
+    _root = NULL;
+}
+
+int nrex::capture_size() const
+{
+    return _capturing + 1;
+}
+
+bool nrex::compile(const nrex_char* pattern)
+{
+    reset();
+    nrex_node_group* root = NREX_NEW(nrex_node_group(_capturing));
+    nrex_array<nrex_node_group*> stack;
+    stack.push(root);
+    _root = root;
+
+    for (const nrex_char* c = pattern; c[0] != '\0'; ++c)
+    {
+        if (c[0] == '(')
+        {
+            if (c[1] == '?')
+            {
+                if (c[2] == ':')
+                {
+                    c = &c[2];
+                    nrex_node_group* group = NREX_NEW(nrex_node_group(-1));
+                    stack.top()->add_child(group);
+                    stack.push(group);
+                }
+                else
+                {
+                    NREX_COMPILE_ERROR("unrecognised qualifier for parenthesis");
+                }
+            }
+            else if (_capturing < 99)
+            {
+                nrex_node_group* group = NREX_NEW(nrex_node_group(++_capturing));
+                stack.top()->add_child(group);
+                stack.push(group);
+            }
+            else
+            {
+                nrex_node_group* group = NREX_NEW(nrex_node_group(-1));
+                stack.top()->add_child(group);
+                stack.push(group);
+            }
+        }
+        else if (c[0] == ')')
+        {
+            if (stack.size() > 1)
+            {
+                stack.pop();
+            }
+            else
+            {
+                NREX_COMPILE_ERROR("unexpected ')'");
+            }
+        }
+        else if (c[0] == '[')
+        {
+            nrex_node_group* group = NREX_NEW(nrex_node_group(-1));
+            stack.top()->add_child(group);
+            if (c[1] == '^')
+            {
+                group->negate = true;
+                ++c;
+            }
+            while (true)
+            {
+                group->add_childset();
+                ++c;
+                if (c[0] == '\0')
+                {
+                    NREX_COMPILE_ERROR("unclosed character class '[]'");
+                }
+                if (c[0] == ']')
+                {
+                    break;
+                }
+                else if (c[0] == '\\')
+                {
+                    nrex_char unescaped = nrex_unescape(c[1]);
+                    if (unescaped)
+                    {
+                        group->add_child(NREX_NEW(nrex_node_char(unescaped)));
+                        ++c;
+                    }
+                    else if (nrex_is_shorthand(c[1]))
+                    {
+                        group->add_child(NREX_NEW(nrex_node_shorthand(c[1])));
+                        ++c;
+                    }
+                    else
+                    {
+                        NREX_COMPILE_ERROR("escape token not recognised");
+                    }
+                }
+                else
+                {
+                    if (c[1] == '-' && c[2] != '\0')
+                    {
+                        bool range = false;
+                        if ('A' <= c[0] && c[0] <= 'Z' && 'A' <= c[2] && c[2] <= 'Z')
+                        {
+                            range = true;
+                        }
+                        if ('a' <= c[0] && c[0] <= 'z' && 'a' <= c[2] && c[2] <= 'z')
+                        {
+                            range = true;
+                        }
+                        if ('0' <= c[0] && c[0] <= '9' && '0' <= c[2] && c[2] <= '9')
+                        {
+                            range = true;
+                        }
+                        if (range)
+                        {
+                            group->add_child(NREX_NEW(nrex_node_range(c[0], c[2])));
+                            c = &c[2];
+                            continue;
+                        }
+                    }
+                    group->add_child(NREX_NEW(nrex_node_char(c[0])));
+                }
+
+            }
+        }
+        else if (nrex_is_quantifier(c[0]))
+        {
+            nrex_node_quantifier* quant = NREX_NEW(nrex_node_quantifier);
+            quant->child = stack.top()->swap_back(quant);
+            if (quant->child == NULL || !quant->child->quantifiable)
+            {
+                NREX_COMPILE_ERROR("element not quantifiable");
+            }
+            quant->child->previous = NULL;
+            quant->child->next = NULL;
+            quant->child->parent = quant;
+            if (c[0] == '?')
+            {
+                quant->min = 0;
+                quant->max = 1;
+            }
+            else if (c[0] == '+')
+            {
+                quant->min = 1;
+                quant->max = -1;
+            }
+            else if (c[0] == '*')
+            {
+                quant->min = 0;
+                quant->max = -1;
+            }
+            else if (c[0] == '{')
+            {
+                bool max_set = false;
+                quant->min = 0;
+                quant->max = -1;
+                while (true)
+                {
+                    ++c;
+                    if (c[0] == '\0')
+                    {
+                        NREX_COMPILE_ERROR("unclosed range quantifier '{}'");
+                    }
+                    else if (c[0] == '}')
+                    {
+                        break;
+                    }
+                    else if (c[0] == ',')
+                    {
+                        max_set = true;
+                        continue;
+                    }
+                    else if (c[0] < '0' || '9' < c[0])
+                    {
+                        NREX_COMPILE_ERROR("expected numeric digits, ',' or '}'");
+                    }
+                    if (max_set)
+                    {
+                        if (quant->max < 0)
+                        {
+                            quant->max = int(c[0] - '0');
+                        }
+                        else
+                        {
+                            quant->max = quant->max * 10 + int(c[0] - '0');
+                        }
+                    }
+                    else
+                    {
+                        quant->min = quant->min * 10 + int(c[0] - '0');
+                    }
+                }
+                if (!max_set)
+                {
+                    quant->max = quant->min;
+                }
+            }
+            if (c[1] == '?')
+            {
+                quant->greedy = false;
+                ++c;
+            }
+        }
+        else if (c[0] == '|')
+        {
+            stack.top()->add_childset();
+        }
+        else if (c[0] == '^' || c[0] == '$')
+        {
+            stack.top()->add_child(NREX_NEW(nrex_node_anchor((c[0] == '$'))));
+        }
+        else if (c[0] == '.')
+        {
+            stack.top()->add_child(NREX_NEW(nrex_node_shorthand('.')));
+        }
+        else if (c[0] == '\\')
+        {
+            nrex_char unescaped = nrex_unescape(c[1]);
+            if (unescaped)
+            {
+                stack.top()->add_child(NREX_NEW(nrex_node_char(unescaped)));
+                ++c;
+            }
+            else if (nrex_is_shorthand(c[1]))
+            {
+                stack.top()->add_child(NREX_NEW(nrex_node_shorthand(c[1])));
+                ++c;
+            }
+            else if ('1' <= c[1] && c[1] <= '9')
+            {
+                int ref = 0;
+                if ('0' <= c[2] && c[2] <= '9')
+                {
+                    ref = int(c[1] - '0') * 10 + int(c[2] - '0');
+                    c = &c[2];
+                }
+                else
+                {
+                    ref = int(c[1] - '0');
+                    ++c;
+                }
+                if (ref > _capturing)
+                {
+                    NREX_COMPILE_ERROR("backreference to non-existent capture");
+                }
+                stack.top()->add_child(NREX_NEW(nrex_node_backreference(ref)));
+            }
+            else
+            {
+                NREX_COMPILE_ERROR("escape token not recognised");
+            }
+        }
+        else
+        {
+            stack.top()->add_child(NREX_NEW(nrex_node_char(c[0])));
+        }
+    }
+    return true;
+}
+
+bool nrex::match(const nrex_char* str, nrex_result* captures, int offset, int end) const
+{
+    nrex_search s(str, captures);
+    if (end >= offset)
+    {
+        s.end = end;
+    }
+    else
+    {
+        s.end = NREX_STRLEN(str);
+    }
+    for (int i = offset; i < s.end; ++i)
+    {
+        for (int c = 0; c <= _capturing; ++c)
+        {
+            captures[c].start = 0;
+            captures[c].length = 0;
+        }
+        if (_root->test(&s, i) >= 0)
+        {
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/drivers/nrex/nrex.hpp b/drivers/nrex/nrex.hpp
new file mode 100644
index 0000000000..2a6aa08e1d
--- /dev/null
+++ b/drivers/nrex/nrex.hpp
@@ -0,0 +1,144 @@
+//  NREX: Node RegEx
+//
+//  Copyright (c) 2015, Zher Huei Lee
+//  All rights reserved.
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//   1. The origin of this software must not be misrepresented; you must not
+//      claim that you wrote the original software. If you use this software
+//      in a product, an acknowledgment in the product documentation would
+//      be appreciated but is not required.
+//
+//   2. Altered source versions must be plainly marked as such, and must not
+//      be misrepresented as being the original software.
+//
+//   3. This notice may not be removed or altered from any source
+//      distribution.
+//
+
+#ifndef NREX_HPP
+#define NREX_HPP
+
+#include "nrex_config.h"
+
+#ifdef NREX_UNICODE
+typedef wchar_t nrex_char;
+#else
+typedef char nrex_char;
+#endif
+
+/*!
+ * \brief Struct to contain the range of a capture result
+ *
+ * The range provided is relative to the begining of the searched string.
+ *
+ * \see nrex_node::match()
+ */
+struct nrex_result
+{
+    public:
+        int start; /*!< Start of text range */
+        int length; /*!< Length of text range */
+};
+
+class nrex_node;
+
+/*!
+ * \brief Holds the compiled regex pattern
+ */
+class nrex
+{
+    private:
+        int _capturing;
+        nrex_node* _root;
+    public:
+        nrex();
+        ~nrex();
+
+        /*!
+         * \brief Removes the compiled regex and frees up the memory
+         */
+        void reset();
+
+        /*!
+         * \brief Checks if there is a compiled regex being stored
+         * \return True if present, False if not present
+         */
+        bool valid() const;
+
+        /*!
+         * \brief Provides number of captures the compiled regex uses
+         *
+         * This is used to provide the array size of the captures needed for
+         * nrex::match() to work. The size is actually the number of capture
+         * groups + one for the matching of the entire pattern. The result is
+         * always capped at 100.
+         *
+         * \return The number of captures
+         */
+        int capture_size() const;
+
+        /*!
+         * \brief Compiles the provided regex pattern
+         *
+         * This automatically removes the existing compiled regex if already
+         * present.
+         *
+         * If the NREX_THROW_ERROR was defined it would automatically throw a
+         * runtime error nrex_compile_error if it encounters a problem when
+         * parsing the pattern.
+         *
+         * \param The regex pattern
+         * \return True if the pattern was succesfully compiled
+         */
+        bool compile(const nrex_char* pattern);
+
+        /*!
+         * \brief Uses the pattern to search through the provided string
+         * \param str       The text to search through. It only needs to be
+         *                  null terminated if the end point is not provided.
+         *                  This also determines the starting anchor.
+         * \param captures  The array of results to store the capture results.
+         *                  The size of that array needs to be the same as the
+         *                  size given in nrex::capture_size(). As it matches
+         *                  the function fills the array with the results. 0 is
+         *                  the result for the entire pattern, 1 and above
+         *                  corresponds to the regex capture group if present.
+         * \param offset    The starting point of the search. This does not move
+         *                  the starting anchor. Defaults to 0.
+         * \param end       The end point of the search. This also determines
+         *                  the ending anchor. If a number less than the offset
+         *                  is provided, the search would be done until null
+         *                  termination. Defaults to -1.
+         * \return          True if a match was found. False otherwise.
+         */
+        bool match(const nrex_char* str, nrex_result* captures, int offset = 0, int end = -1) const;
+};
+
+#ifdef NREX_THROW_ERROR
+
+#include <stdexcept>
+
+class nrex_compile_error : std::runtime_error
+{
+    public:
+        nrex_compile_error(const char* message)
+            : std::runtime_error(message)
+        {
+        }
+
+        ~nrex_compile_error() throw()
+        {
+        }
+};
+
+#endif
+
+#endif // NREX_HPP
diff --git a/drivers/nrex/nrex_config.h b/drivers/nrex/nrex_config.h
new file mode 100644
index 0000000000..540f34f8b4
--- /dev/null
+++ b/drivers/nrex/nrex_config.h
@@ -0,0 +1,12 @@
+// Godot-specific configuration
+// To use this, replace nrex_config.h
+
+#include "core/os/memory.h"
+
+#define NREX_UNICODE
+//#define NREX_THROW_ERROR
+
+#define NREX_NEW(X) memnew(X)
+#define NREX_NEW_ARRAY(X, N) memnew_arr(X, N)
+#define NREX_DELETE(X) memdelete(X)
+#define NREX_DELETE_ARRAY(X) memdelete_arr(X)
diff --git a/drivers/nrex/regex.cpp b/drivers/nrex/regex.cpp
new file mode 100644
index 0000000000..d7c12bd544
--- /dev/null
+++ b/drivers/nrex/regex.cpp
@@ -0,0 +1,112 @@
+/*************************************************/
+/*  regex.cpp                                    */
+/*************************************************/
+/*            This file is part of:              */
+/*                GODOT ENGINE                   */
+/*************************************************/
+/*       Source code within this file is:        */
+/*  (c) 2007-2010 Juan Linietsky, Ariel Manzur   */
+/*             All Rights Reserved.              */
+/*************************************************/
+
+#include "regex.h"
+#include "nrex.hpp"
+#include "core/os/memory.h"
+
+void RegEx::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("compile","pattern"),&RegEx::compile);
+	ObjectTypeDB::bind_method(_MD("match","text","start","end"),&RegEx::match, DEFVAL(0), DEFVAL(-1));
+	ObjectTypeDB::bind_method(_MD("get_capture","capture"),&RegEx::get_capture);
+	ObjectTypeDB::bind_method(_MD("get_capture_list"),&RegEx::_bind_get_capture_list);
+
+};
+
+StringArray RegEx::_bind_get_capture_list() const {
+
+	StringArray ret;
+	int count = get_capture_count();
+	for (int i=0; i<count; i++) {
+
+		String c = get_capture(i);
+		ret.push_back(c);
+	};
+
+	return ret;
+
+};
+
+void RegEx::clear() {
+
+	text.clear();
+	captures.clear();
+	exp.reset();
+
+};
+
+bool RegEx::is_valid() const {
+
+	return exp.valid();
+
+};
+
+int RegEx::get_capture_count() const {
+	
+	return exp.capture_size();
+}
+
+String RegEx::get_capture(int capture) const {
+
+	ERR_FAIL_COND_V( get_capture_count() <= capture, String() );
+
+	return text.substr(captures[capture].start, captures[capture].length);
+
+}
+
+Error RegEx::compile(const String& p_pattern) {
+	
+	clear();
+
+	exp.compile(p_pattern.c_str());
+
+	ERR_FAIL_COND_V( !exp.valid(), FAILED );
+	
+	captures.resize(exp.capture_size());
+
+	return OK;
+
+};
+
+bool RegEx::match(const String& p_text, int p_start, int p_end) const {
+
+	
+	ERR_FAIL_COND_V( !exp.valid(), false );
+	ERR_FAIL_COND_V( p_text.length() < p_start, false );
+	ERR_FAIL_COND_V( p_text.length() < p_end, false );
+
+	bool res = exp.match(p_text.c_str(), &captures[0], p_start, p_end);
+
+	if (res) {
+		text = p_text;
+		return true;
+	}
+	text.clear();
+	return false;
+
+};
+
+RegEx::RegEx(const String& p_pattern) {
+
+	compile(p_pattern);
+
+};
+
+RegEx::RegEx() {
+
+};
+
+RegEx::~RegEx() {
+
+	clear();
+
+};
diff --git a/drivers/trex/regex.h b/drivers/nrex/regex.h
index 899bfd0189..3ef9ca3425 100644
--- a/drivers/trex/regex.h
+++ b/drivers/nrex/regex.h
@@ -13,34 +13,31 @@
 #define REGEX_H
 
 #include "ustring.h"
-#include "list.h"
+#include "vector.h"
 #include "core/reference.h"
-struct TRex;
+#include "nrex.hpp"
 
 class RegEx : public Reference {
 
 	OBJ_TYPE(RegEx, Reference);
 
 	mutable String text;
-	TRex *exp;
+	mutable Vector<nrex_result> captures;
+	nrex exp;
 
 protected:
 
 	static void _bind_methods();
+	StringArray _bind_get_capture_list() const;
 
-	int _bind_find(const String& p_text, int p_start = 0, int p_end = -1) const;
-	StringArray _bind_get_captures() const;
 public:
 
 	void clear();
-
-	Error compile(const String& p_pattern);
 	bool is_valid() const;
-	bool match(const String& p_text, List<String>* p_captures = NULL, int p_start = 0, int p_end = -1) const;
-	bool find(const String& p_text, int& p_rstart, int &p_rend, List<String>* p_captures = NULL, int p_start = 0, int p_end = -1) const;
 	int get_capture_count() const;
-	Error get_capture_limits(int p_capture, int& p_start, int& p_len) const;
-	String get_capture(int p_idx) const;
+	String get_capture(int capture) const;
+	Error compile(const String& p_pattern);
+	bool match(const String& p_text, int p_start = 0, int p_end = -1) const;
 
 	RegEx();
 	RegEx(const String& p_pattern);
diff --git a/drivers/register_driver_types.cpp b/drivers/register_driver_types.cpp
index e730171fbb..01f6a8b5b0 100644
--- a/drivers/register_driver_types.cpp
+++ b/drivers/register_driver_types.cpp
@@ -48,7 +48,7 @@
 #endif
 
 
-#include "drivers/trex/regex.h"
+#include "drivers/nrex/regex.h"
 
 #ifdef MUSEPACK_ENABLED
 #include "mpc/audio_stream_mpc.h"
diff --git a/drivers/trex/TRexpp.h b/drivers/trex/TRexpp.h
deleted file mode 100644
index 8391e47414..0000000000
--- a/drivers/trex/TRexpp.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef _TREXPP_H_

-#define _TREXPP_H_

-/***************************************************************

-	T-Rex a tiny regular expression library

-

-	Copyright (C) 2003-2004 Alberto Demichelis

-

-	This software is provided 'as-is', without any express 

-	or implied warranty. In no event will the authors be held 

-	liable for any damages arising from the use of this software.

-

-	Permission is granted to anyone to use this software for 

-	any purpose, including commercial applications, and to alter

-	it and redistribute it freely, subject to the following restrictions:

-

-		1. The origin of this software must not be misrepresented;

-		you must not claim that you wrote the original software.

-		If you use this software in a product, an acknowledgment

-		in the product documentation would be appreciated but

-		is not required.

-

-		2. Altered source versions must be plainly marked as such,

-		and must not be misrepresented as being the original software.

-

-		3. This notice may not be removed or altered from any

-		source distribution.

-

-****************************************************************/

-

-extern "C" {

-#include "trex.h"

-}

-

-struct TRexParseException{TRexParseException(const TRexChar *c):desc(c){}const TRexChar *desc;};

-

-class TRexpp {

-public:

-	TRexpp() { _exp = (TRex *)0; }

-	~TRexpp() { CleanUp(); }

-	// compiles a regular expression

-	void Compile(const TRexChar *pattern) { 

-		const TRexChar *error;

-		CleanUp();

-		if(!(_exp = trex_compile(pattern,&error)))

-			throw TRexParseException(error);

-	}

-	// return true if the given text match the expression

-	bool Match(const TRexChar* text) { 

-		return _exp?(trex_match(_exp,text) != 0):false; 

-	}

-	// Searches for the first match of the expression in a zero terminated string

-	bool Search(const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end) { 

-		return _exp?(trex_search(_exp,text,out_begin,out_end) != 0):false; 

-	}

-	// Searches for the first match of the expression in a string sarting at text_begin and ending at text_end

-	bool SearchRange(const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end) { 

-		return _exp?(trex_searchrange(_exp,text_begin,text_end,out_begin,out_end) != 0):false; 

-	}

-	bool GetSubExp(int n, const TRexChar** out_begin, int *out_len)

-	{

-		TRexMatch match;

-		TRexBool res = _exp?(trex_getsubexp(_exp,n,&match)):TRex_False; 

-		if(res) {

-			*out_begin = match.begin;

-			*out_len = match.len;

-			return true;

-		}

-		return false;

-	}

-	int GetSubExpCount() { return _exp?trex_getsubexpcount(_exp):0; }

-private:

-	void CleanUp() { if(_exp) trex_free(_exp); _exp = (TRex *)0; }

-	TRex *_exp;

-};

-#endif //_TREXPP_H_
\ No newline at end of file
diff --git a/drivers/trex/history.txt b/drivers/trex/history.txt
deleted file mode 100644
index 5cfe8770b4..0000000000
--- a/drivers/trex/history.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-===version 1.3

--fixed a bug for GCC users(thx Brendan)

-

-===version 1.2

--added word boundary match \b and \B

--added vertical tab escape \v

--\w now also matches '_' (underscore)

--fixed greediness for * and +

-

-===version 1.1 , April 1, 2004

--fixed some minor bug

--added predefined character classes(\w,\W,\s,\S etc...)

-

-===version 1.0 , February 23, 2004

--first public realase
\ No newline at end of file
diff --git a/drivers/trex/readme.txt b/drivers/trex/readme.txt
deleted file mode 100644
index 1d93558e92..0000000000
--- a/drivers/trex/readme.txt
+++ /dev/null
@@ -1,171 +0,0 @@
-T-REX 1.3 http://tiny-rex.sourceforge.net

-----------------------------------------------------------------------

-	T-Rex a tiny regular expression library

-

-	Copyright (C) 2003-2006 Alberto Demichelis

-

-	This software is provided 'as-is', without any express 

-	or implied warranty. In no event will the authors be held 

-	liable for any damages arising from the use of this software.

-

-	Permission is granted to anyone to use this software for 

-	any purpose, including commercial applications, and to alter

-	it and redistribute it freely, subject to the following restrictions:

-

-		1. The origin of this software must not be misrepresented;

-		you must not claim that you wrote the original software.

-		If you use this software in a product, an acknowledgment

-		in the product documentation would be appreciated but

-		is not required.

-

-		2. Altered source versions must be plainly marked as such,

-		and must not be misrepresented as being the original software.

-

-		3. This notice may not be removed or altered from any

-		source distribution.

-		

-----------------------------------------------------------------------

-TRex implements the following expressions

-

-\	Quote the next metacharacter

-^	Match the beginning of the string

-.	Match any character

-$	Match the end of the string

-|	Alternation

-()	Grouping (creates a capture)

-[]	Character class  

-

-==GREEDY CLOSURES==

-*	   Match 0 or more times

-+	   Match 1 or more times

-?	   Match 1 or 0 times

-{n}    Match exactly n times

-{n,}   Match at least n times

-{n,m}  Match at least n but not more than m times  

-

-==ESCAPE CHARACTERS==

-\t		tab                   (HT, TAB)

-\n		newline               (LF, NL)

-\r		return                (CR)

-\f		form feed             (FF)

-

-==PREDEFINED CLASSES==

-\l		lowercase next char

-\u		uppercase next char

-\a		letters

-\A		non letters

-\w		alphanimeric [0-9a-zA-Z]

-\W		non alphanimeric

-\s		space

-\S		non space

-\d		digits

-\D		non nondigits

-\x		exadecimal digits

-\X		non exadecimal digits

-\c		control charactrs

-\C		non control charactrs

-\p		punctation

-\P		non punctation

-\b		word boundary

-\B		non word boundary

-

-----------------------------------------------------------------------

-API DOC

-----------------------------------------------------------------------

-TRex *trex_compile(const TRexChar *pattern,const TRexChar **error);

-

-compiles an expression and returns a pointer to the compiled version.

-in case of failure returns NULL.The returned object has to be deleted

-through the function trex_free().

-

-pattern

-	a pointer to a zero terminated string containing the pattern that 

-	has to be compiled.

-error

-	apointer to a string pointer that will be set with an error string

-	in case of failure.

-	

-----------------------------------------------------------------------

-void trex_free(TRex *exp)

-

-deletes a expression structure created with trex_compile()

-

-exp

-	the expression structure that has to be deleted

-

-----------------------------------------------------------------------

-TRexBool trex_match(TRex* exp,const TRexChar* text)

-

-returns TRex_True if the string specified in the parameter text is an

-exact match of the expression, otherwise returns TRex_False.

-

-exp

-	the compiled expression

-text

-	the string that has to be tested

-	

-----------------------------------------------------------------------

-TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end)

-

-searches the first match of the expressin in the string specified in the parameter text.

-if the match is found returns TRex_True and the sets out_begin to the beginning of the

-match and out_end at the end of the match; otherwise returns TRex_False.

-

-exp

-	the compiled expression

-text

-	the string that has to be tested

-out_begin

-	a pointer to a string pointer that will be set with the beginning of the match

-out_end

-	a pointer to a string pointer that will be set with the end of the match

-

-----------------------------------------------------------------------

-TREX_API TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end)

-

-searches the first match of the expressin in the string delimited 

-by the parameter text_begin and text_end.

-if the match is found returns TRex_True and the sets out_begin to the beginning of the

-match and out_end at the end of the match; otherwise returns TRex_False.

-

-exp

-	the compiled expression

-text_begin

-	a pointer to the beginnning of the string that has to be tested

-text_end

-	a pointer to the end of the string that has to be tested

-out_begin

-	a pointer to a string pointer that will be set with the beginning of the match

-out_end

-	a pointer to a string pointer that will be set with the end of the match

-	

-----------------------------------------------------------------------

-int trex_getsubexpcount(TRex* exp)

-

-returns the number of sub expressions matched by the expression

-

-exp

-	the compiled expression

-

----------------------------------------------------------------------

-TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *submatch)

-

-retrieve the begin and and pointer to the length of the sub expression indexed

-by n. The result is passed trhough the struct TRexMatch:

-

-typedef struct {

-	const TRexChar *begin;

-	int len;

-} TRexMatch;

-

-the function returns TRex_True if n is valid index otherwise TRex_False.

-

-exp

-	the compiled expression

-n

-	the index of the submatch

-submatch

-	a pointer to structure that will store the result

-	

-this function works also after a match operation has been performend.

-	

diff --git a/drivers/trex/regex.cpp b/drivers/trex/regex.cpp
deleted file mode 100644
index 11cd6256e2..0000000000
--- a/drivers/trex/regex.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/*************************************************/
-/*  regex.cpp                                    */
-/*************************************************/
-/*            This file is part of:              */
-/*                GODOT ENGINE                   */
-/*************************************************/
-/*       Source code within this file is:        */
-/*  (c) 2007-2010 Juan Linietsky, Ariel Manzur   */
-/*             All Rights Reserved.              */
-/*************************************************/
-
-#include "regex.h"
-
-extern "C" {
-
-#define _UNICODE
-#include "trex.h"
-
-};
-
-void RegEx::_bind_methods() {
-
-	ObjectTypeDB::bind_method(_MD("compile","pattern"),&RegEx::compile);
-	ObjectTypeDB::bind_method(_MD("find","text", "start","end"),&RegEx::_bind_find, DEFVAL(0), DEFVAL(-1));
-	ObjectTypeDB::bind_method(_MD("get_captures"),&RegEx::_bind_get_captures);
-};
-
-Error RegEx::compile(const String& p_pattern) {
-
-	clear();
-	const TRexChar* error;
-	exp = trex_compile(p_pattern.c_str(), &error);
-	ERR_FAIL_COND_V(!exp, FAILED);
-	return OK;
-};
-
-
-int RegEx::_bind_find(const String& p_text, int p_start, int p_end) const {
-
-	int start, end;
-	bool ret = find(p_text, start, end, NULL, p_start, p_end);
-
-	return ret?start:-1;
-};
-
-bool RegEx::find(const String& p_text, int& p_rstart, int &p_rend, List<String>* p_captures, int p_start, int p_end) const {
-
-	ERR_FAIL_COND_V( !exp, false );
-	text=p_text;
-
-	const CharType* str = p_text.c_str();
-	const CharType* start = str + p_start;
-	const CharType* end = str + (p_end == -1?p_text.size():p_end);
-
-	const CharType* out_begin;
-	const CharType* out_end;
-
-	bool ret = trex_searchrange(exp, start, end, &out_begin, &out_end);
-	if (ret) {
-
-		p_rstart = out_begin - str;
-		p_rend = out_end - str;
-
-		if (p_captures) {
-
-			int count = get_capture_count();
-			for (int i=0; i<count; i++) {
-
-				int start, len;
-				get_capture_limits(i, start, len);
-				p_captures->push_back(p_text.substr(start, len));
-			};
-		};
-	} else {
-
-		p_rstart = -1;
-	};
-
-	return ret;
-};
-
-
-bool RegEx::match(const String& p_text, List<String>* p_captures, int p_start, int p_end) const {
-
-	ERR_FAIL_COND_V( !exp, false );
-
-	int start, end;
-	return find(p_text, start, end, p_captures, p_start, p_end);
-};
-
-int RegEx::get_capture_count() const {
-
-	ERR_FAIL_COND_V( exp == NULL, -1 );
-
-	return trex_getsubexpcount(exp);
-};
-
-Error RegEx::get_capture_limits(int p_capture, int& p_start, int& p_len) const {
-
-	ERR_FAIL_COND_V( exp == NULL, ERR_UNCONFIGURED );
-
-	TRexMatch match;
-	TRexBool res = trex_getsubexp(exp, p_capture, &match);
-	ERR_FAIL_COND_V( !res, FAILED );
-	p_start = (int)(match.begin - text.c_str());
-	p_len = match.len;
-
-	return OK;
-};
-
-String RegEx::get_capture(int p_idx) const {
-
-	ERR_FAIL_COND_V( exp == NULL, "" );
-	int start, len;
-	Error ret = get_capture_limits(p_idx, start, len);
-	ERR_FAIL_COND_V(ret != OK, "");
-	if (len == 0)
-		return "";
-	return text.substr(start, len);
-};
-
-StringArray RegEx::_bind_get_captures() const {
-
-	StringArray ret;
-	int count = get_capture_count();
-	for (int i=0; i<count; i++) {
-
-		String c = get_capture(i);
-		ret.push_back(c);
-	};
-
-	return ret;
-};
-
-bool RegEx::is_valid() const {
-
-	return exp != NULL;
-};
-
-void RegEx::clear() {
-
-	if (exp) {
-
-		trex_free(exp);
-		exp = NULL;
-	};
-};
-
-RegEx::RegEx(const String& p_pattern) {
-
-	exp = NULL;
-	compile(p_pattern);
-};
-
-RegEx::RegEx() {
-
-	exp = NULL;
-};
-
-RegEx::~RegEx() {
-
-	clear();
-};
diff --git a/drivers/trex/test.c b/drivers/trex/test.c
deleted file mode 100644
index 69db49c1af..0000000000
--- a/drivers/trex/test.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "trex.h"

-#include <stdio.h>

-#include <string.h>

-

-#ifdef _UNICODE

-#define trex_sprintf swprintf

-#else

-#define trex_sprintf sprintf

-#endif

-

-int main(int argc, char* argv[])

-{

-	const TRexChar *begin,*end;

-	TRexChar sTemp[200];

-	const TRexChar *error = NULL;

-	TRex *x = trex_compile(_TREXC("(x{1,5})xx"),&error);

-	if(x) {

-		trex_sprintf(sTemp,_TREXC("xxxxxxx"));

-		if(trex_search(x,sTemp,&begin,&end))

-		{

-			int i,n = trex_getsubexpcount(x);

-			TRexMatch match;

-			for(i = 0; i < n; i++)

-			{

-				TRexChar t[200];

-				trex_getsubexp(x,i,&match);

-				trex_sprintf(t,_TREXC("[%%d]%%.%ds\n"),match.len);

-				trex_printf(t,i,match.begin);

-			}

-			trex_printf(_TREXC("match! %d sub matches\n"),trex_getsubexpcount(x));

-		}

-		else {

-			trex_printf(_TREXC("no match!\n"));

-		}

-		trex_free(x);

-	}

-	else {

-		trex_printf(_TREXC("compilation error [%s]!\n"),error?error:_TREXC("undefined"));

-	}

-	return 0;

-}

diff --git a/drivers/trex/trex.c b/drivers/trex/trex.c
deleted file mode 100644
index b3668c3a11..0000000000
--- a/drivers/trex/trex.c
+++ /dev/null
@@ -1,643 +0,0 @@
-	/* see copyright notice in trex.h */

-#include <string.h>

-#include <stdlib.h>

-#include <ctype.h>

-#include <setjmp.h>

-#include "trex.h"

-

-#ifdef _UINCODE

-#define scisprint iswprint

-#define scstrlen wcslen

-#define scprintf wprintf

-#define _SC(x) L##c

-#else

-#define scisprint isprint

-#define scstrlen strlen

-#define scprintf printf

-#define _SC(x) (x)

-#endif

-

-#ifdef _DEBUG

-#include <stdio.h>

-

-static const TRexChar *g_nnames[] =

-{

-	_SC("NONE"),_SC("OP_GREEDY"),	_SC("OP_OR"),

-	_SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"),	_SC("OP_CLASS"),

-	_SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),

-	_SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")

-};

-

-#endif

-#define OP_GREEDY		(MAX_CHAR+1) // * + ? {n}

-#define OP_OR			(MAX_CHAR+2)

-#define OP_EXPR			(MAX_CHAR+3) //parentesis ()

-#define OP_NOCAPEXPR	(MAX_CHAR+4) //parentesis (?:)

-#define OP_DOT			(MAX_CHAR+5)

-#define OP_CLASS		(MAX_CHAR+6)

-#define OP_CCLASS		(MAX_CHAR+7)

-#define OP_NCLASS		(MAX_CHAR+8) //negates class the [^

-#define OP_RANGE		(MAX_CHAR+9)

-#define OP_CHAR			(MAX_CHAR+10)

-#define OP_EOL			(MAX_CHAR+11)

-#define OP_BOL			(MAX_CHAR+12)

-#define OP_WB			(MAX_CHAR+13)

-

-#define TREX_SYMBOL_ANY_CHAR ('.')

-#define TREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')

-#define TREX_SYMBOL_GREEDY_ZERO_OR_MORE ('*')

-#define TREX_SYMBOL_GREEDY_ZERO_OR_ONE ('?')

-#define TREX_SYMBOL_BRANCH ('|')

-#define TREX_SYMBOL_END_OF_STRING ('$')

-#define TREX_SYMBOL_BEGINNING_OF_STRING ('^')

-#define TREX_SYMBOL_ESCAPE_CHAR ('\\')

-

-

-typedef int TRexNodeType;

-

-typedef struct tagTRexNode{

-	TRexNodeType type;

-	int left;

-	int right;

-	int next;

-}TRexNode;

-

-struct TRex{

-	const TRexChar *_eol;

-	const TRexChar *_bol;

-	const TRexChar *_p;

-	int _first;

-	int _op;

-	TRexNode *_nodes;

-	int _nallocated;

-	int _nsize;

-	int _nsubexpr;

-	TRexMatch *_matches;

-	int _currsubexp;

-	void *_jmpbuf;

-	const TRexChar **_error;

-};

-

-static int trex_list(TRex *exp);

-

-static int trex_newnode(TRex *exp, TRexNodeType type)

-{

-	TRexNode n;

-	int newid;

-	n.type = type;

-	n.next = n.right = n.left = -1;

-	if(type == OP_EXPR)

-		n.right = exp->_nsubexpr++;

-	if(exp->_nallocated < (exp->_nsize + 1)) {

-		//int oldsize = exp->_nallocated;

-		exp->_nallocated *= 2;

-		exp->_nodes = (TRexNode *)realloc(exp->_nodes, exp->_nallocated * sizeof(TRexNode));

-	}

-	exp->_nodes[exp->_nsize++] = n;

-	newid = exp->_nsize - 1;

-	return (int)newid;

-}

-

-static void trex_error(TRex *exp,const TRexChar *error)

-{

-	if(exp->_error) *exp->_error = error;

-	longjmp(*((jmp_buf*)exp->_jmpbuf),-1);

-}

-

-static void trex_expect(TRex *exp, int n){

-	if((*exp->_p) != n) 

-		trex_error(exp, _SC("expected paren"));

-	exp->_p++;

-}

-

-static TRexChar trex_escapechar(TRex *exp)

-{

-	if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR){

-		exp->_p++;

-		switch(*exp->_p) {

-		case 'v': exp->_p++; return '\v';

-		case 'n': exp->_p++; return '\n';

-		case 't': exp->_p++; return '\t';

-		case 'r': exp->_p++; return '\r';

-		case 'f': exp->_p++; return '\f';

-		default: return (*exp->_p++);

-		}

-	} else if(!scisprint(*exp->_p)) trex_error(exp,_SC("letter expected"));

-	return (*exp->_p++);

-}

-

-static int trex_charclass(TRex *exp,int classid)

-{

-	int n = trex_newnode(exp,OP_CCLASS);

-	exp->_nodes[n].left = classid;

-	return n;

-}

-

-static int trex_charnode(TRex *exp,TRexBool isclass)

-{

-	TRexChar t;

-	if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR) {

-		exp->_p++;

-		switch(*exp->_p) {

-			case 'n': exp->_p++; return trex_newnode(exp,'\n');

-			case 't': exp->_p++; return trex_newnode(exp,'\t');

-			case 'r': exp->_p++; return trex_newnode(exp,'\r');

-			case 'f': exp->_p++; return trex_newnode(exp,'\f');

-			case 'v': exp->_p++; return trex_newnode(exp,'\v');

-			case 'a': case 'A': case 'w': case 'W': case 's': case 'S': 

-			case 'd': case 'D': case 'x': case 'X': case 'c': case 'C': 

-			case 'p': case 'P': case 'l': case 'u': 

-				{

-				t = *exp->_p; exp->_p++; 

-				return trex_charclass(exp,t);

-				}

-			case 'b': 

-			case 'B':

-				if(!isclass) {

-					int node = trex_newnode(exp,OP_WB);

-					exp->_nodes[node].left = *exp->_p;

-					exp->_p++; 

-					return node;

-				} //else default

-			default: 

-				t = *exp->_p; exp->_p++; 

-				return trex_newnode(exp,t);

-		}

-	}

-	else if(!scisprint(*exp->_p)) {

-		

-		trex_error(exp,_SC("letter expected"));

-	}

-	t = *exp->_p; exp->_p++; 

-	return trex_newnode(exp,t);

-}

-static int trex_class(TRex *exp)

-{

-	int ret = -1;

-	int first = -1,chain;

-	if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING){

-		ret = trex_newnode(exp,OP_NCLASS);

-		exp->_p++;

-	}else ret = trex_newnode(exp,OP_CLASS);

-	

-	if(*exp->_p == ']') trex_error(exp,_SC("empty class"));

-	chain = ret;

-	while(*exp->_p != ']' && exp->_p != exp->_eol) {

-		if(*exp->_p == '-' && first != -1){ 

-			int r,t;

-			if(*exp->_p++ == ']') trex_error(exp,_SC("unfinished range"));

-			r = trex_newnode(exp,OP_RANGE);

-			if(first>*exp->_p) trex_error(exp,_SC("invalid range"));

-			if(exp->_nodes[first].type == OP_CCLASS) trex_error(exp,_SC("cannot use character classes in ranges"));

-			exp->_nodes[r].left = exp->_nodes[first].type;

-			t = trex_escapechar(exp);

-			exp->_nodes[r].right = t;

-            exp->_nodes[chain].next = r;

-			chain = r;

-			first = -1;

-		}

-		else{

-			if(first!=-1){

-				int c = first;

-				exp->_nodes[chain].next = c;

-				chain = c;

-				first = trex_charnode(exp,TRex_True);

-			}

-			else{

-				first = trex_charnode(exp,TRex_True);

-			}

-		}

-	}

-	if(first!=-1){

-		int c = first;

-		exp->_nodes[chain].next = c;

-		chain = c;

-		first = -1;

-	}

-	/* hack? */

-	exp->_nodes[ret].left = exp->_nodes[ret].next;

-	exp->_nodes[ret].next = -1;

-	return ret;

-}

-

-static int trex_parsenumber(TRex *exp)

-{

-	int ret = *exp->_p-'0';

-	int positions = 10;

-	exp->_p++;

-	while(isdigit(*exp->_p)) {

-		ret = ret*10+(*exp->_p++-'0');

-		if(positions==1000000000) trex_error(exp,_SC("overflow in numeric constant"));

-		positions *= 10;

-	};

-	return ret;

-}

-

-static int trex_element(TRex *exp)

-{

-	int ret = -1;

-	switch(*exp->_p)

-	{

-	case '(': {

-		int expr,newn;

-		exp->_p++;

-

-

-		if(*exp->_p =='?') {

-			exp->_p++;

-			trex_expect(exp,':');

-			expr = trex_newnode(exp,OP_NOCAPEXPR);

-		}

-		else

-			expr = trex_newnode(exp,OP_EXPR);

-		newn = trex_list(exp);

-		exp->_nodes[expr].left = newn;

-		ret = expr;

-		trex_expect(exp,')');

-			  }

-			  break;

-	case '[':

-		exp->_p++;

-		ret = trex_class(exp);

-		trex_expect(exp,']');

-		break;

-	case TREX_SYMBOL_END_OF_STRING: exp->_p++; ret = trex_newnode(exp,OP_EOL);break;

-	case TREX_SYMBOL_ANY_CHAR: exp->_p++; ret = trex_newnode(exp,OP_DOT);break;

-	default:

-		ret = trex_charnode(exp,TRex_False);

-		break;

-	}

-

-	{

-		int op;

-		TRexBool isgreedy = TRex_False;

-		unsigned short p0 = 0, p1 = 0;

-		switch(*exp->_p){

-			case TREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;

-			case TREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;

-			case TREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = TRex_True; break;

-			case '{':

-				exp->_p++;

-				if(!isdigit(*exp->_p)) trex_error(exp,_SC("number expected"));

-				p0 = (unsigned short)trex_parsenumber(exp);

-				/*******************************/

-				switch(*exp->_p) {

-			case '}':

-				p1 = p0; exp->_p++;

-				break;

-			case ',':

-				exp->_p++;

-				p1 = 0xFFFF;

-				if(isdigit(*exp->_p)){

-					p1 = (unsigned short)trex_parsenumber(exp);

-				}

-				trex_expect(exp,'}');

-				break;

-			default:

-				trex_error(exp,_SC(", or } expected"));

-		}

-		/*******************************/

-		isgreedy = TRex_True; 

-		break;

-

-		}

-		if(isgreedy) {

-			int nnode = trex_newnode(exp,OP_GREEDY);

-			op = OP_GREEDY;

-			exp->_nodes[nnode].left = ret;

-			exp->_nodes[nnode].right = ((p0)<<16)|p1;

-			ret = nnode;

-		}

-	}

-	if((*exp->_p != TREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != TREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != TREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {

-		int nnode = trex_element(exp);

-		exp->_nodes[ret].next = nnode;

-	}

-

-	return ret;

-}

-

-static int trex_list(TRex *exp)

-{

-	int ret=-1,e;

-	if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING) {

-		exp->_p++;

-		ret = trex_newnode(exp,OP_BOL);

-	}

-	e = trex_element(exp);

-	if(ret != -1) {

-		exp->_nodes[ret].next = e;

-	}

-	else ret = e;

-

-	if(*exp->_p == TREX_SYMBOL_BRANCH) {

-		int temp,tright;

-		exp->_p++;

-		temp = trex_newnode(exp,OP_OR);

-		exp->_nodes[temp].left = ret;

-		tright = trex_list(exp);

-		exp->_nodes[temp].right = tright;

-		ret = temp;

-	}

-	return ret;

-}

-

-static TRexBool trex_matchcclass(int cclass,TRexChar c)

-{

-	switch(cclass) {

-	case 'a': return isalpha(c)?TRex_True:TRex_False;

-	case 'A': return !isalpha(c)?TRex_True:TRex_False;

-	case 'w': return (isalnum(c) || c == '_')?TRex_True:TRex_False;

-	case 'W': return (!isalnum(c) && c != '_')?TRex_True:TRex_False;

-	case 's': return isspace(c)?TRex_True:TRex_False;

-	case 'S': return !isspace(c)?TRex_True:TRex_False;

-	case 'd': return isdigit(c)?TRex_True:TRex_False;

-	case 'D': return !isdigit(c)?TRex_True:TRex_False;

-	case 'x': return isxdigit(c)?TRex_True:TRex_False;

-	case 'X': return !isxdigit(c)?TRex_True:TRex_False;

-	case 'c': return iscntrl(c)?TRex_True:TRex_False;

-	case 'C': return !iscntrl(c)?TRex_True:TRex_False;

-	case 'p': return ispunct(c)?TRex_True:TRex_False;

-	case 'P': return !ispunct(c)?TRex_True:TRex_False;

-	case 'l': return islower(c)?TRex_True:TRex_False;

-	case 'u': return isupper(c)?TRex_True:TRex_False;

-	}

-	return TRex_False; /*cannot happen*/

-}

-

-static TRexBool trex_matchclass(TRex* exp,TRexNode *node,TRexChar c)

-{

-	do {

-		switch(node->type) {

-			case OP_RANGE:

-				if(c >= node->left && c <= node->right) return TRex_True;

-				break;

-			case OP_CCLASS:

-				if(trex_matchcclass(node->left,c)) return TRex_True;

-				break;

-			default:

-				if(c == node->type)return TRex_True;

-		}

-	} while((node->next != -1) && (node = &exp->_nodes[node->next]));

-	return TRex_False;

-}

-

-static const TRexChar *trex_matchnode(TRex* exp,TRexNode *node,const TRexChar *str,TRexNode *next)

-{

-	

-	TRexNodeType type = node->type;

-	switch(type) {

-	case OP_GREEDY: {

-		//TRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;

-		TRexNode *greedystop = NULL;

-		int p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;

-		const TRexChar *s=str, *good = str;

-

-		if(node->next != -1) {

-			greedystop = &exp->_nodes[node->next];

-		}

-		else {

-			greedystop = next;

-		}

-

-		while((nmaches == 0xFFFF || nmaches < p1)) {

-

-			const TRexChar *stop;

-			if(!(s = trex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))

-				break;

-			nmaches++;

-			good=s;

-			if(greedystop) {

-				//checks that 0 matches satisfy the expression(if so skips)

-				//if not would always stop(for instance if is a '?')

-				if(greedystop->type != OP_GREEDY ||

-				(greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))

-				{

-					TRexNode *gnext = NULL;

-					if(greedystop->next != -1) {

-						gnext = &exp->_nodes[greedystop->next];

-					}else if(next && next->next != -1){

-						gnext = &exp->_nodes[next->next];

-					}

-					stop = trex_matchnode(exp,greedystop,s,gnext);

-					if(stop) {

-						//if satisfied stop it

-						if(p0 == p1 && p0 == nmaches) break;

-						else if(nmaches >= p0 && p1 == 0xFFFF) break;

-						else if(nmaches >= p0 && nmaches <= p1) break;

-					}

-				}

-			}

-			

-			if(s >= exp->_eol)

-				break;

-		}

-		if(p0 == p1 && p0 == nmaches) return good;

-		else if(nmaches >= p0 && p1 == 0xFFFF) return good;

-		else if(nmaches >= p0 && nmaches <= p1) return good;

-		return NULL;

-	}

-	case OP_OR: {

-			const TRexChar *asd = str;

-			TRexNode *temp=&exp->_nodes[node->left];

-			while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {

-				if(temp->next != -1)

-					temp = &exp->_nodes[temp->next];

-				else

-					return asd;

-			}

-			asd = str;

-			temp = &exp->_nodes[node->right];

-			while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {

-				if(temp->next != -1)

-					temp = &exp->_nodes[temp->next];

-				else

-					return asd;

-			}

-			return NULL;

-			break;

-	}

-	case OP_EXPR:

-	case OP_NOCAPEXPR:{

-			TRexNode *n = &exp->_nodes[node->left];

-			const TRexChar *cur = str;

-			int capture = -1;

-			if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {

-				capture = exp->_currsubexp;

-				exp->_matches[capture].begin = cur;

-				exp->_currsubexp++;

-			}

-			

-			do {

-				TRexNode *subnext = NULL;

-				if(n->next != -1) {

-					subnext = &exp->_nodes[n->next];

-				}else {

-					subnext = next;

-				}

-				if(!(cur = trex_matchnode(exp,n,cur,subnext))) {

-					if(capture != -1){

-						exp->_matches[capture].begin = 0;

-						exp->_matches[capture].len = 0;

-					}

-					return NULL;

-				}

-			} while((n->next != -1) && (n = &exp->_nodes[n->next]));

-

-			if(capture != -1) 

-				exp->_matches[capture].len = cur - exp->_matches[capture].begin;

-			return cur;

-	}				 

-	case OP_WB:

-		if((str == exp->_bol && !isspace(*str))

-		 || (str == exp->_eol && !isspace(*(str-1)))

-		 || (!isspace(*str) && isspace(*(str+1)))

-		 || (isspace(*str) && !isspace(*(str+1))) ) {

-			return (node->left == 'b')?str:NULL;

-		}

-		return (node->left == 'b')?NULL:str;

-	case OP_BOL:

-		if(str == exp->_bol) return str;

-		return NULL;

-	case OP_EOL:

-		if(str == exp->_eol) return str;

-		return NULL;

-	case OP_DOT:{

-		*str++;

-				}

-		return str;

-	case OP_NCLASS:

-	case OP_CLASS:

-		if(trex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?TRex_True:TRex_False):(type == OP_NCLASS?TRex_True:TRex_False)) {

-			*str++;

-			return str;

-		}

-		return NULL;

-	case OP_CCLASS:

-		if(trex_matchcclass(node->left,*str)) {

-			*str++;

-			return str;

-		}

-		return NULL;

-	default: /* char */

-		if(*str != node->type) return NULL;

-		*str++;

-		return str;

-	}

-	return NULL;

-}

-

-/* public api */

-TRex *trex_compile(const TRexChar *pattern,const TRexChar **error)

-{

-	TRex *exp = (TRex *)malloc(sizeof(TRex));

-	exp->_eol = exp->_bol = NULL;

-	exp->_p = pattern;

-	exp->_nallocated = (int)scstrlen(pattern) * sizeof(TRexChar);

-	exp->_nodes = (TRexNode *)malloc(exp->_nallocated * sizeof(TRexNode));

-	exp->_nsize = 0;

-	exp->_matches = 0;

-	exp->_nsubexpr = 0;

-	exp->_first = trex_newnode(exp,OP_EXPR);

-	exp->_error = error;

-	exp->_jmpbuf = malloc(sizeof(jmp_buf));

-	if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {

-		int res = trex_list(exp);

-		exp->_nodes[exp->_first].left = res;

-		if(*exp->_p!='\0')

-			trex_error(exp,_SC("unexpected character"));

-#ifdef _DEBUG

-		{

-			int nsize,i;

-			TRexNode *t;

-			nsize = exp->_nsize;

-			t = &exp->_nodes[0];

-			scprintf(_SC("\n"));

-			for(i = 0;i < nsize; i++) {

-				if(exp->_nodes[i].type>MAX_CHAR)

-					scprintf(_SC("[%02d] %10s "),i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);

-				else

-					scprintf(_SC("[%02d] %10c "),i,exp->_nodes[i].type);

-				scprintf(_SC("left %02d right %02d next %02d\n"),exp->_nodes[i].left,exp->_nodes[i].right,exp->_nodes[i].next);

-			}

-			scprintf(_SC("\n"));

-		}

-#endif

-		exp->_matches = (TRexMatch *) malloc(exp->_nsubexpr * sizeof(TRexMatch));

-		memset(exp->_matches,0,exp->_nsubexpr * sizeof(TRexMatch));

-	}

-	else{

-		trex_free(exp);

-		return NULL;

-	}

-	return exp;

-}

-

-void trex_free(TRex *exp)

-{

-	if(exp)	{

-		if(exp->_nodes) free(exp->_nodes);

-		if(exp->_jmpbuf) free(exp->_jmpbuf);

-		if(exp->_matches) free(exp->_matches);

-		free(exp);

-	}

-}

-

-TRexBool trex_match(TRex* exp,const TRexChar* text)

-{

-	const TRexChar* res = NULL;

-	exp->_bol = text;

-	exp->_eol = text + scstrlen(text);

-	exp->_currsubexp = 0;

-	res = trex_matchnode(exp,exp->_nodes,text,NULL);

-	if(res == NULL || res != exp->_eol)

-		return TRex_False;

-	return TRex_True;

-}

-

-TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end)

-{

-	const TRexChar *cur = NULL;

-	int node = exp->_first;

-	if(text_begin >= text_end) return TRex_False;

-	exp->_bol = text_begin;

-	exp->_eol = text_end;

-	do {

-		cur = text_begin;

-		while(node != -1) {

-			exp->_currsubexp = 0;

-			cur = trex_matchnode(exp,&exp->_nodes[node],cur,NULL);

-			if(!cur)

-				break;

-			node = exp->_nodes[node].next;

-		}

-		*text_begin++;

-	} while(cur == NULL && text_begin != text_end);

-

-	if(cur == NULL)

-		return TRex_False;

-

-	--text_begin;

-

-	if(out_begin) *out_begin = text_begin;

-	if(out_end) *out_end = cur;

-	return TRex_True;

-}

-

-TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end)

-{

-	return trex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);

-}

-

-int trex_getsubexpcount(TRex* exp)

-{

-	return exp->_nsubexpr;

-}

-

-TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp)

-{

-	if( n<0 || n >= exp->_nsubexpr) return TRex_False;

-	*subexp = exp->_matches[n];

-	return TRex_True;

-}

-

diff --git a/drivers/trex/trex.h b/drivers/trex/trex.h
deleted file mode 100644
index 46e2e73fd5..0000000000
--- a/drivers/trex/trex.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef _TREX_H_

-#define _TREX_H_

-/***************************************************************

-	T-Rex a tiny regular expression library

-

-	Copyright (C) 2003-2006 Alberto Demichelis

-

-	This software is provided 'as-is', without any express 

-	or implied warranty. In no event will the authors be held 

-	liable for any damages arising from the use of this software.

-

-	Permission is granted to anyone to use this software for 

-	any purpose, including commercial applications, and to alter

-	it and redistribute it freely, subject to the following restrictions:

-

-		1. The origin of this software must not be misrepresented;

-		you must not claim that you wrote the original software.

-		If you use this software in a product, an acknowledgment

-		in the product documentation would be appreciated but

-		is not required.

-

-		2. Altered source versions must be plainly marked as such,

-		and must not be misrepresented as being the original software.

-

-		3. This notice may not be removed or altered from any

-		source distribution.

-

-****************************************************************/

-

-#define _UNICODE

-

-

-#ifdef _UNICODE

-#define TRexChar wchar_t

-#define MAX_CHAR 0xFFFF

-#define _TREXC(c) L##c 

-#define trex_strlen wcslen

-#define trex_printf wprintf

-#else

-#define TRexChar char

-#define MAX_CHAR 0xFF

-#define _TREXC(c) (c) 

-#define trex_strlen strlen

-#define trex_printf printf

-#endif

-

-#ifndef TREX_API

-#define TREX_API extern

-#endif

-

-#define TRex_True 1

-#define TRex_False 0

-

-typedef unsigned int TRexBool;

-typedef struct TRex TRex;

-

-typedef struct {

-	const TRexChar *begin;

-	int len;

-} TRexMatch;

-

-TREX_API TRex *trex_compile(const TRexChar *pattern,const TRexChar **error);

-TREX_API void trex_free(TRex *exp);

-TREX_API TRexBool trex_match(TRex* exp,const TRexChar* text);

-TREX_API TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end);

-TREX_API TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end);

-TREX_API int trex_getsubexpcount(TRex* exp);

-TREX_API TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp);

-

-#endif