//  NREX: Node RegEx
//  Version 0.2
//
//  Copyright (c) 2015-2016, 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 <wchar.h>
#include <wctype.h>
#define NREX_ISALPHANUM iswalnum
#define NREX_ISSPACE iswspace
#define NREX_STRLEN wcslen
#else
#include <ctype.h>
#include <string.h>
#define NREX_ISALPHANUM isalnum
#define NREX_ISSPACE isspace
#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(unsigned int reserved) :
			_data(NREX_NEW_ARRAY(T, reserved ? reserved : 1)),
			_reserved(reserved ? reserved : 1),
			_size(0) {
	}

	~nrex_array() {
		NREX_DELETE_ARRAY(_data);
	}

	unsigned int size() const {
		return _size;
	}

	void reserve(unsigned int size) {
		if (size < _size) {
			size = _size;
		}
		if (size == 0) {
			size = 1;
		}
		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++;
	}

	const T &top() const {
		return _data[_size - 1];
	}

	const T &operator[](unsigned int i) const {
		return _data[i];
	}

	void pop() {
		if (_size > 0) {
			--_size;
		}
	}
};

static int nrex_parse_hex(nrex_char 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;
}

static nrex_char nrex_unescape(const nrex_char *&c) {
	switch (c[1]) {
		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';
		case 'x': {
			int point = 0;
			for (int i = 2; i <= 3; ++i) {
				int res = nrex_parse_hex(c[i]);
				if (res == -1) {
					return '\0';
				}
				point = (point << 4) + res;
			}
			c = &c[3];
			return nrex_char(point);
		}
		case 'u': {
			int point = 0;
			for (int i = 2; i <= 5; ++i) {
				int res = nrex_parse_hex(c[i]);
				if (res == -1) {
					return '\0';
				}
				point = (point << 4) + res;
			}
			c = &c[5];
			return nrex_char(point);
		}
	}
	return (++c)[0];
}

struct nrex_search {
	const nrex_char *str;
	nrex_result *captures;
	int end;
	bool complete;
	nrex_array<int> lookahead_pos;

	nrex_char at(int pos) {
		return str[pos];
	}

	nrex_search(const nrex_char *str, nrex_result *captures, int lookahead) :
			str(str),
			captures(captures),
			end(0),
			lookahead_pos(lookahead) {
	}
};

struct nrex_node {
	nrex_node *next;
	nrex_node *previous;
	nrex_node *parent;
	bool quantifiable;
	int length;

	nrex_node(bool quantify = false) :
			next(NULL),
			previous(NULL),
			parent(NULL),
			quantifiable(quantify),
			length(-1) {
	}

	virtual ~nrex_node() {
		if (next) {
			NREX_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 (pos >= 0) {
			s->complete = true;
		}
		if (parent && pos >= 0) {
			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);
		}
	}
};

enum nrex_group_type {
	nrex_group_capture,
	nrex_group_non_capture,
	nrex_group_bracket,
	nrex_group_look_ahead,
	nrex_group_look_behind,
};

struct nrex_node_group : public nrex_node {
	nrex_group_type type;
	int id;
	bool negate;
	nrex_array<nrex_node *> childset;
	nrex_node *back;

	nrex_node_group(nrex_group_type type, int id = 0) :
			nrex_node(true),
			type(type),
			id(id),
			negate(false),
			back(NULL) {
		if (type != nrex_group_bracket) {
			length = 0;
		} else {
			length = 1;
		}
		if (type == nrex_group_look_ahead || type == nrex_group_look_behind) {
			quantifiable = false;
		}
	}

	virtual ~nrex_node_group() {
		for (unsigned int i = 0; i < childset.size(); ++i) {
			NREX_DELETE(childset[i]);
		}
	}

	int test(nrex_search *s, int pos) const {
		int old_start;
		if (type == nrex_group_capture) {
			old_start = s->captures[id].start;
			s->captures[id].start = pos;
		}
		for (unsigned int i = 0; i < childset.size(); ++i) {
			s->complete = false;
			int offset = 0;
			if (type == nrex_group_look_behind) {
				if (pos < length) {
					return -1;
				}
				offset = length;
			}
			if (type == nrex_group_look_ahead) {
				s->lookahead_pos.push(pos);
			}
			int res = childset[i]->test(s, pos - offset);
			if (type == nrex_group_look_ahead) {
				s->lookahead_pos.pop();
			}
			if (s->complete) {
				return res;
			}
			if (negate) {
				if (res < 0) {
					res = pos + 1;
				} else {
					return -1;
				}
				if (i + 1 < childset.size()) {
					continue;
				}
			}
			if (res >= 0) {
				if (type == nrex_group_capture) {
					s->captures[id].length = res - pos;
				} else if (type == nrex_group_look_ahead || type == nrex_group_look_behind) {
					res = pos;
				}
				return next ? next->test(s, res) : res;
			}
		}
		if (type == nrex_group_capture) {
			s->captures[id].start = old_start;
		}
		return -1;
	}

	virtual int test_parent(nrex_search *s, int pos) const {
		if (type == nrex_group_capture) {
			s->captures[id].length = pos - s->captures[id].start;
		}
		if (type == nrex_group_look_ahead) {
			pos = s->lookahead_pos[id];
		}
		return nrex_node::test_parent(s, pos);
	}

	void add_childset() {
		if (childset.size() > 0 && type != nrex_group_bracket) {
			length = -1;
		}
		back = NULL;
	}

	void add_child(nrex_node *node) {
		node->parent = this;
		node->previous = back;
		if (back && type != nrex_group_bracket) {
			back->next = node;
		} else {
			childset.push(node);
		}
		if (type != nrex_group_bracket) {
			increment_length(node->length);
		}
		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();
		}
		if (type != nrex_group_bracket) {
			increment_length(old->length, true);
		}
		back = old->previous;
		add_child(node);
		return old;
	}

	void pop_back() {
		if (back) {
			nrex_node *old = back;
			if (!old->previous) {
				childset.pop();
			}
			if (type != nrex_group_bracket) {
				increment_length(old->length, true);
			}
			back = old->previous;
			NREX_DELETE(old);
		}
	}
};

struct nrex_node_char : public nrex_node {
	nrex_char ch;

	nrex_node_char(nrex_char c) :
			nrex_node(true),
			ch(c) {
		length = 1;
	}

	int test(nrex_search *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;
	}
};

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) {
		length = 1;
	}

	int test(nrex_search *s, int pos) const {
		if (s->end <= pos || 0 > 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;
	}
};

enum nrex_class_type {
	nrex_class_none,
	nrex_class_alnum,
	nrex_class_alpha,
	nrex_class_blank,
	nrex_class_cntrl,
	nrex_class_digit,
	nrex_class_graph,
	nrex_class_lower,
	nrex_class_print,
	nrex_class_punct,
	nrex_class_space,
	nrex_class_upper,
	nrex_class_xdigit,
	nrex_class_word
};

static bool nrex_compare_class(const nrex_char **pos, const char *text) {
	unsigned int i = 0;
	for (i = 0; text[i] != '\0'; ++i) {
		if ((*pos)[i] != text[i]) {
			return false;
		}
	}
	if ((*pos)[i++] != ':' || (*pos)[i] != ']') {
		return false;
	}
	*pos = &(*pos)[i];
	return true;
}

#define NREX_COMPARE_CLASS(POS, NAME) \
	if (nrex_compare_class(POS, #NAME)) return nrex_class_##NAME

static nrex_class_type nrex_parse_class(const nrex_char **pos) {
	NREX_COMPARE_CLASS(pos, alnum);
	NREX_COMPARE_CLASS(pos, alpha);
	NREX_COMPARE_CLASS(pos, blank);
	NREX_COMPARE_CLASS(pos, cntrl);
	NREX_COMPARE_CLASS(pos, digit);
	NREX_COMPARE_CLASS(pos, graph);
	NREX_COMPARE_CLASS(pos, lower);
	NREX_COMPARE_CLASS(pos, print);
	NREX_COMPARE_CLASS(pos, punct);
	NREX_COMPARE_CLASS(pos, space);
	NREX_COMPARE_CLASS(pos, upper);
	NREX_COMPARE_CLASS(pos, xdigit);
	NREX_COMPARE_CLASS(pos, word);
	return nrex_class_none;
}

struct nrex_node_class : public nrex_node {
	nrex_class_type type;

	nrex_node_class(nrex_class_type t) :
			nrex_node(true),
			type(t) {
		length = 1;
	}

	int test(nrex_search *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;
	}

	bool test_class(nrex_char c) const {
		if ((0 <= c && c <= 0x1F) || c == 0x7F) {
			if (type == nrex_class_cntrl) {
				return true;
			}
		} else if (c < 0x7F) {
			if (type == nrex_class_print) {
				return true;
			} else if (type == nrex_class_graph && c != ' ') {
				return true;
			} else if ('0' <= c && c <= '9') {
				switch (type) {
					case nrex_class_alnum:
					case nrex_class_digit:
					case nrex_class_xdigit:
					case nrex_class_word:
						return true;
					default:
						break;
				}
			} else if ('A' <= c && c <= 'Z') {
				switch (type) {
					case nrex_class_alnum:
					case nrex_class_alpha:
					case nrex_class_upper:
					case nrex_class_word:
						return true;
					case nrex_class_xdigit:
						if (c <= 'F') {
							return true;
						}
					default:
						break;
				}
			} else if ('a' <= c && c <= 'z') {
				switch (type) {
					case nrex_class_alnum:
					case nrex_class_alpha:
					case nrex_class_lower:
					case nrex_class_word:
						return true;
					case nrex_class_xdigit:
						if (c <= 'f') {
							return true;
						}
					default:
						break;
				}
			}
		}
		switch (c) {
			case ' ':
			case '\t':
				if (type == nrex_class_blank) {
					return true;
				}
			case '\r':
			case '\n':
			case '\f':
				if (type == nrex_class_space) {
					return true;
				}
				break;
			case '_':
				if (type == nrex_class_word) {
					return true;
				}
			case ']':
			case '[':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '.':
			case '/':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case '\\':
			case '^':
			case '`':
			case '{':
			case '|':
			case '}':
			case '~':
			case '-':
				if (type == nrex_class_punct) {
					return true;
				}
				break;
			default:
				break;
		}
		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) {
		length = 1;
	}

	int test(nrex_search *s, int pos) const {
		if (s->end <= pos || 0 > 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_ISSPACE(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(int min, int max) :
			nrex_node(),
			min(min),
			max(max),
			greedy(true),
			child(NULL) {
	}

	virtual ~nrex_node_quantifier() {
		if (child) {
			NREX_DELETE(child);
		}
	}

	int test(nrex_search *s, int pos) const {
		return test_step(s, pos, 0, pos);
	}

	int test_step(nrex_search *s, int pos, int level, int start) const {
		if (pos > s->end) {
			return -1;
		}
		if (!greedy && level > min) {
			int res = pos;
			if (next) {
				res = next->test(s, res);
			}
			if (s->complete) {
				return res;
			}
			if (res >= 0 && parent->test_parent(s, res) >= 0) {
				return res;
			}
		}
		if (max >= 0 && level > max) {
			return -1;
		}
		if (level > 1 && level > min + 1 && pos == start) {
			return -1;
		}
		int res = pos;
		if (level >= 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;
			} else 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;
	}

	virtual int test_parent(nrex_search *s, int pos) const {
		s->complete = false;
		return pos;
	}
};

struct nrex_node_anchor : public nrex_node {
	bool end;

	nrex_node_anchor(bool end) :
			nrex_node(),
			end(end) {
		length = 0;
	}

	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_word_boundary : public nrex_node {
	bool inverse;

	nrex_node_word_boundary(bool inverse) :
			nrex_node(),
			inverse(inverse) {
		length = 0;
	}

	int test(nrex_search *s, int pos) const {
		bool left = false;
		bool right = false;
		if (pos != 0) {
			nrex_char c = s->at(pos - 1);
			if (c == '_' || NREX_ISALPHANUM(c)) {
				left = true;
			}
		}
		if (pos != s->end) {
			nrex_char c = s->at(pos);
			if (c == '_' || NREX_ISALPHANUM(c)) {
				right = true;
			}
		}
		if ((left != right) == inverse) {
			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) {
		length = -1;
	}

	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;
	}
};

bool nrex_has_lookbehind(nrex_array<nrex_node_group *> &stack) {
	for (unsigned int i = 0; i < stack.size(); i++) {
		if (stack[i]->type == nrex_group_look_behind) {
			return true;
		}
	}
	return false;
}

nrex::nrex() :
		_capturing(0),
		_lookahead_depth(0),
		_root(NULL) {
}

nrex::nrex(const nrex_char *pattern, int captures) :
		_capturing(0),
		_lookahead_depth(0),
		_root(NULL) {
	compile(pattern, captures);
}

nrex::~nrex() {
	if (_root) {
		NREX_DELETE(_root);
	}
}

bool nrex::valid() const {
	return (_root != NULL);
}

void nrex::reset() {
	_capturing = 0;
	_lookahead_depth = 0;
	if (_root) {
		NREX_DELETE(_root);
	}
	_root = NULL;
}

int nrex::capture_size() const {
	if (_root) {
		return _capturing + 1;
	}
	return 0;
}

bool nrex::compile(const nrex_char *pattern, int captures) {
	reset();
	nrex_node_group *root = NREX_NEW(nrex_node_group(nrex_group_capture, _capturing));
	nrex_array<nrex_node_group *> stack;
	stack.push(root);
	unsigned int lookahead_level = 0;
	_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(nrex_group_non_capture));
					stack.top()->add_child(group);
					stack.push(group);
				} else if (c[2] == '!' || c[2] == '=') {
					c = &c[2];
					nrex_node_group *group = NREX_NEW(nrex_node_group(nrex_group_look_ahead, lookahead_level++));
					group->negate = (c[0] == '!');
					stack.top()->add_child(group);
					stack.push(group);
					if (lookahead_level > _lookahead_depth) {
						_lookahead_depth = lookahead_level;
					}
				} else if (c[2] == '<' && (c[3] == '!' || c[3] == '=')) {
					c = &c[3];
					nrex_node_group *group = NREX_NEW(nrex_node_group(nrex_group_look_behind));
					group->negate = (c[0] == '!');
					stack.top()->add_child(group);
					stack.push(group);
				} else {
					NREX_COMPILE_ERROR("unrecognised qualifier for group");
				}
			} else if (captures >= 0 && _capturing < captures) {
				nrex_node_group *group = NREX_NEW(nrex_node_group(nrex_group_capture, ++_capturing));
				stack.top()->add_child(group);
				stack.push(group);
			} else {
				nrex_node_group *group = NREX_NEW(nrex_node_group(nrex_group_non_capture));
				stack.top()->add_child(group);
				stack.push(group);
			}
		} else if (c[0] == ')') {
			if (stack.size() > 1) {
				if (stack.top()->type == nrex_group_look_ahead) {
					--lookahead_level;
				}
				stack.pop();
			} else {
				NREX_COMPILE_ERROR("unexpected ')'");
			}
		} else if (c[0] == '[') {
			nrex_node_group *group = NREX_NEW(nrex_node_group(nrex_group_bracket));
			stack.top()->add_child(group);
			if (c[1] == '^') {
				group->negate = true;
				++c;
			}
			bool first_child = true;
			nrex_char previous_child;
			bool previous_child_single = false;
			while (true) {
				group->add_childset();
				++c;
				if (c[0] == '\0') {
					NREX_COMPILE_ERROR("unclosed bracket expression '['");
				}
				if (c[0] == '[' && c[1] == ':') {
					const nrex_char *d = &c[2];
					nrex_class_type cls = nrex_parse_class(&d);
					if (cls != nrex_class_none) {
						c = d;
						group->add_child(NREX_NEW(nrex_node_class(cls)));
						previous_child_single = false;
					} else {
						group->add_child(NREX_NEW(nrex_node_char('[')));
						previous_child = '[';
						previous_child_single = true;
					}
				} else if (c[0] == ']' && !first_child) {
					break;
				} else if (c[0] == '\\') {
					if (nrex_is_shorthand(c[1])) {
						group->add_child(NREX_NEW(nrex_node_shorthand(c[1])));
						++c;
						previous_child_single = false;
					} else {
						const nrex_char *d = c;
						nrex_char unescaped = nrex_unescape(d);
						if (c == d) {
							NREX_COMPILE_ERROR("invalid escape token");
						}
						group->add_child(NREX_NEW(nrex_node_char(unescaped)));
						c = d;
						previous_child = unescaped;
						previous_child_single = true;
					}
				} else if (previous_child_single && c[0] == '-') {
					bool is_range = false;
					nrex_char next;
					if (c[1] != '\0' && c[1] != ']') {
						if (c[1] == '\\') {
							const nrex_char *d = ++c;
							next = nrex_unescape(d);
							if (c == d) {
								NREX_COMPILE_ERROR("invalid escape token in range");
							}
						} else {
							next = c[1];
							++c;
						}
						is_range = true;
					}
					if (is_range) {
						if (next < previous_child) {
							NREX_COMPILE_ERROR("text range out of order");
						}
						group->pop_back();
						group->add_child(NREX_NEW(nrex_node_range(previous_child, next)));
						previous_child_single = false;
					} else {
						group->add_child(NREX_NEW(nrex_node_char(c[0])));
						previous_child = c[0];
						previous_child_single = true;
					}
				} else {
					group->add_child(NREX_NEW(nrex_node_char(c[0])));
					previous_child = c[0];
					previous_child_single = true;
				}
				first_child = false;
			}
		} else if (nrex_is_quantifier(c[0])) {
			int min = 0;
			int max = -1;
			bool valid_quantifier = true;
			if (c[0] == '?') {
				min = 0;
				max = 1;
			} else if (c[0] == '+') {
				min = 1;
				max = -1;
			} else if (c[0] == '*') {
				min = 0;
				max = -1;
			} else if (c[0] == '{') {
				bool max_set = false;
				const nrex_char *d = c;
				while (true) {
					++d;
					if (d[0] == '\0') {
						valid_quantifier = false;
						break;
					} else if (d[0] == '}') {
						break;
					} else if (d[0] == ',') {
						max_set = true;
						continue;
					} else if (d[0] < '0' || '9' < d[0]) {
						valid_quantifier = false;
						break;
					}
					if (max_set) {
						if (max < 0) {
							max = int(d[0] - '0');
						} else {
							max = max * 10 + int(d[0] - '0');
						}
					} else {
						min = min * 10 + int(d[0] - '0');
					}
				}
				if (!max_set) {
					max = min;
				}
				if (valid_quantifier) {
					c = d;
				}
			}
			if (valid_quantifier) {
				if (stack.top()->back == NULL || !stack.top()->back->quantifiable) {
					NREX_COMPILE_ERROR("element not quantifiable");
				}
				nrex_node_quantifier *quant = NREX_NEW(nrex_node_quantifier(min, max));
				if (min == max) {
					if (stack.top()->back->length >= 0) {
						quant->length = max * stack.top()->back->length;
					}
				} else {
					if (nrex_has_lookbehind(stack)) {
						NREX_COMPILE_ERROR("variable length quantifiers inside lookbehind not supported");
					}
				}
				quant->child = stack.top()->swap_back(quant);
				quant->child->previous = NULL;
				quant->child->next = NULL;
				quant->child->parent = quant;
				if (c[1] == '?') {
					quant->greedy = false;
					++c;
				}
			} else {
				stack.top()->add_child(NREX_NEW(nrex_node_char(c[0])));
			}
		} else if (c[0] == '|') {
			if (nrex_has_lookbehind(stack)) {
				NREX_COMPILE_ERROR("alternations inside lookbehind not supported");
			}
			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] == '\\') {
			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') || (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 (c[1] == '}') {
					unclosed = false;
					++c;
				}
				if (ref > _capturing || ref <= 0 || unclosed) {
					NREX_COMPILE_ERROR("backreference to non-existent capture");
				}
				if (nrex_has_lookbehind(stack)) {
					NREX_COMPILE_ERROR("backreferences inside lookbehind not supported");
				}
				stack.top()->add_child(NREX_NEW(nrex_node_backreference(ref)));
			} else if (c[1] == 'b' || c[1] == 'B') {
				stack.top()->add_child(NREX_NEW(nrex_node_word_boundary(c[1] == 'B')));
				++c;
			} else {
				const nrex_char *d = c;
				nrex_char unescaped = nrex_unescape(d);
				if (c == d) {
					NREX_COMPILE_ERROR("invalid escape token");
				}
				stack.top()->add_child(NREX_NEW(nrex_node_char(unescaped)));
				c = d;
			}
		} else {
			stack.top()->add_child(NREX_NEW(nrex_node_char(c[0])));
		}
	}
	if (stack.size() > 1) {
		NREX_COMPILE_ERROR("unclosed group '('");
	}
	return true;
}

bool nrex::match(const nrex_char *str, nrex_result *captures, int offset, int end) const {
	if (!_root) {
		return false;
	}
	nrex_search s(str, captures, _lookahead_depth);
	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;
}