*
* Credits:
* The parser routines proper are all original material, first
- * written Dec 2000 and Jan 2001 by Larry Doolittle.
- * The execution engine, the builtins, and much of the underlying
- * support has been adapted from busybox-0.49pre's lash,
- * which is Copyright (C) 2000 by Lineo, Inc., and
- * written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>.
- * That, in turn, is based in part on ladsh.c, by Michael K. Johnson and
- * Erik W. Troan, which they placed in the public domain. I don't know
- * how much of the Johnson/Troan code has survived the repeated rewrites.
+ * written Dec 2000 and Jan 2001 by Larry Doolittle. The
+ * execution engine, the builtins, and much of the underlying
+ * support has been adapted from busybox-0.49pre's lash, which is
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ * written by Erik Andersen <andersen@codepoet.org>. That, in turn,
+ * is based in part on ladsh.c, by Michael K. Johnson and Erik W.
+ * Troan, which they placed in the public domain. I don't know
+ * how much of the Johnson/Troan code has survived the repeated
+ * rewrites.
+ *
* Other credits:
* simple_itoa() was lifted from boa-0.93.15
* b_addchr() derived from similar w_addchar function in glibc-2.2
/* #include <dmalloc.h> */
/* #define DEBUG_SHELL */
-#ifdef BB_VER
+#if 1
#include "busybox.h"
#include "cmdedit.h"
#else
-#define applet_name "hush"
+#define bb_applet_name "hush"
#include "standalone.h"
#define hush_main main
#undef CONFIG_FEATURE_SH_FANCY_PROMPT
#define BB_BANNER
#endif
+#define SPECIAL_VAR_SYMBOL 03
+#define FLAG_EXIT_FROM_LOOP 1
+#define FLAG_PARSE_SEMICOLON (1 << 1) /* symbol ';' is special for parser */
+#define FLAG_REPARSING (1 << 2) /* >=2nd pass */
typedef enum {
REDIRECT_INPUT = 1,
RES_DO = 9,
RES_DONE = 10,
RES_XXXX = 11,
- RES_SNTX = 12
+ RES_IN = 12,
+ RES_SNTX = 13
} reserved_style;
#define FLAG_END (1<<RES_NONE)
#define FLAG_IF (1<<RES_IF)
#define FLAG_UNTIL (1<<RES_UNTIL)
#define FLAG_DO (1<<RES_DO)
#define FLAG_DONE (1<<RES_DONE)
+#define FLAG_IN (1<<RES_IN)
#define FLAG_START (1<<RES_XXXX)
/* This holds pointers to the various results of parsing */
reserved_style w;
int old_flag; /* for figuring out valid reserved words */
struct p_context *stack;
+ int type; /* define type of parser : ";$" common or special symbol */
/* How about quoting status? */
};
glob_t glob_result; /* result of parameter globbing */
int is_stopped; /* is the program currently running? */
struct pipe *family; /* pointer back to the child's parent pipe */
+ int sp; /* number of SPECIAL_VAR_SYMBOL */
+ int type;
};
struct pipe {
#define final_printf debug_printf
static void __syntax(char *file, int line) {
- error_msg("syntax error %s:%d", file, line);
+ bb_error_msg("syntax error %s:%d", file, line);
}
#define syntax() __syntax(__FILE__, __LINE__)
/* function prototypes for builtins */
static int builtin_cd(struct child_prog *child);
static int builtin_env(struct child_prog *child);
+static int builtin_eval(struct child_prog *child);
static int builtin_exec(struct child_prog *child);
static int builtin_exit(struct child_prog *child);
static int builtin_export(struct child_prog *child);
static int redirect_opt_num(o_string *o);
static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end);
static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
-static void lookup_param(o_string *dest, struct p_context *ctx, o_string *src);
+static char *lookup_param(char *src);
+static char *make_string(char **inp);
static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input);
static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger);
/* setup: */
-static int parse_stream_outer(struct in_str *inp);
-static int parse_string_outer(const char *s);
+static int parse_stream_outer(struct in_str *inp, int flag);
+static int parse_string_outer(const char *s, int flag);
static int parse_file_outer(FILE *f);
/* job management: */
static int checkjobs(struct pipe* fg_pipe);
static void insert_bg_job(struct pipe *pi);
static void remove_bg_job(struct pipe *pi);
/* local variable support */
+static char **make_list_in(char **inp, char *name);
+static char *insert_var_value(char *inp);
static char *get_local_var(const char *var);
static void unset_local_var(const char *name);
static int set_local_var(const char *s, int flg_export);
{"cd", "Change working directory", builtin_cd},
{"continue", "Continue for, while or until loop", builtin_not_written},
{"env", "Print all environment variables", builtin_env},
- {"eval", "Construct and run shell command", builtin_not_written},
+ {"eval", "Construct and run shell command", builtin_eval},
{"exec", "Exec command, replacing this shell with the exec'd process",
builtin_exec},
{"exit", "Exit from shell()", builtin_exit},
static const char *set_cwd(void)
{
- if(cwd==unknown)
+ if(cwd==bb_msg_unknown)
cwd = NULL; /* xgetcwd(arg) called free(arg) */
cwd = xgetcwd((char *)cwd);
if (!cwd)
- cwd = unknown;
+ cwd = bb_msg_unknown;
return cwd;
}
+/* built-in 'eval' handler */
+static int builtin_eval(struct child_prog *child)
+{
+ char *str = NULL;
+ int rcode = EXIT_SUCCESS;
+
+ if (child->argv[1]) {
+ str = make_string(child->argv + 1);
+ parse_string_outer(str, FLAG_EXIT_FROM_LOOP |
+ FLAG_PARSE_SEMICOLON);
+ free(str);
+ rcode = last_return_code;
+ }
+ return rcode;
+}
/* built-in 'cd <path>' handler */
static int builtin_cd(struct child_prog *child)
}
}
if (res<0)
- perror_msg("export");
+ bb_perror_msg("export");
else if(res==0)
res = set_local_var(name, 1);
else
}
}
if (!pi) {
- error_msg("%s: no current job", child->argv[0]);
+ bb_error_msg("%s: no current job", child->argv[0]);
return EXIT_FAILURE;
}
} else {
if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
- error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
+ bb_error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
return EXIT_FAILURE;
}
for (pi = job_list; pi; pi = pi->next) {
}
}
if (!pi) {
- error_msg("%s: %d: no such job", child->argv[0], jobnum);
+ bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
return EXIT_FAILURE;
}
}
if (i == ESRCH) {
remove_bg_job(pi);
} else {
- perror_msg("kill (SIGCONT)");
+ bb_perror_msg("kill (SIGCONT)");
}
}
/* XXX search through $PATH is missing */
input = fopen(child->argv[1], "r");
if (!input) {
- error_msg("Couldn't open file '%s'", child->argv[1]);
+ bb_error_msg("Couldn't open file '%s'", child->argv[1]);
return EXIT_FAILURE;
}
static void b_free(o_string *o)
{
b_reset(o);
- if (o->data != NULL) free(o->data);
+ free(o->data);
o->data = NULL;
o->maxlen = 0;
}
#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
/* Set up the prompt */
if (promptmode == 1) {
- if (PS1)
- free(PS1);
+ free(PS1);
PS1=xmalloc(strlen(cwd)+4);
sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
*prompt_str = PS1;
{
struct close_me *tmp;
if (close_me_head == NULL || close_me_head->fd != fd)
- error_msg_and_die("corrupt close_me");
+ bb_error_msg_and_die("corrupt close_me");
tmp = close_me_head;
close_me_head = close_me_head->next;
free(tmp);
if (openfd < 0) {
/* this could get lost if stderr has been redirected, but
bash and ash both lose it as well (though zsh doesn't!) */
- perror_msg("error opening %s", redir->word.gl_pathv[0]);
+ bb_perror_msg("error opening %s", redir->word.gl_pathv[0]);
return 1;
}
} else {
static void pseudo_exec(struct child_prog *child)
{
int i, rcode;
+ char *p;
struct built_in_command *x;
if (child->argv) {
for (i=0; is_assignment(child->argv[i]); i++) {
debug_printf("pid %d environment modification: %s\n",getpid(),child->argv[i]);
- putenv(strdup(child->argv[i]));
+ p = insert_var_value(child->argv[i]);
+ putenv(strdup(p));
+ if (p != child->argv[i]) free(p);
}
child->argv+=i; /* XXX this hack isn't so horrible, since we are about
to exit, and therefore don't need to keep data
#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
/* Following discussions from November 2000 on the busybox mailing
* list, the default configuration, (without
- * get_last_path_component()) lets the user force use of an
+ * bb_get_last_path_component()) lets the user force use of an
* external command by specifying the full (with slashes) filename.
* If you enable CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN, then applets
* _aways_ override external commands, so if you want to run
* /bin/cat, it will use BusyBox cat even if /bin/cat exists on the
* filesystem and is _not_ busybox. Some systems may want this,
* most do not. */
- name = get_last_path_component(name);
+ name = bb_get_last_path_component(name);
#endif
/* Count argc for use in a second... */
for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
#endif
debug_printf("exec of %s\n",child->argv[0]);
execvp(child->argv[0],child->argv);
- perror_msg("couldn't exec: %s",child->argv[0]);
+ bb_perror_msg("couldn't exec: %s",child->argv[0]);
_exit(1);
} else if (child->group) {
debug_printf("runtime nesting to group\n");
}
if (childpid == -1 && errno != ECHILD)
- perror_msg("waitpid");
+ bb_perror_msg("waitpid");
/* move the shell to the foreground */
//if (interactive && tcsetpgrp(shell_terminal, getpgid(0)))
- // perror_msg("tcsetpgrp-2");
+ // bb_perror_msg("tcsetpgrp-2");
return -1;
}
int pipefds[2]; /* pipefds[0] is for reading */
struct child_prog *child;
struct built_in_command *x;
+ char *p;
nextin = 0;
pi->pgrp = -1;
* variable. */
int export_me=0;
char *name, *value;
- name = xstrdup(child->argv[i]);
+ name = bb_xstrdup(child->argv[i]);
debug_printf("Local environment set: %s\n", name);
value = strchr(name, '=');
if (value)
export_me=1;
}
free(name);
- set_local_var(child->argv[i], export_me);
+ p = insert_var_value(child->argv[i]);
+ set_local_var(p, export_me);
+ if (p != child->argv[i]) free(p);
}
return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
}
+ for (i = 0; is_assignment(child->argv[i]); i++) {
+ p = insert_var_value(child->argv[i]);
+ putenv(strdup(p));
+ if (p != child->argv[i]) {
+ child->sp--;
+ free(p);
+ }
+ }
+ if (child->sp) {
+ char * str = NULL;
+
+ str = make_string((child->argv + i));
+ parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
+ free(str);
+ return last_return_code;
+ }
for (x = bltins; x->cmd; x++) {
if (strcmp(child->argv[i], x->cmd) == 0 ) {
int squirrel[] = {-1, -1, -1};
* Is it really safe for inline use? Experimentally,
* things seem to work with glibc. */
setup_redirects(child, squirrel);
- for (i=0; is_assignment(child->argv[i]); i++) {
- putenv(strdup(child->argv[i]));
- }
child->argv+=i; /* XXX horrible hack */
rcode = x->function(child);
child->argv-=i; /* XXX restore hack so free() can work right */
/* pipes are inserted between pairs of commands */
if ((i + 1) < pi->num_progs) {
- if (pipe(pipefds)<0) perror_msg_and_die("pipe");
+ if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
nextout = pipefds[1];
} else {
nextout=1;
static int run_list_real(struct pipe *pi)
{
- int rcode=0;
+ char *save_name = NULL;
+ char **list = NULL;
+ char **save_list = NULL;
+ struct pipe *rpipe;
+ int flag_rep = 0;
+ int save_num_progs;
+ int rcode=0, flag_skip=1;
+ int flag_restore = 0;
int if_code=0, next_if_code=0; /* need double-buffer to handle elif */
reserved_style rmode, skip_more_in_this_rmode=RES_XXXX;
- for (;pi;pi=pi->next) {
+ /* check syntax for "for" */
+ for (rpipe = pi; rpipe; rpipe = rpipe->next) {
+ if ((rpipe->r_mode == RES_IN ||
+ rpipe->r_mode == RES_FOR) &&
+ (rpipe->next == NULL)) {
+ syntax();
+ return 1;
+ }
+ if ((rpipe->r_mode == RES_IN &&
+ (rpipe->next->r_mode == RES_IN &&
+ rpipe->next->progs->argv != NULL))||
+ (rpipe->r_mode == RES_FOR &&
+ rpipe->next->r_mode != RES_IN)) {
+ syntax();
+ return 1;
+ }
+ }
+ for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) {
+ if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL ||
+ pi->r_mode == RES_FOR) {
+ flag_restore = 0;
+ if (!rpipe) {
+ flag_rep = 0;
+ rpipe = pi;
+ }
+ }
rmode = pi->r_mode;
debug_printf("rmode=%d if_code=%d next_if_code=%d skip_more=%d\n", rmode, if_code, next_if_code, skip_more_in_this_rmode);
- if (rmode == skip_more_in_this_rmode) continue;
+ if (rmode == skip_more_in_this_rmode && flag_skip) {
+ if (pi->followup == PIPE_SEQ) flag_skip=0;
+ continue;
+ }
+ flag_skip = 1;
skip_more_in_this_rmode = RES_XXXX;
if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code;
if (rmode == RES_THEN && if_code) continue;
if (rmode == RES_ELSE && !if_code) continue;
if (rmode == RES_ELIF && !if_code) continue;
+ if (rmode == RES_FOR && pi->num_progs) {
+ if (!list) {
+ /* if no variable values after "in" we skip "for" */
+ if (!pi->next->progs->argv) continue;
+ /* create list of variable values */
+ list = make_list_in(pi->next->progs->argv,
+ pi->progs->argv[0]);
+ save_list = list;
+ save_name = pi->progs->argv[0];
+ pi->progs->argv[0] = NULL;
+ flag_rep = 1;
+ }
+ if (!(*list)) {
+ free(pi->progs->argv[0]);
+ free(save_list);
+ list = NULL;
+ flag_rep = 0;
+ pi->progs->argv[0] = save_name;
+ pi->progs->glob_result.gl_pathv[0] =
+ pi->progs->argv[0];
+ continue;
+ } else {
+ /* insert new value from list for variable */
+ if (pi->progs->argv[0])
+ free(pi->progs->argv[0]);
+ pi->progs->argv[0] = *list++;
+ pi->progs->glob_result.gl_pathv[0] =
+ pi->progs->argv[0];
+ }
+ }
+ if (rmode == RES_IN) continue;
+ if (rmode == RES_DO) {
+ if (!flag_rep) continue;
+ }
+ if ((rmode == RES_DONE)) {
+ if (flag_rep) {
+ flag_restore = 1;
+ } else {
+ rpipe = NULL;
+ }
+ }
if (pi->num_progs == 0) continue;
+ save_num_progs = pi->num_progs; /* save number of programs */
rcode = run_pipe_real(pi);
debug_printf("run_pipe_real returned %d\n",rcode);
if (rcode!=-1) {
if (interactive) {
/* move the new process group into the foreground */
if (tcsetpgrp(shell_terminal, pi->pgrp) && errno != ENOTTY)
- perror_msg("tcsetpgrp-3");
+ bb_perror_msg("tcsetpgrp-3");
rcode = checkjobs(pi);
/* move the shell to the foreground */
if (tcsetpgrp(shell_terminal, getpgid(0)) && errno != ENOTTY)
- perror_msg("tcsetpgrp-4");
+ bb_perror_msg("tcsetpgrp-4");
} else {
rcode = checkjobs(pi);
}
debug_printf("checkjobs returned %d\n",rcode);
}
last_return_code=rcode;
+ pi->num_progs = save_num_progs; /* restore number of programs */
if ( rmode == RES_IF || rmode == RES_ELIF )
next_if_code=rcode; /* can be overwritten a number of times */
+ if (rmode == RES_WHILE)
+ flag_rep = !last_return_code;
+ if (rmode == RES_UNTIL)
+ flag_rep = last_return_code;
if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
(rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
skip_more_in_this_rmode=rmode;
debug_printf("globhack returned %d\n",gr);
}
if (gr == GLOB_NOSPACE)
- error_msg_and_die("out of memory during glob");
+ bb_error_msg_and_die("out of memory during glob");
if (gr != 0) { /* GLOB_ABORTED ? */
- error_msg("glob(3) error %d",gr);
+ bb_error_msg("glob(3) error %d",gr);
}
/* globprint(glob_target); */
return gr;
result++;
} else {
if(cur->flg_read_only) {
- error_msg("%s: readonly variable", name);
+ bb_error_msg("%s: readonly variable", name);
result = -1;
} else {
if(flg_export>0 || cur->flg_export>1)
if(cur!=0) {
struct variables *next = top_vars;
if(cur->flg_read_only) {
- error_msg("%s: readonly variable", name);
+ bb_error_msg("%s: readonly variable", name);
return;
} else {
if(cur->flg_export)
ctx->pipe=ctx->list_head;
ctx->w=RES_NONE;
ctx->stack=NULL;
+ ctx->old_flag=0;
done_command(ctx); /* creates the memory for working child */
}
{ "elif", RES_ELIF, FLAG_THEN },
{ "else", RES_ELSE, FLAG_FI },
{ "fi", RES_FI, FLAG_END },
- { "for", RES_FOR, FLAG_DO | FLAG_START },
+ { "for", RES_FOR, FLAG_IN | FLAG_START },
{ "while", RES_WHILE, FLAG_DO | FLAG_START },
{ "until", RES_UNTIL, FLAG_DO | FLAG_START },
+ { "in", RES_IN, FLAG_DO },
{ "do", RES_DO, FLAG_DONE },
{ "done", RES_DONE, FLAG_END }
};
if (r->flag & FLAG_START) {
struct p_context *new = xmalloc(sizeof(struct p_context));
debug_printf("push stack\n");
+ if (ctx->w == RES_IN || ctx->w == RES_FOR) {
+ syntax();
+ free(new);
+ ctx->w = RES_SNTX;
+ b_reset(dest);
+ return 1;
+ }
*new = *ctx; /* physical copy */
initialize_context(ctx);
ctx->stack=new;
} else if ( ctx->w == RES_NONE || ! (ctx->old_flag & (1<<r->code))) {
syntax();
ctx->w = RES_SNTX;
- b_reset (dest);
+ b_reset(dest);
return 1;
}
ctx->w=r->code;
if (ctx->old_flag & FLAG_END) {
struct p_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;
syntax();
return 1; /* syntax error, groups and arglists don't mix */
}
- if (!child->argv) {
+ if (!child->argv && (ctx->type & FLAG_PARSE_SEMICOLON)) {
debug_printf("checking %s for reserved-ness\n",dest->data);
if (reserved_word(dest,ctx)) return ctx->w==RES_SNTX;
}
if (ctx->pending_redirect) {
ctx->pending_redirect=NULL;
if (glob_target->gl_pathc != 1) {
- error_msg("ambiguous redirect");
+ bb_error_msg("ambiguous redirect");
return 1;
}
} else {
child->argv = glob_target->gl_pathv;
}
+ if (ctx->w == RES_FOR) {
+ done_word(dest,ctx);
+ done_pipe(ctx,PIPE_SEQ);
+ }
return 0;
}
prog->group = NULL;
prog->glob_result.gl_pathv = NULL;
prog->family = pi;
+ prog->sp = 0;
+ ctx->child = prog;
+ prog->type = ctx->type;
- ctx->child=prog;
/* but ctx->pipe and ctx->list_head remain unchanged */
return 0;
}
}
if (ok) return d;
- error_msg("ambiguous redirect");
+ bb_error_msg("ambiguous redirect");
return -2;
}
FILE *pf;
#if 1
int pid, channel[2];
- if (pipe(channel)<0) perror_msg_and_die("pipe");
+ if (pipe(channel)<0) bb_perror_msg_and_die("pipe");
#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
pid=fork();
#else
pid=vfork();
#endif
if (pid<0) {
- perror_msg_and_die("fork");
+ bb_perror_msg_and_die("fork");
} else if (pid==0) {
close(channel[0]);
if (channel[1] != 1) {
/* basically useful version until someone wants to get fancier,
* see the bash man page under "Parameter Expansion" */
-static void lookup_param(o_string *dest, struct p_context *ctx, o_string *src)
+static char *lookup_param(char *src)
{
- const char *p=NULL;
- if (src->data) {
- p = getenv(src->data);
+ char *p=NULL;
+ if (src) {
+ p = getenv(src);
if (!p)
- p = get_local_var(src->data);
+ p = get_local_var(src);
}
- if (p) parse_string(dest, ctx, p); /* recursion */
- b_free(src);
+ return p;
}
/* return code: 0 for OK, 1 for syntax error */
static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input)
{
int i, advance=0;
- o_string alt=NULL_O_STRING;
char sep[]=" ";
int ch = input->peek(input); /* first character after the $ */
debug_printf("handle_dollar: ch=%c\n",ch);
if (isalpha(ch)) {
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ ctx->child->sp++;
while(ch=b_peek(input),isalnum(ch) || ch=='_') {
b_getch(input);
- b_addchr(&alt,ch);
+ b_addchr(dest,ch);
}
- lookup_param(dest, ctx, &alt);
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
} else if (isdigit(ch)) {
i = ch-'0'; /* XXX is $0 special? */
if (i<global_argc) {
advance = 1;
break;
case '{':
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ ctx->child->sp++;
b_getch(input);
/* XXX maybe someone will try to escape the '}' */
while(ch=b_getch(input),ch!=EOF && ch!='}') {
- b_addchr(&alt,ch);
+ b_addchr(dest,ch);
}
if (ch != '}') {
syntax();
return 1;
}
- lookup_param(dest, ctx, &alt);
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
break;
case '(':
b_getch(input);
case '-':
case '_':
/* still unhandled, but should be eventually */
- error_msg("unhandled syntax: $%c",ch);
+ bb_error_msg("unhandled syntax: $%c",ch);
return 1;
break;
default:
b_addqchr(dest, ch, dest->quote);
} else {
if (m==2) { /* unquoted IFS */
- done_word(dest, ctx);
+ if (done_word(dest, ctx)) {
+ return 1;
+ }
/* If we aren't performing a substitution, treat a newline as a
* command separator. */
if (end_trigger != '\0' && ch=='\n')
/* most recursion does not come through here, the exeception is
* from builtin_source() */
-int parse_stream_outer(struct in_str *inp)
+int parse_stream_outer(struct in_str *inp, int flag)
{
struct p_context ctx;
o_string temp=NULL_O_STRING;
int rcode;
do {
+ ctx.type = flag;
initialize_context(&ctx);
update_ifs_map();
+ if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING)) mapset(";$&|", 0);
inp->promptmode=1;
rcode = parse_stream(&temp, &ctx, inp, '\n');
- done_word(&temp, &ctx);
- done_pipe(&ctx,PIPE_SEQ);
- run_list(ctx.list_head);
+ if (rcode != 1 && ctx.old_flag != 0) {
+ syntax();
+ }
+ if (rcode != 1 && ctx.old_flag == 0) {
+ done_word(&temp, &ctx);
+ done_pipe(&ctx,PIPE_SEQ);
+ run_list(ctx.list_head);
+ } else {
+ if (ctx.old_flag != 0) {
+ free(ctx.stack);
+ b_reset(&temp);
+ }
+ temp.nonnull = 0;
+ temp.quote = 0;
+ inp->p = NULL;
+ free_pipe_list(ctx.list_head,0);
+ }
b_free(&temp);
- } while (rcode != -1); /* loop on syntax errors, return on EOF */
+ } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP)); /* loop on syntax errors, return on EOF */
return 0;
}
-static int parse_string_outer(const char *s)
+static int parse_string_outer(const char *s, int flag)
{
struct in_str input;
setup_string_in_str(&input, s);
- return parse_stream_outer(&input);
+ return parse_stream_outer(&input, flag);
}
static int parse_file_outer(FILE *f)
int rcode;
struct in_str input;
setup_file_in_str(&input, f);
- rcode = parse_stream_outer(&input);
+ rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON);
return rcode;
}
{
global_argv = argv+optind;
global_argc = argc-optind;
- opt = parse_string_outer(optarg);
+ opt = parse_string_outer(optarg, FLAG_PARSE_SEMICOLON);
goto final_return;
}
break;
" or: sh -c command [args]...\n\n");
exit(EXIT_FAILURE);
#else
- show_usage();
+ bb_show_usage();
#endif
}
}
debug_printf("\nrunning script '%s'\n", argv[optind]);
global_argv = argv+optind;
global_argc = argc-optind;
- input = xfopen(argv[optind], "r");
+ input = bb_xfopen(argv[optind], "r");
opt = parse_file_outer(input);
#ifdef CONFIG_FEATURE_CLEAN_UP
fclose(input);
- if (cwd && cwd != unknown)
+ if (cwd && cwd != bb_msg_unknown)
free((char*)cwd);
{
struct variables *cur, *tmp;
final_return:
return(opt?opt:last_return_code);
}
+
+static char *insert_var_value(char *inp)
+{
+ int res_str_len = 0;
+ int len;
+ int done = 0;
+ char *p, *p1, *res_str = NULL;
+
+ while ((p = strchr(inp, SPECIAL_VAR_SYMBOL))) {
+ if (p != inp) {
+ len = p - inp;
+ res_str = xrealloc(res_str, (res_str_len + len));
+ strncpy((res_str + res_str_len), inp, len);
+ res_str_len += len;
+ }
+ inp = ++p;
+ p = strchr(inp, SPECIAL_VAR_SYMBOL);
+ *p = '\0';
+ if ((p1 = lookup_param(inp))) {
+ len = res_str_len + strlen(p1);
+ res_str = xrealloc(res_str, (1 + len));
+ strcpy((res_str + res_str_len), p1);
+ res_str_len = len;
+ }
+ *p = SPECIAL_VAR_SYMBOL;
+ inp = ++p;
+ done = 1;
+ }
+ if (done) {
+ res_str = xrealloc(res_str, (1 + res_str_len + strlen(inp)));
+ strcpy((res_str + res_str_len), inp);
+ while ((p = strchr(res_str, '\n'))) {
+ *p = ' ';
+ }
+ }
+ return (res_str == NULL) ? inp : res_str;
+}
+
+static char **make_list_in(char **inp, char *name)
+{
+ int len, i;
+ int name_len = strlen(name);
+ int n = 0;
+ char **list;
+ char *p1, *p2, *p3;
+
+ /* create list of variable values */
+ list = xmalloc(sizeof(*list));
+ for (i = 0; inp[i]; i++) {
+ p3 = insert_var_value(inp[i]);
+ p1 = p3;
+ while (*p1) {
+ if ((*p1 == ' ')) {
+ p1++;
+ continue;
+ }
+ if ((p2 = strchr(p1, ' '))) {
+ len = p2 - p1;
+ } else {
+ len = strlen(p1);
+ p2 = p1 + len;
+ }
+ /* we use n + 2 in realloc for list,because we add
+ * new element and then we will add NULL element */
+ list = xrealloc(list, sizeof(*list) * (n + 2));
+ list[n] = xmalloc(2 + name_len + len);
+ strcpy(list[n], name);
+ strcat(list[n], "=");
+ strncat(list[n], p1, len);
+ list[n++][name_len + len + 1] = '\0';
+ p1 = p2;
+ }
+ if (p3 != inp[i]) free(p3);
+ }
+ list[n] = NULL;
+ return list;
+}
+
+/* Make new string for parser */
+static char * make_string(char ** inp)
+{
+ char *p;
+ char *str = NULL;
+ int n;
+ int len = 2;
+
+ for (n = 0; inp[n]; n++) {
+ p = insert_var_value(inp[n]);
+ str = xrealloc(str, (len + strlen(p)));
+ if (n) {
+ strcat(str, " ");
+ } else {
+ *str = '\0';
+ }
+ strcat(str, p);
+ len = strlen(str) + 3;
+ if (p != inp[n]) free(p);
+ }
+ len = strlen(str);
+ *(str + len) = '\n';
+ *(str + len + 1) = '\0';
+ return str;
+}
projects / oweals / busybox.git / blobdiff