X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/7a1ed62033184b79388b541258a14bc579389bdb..52ef24e4020adcb773adcb0d82b1c2c385610461:/avr/command.c?ds=sidebyside

diff --git a/avr/command.c b/avr/command.c
index e88e2f3..8eb5bb7 100644
--- a/avr/command.c
+++ b/avr/command.c
@@ -1,5 +1,5 @@
 /*
- * (C) Copyright 2014, 2016 Leo C. <erbl259-lmu@yahoo.de>
+ * (C) Copyright 2014, 2016, 2018 Leo C. <erbl259-lmu@yahoo.de>
  *
  * (C) Copyright 2000-2009
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
@@ -13,8 +13,6 @@
 
 #include "command.h"
 #include "common.h"
-#include <stdlib.h>
-#include <string.h>
 #include <ctype.h>
 #include <setjmp.h>
 
@@ -23,56 +21,62 @@
 #include "con-utils.h"
 #include "env.h"
 #include "debug.h"
+#include "getopt-min.h"
+#include "strerror.h"
 
+#define DEBUG_CMD	0	/* set to 1 to debug */
 
-jmp_buf cmd_jbuf;
-
-
-static void print_usage_line(const FLASH char *name, int width,
-				const FLASH char *usage)
-{
-	width -= strlen_P(name);
-	if (width < 0)
-		width = 0;
-	my_puts_P(name);
-	print_blanks(width);
-	my_puts_P(PSTR(" - "));
-	my_puts_P(usage);
-	my_puts_P(PSTR("\n"));
-}
+#define debug_cmd(fmt, args...)		                                              \
+	debug_cond(DEBUG_CMD, fmt, ##args)
 
-int strcmp_PP(const FLASH char *s1, const FLASH char *s2)
-{
-	unsigned char c1, c2;
 
-	while ((c1 = *(const FLASH unsigned char *)s1++)
-			== (c2 = *(const FLASH unsigned char *)s2++))
-		if (c1 == 0)
-			return 0;
-
-	return c1 - c2;
-}
+jmp_buf cmd_jbuf;
 
-int cmpstring_PP(const void *p1, const void *p2)
+char *strcasestr_P2(const FLASH char *haystack, const char *needle)
 {
-	return strcmp_PP((*(const FLASH cmd_tbl_t **) p1)->name,
-		         (*(const FLASH cmd_tbl_t **) p2)->name);
+	int nlen = strlen(needle);
+	int hlen = strlen_P(haystack) - nlen + 1;
+	int i;
+
+	for (i = 0; i < hlen; i++) {
+		int j;
+		for (j = 0; j < nlen; j++) {
+			unsigned char c1 = haystack[i+j];
+			unsigned char c2 = needle[j];
+			if (toupper(c1) != toupper(c2))
+				goto next;
+		}
+		return (char *) haystack + i;
+	next:
+		;
+	}
+	return NULL;
 }
 
-/****************************************************************************/
 
-int cmd_tbl_item_count(cmd_tbl_t *p)
+#if 0
+static int cmd_tbl_item_count(cmd_tbl_t *p)
 {
 	int count = 0;
 
 	while (p->name != NULL) {
-		p++; count++;
+		if (p->subcmd) {
+			cmd_tbl_t *sub = p->subcmd;
+			while (sub->name != NULL) {
+				if (sub->flags & CTBL_SUBCMDAUTO)
+					count++;
+				sub++;
+			}
+		}
+		if ((p->flags & CTBL_SUBCMDAUTO) == 0)
+			count++;
+		p++;
 	}
 	return count;
 }
+#endif
 
-
-cmd_tbl_t *get_cmd_tbl_base(cmd_tbl_t  *cmdtp)
+static cmd_tbl_t *get_cmd_tbl_base(cmd_tbl_t  *cmdtp)
 {
 	cmd_tbl_t *p = cmdtp;
 
@@ -82,74 +86,164 @@ cmd_tbl_t *get_cmd_tbl_base(cmd_tbl_t  *cmdtp)
 	return p->subcmd;
 }
 
-/*
- * find command table entry for a command
- */
-typedef struct {
-		size_t len;
-		uint_fast8_t level;
-		bool opt_debug;
-	} find_cmd_para_t;
-
-cmd_tbl_t *_find_cmd (const char *cmd, cmd_tbl_t *table, find_cmd_para_t *para)
+static cmd_tbl_t *get_cmd_tbl_parent(cmd_tbl_t  *child)
 {
-	cmd_tbl_t *cmdtp_ret = NULL;
-	uint_fast8_t n_found = 0, sub_found = 0;
-
-	for (cmd_tbl_t *cmdtp = table; cmdtp->name != NULL; cmdtp++) {
-		if (strncmp_P(cmd, cmdtp->name, para->len) == 0 &&
-					(para->opt_debug || !(cmdtp->flags & CTBL_DBG))) {
-			if (para->len == strlen_P(cmdtp->name))
-				return cmdtp;	/* full match */
-
-			cmdtp_ret = cmdtp;	/* abbreviated command ? */
-			n_found++;
-		} else if (cmdtp->subcmd && cmdtp->flags & CTBL_SUBCMDAUTO) {
-			cmd_tbl_t *sub = _find_cmd(cmd, cmdtp->subcmd, para);
-			if (sub) {
-				cmdtp_ret = sub;
-				++n_found;
-			}
+	if ((child->flags & CTBL_SUBCMDAUTO) == 0) {
+
+		cmd_tbl_t *tbl_start = get_cmd_tbl_base(child);
+		if (tbl_start != cmd_tbl) {
+			cmd_tbl_t *top = cmd_tbl;
+			while (top->subcmd != tbl_start)
+				++top;
+			return top;
 		}
 	}
-	if (n_found == 1) {			/* exactly one match */
-		if (sub_found)
-			para->level++;
-		return cmdtp_ret;
+	return NULL;
+}
+
+static int print_nameprefix(cmd_tbl_t *p)
+{
+	cmd_tbl_t *top = get_cmd_tbl_parent(p);
+
+	int width = 0;
+	if (top) {
+		width = printf_P(PSTR("%S "), top->name);
 	}
 
-	return NULL;	/* not found or ambiguous command */
+	return width;
 }
 
+static int print_prefixed_name(cmd_tbl_t *p)
+{
+	int len;
+
+	len = print_nameprefix(p);
+	len += strlen_P(p->name);
+	my_puts_P(p->name);
 
-cmd_tbl_t *find_cmd (const char *cmd, cmd_tbl_t *table, uint_fast8_t *cmdlevel)
+	return len;
+}
+
+static void print_usage_line(cmd_tbl_t *p, int width)
 {
-	find_cmd_para_t para;
+	width -= print_prefixed_name(p);
+	if (width < 0)
+		width = 0;
+	print_blanks(width);
+	my_puts_P(PSTR(" - "));
+	puts_P(p->usage);
+}
 
-	if (!cmd)
-		return NULL;
+#if 0
+static int strcmp_PP(const FLASH char *s1, const FLASH char *s2)
+{
+	unsigned char c1, c2;
 
-	char *optenv = getenv_str(PSTR("cmd"));
-	para.level = 0;
-	para.opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
-	para.len = strlen(cmd);
+	while ((c1 = *(const FLASH unsigned char *)s1++)
+			== (c2 = *(const FLASH unsigned char *)s2++))
+		if (c1 == 0)
+			return 0;
 
-	cmd_tbl_t *cmdtp = _find_cmd(cmd, table, &para);
+	return c1 - c2;
+}
+#endif
 
-	if (cmdlevel)
-		*cmdlevel = para.level;
-	return cmdtp;
+#if 1
+static int cmpstring_PP(const void *p1, const void *p2)
+{
+	char s1[21] = {'\0'};
+	char s2[21] = {'\0'};
+	cmd_tbl_t *cp1 = *(cmd_tbl_t **) p1;
+	cmd_tbl_t *cp2 = *(cmd_tbl_t **) p2;
+	cmd_tbl_t *top1 = get_cmd_tbl_parent(*(cmd_tbl_t **) p1);
+	cmd_tbl_t *top2 = get_cmd_tbl_parent(*(cmd_tbl_t **) p2);
+
+	if (top1)
+		strlcpy_P(s1, top1->name, 21);
+	if (top2)
+		strlcpy_P(s2, top2->name, 21);
+
+	strlcat_P(s1, cp1->name, 21);
+	strlcat_P(s2, cp2->name, 21);
+
+	return strcmp(s1, s2);
 }
+#else
+static int cmpstring_PP(const void *p1, const void *p2)
+{
+	cmd_tbl_t *cp1 = *(cmd_tbl_t **) p1;
+	cmd_tbl_t *cp2 = *(cmd_tbl_t **) p2;
+	cmd_tbl_t *top1 = get_cmd_tbl_parent(*(cmd_tbl_t **) p1);
+	cmd_tbl_t *top2 = get_cmd_tbl_parent(*(cmd_tbl_t **) p2);
+	int res;
+
+	if (top1 && top2) {
+		res = strcmp_PP(top1->name, top2->name);
+		if (res == 0)
+			res = strcmp_PP(cp1->name, cp2->name);
+		return res;
+	}
+	if (top1) {
+		res = strcmp_PP(top1->name, cp2->name);
+		if (res == 0)
+			res = strcmp_PP(cp1->name, cp2->name);
+		return res;
+	}
+	if (top2) {
+		res = strcmp_PP(cp1->name, top2->name);
+		if (res == 0)
+			res = strcmp_PP(cp1->name, cp2->name);
+		return res;
+	}
+	return strcmp_PP(cp1->name, cp2->name);
+}
+#endif
+
+/****************************************************************************/
+
+/*
+ * find command table entry for a command
+ */
 
-cmd_tbl_t *find_cmd_sub(const char *cmd, cmd_tbl_t *table)
+static cmd_tbl_t *find_cmd (const char *cmd, cmd_tbl_t *table)
 {
-	cmd_tbl_t *entry = NULL;
+	if (!cmd)
+		return NULL;
+
+	char *optenv = getenv_str(PSTR("cmd"));
+	uint8_t opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
+
+	cmd_tbl_t *cmdtp_ret = NULL;
+	uint_fast8_t n_found = 0;
+	uint_fast8_t len = strlen(cmd);
+
+	for (cmd_tbl_t *cmdtp = table; cmdtp->name != NULL; cmdtp++) {
+		if (cmdtp->subcmd) {
+			for (cmd_tbl_t *sub = cmdtp->subcmd; sub->name != NULL; sub++) {
+				if (sub->flags & CTBL_SUBCMDAUTO &&
+							strncmp_P(cmd, sub->name, len) == 0 &&
+							(opt_debug || !(sub->flags & CTBL_DBG))) {
+					if (len == strlen_P(sub->name))
+						return sub;				/* full match */
+					cmdtp_ret = sub;			/* abbreviated command ? */
+					++n_found;
+				}
+			}
+		}
+		if ((cmdtp->flags & CTBL_SUBCMDAUTO) == 0 &&
+					strncmp_P(cmd, cmdtp->name, len) == 0 &&
+					(opt_debug || !(cmdtp->flags & CTBL_DBG))) {
+			if (len == strlen_P(cmdtp->name))
+				return cmdtp;					/* full match */
+			cmdtp_ret = cmdtp;					/* abbreviated command ? */
+			++n_found;
+		}
+	}
 
-	for (cmd_tbl_t *tp = get_cmd_tbl_base(table); tp->name && entry == NULL; tp++)
-		if (tp->subcmd && tp->flags & CTBL_SUBCMDAUTO)
-			entry = find_cmd(cmd, tp->subcmd, NULL);
+	if (n_found == 1)
+		return cmdtp_ret;			/* exactly one match */
 
-	return entry;
+	return NULL;	/* not found or ambiguous command */
 }
 
 /*
@@ -160,91 +254,180 @@ cmd_tbl_t *find_cmd_sub(const char *cmd, cmd_tbl_t *table)
 command_ret_t do_help(cmd_tbl_t *cmdtp, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 {
 	cmd_tbl_t *tbl_start = get_cmd_tbl_base(cmdtp);
+	command_ret_t res = CMD_RET_SUCCESS;
+	uint_fast8_t options = 0;
+#define OPT_DBG_CMDS	0x01
+#define OPT_ALL			0x02
+#define OPT_NAME		0x04
+#define OPT_USAGE		0x08
+#define OPT_LONG		0x10
+
+	int opt;
+	while ((opt = getopt(argc, argv, PSTR("afk"))) != -1) {
+		switch (opt) {
+		case 'a':
+			options |= OPT_ALL;
+			break;
+		case 'f':
+			options |= OPT_NAME | OPT_ALL;
+			break;
+		case 'k':
+			options |= OPT_USAGE | OPT_ALL;
+			break;
+		default: /* '?' */
+			return CMD_RET_USAGE;
+		}
+	}
+
+	/* remaining arguments */
+	argc -= optind;
+	argv += optind;
+
+	if ((options & (OPT_USAGE|OPT_NAME)) == (OPT_USAGE|OPT_NAME)) {
+		puts_P(PSTR("Inkompatible options: -f -k\n"
+					  "Try 'help help'"));
+		return CMD_RET_USAGE;
+	}
+	if (options & OPT_USAGE)
+		options |= OPT_NAME;
+
+	if ((options & (OPT_NAME | OPT_USAGE)) == 0 && argc > 0)
+		options |= OPT_LONG;
 
 	char *optenv = getenv_str(PSTR("cmd"));
-	bool opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
+	if (optenv && strstr_P(optenv, PSTR("debug")) != NULL)
+		options |= OPT_DBG_CMDS;
+
+	uint_fast8_t maxlen_cmd;
+	int cmd_items;
+	cmd_tbl_t **cmd_list = NULL;
+	for (uint_fast8_t pass = 0; pass < 2; ++pass) {
+		maxlen_cmd = 0;
+		if (pass == 0)
+			cmd_items = 0;
+		else {
+			cmd_list = (cmd_tbl_t **) malloc(cmd_items * sizeof(cmd_tbl_t *));
+			/* TODO: Check error */
+		}
 
-	if (argc == 1) {	/*show list of commands */
-		int cmd_items = cmd_tbl_item_count(tbl_start);
-		cmd_tbl_t *cmd_array[cmd_items];
+		/* Make array of commands */
 		cmd_tbl_t *tp = tbl_start;
-		uint_fast8_t max_len = 0;
-
-		/* Make array of commands from .uboot_cmd section */
-		for (int i = 0; i < cmd_items; i++) {
-			cmd_array[i] = tp++;
-			uint_fast8_t l = strlen_P(cmd_array[i]->name);
-			if (l > max_len)
-				max_len = l;
+		int i = 0;
+		while (tp->name != NULL) {
+			if (tp->subcmd) {
+				cmd_tbl_t *sub = tp->subcmd;
+				while (sub->name != NULL) {
+					if (options & OPT_ALL || sub->flags & CTBL_SUBCMDAUTO) {
+						if (pass == 0)
+							++cmd_items;
+						else {
+							cmd_list[i++] = sub;
+							uint_fast8_t len = strlen_P(sub->name);
+							if ((sub->flags & CTBL_SUBCMDAUTO) == 0) {
+								len += strlen_P(tp->name) + 1;
+							}
+							if (len > maxlen_cmd) {
+								maxlen_cmd = len;
+							}
+//debug_cmd("### i:%3d, maxlen:%3d, tp: '%S', sub: '%S'\n", i, maxlen_cmd, tp->name, sub->name);
+						}
+					}
+					sub++;
+				}
+			}
+			if ((tp->flags & CTBL_SUBCMDAUTO) == 0) {
+				if (pass == 0)
+					++cmd_items;
+				else {
+					cmd_list[i++] = tp;
+					uint_fast8_t len = strlen_P(tp->name);
+					cmd_tbl_t *top = get_cmd_tbl_parent(tp);
+					if (top)
+						len += strlen_P(top->name) + 1;
+					if (len > maxlen_cmd)
+						maxlen_cmd = len;
+				}
+			}
+			tp++;
 		}
+//debug_cmd("### pass: %d, cmd_items: %d, i: %d, maxlen_cmd: %d\n", pass, cmd_items, i, maxlen_cmd);
+	}
 
-		/* Sort command list */
-		qsort(cmd_array, cmd_items, sizeof (cmd_tbl_t *), cmpstring_PP);
+	/* Sort command list */
+	qsort(cmd_list, cmd_items, sizeof (cmd_tbl_t *), cmpstring_PP);
 
+	if ((options & OPT_LONG) == 0) {
 		/* print short help (usage) */
-		for (int i = 0; i < cmd_items; i++) {
-			if (opt_debug || !(cmd_array[i]->flags & CTBL_DBG)) {
-				const FLASH char *usage = cmd_array[i]->usage;
-
-				/* allow user abort */
-				if (ctrlc ())
-					return CMD_RET_FAILURE;
-				if (usage == NULL)
-					continue;
-#if defined(GCC_BUG_61443) || 1
-				print_usage_line(cmd_array[i]->name, max_len, usage);
-#else
-				printf_P(PSTR("%-" stringify(8) /*FIXME*/ "S - %S\n"),
-						cmd_array[i]->name, usage);
-#endif
+		for (uint_fast8_t cmdi = 0; cmdi < cmd_items; cmdi++) {
+
+			/* allow user abort */
+			if (ctrlc ()) {
+				res = CMD_RET_FAILURE;
+				break;
+			}
+			if ((cmd_list[cmdi]->flags & CTBL_DBG) && !(options & OPT_DBG_CMDS))
+				continue;
+			if (cmd_list[cmdi]->usage == NULL)
+				continue;
+
+			if (argc == 0)
+				print_usage_line(cmd_list[cmdi], maxlen_cmd);
+			else {
+				for (uint_fast8_t argi = 0; argi < argc; argi++) {
+					if (((options & OPT_NAME) &&
+							strcasestr_P2(cmd_list[cmdi]->name, argv[argi])) ||
+						((options & OPT_USAGE) &&
+							strcasestr_P2(cmd_list[cmdi]->usage, argv[argi]))) {
+						print_usage_line(cmd_list[cmdi], maxlen_cmd);
+					}
+				}
 			}
 		}
-		return CMD_RET_SUCCESS;
-	}
-
-	/*
-	 * command help (long version)
-	 */
-	for (uint8_t i = 1; i < argc; ++i) {
-		if ((cmdtp = find_cmd(argv[i], tbl_start, NULL)) != NULL &&
-					(opt_debug || cmdtp->name[0] != '!')) {
-			cmd_usage(cmdtp);
-		} else {
-			printf_P(PSTR("Unknown command '%s' - try 'help'"
-				" without arguments.\n\n"), argv[i]
-				);
-			return CMD_RET_FAILURE;
+	} else {
+		/* command help (long version) */
+		for (uint_fast8_t argi = 0; argi < argc; ++argi) {
+			uint_fast8_t got = 0;
+			cmd_tbl_t *tp = find_cmd(argv[argi], tbl_start);
+			if (tp) {
+				cmd_usage(tp);
+				got = 1;
+			}
+			if (options & OPT_ALL) {
+				for (cmd_tbl_t *sub = tbl_start; sub->name != NULL; sub++) {
+					if (sub->subcmd) {
+						tp = find_cmd(argv[argi], sub->subcmd);
+						if (tp) {
+							cmd_usage(tp);
+							got = 1;
+						}
+					}
+				}
+			}
+			if (!got) {
+				printf_P(PSTR("Unknown command '%s' - try 'help help'\n"),
+						argv[argi]);
+				res = CMD_RET_FAILURE;
+				break;
+			}
 		}
 	}
-
-	return CMD_RET_SUCCESS;
+	free(cmd_list);
+	return res;
 }
 
 
-command_ret_t cmd_usage(const FLASH cmd_tbl_t *cmdtp)
+command_ret_t cmd_usage(cmd_tbl_t *cmdtp)
 {
-//	printf("%s - %s\n\n", cmdtp->name, cmdtp->usage);
-	print_usage_line(cmdtp->name, 0, cmdtp->usage);
-#if 0
-	my_puts_P(cmdtp->name);
-	print_blanks(/*FIXME*/ 8 - strlen_P(cmdtp->name));
-	my_puts_P(PSTR(" - "));
-	my_puts_P(cmdtp->usage);
-	my_puts_P(PSTR("\n\n"));
-#endif
+	print_usage_line(cmdtp, 0);
 #ifdef	CONFIG_SYS_LONGHELP
-//	printf("Usage:\n%s ", cmdtp->name);
 	my_puts_P(PSTR("Usage:\n"));
-	my_puts_P(cmdtp->name);
+	print_prefixed_name(cmdtp);
 	my_puts_P(PSTR(" "));
 
-	if (!cmdtp->help) {
+	if (cmdtp->help && *cmdtp->help != '\0')
+		puts_P(cmdtp->help);
+	else
 		my_puts_P(PSTR(" - No additional help available.\n"));
-		return CMD_RET_FAILURE;
-	}
-
-	my_puts_P(cmdtp->help);
-	my_puts_P(PSTR("\n"));
 #endif	/* CONFIG_SYS_LONGHELP */
 	return CMD_RET_FAILURE;
 }
@@ -509,6 +692,7 @@ int cmd_auto_complete(const FLASH char *const prompt, char *buf, int *np, int *c
 #endif /* CONFIG_AUTO_COMPLETE */
 
 
+static cmd_tbl_t *cmd_invocation_ptr;
 
 /**
  * Call a command function. This should be the only route in U-Boot to call
@@ -521,7 +705,7 @@ int cmd_auto_complete(const FLASH char *const prompt, char *buf, int *np, int *c
  * @param argv		Arguments
  * @return 0 if command succeeded, else non-zero (CMD_RET_...)
  */
-command_ret_t cmd_call(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
+static command_ret_t cmd_call(cmd_tbl_t *cmdtp, uint_fast8_t flag, int argc, char * const argv[])
 {
 	command_ret_t result;
 
@@ -538,16 +722,15 @@ command_ret_t cmd_process(uint_fast8_t flag, int argc, char * const argv[],
 {
 	command_ret_t rc = CMD_RET_SUCCESS;
 	cmd_tbl_t *cmdtp;
-	uint_fast8_t cmdlevel;
 
 	/* Look up command in command table */
-	cmdtp = find_cmd(argv[0], cmd_tbl, &cmdlevel);
+	cmdtp = find_cmd(argv[0], cmd_tbl);
 	if (cmdtp != NULL) {
 		/* Check if this command has subcommands */
 		if (cmdtp->subcmd && argc > 1) {
 
 			/* Look up subcommand in subcommand table */
-			cmd_tbl_t *cmdtpsub = find_cmd(argv[1], cmdtp->subcmd, &cmdlevel);
+			cmd_tbl_t *cmdtpsub = find_cmd(argv[1], cmdtp->subcmd);
 			if (cmdtpsub == NULL) {
 				printf_P(PSTR("Unknown '%s' subcommand '%s' - try '%s help'\n"), argv[0], argv[1], argv[0]);
 				return CMD_RET_FAILURE;
@@ -557,12 +740,6 @@ command_ret_t cmd_process(uint_fast8_t flag, int argc, char * const argv[],
 			++argv;
 		}
 	}
-#if 0
-	 else {
-		/* Search subcommands */
-		cmdtp = find_cmd_sub(argv[0], cmd_tbl, &cmdlevel);
-	}
-#endif
 
 	if (cmdtp == NULL) {
 		printf_P(PSTR("Unknown command '%s' - try 'help'\n"), argv[0]);
@@ -590,6 +767,8 @@ command_ret_t cmd_process(uint_fast8_t flag, int argc, char * const argv[],
 
 	/* If OK so far, then do the command */
 	if (!rc) {
+		optind = 0;			/* reset getopt() */
+		cmd_invocation_ptr = cmdtp;
 		rc = cmd_call(cmdtp, flag, argc, argv);
 		*repeatable &= (cmdtp->flags & CTBL_RPT) != 0;
 	}
@@ -610,3 +789,25 @@ int cmd_process_error(cmd_tbl_t *cmdtp, int err)
 
 	return 0;
 }
+
+void cmd_error(int status, int errnum, const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	print_prefixed_name(cmd_invocation_ptr);
+	if (fmt != NULL) {
+		my_puts_P(PSTR(": "));
+		vfprintf_P(stdout, fmt, ap);
+	}
+	va_end(ap);
+
+	if (errnum != 0)
+		printf_P(PSTR(": %S"), my_strerror_P(errnum));
+
+	putchar('\n');
+	_delay_ms(20);
+
+	if (status != 0) {
+		longjmp(cmd_jbuf, 1);
+	}
+}