emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d818dcc72a
busybox/shell/msh.c

5339 lines
97 KiB
C
Raw Normal View History

This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* vi: set sw=4 ts=4: */
/*
* Minix shell port for busybox
*
* This version of the Minix shell was adapted for use in busybox
Update a bunch of docs. Run a script to update my email addr.
2003-07-15 02:51:08 +05:30
* by Erik Andersen <andersen@codepoet.org>
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
* - backtick expansion did not work properly
* Jonas Holmberg <jonas.holmberg@axis.com>
* Robert Schwebel <r.schwebel@pengutronix.de>
Update a bunch of docs. Run a script to update my email addr.
2003-07-15 02:51:08 +05:30
* Erik Andersen <andersen@codepoet.org>
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
*
A couple things that got tangled up in my tree, easier to check in both than untangle them: Rewrite u_signal_names() into get_signum() and get_signame(), plus trim the signal list to that required by posix (they can specify the numbers for the rest if they really need them). (This is preparatory cleanup for adding a timeout applet like Roberto Foglietta wants.) Export the itoa (added due to Denis Vlasenko, although it's not quite his preferred implementation) from xfuncs.c so it's actually used, and remove several other redundant implementations of itoa and utoa() in the tree.
2006-07-13 00:47:55 +05:30
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*/
#include <setjmp.h>
#include <sys/times.h>
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
#include "busybox.h"
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
extern char **environ;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
didnt mean to commit debug enable
2006-05-06 02:03:07 +05:30
/*#define MSHDEBUG 1*/
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#ifdef MSHDEBUG
assign default debug level to the MSHDEBUG define
2006-06-21 02:07:01 +05:30
int mshdbg = MSHDEBUG;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define DBGPRINTF(x) if(mshdbg>0)printf x
#define DBGPRINTF0(x) if(mshdbg>0)printf x
#define DBGPRINTF1(x) if(mshdbg>1)printf x
#define DBGPRINTF2(x) if(mshdbg>2)printf x
#define DBGPRINTF3(x) if(mshdbg>3)printf x
#define DBGPRINTF4(x) if(mshdbg>4)printf x
#define DBGPRINTF5(x) if(mshdbg>5)printf x
#define DBGPRINTF6(x) if(mshdbg>6)printf x
#define DBGPRINTF7(x) if(mshdbg>7)printf x
#define DBGPRINTF8(x) if(mshdbg>8)printf x
#define DBGPRINTF9(x) if(mshdbg>9)printf x
int mshdbg_rc = 0;
#define RCPRINTF(x) if(mshdbg_rc)printf x
#else
#define DBGPRINTF(x)
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
#define DBGPRINTF0(x) ((void)0)
#define DBGPRINTF1(x) ((void)0)
#define DBGPRINTF2(x) ((void)0)
#define DBGPRINTF3(x) ((void)0)
#define DBGPRINTF4(x) ((void)0)
#define DBGPRINTF5(x) ((void)0)
#define DBGPRINTF6(x) ((void)0)
#define DBGPRINTF7(x) ((void)0)
#define DBGPRINTF8(x) ((void)0)
#define DBGPRINTF9(x) ((void)0)
#define RCPRINTF(x) ((void)0)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#endif /* MSHDEBUG */
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
make the default prompt suck less when using fancy prompts
2006-06-06 11:56:12 +05:30
# define DEFAULT_ROOT_PROMPT "\\u:\\w> "
# define DEFAULT_USER_PROMPT "\\u:\\w$ "
#else
# define DEFAULT_ROOT_PROMPT "# "
# define DEFAULT_USER_PROMPT "$ "
#endif
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- sh.h -------- */
/*
* shell
*/
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define LINELIM 2100
#define NPUSH 8 /* limit to input nesting */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Fixup all the horrible broken function prototypes -Erik
2002-12-11 13:12:46 +05:30
#undef NOFILE
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define NOFILE 20 /* Number of open files */
#define NUFILE 10 /* Number of user-accessible files */
#define FDBASE 10 /* First file usable by Shell */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* values returned by wait
*/
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define WAITSIG(s) ((s)&0177)
#define WAITVAL(s) (((s)>>8)&0377)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define WAITCORE(s) (((s)&0200)!=0)
/*
Larry Doolittle writes: This is a bulk spelling fix patch against busybox-1.00-pre10. If anyone gets a corrupted copy (and cares), let me know and I will make alternate arrangements. Erik - please apply. Authors - please check that I didn't corrupt any meaning. Package importers - see if any of these changes should be passed to the upstream authors. I glossed over lots of sloppy capitalizations, missing apostrophes, mixed American/British spellings, and German-style compound words. What is "pretect redefined for test" in cmdedit.c? Good luck on the 1.00 release! - Larry
2004-04-14 23:21:38 +05:30
* library and system definitions
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
typedef void xint; /* base type of jmp_buf, for not broken compilers */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* shell components
*/
#define QUOTE 0200
#define NOBLOCK ((struct op *)NULL)
#define NOWORD ((char *)NULL)
#define NOWORDS ((char **)NULL)
#define NOPIPE ((int *)NULL)
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
/*
* redirection
*/
struct ioword {
short io_unit; /* unit affected */
short io_flag; /* action (below) */
char *io_name; /* file name */
};
#define IOREAD 1 /* < */
#define IOHERE 2 /* << (here file) */
#define IOWRITE 4 /* > */
#define IOCAT 8 /* >> */
#define IOXHERE 16 /* ${}, ` in << */
#define IODUP 32 /* >&digit */
#define IOCLOSE 64 /* >&- */
#define IODEFAULT (-1) /* token for default IO unit */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* Description of a command or an operation on commands.
* Might eventually use a union.
*/
struct op {
Run msh through indent
2004-08-05 00:46:54 +05:30
int type; /* operation type, see below */
char **words; /* arguments to a command */
struct ioword **ioact; /* IO actions (eg, < > >>) */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct op *left;
struct op *right;
Run msh through indent
2004-08-05 00:46:54 +05:30
char *str; /* identifier for case and for */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
#define TCOM 1 /* command */
#define TPAREN 2 /* (c-list) */
#define TPIPE 3 /* a | b */
#define TLIST 4 /* a [&;] b */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define TOR 5 /* || */
Run msh through indent
2004-08-05 00:46:54 +05:30
#define TAND 6 /* && */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define TFOR 7
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define TDO 8
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define TCASE 9
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define TIF 10
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define TWHILE 11
#define TUNTIL 12
#define TELIF 13
Run msh through indent
2004-08-05 00:46:54 +05:30
#define TPAT 14 /* pattern in case */
#define TBRACE 15 /* {c-list} */
#define TASYNC 16 /* c & */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* Added to support "." file expansion */
#define TDOT 17
/* Strings for names to make debug easier */
Reduce exported from msh applet
2005-09-22 20:08:17 +05:30
#ifdef MSHDEBUG
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
static const char *const T_CMD_NAMES[] = {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
"PLACEHOLDER",
"TCOM",
"TPAREN",
"TPIPE",
"TLIST",
"TOR",
"TAND",
"TFOR",
"TDO",
"TCASE",
"TIF",
"TWHILE",
"TUNTIL",
"TELIF",
"TPAT",
"TBRACE",
"TASYNC",
"TDOT",
};
Reduce exported from msh applet
2005-09-22 20:08:17 +05:30
#endif
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* actions determining the environment of a process
*/
#define BIT(i) (1<<(i))
Run msh through indent
2004-08-05 00:46:54 +05:30
#define FEXEC BIT(0) /* execute without forking */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define AREASIZE (90000)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* flags to control evaluation of words
*/
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define DOSUB 1 /* interpret $, `, and quotes */
#define DOBLANK 2 /* perform blank interpretation */
#define DOGLOB 4 /* interpret [?* */
#define DOKEY 8 /* move words with `=' to 2nd arg. list */
#define DOTRIM 16 /* trim resulting string */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define DOALL (DOSUB|DOBLANK|DOGLOB|DOKEY|DOTRIM)
Run msh through indent
2004-08-05 00:46:54 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* PROTOTYPES */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static int newfile(char *s);
Run msh through indent
2004-08-05 00:46:54 +05:30
struct brkcon {
jmp_buf brkpt;
struct brkcon *nextlev;
};
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* flags:
* -e: quit on error
* -k: look for name=value everywhere on command line
* -n: no execution
* -t: exit after reading and executing one command
* -v: echo as read
* -x: trace
* -u: unset variables net diagnostic
*/
remove duplicate flag decls
2006-11-16 03:22:10 +05:30
static char flags['z' - 'a' + 1];
/* this looks weird, but is OK ... we index flag with 'a'...'z' */
static char *flag = flags - 'a';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static char *null; /* null value for variable */
static int intr; /* interrupt pending */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static char *trap[_NSIG + 1];
static char ourtrap[_NSIG + 1];
static int trapset; /* trap pending */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static int heedint; /* heed interrupt signals */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static int yynerrs; /* yacc */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static char line[LINELIM];
static char *elinep;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
#if ENABLE_FEATURE_EDITING
static char *current_prompt;
static line_input_t *line_input_state;
#endif
static int areanum; /* current allocation area */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* other functions
*/
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static const char *rexecve(char *c, char **v, char **envp);
Run msh through indent
2004-08-05 00:46:54 +05:30
static char *evalstr(char *cp, int f);
static char *putn(int n);
static char *unquote(char *as);
static int rlookup(char *n);
static struct wdblock *glob(char *cp, struct wdblock *wb);
static int my_getc(int ec);
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int subgetc(char ec, int quoted);
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
static char **makenv(int all, struct wdblock *wb);
Run msh through indent
2004-08-05 00:46:54 +05:30
static char **eval(char **ap, int f);
static int setstatus(int s);
static int waitfor(int lastpid, int canintr);
static void onintr(int s); /* SIGINT handler */
static int newenv(int f);
static void quitenv(void);
static void next(int f);
static void setdash(void);
static void onecommand(void);
static void runtrap(int i);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- area stuff -------- */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#define REGSIZE sizeof(struct region)
#define GROWBY (256)
/* #define SHRINKBY (64) */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#undef SHRINKBY
just whitespace
2006-01-25 05:38:53 +05:30
#define FREE (32767)
#define BUSY (0)
#define ALIGN (sizeof(int)-1)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct region {
Run msh through indent
2004-08-05 00:46:54 +05:30
struct region *next;
int area;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
/* -------- grammar stuff -------- */
typedef union {
Run msh through indent
2004-08-05 00:46:54 +05:30
char *cp;
char **wp;
int i;
struct op *o;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} YYSTYPE;
Run msh through indent
2004-08-05 00:46:54 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
#define WORD 256
#define LOGAND 257
#define LOGOR 258
#define BREAK 259
#define IF 260
#define THEN 261
#define ELSE 262
#define ELIF 263
#define FI 264
#define CASE 265
#define ESAC 266
#define FOR 267
#define WHILE 268
#define UNTIL 269
#define DO 270
#define DONE 271
#define IN 272
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* Added for "." file expansion */
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
#define DOT 273
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define YYERRCODE 300
/* flags to yylex */
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
#define CONTIN 01 /* skip new lines to complete command */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct op *pipeline(int cf);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static struct op *andor(void);
static struct op *c_list(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static int synio(int cf);
static void musthave(int c, int cf);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static struct op *simple(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct op *nested(int type, int mark);
static struct op *command(int cf);
static struct op *dogroup(int onlydone);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static struct op *thenpart(void);
static struct op *elsepart(void);
static struct op *caselist(void);
static struct op *casepart(void);
static char **pattern(void);
static char **wordlist(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct op *list(struct op *t1, struct op *t2);
static struct op *block(int type, struct op *t1, struct op *t2, char **wp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static struct op *newtp(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct op *namelist(struct op *t);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static char **copyw(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static void word(char *cp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
static struct ioword **copyio(void);
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct ioword *io(int u, int f, char *cp);
static int yylex(int cf);
static int collect(int c, int c1);
static int dual(int c);
static void diag(int ec);
static char *tree(unsigned size);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- var.h -------- */
Run msh through indent
2004-08-05 00:46:54 +05:30
struct var {
char *value;
char *name;
struct var *next;
char status;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
#define COPYV 1 /* flag to setval, suggesting copy */
#define RONLY 01 /* variable is read-only */
#define EXPORT 02 /* variable is to be exported */
#define GETCELL 04 /* name & value space was got with getcell */
static int yyparse(void);
static int execute(struct op *t, int *pin, int *pout, int act);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
#define AFID_NOBUF (~0)
#define AFID_ID 0
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- io.h -------- */
/* io buffer */
struct iobuf {
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
unsigned id; /* buffer id */
char buf[512]; /* buffer */
char *bufp; /* pointer into buffer */
char *ebufp; /* pointer to end of buffer */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
/* possible arguments to an IO function */
struct ioarg {
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *aword;
Run msh through indent
2004-08-05 00:46:54 +05:30
char **awordlist;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
int afile; /* file descriptor */
unsigned afid; /* buffer id */
long afpos; /* file position */
struct iobuf *afbuf; /* buffer for this file */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* an input generator's state */
Run msh through indent
2004-08-05 00:46:54 +05:30
struct io {
int (*iofn) (struct ioarg *, struct io *);
struct ioarg *argp;
int peekc;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
char prev; /* previous character read by readc() */
char nlcount; /* for `'s */
char xchar; /* for `'s */
char task; /* reason for pushed IO */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
#define XOTHER 0 /* none of the below */
#define XDOLL 1 /* expanding ${} */
#define XGRAVE 2 /* expanding `'s */
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
#define XIO 3 /* file IO */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* in substitution */
#define INSUB() (e.iop->task == XGRAVE || e.iop->task == XDOLL)
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static struct ioarg temparg = { 0, 0, 0, AFID_NOBUF, 0 }; /* temporary for PUSHIO */
static struct ioarg ioargstack[NPUSH];
static struct io iostack[NPUSH];
static struct iobuf sharedbuf = { AFID_NOBUF };
static struct iobuf mainbuf = { AFID_NOBUF };
static unsigned bufid = AFID_ID; /* buffer id counter */
#define PUSHIO(what,arg,gen) ((temparg.what = (arg)), pushio(&temparg,(gen)))
#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
/*
* parsing & execution environment
*/
static struct env {
char *linep;
struct io *iobase;
struct io *iop;
xint *errpt; /* void * */
int iofd;
struct env *oenv;
} e;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* input generators for IO structure
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static int nlchar(struct ioarg *ap);
static int strchar(struct ioarg *ap);
static int qstrchar(struct ioarg *ap);
static int filechar(struct ioarg *ap);
static int herechar(struct ioarg *ap);
static int linechar(struct ioarg *ap);
static int gravechar(struct ioarg *ap, struct io *iop);
static int qgravechar(struct ioarg *ap, struct io *iop);
static int dolchar(struct ioarg *ap);
static int wdchar(struct ioarg *ap);
static void scraphere(void);
static void freehere(int area);
static void gethere(void);
static void markhere(char *s, struct ioword *iop);
static int herein(char *hname, int xdoll);
static int run(struct ioarg *argp, int (*f) (struct ioarg *));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static int eofc(void);
static int readc(void);
static void unget(int c);
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void ioecho(char c);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* IO control
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static void pushio(struct ioarg *argp, int (*f) (struct ioarg *));
static int remap(int fd);
static int openpipe(int *pv);
static void closepipe(int *pv);
static struct io *setbase(struct io *ip);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- word.h -------- */
Run msh through indent
2004-08-05 00:46:54 +05:30
#define NSTART 16 /* default number of words to allow for initially */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
struct wdblock {
short w_bsize;
short w_nword;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* bounds are arbitrary */
Run msh through indent
2004-08-05 00:46:54 +05:30
char *w_words[1];
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct wdblock *addword(char *wd, struct wdblock *wb);
static struct wdblock *newword(int nw);
static char **getwords(struct wdblock *wb);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- misc stuff -------- */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
static int forkexec(struct op *t, int *pin, int *pout, int act, char **wp);
Run msh through indent
2004-08-05 00:46:54 +05:30
static int iosetup(struct ioword *iop, int pipein, int pipeout);
static void brkset(struct brkcon *bc);
static int dolabel(struct op *t);
static int dohelp(struct op *t);
static int dochdir(struct op *t);
static int doshift(struct op *t);
static int dologin(struct op *t);
static int doumask(struct op *t);
static int doexec(struct op *t);
static int dodot(struct op *t);
static int dowait(struct op *t);
static int doread(struct op *t);
static int doeval(struct op *t);
static int dotrap(struct op *t);
static int getsig(char *s);
static void setsig(int n, sighandler_t f);
static int getn(char *as);
static int dobreak(struct op *t);
static int docontinue(struct op *t);
static int brkcontin(char *cp, int val);
static int doexit(struct op *t);
static int doexport(struct op *t);
static int doreadonly(struct op *t);
static void rdexp(char **wp, void (*f) (struct var *), int key);
static void badid(char *s);
static int doset(struct op *t);
static void varput(char *s, int out);
static int dotimes(struct op *t);
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static int expand(const char *cp, struct wdblock **wbp, int f);
Run msh through indent
2004-08-05 00:46:54 +05:30
static char *blank(int f);
static int dollar(int quoted);
static int grave(int quoted);
static void globname(char *we, char *pp);
static char *generate(char *start1, char *end1, char *middle, char *end);
static int anyspcl(struct wdblock *wb);
static int xstrcmp(char *p1, char *p2);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
static void glob0(char *a0, unsigned a1, int a2,
Run msh through indent
2004-08-05 00:46:54 +05:30
int (*a3) (char *, char *));
static void readhere(char **name, char *s, int ec);
static void pushio(struct ioarg *argp, int (*f) (struct ioarg *));
static int xxchar(struct ioarg *ap);
struct here {
char *h_tag;
int h_dosub;
struct ioword *h_iop;
struct here *h_next;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
data --> text
2005-10-17 15:18:57 +05:30
static const char * const signame[] = {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
"Signal 0",
"Hangup",
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
NULL, /* interrupt */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
"Quit",
"Illegal instruction",
"Trace/BPT trap",
"Abort",
"Bus error",
"Floating Point Exception",
"Killed",
"SIGUSR1",
"SIGSEGV",
"SIGUSR2",
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
NULL, /* broken pipe */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
"Alarm clock",
"Terminated",
};
Run msh through indent
2004-08-05 00:46:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))
struct res {
data --> text
2005-10-17 15:18:57 +05:30
const char *r_name;
Run msh through indent
2004-08-05 00:46:54 +05:30
int r_val;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
data --> text
2005-10-17 15:18:57 +05:30
static const struct res restab[] = {
Run msh through indent
2004-08-05 00:46:54 +05:30
{"for", FOR},
{"case", CASE},
{"esac", ESAC},
{"while", WHILE},
{"do", DO},
{"done", DONE},
{"if", IF},
{"in", IN},
{"then", THEN},
{"else", ELSE},
{"elif", ELIF},
{"until", UNTIL},
{"fi", FI},
{";;", BREAK},
{"||", LOGOR},
{"&&", LOGAND},
{"{", '{'},
{"}", '}'},
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
{".", DOT},
Run msh through indent
2004-08-05 00:46:54 +05:30
{0, 0},
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
struct builtincmd {
const char *name;
Run msh through indent
2004-08-05 00:46:54 +05:30
int (*builtinfunc) (struct op * t);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Run msh through indent
2004-08-05 00:46:54 +05:30
static const struct builtincmd builtincmds[] = {
{".", dodot},
{":", dolabel},
{"break", dobreak},
{"cd", dochdir},
{"continue", docontinue},
{"eval", doeval},
{"exec", doexec},
{"exit", doexit},
{"export", doexport},
{"help", dohelp},
{"login", dologin},
{"newgrp", dologin},
{"read", doread},
{"readonly", doreadonly},
{"set", doset},
{"shift", doshift},
{"times", dotimes},
{"trap", dotrap},
{"umask", doumask},
{"wait", dowait},
{0, 0}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
};
Reduce exported from msh applet
2005-09-22 20:08:17 +05:30
static struct op *scantree(struct op *);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
static struct op *dowholefile(int, int);
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* Globals */
Run msh through indent
2004-08-05 00:46:54 +05:30
static char **dolv;
static int dolc;
static int exstat;
static char gflg;
data --> text
2005-10-17 15:18:57 +05:30
static int interactive; /* Is this an interactive shell */
Run msh through indent
2004-08-05 00:46:54 +05:30
static int execflg;
static int multiline; /* \n changed to ; */
static struct op *outtree; /* result from parser */
static xint *failpt;
static xint *errpt;
static struct brkcon *brklist;
static int isbreak;
static struct wdblock *wdlist;
static struct wdblock *iolist;
static char *trap[_NSIG + 1];
static char ourtrap[_NSIG + 1];
static int trapset; /* trap pending */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#ifdef MSHDEBUG
static struct var *mshdbg_var;
#endif
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct var *vlist; /* dictionary */
static struct var *homedir; /* home directory */
static struct var *prompt; /* main prompt */
static struct var *cprompt; /* continuation prompt */
static struct var *path; /* search path for commands */
static struct var *shell; /* shell to interpret command files */
static struct var *ifs; /* field separators */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static int areanum; /* current allocation area */
static int intr;
static int inparse;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static char *null = (char*)"";
Run msh through indent
2004-08-05 00:46:54 +05:30
static int heedint = 1;
static void (*qflag) (int) = SIG_IGN;
static int startl;
static int peeksym;
static int nlseen;
static int iounit = IODEFAULT;
static YYSTYPE yylval;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
static char *elinep = line + sizeof(line) - 5;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
static struct here *inhere; /* list of hear docs while parsing */
static struct here *acthere; /* list of active here documents */
static struct region *areabot; /* bottom of area */
static struct region *areatop; /* top of area */
static struct region *areanxt; /* starting point of scan */
Run msh through indent
2004-08-05 00:46:54 +05:30
static void *brktop;
static void *brkaddr;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
static struct env e = {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
line, /* linep: char ptr */
iostack, /* iobase: struct io ptr */
iostack - 1, /* iop: struct io ptr */
(xint *) NULL, /* errpt: void ptr for errors? */
FDBASE, /* iofd: file desc */
(struct env *) NULL /* oenv: struct env ptr */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
};
#ifdef MSHDEBUG
void print_t(struct op *t)
{
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("T: t=%p, type %s, words=%p, IOword=%p\n", t,
T_CMD_NAMES[t->type], t->words, t->ioact));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (t->words) {
DBGPRINTF(("T: W1: %s", t->words[0]));
}
}
void print_tree(struct op *head)
{
if (head == NULL) {
DBGPRINTF(("PRINT_TREE: no tree\n"));
return;
}
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("NODE: %p, left %p, right %p\n", head, head->left,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
head->right));
if (head->left)
print_tree(head->left);
if (head->right)
print_tree(head->right);
}
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
#endif /* MSHDEBUG */
/*
* IO functions
*/
static void prs(const char *s)
{
if (*s)
write(2, s, strlen(s));
}
static void prn(unsigned u)
{
prs(itoa(u));
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static void echo(char **wp)
{
int i;
prs("+");
for (i = 0; wp[i]; i++) {
if (i)
prs(" ");
prs(wp[i]);
}
prs("\n");
}
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
static void closef(int i)
{
if (i > 2)
close(i);
}
static void closeall(void)
{
int u;
for (u = NUFILE; u < NOFILE;)
close(u++);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* fail but return to process next command */
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
static void fail(void) ATTRIBUTE_NORETURN;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void fail(void)
{
longjmp(failpt, 1);
/* NOTREACHED */
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* abort shell (or fail in subshell) */
static void leave(void) ATTRIBUTE_NORETURN;
static void leave(void)
{
DBGPRINTF(("LEAVE: leave called!\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
if (execflg)
fail();
scraphere();
freehere(1);
runtrap(0);
_exit(exstat);
/* NOTREACHED */
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void warn(const char *s)
{
if (*s) {
prs(s);
exstat = -1;
}
prs("\n");
if (flag['e'])
leave();
}
Convert cmdedit into more generic line input facility (make history and completion optional at runtime). Use it for fdisk, as an example. Some unrelated fixes in fdisk are also here.
2007-01-22 12:51:38 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void err(const char *s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
warn(s);
if (flag['n'])
return;
if (!interactive)
leave();
if (e.errpt)
longjmp(e.errpt, 1);
closeall();
e.iop = e.iobase = iostack;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* -------- area.c -------- */
Convert cmdedit into more generic line input facility (make history and completion optional at runtime). Use it for fdisk, as an example. Some unrelated fixes in fdisk are also here.
2007-01-22 12:51:38 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/*
* All memory between (char *)areabot and (char *)(areatop+1) is
* exclusively administered by the area management routines.
* It is assumed that sbrk() and brk() manipulate the high end.
*/
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
#define sbrk(X) ({ \
void * __q = (void *)-1; \
if (brkaddr + (int)(X) < brktop) { \
__q = brkaddr; \
brkaddr += (int)(X); \
} \
__q; \
})
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void initarea(void)
{
brkaddr = xmalloc(AREASIZE);
brktop = brkaddr + AREASIZE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
while ((long) sbrk(0) & ALIGN)
sbrk(1);
areabot = (struct region *) sbrk(REGSIZE);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
areabot->next = areabot;
areabot->area = BUSY;
areatop = areabot;
areanxt = areabot;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static char *getcell(unsigned nbytes)
{
int nregio;
struct region *p, *q;
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
if (nbytes == 0) {
puts("getcell(0)");
abort();
}
/* silly and defeats the algorithm */
/*
* round upwards and add administration area
*/
nregio = (nbytes + (REGSIZE - 1)) / REGSIZE + 1;
p = areanxt;
for (;;) {
if (p->area > areanum) {
/*
* merge free cells
*/
while ((q = p->next)->area > areanum && q != areanxt)
p->next = q->next;
/*
* exit loop if cell big enough
*/
if (q >= p + nregio)
goto found;
}
p = p->next;
if (p == areanxt)
break;
}
i = nregio >= GROWBY ? nregio : GROWBY;
p = (struct region *) sbrk(i * REGSIZE);
if (p == (struct region *) -1)
return NULL;
p--;
if (p != areatop) {
puts("not contig");
abort(); /* allocated areas are contiguous */
}
q = p + i;
p->next = q;
p->area = FREE;
q->next = areabot;
q->area = BUSY;
areatop = q;
found:
/*
* we found a FREE area big enough, pointed to by 'p', and up to 'q'
*/
areanxt = p + nregio;
if (areanxt < q) {
/*
* split into requested area and rest
*/
if (areanxt + 1 > q) {
puts("OOM");
abort(); /* insufficient space left for admin */
}
areanxt->next = q;
areanxt->area = FREE;
p->next = areanxt;
}
p->area = areanum;
return (char *) (p + 1);
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void freecell(char *cp)
{
struct region *p;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
p = (struct region *) cp;
if (p != NULL) {
p--;
if (p < areanxt)
areanxt = p;
p->area = FREE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
}
#define DELETE(obj) freecell((char *)obj)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void freearea(int a)
{
struct region *p, *top;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
top = areatop;
for (p = areabot; p != top; p = p->next)
if (p->area >= a)
p->area = FREE;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void setarea(char *cp, int a)
{
struct region *p;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
p = (struct region *) cp;
if (p != NULL)
(p - 1)->area = a;
}
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static int getarea(char *cp)
{
return ((struct region *) cp - 1)->area;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void garbage(void)
{
struct region *p, *q, *top;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
top = areatop;
for (p = areabot; p != top; p = p->next) {
if (p->area > areanum) {
while ((q = p->next)->area > areanum)
p->next = q->next;
areanxt = p;
}
}
#ifdef SHRINKBY
if (areatop >= q + SHRINKBY && q->area > areanum) {
brk((char *) (q + 1));
q->next = areabot;
q->area = BUSY;
areatop = q;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
#endif
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static char *space(int n)
{
char *cp;
cp = getcell(n);
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
if (cp == NULL)
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
err("out of string space");
return cp;
}
static char *strsave(const char *s, int a)
{
char *cp;
cp = space(strlen(s) + 1);
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
if (cp == NULL) {
// FIXME: I highly doubt this is good.
return (char*)"";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
setarea(cp, a);
strcpy(cp, s);
return cp;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* -------- var.c -------- */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static int eqname(const char *n1, const char *n2)
{
for (; *n1 != '=' && *n1 != '\0'; n1++)
if (*n2++ != *n1)
return 0;
return *n2 == '\0' || *n2 == '=';
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static const char *findeq(const char *cp)
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
{
while (*cp != '\0' && *cp != '=')
cp++;
return cp;
}
/*
* Find the given name in the dictionary
* and return its value. If the name was
* not previously there, enter it now and
* return a null value.
*/
static struct var *lookup(const char *n)
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
// FIXME: dirty hack
static struct var dummy;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
struct var *vp;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp;
char *xp;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
int c;
if (isdigit(*n)) {
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
dummy.name = (char*)n;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
for (c = 0; isdigit(*n) && c < 1000; n++)
c = c * 10 + *n - '0';
dummy.status = RONLY;
dummy.value = (c <= dolc ? dolv[c] : null);
return &dummy;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
for (vp = vlist; vp; vp = vp->next)
if (eqname(vp->name, n))
return vp;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
cp = findeq(n);
vp = (struct var *) space(sizeof(*vp));
if (vp == 0 || (vp->name = space((int) (cp - n) + 2)) == 0) {
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
dummy.name = dummy.value = (char*)"";
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
return &dummy;
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
xp = vp->name;
while ((*xp = *n++) != '\0' && *xp != '=')
xp++;
*xp++ = '=';
*xp = '\0';
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
setarea((char *) vp, 0);
setarea((char *) vp->name, 0);
vp->value = null;
vp->next = vlist;
vp->status = GETCELL;
vlist = vp;
return vp;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/*
* if name is not NULL, it must be
* a prefix of the space `val',
* and end with `='.
* this is all so that exporting
* values is reasonably painless.
*/
static void nameval(struct var *vp, const char *val, const char *name)
{
const char *cp;
char *xp;
int fl;
if (vp->status & RONLY) {
xp = vp->name;
while (*xp && *xp != '=')
putc(*xp++, stderr);
err(" is read-only");
return;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
fl = 0;
if (name == NULL) {
xp = space(strlen(vp->name) + strlen(val) + 2);
if (xp == NULL)
return;
/* make string: name=value */
setarea(xp, 0);
name = xp;
cp = vp->name;
while ((*xp = *cp++) != '\0' && *xp != '=')
xp++;
*xp++ = '=';
strcpy(xp, val);
val = xp;
fl = GETCELL;
}
if (vp->status & GETCELL)
freecell(vp->name); /* form new string `name=value' */
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
vp->name = (char*)name;
vp->value = (char*)val;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
vp->status |= fl;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/*
* give variable at `vp' the value `val'.
*/
static void setval(struct var *vp, const char *val)
{
nameval(vp, val, NULL);
}
static void export(struct var *vp)
{
vp->status |= EXPORT;
}
static void ronly(struct var *vp)
{
if (isalpha(vp->name[0]) || vp->name[0] == '_') /* not an internal symbol */
vp->status |= RONLY;
}
static int isassign(const char *s)
{
unsigned char c;
DBGPRINTF7(("ISASSIGN: enter, s=%s\n", s));
/* no isalpha() - we shouldn't use locale */
c = *s;
if (c != '_'
&& (unsigned)((c|0x20) - 'a') > 25 /* not letter */
) {
return 0;
}
while (1) {
c = *++s;
if (c == '\0')
return 0;
if (c == '=')
return 1;
c |= 0x20; /* lowercase letters, doesn't affect numbers */
if (c != '_'
&& (unsigned)(c - '0') > 9 /* not number */
&& (unsigned)(c - 'a') > 25 /* not letter */
) {
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static int assign(const char *s, int cf)
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp;
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
struct var *vp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
DBGPRINTF7(("ASSIGN: enter, s=%s, cf=%d\n", s, cf));
if (!isalpha(*s) && *s != '_')
return 0;
for (cp = s; *cp != '='; cp++)
if (*cp == '\0' || (!isalnum(*cp) && *cp != '_'))
return 0;
vp = lookup(s);
nameval(vp, ++cp, cf == COPYV ? NULL : s);
if (cf != COPYV)
vp->status &= ~GETCELL;
return 1;
}
static int checkname(char *cp)
{
DBGPRINTF7(("CHECKNAME: enter, cp=%s\n", cp));
if (!isalpha(*cp++) && *(cp - 1) != '_')
return 0;
while (*cp)
if (!isalnum(*cp++) && *(cp - 1) != '_')
return 0;
return 1;
}
static void putvlist(int f, int out)
{
struct var *vp;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
for (vp = vlist; vp; vp = vp->next) {
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
if (vp->status & f && (isalpha(*vp->name) || *vp->name == '_')) {
if (vp->status & EXPORT)
write(out, "export ", 7);
if (vp->status & RONLY)
write(out, "readonly ", 9);
write(out, vp->name, (int) (findeq(vp->name) - vp->name));
write(out, "\n", 1);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
}
/*
* trap handling
*/
static void sig(int i)
{
trapset = i;
signal(i, sig);
}
static void runtrap(int i)
{
char *trapstr;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
trapstr = trap[i];
if (trapstr == NULL)
return;
if (i == 0)
trap[i] = NULL;
RUN(aword, trapstr, nlchar);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void setdash(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *cp;
int c;
Run msh through indent
2004-08-05 00:46:54 +05:30
char m['z' - 'a' + 1];
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
cp = m;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (c = 'a'; c <= 'z'; c++)
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
if (flag[c])
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*cp++ = c;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
*cp = '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
setval(lookup("-"), m);
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int newfile(char *s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int f;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("NEWFILE: opening %s\n", s));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
f = 0;
inline strcmp(s, "-") [actually macro-ize it for now - gcc is too stupid]
2006-12-17 05:19:13 +05:30
if (NOT_LONE_DASH(s)) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("NEWFILE: s is %s\n", s));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
f = open(s, 0);
if (f < 0) {
prs(s);
err(": cannot open");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
next(remap(f));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
struct op *scantree(struct op *head)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
{
struct op *dotnode;
if (head == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (head->left != NULL) {
dotnode = scantree(head->left);
if (dotnode)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return dotnode;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
if (head->right != NULL) {
dotnode = scantree(head->right);
if (dotnode)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return dotnode;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
if (head->words == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF5(("SCANTREE: checking node %p\n", head));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
find: support for !
2007-02-04 22:41:25 +05:30
if ((head->type != TDOT) && LONE_CHAR(head->words[0], '.')) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF5(("SCANTREE: dot found in node %p\n", head));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return head;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void onecommand(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
jmp_buf m1;
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("ONECOMMAND: enter, outtree=%p\n", outtree));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (e.oenv)
quitenv();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
areanum = 1;
freehere(areanum);
freearea(areanum);
garbage();
wdlist = 0;
iolist = 0;
e.errpt = 0;
e.linep = line;
yynerrs = 0;
multiline = 0;
inparse = 1;
intr = 0;
execflg = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
failpt = m1;
setjmp(failpt); /* Bruce Evans' fix */
failpt = m1;
if (setjmp(failpt) || yyparse() || intr) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("ONECOMMAND: this is not good.\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (e.oenv)
quitenv();
scraphere();
if (!interactive && intr)
leave();
inparse = 0;
intr = 0;
return;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
inparse = 0;
brklist = 0;
intr = 0;
execflg = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (!flag['n']) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("ONECOMMAND: calling execute, t=outtree=%p\n",
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
outtree));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
execute(outtree, NOPIPE, NOPIPE, 0);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (!interactive && intr) {
execflg = 0;
leave();
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
i = trapset;
if (i != 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
trapset = 0;
runtrap(i);
}
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int newenv(int f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct env *ep;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("NEWENV: f=%d (indicates quitenv and return)\n", f));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (f) {
quitenv();
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
ep = (struct env *) space(sizeof(*ep));
if (ep == NULL) {
while (e.oenv)
quitenv();
fail();
}
*ep = e;
e.oenv = ep;
e.errpt = errpt;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void quitenv(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
struct env *ep;
int fd;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
DBGPRINTF(("QUITENV: e.oenv=%p\n", e.oenv));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
ep = e.oenv;
if (ep != NULL) {
fd = e.iofd;
e = *ep;
/* should close `'d files */
DELETE(ep);
while (--fd >= e.iofd)
close(fd);
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/*
* Is character c in s?
*/
static int any(int c, const char *s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
while (*s)
if (*s++ == c)
return 1;
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/*
* Is any character from s1 in s2?
*/
static int anys(const char *s1, const char *s2)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
while (*s1)
if (any(*s1++, s2))
return 1;
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static char *putn(int n)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
return itoa(n);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void next(int f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
PUSHIO(afile, f, filechar);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
static void onintr(int s) /* ANSI C requires a parameter */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
signal(SIGINT, onintr);
intr = 1;
if (interactive) {
if (inparse) {
prs("\n");
fail();
}
} else if (heedint) {
execflg = 0;
leave();
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- gmatch.c -------- */
/*
* int gmatch(string, pattern)
* char *string, *pattern;
*
* Match a pattern as in sh(1).
*/
#define CMASK 0377
#define QUOTE 0200
#define QMASK (CMASK&~QUOTE)
Run msh through indent
2004-08-05 00:46:54 +05:30
#define NOT '!' /* might use ^ */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static const char *cclass(const char *p, int sub)
{
int c, d, not, found;
not = (*p == NOT);
if (not != 0)
p++;
found = not;
do {
if (*p == '\0')
return NULL;
c = *p & CMASK;
if (p[1] == '-' && p[2] != ']') {
d = p[2] & CMASK;
p++;
} else
d = c;
if (c == sub || (c <= sub && sub <= d))
found = !not;
} while (*++p != ']');
return found ? p + 1 : NULL;
}
static int gmatch(const char *s, const char *p)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int sc, pc;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (s == NULL || p == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while ((pc = *p++ & CMASK) != '\0') {
sc = *s++ & QMASK;
switch (pc) {
case '[':
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
p = cclass(p, sc);
if (p == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
case '?':
if (sc == 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
case '*':
s--;
do {
if (*p == '\0' || gmatch(s, p))
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} while (*s++ != '\0');
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
default:
if (sc != (pc & ~QUOTE))
return 0;
}
}
return *s == '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- csyn.c -------- */
/*
* shell: syntax (C version)
*/
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
static void yyerror(const char *s) ATTRIBUTE_NORETURN;
static void yyerror(const char *s)
{
yynerrs++;
if (interactive && e.iop <= iostack) {
multiline = 0;
while (eofc() == 0 && yylex(0) != '\n');
}
err(s);
fail();
}
static void zzerr(void) ATTRIBUTE_NORETURN;
static void zzerr(void)
{
yyerror("syntax error");
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
int yyparse(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("YYPARSE: enter...\n"));
Run msh through indent
2004-08-05 00:46:54 +05:30
startl = 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = 0;
yynerrs = 0;
outtree = c_list();
musthave('\n', 0);
Run msh through indent
2004-08-05 00:46:54 +05:30
return (yynerrs != 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *pipeline(int cf)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t, *p;
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("PIPELINE: enter, cf=%d\n", cf));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = command(cf);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF9(("PIPELINE: t=%p\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t != NULL) {
while ((c = yylex(0)) == '|') {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
p = command(CONTIN);
if (p == NULL) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("PIPELINE: error!\n"));
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->type != TPAREN && t->type != TCOM) {
/* shell statement */
t = block(TPAREN, t, NOBLOCK, NOWORDS);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = block(TPIPE, t, p, NOWORDS);
}
peeksym = c;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("PIPELINE: returning t=%p\n", t));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *andor(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t, *p;
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("ANDOR: enter...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = pipeline(0);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF9(("ANDOR: t=%p\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t != NULL) {
while ((c = yylex(0)) == LOGAND || c == LOGOR) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
p = pipeline(CONTIN);
if (p == NULL) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("ANDOR: error!\n"));
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
t = block(c == LOGAND ? TAND : TOR, t, p, NOWORDS);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
} /* WHILE */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("ANDOR: returning t=%p\n", t));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *c_list(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t, *p;
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("C_LIST: enter...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = andor();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t != NULL) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
peeksym = yylex(0);
if (peeksym == '&')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = block(TASYNC, t, NOBLOCK, NOWORDS);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
while ((c = yylex(0)) == ';' || c == '&'
|| (multiline && c == '\n')) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
p = andor();
if (p== NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
peeksym = yylex(0);
if (peeksym == '&')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
p = block(TASYNC, p, NOBLOCK, NOWORDS);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = list(t, p);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
} /* WHILE */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* IF */
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("C_LIST: returning t=%p\n", t));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int synio(int cf)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct ioword *iop;
int i;
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("SYNIO: enter, cf=%d\n", cf));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = yylex(cf);
if (c != '<' && c != '>') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = yylval.i;
musthave(WORD, 0);
iop = io(iounit, i, yylval.cp);
iounit = IODEFAULT;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (i & IOHERE)
markhere(yylval.cp, iop);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("SYNIO: returning 1\n"));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void musthave(int c, int cf)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
peeksym = yylex(cf);
if (peeksym != c) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("MUSTHAVE: error!\n"));
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = 0;
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *simple(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = NULL;
for (;;) {
switch (peeksym = yylex(0)) {
case '<':
case '>':
(void) synio(0);
break;
case WORD:
if (t == NULL) {
t = newtp();
t->type = TCOM;
}
peeksym = 0;
word(yylval.cp);
break;
default:
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *nested(int type, int mark)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("NESTED: enter, type=%d, mark=%d\n", type, mark));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
multiline++;
t = c_list();
musthave(mark, 0);
multiline--;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return block(type, t, NOBLOCK, NOWORDS);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *command(int cf)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct wdblock *iosave;
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("COMMAND: enter, cf=%d\n", cf));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
iosave = iolist;
iolist = NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (multiline)
cf |= CONTIN;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (synio(cf))
cf = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
c = yylex(cf);
switch (c) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
default:
peeksym = c;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
t = simple();
if (t == NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (iolist == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = newtp();
t->type = TCOM;
}
break;
case '(':
t = nested(TPAREN, ')');
break;
case '{':
t = nested(TBRACE, '}');
break;
case FOR:
t = newtp();
t->type = TFOR;
musthave(WORD, 0);
startl = 1;
t->str = yylval.cp;
multiline++;
t->words = wordlist();
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = yylex(0);
if (c != '\n' && c != ';')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
t->left = dogroup(0);
multiline--;
break;
case WHILE:
case UNTIL:
multiline++;
t = newtp();
Run msh through indent
2004-08-05 00:46:54 +05:30
t->type = c == WHILE ? TWHILE : TUNTIL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->left = c_list();
t->right = dogroup(1);
t->words = NULL;
multiline--;
break;
case CASE:
t = newtp();
t->type = TCASE;
musthave(WORD, 0);
t->str = yylval.cp;
startl++;
multiline++;
musthave(IN, CONTIN);
startl++;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->left = caselist();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
musthave(ESAC, 0);
multiline--;
break;
case IF:
multiline++;
t = newtp();
t->type = TIF;
t->left = c_list();
t->right = thenpart();
musthave(FI, 0);
multiline--;
break;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
case DOT:
t = newtp();
t->type = TDOT;
musthave(WORD, 0); /* gets name of file */
DBGPRINTF7(("COMMAND: DOT clause, yylval.cp is %s\n", yylval.cp));
word(yylval.cp); /* add word to wdlist */
word(NOWORD); /* terminate wdlist */
t->words = copyw(); /* dup wdlist */
break;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
while (synio(0));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = namelist(t);
iolist = iosave;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("COMMAND: returning %p\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *dowholefile(int type, int mark)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("DOWHOLEFILE: enter, type=%d, mark=%d\n", type, mark));
multiline++;
t = c_list();
multiline--;
t = block(type, t, NOBLOCK, NOWORDS);
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("DOWHOLEFILE: return t=%p\n", t));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *dogroup(int onlydone)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
struct op *mylist;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = yylex(CONTIN);
if (c == DONE && onlydone)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (c != DO)
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
mylist = c_list();
musthave(DONE, 0);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return mylist;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *thenpart(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = yylex(0);
if (c != THEN) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
t = newtp();
t->type = 0;
t->left = c_list();
if (t->left == NULL)
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->right = elsepart();
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *elsepart(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
switch (c = yylex(0)) {
case ELSE:
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
t = c_list();
if (t == NULL)
msh: cleaning up for -Wwrite-strings part #3
2007-02-01 07:13:39 +05:30
zzerr();
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case ELIF:
t = newtp();
t->type = TELIF;
t->left = c_list();
t->right = thenpart();
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
default:
peeksym = c;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *caselist(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
while ((peeksym = yylex(CONTIN)) != ESAC) {
DBGPRINTF(("CASELIST, doing yylex, peeksym=%d\n", peeksym));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = list(t, casepart());
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("CASELIST, returning t=%p\n", t));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *casepart(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("CASEPART: enter...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = newtp();
t->type = TPAT;
t->words = pattern();
musthave(')', 0);
t->left = c_list();
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
peeksym = yylex(CONTIN);
if (peeksym != ESAC)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
musthave(BREAK, CONTIN);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("CASEPART: made newtp(TPAT, t=%p)\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static char **pattern(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c, cf;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
cf = CONTIN;
do {
musthave(WORD, cf);
word(yylval.cp);
cf = 0;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = yylex(0);
} while (c == '|');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
word(NOWORD);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return copyw();
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static char **wordlist(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = yylex(0);
if (c != IN) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = c;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
startl = 0;
while ((c = yylex(0)) == WORD)
word(yylval.cp);
word(NOWORD);
peeksym = c;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return copyw();
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* supporting functions
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static struct op *list(struct op *t1, struct op *t2)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("LIST: enter, t1=%p, t2=%p\n", t1, t2));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t1 == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t2;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t2 == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return block(TLIST, t1, t2, NOWORDS);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *block(int type, struct op *t1, struct op *t2, char **wp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("BLOCK: enter, type=%d (%s)\n", type, T_CMD_NAMES[type]));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t = newtp();
t->type = type;
t->left = t1;
t->right = t2;
t->words = wp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("BLOCK: inserted %p between %p and %p\n", t, t1,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
t2));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* See if given string is a shell multiline (FOR, IF, etc) */
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int rlookup(char *n)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
const struct res *rp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("RLOOKUP: enter, n is %s\n", n));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (rp = restab; rp->r_name; rp++)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (strcmp(rp->r_name, n) == 0) {
DBGPRINTF7(("RLOOKUP: match, returning %d\n", rp->r_val));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return rp->r_val; /* Return numeric code for shell multiline */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
DBGPRINTF7(("RLOOKUP: NO match, returning 0\n"));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0; /* Not a shell multiline */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct op *newtp(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
t = (struct op *) tree(sizeof(*t));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->type = 0;
t->words = NULL;
t->ioact = NULL;
t->left = NULL;
t->right = NULL;
t->str = NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF3(("NEWTP: allocated %p\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static struct op *namelist(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("NAMELIST: enter, t=%p, type %s, iolist=%p\n", t,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
T_CMD_NAMES[t->type], iolist));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (iolist) {
Run msh through indent
2004-08-05 00:46:54 +05:30
iolist = addword((char *) NULL, iolist);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->ioact = copyio();
} else
t->ioact = NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->type != TCOM) {
if (t->type != TPAREN && t->ioact != NULL) {
t = block(TPAREN, t, NOBLOCK, NOWORDS);
t->ioact = t->left->ioact;
t->left->ioact = NULL;
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
word(NOWORD);
t->words = copyw();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static char **copyw(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char **wd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wd = getwords(wdlist);
wdlist = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void word(char *cp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
wdlist = addword(cp, wdlist);
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct ioword **copyio(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct ioword **iop;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
iop = (struct ioword **) getwords(iolist);
iolist = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return iop;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct ioword *io(int u, int f, char *cp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct ioword *iop;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
iop = (struct ioword *) tree(sizeof(*iop));
iop->io_unit = u;
iop->io_flag = f;
iop->io_name = cp;
Run msh through indent
2004-08-05 00:46:54 +05:30
iolist = addword((char *) iop, iolist);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return iop;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int yylex(int cf)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c, c1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int atstart;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = peeksym;
if (c > 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
peeksym = 0;
if (c == '\n')
startl = 1;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
nlseen = 0;
atstart = startl;
startl = 0;
yylval.i = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
e.linep = line;
/* MALAMO */
line[LINELIM - 1] = '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
loop:
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
while ((c = my_getc(0)) == ' ' || c == '\t') /* Skip whitespace */
;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
switch (c) {
default:
if (any(c, "0123456789")) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c1 = my_getc(0);
unget(c1);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (c1 == '<' || c1 == '>') {
iounit = c - '0';
goto loop;
}
*e.linep++ = c;
c = c1;
}
break;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
case '#': /* Comment, skip to next newline or End-of-string */
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
while ((c = my_getc(0)) != '\0' && c != '\n');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
unget(c);
goto loop;
case 0:
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF5(("YYLEX: return 0, c=%d\n", c));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case '$':
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF9(("YYLEX: found $\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*e.linep++ = c;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c = my_getc(0);
if (c == '{') {
c = collect(c, '}');
if (c != '\0')
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
goto pack;
}
break;
case '`':
case '\'':
case '"':
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c = collect(c, c);
if (c != '\0')
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
goto pack;
case '|':
case '&':
case ';':
startl = 1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* If more chars process them, else return NULL char */
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c1 = dual(c);
if (c1 != '\0')
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c1;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
return c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case '^':
startl = 1;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return '|';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case '>':
case '<':
diag(c);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case '\n':
nlseen++;
gethere();
startl = 1;
if (multiline || cf & CONTIN) {
if (interactive && e.iop <= iostack) {
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING
Run msh through indent
2004-08-05 00:46:54 +05:30
current_prompt = cprompt->value;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#else
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(cprompt->value);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#endif
}
if (cf & CONTIN)
goto loop;
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case '(':
case ')':
startl = 1;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
unget(c);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
pack:
while ((c = my_getc(0)) != '\0' && !any(c, "`$ '\"\t;&<>()|^\n")) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (e.linep >= elinep)
err("word too long");
else
*e.linep++ = c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
};
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
unget(c);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
if (any(c, "\"'`$"))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
goto loop;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*e.linep++ = '\0';
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (atstart) {
c = rlookup(line);
if (c != 0) {
startl = 1;
return c;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
yylval.cp = strsave(line, areanum);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return WORD;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int collect(int c, int c1)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
char s[2];
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("COLLECT: enter, c=%d, c1=%d\n", c, c1));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*e.linep++ = c;
while ((c = my_getc(c1)) != c1) {
if (c == 0) {
unget(c);
s[0] = c1;
s[1] = 0;
Run msh through indent
2004-08-05 00:46:54 +05:30
prs("no closing ");
yyerror(s);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return YYERRCODE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (interactive && c == '\n' && e.iop <= iostack) {
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING
Run msh through indent
2004-08-05 00:46:54 +05:30
current_prompt = cprompt->value;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#else
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(cprompt->value);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#endif
}
*e.linep++ = c;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*e.linep++ = c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("COLLECT: return 0, line is %s\n", line));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* "multiline commands" helper func */
/* see if next 2 chars form a shell multiline */
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int dual(int c)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
char s[3];
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *cp = s;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("DUAL: enter, c=%d\n", c));
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
*cp++ = c; /* c is the given "peek" char */
*cp++ = my_getc(0); /* get next char of input */
*cp = '\0'; /* add EOS marker */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c = rlookup(s); /* see if 2 chars form a shell multiline */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (c == 0)
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
unget(*--cp); /* String is not a shell multiline, put peek char back */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
return c; /* String is multiline, return numeric multiline (restab) code */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void diag(int ec)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF8(("DIAG: enter, ec=%d\n", ec));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = my_getc(0);
if (c == '>' || c == '<') {
if (c != ec)
zzerr();
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
yylval.i = (ec == '>' ? IOWRITE | IOCAT : IOHERE);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = my_getc(0);
} else
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
yylval.i = (ec == '>' ? IOWRITE : IOREAD);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (c != '&' || yylval.i == IOHERE)
unget(c);
else
yylval.i |= IODUP;
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static char *tree(unsigned size)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
t = getcell(size);
if (t == NULL) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF2(("TREE: getcell(%d) failed!\n", size));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
prs("command line too complicated\n");
fail();
/* NOTREACHED */
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return t;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* VARARGS1 */
/* ARGSUSED */
/* -------- exec.c -------- */
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static struct op **find1case(struct op *t, const char *w)
{
struct op *t1;
struct op **tp;
char **wp;
char *cp;
if (t == NULL) {
DBGPRINTF3(("FIND1CASE: enter, t==NULL, returning.\n"));
return NULL;
}
DBGPRINTF3(("FIND1CASE: enter, t->type=%d (%s)\n", t->type,
T_CMD_NAMES[t->type]));
if (t->type == TLIST) {
tp = find1case(t->left, w);
if (tp != NULL) {
DBGPRINTF3(("FIND1CASE: found one to the left, returning tp=%p\n", tp));
return tp;
}
t1 = t->right; /* TPAT */
} else
t1 = t;
for (wp = t1->words; *wp;) {
cp = evalstr(*wp++, DOSUB);
if (cp && gmatch(w, cp)) {
DBGPRINTF3(("FIND1CASE: returning &t1->left= %p.\n",
&t1->left));
return &t1->left;
}
}
DBGPRINTF(("FIND1CASE: returning NULL\n"));
return NULL;
}
static struct op *findcase(struct op *t, const char *w)
{
struct op **tp;
tp = find1case(t, w);
return tp != NULL ? *tp : NULL;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* execute tree
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int execute(struct op *t, int *pin, int *pout, int act)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct op *t1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
volatile int i, rv, a;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp;
char **wp, **wp2;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct var *vp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
struct op *outtree_save;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct brkcon bc;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &wp;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
#endif
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (t == NULL) {
DBGPRINTF4(("EXECUTE: enter, t==null, returning.\n"));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("EXECUTE: t=%p, t->type=%d (%s), t->words is %s\n", t,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
t->type, T_CMD_NAMES[t->type],
((t->words == NULL) ? "NULL" : t->words[0])));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
rv = 0;
a = areanum++;
wp = (wp2 = t->words) != NULL
Run msh through indent
2004-08-05 00:46:54 +05:30
? eval(wp2, t->type == TCOM ? DOALL : DOALL & ~DOKEY)
: NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
switch (t->type) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
case TDOT:
DBGPRINTF3(("EXECUTE: TDOT\n"));
outtree_save = outtree;
newfile(evalstr(t->words[0], DOALL));
t->left = dowholefile(TLIST, 0);
t->right = NULL;
outtree = outtree_save;
if (t->left)
rv = execute(t->left, pin, pout, 0);
if (t->right)
rv = execute(t->right, pin, pout, 0);
break;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case TPAREN:
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
rv = execute(t->left, pin, pout, 0);
break;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case TCOM:
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
rv = forkexec(t, pin, pout, act, wp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
case TPIPE:
{
Run msh through indent
2004-08-05 00:46:54 +05:30
int pv[2];
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
rv = openpipe(pv);
if (rv < 0)
Run msh through indent
2004-08-05 00:46:54 +05:30
break;
pv[0] = remap(pv[0]);
pv[1] = remap(pv[1]);
(void) execute(t->left, pin, pv, 0);
rv = execute(t->right, pv, pout, 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
break;
case TLIST:
(void) execute(t->left, pin, pout, 0);
rv = execute(t->right, pin, pout, 0);
break;
case TASYNC:
Run msh through indent
2004-08-05 00:46:54 +05:30
{
int hinteractive = interactive;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("EXECUTE: TASYNC clause, calling vfork()...\n"));
Run msh through indent
2004-08-05 00:46:54 +05:30
i = vfork();
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (i == 0) { /* child */
Run msh through indent
2004-08-05 00:46:54 +05:30
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
if (interactive)
signal(SIGTERM, SIG_DFL);
interactive = 0;
if (pin == NULL) {
close(0);
usage bb_dev_null
2005-10-12 21:04:25 +05:30
open(bb_dev_null, 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
_exit(execute(t->left, pin, pout, FEXEC));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
interactive = hinteractive;
if (i != -1) {
setval(lookup("!"), putn(i));
if (pin != NULL)
closepipe(pin);
if (interactive) {
prs(putn(i));
prs("\n");
}
} else
rv = -1;
setstatus(rv);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
break;
case TOR:
case TAND:
rv = execute(t->left, pin, pout, 0);
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
t1 = t->right;
if (t1 != NULL && (rv == 0) == (t->type == TAND))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
rv = execute(t1, pin, pout, 0);
break;
case TFOR:
if (wp == NULL) {
Run msh through indent
2004-08-05 00:46:54 +05:30
wp = dolv + 1;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
i = dolc;
if (i < 0)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = 0;
} else {
i = -1;
Run msh through indent
2004-08-05 00:46:54 +05:30
while (*wp++ != NULL);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
vp = lookup(t->str);
while (setjmp(bc.brkpt))
if (isbreak)
goto broken;
brkset(&bc);
for (t1 = t->left; i-- && *wp != NULL;) {
setval(vp, *wp++);
rv = execute(t1, pin, pout, 0);
}
brklist = brklist->nextlev;
break;
case TWHILE:
case TUNTIL:
while (setjmp(bc.brkpt))
if (isbreak)
goto broken;
brkset(&bc);
t1 = t->left;
while ((execute(t1, pin, pout, 0) == 0) == (t->type == TWHILE))
rv = execute(t->right, pin, pout, 0);
brklist = brklist->nextlev;
break;
case TIF:
case TELIF:
Run msh through indent
2004-08-05 00:46:54 +05:30
if (t->right != NULL) {
rv = !execute(t->left, pin, pout, 0) ?
execute(t->right->left, pin, pout, 0) :
execute(t->right->right, pin, pout, 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
break;
case TCASE:
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = evalstr(t->str, DOSUB | DOTRIM);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (cp == NULL)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
cp = "";
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("EXECUTE: TCASE, t->str is %s, cp is %s\n",
((t->str == NULL) ? "NULL" : t->str),
((cp == NULL) ? "NULL" : cp)));
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
t1 = findcase(t->left, cp);
if (t1 != NULL) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("EXECUTE: TCASE, calling execute(t=%p, t1=%p)...\n", t, t1));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
rv = execute(t1, pin, pout, 0);
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("EXECUTE: TCASE, back from execute(t=%p, t1=%p)...\n", t, t1));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
case TBRACE:
/*
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
iopp = t->ioact;
if (i)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (*iopp)
if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
rv = -1;
break;
}
*/
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (rv >= 0) {
t1 = t->left;
if (t1) {
rv = execute(t1, pin, pout, 0);
}
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
};
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
broken:
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->words = wp2;
isbreak = 0;
freehere(areanum);
freearea(areanum);
areanum = a;
if (interactive && intr) {
closeall();
fail();
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
i = trapset;
if (i != 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
trapset = 0;
runtrap(i);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("EXECUTE: returning from t=%p, rv=%d\n", t, rv));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return rv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
typedef int (*builtin_func_ptr)(struct op *);
static builtin_func_ptr inbuilt(const char *s) {
const struct builtincmd *bp;
for (bp = builtincmds; bp->name != NULL; bp++)
if (strcmp(bp->name, s) == 0)
return bp->builtinfunc;
return NULL;
}
static int forkexec(struct op *t, int *pin, int *pout, int act, char **wp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
pid_t newpid;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int i, rv;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
builtin_func_ptr shcom = NULL;
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int f;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp = NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct ioword **iopp;
int resetsig;
char **owp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
int forked = 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int *hpin = pin;
int *hpout = pout;
char *hwp;
int hinteractive;
int hintr;
Run msh through indent
2004-08-05 00:46:54 +05:30
struct brkcon *hbrklist;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int hexecflg;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &pin;
(void) &pout;
(void) &wp;
(void) &shcom;
(void) &cp;
(void) &resetsig;
(void) &owp;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
#endif
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("FORKEXEC: t=%p, pin %p, pout %p, act %d\n", t, pin,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
pout, act));
DBGPRINTF7(("FORKEXEC: t->words is %s\n",
((t->words == NULL) ? "NULL" : t->words[0])));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
owp = wp;
resetsig = 0;
Run msh through indent
2004-08-05 00:46:54 +05:30
rv = -1; /* system-detected error */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->type == TCOM) {
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
while (*wp++ != NULL);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
cp = *wp;
/* strip all initial assignments */
/* not correct wrt PATH=yyy command etc */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (flag['x']) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF9(("FORKEXEC: echo'ing, cp=%p, wp=%p, owp=%p\n",
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
cp, wp, owp));
Run msh through indent
2004-08-05 00:46:54 +05:30
echo(cp ? wp : owp);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (cp == NULL && t->ioact == NULL) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
while ((cp = *owp++) != NULL && assign(cp, COPYV))
/**/;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("FORKEXEC: returning setstatus()\n"));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return setstatus(0);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
if (cp != NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
shcom = inbuilt(cp);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
t->words = wp;
f = act;
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("FORKEXEC: shcom %p, f&FEXEC 0x%x, owp %p\n", shcom,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
f & FEXEC, owp));
if (shcom == NULL && (f & FEXEC) == 0) {
/* Save values in case the child process alters them */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
hpin = pin;
hpout = pout;
hwp = *wp;
hinteractive = interactive;
hintr = intr;
hbrklist = brklist;
hexecflg = execflg;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("FORKEXEC: calling vfork()...\n"));
newpid = vfork();
if (newpid == -1) {
rodata cleanup. "unable to" == "cannot". -300 bytes
2006-11-19 03:34:09 +05:30
DBGPRINTF(("FORKEXEC: ERROR, cannot vfork()!\n"));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
if (newpid > 0) { /* Parent */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* Restore values */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
pin = hpin;
pout = hpout;
*wp = hwp;
interactive = hinteractive;
intr = hintr;
brklist = hbrklist;
execflg = hexecflg;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* moved up
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (i == -1)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return rv;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
*/
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (pin != NULL)
closepipe(pin);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
return (pout == NULL ? setstatus(waitfor(newpid, 0)) : 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* Must be the child process, pid should be 0 */
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("FORKEXEC: child process, shcom=%p\n", shcom));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (interactive) {
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
resetsig = 1;
}
interactive = 0;
intr = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
forked = 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
brklist = 0;
execflg = 0;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (owp != NULL)
while ((cp = *owp++) != NULL && assign(cp, COPYV))
if (shcom == NULL)
export(lookup(cp));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#ifdef COMPIPE
if ((pin != NULL || pout != NULL) && shcom != NULL && shcom != doexec) {
err("piping to/from shell builtins not yet done");
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (forked)
_exit(-1);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
#endif
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (pin != NULL) {
dup2(pin[0], 0);
closepipe(pin);
}
if (pout != NULL) {
dup2(pout[1], 1);
closepipe(pout);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
iopp = t->ioact;
if (iopp != NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (shcom != NULL && shcom != doexec) {
prs(cp);
err(": cannot redirect shell command");
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (forked)
_exit(-1);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
while (*iopp)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (iosetup(*iopp++, pin != NULL, pout != NULL)) {
if (forked)
_exit(rv);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return rv;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
}
if (shcom) {
i = setstatus((*shcom) (t));
if (forked)
_exit(i);
DBGPRINTF(("FORKEXEC: returning i=%d\n", i));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* should use FIOCEXCL */
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = FDBASE; i < NOFILE; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
close(i);
if (resetsig) {
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->type == TPAREN)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
_exit(execute(t->left, NOPIPE, NOPIPE, FEXEC));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (wp[0] == NULL)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
_exit(0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
cp = rexecve(wp[0], wp, makenv(0, NULL));
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(wp[0]);
prs(": ");
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
err(cp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (!execflg)
trap[0] = NULL;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("FORKEXEC: calling leave(), pid=%d\n", newpid));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
leave();
/* NOTREACHED */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
_exit(1);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* 0< 1> are ignored as required
* within pipelines.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int iosetup(struct ioword *iop, int pipein, int pipeout)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int u = -1;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
char *cp = NULL;
const char *msg;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("IOSETUP: iop %p, pipein %i, pipeout %i\n", iop,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
pipein, pipeout));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (iop->io_unit == IODEFAULT) /* take default */
Run msh through indent
2004-08-05 00:46:54 +05:30
iop->io_unit = iop->io_flag & (IOREAD | IOHERE) ? 0 : 1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (pipein && iop->io_unit == 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (pipeout && iop->io_unit == 1)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
msg = iop->io_flag & (IOREAD | IOHERE) ? "open" : "create";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if ((iop->io_flag & IOHERE) == 0) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
cp = iop->io_name; /* huh?? */
cp = evalstr(cp, DOSUB | DOTRIM);
if (cp == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (iop->io_flag & IODUP) {
if (cp[1] || (!isdigit(*cp) && *cp != '-')) {
prs(cp);
err(": illegal >& argument");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (*cp == '-')
iop->io_flag = IOCLOSE;
Run msh through indent
2004-08-05 00:46:54 +05:30
iop->io_flag &= ~(IOREAD | IOWRITE);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
switch (iop->io_flag) {
case IOREAD:
u = open(cp, 0);
break;
case IOHERE:
Run msh through indent
2004-08-05 00:46:54 +05:30
case IOHERE | IOXHERE:
u = herein(iop->io_name, iop->io_flag & IOXHERE);
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
cp = (char*)"here file";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
Run msh through indent
2004-08-05 00:46:54 +05:30
case IOWRITE | IOCAT:
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
u = open(cp, 1);
if (u >= 0) {
add open_read_close() and similar stuff
2006-10-14 07:53:43 +05:30
lseek(u, (long) 0, SEEK_END);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
}
case IOWRITE:
u = creat(cp, 0666);
break;
case IODUP:
Run msh through indent
2004-08-05 00:46:54 +05:30
u = dup2(*cp - '0', iop->io_unit);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
case IOCLOSE:
close(iop->io_unit);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (u < 0) {
prs(cp);
prs(": cannot ");
warn(msg);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
if (u != iop->io_unit) {
dup2(u, iop->io_unit);
close(u);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Enter a new loop level (marked for break/continue).
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void brkset(struct brkcon *bc)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
bc->nextlev = brklist;
brklist = bc;
}
/*
* Wait for the last process created.
* Print a message for each process found
* that was killed by a signal.
* Ignore interrupt signals while waiting
* unless `canintr' is true.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int waitfor(int lastpid, int canintr)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int pid, rv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int s;
int oheedint = heedint;
heedint = 0;
rv = 0;
do {
pid = wait(&s);
if (pid == -1) {
if (errno != EINTR || canintr)
break;
} else {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
rv = WAITSIG(s);
if (rv != 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (rv < NSIGNAL) {
if (signame[rv] != NULL) {
if (pid != lastpid) {
prn(pid);
prs(": ");
}
prs(signame[rv]);
}
} else {
if (pid != lastpid) {
prn(pid);
prs(": ");
}
Run msh through indent
2004-08-05 00:46:54 +05:30
prs("Signal ");
prn(rv);
prs(" ");
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (WAITCORE(s))
prs(" - core dumped");
if (rv >= NSIGNAL || signame[rv])
prs("\n");
rv = -1;
} else
rv = WAITVAL(s);
}
} while (pid != lastpid);
heedint = oheedint;
if (intr) {
if (interactive) {
if (canintr)
intr = 0;
} else {
Run msh through indent
2004-08-05 00:46:54 +05:30
if (exstat == 0)
exstat = rv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
onintr(0);
}
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return rv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int setstatus(int s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
exstat = s;
setval(lookup("?"), putn(s));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return s;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* PATH-searching interface to execve.
* If getenv("PATH") were kept up-to-date,
* execvp might be used.
*/
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static const char *rexecve(char *c, char **v, char **envp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *sp;
char *tp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int eacces = 0, asis = 0;
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
char *name = c;
Run msh through indent
2004-08-05 00:46:54 +05:30
Make a warning go away when standalone shell is disabled.
2006-08-11 03:16:43 +05:30
if (ENABLE_FEATURE_SH_STANDALONE_SHELL) {
optind = 1;
if (find_applet_by_name(name)) {
/* We have to exec here since we vforked. Running
* run_applet_by_name() won't work and bad things
* will happen. */
execve(CONFIG_BUSYBOX_EXEC_PATH, v, envp);
}
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
}
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("REXECVE: c=%p, v=%p, envp=%p\n", c, v, envp));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
sp = any('/', c) ? "" : path->value;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
asis = (*sp == '\0');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (asis || *sp != '\0') {
asis = 0;
tp = e.linep;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
for (; *sp != '\0'; tp++) {
*tp = *sp++;
if (*tp == ':') {
asis = (*sp == '\0');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (tp != e.linep)
*tp++ = '/';
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; (*tp++ = c[i++]) != '\0';);
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("REXECVE: e.linep is %s\n", e.linep));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
execve(e.linep, v, envp);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
switch (errno) {
case ENOEXEC:
*v = e.linep;
tp = *--v;
*v = e.linep;
move all "-/bin/sh" "/bin/sh" and "sh" to libbb/messages.c file as one constant. Vodz last_patch_107
2003-09-02 08:06:18 +05:30
execve(DEFAULT_SHELL, v, envp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*v = tp;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return "no Shell";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case ENOMEM:
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return (char *) bb_msg_memory_exhausted;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case E2BIG:
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return "argument list too long";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case EACCES:
eacces++;
break;
}
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return errno == ENOENT ? "not found" : "cannot execute";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Run the command produced by generator `f'
* applied to stream `arg'.
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static int run(struct ioarg *argp, int (*f) (struct ioarg *))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
struct op *otree;
struct wdblock *swdlist;
struct wdblock *siolist;
jmp_buf ev, rt;
xint *ofail;
int rv;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &rv;
#endif
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("RUN: enter, areanum %d, outtree %p, failpt %p\n",
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
areanum, outtree, failpt));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
areanum++;
swdlist = wdlist;
siolist = iolist;
otree = outtree;
ofail = failpt;
rv = -1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
errpt = ev;
if (newenv(setjmp(errpt)) == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wdlist = 0;
iolist = 0;
pushio(argp, f);
e.iobase = e.iop;
yynerrs = 0;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
failpt = rt;
if (setjmp(failpt) == 0 && yyparse() == 0)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
rv = execute(outtree, NOPIPE, NOPIPE, 0);
quitenv();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
} else {
DBGPRINTF(("RUN: error from newenv()!\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wdlist = swdlist;
iolist = siolist;
failpt = ofail;
outtree = otree;
freearea(areanum--);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return rv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/* -------- do.c -------- */
/*
* built-in commands: doX
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static int dohelp(struct op *t)
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
{
int col;
const struct builtincmd *x;
random tiny size savings
2006-12-24 20:53:28 +05:30
puts("\nBuilt-in commands:\n"
"-------------------");
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
for (col = 0, x = builtincmds; x->builtinfunc != NULL; x++) {
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
if (!x->name)
continue;
col += printf("%s%s", ((col == 0) ? "\t" : " "), x->name);
if (col > 60) {
silly size savings and capitalization fixes
2006-10-26 06:07:00 +05:30
puts("");
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
col = 0;
}
}
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_SH_STANDALONE_SHELL
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
{
int i;
const struct BB_applet *applet;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0, applet = applets; i < NUM_APPLETS; applet++, i++) {
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
if (!applet->name)
continue;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
col += printf("%s%s", ((col == 0) ? "\t" : " "), applet->name);
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
if (col > 60) {
silly size savings and capitalization fixes
2006-10-26 06:07:00 +05:30
puts("");
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
col = 0;
}
}
}
#endif
random tiny size savings
2006-12-24 20:53:28 +05:30
puts("\n");
Add in a shell tagline (per lash/hush behavior) to make it easier to know which shell is in use. Add in 'help' to list available builtins, and fixup msh so it can do STANDALONE_SHELL. -Erik
2001-07-07 05:35:55 +05:30
return EXIT_SUCCESS;
}
Run msh through indent
2004-08-05 00:46:54 +05:30
static int dolabel(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int dochdir(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp, *er;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = t->words[1];
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (cp == NULL) {
cp = homedir->value;
msh: fix my buglet
2007-02-09 23:00:14 +05:30
if (cp != NULL)
goto do_cd;
er = ": no home directory";
} else {
do_cd:
if (chdir(cp) >= 0)
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
er = ": bad directory";
msh: fix my buglet
2007-02-09 23:00:14 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(cp != NULL ? cp : "cd");
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
err(er);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int doshift(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int n;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
n = t->words[1] ? getn(t->words[1]) : 1;
if (dolc < n) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
err("nothing to shift");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
dolv[n] = dolv[0];
dolv += n;
dolc -= n;
setval(lookup("#"), putn(dolc));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* execute login and newgrp directly
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int dologin(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (interactive) {
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
}
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
cp = rexecve(t->words[0], t->words, makenv(0, NULL));
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(t->words[0]);
prs(": ");
err(cp);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int doumask(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i, n;
char *cp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = t->words[1];
if (cp == NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = umask(0);
umask(i);
Run msh through indent
2004-08-05 00:46:54 +05:30
for (n = 3 * 4; (n -= 3) >= 0;)
putc('0' + ((i >> n) & 07), stderr);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
putc('\n', stderr);
} else {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
/* huh??? '8','9' are not allowed! */
Run msh through indent
2004-08-05 00:46:54 +05:30
for (n = 0; *cp >= '0' && *cp <= '9'; cp++)
n = n * 8 + (*cp - '0');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
umask(n);
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int doexec(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
jmp_buf ex;
xint *ofail;
t->ioact = NULL;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; (t->words[i] = t->words[i + 1]) != NULL; i++);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (i == 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
execflg = 1;
ofail = failpt;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
failpt = ex;
if (setjmp(failpt) == 0)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
execute(t, NOPIPE, NOPIPE, FEXEC);
failpt = ofail;
execflg = 0;
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int dodot(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *sp;
char *tp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
char *cp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
int maltmp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("DODOT: enter, t=%p, tleft %p, tright %p, e.linep is %s\n", t, t->left, t->right, ((e.linep == NULL) ? "NULL" : e.linep)));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = t->words[1];
if (cp == NULL) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("DODOT: bad args, ret 0\n"));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
DBGPRINTF(("DODOT: cp is %s\n", cp));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
sp = any('/', cp) ? ":" : path->value;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF(("DODOT: sp is %s, e.linep is %s\n",
((sp == NULL) ? "NULL" : sp),
((e.linep == NULL) ? "NULL" : e.linep)));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (*sp) {
tp = e.linep;
while (*sp && (*tp = *sp++) != ':')
tp++;
if (tp != e.linep)
*tp++ = '/';
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; (*tp++ = cp[i++]) != '\0';);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* Original code */
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
i = open(e.linep, 0);
if (i >= 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
exstat = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
maltmp = remap(i);
DBGPRINTF(("DODOT: remap=%d, exstat=%d, e.iofd %d, i %d, e.linep is %s\n", maltmp, exstat, e.iofd, i, e.linep));
next(maltmp); /* Basically a PUSHIO */
DBGPRINTF(("DODOT: returning exstat=%d\n", exstat));
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return exstat;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
} /* while */
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
prs(cp);
err(": not found");
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int dowait(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
char *cp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = t->words[1];
if (cp != NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = getn(cp);
if (i == 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} else
i = -1;
setstatus(waitfor(i, 1));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int doread(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *cp, **wp;
int nb = 0;
int nl = 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->words[1] == NULL) {
err("Usage: read name ...");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
for (wp = t->words + 1; *wp; wp++) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
for (cp = e.linep; !nl && cp < elinep - 1; cp++) {
nb = read(0, cp, sizeof(*cp));
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (nb != sizeof(*cp))
break;
nl = (*cp == '\n');
if (nl || (wp[1] && any(*cp, ifs->value)))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
*cp = '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (nb <= 0)
break;
setval(lookup(*wp), e.linep);
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return nb <= 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int doeval(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return RUN(awordlist, t->words + 1, wdchar);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int dotrap(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int n, i;
int resetsig;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (t->words[1] == NULL) {
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i <= _NSIG; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (trap[i]) {
prn(i);
prs(": ");
prs(trap[i]);
prs("\n");
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
resetsig = isdigit(*t->words[1]);
for (i = resetsig ? 1 : 2; t->words[i] != NULL; ++i) {
n = getsig(t->words[i]);
freecell(trap[n]);
trap[n] = 0;
if (!resetsig) {
if (*t->words[1] != '\0') {
trap[n] = strsave(t->words[1], 0);
setsig(n, sig);
} else
setsig(n, SIG_IGN);
} else {
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
if (interactive) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (n == SIGINT)
setsig(n, onintr);
else
Run msh through indent
2004-08-05 00:46:54 +05:30
setsig(n, n == SIGQUIT ? SIG_IGN : SIG_DFL);
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
} else
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
setsig(n, SIG_DFL);
}
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int getsig(char *s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int n;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
n = getn(s);
if (n < 0 || n > _NSIG) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
err("trap: bad signal number");
n = 0;
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return n;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void setsig(int n, sighandler_t f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
if (n == 0)
return;
if (signal(n, SIG_IGN) != SIG_IGN || ourtrap[n]) {
ourtrap[n] = 1;
signal(n, f);
}
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int getn(char *as)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *s;
int n, m;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
s = as;
m = 1;
if (*s == '-') {
m = -1;
s++;
}
for (n = 0; isdigit(*s); s++)
Run msh through indent
2004-08-05 00:46:54 +05:30
n = (n * 10) + (*s - '0');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*s) {
prs(as);
err(": bad number");
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return n * m;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int dobreak(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return brkcontin(t->words[1], 1);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int docontinue(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return brkcontin(t->words[1], 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int brkcontin(char *cp, int val)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct brkcon *bc;
int nl;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
nl = cp == NULL ? 1 : getn(cp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (nl <= 0)
nl = 999;
do {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
bc = brklist;
if (bc == NULL)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
brklist = bc->nextlev;
} while (--nl);
if (nl) {
err("bad break/continue level");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
isbreak = val;
longjmp(bc->brkpt, 1);
/* NOTREACHED */
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int doexit(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *cp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
execflg = 0;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
cp = t->words[1];
if (cp != NULL)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
setstatus(getn(cp));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("DOEXIT: calling leave(), t=%p\n", t));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
leave();
/* NOTREACHED */
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int doexport(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Run msh through indent
2004-08-05 00:46:54 +05:30
rdexp(t->words + 1, export, EXPORT);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int doreadonly(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Run msh through indent
2004-08-05 00:46:54 +05:30
rdexp(t->words + 1, ronly, RONLY);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
static void rdexp(char **wp, void (*f) (struct var *), int key)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF6(("RDEXP: enter, wp=%p, func=%p, key=%d\n", wp, f, key));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF6(("RDEXP: *wp=%s\n", *wp));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*wp != NULL) {
Allow assignments in the export and readonly commands.
2001-07-13 01:09:59 +05:30
for (; *wp != NULL; wp++) {
if (isassign(*wp)) {
char *cp;
Run msh through indent
2004-08-05 00:46:54 +05:30
Allow assignments in the export and readonly commands.
2001-07-13 01:09:59 +05:30
assign(*wp, COPYV);
Run msh through indent
2004-08-05 00:46:54 +05:30
for (cp = *wp; *cp != '='; cp++);
Allow assignments in the export and readonly commands.
2001-07-13 01:09:59 +05:30
*cp = '\0';
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (checkname(*wp))
Run msh through indent
2004-08-05 00:46:54 +05:30
(*f) (lookup(*wp));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
else
badid(*wp);
Allow assignments in the export and readonly commands.
2001-07-13 01:09:59 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} else
putvlist(key, 1);
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void badid(char *s)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
prs(s);
err(": bad identifier");
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int doset(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct var *vp;
char *cp;
int n;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
cp = t->words[1];
if (cp == NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (vp = vlist; vp; vp = vp->next)
varput(vp->name, 1);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (*cp == '-') {
/* bad: t->words++; */
Run msh through indent
2004-08-05 00:46:54 +05:30
for (n = 0; (t->words[n] = t->words[n + 1]) != NULL; n++);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*++cp == 0)
flag['x'] = flag['v'] = 0;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
else {
for (; *cp; cp++) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
switch (*cp) {
case 'e':
if (!interactive)
flag['e']++;
break;
default:
Run msh through indent
2004-08-05 00:46:54 +05:30
if (*cp >= 'a' && *cp <= 'z')
flag[(int) *cp]++;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
break;
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
setdash();
}
if (t->words[1]) {
t->words[0] = dolv[0];
Run msh through indent
2004-08-05 00:46:54 +05:30
for (n = 1; t->words[n]; n++)
setarea((char *) t->words[n], 0);
dolc = n - 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
dolv = t->words;
setval(lookup("#"), putn(dolc));
Run msh through indent
2004-08-05 00:46:54 +05:30
setarea((char *) (dolv - 1), 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void varput(char *s, int out)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Add support for underscores in variable names.
2001-08-06 19:44:18 +05:30
if (isalnum(*s) || *s == '_') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
write(out, s, strlen(s));
write(out, "\n", 1);
}
}
/*
* Copyright (c) 1999 Herbert Xu <herbert@debian.org>
* This file contains code for the times builtin.
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static int dotimes(struct op *t)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
struct tms buf;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
long clk_tck = sysconf(_SC_CLK_TCK);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
times(&buf);
printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
Run msh through indent
2004-08-05 00:46:54 +05:30
(int) (buf.tms_utime / clk_tck / 60),
((double) buf.tms_utime) / clk_tck,
(int) (buf.tms_stime / clk_tck / 60),
((double) buf.tms_stime) / clk_tck,
(int) (buf.tms_cutime / clk_tck / 60),
((double) buf.tms_cutime) / clk_tck,
(int) (buf.tms_cstime / clk_tck / 60),
((double) buf.tms_cstime) / clk_tck);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
return 0;
}
/* -------- eval.c -------- */
/*
* ${}
* `command`
* blank interpretation
* quoting
* glob
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static char **eval(char **ap, int f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
struct wdblock *wb;
char **wp;
char **wf;
jmp_buf ev;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &wp;
(void) &ap;
#endif
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF4(("EVAL: enter, f=%d\n", f));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wp = NULL;
wb = NULL;
wf = NULL;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
errpt = ev;
if (newenv(setjmp(errpt)) == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (*ap && isassign(*ap))
expand(*ap++, &wb, f & ~DOGLOB);
if (flag['k']) {
for (wf = ap; *wf; wf++) {
if (isassign(*wf))
expand(*wf, &wb, f & ~DOGLOB);
}
}
Run msh through indent
2004-08-05 00:46:54 +05:30
for (wb = addword((char *) 0, wb); *ap; ap++) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (!flag['k'] || !isassign(*ap))
expand(*ap, &wb, f & ~DOKEY);
}
Run msh through indent
2004-08-05 00:46:54 +05:30
wb = addword((char *) 0, wb);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wp = getwords(wb);
quitenv();
} else
gflg = 1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return gflg ? (char **) NULL : wp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* Make the exported environment from the exported
* names in the dictionary. Keyword assignments
* will already have been done.
*/
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
static char **makenv(int all, struct wdblock *wb)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct var *vp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF5(("MAKENV: enter, all=%d\n", all));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (vp = vlist; vp; vp = vp->next)
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (all || vp->status & EXPORT)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wb = addword(vp->name, wb);
Run msh through indent
2004-08-05 00:46:54 +05:30
wb = addword((char *) 0, wb);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return getwords(wb);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static int expand(const char *cp, struct wdblock **wbp, int f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
jmp_buf ev;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
char *xp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &cp;
#endif
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("EXPAND: enter, f=%d\n", f));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
gflg = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (cp == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
if (!anys("$`'\"", cp) && !anys(ifs->value, cp)
&& ((f & DOGLOB) == 0 || !anys("[*?", cp))
) {
xp = strsave(cp, areanum);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (f & DOTRIM)
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
unquote(xp);
*wbp = addword(xp, *wbp);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
errpt = ev;
if (newenv(setjmp(errpt)) == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
PUSHIO(aword, cp, strchar);
e.iobase = e.iop;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
while ((xp = blank(f)) && gflg == 0) {
e.linep = xp;
xp = strsave(xp, areanum);
Run msh through indent
2004-08-05 00:46:54 +05:30
if ((f & DOGLOB) == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (f & DOTRIM)
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
unquote(xp);
*wbp = addword(xp, *wbp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} else
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
*wbp = glob(xp, *wbp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
quitenv();
} else
gflg = 1;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return gflg == 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static char *evalstr(char *cp, int f)
{
struct wdblock *wb;
DBGPRINTF6(("EVALSTR: enter, cp=%p, f=%d\n", cp, f));
wb = NULL;
if (expand(cp, &wb, f)) {
if (wb == NULL || wb->w_nword == 0
|| (cp = wb->w_words[0]) == NULL
) {
// TODO: I suspect that
// char *evalstr(char *cp, int f) is actually
// const char *evalstr(const char *cp, int f)!
cp = (char*)"";
}
DELETE(wb);
} else
cp = NULL;
return cp;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* Blank interpretation and quoting
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static char *blank(int f)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c, c1;
char *sp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int scanequals, foundequals;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("BLANK: enter, f=%d\n", f));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
sp = e.linep;
scanequals = f & DOKEY;
foundequals = 0;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
loop:
c = subgetc('"', foundequals);
switch (c) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
case 0:
if (sp == e.linep)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*e.linep++ = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return sp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
default:
if (f & DOBLANK && any(c, ifs->value))
goto loop;
break;
case '"':
case '\'':
scanequals = 0;
if (INSUB())
break;
for (c1 = c; (c = subgetc(c1, 1)) != c1;) {
if (c == 0)
break;
if (c == '\'' || !any(c, "$`\""))
c |= QUOTE;
*e.linep++ = c;
}
c = 0;
}
unget(c);
Add support for underscores in variable names.
2001-08-06 19:44:18 +05:30
if (!isalpha(c) && c != '_')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
scanequals = 0;
for (;;) {
c = subgetc('"', foundequals);
if (c == 0 ||
Run msh through indent
2004-08-05 00:46:54 +05:30
f & (DOBLANK && any(c, ifs->value)) ||
(!INSUB() && any(c, "\"'"))) {
scanequals = 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
unget(c);
if (any(c, "\"'"))
goto loop;
break;
}
if (scanequals) {
if (c == '=') {
foundequals = 1;
Run msh through indent
2004-08-05 00:46:54 +05:30
scanequals = 0;
} else if (!isalnum(c) && c != '_')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
scanequals = 0;
}
*e.linep++ = c;
}
*e.linep++ = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return sp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Get characters, substituting for ` and $
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int subgetc(char ec, int quoted)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("SUBGETC: enter, quoted=%d\n", quoted));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
again:
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = my_getc(ec);
if (!INSUB() && ec != '\'') {
if (c == '`') {
if (grave(quoted) == 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->task = XGRAVE;
goto again;
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (c == '$') {
c = dollar(quoted);
if (c == 0) {
e.iop->task = XDOLL;
goto again;
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Prepare to generate the string returned by ${} substitution.
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int dollar(int quoted)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
int otask;
struct io *oiop;
char *dolp;
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *s, c, *cp = NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct var *vp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF3(("DOLLAR: enter, quoted=%d\n", quoted));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = readc();
s = e.linep;
if (c != '{') {
*e.linep++ = c;
Add support for underscores in variable names.
2001-08-06 19:44:18 +05:30
if (isalpha(c) || c == '_') {
Run msh through indent
2004-08-05 00:46:54 +05:30
while ((c = readc()) != 0 && (isalnum(c) || c == '_'))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (e.linep < elinep)
*e.linep++ = c;
unget(c);
}
c = 0;
} else {
oiop = e.iop;
otask = e.iop->task;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->task = XOTHER;
Run msh through indent
2004-08-05 00:46:54 +05:30
while ((c = subgetc('"', 0)) != 0 && c != '}' && c != '\n')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (e.linep < elinep)
*e.linep++ = c;
if (oiop == e.iop)
e.iop->task = otask;
if (c != '}') {
err("unclosed ${");
gflg++;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
if (e.linep >= elinep) {
err("string in ${} too long");
gflg++;
e.linep -= 10;
}
*e.linep = 0;
if (*s)
Run msh through indent
2004-08-05 00:46:54 +05:30
for (cp = s + 1; *cp; cp++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (any(*cp, "=-+?")) {
c = *cp;
*cp++ = 0;
break;
}
if (s[1] == 0 && (*s == '*' || *s == '@')) {
if (dolc > 1) {
/* currently this does not distinguish $* and $@ */
/* should check dollar */
e.linep = s;
Run msh through indent
2004-08-05 00:46:54 +05:30
PUSHIO(awordlist, dolv + 1, dolchar);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Run msh through indent
2004-08-05 00:46:54 +05:30
} else { /* trap the nasty ${=} */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
s[0] = '1';
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
s[1] = '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
vp = lookup(s);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
dolp = vp->value;
if (dolp == null) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
switch (c) {
case '=':
if (isdigit(*s)) {
err("cannot use ${...=...} with $n");
gflg++;
break;
}
setval(vp, cp);
dolp = vp->value;
break;
case '-':
dolp = strsave(cp, areanum);
break;
case '?':
if (*cp == 0) {
prs("missing value for ");
err(s);
} else
err(cp);
gflg++;
break;
}
} else if (c == '+')
dolp = strsave(cp, areanum);
if (flag['u'] && dolp == null) {
prs("unset variable: ");
err(s);
gflg++;
}
e.linep = s;
PUSHIO(aword, dolp, quoted ? qstrchar : strchar);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Run the command in `...` and read its output.
*/
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int grave(int quoted)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *cp;
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
int j;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int pf[2];
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
static char child_cmd[LINELIM];
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
const char *src;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
char *dest;
int count;
int ignore;
int ignore_once;
char *argument_list[4];
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
struct wdblock *wb = NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &cp;
#endif
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
for (cp = e.iop->argp->aword; *cp != '`'; cp++) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*cp == 0) {
err("no closing `");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
}
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
/* string copy with dollar expansion */
src = e.iop->argp->aword;
dest = child_cmd;
count = 0;
ignore = 0;
ignore_once = 0;
while ((*src != '`') && (count < LINELIM)) {
if (*src == '\'')
ignore = !ignore;
if (*src == '\\')
ignore_once = 1;
if (*src == '$' && !ignore && !ignore_once) {
struct var *vp;
char var_name[LINELIM];
char alt_value[LINELIM];
int var_index = 0;
int alt_index = 0;
char operator = 0;
int braces = 0;
char *value;
src++;
if (*src == '{') {
braces = 1;
src++;
}
var_name[var_index++] = *src++;
applyinf fix for: 0000155: variable expansion with braces in backticks in msh
2005-07-21 00:03:12 +05:30
while (isalnum(*src) || *src=='_')
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
var_name[var_index++] = *src++;
var_name[var_index] = 0;
if (braces) {
switch (*src) {
case '}':
break;
case '-':
case '=':
case '+':
case '?':
Run msh through indent
2004-08-05 00:46:54 +05:30
operator = * src;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
break;
default:
err("unclosed ${\n");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
}
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
if (operator) {
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
src++;
while (*src && (*src != '}')) {
alt_value[alt_index++] = *src++;
}
alt_value[alt_index] = 0;
if (*src != '}') {
err("unclosed ${\n");
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
}
}
src++;
}
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
if (isalpha(*var_name)) {
/* let subshell handle it instead */
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
char *namep = var_name;
*dest++ = '$';
if (braces)
*dest++ = '{';
while (*namep)
*dest++ = *namep++;
if (operator) {
char *altp = alt_value;
*dest++ = operator;
while (*altp)
*dest++ = *altp++;
}
if (braces)
*dest++ = '}';
wb = addword(lookup(var_name)->name, wb);
} else {
/* expand */
vp = lookup(var_name);
if (vp->value != null)
value = (operator == '+') ?
alt_value : vp->value;
else if (operator == '?') {
err(alt_value);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
} else if (alt_index && (operator != '+')) {
value = alt_value;
if (operator == '=')
setval(vp, value);
} else
continue;
while (*value && (count < LINELIM)) {
*dest++ = *value++;
count++;
}
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
}
} else {
*dest++ = *src++;
count++;
ignore_once = 0;
}
}
*dest = '\0';
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (openpipe(pf) < 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
while ((i = vfork()) == -1 && errno == EAGAIN);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF3(("GRAVE: i is %p\n", io));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
if (i < 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
closepipe(pf);
Run msh through indent
2004-08-05 00:46:54 +05:30
err((char *) bb_msg_memory_exhausted);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (i != 0) {
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
waitpid(i, NULL, 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->argp->aword = ++cp;
close(pf[1]);
Run msh through indent
2004-08-05 00:46:54 +05:30
PUSHIO(afile, remap(pf[0]),
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
(int (*)(struct ioarg *)) ((quoted) ? qgravechar : gravechar));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/* allow trapped signals */
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
/* XXX - Maybe this signal stuff should go as well? */
Run msh through indent
2004-08-05 00:46:54 +05:30
for (j = 0; j <= _NSIG; j++)
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
if (ourtrap[j] && signal(j, SIG_IGN) != SIG_IGN)
signal(j, SIG_DFL);
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
dup2(pf[1], 1);
closepipe(pf);
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
argument_list[0] = (char *) DEFAULT_SHELL;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
argument_list[1] = (char *) "-c";
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
argument_list[2] = child_cmd;
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
argument_list[3] = NULL;
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
Jonas Holmberg from axis dot com writes: This patch makes msh handle variable expansion within backticks more correctly. Current behaviour (wrong): -------------------------- BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` hello $ New behaviour (correct): ------------------------ BusyBox v1.00-rc3 (2004.08.26-11:51+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. $ A='`echo hello`' $ echo $A `echo hello` $ echo `echo $A` `echo hello` $ The current behaviour (wrong according to standards) was actually my fault. msh handles backticks by executing a subshell (which makes it work on MMU-less systems). Executing a subshell makes it hard to only expand variables once in the parent. Therefore I export all variables that will be expanded within the backticks and let the subshell handle the expansion instead. The bug was found while searching for security leaks in CGI-scripts. Current behaviour of msh makes it easy to expand backticks by mistake in $QUERY_STRING. I recommend appling the patch before release of bb 1.00. /Jonas
2004-09-03 04:43:10 +05:30
cp = rexecve(argument_list[0], argument_list, makenv(1, wb));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
prs(argument_list[0]);
prs(": ");
err(cp);
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
_exit(1);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static char *unquote(char *as)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *s;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
s = as;
if (s != NULL)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
while (*s)
*s++ &= ~QUOTE;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return as;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/* -------- glob.c -------- */
/*
* glob
*/
#define scopy(x) strsave((x), areanum)
#define BLKSIZ 512
#define NDENT ((BLKSIZ+sizeof(struct dirent)-1)/sizeof(struct dirent))
Run msh through indent
2004-08-05 00:46:54 +05:30
static struct wdblock *cl, *nl;
static char spcl[] = "[?*";
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct wdblock *glob(char *cp, struct wdblock *wb)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
char *pp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (cp == 0)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = 0;
for (pp = cp; *pp; pp++)
if (any(*pp, spcl))
i++;
else if (!any(*pp & ~QUOTE, spcl))
*pp &= ~QUOTE;
if (i != 0) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
for (cl = addword(scopy(cp), NULL); anyspcl(cl); cl = nl) {
Run msh through indent
2004-08-05 00:46:54 +05:30
nl = newword(cl->w_nword * 2);
for (i = 0; i < cl->w_nword; i++) { /* for each argument */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (pp = cl->w_words[i]; *pp; pp++)
if (any(*pp, spcl)) {
globname(cl->w_words[i], pp);
break;
}
if (*pp == '\0')
nl = addword(scopy(cl->w_words[i]), nl);
}
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < cl->w_nword; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
DELETE(cl->w_words[i]);
DELETE(cl);
}
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < cl->w_nword; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
unquote(cl->w_words[i]);
Run msh through indent
2004-08-05 00:46:54 +05:30
glob0((char *) cl->w_words, cl->w_nword, sizeof(char *), xstrcmp);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (cl->w_nword) {
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < cl->w_nword; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wb = addword(cl->w_words[i], wb);
DELETE(cl);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
wb = addword(unquote(cp), wb);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void globname(char *we, char *pp)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *np, *cp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
char *name, *gp, *dp;
int k;
DIR *dirp;
struct dirent *de;
Run msh through indent
2004-08-05 00:46:54 +05:30
char dname[NAME_MAX + 1];
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
struct stat dbuf;
for (np = we; np != pp; pp--)
if (pp[-1] == '/')
break;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (dp = cp = space((int) (pp - np) + 3); np < pp;)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*cp++ = *np++;
*cp++ = '.';
*cp = '\0';
Run msh through indent
2004-08-05 00:46:54 +05:30
for (gp = cp = space(strlen(pp) + 1); *np && *np != '/';)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*cp++ = *np++;
*cp = '\0';
dirp = opendir(dp);
if (dirp == 0) {
DELETE(dp);
DELETE(gp);
return;
}
dname[NAME_MAX] = '\0';
Run msh through indent
2004-08-05 00:46:54 +05:30
while ((de = readdir(dirp)) != NULL) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* XXX Hmmm... What this could be? (abial) */
/*
Run msh through indent
2004-08-05 00:46:54 +05:30
if (ent[j].d_ino == 0)
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
continue;
Run msh through indent
2004-08-05 00:46:54 +05:30
*/
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
strncpy(dname, de->d_name, NAME_MAX);
Run msh through indent
2004-08-05 00:46:54 +05:30
if (dname[0] == '.')
if (*gp != '.')
continue;
for (k = 0; k < NAME_MAX; k++)
if (any(dname[k], spcl))
dname[k] |= QUOTE;
if (gmatch(dname, gp)) {
name = generate(we, pp, dname, np);
if (*np && !anys(np, spcl)) {
if (stat(name, &dbuf)) {
DELETE(name);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
continue;
}
}
Run msh through indent
2004-08-05 00:46:54 +05:30
nl = addword(name, nl);
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
closedir(dirp);
DELETE(dp);
DELETE(gp);
}
/*
* generate a pathname as below.
* start..end1 / middle end
* the slashes come for free
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static char *generate(char *start1, char *end1, char *middle, char *end)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
char *p;
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *op, *xp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
p = op = space((int)(end1 - start1) + strlen(middle) + strlen(end) + 2);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (xp = start1; xp != end1;)
*op++ = *xp++;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (xp = middle; (*op++ = *xp++) != '\0';);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
op--;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (xp = end; (*op++ = *xp++) != '\0';);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return p;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int anyspcl(struct wdblock *wb)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
char **wd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wd = wb->w_words;
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < wb->w_nword; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (anys(spcl, *wd++))
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 1;
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int xstrcmp(char *p1, char *p2)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return strcmp(*(char **) p1, *(char **) p2);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- word.c -------- */
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static struct wdblock *newword(int nw)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct wdblock *wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
wb = (struct wdblock *) space(sizeof(*wb) + nw * sizeof(char *));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wb->w_bsize = nw;
wb->w_nword = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static struct wdblock *addword(char *wd, struct wdblock *wb)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct wdblock *wb2;
int nw;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (wb == NULL)
wb = newword(NSTART);
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
nw = wb->w_nword;
if (nw >= wb->w_bsize) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wb2 = newword(nw * 2);
Run msh through indent
2004-08-05 00:46:54 +05:30
memcpy((char *) wb2->w_words, (char *) wb->w_words,
nw * sizeof(char *));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
wb2->w_nword = nw;
DELETE(wb);
wb = wb2;
}
wb->w_words[wb->w_nword++] = wd;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
static
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char **getwords(struct wdblock *wb)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char **wd;
int nb;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (wb == NULL)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (wb->w_nword == 0) {
DELETE(wb);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
wd = (char **) space(nb = sizeof(*wd) * wb->w_nword);
Run msh through indent
2004-08-05 00:46:54 +05:30
memcpy((char *) wd, (char *) wb->w_words, nb);
DELETE(wb); /* perhaps should done by caller */
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return wd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Reduce exported from msh applet
2005-09-22 20:08:17 +05:30
static int (*func) (char *, char *);
static int globv;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static void glob3(char *i, char *j, char *k)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
char *index1, *index2, *index3;
int c;
int m;
m = globv;
index1 = i;
index2 = j;
index3 = k;
do {
c = *index1;
*index1++ = *index3;
*index3++ = *index2;
*index2++ = c;
} while (--m);
}
static void glob2(char *i, char *j)
{
char *index1, *index2, c;
int m;
m = globv;
index1 = i;
index2 = j;
do {
c = *index1;
*index1++ = *index2;
*index2++ = c;
} while (--m);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void glob1(char *base, char *lim)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *i, *j;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int v2;
char *lptr, *hptr;
int c;
unsigned n;
v2 = globv;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
top:
n = (int) (lim - base);
if (n <= v2)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
return;
Run msh through indent
2004-08-05 00:46:54 +05:30
n = v2 * (n / (2 * v2));
hptr = lptr = base + n;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
i = base;
Run msh through indent
2004-08-05 00:46:54 +05:30
j = lim - v2;
for (;;) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (i < lptr) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = (*func) (i, lptr);
if (c == 0) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
lptr -= v2;
glob2(i, lptr);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
continue;
}
if (c < 0) {
i += v2;
continue;
}
}
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
begin:
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (j > hptr) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = (*func) (hptr, j);
if (c == 0) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
hptr += v2;
glob2(hptr, j);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
goto begin;
}
if (c > 0) {
if (i == lptr) {
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
hptr += v2;
glob3(i, hptr, j);
i = (lptr += v2);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
goto begin;
}
glob2(i, j);
j -= v2;
i += v2;
continue;
}
j -= v2;
goto begin;
}
if (i == lptr) {
Run msh through indent
2004-08-05 00:46:54 +05:30
if (lptr - base >= lim - hptr) {
glob1(hptr + v2, lim);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
lim = lptr;
} else {
glob1(base, lptr);
Run msh through indent
2004-08-05 00:46:54 +05:30
base = hptr + v2;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
goto top;
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
lptr -= v2;
glob3(j, lptr, i);
j = (hptr -= v2);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
static void glob0(char *a0, unsigned a1, int a2, int (*a3) (char *, char *))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
func = a3;
globv = a2;
glob1(a0, a0 + a1 * a2);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/* -------- io.c -------- */
/*
* shell IO
*/
Run msh through indent
2004-08-05 00:46:54 +05:30
static int my_getc(int ec)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
if (e.linep > elinep) {
while ((c = readc()) != '\n' && c);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
err("input line too long");
gflg++;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
c = readc();
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
if ((ec != '\'') && (ec != '`') && (e.iop->task != XGRAVE)) {
Run msh through indent
2004-08-05 00:46:54 +05:30
if (c == '\\') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = readc();
if (c == '\n' && ec != '\"')
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return my_getc(ec);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c |= QUOTE;
}
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void unget(int c)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
if (e.iop >= e.iobase)
e.iop->peekc = c;
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int eofc(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Run msh through indent
2004-08-05 00:46:54 +05:30
return e.iop < e.iobase || (e.iop->peekc == 0 && e.iop->prev == 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int readc(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
RCPRINTF(("READC: e.iop %p, e.iobase %p\n", e.iop, e.iobase));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
for (; e.iop >= e.iobase; e.iop--) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
RCPRINTF(("READC: e.iop %p, peekc 0x%x\n", e.iop, e.iop->peekc));
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = e.iop->peekc;
if (c != '\0') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->peekc = 0;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
if (e.iop->prev != 0) {
c = (*e.iop->iofn)(e.iop->argp, e.iop);
if (c != '\0') {
if (c == -1) {
e.iop++;
continue;
Run msh through indent
2004-08-05 00:46:54 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (e.iop == iostack)
ioecho(c);
e.iop->prev = c;
return e.iop->prev;
Run msh through indent
2004-08-05 00:46:54 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (e.iop->task == XIO && e.iop->prev != '\n') {
e.iop->prev = 0;
if (e.iop == iostack)
ioecho('\n');
return '\n';
}
}
if (e.iop->task == XIO) {
if (multiline) {
e.iop->prev = 0;
return e.iop->prev;
}
if (interactive && e.iop == iostack + 1) {
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
current_prompt = prompt->value;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#else
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
prs(prompt->value);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#endif
}
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
} /* FOR */
if (e.iop >= iostack) {
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
RCPRINTF(("READC: return 0, e.iop %p\n", e.iop));
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
}
DBGPRINTF(("READC: leave()...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
leave();
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* NOTREACHED */
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void ioecho(char c)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
if (flag['v'])
write(2, &c, sizeof c);
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
static void pushio(struct ioarg *argp, int (*fn) (struct ioarg *))
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("PUSHIO: argp %p, argp->afid 0x%x, e.iop %p\n", argp,
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
argp->afid, e.iop));
/* Set env ptr for io source to next array spot and check for array overflow */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (++e.iop >= &iostack[NPUSH]) {
e.iop--;
err("Shell input nested too deeply");
gflg++;
return;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
/* We did not overflow the NPUSH array spots so setup data structs */
e.iop->iofn = (int (*)(struct ioarg *, struct io *)) fn; /* Store data source func ptr */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (argp->afid != AFID_NOBUF)
Run msh through indent
2004-08-05 00:46:54 +05:30
e.iop->argp = argp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
else {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
e.iop->argp = ioargstack + (e.iop - iostack); /* MAL - index into stack */
*e.iop->argp = *argp; /* copy data from temp area into stack spot */
/* MAL - mainbuf is for 1st data source (command line?) and all nested use a single shared buffer? */
if (e.iop == &iostack[0])
e.iop->argp->afbuf = &mainbuf;
else
e.iop->argp->afbuf = &sharedbuf;
/* MAL - if not a termimal AND (commandline OR readable file) then give it a buffer id? */
/* This line appears to be active when running scripts from command line */
if ((isatty(e.iop->argp->afile) == 0)
&& (e.iop == &iostack[0]
add open_read_close() and similar stuff
2006-10-14 07:53:43 +05:30
|| lseek(e.iop->argp->afile, 0L, SEEK_CUR) != -1)) {
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (++bufid == AFID_NOBUF) /* counter rollover check, AFID_NOBUF = 11111111 */
bufid = AFID_ID; /* AFID_ID = 0 */
e.iop->argp->afid = bufid; /* assign buffer id */
Run msh through indent
2004-08-05 00:46:54 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("PUSHIO: iostack %p, e.iop %p, afbuf %p\n",
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
iostack, e.iop, e.iop->argp->afbuf));
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF(("PUSHIO: mbuf %p, sbuf %p, bid %d, e.iop %p\n",
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
&mainbuf, &sharedbuf, bufid, e.iop));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Run msh through indent
2004-08-05 00:46:54 +05:30
e.iop->prev = ~'\n';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->peekc = 0;
e.iop->xchar = 0;
e.iop->nlcount = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (fn == filechar || fn == linechar)
e.iop->task = XIO;
Run msh through indent
2004-08-05 00:46:54 +05:30
else if (fn == (int (*)(struct ioarg *)) gravechar
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
|| fn == (int (*)(struct ioarg *)) qgravechar)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iop->task = XGRAVE;
else
e.iop->task = XOTHER;
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static struct io *setbase(struct io *ip)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct io *xp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
xp = e.iobase;
e.iobase = ip;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return xp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Input generating functions
*/
/*
* Produce the characters of a string, then a newline, then EOF.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int nlchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (ap->aword == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c = *ap->aword++;
if (c == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
ap->aword = NULL;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return '\n';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Given a list of words, produce the characters
* in them, with a space after each word.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int wdchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char c;
char **wl;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
wl = ap->awordlist;
if (wl == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*wl != NULL) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = *(*wl)++;
if (c != 0)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c & 0177;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
ap->awordlist++;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return ' ';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
ap->awordlist = NULL;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return '\n';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Return the characters of a list of words,
* producing a space between them.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int dolchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
char *wp;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
wp = *ap->awordlist++;
if (wp != NULL) {
Run msh through indent
2004-08-05 00:46:54 +05:30
PUSHIO(aword, wp, *ap->awordlist == NULL ? strchar : xxchar);
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int xxchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (ap->aword == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = *ap->aword++;
if (c == '\0') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
ap->aword = NULL;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return ' ';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Produce the characters from a single word (string).
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int strchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
if (ap->aword == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
return *ap->aword++;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Produce quoted characters from a single word (string).
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int qstrchar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
stty: fix width of a field for ppc32 sort: fix -u to match coreutils 6.3 msh: compile fix (my fault)
2007-01-01 23:48:04 +05:30
if (ap->aword == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return 0;
stty: fix width of a field for ppc32 sort: fix -u to match coreutils 6.3 msh: compile fix (my fault)
2007-01-01 23:48:04 +05:30
c = *ap->aword++;
if (c)
c |= QUOTE;
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Return the characters from a file.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int filechar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
char c;
struct iobuf *bp = ap->afbuf;
if (ap->afid != AFID_NOBUF) {
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
i = (ap->afid != bp->id);
if (i || bp->bufp == bp->ebufp) {
Run msh through indent
2004-08-05 00:46:54 +05:30
if (i)
add open_read_close() and similar stuff
2006-10-14 07:53:43 +05:30
lseek(ap->afile, ap->afpos, SEEK_SET);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
i = safe_read(ap->afile, bp->buf, sizeof(bp->buf));
if (i <= 0) {
closef(ap->afile);
return 0;
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
bp->id = ap->afid;
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
bp->bufp = bp->buf;
bp->ebufp = bp->bufp + i;
Run msh through indent
2004-08-05 00:46:54 +05:30
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
ap->afpos++;
return *bp->bufp++ & 0177;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING
Patch from Jonas Holmberg, adjusted by Robert Schwebel, and later re-adjusted by me to fix msh backtick handling
2003-03-14 21:35:59 +05:30
if (interactive && isatty(ap->afile)) {
Run msh through indent
2004-08-05 00:46:54 +05:30
static char mycommand[BUFSIZ];
static int position = 0, size = 0;
while (size == 0 || position >= size) {
Convert cmdedit into more generic line input facility (make history and completion optional at runtime). Use it for fdisk, as an example. Some unrelated fixes in fdisk are also here.
2007-01-22 12:51:38 +05:30
read_line_input(current_prompt, mycommand, BUFSIZ, line_input_state);
Run msh through indent
2004-08-05 00:46:54 +05:30
size = strlen(mycommand);
position = 0;
}
c = mycommand[position];
position++;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
#endif
i = safe_read(ap->afile, &c, sizeof(c));
return i == sizeof(c) ? (c & 0x7f) : (closef(ap->afile), 0);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Return the characters from a here temp file.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int herechar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
char c;
if (read(ap->afile, &c, sizeof(c)) != sizeof(c)) {
close(ap->afile);
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
c = '\0';
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Return the characters produced by a process (`...`).
* Quote them if required, and remove any trailing newline characters.
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int gravechar(struct ioarg *ap, struct io *iop)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = qgravechar(ap, iop) & ~QUOTE;
if (c == '\n')
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
c = ' ';
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int qgravechar(struct ioarg *ap, struct io *iop)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF3(("QGRAVECHAR: enter, ap=%p, iop=%p\n", ap, iop));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (iop->xchar) {
if (iop->nlcount) {
iop->nlcount--;
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return '\n' | QUOTE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
c = iop->xchar;
iop->xchar = 0;
} else if ((c = filechar(ap)) == '\n') {
iop->nlcount = 1;
while ((c = filechar(ap)) == '\n')
iop->nlcount++;
iop->xchar = c;
if (c == 0)
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
iop->nlcount--;
c = '\n';
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c != 0 ? c | QUOTE : 0;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* Return a single command (usually the first line) from a file.
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int linechar(struct ioarg *ap)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
c = filechar(ap);
if (c == '\n') {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (!multiline) {
closef(ap->afile);
Run msh through indent
2004-08-05 00:46:54 +05:30
ap->afile = -1; /* illegal value */
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
/*
* remap fd into Shell's fd space
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int remap(int fd)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int map[NOFILE];
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
int newfd;
DBGPRINTF(("REMAP: fd=%d, e.iofd=%d\n", fd, e.iofd));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (fd < e.iofd) {
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < NOFILE; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
map[i] = 0;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
do {
map[fd] = 1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
newfd = dup(fd);
fd = newfd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
} while (fd >= 0 && fd < e.iofd);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
Run msh through indent
2004-08-05 00:46:54 +05:30
for (i = 0; i < NOFILE; i++)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (map[i])
close(i);
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (fd < 0)
err("too many files open in shell");
}
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return fd;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static int openpipe(int *pv)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
i = pipe(pv);
if (i < 0)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
err("can't create pipe - try again");
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return i;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void closepipe(int *pv)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
if (pv != NULL) {
close(*pv++);
close(*pv);
}
}
msh: cleaning up for -Wwrite-strings part #4
2007-02-01 07:13:54 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* -------- here.c -------- */
/*
* here documents
*/
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void markhere(char *s, struct ioword *iop)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct here *h, *lh;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("MARKHERE: enter, s=%p\n", s));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
h = (struct here *) space(sizeof(struct here));
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
if (h == NULL)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
return;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
h->h_tag = evalstr(s, DOSUB);
if (h->h_tag == 0)
return;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
h->h_iop = iop;
iop->io_name = 0;
h->h_next = NULL;
if (inhere == 0)
inhere = h;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
else {
for (lh = inhere; lh != NULL; lh = lh->h_next) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (lh->h_next == 0) {
lh->h_next = h;
break;
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
}
Run msh through indent
2004-08-05 00:46:54 +05:30
iop->io_flag |= IOHERE | IOXHERE;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
for (s = h->h_tag; *s; s++) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (*s & QUOTE) {
Run msh through indent
2004-08-05 00:46:54 +05:30
iop->io_flag &= ~IOXHERE;
*s &= ~QUOTE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
h->h_dosub = iop->io_flag & IOXHERE;
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void gethere(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct here *h, *hp;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("GETHERE: enter...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* Scan here files first leaving inhere list in place */
for (hp = h = inhere; h != NULL; hp = h, h = h->h_next)
Run msh through indent
2004-08-05 00:46:54 +05:30
readhere(&h->h_iop->io_name, h->h_tag, h->h_dosub ? 0 : '\'');
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/* Make inhere list active - keep list intact for scraphere */
if (hp != NULL) {
Run msh through indent
2004-08-05 00:46:54 +05:30
hp->h_next = acthere;
acthere = inhere;
inhere = NULL;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
}
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
static void readhere(char **name, char *s, int ec)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
int tf;
char tname[30] = ".msh_XXXXXX";
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int c;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
jmp_buf ev;
Run msh through indent
2004-08-05 00:46:54 +05:30
char myline[LINELIM + 1];
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
char *thenext;
use %p when printing pointers, not %x
2006-05-06 02:02:31 +05:30
DBGPRINTF7(("READHERE: enter, name=%p, s=%p\n", name, s));
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
tf = mkstemp(tname);
if (tf < 0)
return;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
*name = strsave(tname, areanum);
msh: double "static char line[LINELIM]" etc deleted. massive amounts of assignments-in-ifs deleted (some of which were VERY nasty)
2007-01-01 11:30:38 +05:30
errpt = ev;
if (newenv(setjmp(errpt)) != 0)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
unlink(tname);
else {
Run msh through indent
2004-08-05 00:46:54 +05:30
pushio(e.iop->argp, (int (*)(struct ioarg *)) e.iop->iofn);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
e.iobase = e.iop;
for (;;) {
Run msh through indent
2004-08-05 00:46:54 +05:30
if (interactive && e.iop <= iostack) {
cmdedit is not a 'command' editing anymore, it's just editing (generic), so rename stuff accordingly.
2007-01-22 14:33:07 +05:30
#if ENABLE_FEATURE_EDITING
Run msh through indent
2004-08-05 00:46:54 +05:30
current_prompt = cprompt->value;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#else
Run msh through indent
2004-08-05 00:46:54 +05:30
prs(cprompt->value);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
#endif
}
thenext = myline;
while ((c = my_getc(ec)) != '\n' && c) {
if (ec == '\'')
Run msh through indent
2004-08-05 00:46:54 +05:30
c &= ~QUOTE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (thenext >= &myline[LINELIM]) {
c = 0;
break;
}
*thenext++ = c;
}
*thenext = 0;
if (strcmp(s, myline) == 0 || c == 0)
break;
*thenext++ = '\n';
Run msh through indent
2004-08-05 00:46:54 +05:30
write(tf, myline, (int) (thenext - myline));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
if (c == 0) {
Run msh through indent
2004-08-05 00:46:54 +05:30
prs("here document `");
prs(s);
err("' unclosed");
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
quitenv();
}
close(tf);
}
/*
* open here temp file.
* if unquoted here, expand here temp file into second temp file.
*/
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static int herein(char *hname, int xdoll)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
int hf;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
int tf;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &tf;
#endif
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
if (hname == NULL)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("HEREIN: hname is %s, xdoll=%d\n", hname, xdoll));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
hf = open(hname, 0);
if (hf < 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
if (xdoll) {
char c;
char tname[30] = ".msh_XXXXXX";
jmp_buf ev;
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
tf = mkstemp(tname);
if (tf < 0)
style cleanup: return(a) -> return a, part 1
2006-11-27 22:19:31 +05:30
return -1;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
errpt = ev;
if (newenv(setjmp(errpt)) == 0) {
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
PUSHIO(afile, hf, herechar);
setbase(e.iop);
while ((c = subgetc(0, 0)) != 0) {
Run msh through indent
2004-08-05 00:46:54 +05:30
c &= ~QUOTE;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
write(tf, &c, sizeof c);
}
quitenv();
} else
unlink(tname);
close(tf);
tf = open(tname, 0);
unlink(tname);
style cleanup: return(a) -> return a, part 2
2006-11-27 22:19:55 +05:30
return tf;
msh: cleaning up for -Wwrite-strings
2007-02-01 07:09:24 +05:30
}
return hf;
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void scraphere(void)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct here *h;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF7(("SCRAPHERE: enter...\n"));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
for (h = inhere; h != NULL; h = h->h_next) {
if (h->h_iop && h->h_iop->io_name)
Run msh through indent
2004-08-05 00:46:54 +05:30
unlink(h->h_iop->io_name);
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
}
inhere = NULL;
}
/* unlink here temp files before a freearea(area) */
- convert old-style parameter declarations (K&R) to modern style.
2006-06-26 03:38:53 +05:30
static void freehere(int area)
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
{
Remove all usage of the "register" storage class specifier.
2006-07-01 18:38:46 +05:30
struct here *h, *hl;
Michael Leibow, MichaelLe at belkin.com writes: A question was posted a month ago by Mark Alamo to see if others had problems with sourcing subscripts within msh. We asked his firm to fix the msh.c bug he described because we didn't have enough time to do it ourselves. When msh.c is executing a compound statement and there is a . command to source another script file, msh.c will not execute the subscript until it's completed executing the rest of the compound statement. His example was this: Echo "Start" ; . ./subA; echo "mid" ; . ./subB ; echo "end" subA and subB execute AFTER end is printed in reverse order. The same is true if the sourced files are inside an if else fi, case esac, or any compound statement. Attached is a patch to msh.c. It fixes the problem. Cd to the root of your busybox tree and execute "patch -p1 < msh.c.patch" Unfortunately, I won't have more time to work on this so I hope that there aren't any problems! Michael Leibow Senior Software Engineer Belkin Corporation
2004-08-05 00:49:10 +05:30
DBGPRINTF6(("FREEHERE: enter, area=%d\n", area));
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
hl = NULL;
for (h = acthere; h != NULL; h = h->h_next)
if (getarea((char *) h) >= area) {
if (h->h_iop->io_name != NULL)
unlink(h->h_iop->io_name);
if (hl == NULL)
acthere = h->h_next;
else
hl->h_next = h->h_next;
} else
hl = h;
}
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
/* -------- sh.c -------- */
/*
* shell
*/
suppress warnings about easch <applet>_main() having no preceding prototype
2007-02-03 22:58:39 +05:30
int msh_main(int argc, char **argv);
msh: cleaning up for -Wwrite-strings part #2
2007-02-01 07:13:16 +05:30
int msh_main(int argc, char **argv)
{
int f;
char *s;
int cflag;
char *name, **ap;
int (*iof) (struct ioarg *);
#if ENABLE_FEATURE_EDITING
line_input_state = new_line_input_t(FOR_SHELL);
#endif
DBGPRINTF(("MSH_MAIN: argc %d, environ %p\n", argc, environ));
initarea();
ap = environ;
if (ap != NULL) {
while (*ap)
assign(*ap++, !COPYV);
for (ap = environ; *ap;)
export(lookup(*ap++));
}
closeall();
areanum = 1;
shell = lookup("SHELL");
if (shell->value == null)
setval(shell, (char *)DEFAULT_SHELL);
export(shell);
homedir = lookup("HOME");
if (homedir->value == null)
setval(homedir, "/");
export(homedir);
setval(lookup("$"), putn(getpid()));
path = lookup("PATH");
if (path->value == null) {
if (geteuid() == 0)
setval(path, "/sbin:/bin:/usr/sbin:/usr/bin");
else
setval(path, "/bin:/usr/bin");
}
export(path);
ifs = lookup("IFS");
if (ifs->value == null)
setval(ifs, " \t\n");
#ifdef MSHDEBUG
mshdbg_var = lookup("MSHDEBUG");
if (mshdbg_var->value == null)
setval(mshdbg_var, "0");
#endif
prompt = lookup("PS1");
#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
if (prompt->value == null)
#endif
setval(prompt, DEFAULT_USER_PROMPT);
if (geteuid() == 0) {
setval(prompt, DEFAULT_ROOT_PROMPT);
prompt->status &= ~EXPORT;
}
cprompt = lookup("PS2");
#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
if (cprompt->value == null)
#endif
setval(cprompt, "> ");
iof = filechar;
cflag = 0;
name = *argv++;
if (--argc >= 1) {
if (argv[0][0] == '-' && argv[0][1] != '\0') {
for (s = argv[0] + 1; *s; s++)
switch (*s) {
case 'c':
prompt->status &= ~EXPORT;
cprompt->status &= ~EXPORT;
setval(prompt, "");
setval(cprompt, "");
cflag = 1;
if (--argc > 0)
PUSHIO(aword, *++argv, iof = nlchar);
break;
case 'q':
qflag = SIG_DFL;
break;
case 's':
/* standard input */
break;
case 't':
prompt->status &= ~EXPORT;
setval(prompt, "");
iof = linechar;
break;
case 'i':
interactive++;
default:
if (*s >= 'a' && *s <= 'z')
flag[(int) *s]++;
}
} else {
argv--;
argc++;
}
if (iof == filechar && --argc > 0) {
setval(prompt, "");
setval(cprompt, "");
prompt->status &= ~EXPORT;
cprompt->status &= ~EXPORT;
/* Shell is non-interactive, activate printf-based debug */
#ifdef MSHDEBUG
mshdbg = (int) (((char) (mshdbg_var->value[0])) - '0');
if (mshdbg < 0)
mshdbg = 0;
#endif
DBGPRINTF(("MSH_MAIN: calling newfile()\n"));
name = *++argv;
if (newfile(name))
exit(1); /* Exit on error */
}
}
setdash();
/* This won't be true if PUSHIO has been called, say from newfile() above */
if (e.iop < iostack) {
PUSHIO(afile, 0, iof);
if (isatty(0) && isatty(1) && !cflag) {
interactive++;
#if !ENABLE_FEATURE_SH_EXTRA_QUIET
#ifdef MSHDEBUG
printf("\n\n%s Built-in shell (msh with debug)\n", BB_BANNER);
#else
printf("\n\n%s Built-in shell (msh)\n", BB_BANNER);
#endif
printf("Enter 'help' for a list of built-in commands.\n\n");
#endif
}
}
signal(SIGQUIT, qflag);
if (name && name[0] == '-') {
interactive++;
f = open(".profile", 0);
if (f >= 0)
next(remap(f));
f = open("/etc/profile", 0);
if (f >= 0)
next(remap(f));
}
if (interactive)
signal(SIGTERM, sig);
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, onintr);
dolv = argv;
dolc = argc;
dolv[0] = name;
if (dolc > 1) {
for (ap = ++argv; --argc > 0;) {
*ap = *argv++;
if (assign(*ap, !COPYV)) {
dolc--; /* keyword */
} else {
ap++;
}
}
}
setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
DBGPRINTF(("MSH_MAIN: begin FOR loop, interactive %d, e.iop %p, iostack %p\n", interactive, e.iop, iostack));
for (;;) {
if (interactive && e.iop <= iostack) {
#if ENABLE_FEATURE_EDITING
current_prompt = prompt->value;
#else
prs(prompt->value);
#endif
}
onecommand();
/* Ensure that getenv("PATH") stays current */
setenv("PATH", path->value, 1);
}
DBGPRINTF(("MSH_MAIN: returning.\n"));
}
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
/*
* Copyright (c) 1987,1997, Prentice Hall
* All rights reserved.
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
*
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
* Redistribution and use of the MINIX operating system in source and
* binary forms, with or without modification, are permitted provided
* that the following conditions are met:
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
*
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
*
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
* Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
*
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
* Neither the name of Prentice Hall nor the names of the software
* authors or contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
Remove trailing whitespace. Update copyright to include 2004.
2004-03-15 13:59:22 +05:30
*
This is a busybox port of the Minix shell. It is reasonably capable, handles all the basic stuff (for, case/esac, while, if/then/else), and is very small (adds just 38k on x86). It is not as rigorously correct about Bourne semantics as bash, but for most things it is quite workable. There is still some work to be done to further shrink it (it has its own globbing functions instead of using the libc ones, for example), but it is quite usable as is. -Erik
2001-06-29 10:27:14 +05:30
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
Reference in New Issue Copy Permalink