diff --git a/src/acl.c b/src/acl.c
index f210119..86a8597 100644
--- a/src/acl.c
+++ b/src/acl.c
@@ -49,6 +49,12 @@
 	return -1;
 }
 
+/* input values are 0 or 3, output is the same */
+static inline enum acl_test_res pat2acl(enum pat_match_res res)
+{
+	return (enum acl_test_res)res;
+}
+
 /*
  * Registers the ACL keyword list <kwl> as a list of valid keywords for next
  * parsing sessions.
@@ -758,7 +764,7 @@
  * for unresolved dependencies.
  */
 struct acl_cond *parse_acl_cond(const char **args, struct list *known_acl,
-                                int pol, char **err, struct arg_list *al)
+                                enum acl_cond_pol pol, char **err, struct arg_list *al)
 {
 	__label__ out_return, out_free_suite, out_free_term;
 	int arg, neg;
@@ -914,7 +920,7 @@
  */
 struct acl_cond *build_acl_cond(const char *file, int line, struct proxy *px, const char **args, char **err)
 {
-	int pol = ACL_COND_NONE;
+	enum acl_cond_pol pol = ACL_COND_NONE;
 	struct acl_cond *cond = NULL;
 
 	if (err)
@@ -958,7 +964,7 @@
  *     if (cond->pol == ACL_COND_UNLESS)
  *         res = !res;
  */
-int acl_exec_cond(struct acl_cond *cond, struct proxy *px, struct session *l4, void *l7, unsigned int opt)
+enum acl_test_res acl_exec_cond(struct acl_cond *cond, struct proxy *px, struct session *l4, void *l7, unsigned int opt)
 {
 	__label__ fetch_next;
 	struct acl_term_suite *suite;
@@ -966,7 +972,7 @@
 	struct acl_expr *expr;
 	struct acl *acl;
 	struct sample smp;
-	int acl_res, suite_res, cond_res;
+	enum acl_test_res acl_res, suite_res, cond_res;
 
 	/* ACLs are iterated over all values, so let's always set the flag to
 	 * indicate this to the fetch functions.
@@ -979,7 +985,7 @@
 	cond_res = ACL_TEST_FAIL;
 	list_for_each_entry(suite, &cond->suites, list) {
 		/* Evaluate condition suite <suite>. We stop at the first term
-		 * which returns PAT_FAIL. The MISS status is still propagated
+		 * which returns ACL_TEST_FAIL. The MISS status is still propagated
 		 * in case of uncertainty in the result.
 		 */
 
@@ -1009,7 +1015,7 @@
 					continue;
 				}
 
-				acl_res |= pattern_exec_match(&expr->pat, &smp, NULL);
+				acl_res |= pat2acl(pattern_exec_match(&expr->pat, &smp, NULL));
 				/*
 				 * OK now acl_res holds the result of this expression
 				 * as one of ACL_TEST_FAIL, ACL_TEST_MISS or ACL_TEST_PASS.
diff --git a/src/auth.c b/src/auth.c
index d03621a..203b5aa 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -167,7 +167,7 @@
 		return 0;
 }
 
-int
+enum pat_match_res
 pat_match_auth(struct sample *smp, struct pattern *pattern)
 {
 
diff --git a/src/pattern.c b/src/pattern.c
index e3cb464..b6f7502 100644
--- a/src/pattern.c
+++ b/src/pattern.c
@@ -55,7 +55,7 @@
 	[PAT_MATCH_REG]   = pat_parse_reg,
 };
 
-int (*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern *) = {
+enum pat_match_res (*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern *) = {
 	[PAT_MATCH_FOUND] = NULL,
 	[PAT_MATCH_BOOL]  = pat_match_nothing,
 	[PAT_MATCH_INT]   = pat_match_int,
@@ -82,14 +82,14 @@
 }
 
 /* always return false */
-int pat_match_nothing(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_nothing(struct sample *smp, struct pattern *pattern)
 {
 	return PAT_NOMATCH;
 }
 
 
 /* NB: For two strings to be identical, it is required that their lengths match */
-int pat_match_str(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_str(struct sample *smp, struct pattern *pattern)
 {
 	int icase;
 
@@ -104,7 +104,7 @@
 }
 
 /* NB: For two binaries buf to be identical, it is required that their lengths match */
-int pat_match_bin(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_bin(struct sample *smp, struct pattern *pattern)
 {
 	if (pattern->len != smp->data.str.len)
 		return PAT_NOMATCH;
@@ -136,7 +136,7 @@
 /* Executes a regex. It temporarily changes the data to add a trailing zero,
  * and restores the previous character when leaving.
  */
-int pat_match_reg(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_reg(struct sample *smp, struct pattern *pattern)
 {
 	if (regex_exec(pattern->ptr.reg, smp->data.str.str, smp->data.str.len) == 0)
 		return PAT_MATCH;
@@ -144,7 +144,7 @@
 }
 
 /* Checks that the pattern matches the beginning of the tested string. */
-int pat_match_beg(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_beg(struct sample *smp, struct pattern *pattern)
 {
 	int icase;
 
@@ -159,7 +159,7 @@
 }
 
 /* Checks that the pattern matches the end of the tested string. */
-int pat_match_end(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_end(struct sample *smp, struct pattern *pattern)
 {
 	int icase;
 
@@ -175,7 +175,7 @@
 /* Checks that the pattern is included inside the tested string.
  * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
  */
-int pat_match_sub(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_sub(struct sample *smp, struct pattern *pattern)
 {
 	int icase;
 	char *end;
@@ -285,7 +285,7 @@
  * between the delimiters '?' or '/' or at the beginning or end of the string.
  * Delimiters at the beginning or end of the pattern are ignored.
  */
-int pat_match_dir(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_dir(struct sample *smp, struct pattern *pattern)
 {
 	return match_word(smp, pattern, make_4delim('/', '?', '?', '?'));
 }
@@ -294,13 +294,13 @@
  * between the delmiters '/', '?', '.' or ":" or at the beginning or end of
  * the string. Delimiters at the beginning or end of the pattern are ignored.
  */
-int pat_match_dom(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_dom(struct sample *smp, struct pattern *pattern)
 {
 	return match_word(smp, pattern, make_4delim('/', '?', '.', ':'));
 }
 
 /* Checks that the integer in <test> is included between min and max */
-int pat_match_int(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_int(struct sample *smp, struct pattern *pattern)
 {
 	if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.uint) &&
 	    (!pattern->val.range.max_set || smp->data.uint <= pattern->val.range.max))
@@ -309,7 +309,7 @@
 }
 
 /* Checks that the length of the pattern in <test> is included between min and max */
-int pat_match_len(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_len(struct sample *smp, struct pattern *pattern)
 {
 	if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.str.len) &&
 	    (!pattern->val.range.max_set || smp->data.str.len <= pattern->val.range.max))
@@ -317,7 +317,7 @@
 	return PAT_NOMATCH;
 }
 
-int pat_match_ip(struct sample *smp, struct pattern *pattern)
+enum pat_match_res pat_match_ip(struct sample *smp, struct pattern *pattern)
 {
 	unsigned int v4; /* in network byte order */
 	struct in6_addr *v6;
@@ -939,10 +939,10 @@
  * with the pointer associated with the matching pattern. This function returns
  * PAT_NOMATCH or PAT_MATCH.
  */
-inline int pattern_exec_match(struct pattern_expr *expr, struct sample *smp,
-                          struct sample_storage **sample)
+enum pat_match_res pattern_exec_match(struct pattern_expr *expr, struct sample *smp,
+                                      struct sample_storage **sample)
 {
-	int pat_res = PAT_NOMATCH;
+	enum pat_match_res pat_res = PAT_NOMATCH;
 	struct pattern *pattern;
 	struct ebmb_node *node = NULL;
 	struct pat_idx_elt *elt;
diff --git a/src/proto_http.c b/src/proto_http.c
index 57102c8..3a4c535 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -8974,7 +8974,7 @@
 }
 
 /* See above how the method is stored in the global pattern */
-static int pat_match_meth(struct sample *smp, struct pattern *pattern)
+static enum pat_match_res pat_match_meth(struct sample *smp, struct pattern *pattern)
 {
 	int icase;
 
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 92f1b68..17a100a 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -904,7 +904,7 @@
 		partial = 0;
 
 	list_for_each_entry(rule, &s->be->tcp_req.inspect_rules, list) {
-		int ret = ACL_TEST_PASS;
+		enum acl_test_res ret = ACL_TEST_PASS;
 
 		if (rule->cond) {
 			ret = acl_exec_cond(rule->cond, s->be, s, &s->txn, SMP_OPT_DIR_REQ | partial);
@@ -1008,7 +1008,7 @@
 		partial = 0;
 
 	list_for_each_entry(rule, &s->be->tcp_rep.inspect_rules, list) {
-		int ret = ACL_TEST_PASS;
+		enum acl_test_res ret = ACL_TEST_PASS;
 
 		if (rule->cond) {
 			ret = acl_exec_cond(rule->cond, s->be, s, &s->txn, SMP_OPT_DIR_RES | partial);
@@ -1075,7 +1075,7 @@
 	struct stksess *ts;
 	struct stktable *t = NULL;
 	int result = 1;
-	int ret;
+	enum acl_test_res ret;
 
 	list_for_each_entry(rule, &s->fe->tcp_req.l4_rules, list) {
 		ret = ACL_TEST_PASS;
