diff --git a/include/proto/pattern.h b/include/proto/pattern.h
index b9947b5..30a4f81 100644
--- a/include/proto/pattern.h
+++ b/include/proto/pattern.h
@@ -80,40 +80,37 @@
 
 
 /* ignore the current line */
-int pat_parse_nothing(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_nothing(const char *text, struct pattern *pattern, char **err);
 
 /* Parse an integer. It is put both in min and max. */
-int pat_parse_int(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_int(const char *text, struct pattern *pattern, char **err);
 
 /* Parse len like an integer, but specify expected string type */
-int pat_parse_len(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_len(const char *text, struct pattern *pattern, char **err);
 
 /* Parse an version. It is put both in min and max. */
-int pat_parse_dotted_ver(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_dotted_ver(const char *text, struct pattern *pattern, char **err);
 
 /* Parse a range of integers delimited by either ':' or '-'. If only one
  * integer is read, it is set as both min and max.
  */
-int pat_parse_range(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_range(const char *text, struct pattern *pattern, char **err);
 
 /* Parse a string. It is allocated and duplicated. */
-int pat_parse_str(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_str(const char *text, struct pattern *pattern, char **err);
 
 /* Parse a hexa binary definition. It is allocated and duplicated. */
-int pat_parse_bin(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
-
-/* Parse and concatenate strings into one. It is allocated and duplicated. */
-int pat_parse_strcat(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_bin(const char *text, struct pattern *pattern, char **err);
 
 /* Parse a regex. It is allocated. */
-int pat_parse_reg(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_reg(const char *text, struct pattern *pattern, char **err);
 
 /* Parse an IP address and an optional mask in the form addr[/mask].
  * The addr may either be an IPv4 address or a hostname. The mask
  * may either be a dotted mask or a number of bits. Returns 1 if OK,
  * otherwise 0.
  */
-int pat_parse_ip(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+int pat_parse_ip(const char *text, struct pattern *pattern, char **err);
 
 /* NB: For two strings to be identical, it is required that their lengths match */
 enum pat_match_res pat_match_str(struct sample *smp, struct pattern *pattern);
diff --git a/include/types/acl.h b/include/types/acl.h
index 0b6524b..722bfe6 100644
--- a/include/types/acl.h
+++ b/include/types/acl.h
@@ -92,7 +92,7 @@
 struct acl_keyword {
 	const char *kw;
 	char *fetch_kw;
-	int (*parse)(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+	int (*parse)(const char *text, struct pattern *pattern, char **err);
 	int (*index)(struct pattern_expr *expr, struct pattern *pattern, char **err);
 	enum pat_match_res (*match)(struct sample *smp, struct pattern *pattern);
 	/* must be after the config params */
diff --git a/include/types/pattern.h b/include/types/pattern.h
index c4f235f..c59bebc 100644
--- a/include/types/pattern.h
+++ b/include/types/pattern.h
@@ -61,15 +61,6 @@
 	PAT_MATCH = 3,           /* sample matched at least one pattern */
 };
 
-/* This enum describe the running mode of the function pat_parse_*().
- * The lookup mode does not allocate memory. The compile mode allocate
- * memory and create any data
- */
-enum pat_usage {
-	PAT_U_LOOKUP,
-	PAT_U_COMPILE,
-};
-
 /* possible flags for expressions or patterns */
 enum {
 	PAT_F_IGNORE_CASE = 1 << 0,       /* ignore case */
@@ -164,7 +155,7 @@
  * are grouped together in order to optimize caching.
  */
 struct pattern_expr {
-	int (*parse)(const char *text, struct pattern *pattern, enum pat_usage usage, char **err);
+	int (*parse)(const char *text, struct pattern *pattern, char **err);
 	int (*index)(struct pattern_expr *, struct pattern *, char **);
 	enum pat_match_res (*match)(struct sample *smp, struct pattern *pattern);
 	struct list patterns;         /* list of acl_patterns */
@@ -172,7 +163,7 @@
 };
 
 extern char *pat_match_names[PAT_MATCH_NUM];
-extern int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, enum pat_usage, char **);
+extern int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, char **);
 extern int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, char **);
 extern enum pat_match_res (*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern *);
 extern int pat_match_types[PAT_MATCH_NUM];
diff --git a/src/pattern.c b/src/pattern.c
index e652190..84b54fb 100644
--- a/src/pattern.c
+++ b/src/pattern.c
@@ -40,7 +40,7 @@
 	[PAT_MATCH_REG]   = "reg",
 };
 
-int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, enum pat_usage, char **) = {
+int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, char **) = {
 	[PAT_MATCH_FOUND] = pat_parse_nothing,
 	[PAT_MATCH_BOOL]  = pat_parse_nothing,
 	[PAT_MATCH_INT]   = pat_parse_int,
@@ -194,46 +194,28 @@
  */
 
 /* ignore the current line */
-int pat_parse_nothing(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_nothing(const char *text, struct pattern *pattern, char **err)
 {
 	return 1;
 }
 
 /* Parse a string. It is allocated and duplicated. */
-int pat_parse_str(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_str(const char *text, struct pattern *pattern, char **err)
 {
 	pattern->type = SMP_T_CSTR;
 	pattern->expect_type = SMP_T_CSTR;
-	if (usage == PAT_U_COMPILE) {
-		pattern->ptr.str = strdup(text);
-		if (!pattern->ptr.str) {
-			memprintf(err, "out of memory while loading string pattern");
-			return 0;
-		}
-	}
-	else
-		pattern->ptr.str = (char *)text;
+	pattern->ptr.str = (char *)text;
 	pattern->len = strlen(text);
 	return 1;
 }
 
 /* Parse a binary written in hexa. It is allocated. */
-int pat_parse_bin(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_bin(const char *text, struct pattern *pattern, char **err)
 {
 	struct chunk *trash;
 
 	pattern->type = SMP_T_CBIN;
 	pattern->expect_type = SMP_T_CBIN;
-
-	if (usage == PAT_U_COMPILE)
-		/* If the parse_binary fails, it returns 0. In succes case, it returns
-		 * the length of the arsed binary content. The functions pat_parse_* 
-		 * must return 0 if fail and the number of elements eated from **text
-		 * if not fail. In succes case, this function eat always 1 elements.
-		 * The double operator "!" converts the range "1-n" to "1".
-		 */
-		return !!parse_binary(text, &pattern->ptr.str, &pattern->len, err);
-
 	trash = get_trash_chunk();
 	pattern->len = trash->size;
 	pattern->ptr.str = trash->str;
@@ -241,40 +223,21 @@
 }
 
 /* Parse a regex. It is allocated. */
-int pat_parse_reg(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_reg(const char *text, struct pattern *pattern, char **err)
 {
-	struct my_regex *preg;
 	struct chunk *trash;
 
-	if (usage == PAT_U_COMPILE) {
-
-		preg = calloc(1, sizeof(*preg));
-		if (!preg) {
-			memprintf(err, "out of memory while loading pattern");
-			return 0;
-		}
-
-		if (!regex_comp(text, preg, !(pattern->flags & PAT_F_IGNORE_CASE), 0, err)) {
-			free(preg);
-			return 0;
-		}
-		pattern->freeptrbuf = &pat_free_reg;
+	trash = get_trash_chunk();
+	if (trash->size < sizeof(*pattern->ptr.reg)) {
+		memprintf(err, "no space avalaible in the buffer. expect %d, provides %d",
+		          (int)sizeof(*pattern->ptr.reg), trash->size);
+		return 0;
 	}
-	else {
 
-		trash = get_trash_chunk();
-		if (trash->size < sizeof(*preg)) {
-			memprintf(err, "no space avalaible in the buffer. expect %d, provides %d",
-			          (int)sizeof(*preg), trash->size);
-			return 0;
-		}
-
-		preg = (struct my_regex *)trash->str;
-		preg->regstr = (char *)text;
-		pattern->freeptrbuf = NULL;
-	}
+	pattern->ptr.reg = (struct my_regex *)trash->str;
+	pattern->ptr.reg->regstr = (char *)text;
+	pattern->freeptrbuf = NULL;
 
-	pattern->ptr.reg = preg;
 	pattern->expect_type = SMP_T_CSTR;
 	return 1;
 }
@@ -294,7 +257,7 @@
  * non-zero on success.
  *
  */
-int pat_parse_int(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_int(const char *text, struct pattern *pattern, char **err)
 {
 	const char *ptr = text;
 
@@ -360,11 +323,11 @@
 	return 0;
 }
 
-int pat_parse_len(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_len(const char *text, struct pattern *pattern, char **err)
 {
 	int ret;
 
-	ret = pat_parse_int(text, pattern, usage, err);
+	ret = pat_parse_int(text, pattern, err);
 	pattern->expect_type = SMP_T_CSTR;
 	return ret;
 }
@@ -389,7 +352,7 @@
  *    acl valid_ssl       ssl_req_proto 3.0-3.1
  *
  */
-int pat_parse_dotted_ver(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_dotted_ver(const char *text, struct pattern *pattern, char **err)
 {
 	const char *ptr = text;
 
@@ -457,7 +420,7 @@
  * may either be a dotted mask or a number of bits. Returns 1 if OK,
  * otherwise 0. NOTE: IP address patterns are typed (IPV4/IPV6).
  */
-int pat_parse_ip(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+int pat_parse_ip(const char *text, struct pattern *pattern, char **err)
 {
 	pattern->expect_type = SMP_T_ADDR;
 	if (str2net(text, &pattern->val.ipv4.addr, &pattern->val.ipv4.mask)) {
@@ -1021,7 +984,7 @@
 	pattern.smp = smp;
 
 	/* parse pattern */
-	ret = expr->parse(arg, &pattern, PAT_U_LOOKUP, err);
+	ret = expr->parse(arg, &pattern, err);
 	if (!ret)
 		return 0;
 
@@ -1176,7 +1139,7 @@
 		return 0;
 
 	/* build lookup pattern */
-	if (!expr->parse(key, &pattern, PAT_U_LOOKUP, NULL))
+	if (!expr->parse(key, &pattern, NULL))
 		return 0;
 
 	pat = NULL;
diff --git a/src/proto_http.c b/src/proto_http.c
index 8bd10b7..7c0c915 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -8973,7 +8973,7 @@
  * We use the pre-parsed method if it is known, and store its number as an
  * integer. If it is unknown, we use the pointer and the length.
  */
-static int pat_parse_meth(const char *text, struct pattern *pattern, enum pat_usage usage, char **err)
+static int pat_parse_meth(const char *text, struct pattern *pattern, char **err)
 {
 	int len, meth;
 	struct chunk *trash;
@@ -8983,22 +8983,13 @@
 
 	pattern->val.i = meth;
 	if (meth == HTTP_METH_OTHER) {
-		if (usage == PAT_U_COMPILE) {
-			pattern->ptr.str = strdup(text);
-			if (!pattern->ptr.str) {
-				memprintf(err, "out of memory while loading pattern");
-				return 0;
-			}
-		}
-		else {
-			trash = get_trash_chunk();
-			if (trash->size < len) {
-				memprintf(err, "no space avalaible in the buffer. expect %d, provides %d",
-				          len, trash->size);
-				return 0;
-			}
-			pattern->ptr.str = trash->str;
+		trash = get_trash_chunk();
+		if (trash->size < len) {
+			memprintf(err, "no space avalaible in the buffer. expect %d, provides %d",
+			          len, trash->size);
+			return 0;
 		}
+		pattern->ptr.str = trash->str;
 		pattern->expect_type = SMP_T_CSTR;
 		pattern->len = len;
 	}