diff --git a/include/common/cfgparse.h b/include/common/cfgparse.h
index 9e75a65..fd04b14 100644
--- a/include/common/cfgparse.h
+++ b/include/common/cfgparse.h
@@ -80,6 +80,10 @@
 int warnif_misplaced_tcp_conn(struct proxy *proxy, const char *file, int line, const char *arg);
 int warnif_misplaced_tcp_sess(struct proxy *proxy, const char *file, int line, const char *arg);
 int warnif_misplaced_tcp_cont(struct proxy *proxy, const char *file, int line, const char *arg);
+int too_many_args_idx(int maxarg, int index, char **args, char **msg, int *err_code);
+int too_many_args(int maxarg, char **args, char **msg, int *err_code);
+int alertif_too_many_args_idx(int maxarg, int index, const char *file, int linenum, char **args, int *err_code);
+int alertif_too_many_args(int maxarg, const char *file, int linenum, char **args, int *err_code);
 
 /*
  * Sends a warning if proxy <proxy> does not have at least one of the
