aboutsummaryrefslogtreecommitdiff
path: root/shell
diff options
context:
space:
mode:
Diffstat (limited to 'shell')
-rw-r--r--shell/msh_function.patch350
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);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-30 04:00:22 +0000