X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/8f23e84c6a08a384d25582f9cf79c4f5549bc852..52ef24e4020adcb773adcb0d82b1c2c385610461:/avr/command.c

diff --git a/avr/command.c b/avr/command.c
index 2b53adf..8eb5bb7 100644
--- a/avr/command.c
+++ b/avr/command.c
@@ -1,193 +1,433 @@
+/*
+ * (C) Copyright 2014, 2016, 2018 Leo C. <erbl259-lmu@yahoo.de>
+ *
+ * (C) Copyright 2000-2009
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * SPDX-License-Identifier:	GPL-2.0
+ */
+
 /*
  *  Command Processor Table
  */
 
+#include "command.h"
 #include "common.h"
-#include <stdlib.h>
-#include <string.h>
 #include <ctype.h>
-#include <stdio.h>
-#include <avr/pgmspace.h>
+#include <setjmp.h>
 
 #include "config.h"
 #include "print-utils.h"
 #include "con-utils.h"
-#ifdef CONFIG_AUTO_COMPLETE
 #include "env.h"
-#endif
 #include "debug.h"
-#include "command.h"
+#include "getopt-min.h"
+#include "strerror.h"
+
+#define DEBUG_CMD	0	/* set to 1 to debug */
+
+#define debug_cmd(fmt, args...)		                                              \
+	debug_cond(DEBUG_CMD, fmt, ##args)
+
+
+jmp_buf cmd_jbuf;
+
+char *strcasestr_P2(const FLASH char *haystack, const char *needle)
+{
+	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;
+}
+
+
+#if 0
+static int cmd_tbl_item_count(cmd_tbl_t *p)
+{
+	int count = 0;
+
+	while (p->name != NULL) {
+		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
+
+static cmd_tbl_t *get_cmd_tbl_base(cmd_tbl_t  *cmdtp)
+{
+	cmd_tbl_t *p = cmdtp;
+
+	while (p->name != NULL)
+		++p;
+
+	return p->subcmd;
+}
+
+static cmd_tbl_t *get_cmd_tbl_parent(cmd_tbl_t  *child)
+{
+	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;
+		}
+	}
+	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 width;
+}
 
-static void print_usage_line(const FLASH char *name, int width,
-				const FLASH char *usage)
+static int print_prefixed_name(cmd_tbl_t *p)
 {
-	width -= strlen_P(name);
+	int len;
+
+	len = print_nameprefix(p);
+	len += strlen_P(p->name);
+	my_puts_P(p->name);
+
+	return len;
+}
+
+static void print_usage_line(cmd_tbl_t *p, int width)
+{
+	width -= print_prefixed_name(p);
 	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"));
+	puts_P(p->usage);
 }
 
-int strcmp_PP(const FLASH char *s1, const FLASH char *s2)
+#if 0
+static int strcmp_PP(const FLASH char *s1, const FLASH char *s2)
 {
 	unsigned char c1, c2;
 
-	while ((c1 = *(const FLASH unsigned char *)s1++) 
+	while ((c1 = *(const FLASH unsigned char *)s1++)
 			== (c2 = *(const FLASH unsigned char *)s2++))
 		if (c1 == 0)
 			return 0;
 
 	return c1 - c2;
 }
+#endif
 
-int cmpstringp(const void *p1, const void *p2)
+#if 1
+static int cmpstring_PP(const void *p1, const void *p2)
 {
-	return strcmp_PP((*(const FLASH cmd_tbl_t **) p1)->name, 
-		         (*(const FLASH cmd_tbl_t **) p2)->name);
+	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);
 }
-
-int cmd_tbl_item_count(void)
+#else
+static int cmpstring_PP(const void *p1, const void *p2)
 {
-	cmd_tbl_t * p = cmd_tbl;
-	int count = 0;
-
-	while (p->name != NULL) {
-		p++; count++;
+	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;
 	}
-	return count;
+	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
+
+/****************************************************************************/
 
 /*
- * Use puts() instead of printf() to avoid printf buffer overflow
- * for long help messages
+ * find command table entry for a command
  */
 
-command_ret_t _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp,
-		int flag, int argc, char * const argv[])
+static cmd_tbl_t *find_cmd (const char *cmd, cmd_tbl_t *table)
 {
-	uint_fast8_t i, max_len = 0;
-	command_ret_t rcode = CMD_RET_SUCCESS;
-
-	(void) flag;
-
-	if (argc == 1) {	/*show list of commands */
-		cmd_tbl_t *cmd_array[cmd_items];
-		int i;
-
-		/* Make array of commands from .uboot_cmd section */
-		cmdtp = cmd_start;
-		for (i = 0; i < cmd_items; i++) {
-			cmd_array[i] = cmdtp++;
-			uint_fast8_t l = strlen_P(cmd_array[i]->name);
-			if (l > max_len)
-				max_len = l;
-		}
+	if (!cmd)
+		return NULL;
 
-		/* Sort command list */
-		qsort(cmd_array, cmd_items, sizeof (cmd_tbl_t *), cmpstringp);
+	char *optenv = getenv_str(PSTR("cmd"));
+	uint8_t opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
 
-		/* print short help (usage) */
-		for (i = 0; i < cmd_items; i++) {
-			const FLASH char *usage = cmd_array[i]->usage;
-
-			/* allow user abort */
-			if (ctrlc ())
-				return CMD_RET_FAILURE;
-			if (usage == NULL)
-				continue;
-#ifdef GCC_BUG_61443 
-			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
+	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;
+				}
+			}
 		}
-		return CMD_RET_SUCCESS;
-	}
-	/*
-	 * command help (long version)
-	 */
-	for (i = 1; i < argc; ++i) {
-		if ((cmdtp = find_cmd_tbl (argv[i], cmd_start, cmd_items )) != NULL) {
-			rcode = cmd_usage(cmdtp);
-		} else {
-			printf_P(PSTR("Unknown command '%s' - try 'help'"
-				" without arguments.\n\n"), argv[i]
-				);
-			rcode = CMD_RET_FAILURE;
+		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;
 		}
 	}
-	return rcode;
+
+	if (n_found == 1)
+		return cmdtp_ret;			/* exactly one match */
+
+	return NULL;	/* not found or ambiguous command */
 }
 
-/***************************************************************************
- * find command table entry for a command
+/*
+ * Use puts() instead of printf() to avoid printf buffer overflow
+ * for long help messages
  */
-cmd_tbl_t *find_cmd_tbl (const char *cmd, cmd_tbl_t *table, int table_len)
-{
-	cmd_tbl_t *cmdtp;
-	cmd_tbl_t *cmdtp_temp = table;	/*Init value */
-	size_t len;
-	uint_fast8_t n_found = 0;
 
-	if (!cmd)
-		return NULL;
+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;
+		}
+	}
 
-	len = strlen(cmd);
+	/* remaining arguments */
+	argc -= optind;
+	argv += optind;
 
-	for (cmdtp = table;
-	     cmdtp != table + table_len;
-	     cmdtp++) {
-		if (strncmp_P (cmd, cmdtp->name, len) == 0) {
-			if (len == strlen (cmdtp->name))
-				return cmdtp;	/* full match */
+	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"));
+	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 */
+		}
 
-			cmdtp_temp = cmdtp;	/* abbreviated command ? */
-			n_found++;
+		/* Make array of commands */
+		cmd_tbl_t *tp = tbl_start;
+		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++;
 		}
-	}
-	if (n_found == 1) {			/* exactly one match */
-		return cmdtp_temp;
+//debug_cmd("### pass: %d, cmd_items: %d, i: %d, maxlen_cmd: %d\n", pass, cmd_items, i, maxlen_cmd);
 	}
 
-	return NULL;	/* not found or ambiguous command */
-}
+	/* Sort command list */
+	qsort(cmd_list, cmd_items, sizeof (cmd_tbl_t *), cmpstring_PP);
 
+	if ((options & OPT_LONG) == 0) {
+		/* print short help (usage) */
+		for (uint_fast8_t cmdi = 0; cmdi < cmd_items; cmdi++) {
 
-cmd_tbl_t *find_cmd (const char *cmd)
-{
-	return find_cmd_tbl(cmd, cmd_tbl, cmd_tbl_item_count());
+			/* 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);
+					}
+				}
+			}
+		}
+	} 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;
+			}
+		}
+	}
+	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;
 }
@@ -245,7 +485,7 @@ static int complete_cmdv(int argc, char * const argv[], char last_char, int maxv
 
 	/* more than one arg or one but the start of the next */
 	if (argc > 1 || (last_char == '\0' || isblank(last_char))) {
-		cmdtp = find_cmd(argv[0]);
+		cmdtp = find_cmd(argv[0], cmd_tbl);
 		if (cmdtp == NULL || cmdtp->complete == NULL) {
 			cmdv[0] = NULL;
 			return 0;
@@ -452,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
@@ -464,32 +705,46 @@ 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, int 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;
 
 	result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
-	if (result != CMD_RET_SUCCESS)
-		debug("Command failed, result=%d\n", result);
+//	if (result != CMD_RET_SUCCESS)
+//		debug("Command failed, result=%d\n", result);
 	return result;
 }
 
-command_ret_t cmd_process(int flag, int argc, char * const argv[],
+#pragma GCC diagnostic ignored "-Wclobbered"
+
+command_ret_t cmd_process(uint_fast8_t flag, int argc, char * const argv[],
 			       uint_fast8_t *repeatable)
 {
 	command_ret_t rc = CMD_RET_SUCCESS;
 	cmd_tbl_t *cmdtp;
 
 	/* Look up command in command table */
-	cmdtp = find_cmd(argv[0]);
+	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);
+			if (cmdtpsub == NULL) {
+				printf_P(PSTR("Unknown '%s' subcommand '%s' - try '%s help'\n"), argv[0], argv[1], argv[0]);
+				return CMD_RET_FAILURE;
+			}
+			cmdtp = cmdtpsub;
+			--argc;
+			++argv;
+		}
+	}
+
 	if (cmdtp == NULL) {
 		printf_P(PSTR("Unknown command '%s' - try 'help'\n"), argv[0]);
 		return CMD_RET_FAILURE;
 	}
-	if (!cmdtp->cmd) {
-		debug("### Command '%s' found, but ->cmd == NULL \n", argv[0]);
-		return CMD_RET_FAILURE;
-	}
 
 	/* found - check max args */
 	if (argc > cmdtp->maxargs)
@@ -507,10 +762,15 @@ command_ret_t cmd_process(int flag, int argc, char * const argv[],
 	}
 #endif
 
+	if (setjmp(cmd_jbuf) != 0)
+		return CMD_RET_FAILURE;
+
 	/* 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->repeatable;
+		*repeatable &= (cmdtp->flags & CTBL_RPT) != 0;
 	}
 	if (rc == CMD_RET_USAGE)
 		rc = cmd_usage(cmdtp);
@@ -529,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);
+	}
+}