msh_function.patch: picked it up in the wild.

Fixed allocation bugs (it was allocating
one too small vectors) but it still is very buggy,
thus not applied.

1 files changed, 350 insertions, 0 deletions

diff --git a/shell/msh_function.patch b/shell/msh_function.patch
new file mode 100644
index 000000000..b02b291e1
--- /dev/null
+++ b/shell/msh_function.patch
@@ -0,0 +1,350 @@
+This is a "function" patch for msh which is in use by some busybox
+users. Unfortunately it is far too buggy to be applied, but maybe
+it's a useful starting point for future work.
+
+Function-related code is delimited by comments of the form
+	//funccode:start
+	...
+	//funccode:end
+for ease of grepping
+
+An example of buggy behavior:
+
+#f() {
+#    echo foo
+#    echo test`echo bar >&2`
+#    echo END f
+#}
+
+function g {
+#    echo 2 foo
+#    echo 2 test`echo 2 bar >&2`
+#    f
+    echo END g
+#    echo "1:'$1' 2:'$2'"
+}
+
+# Even this first block fails - it does not even call functions!
+# (replacing "echo END g" above with "echo END" makes it run ok)
+echo DRY RUN
+    echo 2 foo
+    echo 2 test`echo 2 bar >&2`
+    echo END g
+    echo "1:'$1' 2:'$2'"
+    echo foo
+    echo test`echo bar >&2`
+    echo END f
+echo END DRY RUN
+
+exit
+
+# This would fail too
+g "$1-one" "two$2"
+echo DONE
+
+
+
+diff -d -urpN busybox.7/shell/msh.c busybox.8/shell/msh.c
+--- busybox.7/shell/msh.c	2008-06-09 09:34:45.000000000 +0200
++++ busybox.8/shell/msh.c	2008-06-09 09:38:17.000000000 +0200
+@@ -89,6 +89,14 @@ static char *itoa(int n)
+ 
+ //#define MSHDEBUG 4
+ 
++/* Used only in "function" support code */
++#ifdef KSDBG //funccode:start
++      #define KSDBG_PRINT_FUNCNAME fprintf(stderr, "in %s\n", __FUNCTION__)
++#else
++      #define KSDBG_PRINT_FUNCNAME ((void)0)
++#endif
++//funccode:end
++
+ #ifdef MSHDEBUG
+ static int mshdbg = MSHDEBUG;
+ 
+@@ -220,6 +228,9 @@ struct op {
+ #define TASYNC  16      /* c & */
+ /* Added to support "." file expansion */
+ #define TDOT    17
++#define TFUNC   18 //funccode:start
++#define TRETURN 19
++ //funccode:end
+ 
+ /* Strings for names to make debug easier */
+ #ifdef MSHDEBUG
+@@ -319,6 +330,27 @@ struct region {
+ 	int area;
+ };
+ 
++static int func_finished; //funccode:start
++struct func {
++	char* name;
++	int begin_addr; /* pos in buffer of function */
++	int end_addr;
++};
++#define MAX_FUNCS 100
++
++static struct func funcs[MAX_FUNCS];
++
++/* the max DEPTH of function call */
++#define MAX_DEPTH 100
++static struct _frame_s {
++	int argc;
++	char **argv;
++	int saved_return_addr;
++} frame[MAX_DEPTH];
++
++static void register_func(int begin, int end);
++static struct func* find_func(char* name);
++static void exec_func(struct func* f); //funccode:end
+ 
+ /* -------- grammar stuff -------- */
+ typedef union {
+@@ -347,6 +379,8 @@ typedef union {
+ #define IN      272
+ /* Added for "." file expansion */
+ #define DOT     273
++#define FUNC    274 //funccode:start
++#define RETURN  275 //funccode:end
+ 
+ #define	YYERRCODE 300
+ 
+@@ -1722,6 +1756,40 @@ static struct op *simple(void)
+ 			(void) synio(0);
+ 			break;
+ 
++		case FUNC: { //funccode:start
++			int stop_flag;
++			int number_brace;
++			int func_begin;
++			int func_end;
++			int c;
++			while ((c = my_getc(0)) == ' ' || c == '\t'|| c == '\n') /* skip whitespace */
++				continue;
++			stop_flag = 1;
++			number_brace = 0;
++			func_begin = global_env.iobase->argp->afpos;
++			while (stop_flag) {
++				if (c == '{')
++					number_brace++;
++				if (c == '}')
++					number_brace--;
++				if (!number_brace) /* if we reach the brace of most outsite */
++					stop_flag = 0;
++				c = my_getc(0);
++			}
++			unget(c);
++			unget(c);
++			func_end = global_env.iobase->argp->afpos;
++			register_func(func_begin, func_end);
++			peeksym = 0;
++			t = NULL;
++			return t;
++		}
++		case RETURN:
++			func_finished = 1;
++			peeksym = 0;
++			t = NULL;
++			return t; //funccode:end
++
+ 		case WORD:
+ 			if (t == NULL) {
+ 				t = newtp();
+@@ -2265,6 +2333,13 @@ static int yylex(int cf)
+ 	case ')':
+ 		startl = 1;
+ 		return c;
++	case '{': //funccode:start
++		c = collect(c, '}');
++		if (c != '\0')
++			return c;
++		break;
++	case '}':
++		return RETURN; //funccode:end
+ 	}
+ 
+ 	unget(c);
+@@ -2293,9 +2368,172 @@ static int yylex(int cf)
+ 	}
+ 
+ 	yylval.cp = strsave(line, areanum);
++	/* To identify a subroutine */ //funccode:start
++	c = my_getc(0);
++	if (c && any(c, "(")) {
++		c = my_getc(0);
++		if (c && any(c, ")"))
++			return FUNC;
++		zzerr();
++	} else
++		unget(c);
++	/* read the first char */
++	/* To identify a function */
++	if (strcmp(yylval.cp, "function") == 0) {
++		int ret = yylex(0);
++		/* read the function name after "function" */
++		if (ret == WORD)
++			return (FUNC);
++		zzerr();
++	}
++	{
++		struct func* f = find_func(yylval.cp);
++		if (f != NULL) {
++			exec_func(f);
++			return RETURN;
++		}
++	}
++	if (yylval.cp != NULL && strcmp(yylval.cp, "return") == 0) {
++		return RETURN;
++	} //funccode:end
+ 	return WORD;
+ }
+ 
++static void register_func(int begin, int end) //funccode:start
++{
++	struct func *p;
++	int i;
++        for (i = 0; i < MAX_FUNCS; i++) {
++		if (funcs[i].name == NULL) {
++			p = &funcs[i];
++			break;
++		}
++	}
++	if (i == MAX_FUNCS) {
++		fprintf(stderr, "Too much functions beyond limit\n");
++		leave();
++	}
++	p->name = xstrdup(yylval.cp);
++	//fprintf(stderr, "register function,%d,%d,%s\n", begin, end, p->name);
++	KSDBG_PRINT_FUNCNAME;
++	 /* io stream */
++	p->begin_addr = begin;
++	p->end_addr = end;
++}
++
++static struct func* find_func(char* name)
++{
++	int i;
++	for (i = 0; i < MAX_FUNCS; i++) {
++		if (funcs[i].name == NULL)
++			continue;
++		if (!strcmp(funcs[i].name, name))
++			return &funcs[i];
++	}
++	KSDBG_PRINT_FUNCNAME;
++	//fprintf(stderr, "not found the function %s\n", name);
++	return NULL;
++	//zzerr();
++}
++
++/* Begin to execute the function */
++static int cur_frame = 0;
++
++static void exec_func(struct func* f)
++{
++	int c;
++	int temp_argc;
++	char** temp_argv;
++	struct iobuf *bp;
++
++	/* create a new frame, save the argument and return address to this frame */
++	frame[cur_frame].argc = dolc;
++	frame[cur_frame].argv = dolv;
++
++	cur_frame++;
++	/* do some argment parse and set arguments */
++	temp_argv = xmalloc(sizeof(char *));
++	temp_argv[0] = xstrdup(f->name);
++	temp_argc = 0;
++	global_env.iop->argp->afpos--;
++	global_env.iop->argp->afbuf->bufp--;
++//	unget(c);
++	while (((c = yylex(0)) != '\n') && (yylval.cp != NULL)) {
++		temp_argc++;
++		temp_argv = xrealloc(temp_argv, sizeof(char *) * (temp_argc+1));
++		/* parse $ var if passed argument is a variable */
++		if (yylval.cp[0] == '$') {
++			struct var *arg = lookup(&yylval.cp[1]);
++			temp_argv[temp_argc] = xstrdup(arg->value);
++			//fprintf(stderr, "arg->value=%s\n", arg->value);
++		} else {
++			temp_argv[temp_argc] = xstrdup(yylval.cp);
++			//fprintf(stderr, "ARG:%s\n", yylval.cp);
++		}
++	}
++	/*
++	global_env.iop->argp->afpos--;
++        global_env.iop->argp->afbuf->bufp--;
++	*/
++	dolc = temp_argc;
++	dolv = temp_argv;
++	//unget(c);
++	//while ((c = my_getc(0)) == ' ' || c == '\t')  /* Skip whitespace */
++	//	continue;
++	//unget(c);
++	frame[cur_frame].saved_return_addr = global_env.iop->argp->afpos;
++
++	/* get function begin address and execute this function */
++
++	bp = global_env.iop->argp->afbuf;
++	bp->bufp = &(bp->buf[f->begin_addr]);
++	global_env.iop->argp->afpos = f->begin_addr;
++
++	/* func_finished=0 means we are in a function and func_finished=1 means we are executing a function */
++	func_finished = 0;
++
++	//fprintf(stderr, "exec function %s\n", f->name);
++	KSDBG_PRINT_FUNCNAME;
++	for (;;) {
++		//fprintf(stderr, "afpos=%d,%s\n", global_env.iop->argp->afpos, yylval.cp);
++		if (global_env.iop->argp->afpos == f->end_addr)
++			break;
++		onecommand();
++		/* we return from a function, when func_finished = 1 */
++		if (func_finished)
++			break;
++	}
++
++	{
++		//fprintf(stderr, "%s is finished @%d!\n", f->name, global_env.iop->argp->afpos);
++		int ret = frame[cur_frame].saved_return_addr;
++		/* workaround code for \n */
++		if (dolc)
++			ret--;
++		/* get return address from current frame and jump to */
++		global_env.iop->argp->afpos = ret;
++		global_env.iop->argp->afbuf->bufp = &(global_env.iop->argp->afbuf->buf[ret]);
++	}
++	/*
++	fprintf(stderr, "******** after execution ********************\n");
++	fprintf(stderr, " %s \n############# %d\n", global_env.iop->argp->afbuf->bufp, ret);
++	fprintf(stderr, "*******************************\n");
++	*/
++	/* we return to previous frame */
++	cur_frame--;
++	/* free some space occupied by argument */
++	while (dolc--)
++		free(dolv[dolc]);
++	free(dolv);
++
++	/* recover argument for last function */
++	dolv = frame[cur_frame].argv;
++	dolc = frame[cur_frame].argc;
++	/* If we are not in the outest frame, we should set
++	 * func_finished to 0 that means we still in some function */
++	if (cur_frame != 0)
++		func_finished = 0;
++} //funccode:end
+ 
+ static int collect(int c, int c1)
+ {
+@@ -2601,6 +2839,10 @@ static int execute(struct op *t, int *pi
+ 				execute(t->right->right, pin, pout, /* no_fork: */ 0);
+ 		}
+ 		break;
++	case TFUNC: //funccode:start
++		break;
++	case TRETURN:
++		break; //funccode:end
+ 
+ 	case TCASE:
+ 		cp = evalstr(t->str, DOSUB | DOTRIM);