* "small and simple is beautiful" philosophy, which
* incidentally is a good match to today's BusyBox.
*
- * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
+ * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
* Copyright (C) 2008,2009 Denys Vlasenko <vda.linux@googlemail.com>
*
* Credits:
* POSIX syntax not implemented:
* aliases
* <(list) and >(list) Process Substitution
- * Functions
* Tilde Expansion
*
* Bash stuff (maybe optionally enable?):
* ^Z handling (and explain it in comments for mere humans)
* separate job control from interactiveness
* (testcase: booting with init=/bin/hush does not show prompt (2009-04))
- * functions
*
* Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
*/
#include <glob.h>
/* #include <dmalloc.h> */
#if ENABLE_HUSH_CASE
-#include <fnmatch.h>
+# include <fnmatch.h>
#endif
#include "math.h"
#include "match.h"
* Keeping 1 for now even in released versions.
*/
#define HUSH_DEBUG 1
-/* In progress... */
-#define ENABLE_HUSH_FUNCTIONS 1
#if BUILD_AS_NOMMU
#if defined SINGLE_APPLET_MAIN
/* STANDALONE does not make sense, and won't compile */
-#undef CONFIG_FEATURE_SH_STANDALONE
-#undef ENABLE_FEATURE_SH_STANDALONE
-#undef USE_FEATURE_SH_STANDALONE
-#define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
-#define ENABLE_FEATURE_SH_STANDALONE 0
-#define USE_FEATURE_SH_STANDALONE(...)
-#define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
+# undef CONFIG_FEATURE_SH_STANDALONE
+# undef ENABLE_FEATURE_SH_STANDALONE
+# undef USE_FEATURE_SH_STANDALONE
+# define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
+# define ENABLE_FEATURE_SH_STANDALONE 0
+# define USE_FEATURE_SH_STANDALONE(...)
+# define SKIP_FEATURE_SH_STANDALONE(...) __VA_ARGS__
#endif
#if !ENABLE_HUSH_INTERACTIVE
-#undef ENABLE_FEATURE_EDITING
-#define ENABLE_FEATURE_EDITING 0
-#undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
-#define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
+# undef ENABLE_FEATURE_EDITING
+# define ENABLE_FEATURE_EDITING 0
+# undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
+# define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
#endif
/* Do we support ANY keywords? */
#if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS || ENABLE_HUSH_CASE
-#define HAS_KEYWORDS 1
-#define IF_HAS_KEYWORDS(...) __VA_ARGS__
-#define IF_HAS_NO_KEYWORDS(...)
+# define HAS_KEYWORDS 1
+# define IF_HAS_KEYWORDS(...) __VA_ARGS__
+# define IF_HAS_NO_KEYWORDS(...)
#else
-#define HAS_KEYWORDS 0
-#define IF_HAS_KEYWORDS(...)
-#define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
+# define HAS_KEYWORDS 0
+# define IF_HAS_KEYWORDS(...)
+# define IF_HAS_NO_KEYWORDS(...) __VA_ARGS__
#endif
/* If you comment out one of these below, it will be #defined later
#define debug_printf_subst(...) do {} while (0)
#define debug_printf_clean(...) do {} while (0)
-#ifndef debug_printf
-#define debug_printf(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_parse
-#define debug_printf_parse(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_exec
-#define debug_printf_exec(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_env
-#define debug_printf_env(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_jobs
-#define debug_printf_jobs(...) fprintf(stderr, __VA_ARGS__)
-#define DEBUG_JOBS 1
-#else
-#define DEBUG_JOBS 0
-#endif
-
-#ifndef debug_printf_expand
-#define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
-#define DEBUG_EXPAND 1
-#else
-#define DEBUG_EXPAND 0
-#endif
-
-#ifndef debug_printf_glob
-#define debug_printf_glob(...) fprintf(stderr, __VA_ARGS__)
-#define DEBUG_GLOB 1
-#else
-#define DEBUG_GLOB 0
-#endif
-
-#ifndef debug_printf_list
-#define debug_printf_list(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_subst
-#define debug_printf_subst(...) fprintf(stderr, __VA_ARGS__)
-#endif
-
-#ifndef debug_printf_clean
-/* broken, of course, but OK for testing */
-static const char *indenter(int i)
-{
- static const char blanks[] ALIGN1 =
- " ";
- return &blanks[sizeof(blanks) - i - 1];
-}
-#define debug_printf_clean(...) fprintf(stderr, __VA_ARGS__)
-#define DEBUG_CLEAN 1
-#else
-#define DEBUG_CLEAN 0
-#endif
-
-#if DEBUG_EXPAND
-static void debug_print_strings(const char *prefix, char **vv)
-{
- fprintf(stderr, "%s:\n", prefix);
- while (*vv)
- fprintf(stderr, " '%s'\n", *vv++);
-}
-#else
-#define debug_print_strings(prefix, vv) ((void)0)
-#endif
-
#define ERR_PTR ((void*)(long)1)
#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
/* note: for heredocs, rd_filename contains heredoc delimiter,
* and subsequently heredoc itself; and rd_dup is a bitmask:
* 1: do we need to trim leading tabs?
- * 2: is heredoc quoted (<<'dleim' syntax) ?
+ * 2: is heredoc quoted (<<'delim' syntax) ?
*/
};
typedef enum redir_type {
int assignment_cnt; /* how many argv[i] are assignments? */
smallint is_stopped; /* is the command currently running? */
smallint grp_type; /* GRP_xxx */
+#define GRP_NORMAL 0
+#define GRP_SUBSHELL 1
+#if ENABLE_HUSH_FUNCTIONS
+# define GRP_FUNCTION 2
+#endif
struct pipe *group; /* if non-NULL, this "command" is { list },
* ( list ), or a compound statement */
#if !BB_MMU
char *group_as_string;
+#endif
+#if ENABLE_HUSH_FUNCTIONS
+ struct function *child_func;
+/* This field is used to prevent a bug here:
+ * while...do f1() {a;}; f1; f1 {b;}; f1; done
+ * When we execute "f1() {a;}" cmd, we create new function and clear
+ * cmd->group, cmd->group_as_string, cmd->argv[0].
+ * when we execute "f1 {b;}", we notice that f1 exists,
+ * and that it's "parent cmd" struct is still "alive",
+ * we put those fields back into cmd->xxx
+ * (struct function has ->parent_cmd ptr to facilitate that).
+ * When we loop back, we can execute "f1() {a;}" again and set f1 correctly.
+ * Without this trick, loop would execute a;b;b;b;...
+ * instead of correct sequence a;b;a;b;...
+ * When command is freed, it severs the link
+ * (sets ->child_func->parent_cmd to NULL).
+ */
#endif
char **argv; /* command name and arguments */
- struct redir_struct *redirects; /* I/O redirections */
-};
/* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
* and on execution these are substituted with their values.
* Substitution can make _several_ words out of one argv[n]!
* Example: argv[0]=='.^C*^C.' here: echo .$*.
* References of the form ^C`cmd arg^C are `cmd arg` substitutions.
*/
-#define GRP_NORMAL 0
-#define GRP_SUBSHELL 1
-#if ENABLE_HUSH_FUNCTIONS
-# define GRP_FUNCTION 2
-#endif
+ struct redir_struct *redirects; /* I/O redirections */
+};
struct pipe {
struct pipe *next;
struct function {
struct function *next;
char *name;
+ struct command *parent_cmd;
struct pipe *body;
#if !BB_MMU
char *body_as_string;
sigset_t inherited_set;
#if HUSH_DEBUG
unsigned long memleak_value;
+ int debug_indent;
#endif
char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
#if ENABLE_FEATURE_SH_STANDALONE
};
+/* Debug printouts.
+ */
+#if HUSH_DEBUG
+/* prevent disasters with G.debug_indent < 0 */
+# define indent() fprintf(stderr, "%*s", (G.debug_indent * 2) & 0xff, "")
+# define debug_enter() (G.debug_indent++)
+# define debug_leave() (G.debug_indent--)
+#else
+# define indent() ((void)0)
+# define debug_enter() ((void)0)
+# define debug_leave() ((void)0)
+#endif
+
+#ifndef debug_printf
+# define debug_printf(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_parse
+# define debug_printf_parse(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_exec
+#define debug_printf_exec(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_env
+# define debug_printf_env(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_jobs
+# define debug_printf_jobs(...) (indent(), fprintf(stderr, __VA_ARGS__))
+# define DEBUG_JOBS 1
+#else
+# define DEBUG_JOBS 0
+#endif
+
+#ifndef debug_printf_expand
+# define debug_printf_expand(...) (indent(), fprintf(stderr, __VA_ARGS__))
+# define DEBUG_EXPAND 1
+#else
+# define DEBUG_EXPAND 0
+#endif
+
+#ifndef debug_printf_glob
+# define debug_printf_glob(...) (indent(), fprintf(stderr, __VA_ARGS__))
+# define DEBUG_GLOB 1
+#else
+# define DEBUG_GLOB 0
+#endif
+
+#ifndef debug_printf_list
+# define debug_printf_list(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_subst
+# define debug_printf_subst(...) (indent(), fprintf(stderr, __VA_ARGS__))
+#endif
+
+#ifndef debug_printf_clean
+# define debug_printf_clean(...) (indent(), fprintf(stderr, __VA_ARGS__))
+# define DEBUG_CLEAN 1
+#else
+# define DEBUG_CLEAN 0
+#endif
+
+#if DEBUG_EXPAND
+static void debug_print_strings(const char *prefix, char **vv)
+{
+ indent();
+ fprintf(stderr, "%s:\n", prefix);
+ while (*vv)
+ fprintf(stderr, " '%s'\n", *vv++);
+}
+#else
+#define debug_print_strings(prefix, vv) ((void)0)
+#endif
+
+
/* Leak hunting. Use hush_leaktool.sh for post-processing.
*/
#if LEAK_HUNTING
msg[0] = ch;
msg[1] = '\0';
die_if_script(lineno, "syntax error: unexpected %s", msg);
- xfunc_die();
}
#if HUSH_DEBUG < 2
char **list = (char**)o->data;
int string_start = ((n + 0xf) & ~0xf) * sizeof(list[0]);
int i = 0;
+
+ indent();
fprintf(stderr, "%s: list:%p n:%d string_start:%d length:%d maxlen:%d\n",
prefix, list, n, string_start, o->length, o->maxlen);
while (i < n) {
+ indent();
fprintf(stderr, " list[%d]=%d '%s' %p\n", i, (int)list[i],
o->data + (int)list[i] + string_start,
o->data + (int)list[i] + string_start);
}
if (n) {
const char *p = o->data + (int)list[n - 1] + string_start;
+ indent();
fprintf(stderr, " total_sz:%ld\n", (long)((p + strlen(p) + 1) - o->data));
}
}
char param_buf[sizeof("-$%x:%x:%x:%x") + sizeof(unsigned) * 4];
char *heredoc_argv[4];
struct variable *cur;
+#if ENABLE_HUSH_FUNCTIONS
+ struct function *funcp;
+#endif
char **argv, **pp;
unsigned cnt;
, (unsigned) G.last_exitcode
USE_HUSH_LOOPS(, G.depth_of_loop)
);
- /* 1:hush 2:-$<pid>:<pid>:<exitcode>:<depth> <vars...>
+ /* 1:hush 2:-$<pid>:<pid>:<exitcode>:<depth> <vars...> <funcs...>
* 3:-c 4:<cmd> 5:<arg0> <argN...> 6:NULL
*/
cnt = 6;
if (!cur->flg_export || cur->flg_read_only)
cnt += 2;
}
+#if ENABLE_HUSH_FUNCTIONS
+ for (funcp = G.top_func; funcp; funcp = funcp->next)
+ cnt += 3;
+#endif
pp = g_argv;
while (*pp++)
cnt++;
*pp++ = cur->varstr;
}
}
-//TODO: pass functions
+#if ENABLE_HUSH_FUNCTIONS
+ for (funcp = G.top_func; funcp; funcp = funcp->next) {
+ *pp++ = (char *) "-F";
+ *pp++ = funcp->name;
+ *pp++ = funcp->body_as_string;
+ }
+#endif
/* We can pass activated traps here. Say, -Tnn:trap_string
*
* However, POSIX says that subshells reset signals with traps
}
-#if !DEBUG_CLEAN
-#define free_pipe_list(head, indent) free_pipe_list(head)
-#define free_pipe(pi, indent) free_pipe(pi)
-#endif
-static void free_pipe_list(struct pipe *head, int indent);
+static void free_pipe_list(struct pipe *head);
/* Return code is the exit status of the pipe */
-static void free_pipe(struct pipe *pi, int indent)
+static void free_pipe(struct pipe *pi)
{
char **p;
struct command *command;
if (pi->stopped_cmds > 0) /* why? */
return;
- debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
+ debug_printf_clean("run pipe: (pid %d)\n", getpid());
for (i = 0; i < pi->num_cmds; i++) {
command = &pi->cmds[i];
- debug_printf_clean("%s command %d:\n", indenter(indent), i);
+ debug_printf_clean(" command %d:\n", i);
if (command->argv) {
for (a = 0, p = command->argv; *p; a++, p++) {
- debug_printf_clean("%s argv[%d] = %s\n",
- indenter(indent), a, *p);
+ debug_printf_clean(" argv[%d] = %s\n", a, *p);
}
free_strings(command->argv);
command->argv = NULL;
}
/* not "else if": on syntax error, we may have both! */
if (command->group) {
- debug_printf_clean("%s begin group (grp_type:%d)\n",
- indenter(indent), command->grp_type);
- free_pipe_list(command->group, indent+3);
- debug_printf_clean("%s end group\n", indenter(indent));
+ debug_printf_clean(" begin group (grp_type:%d)\n",
+ command->grp_type);
+ free_pipe_list(command->group);
+ debug_printf_clean(" end group\n");
command->group = NULL;
}
+ /* else is crucial here.
+ * If group != NULL, child_func is meaningless */
+#if ENABLE_HUSH_FUNCTIONS
+ else if (command->child_func) {
+ debug_printf_exec("cmd %p releases child func at %p\n", command, command->child_func);
+ command->child_func->parent_cmd = NULL;
+ }
+#endif
#if !BB_MMU
free(command->group_as_string);
command->group_as_string = NULL;
#endif
for (r = command->redirects; r; r = rnext) {
- debug_printf_clean("%s redirect %d%s", indenter(indent),
- r->fd, redir_table[r->rd_type].descrip);
+ debug_printf_clean(" redirect %d%s",
+ r->rd_fd, redir_table[r->rd_type].descrip);
/* guard against the case >$FOO, where foo is unset or blank */
if (r->rd_filename) {
debug_printf_clean(" fname:'%s'\n", r->rd_filename);
#endif
}
-static void free_pipe_list(struct pipe *head, int indent)
+static void free_pipe_list(struct pipe *head)
{
struct pipe *pi, *next;
for (pi = head; pi; pi = next) {
#if HAS_KEYWORDS
- debug_printf_clean("%s pipe reserved word %d\n", indenter(indent), pi->res_word);
+ debug_printf_clean(" pipe reserved word %d\n", pi->res_word);
#endif
- free_pipe(pi, indent);
- debug_printf_clean("%s pipe followup code %d\n", indenter(indent), pi->followup);
+ free_pipe(pi);
+ debug_printf_clean("pipe followup code %d\n", pi->followup);
next = pi->next;
/*pi->next = NULL;*/
free(pi);
static int run_list(struct pipe *pi);
+#if BB_MMU
+#define parse_stream(pstring, input, end_trigger) \
+ parse_stream(input, end_trigger)
+#endif
+static struct pipe *parse_stream(char **pstring,
+ struct in_str *input,
+ int end_trigger);
+static void parse_and_run_string(const char *s);
+
static const struct built_in_command* find_builtin(const char *name)
{
return funcp;
}
+/* Note: takes ownership on name ptr */
+static struct function *new_function(char *name)
+{
+ struct function *funcp;
+ struct function **funcpp = &G.top_func;
+
+ while ((funcp = *funcpp) != NULL) {
+ struct command *cmd;
+
+ if (strcmp(funcp->name, name) != 0) {
+ funcpp = &funcp->next;
+ continue;
+ }
+
+ cmd = funcp->parent_cmd;
+ debug_printf_exec("func %p parent_cmd %p\n", funcp, cmd);
+ if (!cmd) {
+ debug_printf_exec("freeing & replacing function '%s'\n", funcp->name);
+ free(funcp->name);
+ /* Note: if !funcp->body, do not free body_as_string!
+ * This is a special case of "-F name body" function:
+ * body_as_string was not malloced! */
+ if (funcp->body) {
+ free_pipe_list(funcp->body);
+#if !BB_MMU
+ free(funcp->body_as_string);
+#endif
+ }
+ } else {
+ debug_printf_exec("reinserting in tree & replacing function '%s'\n", funcp->name);
+ cmd->argv[0] = funcp->name;
+ cmd->group = funcp->body;
+#if !BB_MMU
+ cmd->group_as_string = funcp->body_as_string;
+#endif
+ }
+ goto skip;
+ }
+ debug_printf_exec("remembering new function '%s'\n", command->argv[0]);
+ funcp = *funcpp = xzalloc(sizeof(*funcp));
+ /*funcp->next = NULL;*/
+ skip:
+ funcp->name = name;
+ return funcp;
+}
+
static void exec_function(const struct function *funcp, char **argv) NORETURN;
static void exec_function(const struct function *funcp, char **argv)
{
while (*++argv)
n++;
G.global_argc = n;
+ /* On MMU, funcp->body is always non-NULL */
n = run_list(funcp->body);
fflush(NULL);
_exit(n);
G.global_argc = n;
G.global_argv = argv;
- n = run_list(funcp->body);
+ /* On MMU, funcp->body is always non-NULL */
+#if !BB_MMU
+ if (!funcp->body) {
+ /* Function defined by -F */
+ parse_and_run_string(funcp->body_as_string);
+ n = G.last_exitcode;
+ } else
+#endif
+ {
+ n = run_list(funcp->body);
+ }
if (G.global_args_malloced) {
/* function ran "set -- arg1 arg2 ..." */
{
remove_bg_job(pi);
pi->stopped_cmds = 0;
- free_pipe(pi, 0);
+ free_pipe(pi);
free(pi);
}
#endif /* JOB */
int rcode;
debug_printf_exec("run_pipe start: members:%d\n", pi->num_cmds);
+ debug_enter();
USE_HUSH_JOB(pi->pgrp = -1;)
pi->stopped_cmds = 0;
if (command->grp_type == GRP_FUNCTION) {
/* "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'\n", funcp->name);
- free(funcp->name);
- free_pipe_list(funcp->body, /* indent: */ 0);
- goto skip;
- }
- funcpp = &funcp->next;
- }
- debug_printf_exec("remembering new function '%s'\n", command->argv[0]);
- funcp = *funcpp = xzalloc(sizeof(*funcp));
- /*funcp->next = NULL;*/
- skip:
- funcp->name = command->argv[0];
+
+ funcp = new_function(command->argv[0]);
+ /* funcp->name is already set to argv[0] */
funcp->body = command->group;
#if !BB_MMU
funcp->body_as_string = command->group_as_string;
#endif
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!
+ debug_printf_exec("cmd %p has child func at %p\n", command, funcp);
+ funcp->parent_cmd = command;
+ command->child_func = funcp;
+ debug_printf_exec("run_pipe: return EXIT_SUCCESS\n");
+ debug_leave();
return EXIT_SUCCESS;
}
#endif
if (setup_redirects(command, squirrel) == 0) {
debug_printf_exec(": run_list\n");
rcode = run_list(command->group) & 0xff;
- debug_printf_exec("run_pipe return %d\n", rcode);
}
restore_redirects(squirrel);
IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
+ debug_leave();
+ debug_printf_exec("run_pipe: return %d\n", rcode);
return rcode;
}
* "assignment to readonly var" and "putenv error"
*/
IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
+ debug_leave();
+ debug_printf_exec("run_pipe: return %d\n", rcode);
return rcode;
}
clean_up_and_ret1:
free(argv_expanded);
IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
+ debug_leave();
debug_printf_exec("run_pipe return %d\n", rcode);
return rcode;
}
}
if (!pi->alive_cmds) {
+ debug_leave();
debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
return 1;
}
+ debug_leave();
debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
return -1;
}
#endif
debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
+ debug_enter();
#if ENABLE_HUSH_LOOPS
/* Check syntax for "for" */
/* current word is FOR or IN (BOLD in comments below) */
if (cpipe->next == NULL) {
syntax_error("malformed for");
+ debug_leave();
debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
return 1;
}
|| cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
) {
syntax_error("malformed for");
+ debug_leave();
debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
return 1;
}
//// signal(SIGINT, SIG_IGN);
//// }
#endif
- debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
#if ENABLE_HUSH_LOOPS
if (loop_top)
G.depth_of_loop--;
#if ENABLE_HUSH_CASE
free(case_word);
#endif
+ debug_leave();
+ debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
return rcode;
}
/* free_pipe_list has the side effect of clearing memory.
* In the long run that function can be merged with run_list,
* but doing that now would hobble the debugging effort. */
- free_pipe_list(pi, /* indent: */ 0);
+ free_pipe_list(pi);
debug_printf_exec("run_and_free_list return %d\n", rcode);
return rcode;
}
* RES_NONE case is for "for a in; do ..." (empty IN set)
* and other cases to work. */
if (not_null
-#if HAS_KEYWORDS
+#if ENABLE_HUSH_IF
|| ctx->ctx_res_w == RES_FI
+#endif
+#if ENABLE_HUSH_LOOPS
|| ctx->ctx_res_w == RES_DONE
|| ctx->ctx_res_w == RES_FOR
|| ctx->ctx_res_w == RES_IN
+#endif
+#if ENABLE_HUSH_CASE
|| ctx->ctx_res_w == RES_ESAC
#endif
) {
}
-#if BB_MMU
-#define parse_stream(pstring, input, end_trigger) \
- parse_stream(input, end_trigger)
-#endif
-static struct pipe *parse_stream(char **pstring,
- struct in_str *input,
- int end_trigger);
-static void parse_and_run_string(const char *s);
-
#if ENABLE_HUSH_TICK
static FILE *generate_stream_from_string(const char *s)
{
*/
debug_printf_parse("parse_stream entered, end_trigger='%c'\n",
end_trigger ? : 'X');
+ debug_enter();
G.ifs = get_local_var_value("IFS");
if (G.ifs == NULL)
if (pi->num_cmds == 0
IF_HAS_KEYWORDS( && pi->res_word == RES_NONE)
) {
- free_pipe_list(pi, 0);
+ free_pipe_list(pi);
pi = NULL;
}
- debug_printf_parse("parse_stream return %p\n", pi);
#if !BB_MMU
debug_printf_parse("as_string '%s'\n", ctx.as_string.data);
if (pstring)
else
o_free_unsafe(&ctx.as_string);
#endif
+ debug_leave();
+ debug_printf_parse("parse_stream return %p\n", pi);
return pi;
}
nommu_addchr(&ctx.as_string, ch);
if (!HAS_KEYWORDS
IF_HAS_KEYWORDS(|| (ctx.ctx_res_w == RES_NONE && ctx.old_flag == 0))
) {
- debug_printf_parse("parse_stream return %p: "
- "end_trigger char found\n",
- ctx.list_head);
o_free(&dest);
#if !BB_MMU
debug_printf_parse("as_string '%s'\n", ctx.as_string.data);
else
o_free_unsafe(&ctx.as_string);
#endif
+ debug_leave();
+ debug_printf_parse("parse_stream return %p: "
+ "end_trigger char found\n",
+ ctx.list_head);
return ctx.list_head;
}
}
debug_printf_clean("freeing list %p from ctx %p\n",
pctx->list_head, pctx);
debug_print_tree(pctx->list_head, 0);
- free_pipe_list(pctx->list_head, 0);
+ free_pipe_list(pctx->list_head);
debug_printf_clean("freed list %p\n", pctx->list_head);
#if !BB_MMU
o_free_unsafe(&pctx->as_string);
if (pstring)
*pstring = NULL;
#endif
+ debug_leave();
return ERR_PTR;
}
/* Discard cached input, force prompt */
while (1) {
opt = getopt(argc, argv, "c:xins"
#if !BB_MMU
- "<:$:!:?:D:R:V:"
+ "<:$:R:V:"
+# if ENABLE_HUSH_FUNCTIONS
+ "F:"
+# endif
#endif
);
if (opt <= 0)
case 'V':
set_local_var(xstrdup(optarg), 0, opt == 'R');
break;
+# if ENABLE_HUSH_FUNCTIONS
+ case 'F': {
+ struct function *funcp = new_function(optarg);
+ /* funcp->name is already set to optarg */
+ /* funcp->body is set to NULL. It's a special case. */
+ funcp->body_as_string = argv[optind];
+ optind++;
+ break;
+ }
+# endif
#endif
case 'n':
case 'x':
projects / oweals / busybox.git / blobdiff