hush: first stab at function support. argv passing is not coded yet.

 Only very rudimentary testing was done.
 With function support off, code growth is zero, with it on:

function                                             old     new   delta
run_list                                            2158    2339    +181
parse_stream                                        1929    2044    +115
find_builtin                                          24      67     +43
find_function                                          -      36     +36
file_get                                             244     264     +20
pseudo_exec_argv                                     145     160     +15
free_strings                                           -       7      +7
free_pipe                                            183     181      -2
done_word                                            735     728      -7
expand_variables                                    2227    2204     -23
------------------------------------------------------------------------------
(add/remove: 2/0 grow/shrink: 5/3 up/down: 417/-32)           Total: 385 bytes

1 files changed, 169 insertions, 64 deletions

diff --git a/shell/hush.c b/shell/hush.c
index 9adf0e127..3728583fc 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -86,7 +86,7 @@
  */
 #define HUSH_DEBUG 1
 /* In progress... */
-#define ENABLE_HUSH_FUNCTIONS 0
+#define ENABLE_HUSH_FUNCTIONS 1
 
 
 #if BUILD_AS_NOMMU
@@ -374,12 +374,12 @@ struct command {
 #define GRP_NORMAL   0
 #define GRP_SUBSHELL 1
 #if ENABLE_HUSH_FUNCTIONS
-#define GRP_FUNCTION 2
+# define GRP_FUNCTION 2
 #endif
 
 struct pipe {
 	struct pipe *next;
-	int num_cmds;               /* total number of commands in job */
+	int num_cmds;               /* total number of commands in pipe */
 	int alive_cmds;             /* number of commands running (not exited) */
 	int stopped_cmds;           /* number of commands alive, but stopped */
 #if ENABLE_HUSH_JOB
@@ -452,6 +452,12 @@ enum {
 	BC_CONTINUE = 2,
 };
 
+struct function {
+	struct function *next;
+	char *name;
+	struct pipe *body;
+};
+
 
 /* "Globals" within this file */
 /* Sorted roughly by size (smaller offsets == smaller code) */
@@ -504,6 +510,7 @@ struct globals {
 	const char *cwd;
 	struct variable *top_var; /* = &G.shell_ver (set in main()) */
 	struct variable shell_ver;
+	struct function *top_func;
 	/* Signal and trap handling */
 //	unsigned count_SIGCHLD;
 //	unsigned handled_SIGCHLD;
@@ -2585,6 +2592,35 @@ static void free_pipe_list(struct pipe *head, int indent)
 }
 
 
+static const struct built_in_command* find_builtin(const char *name)
+{
+	const struct built_in_command *x;
+	for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
+		if (strcmp(name, x->cmd) != 0)
+			continue;
+		debug_printf_exec("found builtin '%s'\n", name);
+		return x;
+	}
+	return NULL;
+}
+
+# if ENABLE_HUSH_FUNCTIONS
+static const struct function *find_function(const char *name)
+{
+	const struct function *funcp = G.top_func;
+	while (funcp) {
+		if (strcmp(name, funcp->name) != 0)
+			continue;
+		return funcp;
+		debug_printf_exec("found function '%s'\n", name);
+	}
+	return NULL;
+}
+#endif
+
+
+static int run_list(struct pipe *pi);
+
 #if BB_MMU
 #define pseudo_exec_argv(nommu_save, argv, assignment_cnt, argv_expanded) \
 	pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
@@ -2627,6 +2663,11 @@ static void pseudo_exec_argv(nommu_save_t *nommu_save,
 #endif
 	}
 
+#if ENABLE_FEATURE_SH_STANDALONE || BB_MMU
+	if (strchr(argv[0], '/') != NULL)
+		goto skip;
+#endif
+
 	/* On NOMMU, we must never block!
 	 * Example: { sleep 99999 | read line } & echo Ok
 	 * read builtin will block on read syscall, leaving parent blocked
@@ -2640,30 +2681,38 @@ static void pseudo_exec_argv(nommu_save_t *nommu_save,
 	 */
 	{
 		int rcode;
-		const struct built_in_command *x;
-		for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
-			if (strcmp(argv[0], x->cmd) == 0) {
-				debug_printf_exec("running builtin '%s'\n",
-						argv[0]);
-				rcode = x->function(argv);
-				fflush(NULL);
-				_exit(rcode);
-			}
+		const struct built_in_command *x = find_builtin(argv[0]);
+		if (x) {
+			rcode = x->function(argv);
+			fflush(NULL);
+			_exit(rcode);
 		}
 	}
+# if ENABLE_HUSH_FUNCTIONS
+	/* Check if the command matches any functions */
+	{
+		int rcode;
+		const struct function *funcp = find_function(argv[0]);
+		if (funcp) {
+			rcode = run_list(funcp->body);
+			fflush(NULL);
+			_exit(rcode);
+		}
+	}
+# endif
 #endif
 
 #if ENABLE_FEATURE_SH_STANDALONE
 	/* Check if the command matches any busybox applets */
-	if (strchr(argv[0], '/') == NULL) {
+	{
 		int a = find_applet_by_name(argv[0]);
 		if (a >= 0) {
-#if BB_MMU /* see above why on NOMMU it is not allowed */
+# if BB_MMU /* see above why on NOMMU it is not allowed */
 			if (APPLET_IS_NOEXEC(a)) {
 				debug_printf_exec("running applet '%s'\n", argv[0]);
 				run_applet_no_and_exit(a, argv);
 			}
-#endif
+# endif
 			/* Re-exec ourselves */
 			debug_printf_exec("re-execing applet '%s'\n", argv[0]);
 			sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
@@ -2674,6 +2723,7 @@ static void pseudo_exec_argv(nommu_save_t *nommu_save,
 	}
 #endif
 
+ skip:
 	debug_printf_exec("execing '%s'\n", argv[0]);
 	sigprocmask(SIG_SETMASK, &G.inherited_set, NULL);
 	execvp(argv[0], argv);
@@ -2681,8 +2731,6 @@ static void pseudo_exec_argv(nommu_save_t *nommu_save,
 	_exit(EXIT_FAILURE);
 }
 
-static int run_list(struct pipe *pi);
-
 /* Called after [v]fork() in run_pipe
  */
 static void pseudo_exec(nommu_save_t *nommu_save,
@@ -3031,8 +3079,35 @@ static int run_pipe(struct pipe *pi)
 	if (command->group) {
 #if ENABLE_HUSH_FUNCTIONS
 		if (command->grp_type == GRP_FUNCTION) {
-			/* func () { list } */
-			bb_error_msg("here we ought to remember function definition, and go on");
+			/* "executing" func () { list } */
+			struct function *funcp;
+			struct function **funcpp = &G.top_func;
+
+			while ((funcp = *funcpp) != NULL) {
+				if (strcmp(funcp->name, command->argv[0]) == 0) {
+					debug_printf_exec("replacing function '%s'", funcp->name);
+					free(funcp->name);
+					free_pipe_list(funcp->body, /* indent: */ 0);
+					goto skip;
+				}
+				funcpp = &funcp->next;
+			}
+			debug_printf_exec("remembering new function '%s'", funcp->name);
+			funcp = *funcpp = xzalloc(sizeof(*funcp));
+			/*funcp->next = NULL;*/
+ skip:
+			funcp->name = command->argv[0];
+			funcp->body = command->group;
+			command->group = NULL;
+			command->argv[0] = NULL;
+			free_strings(command->argv);
+			command->argv = NULL;
+			/* note: if we are in a loop, future "executions"
+			 * of func def will see it as null command since
+			 * command->group == NULL and command->argv == NULL */
+//this isn't exactly right: while...do f1() {a;}; f1; f1 {b;}; done
+//second loop will execute b!
+
 			return EXIT_SUCCESS;
 		}
 #endif
@@ -3052,6 +3127,11 @@ static int run_pipe(struct pipe *pi)
 	argv = command->argv ? command->argv : (char **) &null_ptr;
 	{
 		const struct built_in_command *x;
+#if ENABLE_HUSH_FUNCTIONS
+		const struct function *funcp;
+#else
+		enum { funcp = 0 };
+#endif
 		char **new_env = NULL;
 		char **old_env = NULL;
 
@@ -3078,13 +3158,18 @@ static int run_pipe(struct pipe *pi)
 		/* Expand the rest into (possibly) many strings each */
 		argv_expanded = expand_strvec_to_strvec(argv + command->assignment_cnt);
 
-		for (x = bltins; x != &bltins[ARRAY_SIZE(bltins)]; x++) {
-			if (strcmp(argv_expanded[0], x->cmd) != 0)
-				continue;
-			if (x->function == builtin_exec && argv_expanded[1] == NULL) {
-				debug_printf("exec with redirects only\n");
-				rcode = setup_redirects(command, NULL);
-				goto clean_up_and_ret1;
+		x = find_builtin(argv_expanded[0]);
+#if ENABLE_HUSH_FUNCTIONS
+		if (!x)
+			funcp = find_function(argv_expanded[0]);
+#endif
+		if (x || funcp) {
+			if (!funcp) {
+				if (x->function == builtin_exec && argv_expanded[1] == NULL) {
+					debug_printf("exec with redirects only\n");
+					rcode = setup_redirects(command, NULL);
+					goto clean_up_and_ret1;
+				}
 			}
 			debug_printf("builtin inline %s\n", argv_expanded[0]);
 			/* XXX setup_redirects acts on file descriptors, not FILEs.
@@ -3095,9 +3180,18 @@ static int run_pipe(struct pipe *pi)
 			if (rcode == 0) {
 				new_env = expand_assignments(argv, command->assignment_cnt);
 				old_env = putenv_all_and_save_old(new_env);
-				debug_printf_exec(": builtin '%s' '%s'...\n",
+				if (!funcp) {
+					debug_printf_exec(": builtin '%s' '%s'...\n",
 						x->cmd, argv_expanded[1]);
-				rcode = x->function(argv_expanded) & 0xff;
+					rcode = x->function(argv_expanded) & 0xff;
+				}
+#if ENABLE_HUSH_FUNCTIONS
+				else {
+					debug_printf_exec(": function '%s' '%s'...\n",
+						funcp->name, argv_expanded[1]);
+					rcode = run_list(funcp->body) & 0xff;
+				}
+#endif
 			}
 #if ENABLE_FEATURE_SH_STANDALONE
  clean_up_and_ret:
@@ -3114,6 +3208,7 @@ static int run_pipe(struct pipe *pi)
 			debug_printf_exec("run_pipe return %d\n", rcode);
 			return rcode;
 		}
+
 #if ENABLE_FEATURE_SH_STANDALONE
 		i = find_applet_by_name(argv_expanded[0]);
 		if (i >= 0 && APPLET_IS_NOFORK(i)) {
@@ -4081,6 +4176,10 @@ static int done_word(o_string *word, struct parse_context *ctx)
 			}
 		}
 		command->argv = add_string_to_strings(command->argv, xstrdup(word->data));
+//SEGV, but good idea.
+//		command->argv = add_string_to_strings(command->argv, word->data);
+//		word->data = NULL;
+//		word->length = 0;
 		debug_print_strings("word appended to argv", command->argv);
 	}
 
@@ -4089,7 +4188,7 @@ static int done_word(o_string *word, struct parse_context *ctx)
 		if (word->o_quoted
 		 || !is_well_formed_var_name(command->argv[0], '\0')
 		) {
-			/* bash says "not a valid identifier" */
+			/* bash says just "not a valid identifier" */
 			syntax_error("not a valid identifier in for");
 			return 1;
 		}
@@ -4462,27 +4561,55 @@ static int parse_group(o_string *dest, struct parse_context *ctx,
 
 	debug_printf_parse("parse_group entered\n");
 #if ENABLE_HUSH_FUNCTIONS
-	if (ch == 'F') { /* function definition? */
-		bb_error_msg("aha '%s' is a function, parsing it...", dest->data);
-		//command->fname = dest->data;
-		command->grp_type = GRP_FUNCTION;
-		memset(dest, 0, sizeof(*dest));
+	if (ch == '(') {
+		if (!dest->o_quoted) {
+			if (dest->length)
+				done_word(dest, ctx);
+			if (!command->argv)
+				goto skip; /* (... */
+			if (command->argv[1]) { /* word word ... (... */
+				syntax_error("unexpected character (");
+				return 1;
+			}
+			/* it is "word(..." or "word (..." */
+			do
+				ch = i_getch(input);
+			while (ch == ' ' || ch == '\t');
+			if (ch != ')') {
+				syntax_error("unexpected character X");
+				return 1;
+			}
+			do
+				ch = i_getch(input);
+			while (ch == ' ' || ch == '\t' || ch == '\n');
+			if (ch != '{') {
+				syntax_error("unexpected character X");
+				return 1;
+			}
+			command->grp_type = GRP_FUNCTION;
+			goto skip;
+		}
 	}
 #endif
-	if (command->argv /* word [word](... */
-	 || dest->length /* word(... */
-	 || dest->o_quoted /* ""(... */
+	if (command->argv /* word [word]{... */
+	 || dest->length /* word{... */
+	 || dest->o_quoted /* ""{... */
 	) {
 		syntax_error(NULL);
 		debug_printf_parse("parse_group return 1: "
 			"syntax error, groups and arglists don't mix\n");
 		return 1;
 	}
+
+#if ENABLE_HUSH_FUNCTIONS
+ skip:
+#endif
 	endch = '}';
 	if (ch == '(') {
 		endch = ')';
 		command->grp_type = GRP_SUBSHELL;
 	}
+
 	{
 #if !BB_MMU
 		char *as_string = NULL;
@@ -5311,28 +5438,6 @@ static struct pipe *parse_stream(char **pstring,
 				continue;
 			}
 #endif
-#if ENABLE_HUSH_FUNCTIONS
-			if (dest.length != 0 /* not just () but word() */
-			 && dest.o_quoted == 0 /* not a"b"c() */
-			 && ctx.command->argv == NULL /* it's the first word */
-//TODO: "func ( ) {...}" - note spaces - is valid format too in bash
-			 && i_peek(input) == ')'
-			 && !match_reserved_word(&dest)
-			) {
-				bb_error_msg("seems like a function definition");
-				i_getch(input);
-//if !BB_MMU o_addchr(&ctx.as_string...
-				do {
-//TODO: do it properly.
-					ch = i_getch(input);
-				} while (ch == ' ' || ch == '\n');
-				if (ch != '{') {
-					syntax_error("was expecting {");
-					goto parse_error;
-				}
-				ch = 'F'; /* magic value */
-			}
-#endif
 		case '{':
 			if (parse_group(&dest, &ctx, input, ch) != 0) {
 				goto parse_error;
@@ -6427,11 +6532,11 @@ static int builtin_unset(char **argv)
 				ret = EXIT_FAILURE;
 			}
 		}
-#if ENABLE_HUSH_FUNCTIONS
-		else {
-			unset_local_func(*argv);
-		}
-#endif
+//#if ENABLE_HUSH_FUNCTIONS
+//		else {
+//			unset_local_func(*argv);
+//		}
+//#endif
 		argv++;
 	}
 	return ret;