* aliases
* Arithmetic Expansion
* <(list) and >(list) Process Substitution
- * reserved words: case, esac, select, function
+ * reserved words: select, function
* Here Documents ( << word )
* Functions
* Major bugs:
* job handling woefully incomplete and buggy (improved --vda)
- * reserved word execution woefully incomplete and buggy
* to-do:
* port selected bugfixes from post-0.49 busybox lash - done?
* change { and } from special chars to reserved words
RES_SNTX
} reserved_style;
-/* This holds pointers to the various results of parsing */
-struct p_context {
- struct child_prog *child;
- struct pipe *list_head;
- struct pipe *pipe;
- struct redir_struct *pending_redirect;
-#if HAS_KEYWORDS
- smallint ctx_res_w;
- smallint ctx_inverted; /* "! cmd | cmd" */
-#if ENABLE_HUSH_CASE
- smallint ctx_dsemicolon; /* ";;" seen */
-#endif
- int old_flag; /* bitmask of FLAG_xxx, for figuring out valid reserved words */
- struct p_context *stack;
-#endif
-};
-
struct redir_struct {
struct redir_struct *next;
char *rd_filename; /* filename */
smallint /*enum redir_type*/ rd_type;
};
-struct child_prog {
+struct command {
pid_t pid; /* 0 if exited */
int assignment_cnt; /* how many argv[i] are assignments? */
- smallint is_stopped; /* is the program currently running? */
+ smallint is_stopped; /* is the command currently running? */
smallint subshell; /* flag, non-zero if group must be forked */
struct pipe *group; /* if non-NULL, this "prog" is {} group,
* subshell, or a compound statement */
- char **argv; /* program name and arguments */
+ char **argv; /* command name and arguments */
struct redir_struct *redirects; /* I/O redirections */
};
/* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
struct pipe {
struct pipe *next;
- int num_progs; /* total number of programs in job */
- int alive_progs; /* number of programs running (not exited) */
- int stopped_progs; /* number of programs alive, but stopped */
+ int num_cmds; /* total number of commands in job */
+ int alive_cmds; /* number of commands running (not exited) */
+ int stopped_cmds; /* number of commands alive, but stopped */
#if ENABLE_HUSH_JOB
int jobid; /* job number */
pid_t pgrp; /* process group ID for the job */
char *cmdtext; /* name of job */
#endif
- struct child_prog *progs; /* array of commands in pipe */
+ struct command *cmds; /* array of commands in pipe */
smallint followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */
IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */
};
+/* This holds pointers to the various results of parsing */
+struct parse_context {
+ struct command *command;
+ struct pipe *list_head;
+ struct pipe *pipe;
+ struct redir_struct *pending_redirect;
+#if HAS_KEYWORDS
+ smallint ctx_res_w;
+ smallint ctx_inverted; /* "! cmd | cmd" */
+#if ENABLE_HUSH_CASE
+ smallint ctx_dsemicolon; /* ";;" seen */
+#endif
+ int old_flag; /* bitmask of FLAG_xxx, for figuring out valid reserved words */
+ struct parse_context *stack;
+#endif
+};
+
/* On program start, environ points to initial environment.
* putenv adds new pointers into it, unsetenv removes them.
* Neither of these (de)allocates the strings.
static int free_pipe_list(struct pipe *head, int indent);
static int free_pipe(struct pipe *pi, int indent);
/* really run the final data structures: */
-static int setup_redirects(struct child_prog *prog, int squirrel[]);
+static int setup_redirects(struct command *prog, int squirrel[]);
static int run_list(struct pipe *pi);
#if BB_MMU
#define pseudo_exec_argv(ptrs2free, argv, assignment_cnt, argv_expanded) \
pseudo_exec_argv(argv, assignment_cnt, argv_expanded)
-#define pseudo_exec(ptrs2free, child, argv_expanded) \
- pseudo_exec(child, argv_expanded)
+#define pseudo_exec(ptrs2free, command, argv_expanded) \
+ pseudo_exec(command, argv_expanded)
#endif
static void pseudo_exec_argv(char **ptrs2free, char **argv, int assignment_cnt, char **argv_expanded) NORETURN;
-static void pseudo_exec(char **ptrs2free, struct child_prog *child, char **argv_expanded) NORETURN;
+static void pseudo_exec(char **ptrs2free, struct command *command, char **argv_expanded) NORETURN;
static int run_pipe(struct pipe *pi);
/* data structure manipulation: */
-static int setup_redirect(struct p_context *ctx, int fd, redir_type style, struct in_str *input);
-static void initialize_context(struct p_context *ctx);
-static int done_word(o_string *dest, struct p_context *ctx);
-static int done_command(struct p_context *ctx);
-static void done_pipe(struct p_context *ctx, pipe_style type);
+static int setup_redirect(struct parse_context *ctx, int fd, redir_type style, struct in_str *input);
+static void initialize_context(struct parse_context *ctx);
+static int done_word(o_string *dest, struct parse_context *ctx);
+static int done_command(struct parse_context *ctx);
+static void done_pipe(struct parse_context *ctx, pipe_style type);
/* primary string parsing: */
static int redirect_dup_num(struct in_str *input);
static int redirect_opt_num(o_string *o);
static int process_command_subs(o_string *dest,
struct in_str *input, const char *subst_end);
#endif
-static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
+static int parse_group(o_string *dest, struct parse_context *ctx, struct in_str *input, int ch);
static const char *lookup_param(const char *src);
static int handle_dollar(o_string *dest,
struct in_str *input);
-static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, const char *end_trigger);
+static int parse_stream(o_string *dest, struct parse_context *ctx, struct in_str *input0, const char *end_trigger);
/* setup: */
static int parse_and_run_stream(struct in_str *inp, int parse_flag);
static int parse_and_run_string(const char *s, int parse_flag);
/* parent */
/* finish filling up pipe info */
G.toplevel_list->pgrp = pid; /* child is in its own pgrp */
- G.toplevel_list->progs[0].pid = pid;
+ G.toplevel_list->cmds[0].pid = pid;
/* parent needs to longjmp out of running nofork.
* we will "return" exitcode 0, with child put in background */
// as usual we can have all kinds of nasty problems with leaked malloc data here
/* squirrel != NULL means we squirrel away copies of stdin, stdout,
* and stderr if they are redirected. */
-static int setup_redirects(struct child_prog *prog, int squirrel[])
+static int setup_redirects(struct command *prog, int squirrel[])
{
int openfd, mode;
struct redir_struct *redir;
/* Called after [v]fork() in run_pipe()
*/
-static void pseudo_exec(char **ptrs2free, struct child_prog *child, char **argv_expanded)
+static void pseudo_exec(char **ptrs2free, struct command *command, char **argv_expanded)
{
- if (child->argv)
- pseudo_exec_argv(ptrs2free, child->argv, child->assignment_cnt, argv_expanded);
+ if (command->argv)
+ pseudo_exec_argv(ptrs2free, command->argv, command->assignment_cnt, argv_expanded);
- if (child->group) {
+ if (command->group) {
#if !BB_MMU
bb_error_msg_and_die("nested lists are not supported on NOMMU");
#else
int rcode;
debug_printf_exec("pseudo_exec: run_list\n");
- rcode = run_list(child->group);
+ rcode = run_list(command->group);
/* OK to leak memory by not calling free_pipe_list,
* since this process is about to exit */
_exit(rcode);
* On subsequent bg argv is trashed, but we won't use it */
if (pi->cmdtext)
return pi->cmdtext;
- argv = pi->progs[0].argv;
+ argv = pi->cmds[0].argv;
if (!argv || !argv[0]) {
pi->cmdtext = xzalloc(1);
return pi->cmdtext;
len = 0;
do len += strlen(*argv) + 1; while (*++argv);
pi->cmdtext = p = xmalloc(len);
- argv = pi->progs[0].argv;
+ argv = pi->cmds[0].argv;
do {
len = strlen(*argv);
memcpy(p, *argv, len);
/* Physically copy the struct job */
memcpy(thejob, pi, sizeof(struct pipe));
- thejob->progs = xzalloc(sizeof(pi->progs[0]) * pi->num_progs);
- /* We cannot copy entire pi->progs[] vector! Double free()s will happen */
- for (i = 0; i < pi->num_progs; i++) {
+ thejob->cmds = xzalloc(sizeof(pi->cmds[0]) * pi->num_cmds);
+ /* We cannot copy entire pi->cmds[] vector! Double free()s will happen */
+ for (i = 0; i < pi->num_cmds; i++) {
// TODO: do we really need to have so many fields which are just dead weight
// at execution stage?
- thejob->progs[i].pid = pi->progs[i].pid;
+ thejob->cmds[i].pid = pi->cmds[i].pid;
/* all other fields are not used and stay zero */
}
thejob->next = NULL;
/* We don't wait for background thejobs to return -- append it
to the list of backgrounded thejobs and leave it alone */
- printf("[%d] %d %s\n", thejob->jobid, thejob->progs[0].pid, thejob->cmdtext);
- G.last_bg_pid = thejob->progs[0].pid;
+ printf("[%d] %d %s\n", thejob->jobid, thejob->cmds[0].pid, thejob->cmdtext);
+ G.last_bg_pid = thejob->cmds[0].pid;
G.last_jobid = thejob->jobid;
}
static void delete_finished_bg_job(struct pipe *pi)
{
remove_bg_job(pi);
- pi->stopped_progs = 0;
+ pi->stopped_cmds = 0;
free_pipe(pi, 0);
free(pi);
}
#endif
/* Were we asked to wait for fg pipe? */
if (fg_pipe) {
- for (i = 0; i < fg_pipe->num_progs; i++) {
- debug_printf_jobs("check pid %d\n", fg_pipe->progs[i].pid);
- if (fg_pipe->progs[i].pid != childpid)
+ for (i = 0; i < fg_pipe->num_cmds; i++) {
+ debug_printf_jobs("check pid %d\n", fg_pipe->cmds[i].pid);
+ if (fg_pipe->cmds[i].pid != childpid)
continue;
/* printf("process %d exit %d\n", i, WEXITSTATUS(status)); */
if (dead) {
- fg_pipe->progs[i].pid = 0;
- fg_pipe->alive_progs--;
- if (i == fg_pipe->num_progs - 1) {
+ fg_pipe->cmds[i].pid = 0;
+ fg_pipe->alive_cmds--;
+ if (i == fg_pipe->num_cmds - 1) {
/* last process gives overall exitstatus */
rcode = WEXITSTATUS(status);
IF_HAS_KEYWORDS(if (fg_pipe->pi_inverted) rcode = !rcode;)
}
} else {
- fg_pipe->progs[i].is_stopped = 1;
- fg_pipe->stopped_progs++;
+ fg_pipe->cmds[i].is_stopped = 1;
+ fg_pipe->stopped_cmds++;
}
- debug_printf_jobs("fg_pipe: alive_progs %d stopped_progs %d\n",
- fg_pipe->alive_progs, fg_pipe->stopped_progs);
- if (fg_pipe->alive_progs - fg_pipe->stopped_progs <= 0) {
+ debug_printf_jobs("fg_pipe: alive_cmds %d stopped_cmds %d\n",
+ fg_pipe->alive_cmds, fg_pipe->stopped_cmds);
+ if (fg_pipe->alive_cmds - fg_pipe->stopped_cmds <= 0) {
/* All processes in fg pipe have exited/stopped */
#if ENABLE_HUSH_JOB
- if (fg_pipe->alive_progs)
+ if (fg_pipe->alive_cmds)
insert_bg_job(fg_pipe);
#endif
return rcode;
/* We asked to wait for bg or orphaned children */
/* No need to remember exitcode in this case */
for (pi = G.job_list; pi; pi = pi->next) {
- for (i = 0; i < pi->num_progs; i++) {
- if (pi->progs[i].pid == childpid)
+ for (i = 0; i < pi->num_cmds; i++) {
+ if (pi->cmds[i].pid == childpid)
goto found_pi_and_prognum;
}
}
found_pi_and_prognum:
if (dead) {
/* child exited */
- pi->progs[i].pid = 0;
- pi->alive_progs--;
- if (!pi->alive_progs) {
+ pi->cmds[i].pid = 0;
+ pi->alive_cmds--;
+ if (!pi->alive_cmds) {
printf(JOB_STATUS_FORMAT, pi->jobid,
"Done", pi->cmdtext);
delete_finished_bg_job(pi);
}
} else {
/* child stopped */
- pi->progs[i].is_stopped = 1;
- pi->stopped_progs++;
+ pi->cmds[i].is_stopped = 1;
+ pi->stopped_cmds++;
}
#endif
} /* while (waitpid succeeds)... */
int i;
int nextin;
int pipefds[2]; /* pipefds[0] is for reading */
- struct child_prog *child;
+ struct command *command;
char **argv_expanded = NULL;
char **argv;
const struct built_in_command *x;
/* it is not always needed, but we aim to smaller code */
int squirrel[] = { -1, -1, -1 };
int rcode;
- const int single_and_fg = (pi->num_progs == 1 && pi->followup != PIPE_BG);
+ const int single_and_fg = (pi->num_cmds == 1 && pi->followup != PIPE_BG);
debug_printf_exec("run_pipe start: single_and_fg=%d\n", single_and_fg);
#if ENABLE_HUSH_JOB
pi->pgrp = -1;
#endif
- pi->alive_progs = 1;
- pi->stopped_progs = 0;
+ pi->alive_cmds = 1;
+ pi->stopped_cmds = 0;
/* Check if this is a simple builtin (not part of a pipe).
* Builtins within pipes have to fork anyway, and are handled in
* pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
*/
- child = &(pi->progs[0]);
- if (single_and_fg && child->group && child->subshell == 0) {
+ command = &(pi->cmds[0]);
+ if (single_and_fg && command->group && command->subshell == 0) {
debug_printf("non-subshell grouping\n");
- setup_redirects(child, squirrel);
+ setup_redirects(command, squirrel);
debug_printf_exec(": run_list\n");
- rcode = run_list(child->group) & 0xff;
+ rcode = run_list(command->group) & 0xff;
restore_redirects(squirrel);
debug_printf_exec("run_pipe return %d\n", rcode);
IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)
return rcode;
}
- argv = child->argv;
+ argv = command->argv;
if (single_and_fg && argv != NULL) {
- i = child->assignment_cnt;
+ i = command->assignment_cnt;
if (i != 0 && argv[i] == NULL) {
/* assignments, but no command: set local environment */
for (i = 0; argv[i] != NULL; i++) {
}
/* Expand assignments into one string each */
- for (i = 0; i < child->assignment_cnt; i++) {
+ for (i = 0; i < command->assignment_cnt; i++) {
p = expand_string_to_string(argv[i]);
putenv(p);
//FIXME: do we leak p?!
if (strcmp(argv_expanded[0], x->cmd) == 0) {
if (x->function == builtin_exec && argv_expanded[1] == NULL) {
debug_printf("magic exec\n");
- setup_redirects(child, NULL);
+ setup_redirects(command, NULL);
return EXIT_SUCCESS;
}
debug_printf("builtin inline %s\n", argv_expanded[0]);
* This is perfect for work that comes after exec().
* Is it really safe for inline use? Experimentally,
* things seem to work with glibc. */
- setup_redirects(child, squirrel);
+ setup_redirects(command, squirrel);
debug_printf_exec(": builtin '%s' '%s'...\n", x->cmd, argv_expanded[1]);
rcode = x->function(argv_expanded) & 0xff;
free(argv_expanded);
{
int a = find_applet_by_name(argv_expanded[0]);
if (a >= 0 && APPLET_IS_NOFORK(a)) {
- setup_redirects(child, squirrel);
+ setup_redirects(command, squirrel);
save_nofork_data(&G.nofork_save);
debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
rcode = run_nofork_applet_prime(&G.nofork_save, a, argv_expanded);
set_jobctrl_sighandler(SIG_IGN);
/* Going to fork a child per each pipe member */
- pi->alive_progs = 0;
+ pi->alive_cmds = 0;
nextin = 0;
- for (i = 0; i < pi->num_progs; i++) {
+ for (i = 0; i < pi->num_cmds; i++) {
#if !BB_MMU
char **ptrs2free = NULL;
#endif
- child = &(pi->progs[i]);
- if (child->argv) {
- debug_printf_exec(": pipe member '%s' '%s'...\n", child->argv[0], child->argv[1]);
+ command = &(pi->cmds[i]);
+ if (command->argv) {
+ debug_printf_exec(": pipe member '%s' '%s'...\n", command->argv[0], command->argv[1]);
#if !BB_MMU
- ptrs2free = alloc_ptrs(child->argv);
+ ptrs2free = alloc_ptrs(command->argv);
#endif
} else
debug_printf_exec(": pipe member with no argv\n");
/* pipes are inserted between pairs of commands */
pipefds[0] = 0;
pipefds[1] = 1;
- if ((i + 1) < pi->num_progs)
+ if ((i + 1) < pi->num_cmds)
xpipe(pipefds);
- child->pid = BB_MMU ? fork() : vfork();
- if (!child->pid) { /* child */
+ command->pid = BB_MMU ? fork() : vfork();
+ if (!command->pid) { /* child */
if (ENABLE_HUSH_JOB)
die_sleep = 0; /* let nofork's xfuncs die */
#if ENABLE_HUSH_JOB
close(pipefds[0]); /* read end */
/* Like bash, explicit redirects override pipes,
* and the pipe fd is available for dup'ing. */
- setup_redirects(child, NULL);
+ setup_redirects(command, NULL);
/* Restore default handlers just prior to exec */
set_jobctrl_sighandler(SIG_DFL);
set_misc_sighandler(SIG_DFL);
signal(SIGCHLD, SIG_DFL);
- pseudo_exec(ptrs2free, child, argv_expanded); /* does not return */
+ pseudo_exec(ptrs2free, command, argv_expanded); /* does not return */
}
free(argv_expanded);
argv_expanded = NULL;
#if !BB_MMU
free_strings(ptrs2free);
#endif
- if (child->pid < 0) { /* [v]fork failed */
+ if (command->pid < 0) { /* [v]fork failed */
/* Clearly indicate, was it fork or vfork */
bb_perror_msg(BB_MMU ? "fork" : "vfork");
} else {
- pi->alive_progs++;
+ pi->alive_cmds++;
#if ENABLE_HUSH_JOB
/* Second and next children need to know pid of first one */
if (pi->pgrp < 0)
- pi->pgrp = child->pid;
+ pi->pgrp = command->pid;
#endif
}
if (i)
close(nextin);
- if ((i + 1) < pi->num_progs)
+ if ((i + 1) < pi->num_cmds)
close(pipefds[1]); /* write end */
/* Pass read (output) pipe end to next iteration */
nextin = pipefds[0];
}
- if (!pi->alive_progs) {
+ if (!pi->alive_cmds) {
debug_printf_exec("run_pipe return 1 (all forks failed, no children)\n");
return 1;
}
- debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_progs);
+ debug_printf_exec("run_pipe return -1 (%u children started)\n", pi->alive_cmds);
return -1;
}
fprintf(stderr, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
prn = 0;
- while (prn < pi->num_progs) {
- struct child_prog *child = &pi->progs[prn];
- char **argv = child->argv;
+ while (prn < pi->num_cmds) {
+ struct command *command = &pi->cmds[prn];
+ char **argv = command->argv;
- fprintf(stderr, "%*s prog %d assignment_cnt:%d", lvl*2, "", prn, child->assignment_cnt);
- if (child->group) {
+ fprintf(stderr, "%*s prog %d assignment_cnt:%d", lvl*2, "", prn, command->assignment_cnt);
+ if (command->group) {
fprintf(stderr, " group %s: (argv=%p)\n",
- (child->subshell ? "()" : "{}"),
+ (command->subshell ? "()" : "{}"),
argv);
- debug_print_tree(child->group, lvl+1);
+ debug_print_tree(command->group, lvl+1);
prn++;
continue;
}
}
#endif
#if ENABLE_HUSH_LOOPS
- if (rword == RES_FOR) { /* && pi->num_progs - always == 1 */
+ if (rword == RES_FOR) { /* && pi->num_cmds - always == 1 */
if (!for_lcur) {
/* first loop through for */
vals = (char**)encoded_dollar_at_argv;
if (pi->next->res_word == RES_IN) {
/* if no variable values after "in" we skip "for" */
- if (!pi->next->progs[0].argv)
+ if (!pi->next->cmds[0].argv)
break;
- vals = pi->next->progs[0].argv;
+ vals = pi->next->cmds[0].argv;
} /* else: "for var; do..." -> assume "$@" list */
/* create list of variable values */
debug_print_strings("for_list made from", vals);
for_list = expand_strvec_to_strvec(vals);
for_lcur = for_list;
debug_print_strings("for_list", for_list);
- for_varname = pi->progs[0].argv[0];
- pi->progs[0].argv[0] = NULL;
+ for_varname = pi->cmds[0].argv[0];
+ pi->cmds[0].argv[0] = NULL;
}
- free(pi->progs[0].argv[0]);
+ free(pi->cmds[0].argv[0]);
if (!*for_lcur) {
/* "for" loop is over, clean up */
free(for_list);
for_list = NULL;
for_lcur = NULL;
- pi->progs[0].argv[0] = for_varname;
+ pi->cmds[0].argv[0] = for_varname;
break;
}
/* insert next value from for_lcur */
//TODO: does it need escaping?
- pi->progs[0].argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
- pi->progs[0].assignment_cnt = 1;
+ pi->cmds[0].argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
+ pi->cmds[0].assignment_cnt = 1;
}
if (rword == RES_IN) /* "for v IN list;..." - "in" has no cmds anyway */
continue;
#endif
#if ENABLE_HUSH_CASE
if (rword == RES_CASE) {
- case_word = expand_strvec_to_string(pi->progs->argv);
+ case_word = expand_strvec_to_string(pi->cmds->argv);
continue;
}
if (rword == RES_MATCH) {
if (!case_word) /* "case ... matched_word) ... WORD)": we executed selected branch, stop */
break;
/* all prev words didn't match, does this one match? */
- argv = pi->progs->argv;
+ argv = pi->cmds->argv;
while (*argv) {
char *pattern = expand_string_to_string(*argv);
/* TODO: which FNM_xxx flags to use? */
continue; /* not matched yet, skip this pipe */
}
#endif
- if (pi->num_progs == 0)
+ if (pi->num_cmds == 0)
continue;
/* After analyzing all keywords and conditions, we decided
* to execute this pipe. NB: has to do checkjobs(NULL)
* after run_pipe() to collect any background children,
* even if list execution is to be stopped. */
- debug_printf_exec(": run_pipe with %d members\n", pi->num_progs);
+ debug_printf_exec(": run_pipe with %d members\n", pi->num_cmds);
{
int r;
#if ENABLE_HUSH_LOOPS
static int free_pipe(struct pipe *pi, int indent)
{
char **p;
- struct child_prog *child;
+ struct command *command;
struct redir_struct *r, *rnext;
int a, i, ret_code = 0;
- if (pi->stopped_progs > 0)
+ if (pi->stopped_cmds > 0)
return ret_code;
debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
- for (i = 0; i < pi->num_progs; i++) {
- child = &pi->progs[i];
+ for (i = 0; i < pi->num_cmds; i++) {
+ command = &pi->cmds[i];
debug_printf_clean("%s command %d:\n", indenter(indent), i);
- if (child->argv) {
- for (a = 0, p = child->argv; *p; a++, p++) {
+ if (command->argv) {
+ for (a = 0, p = command->argv; *p; a++, p++) {
debug_printf_clean("%s argv[%d] = %s\n", indenter(indent), a, *p);
}
- free_strings(child->argv);
- child->argv = NULL;
- } else if (child->group) {
- debug_printf_clean("%s begin group (subshell:%d)\n", indenter(indent), child->subshell);
- ret_code = free_pipe_list(child->group, indent+3);
+ free_strings(command->argv);
+ command->argv = NULL;
+ } else if (command->group) {
+ debug_printf_clean("%s begin group (subshell:%d)\n", indenter(indent), command->subshell);
+ ret_code = free_pipe_list(command->group, indent+3);
debug_printf_clean("%s end group\n", indenter(indent));
} else {
debug_printf_clean("%s (nil)\n", indenter(indent));
}
- for (r = child->redirects; r; r = rnext) {
+ for (r = command->redirects; r; r = rnext) {
debug_printf_clean("%s redirect %d%s", indenter(indent), r->fd, redir_table[r->rd_type].descrip);
if (r->dup == -1) {
/* guard against the case >$FOO, where foo is unset or blank */
rnext = r->next;
free(r);
}
- child->redirects = NULL;
+ command->redirects = NULL;
}
- free(pi->progs); /* children are an array, they get freed all at once */
- pi->progs = NULL;
+ free(pi->cmds); /* children are an array, they get freed all at once */
+ pi->cmds = NULL;
#if ENABLE_HUSH_JOB
free(pi->cmdtext);
pi->cmdtext = NULL;
int rcode = 0;
debug_printf_exec("run_and_free_list entered\n");
if (!G.fake_mode) {
- debug_printf_exec(": run_list with %d members\n", pi->num_progs);
+ debug_printf_exec(": run_list with %d members\n", pi->num_cmds);
rcode = run_list(pi);
}
/* free_pipe_list has the side effect of clearing memory.
* for file descriptor duplication, e.g., "2>&1".
* Return code is 0 normally, 1 if a syntax error is detected in src.
* Resource errors (in xmalloc) cause the process to exit */
-static int setup_redirect(struct p_context *ctx, int fd, redir_type style,
+static int setup_redirect(struct parse_context *ctx, int fd, redir_type style,
struct in_str *input)
{
- struct child_prog *child = ctx->child;
- struct redir_struct *redir = child->redirects;
+ struct command *command = ctx->command;
+ struct redir_struct *redir = command->redirects;
struct redir_struct *last_redir = NULL;
/* Create a new redir_struct and drop it onto the end of the linked list */
if (last_redir) {
last_redir->next = redir;
} else {
- child->redirects = redir;
+ command->redirects = redir;
}
redir->rd_type = style;
return pi;
}
-static void initialize_context(struct p_context *ctx)
+static void initialize_context(struct parse_context *ctx)
{
memset(ctx, 0, sizeof(*ctx));
ctx->pipe = ctx->list_head = new_pipe();
- /* Create the memory for child, roughly:
- * ctx->pipe->progs = new struct child_prog;
- * ctx->child = &ctx->pipe->progs[0];
+ /* Create the memory for command, roughly:
+ * ctx->pipe->cmds = new struct command;
+ * ctx->command = &ctx->pipe->cmds[0];
*/
done_command(ctx);
}
* case, function, and select are obnoxious, save those for later.
*/
#if HAS_KEYWORDS
-static int reserved_word(o_string *word, struct p_context *ctx)
+static int reserved_word(o_string *word, struct parse_context *ctx)
{
struct reserved_combo {
char literal[6];
return 1;
}
if (r->flag & FLAG_START) {
- struct p_context *new;
+ struct parse_context *new;
debug_printf("push stack\n");
new = xmalloc(sizeof(*new));
*new = *ctx; /* physical copy */
ctx->ctx_res_w = r->res;
ctx->old_flag = r->flag;
if (ctx->old_flag & FLAG_END) {
- struct p_context *old;
+ struct parse_context *old;
debug_printf("pop stack\n");
done_pipe(ctx, PIPE_SEQ);
old = ctx->stack;
- old->child->group = ctx->list_head;
- old->child->subshell = 0;
+ old->command->group = ctx->list_head;
+ old->command->subshell = 0;
*ctx = *old; /* physical copy */
free(old);
}
/* Word is complete, look at it and update parsing context.
* Normal return is 0. Syntax errors return 1. */
-static int done_word(o_string *word, struct p_context *ctx)
+static int done_word(o_string *word, struct parse_context *ctx)
{
- struct child_prog *child = ctx->child;
+ struct command *command = ctx->command;
- debug_printf_parse("done_word entered: '%s' %p\n", word->data, child);
+ debug_printf_parse("done_word entered: '%s' %p\n", word->data, command);
if (word->length == 0 && word->nonnull == 0) {
debug_printf_parse("done_word return 0: true null, ignored\n");
return 0;
word->o_assignment = NOT_ASSIGNMENT;
} else {
if (word->o_assignment == DEFINITELY_ASSIGNMENT)
- child->assignment_cnt++;
+ command->assignment_cnt++;
word->o_assignment = MAYBE_ASSIGNMENT;
}
} else {
/* "{ echo foo; } echo bar" - bad */
/* NB: bash allows e.g. "if true; then { echo foo; } fi". TODO? */
- if (child->group) {
+ if (command->group) {
syntax(NULL);
debug_printf_parse("done_word return 1: syntax error, groups and arglists don't mix\n");
return 1;
} else
#endif
- if (!child->argv /* if it's the first word... */
+ if (!command->argv /* if it's the first word... */
#if ENABLE_HUSH_LOOPS
&& ctx->ctx_res_w != RES_FOR /* ...not after FOR or IN */
&& ctx->ctx_res_w != RES_IN
o_addchr(word, SPECIAL_VAR_SYMBOL);
}
}
- child->argv = add_malloced_string_to_strings(child->argv, xstrdup(word->data));
- debug_print_strings("word appended to argv", child->argv);
+ command->argv = add_malloced_string_to_strings(command->argv, xstrdup(word->data));
+ debug_print_strings("word appended to argv", command->argv);
}
o_reset(word);
* as it is "for v; in ...". FOR and IN become two pipe structs
* in parse tree. */
if (ctx->ctx_res_w == RES_FOR) {
-//TODO: check that child->argv[0] is a valid variable name!
+//TODO: check that command->argv[0] is a valid variable name!
done_pipe(ctx, PIPE_SEQ);
}
#endif
/* Command (member of a pipe) is complete. The only possible error here
* is out of memory, in which case xmalloc exits. */
-static int done_command(struct p_context *ctx)
+static int done_command(struct parse_context *ctx)
{
- /* The child is really already in the pipe structure, so
- * advance the pipe counter and make a new, null child. */
+ /* The command is really already in the pipe structure, so
+ * advance the pipe counter and make a new, null command. */
struct pipe *pi = ctx->pipe;
- struct child_prog *child = ctx->child;
+ struct command *command = ctx->command;
- if (child) {
- if (child->group == NULL
- && child->argv == NULL
- && child->redirects == NULL
+ if (command) {
+ if (command->group == NULL
+ && command->argv == NULL
+ && command->redirects == NULL
) {
- debug_printf_parse("done_command: skipping null cmd, num_progs=%d\n", pi->num_progs);
- return pi->num_progs;
+ debug_printf_parse("done_command: skipping null cmd, num_cmds=%d\n", pi->num_cmds);
+ return pi->num_cmds;
}
- pi->num_progs++;
- debug_printf_parse("done_command: ++num_progs=%d\n", pi->num_progs);
+ pi->num_cmds++;
+ debug_printf_parse("done_command: ++num_cmds=%d\n", pi->num_cmds);
} else {
- debug_printf_parse("done_command: initializing, num_progs=%d\n", pi->num_progs);
+ debug_printf_parse("done_command: initializing, num_cmds=%d\n", pi->num_cmds);
}
/* Only real trickiness here is that the uncommitted
- * child structure is not counted in pi->num_progs. */
- pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
- child = &pi->progs[pi->num_progs];
- memset(child, 0, sizeof(*child));
+ * command structure is not counted in pi->num_cmds. */
+ pi->cmds = xrealloc(pi->cmds, sizeof(*pi->cmds) * (pi->num_cmds+1));
+ command = &pi->cmds[pi->num_cmds];
+ memset(command, 0, sizeof(*command));
- ctx->child = child;
+ ctx->command = command;
/* but ctx->pipe and ctx->list_head remain unchanged */
- return pi->num_progs; /* used only for 0/nonzero check */
+ return pi->num_cmds; /* used only for 0/nonzero check */
}
-static void done_pipe(struct p_context *ctx, pipe_style type)
+static void done_pipe(struct parse_context *ctx, pipe_style type)
{
int not_null;
new_p = new_pipe();
ctx->pipe->next = new_p;
ctx->pipe = new_p;
- ctx->child = NULL; /* needed! */
+ ctx->command = NULL; /* needed! */
/* RES_THEN, RES_DO etc are "sticky" -
* they remain set for commands inside if/while.
* This is used to control execution.
if (ctx->ctx_res_w == RES_MATCH)
ctx->ctx_res_w = RES_CASEI;
#endif
- /* Create the memory for child, roughly:
- * ctx->pipe->progs = new struct child_prog;
- * ctx->child = &ctx->pipe->progs[0];
+ /* Create the memory for command, roughly:
+ * ctx->pipe->cmds = new struct command;
+ * ctx->command = &ctx->pipe->cmds[0];
*/
done_command(ctx);
}
{
int retcode, ch, eol_cnt;
o_string result = NULL_O_STRING;
- struct p_context inner;
+ struct parse_context inner;
FILE *p;
struct in_str pipe_str;
}
#endif
-static int parse_group(o_string *dest, struct p_context *ctx,
+static int parse_group(o_string *dest, struct parse_context *ctx,
struct in_str *input, int ch)
{
/* NB: parse_group may create and use its own o_string,
* if we (ab)use caller's one. */
int rcode;
const char *endch = NULL;
- struct p_context sub;
- struct child_prog *child = ctx->child;
+ struct parse_context sub;
+ struct command *command = ctx->command;
debug_printf_parse("parse_group entered\n");
- if (child->argv) {
+ if (command->argv /* word [word](... */
+ || dest->length /* word(... */
+ || dest->nonnull /* ""(... */
+ ) {
syntax(NULL);
debug_printf_parse("parse_group return 1: syntax error, groups and arglists don't mix\n");
return 1;
endch = "}";
if (ch == '(') {
endch = ")";
- child->subshell = 1;
+ command->subshell = 1;
}
rcode = parse_stream(dest, &sub, input, endch);
if (rcode == 0) {
done_word(dest, &sub); /* finish off the final word in the subcontext */
done_pipe(&sub, PIPE_SEQ); /* and the final command there, too */
- child->group = sub.list_head;
+ command->group = sub.list_head;
}
debug_printf_parse("parse_group return %d\n", rcode);
return rcode;
- /* child remains "open", available for possible redirects */
+ /* command remains "open", available for possible redirects */
}
/* Basically useful version until someone wants to get fancier,
* Return code is 0 if end_trigger char is met,
* -1 on EOF (but if end_trigger == NULL then return 0),
* 1 for syntax error */
-static int parse_stream(o_string *dest, struct p_context *ctx,
+static int parse_stream(o_string *dest, struct parse_context *ctx,
struct in_str *input, const char *end_trigger)
{
int ch, m;
case '(':
#if ENABLE_HUSH_CASE
/* "case... in [(]word)..." - skip '(' */
- if (dest->length == 0 // && argv[0] == NULL
+ if (dest->length == 0 /* not word(... */
+ && dest->nonnull == 0 /* not ""(... */
&& ctx->ctx_res_w == RES_MATCH
+ && ctx->command->argv == NULL /* not (word|(... */
) {
continue;
}
* from builtin_source() and builtin_eval() */
static int parse_and_run_stream(struct in_str *inp, int parse_flag)
{
- struct p_context ctx;
+ struct parse_context ctx;
o_string temp = NULL_O_STRING;
int rcode;
}
/* Restart the processes in the job */
- debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_progs, pi->pgrp);
- for (i = 0; i < pi->num_progs; i++) {
- debug_printf_jobs("reviving pid %d\n", pi->progs[i].pid);
- pi->progs[i].is_stopped = 0;
+ debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_cmds, pi->pgrp);
+ for (i = 0; i < pi->num_cmds; i++) {
+ debug_printf_jobs("reviving pid %d\n", pi->cmds[i].pid);
+ pi->cmds[i].is_stopped = 0;
}
- pi->stopped_progs = 0;
+ pi->stopped_cmds = 0;
i = kill(- pi->pgrp, SIGCONT);
if (i < 0) {
const char *status_string;
for (job = G.job_list; job; job = job->next) {
- if (job->alive_progs == job->stopped_progs)
+ if (job->alive_cmds == job->stopped_cmds)
status_string = "Stopped";
else
status_string = "Running";
projects / oweals / busybox.git / commitdiff