diff --git a/doc/configuration.txt b/doc/configuration.txt
index f566d2f..babcefc 100644
--- a/doc/configuration.txt
+++ b/doc/configuration.txt
@@ -12645,10 +12645,10 @@
 it will explain what part of the command is invalid when this happens.
 
 add acl <acl> <pattern>
-  Add an entry into the acl <acl>. This command does not verify if the entry
-  already exists. This command cannot be used if the reference <acl> is a file
-  also used with a map. In this case, you must use the command 'add map' in
-  place of 'add acl'.
+  Add an entry into the acl <acl>. <acl> is the #<id> or the <file> returned by
+  "show acl". This command does not verify if the entry already exists. This
+  command cannot be used if the reference <acl> is a file also used with a map.
+  In this case, you must use the command "add map" in place of "add acl".
 
 add map <map> <key> <value>
   Add an entry into the map <map> to associate the value <value> to the key
@@ -12670,12 +12670,14 @@
   and can only be issued on sockets configured for level "admin".
 
 clear acl <acl>
-  Remove all entries from the acl <acl>. Note that if the reference <acl> is a
-  file and is shared with a map, this map will be also cleared.
+  Remove all entries from the acl <acl>. <acl> is the #<id> or the <file>
+  returned by "show acl". Note that if the reference <acl> is a file and is
+  shared with a map, this map will be also cleared.
 
 clear map <map>
-  Remove all entries from the map <map>. Note that if the reference <map> is a
-  file and is shared with a acl, this acl will be also cleared.
+  Remove all entries from the map <map>. <map> is the #<id> or the <file>
+  returned by "show map". Note that if the reference <map> is a file and is
+  shared with a acl, this acl will be also cleared.
 
 clear table <table> [ data.<type> <operator> <value> ] | [ key <key> ]
   Remove entries from the stick-table <table>.
@@ -12727,17 +12729,17 @@
 
 del acl <acl> [<key>|#<ref>]
   Delete all the acl entries from the acl <acl> corresponding to the key <key>.
-  If the <ref> is used, this command delete only the listed reference. The
-  reference can be found with listing the content of the acl. Note that if the
-  reference <acl> is a file and is shared with a map, the entry will be also
-  deleted in the map.
+  <acl> is the #<id> or the <file> returned by "show acl". If the <ref> is used,
+  this command delete only the listed reference. The reference can be found with
+  listing the content of the acl. Note that if the reference <acl> is a file and
+  is shared with a map, the entry will be also deleted in the map.
 
 del map <map> [<key>|#<ref>]
   Delete all the map entries from the map <map> corresponding to the key <key>.
-  If the <ref> is used, this command delete only the listed reference. The
-  reference can be found with listing the content of the map. Note that if the
-  reference <map> is a file and is shared with a acl, the entry will be also
-  deleted in the map.
+  <map> is the #<id> or the <file> returned by "show map". If the <ref> is used,
+  this command delete only the listed reference. The reference can be found with
+  listing the content of the map. Note that if the reference <map> is a file and
+  is shared with a acl, the entry will be also deleted in the map.
 
 disable agent <backend>/<server>
   Mark the auxiliary agent check as temporarily stopped.
@@ -12825,11 +12827,12 @@
   level "admin".
 
 get map <map> <value>
-get acl <map> <value>
-  Lookup the value <value> in the map <map>. This command returns all the
-  matching patterns associated with this map. This is useful for debugging maps
-  and ACLs. The output format is composed by one line par matching type. Each
-  line is composed by space-delimited series of words.
+get acl <acl> <value>
+  Lookup the value <value> in the map <map> or in the ACL <acl>. <map> or <acl>
+  are the #<id> or the <file> returned by "show map" or "show acl". This command
+  returns all the matching patterns associated with this map. This is useful for
+  debugging maps and ACLs. The output format is composed by one line par
+  matching type. Each line is composed by space-delimited series of words.
 
   The first two words are:
 
@@ -12884,9 +12887,9 @@
   Close the connection when in interactive mode.
 
 set map <map> [<key>|#<ref>] <value>
-  Modify the value corresponding to each key <key> in a map <map>. If the <ref>
-  is used in place of <key>, only the entry pointed by <ref> is changed. The new
-  value is <value>.
+  Modify the value corresponding to each key <key> in a map <map>. <map> is the
+  #<id> or <file> returned by "show map". If the <ref> is used in place of
+  <key>, only the entry pointed by <ref> is changed. The new value is <value>.
 
 set maxconn frontend <frontend> <value>
   Dynamically change the specified frontend's maxconn setting. Any positive
@@ -13018,15 +13021,20 @@
 
 show map [<map>]
   Dump info about map converters. Without argument, the list of all available
-  maps is returned. If a <map> is specified, its contents are dumped. The first
-  column is a unique identifier. It can be used as reference for the operation
-  "del map" and "set map". The second column is the pattern and the third column
-  is the sample if available.
+  maps is returned. If a <map> is specified, its contents are dumped. <map> is
+  the #<id> or <file>. The first column is a unique identifier. It can be used
+  as reference for the operation "del map" and "set map". The second column is
+  the pattern and the third column is the sample if available. The data returned
+  are not directly a list of available maps, but are the list of all patterns
+  composing any map. Many of these patterns can be shared with ACL.
 
 show acl [<acl>]
   Dump info about acl converters. Without argument, the list of all available
-  acls is returned. If a <acl> is specified, its contents are dumped. The dump
-  format is the same than the map even for the sample value.
+  acls is returned. If a <acl> is specified, its contents are dumped. <acl> if
+  the #<id> or <file>. The dump format is the same than the map even for the
+  sample value. The data returned are not a list of available ACL, but are the
+  list of all patterns composing any ACL. Many of these patterns can be shared
+  with maps.
 
 show pools
   Dump the status of internal memory pools. This is useful to track memory
diff --git a/src/dumpstats.c b/src/dumpstats.c
index 27d440e..6a4de8c 100644
--- a/src/dumpstats.c
+++ b/src/dumpstats.c
@@ -1149,9 +1149,9 @@
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1248,9 +1248,9 @@
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1318,9 +1318,9 @@
 			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1631,7 +1631,7 @@
 			/* Lookup the reference in the maps. */
 			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
-				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1647,7 +1647,7 @@
 				/* Convert argument to integer value. */
 				conv = strtoll(&args[3][1], &error, 16);
 				if (*error != '\0') {
-					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
 					appctx->st0 = STAT_CLI_PRINT;
 					return 1;
 				}
@@ -1655,7 +1655,7 @@
 				/* Convert and check integer to pointer. */
 				ref = (struct pat_ref_elt *)(long)conv;
 				if ((long long int)(long)ref != conv) {
-					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
 					appctx->st0 = STAT_CLI_PRINT;
 					return 1;
 				}
@@ -1940,7 +1940,7 @@
 			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref ||
 			    !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
-				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+				appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -1956,7 +1956,7 @@
 				/* Convert argument to integer value. */
 				conv = strtoll(&args[3][1], &error, 16);
 				if (*error != '\0') {
-					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
 					appctx->st0 = STAT_CLI_PRINT;
 					return 1;
 				}
@@ -1964,7 +1964,7 @@
 				/* Convert and check integer to pointer. */
 				ref = (struct pat_ref_elt *)(long)conv;
 				if ((long long int)(long)ref != conv) {
-					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
 					appctx->st0 = STAT_CLI_PRINT;
 					return 1;
 				}
@@ -2034,9 +2034,9 @@
 			appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
 			if (!appctx->ctx.map.ref) {
 				if (appctx->ctx.map.display_flags == PAT_REF_MAP)
-					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
 				else
-					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <name>.\n";
+					appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
 				appctx->st0 = STAT_CLI_PRINT;
 				return 1;
 			}
@@ -4863,7 +4863,7 @@
 		 * later and restart at the state "STAT_ST_INIT".
 		 */
 		chunk_reset(&trash);
-		chunk_appendf(&trash, "# id (name) description\n");
+		chunk_appendf(&trash, "# id (file) description\n");
 		if (bi_putchk(si->ib, &trash) == -1)
 			return 0;
 
