int AMXEXPORT AMXAPI amx_ProcessCleanup(AMX *amx)
{
#if defined HAVE_DYNCALL_H || defined WIN32_FFI
freelib(&ModRoot, amx, NULL);
#endif
closepipe();
return AMX_ERR_NONE;
}
/*
* execute command tree
*/
int
execute(struct op * volatile t,
/* if XEXEC don't fork */
volatile int flags,
volatile int * volatile xerrok)
{
int i;
volatile int rv = 0, dummy = 0;
int pv[2];
const char ** volatile ap = NULL;
char ** volatile up;
const char *s, *ccp;
struct ioword **iowp;
struct tbl *tp = NULL;
char *cp;
if (t == NULL)
return (0);
/* Caller doesn't care if XERROK should propagate. */
if (xerrok == NULL)
xerrok = &dummy;
if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
/* run in sub-process */
return (exchild(t, flags & ~XTIME, xerrok, -1));
newenv(E_EXEC);
if (trap)
runtraps(0);
/* we want to run an executable, do some variance checks */
if (t->type == TCOM) {
/* check if this is 'var=<<EOF' */
if (
/* we have zero arguments, i.e. no programme to run */
t->args[0] == NULL &&
/* we have exactly one variable assignment */
t->vars[0] != NULL && t->vars[1] == NULL &&
/* we have exactly one I/O redirection */
t->ioact != NULL && t->ioact[0] != NULL &&
t->ioact[1] == NULL &&
/* of type "here document" (or "here string") */
(t->ioact[0]->flag & IOTYPE) == IOHERE &&
/* the variable assignment begins with a valid varname */
(ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] &&
/* and has no right-hand side (i.e. "varname=") */
ccp[0] == CHAR && ccp[1] == '=' && ccp[2] == EOS &&
/* plus we can have a here document content */
herein(t->ioact[0], &cp) == 0 && cp && *cp) {
char *sp = cp, *dp;
size_t n = ccp - t->vars[0] + 2, z;
/* drop redirection (will be garbage collected) */
t->ioact = NULL;
/* set variable to its expanded value */
z = strlen(cp) + 1;
if (notoktomul(z, 2) || notoktoadd(z * 2, n))
internal_errorf(Toomem, (unsigned long)-1);
dp = alloc(z * 2 + n, ATEMP);
memcpy(dp, t->vars[0], n);
t->vars[0] = dp;
dp += n;
while (*sp) {
*dp++ = QCHAR;
*dp++ = *sp++;
}
*dp = EOS;
/* free the expanded value */
afree(cp, APERM);
}
/*
* Clear subst_exstat before argument expansion. Used by
* null commands (see comexec() and c_eval()) and by c_set().
*/
subst_exstat = 0;
/* for $LINENO */
current_lineno = t->lineno;
/*
* POSIX says expand command words first, then redirections,
* and assignments last..
*/
up = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
if (flags & XTIME)
/* Allow option parsing (bizarre, but POSIX) */
timex_hook(t, &up);
ap = (const char **)up;
if (Flag(FXTRACE) && ap[0]) {
shf_puts(substitute(str_val(global("PS4")), 0),
shl_out);
for (i = 0; ap[i]; i++)
shf_fprintf(shl_out, "%s%c", ap[i],
ap[i + 1] ? ' ' : '\n');
shf_flush(shl_out);
}
if (ap[0])
tp = findcom(ap[0], FC_BI|FC_FUNC);
}
flags &= ~XTIME;
if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
e->savefd = alloc2(NUFILE, sizeof(short), ATEMP);
/* initialise to not redirected */
memset(e->savefd, 0, NUFILE * sizeof(short));
}
/* mark for replacement later (unless TPIPE) */
vp_pipest->flag |= INT_L;
/* do redirection, to be restored in quitenv() */
if (t->ioact != NULL)
for (iowp = t->ioact; *iowp != NULL; iowp++) {
if (iosetup(*iowp, tp) < 0) {
exstat = rv = 1;
/*
* Redirection failures for special commands
* cause (non-interactive) shell to exit.
*/
if (tp && tp->type == CSHELL &&
(tp->flag & SPEC_BI))
errorfz();
/* Deal with FERREXIT, quitenv(), etc. */
goto Break;
}
}
switch (t->type) {
case TCOM:
rv = comexec(t, tp, (const char **)ap, flags, xerrok);
break;
case TPAREN:
rv = execute(t->left, flags | XFORK, xerrok);
break;
case TPIPE:
flags |= XFORK;
flags &= ~XEXEC;
e->savefd[0] = savefd(0);
e->savefd[1] = savefd(1);
while (t->type == TPIPE) {
openpipe(pv);
/* stdout of curr */
ksh_dup2(pv[1], 1, false);
/**
* Let exchild() close pv[0] in child
* (if this isn't done, commands like
* (: ; cat /etc/termcap) | sleep 1
* will hang forever).
*/
exchild(t->left, flags | XPIPEO | XCCLOSE,
NULL, pv[0]);
/* stdin of next */
ksh_dup2(pv[0], 0, false);
closepipe(pv);
flags |= XPIPEI;
t = t->right;
}
/* stdout of last */
restfd(1, e->savefd[1]);
/* no need to re-restore this */
e->savefd[1] = 0;
/* Let exchild() close 0 in parent, after fork, before wait */
i = exchild(t, flags | XPCLOSE | XPIPEST, xerrok, 0);
if (!(flags&XBGND) && !(flags&XXCOM))
rv = i;
break;
case TLIST:
while (t->type == TLIST) {
execute(t->left, flags & XERROK, NULL);
t = t->right;
}
rv = execute(t, flags & XERROK, xerrok);
break;
case TCOPROC: {
#ifndef MKSH_NOPROSPECTOFWORK
sigset_t omask;
/*
* Block sigchild as we are using things changed in the
* signal handler
*/
sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
e->type = E_ERRH;
if ((i = kshsetjmp(e->jbuf))) {
sigprocmask(SIG_SETMASK, &omask, NULL);
quitenv(NULL);
unwind(i);
/* NOTREACHED */
}
#endif
/* Already have a (live) co-process? */
if (coproc.job && coproc.write >= 0)
errorf("coprocess already exists");
/* Can we re-use the existing co-process pipe? */
coproc_cleanup(true);
/* do this before opening pipes, in case these fail */
e->savefd[0] = savefd(0);
e->savefd[1] = savefd(1);
openpipe(pv);
if (pv[0] != 0) {
ksh_dup2(pv[0], 0, false);
close(pv[0]);
}
coproc.write = pv[1];
coproc.job = NULL;
if (coproc.readw >= 0)
ksh_dup2(coproc.readw, 1, false);
else {
openpipe(pv);
coproc.read = pv[0];
ksh_dup2(pv[1], 1, false);
/* closed before first read */
coproc.readw = pv[1];
coproc.njobs = 0;
/* create new coprocess id */
++coproc.id;
}
#ifndef MKSH_NOPROSPECTOFWORK
sigprocmask(SIG_SETMASK, &omask, NULL);
/* no more need for error handler */
e->type = E_EXEC;
#endif
/*
* exchild() closes coproc.* in child after fork,
* will also increment coproc.njobs when the
* job is actually created.
*/
flags &= ~XEXEC;
exchild(t->left, flags | XBGND | XFORK | XCOPROC | XCCLOSE,
NULL, coproc.readw);
break;
}
case TASYNC:
/*
* XXX non-optimal, I think - "(foo &)", forks for (),
* forks again for async... parent should optimise
* this to "foo &"...
*/
rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);
break;
case TOR:
case TAND:
rv = execute(t->left, XERROK, xerrok);
if ((rv == 0) == (t->type == TAND))
rv = execute(t->right, XERROK, xerrok);
flags |= XERROK;
if (xerrok)
*xerrok = 1;
break;
case TBANG:
rv = !execute(t->right, XERROK, xerrok);
flags |= XERROK;
if (xerrok)
*xerrok = 1;
break;
case TDBRACKET: {
Test_env te;
te.flags = TEF_DBRACKET;
te.pos.wp = t->args;
te.isa = dbteste_isa;
te.getopnd = dbteste_getopnd;
te.eval = test_eval;
te.error = dbteste_error;
rv = test_parse(&te);
break;
}
case TFOR:
case TSELECT: {
volatile bool is_first = true;
ap = (t->vars == NULL) ? e->loc->argv + 1 :
(const char **)eval((const char **)t->vars,
DOBLANK | DOGLOB | DOTILDE);
e->type = E_LOOP;
while ((i = kshsetjmp(e->jbuf))) {
if ((e->flags&EF_BRKCONT_PASS) ||
(i != LBREAK && i != LCONTIN)) {
quitenv(NULL);
unwind(i);
} else if (i == LBREAK) {
rv = 0;
goto Break;
}
}
/* in case of a continue */
rv = 0;
if (t->type == TFOR) {
while (*ap != NULL) {
setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
rv = execute(t->left, flags & XERROK, xerrok);
}
} else {
/* TSELECT */
for (;;) {
if (!(ccp = do_selectargs(ap, is_first))) {
rv = 1;
break;
}
is_first = false;
setstr(global(t->str), ccp, KSH_UNWIND_ERROR);
execute(t->left, flags & XERROK, xerrok);
}
}
break;
}
case TWHILE:
case TUNTIL:
e->type = E_LOOP;
while ((i = kshsetjmp(e->jbuf))) {
if ((e->flags&EF_BRKCONT_PASS) ||
(i != LBREAK && i != LCONTIN)) {
quitenv(NULL);
unwind(i);
} else if (i == LBREAK) {
rv = 0;
goto Break;
}
}
/* in case of a continue */
rv = 0;
while ((execute(t->left, XERROK, NULL) == 0) ==
(t->type == TWHILE))
rv = execute(t->right, flags & XERROK, xerrok);
break;
case TIF:
case TELIF:
if (t->right == NULL)
/* should be error */
break;
rv = execute(t->left, XERROK, NULL) == 0 ?
execute(t->right->left, flags & XERROK, xerrok) :
execute(t->right->right, flags & XERROK, xerrok);
break;
case TCASE:
i = 0;
ccp = evalstr(t->str, DOTILDE);
for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {
for (ap = (const char **)t->vars; *ap; ap++) {
if (i || ((s = evalstr(*ap, DOTILDE|DOPAT)) &&
gmatchx(ccp, s, false))) {
rv = execute(t->left, flags & XERROK,
xerrok);
i = 0;
switch (t->u.charflag) {
case '&':
i = 1;
/* FALLTHROUGH */
case '|':
goto TCASE_next;
}
goto TCASE_out;
}
}
i = 0;
TCASE_next:
/* empty */;
}
TCASE_out:
break;
case TBRACE:
rv = execute(t->left, flags & XERROK, xerrok);
break;
case TFUNCT:
rv = define(t->str, t);
break;
case TTIME:
/*
* Clear XEXEC so nested execute() call doesn't exit
* (allows "ls -l | time grep foo").
*/
rv = timex(t, flags & ~XEXEC, xerrok);
break;
case TEXEC:
/* an eval'd TCOM */
s = t->args[0];
up = makenv();
restoresigs();
cleanup_proc_env();
{
union mksh_ccphack cargs;
cargs.ro = t->args;
execve(t->str, cargs.rw, up);
rv = errno;
}
if (rv == ENOEXEC)
scriptexec(t, (const char **)up);
else
errorf("%s: %s", s, cstrerror(rv));
}
Break:
exstat = rv & 0xFF;
if (vp_pipest->flag & INT_L) {
unset(vp_pipest, 1);
vp_pipest->flag = DEFINED | ISSET | INTEGER | RDONLY |
ARRAY | INT_U;
vp_pipest->val.i = rv;
}
/* restores IO */
quitenv(NULL);
if ((flags&XEXEC))
/* exit child */
unwind(LEXIT);
if (rv != 0 && !(flags & XERROK) &&
(xerrok == NULL || !*xerrok)) {
if (Flag(FERREXIT) & 0x80) {
/* inside eval */
Flag(FERREXIT) = 0;
} else {
trapsig(ksh_SIGERR);
if (Flag(FERREXIT))
unwind(LERROR);
}
}
return (rv);
}
int AMXEXPORT AMXAPI amx_ProcessCleanup(AMX *amx)
{
freelib(&ModRoot, amx, NULL);
closepipe();
return AMX_ERR_NONE;
}
/* PID: procexec(const commandline[])
* Executes a program. Returns an "id" representing the new process (or 0 on
* failure).
*/
static cell AMX_NATIVE_CALL n_procexec(AMX *amx, const cell *params)
{
TCHAR *pgmname;
#if defined __WIN32__ || defined _WIN32 || defined WIN32
BOOL IsWinNT;
OSVERSIONINFO VerInfo;
STARTUPINFO si;
SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
PROCESS_INFORMATION pi;
#elif defined _Windows
HINSTANCE hinst;
#elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
pid_t pid;
#endif
amx_StrParam(amx,params[1],pgmname);
#if defined __WIN32__ || defined _WIN32 || defined WIN32
/* most of this code comes from a "Borland Network" article, combined
* with some knowledge gained from a CodeProject article
*/
closepipe();
VerInfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
GetVersionEx(&VerInfo);
IsWinNT = VerInfo.dwPlatformId==VER_PLATFORM_WIN32_NT;
if (IsWinNT) { //initialize security descriptor (Windows NT)
InitializeSecurityDescriptor(&sd,SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
sa.lpSecurityDescriptor = &sd;
} else {
sa.lpSecurityDescriptor = NULL;
} /* if */
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE; //allow inheritable handles
if (!CreatePipe(&newstdin,&write_stdin,&sa,0)) { //create stdin pipe
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
if (!CreatePipe(&read_stdout,&newstdout,&sa,0)) { //create stdout pipe
closepipe();
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
GetStartupInfo(&si); //set startupinfo for the spawned process
si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOWNORMAL;
si.hStdOutput = newstdout;
si.hStdError = newstdout; //set the new handles for the child process
si.hStdInput = newstdin;
/* spawn the child process */
if (!CreateProcess(NULL,(TCHAR*)pgmname,NULL,NULL,TRUE,CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi)) {
closepipe();
return 0;
} /* if */
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
Sleep(100);
return pi.dwProcessId;
#elif defined _Windows
hinst=WinExec(pgmname,SW_SHOW);
if (hinst<=32)
hinst=0;
return (cell)hinst;
#elif defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
/* set up communication pipes first */
closepipe();
if (pipe(pipe_to)!=0 || pipe(pipe_from)!=0) {
closepipe();
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
/* attempt to fork */
if ((pid=fork())<0) {
closepipe();
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
if (pid==0) {
/* this is the child process */
#define MAX_ARGS 10
TCHAR *args[MAX_ARGS];
int i;
dup2(pipe_to[0],STDIN_FILENO); /* replace stdin with the in side of the pipe */
dup2(pipe_from[1],STDOUT_FILENO); /* replace stdout with the out side of the pipe */
close(pipe_to[0]); /* the pipes are no longer needed */
close(pipe_to[1]);
close(pipe_from[0]);
close(pipe_from[1]);
pipe_to[0]=-1;
pipe_to[1]=-1;
pipe_from[0]=-1;
pipe_from[1]=-1;
/* split off the option(s) */
assert(MAX_ARGS>=2); /* args[0] is reserved */
memset(args,0,MAX_ARGS*sizeof(TCHAR*));
args[0]=pgmname;
for (i=1; i<MAX_ARGS && args[i-1]!=NULL; i++) {
if ((args[i]=strchr(args[i-1],' '))!=NULL) {
args[i][0]='\0';
args[i]+=1;
} /* if */
} /* for */
/* replace the child fork with a new process */
if(execvp(pgmname,args)<0)
return 0;
} else {
close(pipe_to[0]); /* close unused pipes */
close(pipe_from[1]);
pipe_to[0]=-1;
pipe_from[1]=-1;
} /* if */
return pid;
#else
return (system(pgmname)==0);
#endif
}
int execute(TREPTR argt, int execflg, int *pf1, int *pf2)
{
/* `stakbot' is preserved by this routine */
register TREPTR t;
STKPTR sav = savstak();
sigchk();
if ((t = argt) && execbrk == 0) {
register int treeflgs;
int oldexit, type;
register char **com;
treeflgs = t->tretyp;
type = treeflgs & COMMSK;
oldexit = exitval;
exitval = 0;
switch (type) {
case TCOM:
{
STRING a1;
int argn, internal;
ARGPTR schain = gchain;
IOPTR io = t->treio;
gchain = 0;
argn = getarg((void *)t);/*FIXME*/
com = scan(argn);
a1 = com[1];
gchain = schain;
if ((internal = syslook(com[0], commands)) || argn == 0)
setlist(((COMPTR) t)->comset, 0);
if (argn && (flags & noexec) == 0) { /* print command if execpr */
if (flags & execpr) {
argn = 0;
prs(execpmsg);
while (com[argn] != ENDARGS) {
prs(com[argn++]);
blank();
}
newline();
}
switch (internal) {
case SYSDOT:
if (a1) {
register int f;
if ((f = pathopen(getpath(a1), a1)) < 0)
failed(a1, notfound);
else
execexp(0, f);
}
break;
case SYSTIMES:
{
struct tms t;
times(&t);
prt(t.tms_cutime);
blank();
prt(t.tms_cstime);
newline();
}
break;
case SYSEXIT:
exitsh(a1 ? stoi(a1) : oldexit);
case SYSNULL:
io = 0;
break;
case SYSCONT:
execbrk = -loopcnt;
break;
case SYSBREAK:
if ((execbrk = loopcnt) && a1)
breakcnt = stoi(a1);
break;
case SYSTRAP:
if (a1) {
BOOL clear;
if ((clear = digit(*a1)) == 0)
++com;
while (*++com) {
int i;
if ((i = stoi(*com)) >= MAXTRAP || i < MINTRAP)
failed(*com, badtrap);
else if (clear)
clrsig(i);
else {
replace(&trapcom[i], a1);
if (*a1)
getsig(i);
else
ignsig(i);
}
}
} else { /* print out current traps */
int i;
for (i = 0; i < MAXTRAP; i++) {
if (trapcom[i]) {
prn(i);
prs(colon);
prs(trapcom[i]);
newline();
}
}
}
break;
case SYSEXEC:
com++;
initio(io);
ioset = 0;
io = 0;
if (a1 == 0)
break;
case SYSLOGIN:
flags |= forked;
oldsigs();
execa((const char **)com);
done();
case SYSCD:
if (flags & rshflg)
failed(com[0], restricted);
else if ((a1 == 0 && (a1 = (char *)homenod.namval) == 0) || chdir(a1) < 0) /* FIXME */
failed(a1, baddir);
break;
case SYSSHFT:
if (dolc < 1)
error(badshift);
else {
dolv++;
dolc--;
}
assnum(&dolladr, dolc);
break;
case SYSWAIT:
await(-1);
break;
case SYSREAD:
exitval = readvar(&com[1]);
break;
/*
case SYSTST:
exitval=testcmd(com);
break;
*/
case SYSSET:
if (a1) {
int argc;
argc = options(argn, (const char **)com);
if (argc > 1)
setargs((const char **)com + argn - argc);
} else if (((COMPTR) t)->comset == 0)
/* Scan name chain and print */
namscan(printnam);
break;
case SYSRDONLY:
exitval = N_RDONLY;
case SYSXPORT:
if (exitval == 0)
exitval = N_EXPORT;;
if (a1) {
while (*++com)
attrib(lookup(*com), exitval);
} else {
namscan(printflg);
}
exitval = 0;
break;
case SYSEVAL:
if (a1)
execexp(a1, (UFD)&com[2]); /* FIXME */
break;
case SYSUMASK:
if (a1) {
int c, i;
i = 0;
while ((c = *a1++) >= '0' && c <= '7')
i = (i << 3) + c - '0';
umask(i);
} else {
int i, j;
umask(i = umask(0));
prc('0');
for (j = 6; j >= 0; j -= 3)
prc(((i >> j) & 07) + '0');
newline();
}
break;
default:
internal = builtin(argn, com);
}
if (internal) {
if (io)
error(illegal);
chktrap();
break;
}
} else if (t->treio == 0)
break;
}
case TFORK:
if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
parent = 0;
else {
while ((parent = fork()) == -1) {
sigchk();
alarm(10);
pause();
}
}
if (parent) { /* This is the parent branch of fork; */
/* it may or may not wait for the child. */
if (treeflgs & FPRS && flags & ttyflg) {
prn(parent);
newline();
}
if (treeflgs & FPCL)
closepipe(pf1);
if ((treeflgs & (FAMP | FPOU)) == 0)
await(parent);
else if ((treeflgs & FAMP) == 0)
post(parent);
else
assnum(&pcsadr, parent);
chktrap();
break;
} else { /* this is the forked branch (child) of execute */
flags |= forked;
iotemp = 0;
postclr();
settmp();
/* Turn off INTR and QUIT if `FINT' */
/* Reset ramaining signals to parent */
/* except for those `lost' by trap */
oldsigs();
if (treeflgs & FINT) {
signal(INTR, SIG_IGN);
signal(QUIT, SIG_IGN);
}
/* pipe in or out */
if (treeflgs & FPIN) {
sh_rename(pf1[INPIPE], 0);
close(pf1[OTPIPE]);
}
if (treeflgs & FPOU) {
sh_rename(pf2[OTPIPE], 1);
close(pf2[INPIPE]);
}
/* default std input for & */
if (treeflgs & FINT && ioset == 0)
sh_rename(chkopen(devnull), 0);
/* io redirection */
initio(t->treio);
if (type != TCOM)
execute(((FORKPTR) t)->forktre, 1, NULL, NULL);
else if (com[0] != ENDARGS) {
setlist(((COMPTR) t)->comset, N_EXPORT);
execa((const char **)com);
}
done();
}
case TPAR:
sh_rename(dup(2), output);
execute(((PARPTR) t)->partre, execflg, NULL, NULL);
done();
case TFIL:
{
int pv[2];
chkpipe(pv);
if (execute(((LSTPTR) t)->lstlef, 0, pf1, pv) == 0)
execute(((LSTPTR) t)->lstrit, execflg, pv, pf2);
else
closepipe(pv);
break;
}
case TLST:
execute(((LSTPTR) t)->lstlef, 0, NULL, NULL);
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TAND:
if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) == 0)
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TORF:
if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) != 0)
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TFOR:
{
NAMPTR n = lookup(((FORPTR) t)->fornam);
char **args;
DOLPTR argsav = 0;
if (((FORPTR) t)->forlst == 0) {
args = (char **)dolv + 1;
argsav = useargs();
} else {
ARGPTR schain = gchain;
gchain = 0;
trim((args = scan(getarg(((FORPTR) t)->forlst)))[0]);
gchain = schain;
}
loopcnt++;
while (*args != ENDARGS && execbrk == 0) {
assign(n, *args++);
execute(((FORPTR) t)->fortre, 0, NULL, NULL);
if (execbrk < 0) {
execbrk = 0;
}
}
if (breakcnt)
breakcnt--;
execbrk = breakcnt;
loopcnt--;
argfor = freeargs(argsav);
break;
}
case TWH:
case TUN:
{
int i = 0;
loopcnt++;
while (execbrk == 0 && (execute(((WHPTR) t)->whtre, 0, NULL, NULL) == 0) == (type == TWH)) {
i = execute(((WHPTR) t)->dotre, 0, NULL, NULL);
if (execbrk < 0)
execbrk = 0;
}
if (breakcnt)
breakcnt--;
execbrk = breakcnt;
loopcnt--;
exitval = i;
break;
}
case TIF:
if (execute(((IFPTR) t)->iftre, 0, NULL, NULL) == 0)
execute(((IFPTR) t)->thtre, execflg, NULL, NULL);
else
execute(((IFPTR) t)->eltre, execflg, NULL, NULL);
break;
case TSW:
{
register char *r = mactrim(((SWPTR) t)->swarg);
t = (TREPTR) ((SWPTR) t)->swlst;
while (t) {
ARGPTR rex = ((REGPTR) t)->regptr;
while (rex) {
register char *s;
if (gmatch(r, s = macro(rex->argval)) || (trim(s), eq(r, s))) {
execute(((REGPTR)t)->regcom, 0, NULL, NULL);
t = 0;
break;
} else
rex = ((ARGPTR)rex)->argnxt;
}
if (t)
t = (TREPTR) ((REGPTR) t)->regnxt;
}
}
break;
}
exitset();
}