X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/04f849375f8277203eddbeac2bfbfbfc433bbacf..66f6a44eb2e13ca5a293bd5c05189279e2cfbe18:/avr/command.c

diff --git a/avr/command.c b/avr/command.c
index c9137ea..b579a5e 100644
--- a/avr/command.c
+++ b/avr/command.c
@@ -21,50 +21,45 @@
 #include "con-utils.h"
 #include "env.h"
 #include "debug.h"
+#include "getopt-min.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"));
-}
-
-int strcmp_PP(const FLASH char *s1, const FLASH char *s2)
-{
-	unsigned char c1, c2;
+#define debug_cmd(fmt, args...)		                                              \
+	debug_cond(DEBUG_CMD, fmt, ##args)
 
-	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) {
-		if (p->subcmd && p->flags & CTBL_SUBCMDAUTO) {
+		if (p->subcmd) {
 			cmd_tbl_t *sub = p->subcmd;
 			while (sub->name != NULL) {
 				if (sub->flags & CTBL_SUBCMDAUTO)
@@ -72,13 +67,15 @@ int cmd_tbl_item_count(cmd_tbl_t *p)
 				sub++;
 			}
 		}
-		p++; count++;
+		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;
 
@@ -88,74 +85,155 @@ 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 && sub->flags & CTBL_SUBCMDAUTO) {
-				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_name_prefix(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 void print_usage_line(cmd_tbl_t *p, int width)
+{
+	width -= strlen_P(p->name);
+	width -= print_name_prefix(p);
+	if (width < 0)
+		width = 0;
+	my_puts_P(p->name);
+	print_blanks(width);
+	my_puts_P(PSTR(" - "));
+	puts_P(p->usage);
 }
 
+#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++)
+			== (c2 = *(const FLASH unsigned char *)s2++))
+		if (c1 == 0)
+			return 0;
+
+	return c1 - c2;
+}
+#endif
 
-cmd_tbl_t *find_cmd (const char *cmd, cmd_tbl_t *table, uint_fast8_t *cmdlevel)
+#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)
 {
-	find_cmd_para_t para;
+	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
+ */
 
+static cmd_tbl_t *find_cmd (const char *cmd, cmd_tbl_t *table)
+{
 	if (!cmd)
 		return NULL;
 
 	char *optenv = getenv_str(PSTR("cmd"));
-	para.level = 0;
-	para.opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
-	para.len = strlen(cmd);
-
-	cmd_tbl_t *cmdtp = _find_cmd(cmd, table, &para);
+	uint8_t opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
 
-	if (cmdlevel)
-		*cmdlevel = para.level;
-	return cmdtp;
-}
+	cmd_tbl_t *cmdtp_ret = NULL;
+	uint_fast8_t n_found = 0;
+	uint_fast8_t len = strlen(cmd);
 
-cmd_tbl_t *find_cmd_sub(const char *cmd, cmd_tbl_t *table)
-{
-	cmd_tbl_t *entry = NULL;
+	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 */
 }
 
 /*
@@ -166,107 +244,175 @@ 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
+
+	/* reset getopt() */
+	optind = 0;
+
+	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;
+		}
+	}
 
-	char *optenv = getenv_str(PSTR("cmd"));
-	bool opt_debug = optenv && strstr_P(optenv, PSTR("debug")) != NULL;
+	/* 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;
 
-	if (argc == 1) {	/*show list of commands */
-		int cmd_items = cmd_tbl_item_count(tbl_start);
-		cmd_tbl_t **cmd_list = (cmd_tbl_t **) malloc(cmd_items * sizeof(cmd_tbl_t *));
-		uint_fast8_t maxlen_cmd = 0;
+	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 */
+		}
 
 		/* Make array of commands */
 		cmd_tbl_t *tp = tbl_start;
 		int i = 0;
 		while (tp->name != NULL) {
-			uint_fast8_t len;
-			if (tp->subcmd && tp->flags & CTBL_SUBCMDAUTO) {
+			if (tp->subcmd) {
 				cmd_tbl_t *sub = tp->subcmd;
 				while (sub->name != NULL) {
-					if (sub->flags & CTBL_SUBCMDAUTO) {
-						len = strlen_P(sub->name);
-						if (len > maxlen_cmd)
-							maxlen_cmd = len;
-						cmd_list[i++] = sub;
+					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++;
 				}
 			}
-			len = strlen_P(tp->name);
-			if (len > maxlen_cmd)
-				maxlen_cmd = len;
-			cmd_list[i++] = tp++;
+			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++;
 		}
-		/* Sort command list */
-		qsort(cmd_list, cmd_items, sizeof (cmd_tbl_t *), cmpstring_PP);
+//debug_cmd("### pass: %d, cmd_items: %d, i: %d, maxlen_cmd: %d\n", pass, cmd_items, i, maxlen_cmd);
+	}
+
+	/* 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_list[i]->flags & CTBL_DBG)) {
-				const FLASH char *usage = cmd_list[i]->usage;
-
-				/* allow user abort */
-				if (ctrlc ()) {
-					free(cmd_list);
-					return CMD_RET_FAILURE;
+		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);
+					}
 				}
-				if (usage == NULL)
-					continue;
-#if defined(GCC_BUG_61443) || 1
-				print_usage_line(cmd_list[i]->name, maxlen_cmd, usage);
-#else
-				printf_P(PSTR("%-" stringify(8) /*FIXME*/ "S - %S\n"),
-						cmd_list[i]->name, usage);
-#endif
 			}
 		}
-		free(cmd_list);
-		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->flags & CTBL_DBG))) {
-			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;
+
+			for (uint_fast8_t cmdi = 0; cmdi < cmd_items; cmdi++) {
+				if (strcmp_P(argv[argi], cmd_list[cmdi]->name) == 0) {
+					cmd_usage(cmd_list[cmdi]);
+					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(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"));
+	print_name_prefix(cmdtp);
 	my_puts_P(cmdtp->name);
 	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;
 }
@@ -560,16 +706,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;
@@ -579,12 +724,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]);