@@ -169,6 +169,8 @@ libclamav_la_SOURCES = \

 	iana_tld.h \

 	regex_list.c \

 	regex_list.h \

+	regex_suffix.c \

+	regex_suffix.h \

 	mspack.c \

 	mspack.h \

 	cab.c \

@@ -88,8 +88,9 @@ am_libclamav_la_OBJECTS = matcher-ac.lo matcher-bm.lo matcher.lo \

 	regerror.lo regexec.lo regfree.lo unarj.lo bzlib.lo nulsft.lo \

 	infblock.lo pdf.lo spin.lo yc.lo elf.lo sis.lo uuencode.lo \

 	phishcheck.lo phish_domaincheck_db.lo phish_whitelist.lo \

-	regex_list.lo mspack.lo cab.lo entconv.lo hashtab.lo dconf.lo \

-	lzma_iface.lo explode.lo textnorm.lo dlp.lo js-norm.lo

+	regex_list.lo regex_suffix.lo mspack.lo cab.lo entconv.lo \

+	hashtab.lo dconf.lo lzma_iface.lo explode.lo textnorm.lo \

+	dlp.lo js-norm.lo

 libclamav_la_OBJECTS = $(am_libclamav_la_OBJECTS)

 libclamav_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \

 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \

@@ -410,6 +411,8 @@ libclamav_la_SOURCES = \

 	iana_tld.h \

 	regex_list.c \

 	regex_list.h \

+	regex_suffix.c \

+	regex_suffix.h \

 	mspack.c \

 	mspack.h \

 	cab.c \

@@ -582,6 +585,7 @@ distclean-compile:

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regcomp.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regerror.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regex_list.Plo@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regex_suffix.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regexec.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regfree.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtf.Plo@am__quote@

@@ -83,6 +83,7 @@ CLAMAV_PRIVATE {

     cli_unescape;

     cli_textbuffer_append_normalize;

     cli_dconf_init;

+    cli_regex2suffix;

     html_normalise_mem;

   local:

     *;

@@ -56,380 +56,14 @@

 #include "str.h"

 #include "readdb.h"

 #include "jsparse/textbuf.h"

-

-/* ------- parse a regular expression, and extract a static suffix ------*/

-enum node_type {

-	root=0,

-	concat,

-	alternate, /* | */

-	optional,/* ?, * */

-	leaf, /* a character */

-	leaf_class /* character class */

-	/* (x)+ is transformed into (x)*(x) */

-};

-

-struct node {

-	enum node_type type;

-	struct node *parent;

-	union {

-		struct {

-			struct node* left;

-			struct node* right;

-		} children;

-		uint8_t*    leaf_class_bitmap;

-		uint8_t     leaf_char;

-	} u;

-};

-

+#include "regex_suffix.h"

 /* Prototypes */

 static size_t reverse_string(char *pattern);

 static int add_pattern(struct regex_matcher *matcher, char *pattern);

-static int add_pattern_suffix(struct regex_matcher *matcher, char *suffix, size_t suffix_len, struct regex_list *regex);

+static int add_pattern_suffix(void *cbdata, const char *suffix, size_t suffix_len, struct regex_list *regex);

 static int add_static_pattern(struct regex_matcher *matcher, char* pattern);

-static int build_suffixtree_descend(struct regex_matcher *matcher, struct regex_list *regex, struct node *n, struct text_buffer *buf);

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

-static uint8_t dot_bitmap[32];

-

-static struct node* make_node(enum node_type type, struct node *left, struct node *right)

-{

-	struct node *n;

-	if(type == concat) {

-		if(left == NULL)

-			return right;

-		if(right == NULL)

-			return left;

-	}

-	n = cli_malloc(sizeof(*n));

-	if(!n)

-		return NULL;

-	n->type = type;

-	n->parent = NULL;

-	n->u.children.left = left;

-	n->u.children.right = right;

-	if(left)

-		left->parent = n;

-	if(right)

-		right->parent = n;

-	return n;

-}

-

-static struct node *dup_node(struct node *p)

-{

-	struct node *node_left, *node_right;

-	struct node *d;

-

-	if(!p)

-		return NULL;

-	d = cli_malloc(sizeof(*d));

-	if(!d)

-		return NULL;

-	d->type = p->type;

-	d->parent = NULL;

-	switch(p->type) {

-		case leaf:

-			d->u.leaf_char = p->u.leaf_char;

-			break;

-		case leaf_class:

-			d->u.leaf_class_bitmap = cli_malloc(32);

-			if(!d->u.leaf_class_bitmap)

-				return NULL;

-			memcpy(d->u.leaf_class_bitmap, p->u.leaf_class_bitmap, 32);

-			break;

-		default:

-			node_left = dup_node(p->u.children.left);

-			node_right = dup_node(p->u.children.right);

-			d->u.children.left = node_left;

-			d->u.children.right = node_right;

-			if(node_left)

-				node_left->parent = d;

-			if(node_right)

-				node_right->parent = d;

-			break;

-	}

-	return d;

-}

-

-static struct node *make_charclass(uint8_t *bitmap)

-{

-	struct node *v = cli_malloc(sizeof(*v));

-	if(!v)

-		return NULL;

-	v->type = leaf_class;

-	v->parent = NULL;

-	v->u.leaf_class_bitmap = bitmap;

-	return v;

-}

-

-static struct node *make_leaf(char c)

-{

-	struct node *v = cli_malloc(sizeof(*v));

-	if(!v)

-		return NULL;

-	v->type = leaf;

-	v->parent = NULL;

-	v->u.leaf_char = c;

-	return v;

-}

-

-static void destroy_tree(struct node *n)

-{

-	if(!n)

-		return;

-	switch(n->type) {

-		case concat:

-		case alternate:

-		case optional:

-			destroy_tree(n->u.children.left);

-			destroy_tree(n->u.children.right);

-			break;

-		case leaf_class:

-			if(n->u.leaf_class_bitmap != dot_bitmap)

-			  free(n->u.leaf_class_bitmap);

-			break;

-		case root:

-		case leaf:

-			break;

-	}

-	free(n);

-}

-

-static uint8_t* parse_char_class(const char *pat, size_t *pos)

-{

-	unsigned char range_start=0;

-	int hasprev = 0;

-	uint8_t* bitmap = cli_malloc(32);

-	if(!bitmap)

-		return NULL;

-	if (pat[*pos]=='^') {

-		memset(bitmap,0xFF,32);/*match chars not in brackets*/

-		++*pos;

-	}

-	else

-		memset(bitmap,0x00,32);

-	do {

-		/* literal ] can be first character, so test for it at the end of the loop, for example: []] */

-		if (pat[*pos]=='-' && hasprev) {

-			/* it is a range*/

-			unsigned char range_end;

-			unsigned int c;

-			assert(range_start);

-			++*pos;

-			if (pat[*pos]=='[')

-				if (pat[*pos+1]=='.') {

-					/* collating sequence not handled */

-					free(bitmap);

-					/* we are parsing the regex for a

-					 * filter, be conservative and

-					 * tell the filter that anything could

-					 * match here */

-					while(pat[*pos] != ']') ++*pos;

-					++*pos;

-					while(pat[*pos] != ']') ++*pos;

-					return dot_bitmap;

-				}

-				else

-					range_end = pat[*pos];

-			else

-				range_end = pat[*pos];

-			for(c=range_start+1;c<=range_end;c++)

-				bitmap[c>>3] ^= 1<<(c&0x7);

-			hasprev = 0;

-		}

-		else if (pat[*pos]=='[' && pat[*pos]==':') {

-			/* char class */

-			free(bitmap);

-			while(pat[*pos] != ']') ++*pos;

-			++*pos;

-			while(pat[*pos] != ']') ++*pos;

-			return dot_bitmap;

-		} else {

-			bitmap[pat[*pos]>>3] ^= 1<<(pat[*pos]&0x7);

-			++*pos;

-			range_start = pat[*pos];

-			hasprev = 1;

-		}

-	} while(pat[*pos]!=']');

-	return bitmap;

-}

-

-static struct node* parse_regex(const char *p, size_t *last)

-{

-	struct node *v = NULL;

-	struct node *right;

-	struct node *tmp;

-

-	while(p[*last] != '$' && p[*last] != '\0') {

-		switch(p[*last]) {

-			case '|':

-				++*last;

-				right = parse_regex(p, last);

-				v = make_node(alternate, v, right);

-				if(!v)

-					return NULL;

-				break;

-			case '*':

-			case '?':

-				v = make_node(optional, v, NULL);

-				if(!v)

-					return NULL;

-				++*last;

-				break;

-			case '+':

-				/* (x)* */

-				tmp = make_node(optional, v, NULL);

-				if(!tmp)

-					return NULL;

-				/* (x) */

-				right = dup_node(v);

-				if(!right)

-					return NULL;

-				/* (x)*(x) => (x)+ */

-				v = make_node(concat, tmp, right);

-				if(!v)

-					return NULL;

-				++*last;

-				break;

-			case '(':

-				++*last;

-				right = parse_regex(p, last);

-				if(!right)

-					return NULL;

-				++*last;

-				v = make_node(concat, v, right);

-				break;

-			case ')':

-				return v;

-			case '.':

-				right = make_charclass(dot_bitmap);

-				if(!right)

-					return NULL;

-				v = make_node(concat, v, right);

-				if(!v)

-					return NULL;

-				++*last;

-				break;

-			case '[':

-				right = make_charclass( parse_char_class(p, last) );

-				if(!right)

-					return NULL;

-				v = make_node(concat, v, right);

-				if(!v)

-					return NULL;

-			case '\\':

-				/* next char is escaped, advance pointer

-				 * and let fall-through handle it */

-				++*last;

-			default:

-				right = make_leaf(p[*last]);

-				v = make_node(concat, v, right);

-				if(!v)

-					return NULL;

-				++*last;

-				break;

-		}

-	}

-	return v;

-}

-

-#define BITMAP_HASSET(b, i) (b[i>>3] & (1<<(i&7)))

-

-static int build_suffixtree_ascend(struct regex_matcher *matcher, struct regex_list *regex, struct node *n, struct text_buffer *buf, struct node *prev)

-{

-	size_t i;

-	while(n) {

-		struct node *q = n;

-		switch(n->type) {

-			case root:

-				textbuffer_putc(buf, '\0');

-				if(add_pattern_suffix(matcher, buf->data, buf->pos, regex) < 0)

-					return CL_EMEM;

-				return 0;

-			case leaf:

-				textbuffer_putc(buf, n->u.leaf_char);

-				n = n->parent;

-				break;

-			case leaf_class:

-				if(memcmp(n->u.leaf_class_bitmap, dot_bitmap, sizeof(dot_bitmap)) == 0) {

-					textbuffer_putc(buf, '\0');

-					if(add_pattern_suffix(matcher, buf->data, buf->pos, regex) < 0)

-						return CL_EMEM;

-					return 0;

-				}

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

-					if(BITMAP_HASSET(n->u.leaf_class_bitmap, i)) {

-						size_t pos;

-						pos = buf->pos;

-						textbuffer_putc(buf, i);

-						if(build_suffixtree_ascend(matcher, regex, n->parent, buf, n) < 0)

-							return CL_EMEM;

-						buf->pos = pos;

-					}

-				}

-				return 0;

-			case concat:

-				if(prev != n->u.children.left) {

-					if(build_suffixtree_descend(matcher, regex, n->u.children.left, buf) < 0)

-						return CL_EMEM;

-					/* we're done here, descend will call

-					 * ascend if needed */

-					return 0;

-				} else {

-					n = n->parent;

-				}

-				break;

-			case alternate:

-				n = n->parent;

-				break;

-			case optional:

-				textbuffer_putc(buf, '\0');

-				if(add_pattern_suffix(matcher, buf->data, buf->pos, regex) < 0)

-					return CL_EMEM;

-				return 0;

-		}

-		prev = q;

-	}

-	return 0;

-}

-

-static int build_suffixtree_descend(struct regex_matcher *matcher, struct regex_list *regex, struct node *n, struct text_buffer *buf)

-{

-	size_t pos;

-	while(n && n->type == concat) {

-		n = n->u.children.right;

-	}

-	if(!n)

-		return 0;

-	/* find out end of the regular expression,

-	 * if it ends with a static pattern */

-	switch(n->type) {

-		case alternate:

-			/* save pos as restart point */

-			pos = buf->pos;

-			if(build_suffixtree_descend(matcher, regex, n->u.children.left, buf) < 0)

-				return CL_EMEM;

-			buf->pos = pos;

-			if(build_suffixtree_descend(matcher, regex, n->u.children.right, buf) < 0)

-				return CL_EMEM;

-			buf->pos = pos;

-			break;

-		case optional:

-			textbuffer_putc(buf, '\0');

-			if(add_pattern_suffix(matcher, buf->data, buf->pos, regex) < 0)

-				return CL_EMEM;

-			return 0;

-		case leaf:

-		case leaf_class:

-			if(build_suffixtree_ascend(matcher, regex, n, buf, NULL) < 0)

-			        return CL_EMEM;

-			return 0;

-		default:

-			break;

-	}

-	return 0;

-}

-

-

 /* ----- shift-or filtering -------------- */

 #define BITMAP_CONTAINS(bmap, val) ((bmap)[(val) >> 5] & (1 << ((val) & 0x1f)))

@@ -557,7 +191,6 @@ static inline size_t get_char_at_pos_with_skip(const struct pre_fixup_info* info

 static int validate_subdomain(const struct regex_list *regex, const struct pre_fixup_info *pre_fixup, const char *buffer, size_t buffer_len, char *real_url, size_t real_len, char *orig_real_url)

 {

 	char c;

-	const char *matched;

 	size_t match_len;

 	if(!regex || !regex->pattern)

@@ -626,7 +259,6 @@ int regex_list_match(struct regex_matcher* matcher,char* real_url,const char* di

 		size_t buffer_len  = (hostOnly && !is_whitelist) ? real_len + 1 : real_len + display_len + 1 + 1;

 		char *buffer = cli_malloc(buffer_len+1);

 		char *bufrev;

-		size_t i;

 		int rc = 0;

 		struct cli_ac_data mdata;

@@ -662,7 +294,7 @@ int regex_list_match(struct regex_matcher* matcher,char* real_url,const char* di

 		if(rc) {

 			/* TODO loop over multiple virusnames here */

-			regex = (struct regex_list*)vinfo;

+			regex = (const struct regex_list*)vinfo;

 			do {

 				/* loop over multiple regexes corresponding to

 				 * this suffix */

@@ -903,7 +535,7 @@ int is_regex_ok(struct regex_matcher* matcher)

 	return (!matcher->list_inited || matcher->list_inited!=-1);/* either we don't have a regexlist, or we initialized it successfully */

 }

-static int add_newsuffix(struct regex_matcher *matcher, struct regex_list *info, char *suffix, size_t len)

+static int add_newsuffix(struct regex_matcher *matcher, struct regex_list *info, const char *suffix, size_t len)

 {

 	struct cli_matcher *root = &matcher->suffixes;

 	struct cli_ac_patt *new = cli_calloc(1,sizeof(*new));

@@ -951,8 +583,9 @@ static int add_newsuffix(struct regex_matcher *matcher, struct regex_list *info,

 /* ------ load a regex, determine suffix, determine suffix2regexlist map ---- */

 /* returns 0 on success, clamav error code otherwise */

-static int add_pattern_suffix(struct regex_matcher *matcher, char *suffix, size_t suffix_len, struct regex_list *regex)

+static int add_pattern_suffix(void *cbdata, const char *suffix, size_t suffix_len, struct regex_list *regex)

 {

+	struct regex_matcher *matcher = cbdata;

 	const struct element *el;

 	assert(matcher);

@@ -1006,12 +639,8 @@ static int add_static_pattern(struct regex_matcher *matcher, char* pattern)

 static int add_pattern(struct regex_matcher *matcher, char *pattern)

 {

-	struct text_buffer buf;

-	struct node *n;

-	size_t last=0;

 	int rc;

 	struct regex_list *regex = cli_malloc(sizeof(*regex));

-	struct node root_node;

 	size_t len;

 	/* we only match the host, so remove useless stuff */

 	const char remove_end[] = "([/?].*)?/";

@@ -1032,32 +661,11 @@ static int add_pattern(struct regex_matcher *matcher, char *pattern)

 	}

 	pattern[len] = '\0';

-

-	rc = cli_regcomp(&regex->preg, pattern, REG_EXTENDED);

+	rc = cli_regex2suffix(pattern, regex, add_pattern_suffix, matcher);

 	if(rc) {

-		size_t buflen = cli_regerror(rc, &regex->preg, NULL, 0);

-		char *errbuf = cli_malloc(buflen);

-		if(errbuf) {

-			cli_regerror(rc, &regex->preg, errbuf, buflen);

-			cli_errmsg(MODULE "Error compiling regular expression %s: %s\n", pattern, errbuf);

-			free(errbuf);

-		} else {

-			cli_errmsg(MODULE "Error compiling regular expression: %s\n", pattern);

-		}

-		return rc;

 		cli_regfree(&regex->preg);

 		free(regex);

-		return CL_EMALFDB;

 	}

-	regex->pattern = cli_strdup(pattern);

-	regex->nxt = NULL;

-

-	n = parse_regex(pattern, &last);

-	memset(&buf, 0, sizeof(buf));

-	memset(&root_node, 0, sizeof(buf));

-	n->parent = &root_node;

-	rc = build_suffixtree_descend(matcher, regex, n, &buf);

-	destroy_tree(n);

 	return rc;

 }

@@ -29,12 +29,6 @@

 #include "matcher.h"

 #include <zlib.h> /* for gzFile */

-struct regex_list {

-	const char *pattern;

-	regex_t preg;

-	struct regex_list *nxt;

-};

-

 struct filter {

 	uint32_t B[65536];

 	uint32_t end_fast[256];

new file mode 100644

@@ -0,0 +1,448 @@

+/*

+ *  Parse a regular expression, and extract a static suffix.

+ *

+ *  Copyright (C) 2007-2008 Sourcefire, Inc.

+ *

+ *  Authors: Török Edvin

+ *

+ *  This program is free software; you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License version 2 as

+ *  published by the Free Software Foundation.

+ *

+ *  This program is distributed in the hope that it will be useful,

+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *  GNU General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with this program; if not, write to the Free Software

+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

+ *  MA 02110-1301, USA.

+ */

+#if HAVE_CONFIG_H

+#include "clamav-config.h"

+#endif

+

+#ifndef CL_DEBUG

+#define NDEBUG

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <assert.h>

+

+#include "others.h"

+#include "jsparse/textbuf.h"

+#include "regex_suffix.h"

+#define MODULE "regex_suffix: "

+

+

+enum node_type {

+	root=0,

+	concat,

+	alternate, /* | */

+	optional,/* ?, * */

+	leaf, /* a character */

+	leaf_class /* character class */

+	/* (x)+ is transformed into (x)*(x) */

+};

+

+struct node {

+	enum node_type type;

+	struct node *parent;

+	union {

+		struct {

+			struct node* left;

+			struct node* right;

+		} children;

+		uint8_t*    leaf_class_bitmap;

+		uint8_t     leaf_char;

+	} u;

+};

+

+/* --- Prototypes --*/

+static int build_suffixtree_descend(struct node *n, struct text_buffer *buf, suffix_callback cb, void *cbdata, struct regex_list *regex);

+/* -----------------*/

+

+static uint8_t dot_bitmap[32];

+

+static struct node* make_node(enum node_type type, struct node *left, struct node *right)

+{

+	struct node *n;

+	if(type == concat) {

+		if(left == NULL)

+			return right;

+		if(right == NULL)

+			return left;

+	}

+	n = cli_malloc(sizeof(*n));

+	if(!n)

+		return NULL;

+	n->type = type;

+	n->parent = NULL;

+	n->u.children.left = left;

+	n->u.children.right = right;

+	if(left)

+		left->parent = n;

+	if(right)

+		right->parent = n;

+	return n;

+}

+

+static struct node *dup_node(struct node *p)

+{

+	struct node *node_left, *node_right;

+	struct node *d;

+

+	if(!p)

+		return NULL;

+	d = cli_malloc(sizeof(*d));

+	if(!d)

+		return NULL;

+	d->type = p->type;

+	d->parent = NULL;

+	switch(p->type) {

+		case leaf:

+			d->u.leaf_char = p->u.leaf_char;

+			break;

+		case leaf_class:

+			d->u.leaf_class_bitmap = cli_malloc(32);

+			if(!d->u.leaf_class_bitmap)

+				return NULL;

+			memcpy(d->u.leaf_class_bitmap, p->u.leaf_class_bitmap, 32);

+			break;

+		default:

+			node_left = dup_node(p->u.children.left);

+			node_right = dup_node(p->u.children.right);

+			d->u.children.left = node_left;

+			d->u.children.right = node_right;

+			if(node_left)

+				node_left->parent = d;

+			if(node_right)

+				node_right->parent = d;

+			break;

+	}

+	return d;

+}

+

+static struct node *make_charclass(uint8_t *bitmap)

+{

+	struct node *v = cli_malloc(sizeof(*v));

+	if(!v)

+		return NULL;

+	v->type = leaf_class;

+	v->parent = NULL;

+	v->u.leaf_class_bitmap = bitmap;

+	return v;

+}

+

+static struct node *make_leaf(char c)

+{

+	struct node *v = cli_malloc(sizeof(*v));

+	if(!v)

+		return NULL;

+	v->type = leaf;

+	v->parent = NULL;

+	v->u.leaf_char = c;

+	return v;

+}

+

+static void destroy_tree(struct node *n)

+{

+	if(!n)

+		return;

+	switch(n->type) {

+		case concat:

+		case alternate:

+		case optional:

+			destroy_tree(n->u.children.left);

+			destroy_tree(n->u.children.right);

+			break;

+		case leaf_class:

+			if(n->u.leaf_class_bitmap != dot_bitmap)

+			  free(n->u.leaf_class_bitmap);

+			break;

+		case root:

+		case leaf:

+			break;

+	}

+	free(n);

+}

+

+static uint8_t* parse_char_class(const char *pat, size_t *pos)

+{

+	unsigned char range_start=0;

+	int hasprev = 0;

+	uint8_t* bitmap = cli_malloc(32);

+	if(!bitmap)

+		return NULL;

+	if (pat[*pos]=='^') {

+		memset(bitmap,0xFF,32);/*match chars not in brackets*/

+		++*pos;

+	}

+	else

+		memset(bitmap,0x00,32);

+	do {

+		/* literal ] can be first character, so test for it at the end of the loop, for example: []] */

+		if (pat[*pos]=='-' && hasprev) {

+			/* it is a range*/

+			unsigned char range_end;

+			unsigned int c;

+			assert(range_start);

+			++*pos;

+			if (pat[*pos]=='[')

+				if (pat[*pos+1]=='.') {

+					/* collating sequence not handled */

+					free(bitmap);

+					/* we are parsing the regex for a

+					 * filter, be conservative and

+					 * tell the filter that anything could

+					 * match here */

+					while(pat[*pos] != ']') ++*pos;

+					++*pos;

+					while(pat[*pos] != ']') ++*pos;

+					return dot_bitmap;

+				}

+				else

+					range_end = pat[*pos];

+			else

+				range_end = pat[*pos];

+			for(c=range_start+1;c<=range_end;c++)

+				bitmap[c>>3] ^= 1<<(c&0x7);

+			hasprev = 0;

+		}

+		else if (pat[*pos]=='[' && pat[*pos]==':') {

+			/* char class */

+			free(bitmap);

+			while(pat[*pos] != ']') ++*pos;

+			++*pos;

+			while(pat[*pos] != ']') ++*pos;

+			return dot_bitmap;

+		} else {

+			bitmap[pat[*pos]>>3] ^= 1<<(pat[*pos]&0x7);

+			++*pos;

+			range_start = pat[*pos];

+			hasprev = 1;

+		}

+	} while(pat[*pos]!=']');

+	return bitmap;

+}

+

+static struct node* parse_regex(const char *p, size_t *last)

+{

+	struct node *v = NULL;

+	struct node *right;

+	struct node *tmp;

+

+	while(p[*last] != '$' && p[*last] != '\0') {

+		switch(p[*last]) {

+			case '|':

+				++*last;

+				right = parse_regex(p, last);

+				v = make_node(alternate, v, right);

+				if(!v)

+					return NULL;

+				break;

+			case '*':

+			case '?':

+				v = make_node(optional, v, NULL);

+				if(!v)

+					return NULL;

+				++*last;

+				break;

+			case '+':

+				/* (x)* */

+				tmp = make_node(optional, v, NULL);

+				if(!tmp)

+					return NULL;

+				/* (x) */

+				right = dup_node(v);

+				if(!right)

+					return NULL;

+				/* (x)*(x) => (x)+ */

+				v = make_node(concat, tmp, right);

+				if(!v)

+					return NULL;

+				++*last;

+				break;

+			case '(':

+				++*last;

+				right = parse_regex(p, last);

+				if(!right)

+					return NULL;

+				++*last;

+				v = make_node(concat, v, right);

+				break;

+			case ')':

+				return v;

+			case '.':

+				right = make_charclass(dot_bitmap);

+				if(!right)

+					return NULL;

+				v = make_node(concat, v, right);

+				if(!v)

+					return NULL;

+				++*last;

+				break;

+			case '[':

+				right = make_charclass( parse_char_class(p, last) );

+				if(!right)

+					return NULL;

+				v = make_node(concat, v, right);

+				if(!v)

+					return NULL;

+			case '\\':

+				/* next char is escaped, advance pointer

+				 * and let fall-through handle it */

+				++*last;

+			default:

+				right = make_leaf(p[*last]);

+				v = make_node(concat, v, right);

+				if(!v)

+					return NULL;

+				++*last;

+				break;

+		}

+	}

+	return v;

+}

+

+#define BITMAP_HASSET(b, i) (b[i>>3] & (1<<(i&7)))

+

+static int build_suffixtree_ascend(struct node *n, struct text_buffer *buf, struct node *prev, suffix_callback cb, void *cbdata, struct regex_list *regex)

+{

+	size_t i;

+	while(n) {

+		struct node *q = n;

+		switch(n->type) {

+			case root:

+				textbuffer_putc(buf, '\0');

+				if(cb(cbdata, buf->data, buf->pos-1, regex) < 0)

+					return CL_EMEM;

+				return 0;

+			case leaf:

+				textbuffer_putc(buf, n->u.leaf_char);

+				n = n->parent;

+				break;

+			case leaf_class:

+				if(memcmp(n->u.leaf_class_bitmap, dot_bitmap, sizeof(dot_bitmap)) == 0) {

+					textbuffer_putc(buf, '\0');

+					if(cb(cbdata, buf->data, buf->pos-1, regex) < 0)

+						return CL_EMEM;

+					return 0;

+				}

+				for(i=0;i<255;i++) {

+					if(BITMAP_HASSET(n->u.leaf_class_bitmap, i)) {

+						size_t pos;

+						pos = buf->pos;

+						textbuffer_putc(buf, i);

+						if(build_suffixtree_ascend(n->parent, buf, n, cb, cbdata, regex) < 0)