14887Schin /***********************************************************************
24887Schin *                                                                      *
34887Schin *               This software is part of the ast package               *
48462SApril.Chin@Sun.COM *          Copyright (c) 1982-2008 AT&T Intellectual Property          *
54887Schin *                      and is licensed under the                       *
64887Schin *                  Common Public License, Version 1.0                  *
78462SApril.Chin@Sun.COM *                    by AT&T Intellectual Property                     *
84887Schin *                                                                      *
94887Schin *                A copy of the License is available at                 *
104887Schin *            http://www.opensource.org/licenses/cpl1.0.txt             *
114887Schin *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
124887Schin *                                                                      *
134887Schin *              Information and Software Systems Research               *
144887Schin *                            AT&T Research                             *
154887Schin *                           Florham Park NJ                            *
164887Schin *                                                                      *
174887Schin *                  David Korn <dgk@research.att.com>                   *
184887Schin *                                                                      *
194887Schin ***********************************************************************/
204887Schin #pragma prototyped
214887Schin /*
224887Schin  * UNIX shell parse tree executer
234887Schin  *
244887Schin  *   David Korn
254887Schin  *   AT&T Labs
264887Schin  *
274887Schin  */
284887Schin 
294887Schin #include	"defs.h"
304887Schin #include	<fcin.h>
314887Schin #include	"variables.h"
324887Schin #include	"path.h"
334887Schin #include	"name.h"
344887Schin #include	"io.h"
354887Schin #include	"shnodes.h"
364887Schin #include	"jobs.h"
374887Schin #include	"test.h"
384887Schin #include	"builtins.h"
394887Schin #include	"FEATURE/time"
404887Schin #include	"FEATURE/externs"
414887Schin #include	"FEATURE/locale"
424887Schin #include	"streval.h"
434887Schin 
444887Schin #if !_std_malloc
454887Schin #   include	<vmalloc.h>
464887Schin #endif
474887Schin 
488462SApril.Chin@Sun.COM #if     _lib_vfork
498462SApril.Chin@Sun.COM #   include     <ast_vfork.h>
508462SApril.Chin@Sun.COM #else
518462SApril.Chin@Sun.COM #   define vfork()      fork()
528462SApril.Chin@Sun.COM #endif
538462SApril.Chin@Sun.COM 
544887Schin #define SH_NTFORK	SH_TIMING
554887Schin 
564887Schin #if _lib_nice
574887Schin     extern int	nice(int);
584887Schin #endif /* _lib_nice */
594887Schin #if !_lib_spawnveg
604887Schin #   define spawnveg(a,b,c,d)    spawnve(a,b,c)
614887Schin #endif /* !_lib_spawnveg */
624887Schin #if SHOPT_SPAWN
638462SApril.Chin@Sun.COM     static pid_t sh_ntfork(Shell_t*,const Shnode_t*,char*[],int*,int);
644887Schin #endif /* SHOPT_SPAWN */
654887Schin 
668462SApril.Chin@Sun.COM static void	sh_funct(Shell_t *,Namval_t*, int, char*[], struct argnod*,int);
674887Schin static int	trim_eq(const char*, const char*);
688462SApril.Chin@Sun.COM static void	coproc_init(Shell_t*, int pipes[]);
694887Schin 
704887Schin static void	*timeout;
714887Schin static char	pipejob;
724887Schin 
734887Schin struct funenv
744887Schin {
754887Schin 	Namval_t	*node;
764887Schin 	struct argnod	*env;
774887Schin };
784887Schin 
794887Schin /* ========	command execution	========*/
804887Schin 
814887Schin /*
824887Schin  * print time <t> in h:m:s format with precision <p>
834887Schin  */
844887Schin static void     l_time(Sfio_t *outfile,register clock_t t,int p)
854887Schin {
864887Schin 	register int  min, sec, frac;
874887Schin 	register int hr;
884887Schin 	if(p)
894887Schin 	{
904887Schin 		frac = t%sh.lim.clk_tck;
914887Schin 		frac = (frac*100)/sh.lim.clk_tck;
924887Schin 	}
934887Schin 	t /= sh.lim.clk_tck;
944887Schin 	sec = t%60;
954887Schin 	t /= 60;
964887Schin 	min = t%60;
974887Schin 	if(hr=t/60)
984887Schin 		sfprintf(outfile,"%dh",hr);
994887Schin 	if(p)
1004887Schin 		sfprintf(outfile,"%dm%d%c%0*ds",min,sec,GETDECIMAL(0),p,frac);
1014887Schin 	else
1024887Schin 		sfprintf(outfile,"%dm%ds",min,sec);
1034887Schin }
1044887Schin 
1058462SApril.Chin@Sun.COM static int p_time(Shell_t *shp, Sfio_t *out, const char *format, clock_t *tm)
1064887Schin {
1078462SApril.Chin@Sun.COM 	int		c,p,l,n,offset = staktell();
1088462SApril.Chin@Sun.COM 	const char	*first;
1098462SApril.Chin@Sun.COM 	double		d;
1108462SApril.Chin@Sun.COM 	Stk_t		*stkp = shp->stk;
1114887Schin 	for(first=format ; c= *format; format++)
1124887Schin 	{
1134887Schin 		if(c!='%')
1144887Schin 			continue;
1158462SApril.Chin@Sun.COM 		sfwrite(stkp, first, format-first);
1164887Schin 		n = l = 0;
1174887Schin 		p = 3;
1184887Schin 		if((c= *++format) == '%')
1194887Schin 		{
1204887Schin 			first = format;
1214887Schin 			continue;
1224887Schin 		}
1234887Schin 		if(c>='0' && c <='9')
1244887Schin 		{
1254887Schin 			p = (c>'3')?3:(c-'0');
1264887Schin 			c = *++format;
1274887Schin 		}
1284887Schin 		else if(c=='P')
1294887Schin 		{
1304887Schin 			if(d=tm[0])
1314887Schin 				d = 100.*(((double)(tm[1]+tm[2]))/d);
1324887Schin 			p = 2;
1334887Schin 			goto skip;
1344887Schin 		}
1354887Schin 		if(c=='l')
1364887Schin 		{
1374887Schin 			l = 1;
1384887Schin 			c = *++format;
1394887Schin 		}
1404887Schin 		if(c=='U')
1414887Schin 			n = 1;
1424887Schin 		else if(c=='S')
1434887Schin 			n = 2;
1444887Schin 		else if(c!='R')
1454887Schin 		{
1468462SApril.Chin@Sun.COM 			stkseek(stkp,offset);
1474887Schin 			errormsg(SH_DICT,ERROR_exit(0),e_badtformat,c);
1484887Schin 			return(0);
1494887Schin 		}
1504887Schin 		d = (double)tm[n]/sh.lim.clk_tck;
1514887Schin 	skip:
1524887Schin 		if(l)
1538462SApril.Chin@Sun.COM 			l_time(stkp, tm[n], p);
1544887Schin 		else
1558462SApril.Chin@Sun.COM 			sfprintf(stkp,"%.*f",p, d);
1564887Schin 		first = format+1;
1574887Schin 	}
1584887Schin 	if(format>first)
1598462SApril.Chin@Sun.COM 		sfwrite(stkp,first, format-first);
1608462SApril.Chin@Sun.COM 	sfputc(stkp,'\n');
1618462SApril.Chin@Sun.COM 	n = stktell(stkp)-offset;
1628462SApril.Chin@Sun.COM 	sfwrite(out,stkptr(stkp,offset),n);
1638462SApril.Chin@Sun.COM 	stkseek(stkp,offset);
1644887Schin 	return(n);
1654887Schin }
1664887Schin 
1674887Schin #if SHOPT_OPTIMIZE
1684887Schin /*
1694887Schin  * clear argument pointers that point into the stack
1704887Schin  */
1714887Schin static int p_arg(struct argnod*,int);
1724887Schin static int p_switch(struct regnod*);
1734887Schin static int p_comarg(register struct comnod *com)
1744887Schin {
1754887Schin 	Namval_t *np=com->comnamp;
1764887Schin 	int n = p_arg(com->comset,ARG_ASSIGN);
1774887Schin 	if(com->comarg && (com->comtyp&COMSCAN))
1784887Schin 		n+= p_arg(com->comarg,0);
1794887Schin 	if(com->comstate  && np)
1804887Schin 	{
1814887Schin 		/* call builtin to cleanup state */
1828462SApril.Chin@Sun.COM 		Shbltin_t *bp = &sh.bltindata;
1838462SApril.Chin@Sun.COM 		void  *save_ptr = bp->ptr;
1848462SApril.Chin@Sun.COM 		void  *save_data = bp->data;
1858462SApril.Chin@Sun.COM 		bp->bnode = np;
1868462SApril.Chin@Sun.COM 		bp->vnode = com->comnamq;
1878462SApril.Chin@Sun.COM 		bp->ptr = nv_context(np);
1888462SApril.Chin@Sun.COM 		bp->data = com->comstate;
1898462SApril.Chin@Sun.COM 		bp->flags = SH_END_OPTIM;
1908462SApril.Chin@Sun.COM 		(*funptr(np))(0,(char**)0, bp);
1918462SApril.Chin@Sun.COM 		bp->ptr = save_ptr;
1928462SApril.Chin@Sun.COM 		bp->data = save_data;
1934887Schin 	}
1944887Schin 	com->comstate = 0;
1954887Schin 	if(com->comarg && !np)
1964887Schin 		n++;
1974887Schin 	return(n);
1984887Schin }
1994887Schin 
2004887Schin extern void sh_optclear(Shell_t*, void*);
2014887Schin 
2024887Schin static int sh_tclear(register Shnode_t *t)
2034887Schin {
2044887Schin 	int n=0;
2054887Schin 	if(!t)
2064887Schin 		return(0);
2074887Schin 	switch(t->tre.tretyp&COMMSK)
2084887Schin 	{
2094887Schin 		case TTIME:
2104887Schin 		case TPAR:
2114887Schin 			return(sh_tclear(t->par.partre));
2124887Schin 		case TCOM:
2134887Schin 			return(p_comarg((struct comnod*)t));
2144887Schin 		case TSETIO:
2154887Schin 		case TFORK:
2164887Schin 			return(sh_tclear(t->fork.forktre));
2174887Schin 		case TIF:
2184887Schin 			n=sh_tclear(t->if_.iftre);
2194887Schin 			n+=sh_tclear(t->if_.thtre);
2204887Schin 			n+=sh_tclear(t->if_.eltre);
2214887Schin 			return(n);
2224887Schin 		case TWH:
2234887Schin 			if(t->wh.whinc)
2244887Schin 				n=sh_tclear((Shnode_t*)(t->wh.whinc));
2254887Schin 			n+=sh_tclear(t->wh.whtre);
2264887Schin 			n+=sh_tclear(t->wh.dotre);
2274887Schin 			return(n);
2284887Schin 		case TLST:
2294887Schin 		case TAND:
2304887Schin 		case TORF:
2314887Schin 		case TFIL:
2324887Schin 			n=sh_tclear(t->lst.lstlef);
2334887Schin 			return(n+sh_tclear(t->lst.lstrit));
2344887Schin 		case TARITH:
2354887Schin 			return(p_arg(t->ar.arexpr,ARG_ARITH));
2364887Schin 		case TFOR:
2374887Schin 			n=sh_tclear(t->for_.fortre);
2384887Schin 			return(n+sh_tclear((Shnode_t*)t->for_.forlst));
2394887Schin 		case TSW:
2404887Schin 			n=p_arg(t->sw.swarg,0);
2414887Schin 			return(n+p_switch(t->sw.swlst));
2424887Schin 		case TFUN:
2434887Schin 			n=sh_tclear(t->funct.functtre);
2444887Schin 			return(n+sh_tclear((Shnode_t*)t->funct.functargs));
2454887Schin 		case TTST:
2464887Schin 			if((t->tre.tretyp&TPAREN)==TPAREN)
2474887Schin 				return(sh_tclear(t->lst.lstlef));
2484887Schin 			else
2494887Schin 			{
2504887Schin 				n=p_arg(&(t->lst.lstlef->arg),0);
2514887Schin 				if(t->tre.tretyp&TBINARY)
2524887Schin 					n+=p_arg(&(t->lst.lstrit->arg),0);
2534887Schin 			}
2544887Schin 	}
2554887Schin 	return(n);
2564887Schin }
2574887Schin 
2584887Schin static int p_arg(register struct argnod *arg,int flag)
2594887Schin {
2604887Schin 	while(arg)
2614887Schin 	{
2624887Schin 		if(strlen(arg->argval) || (arg->argflag==ARG_RAW))
2634887Schin 			arg->argchn.ap = 0;
2644887Schin 		else if(flag==0)
2654887Schin 			sh_tclear((Shnode_t*)arg->argchn.ap);
2664887Schin 		else
2674887Schin 			sh_tclear(((struct fornod*)arg->argchn.ap)->fortre);
2684887Schin 		arg = arg->argnxt.ap;
2694887Schin 	}
2704887Schin 	return(0);
2714887Schin }
2724887Schin 
2734887Schin static int p_switch(register struct regnod *reg)
2744887Schin {
2754887Schin 	int n=0;
2764887Schin 	while(reg)
2774887Schin 	{
2784887Schin 		n+=p_arg(reg->regptr,0);
2794887Schin 		n+=sh_tclear(reg->regcom);
2804887Schin 		reg = reg->regnxt;
2814887Schin 	}
2824887Schin 	return(n);
2834887Schin }
2844887Schin #   define OPTIMIZE_FLAG	(ARG_OPTIMIZE)
2854887Schin #   define OPTIMIZE		(flags&OPTIMIZE_FLAG)
2864887Schin #else
2874887Schin #   define OPTIMIZE_FLAG	(0)
2884887Schin #   define OPTIMIZE		(0)
2894887Schin #   define sh_tclear(x)
2904887Schin #endif /* SHOPT_OPTIMIZE */
2914887Schin 
2924887Schin static void out_pattern(Sfio_t *iop, register const char *cp, int n)
2934887Schin {
2944887Schin 	register int c;
2954887Schin 	do
2964887Schin 	{
2974887Schin 		switch(c= *cp)
2984887Schin 		{
2994887Schin 		    case 0:
3004887Schin 			if(n<0)
3014887Schin 				return;
3024887Schin 			c = n;
3034887Schin 			break;
3044887Schin 		    case '\n':
3054887Schin 			sfputr(iop,"$'\\n",'\'');
3064887Schin 			continue;
3074887Schin 		    case '\\':
3084887Schin 			if (!(c = *++cp))
3094887Schin 				c = '\\';
3104887Schin 			/*FALLTHROUGH*/
3114887Schin 		    case ' ':
3124887Schin 		    case '<': case '>': case ';':
3134887Schin 		    case '$': case '`': case '\t':
3144887Schin 			sfputc(iop,'\\');
3154887Schin 			break;
3164887Schin 		}
3174887Schin 		sfputc(iop,c);
3184887Schin 	}
3194887Schin 	while(*cp++);
3204887Schin }
3214887Schin 
3224887Schin static void out_string(Sfio_t *iop, register const char *cp, int c, int quoted)
3234887Schin {
3244887Schin 	if(quoted)
3254887Schin 	{
3268462SApril.Chin@Sun.COM 		int n = stktell(stkstd);
3274887Schin 		cp = sh_fmtq(cp);
3284887Schin 		if(iop==stkstd && cp==stkptr(stkstd,n))
3294887Schin 		{
3304887Schin 			*stkptr(stkstd,stktell(stkstd)-1) = c;
3314887Schin 			return;
3324887Schin 		}
3334887Schin 	}
3344887Schin 	sfputr(iop,cp,c);
3354887Schin }
3364887Schin 
3374887Schin struct Level
3384887Schin {
3394887Schin 	Namfun_t	hdr;
3404887Schin 	short		maxlevel;
3414887Schin };
3424887Schin 
3434887Schin /*
3444887Schin  * this is for a debugger but it hasn't been tested yet
3454887Schin  * if a debug script sets .sh.level it should set up the scope
3464887Schin  *  as if you were executing in that level
3474887Schin  */
3484887Schin static void put_level(Namval_t* np,const char *val,int flags,Namfun_t *fp)
3494887Schin {
3504887Schin 	Shscope_t	*sp;
3514887Schin 	struct Level *lp = (struct Level*)fp;
3524887Schin 	int16_t level, oldlevel = (int16_t)nv_getnum(np);
3534887Schin 	nv_putv(np,val,flags,fp);
3548462SApril.Chin@Sun.COM 	if(!val)
3558462SApril.Chin@Sun.COM 		return;
3564887Schin 	level = nv_getnum(np);
3574887Schin 	if(level<0 || level > lp->maxlevel)
3584887Schin 	{
3598462SApril.Chin@Sun.COM 		nv_putv(np, (char*)&oldlevel, NV_INT16, fp);
3604887Schin 		/* perhaps this should be an error */
3614887Schin 		return;
3624887Schin 	}
3634887Schin 	if(level==oldlevel)
3644887Schin 		return;
3654887Schin 	if(sp = sh_getscope(level,SEEK_SET))
3664887Schin 	{
3678462SApril.Chin@Sun.COM 		sh_setscope(sp);
3688462SApril.Chin@Sun.COM 		error_info.id = sp->cmdname;
3698462SApril.Chin@Sun.COM 
3704887Schin 	}
3714887Schin }
3724887Schin 
3738462SApril.Chin@Sun.COM static const Namdisc_t level_disc = {  sizeof(struct Level), put_level };
3748462SApril.Chin@Sun.COM 
3758462SApril.Chin@Sun.COM static struct Level *init_level(int level)
3768462SApril.Chin@Sun.COM {
3778462SApril.Chin@Sun.COM 	struct Level *lp = newof(NiL,struct Level,1,0);
3788462SApril.Chin@Sun.COM 	lp->maxlevel = level;
3798462SApril.Chin@Sun.COM 	_nv_unset(SH_LEVELNOD,0);
3808462SApril.Chin@Sun.COM 	nv_onattr(SH_LEVELNOD,NV_INT16|NV_NOFREE);
3818462SApril.Chin@Sun.COM 	nv_putval(SH_LEVELNOD,(char*)&lp->maxlevel,NV_INT16);
3828462SApril.Chin@Sun.COM 	lp->hdr.disc = &level_disc;
3838462SApril.Chin@Sun.COM 	nv_disc(SH_LEVELNOD,&lp->hdr,NV_FIRST);
3848462SApril.Chin@Sun.COM 	return(lp);
3858462SApril.Chin@Sun.COM }
3864887Schin 
3874887Schin /*
3884887Schin  * write the current common on the stack and make it available as .sh.command
3894887Schin  */
3908462SApril.Chin@Sun.COM int sh_debug(Shell_t *shp, const char *trap, const char *name, const char *subscript, char *const argv[], int flags)
3914887Schin {
3928462SApril.Chin@Sun.COM 	Stk_t			*stkp=shp->stk;
3934887Schin 	struct sh_scoped	savst;
3944887Schin 	Namval_t		*np = SH_COMMANDNOD;
3958462SApril.Chin@Sun.COM 	char			*sav = stkptr(stkp,0);
3968462SApril.Chin@Sun.COM 	int			n=4, offset=stktell(stkp);
3974887Schin 	const char		*cp = "+=( ";
3984887Schin 	Sfio_t			*iop = stkstd;
3998462SApril.Chin@Sun.COM 	short			level;
4008462SApril.Chin@Sun.COM 	if(shp->indebug)
4018462SApril.Chin@Sun.COM 		return(0);
4028462SApril.Chin@Sun.COM 	shp->indebug = 1;
4034887Schin 	if(name)
4044887Schin 	{
4054887Schin 		sfputr(iop,name,-1);
4064887Schin 		if(subscript)
4074887Schin 		{
4084887Schin 			sfputc(iop,'[');
4094887Schin 			out_string(iop,subscript,']',1);
4104887Schin 		}
4114887Schin 		if(!(flags&ARG_APPEND))
4124887Schin 			cp+=1, n-=1;
4134887Schin 		if(!(flags&ARG_ASSIGN))
4144887Schin 			n -= 2;
4154887Schin 		sfwrite(iop,cp,n);
4164887Schin 	}
4174887Schin 	if(!(flags&ARG_RAW))
4184887Schin 		out_string(iop, *argv++,' ', 0);
4194887Schin 	n = (flags&ARG_ARITH);
4204887Schin 	while(cp = *argv++)
4214887Schin 	{
4224887Schin 		if((flags&ARG_EXP) && argv[1]==0)
4234887Schin 			out_pattern(iop, cp,' ');
4244887Schin 		else
4254887Schin 			out_string(iop, cp,' ',n?0: (flags&(ARG_RAW|ARG_NOGLOB))||*argv);
4264887Schin 	}
4274887Schin 	if(flags&ARG_ASSIGN)
4284887Schin 		sfputc(iop,')');
4294887Schin 	else if(iop==stkstd)
4308462SApril.Chin@Sun.COM 		*stkptr(stkp,stktell(stkp)-1) = 0;
4318462SApril.Chin@Sun.COM 	np->nvalue.cp = stkfreeze(stkp,1);
4324887Schin 	/* now setup .sh.level variable */
4338462SApril.Chin@Sun.COM 	shp->st.lineno = error_info.line;
4348462SApril.Chin@Sun.COM 	level  = shp->fn_depth+shp->dot_depth;
4358462SApril.Chin@Sun.COM 	if(!SH_LEVELNOD->nvfun || !SH_LEVELNOD->nvfun->disc || nv_isattr(SH_LEVELNOD,NV_INT16|NV_NOFREE)!=(NV_INT16|NV_NOFREE))
4368462SApril.Chin@Sun.COM 		init_level(level);
4378462SApril.Chin@Sun.COM 	else
4388462SApril.Chin@Sun.COM 		nv_putval(SH_LEVELNOD,(char*)&level,NV_INT16);
4398462SApril.Chin@Sun.COM 	savst = shp->st;
4408462SApril.Chin@Sun.COM 	shp->st.trap[SH_DEBUGTRAP] = 0;
4414887Schin 	n = sh_trap(trap,0);
4424887Schin 	np->nvalue.cp = 0;
4438462SApril.Chin@Sun.COM 	shp->indebug = 0;
4448462SApril.Chin@Sun.COM 	if(shp->st.cmdname)
4458462SApril.Chin@Sun.COM 		error_info.id = shp->st.cmdname;
4468462SApril.Chin@Sun.COM 	nv_putval(SH_PATHNAMENOD,shp->st.filename,NV_NOFREE);
4478462SApril.Chin@Sun.COM 	nv_putval(SH_FUNNAMENOD,shp->st.funname,NV_NOFREE);
4488462SApril.Chin@Sun.COM 	shp->st = savst;
4498462SApril.Chin@Sun.COM 	if(sav != stkptr(stkp,0))
4508462SApril.Chin@Sun.COM 		stkset(stkp,sav,0);
4514887Schin 	else
4528462SApril.Chin@Sun.COM 		stkseek(stkp,offset);
4534887Schin 	return(n);
4544887Schin }
4554887Schin 
4564887Schin /*
4574887Schin  * Given stream <iop> compile and execute
4584887Schin  */
4594887Schin int sh_eval(register Sfio_t *iop, int mode)
4604887Schin {
4614887Schin 	register Shnode_t *t;
4624887Schin 	Shell_t  *shp = sh_getinterp();
4634887Schin 	struct slnod *saveslp = shp->st.staklist;
4644887Schin 	int jmpval;
4654887Schin 	struct checkpt *pp = (struct checkpt*)shp->jmplist;
4664887Schin 	struct checkpt buff;
4674887Schin 	static Sfio_t *io_save;
4688462SApril.Chin@Sun.COM 	volatile int traceon=0, lineno=0;
4694887Schin 	io_save = iop; /* preserve correct value across longjmp */
4708462SApril.Chin@Sun.COM #define SH_TOPFUN	0x8000	/* this is a temporary tksh hack */
4718462SApril.Chin@Sun.COM 	if (mode & SH_TOPFUN)
4728462SApril.Chin@Sun.COM 	{
4738462SApril.Chin@Sun.COM 		mode ^= SH_TOPFUN;
4748462SApril.Chin@Sun.COM 		shp->fn_reset = 1;
4758462SApril.Chin@Sun.COM 	}
4764887Schin 	sh_pushcontext(&buff,SH_JMPEVAL);
4774887Schin 	buff.olist = pp->olist;
4784887Schin 	jmpval = sigsetjmp(buff.buff,0);
4794887Schin 	if(jmpval==0)
4804887Schin 	{
4818462SApril.Chin@Sun.COM 		if(mode&SH_READEVAL)
4828462SApril.Chin@Sun.COM 		{
4838462SApril.Chin@Sun.COM 			lineno = shp->inlineno;
4848462SApril.Chin@Sun.COM 			if(traceon=sh_isoption(SH_XTRACE))
4858462SApril.Chin@Sun.COM 				sh_offoption(SH_XTRACE);
4868462SApril.Chin@Sun.COM 		}
4878462SApril.Chin@Sun.COM 		t = (Shnode_t*)sh_parse(shp,iop,(mode&SH_READEVAL)?0:SH_NL);
4888462SApril.Chin@Sun.COM 		if(mode&SH_READEVAL)
4898462SApril.Chin@Sun.COM 			mode &= SH_READEVAL;
4908462SApril.Chin@Sun.COM 		else
4918462SApril.Chin@Sun.COM 			sfclose(iop);
4924887Schin 		io_save = 0;
4934887Schin 		if(!sh_isoption(SH_VERBOSE))
4944887Schin 			sh_offstate(SH_VERBOSE);
4954887Schin 		if(mode && shp->hist_ptr)
4964887Schin 		{
4974887Schin 			hist_flush(shp->hist_ptr);
4984887Schin 			mode = sh_state(SH_INTERACTIVE);
4994887Schin 		}
5004887Schin 		sh_exec(t,sh_isstate(SH_ERREXIT)|mode);
5014887Schin 	}
5024887Schin 	sh_popcontext(&buff);
5038462SApril.Chin@Sun.COM 	if(traceon)
5048462SApril.Chin@Sun.COM 		sh_onoption(SH_XTRACE);
5058462SApril.Chin@Sun.COM 	if(lineno)
5068462SApril.Chin@Sun.COM 		shp->inlineno = lineno;
5074887Schin 	if(io_save)
5084887Schin 		sfclose(io_save);
5098462SApril.Chin@Sun.COM 	sh_freeup(shp);
5104887Schin 	shp->st.staklist = saveslp;
5118462SApril.Chin@Sun.COM 	shp->fn_reset = 0;
5124887Schin 	if(jmpval>SH_JMPEVAL)
5134887Schin 		siglongjmp(*shp->jmplist,jmpval);
5148462SApril.Chin@Sun.COM 	return(shp->exitval);
5154887Schin }
5164887Schin 
5174887Schin #if SHOPT_FASTPIPE
5188462SApril.Chin@Sun.COM static int pipe_exec(Shell_t* shp,int pv[], Shnode_t *t, int errorflg)
5194887Schin {
5204887Schin 	struct checkpt buff;
5214887Schin 	register Shnode_t *tchild = t->fork.forktre;
5224887Schin 	Namval_t *np;
5238462SApril.Chin@Sun.COM 	int jmpval;
5248462SApril.Chin@Sun.COM 	volatile Sfio_t *iop;
5258462SApril.Chin@Sun.COM 	volatile int r;
5264887Schin 	if((tchild->tre.tretyp&COMMSK)!=TCOM || !(np=(Namval_t*)(tchild->com.comnamp)))
5274887Schin 	{
5284887Schin 		sh_pipe(pv);
5294887Schin 		return(sh_exec(t,errorflg));
5304887Schin 	}
5318462SApril.Chin@Sun.COM 	pv[0] = shp->lim.open_max;
5328462SApril.Chin@Sun.COM 	shp->fdstatus[pv[0]] = IOREAD|IODUP|IOSEEK;
5338462SApril.Chin@Sun.COM 	pv[1] = shp->lim.open_max+1;
5348462SApril.Chin@Sun.COM 	shp->fdstatus[pv[1]] = IOWRITE|IOSEEK;
5354887Schin 	iop = sftmp(IOBSIZE+1);
5368462SApril.Chin@Sun.COM 	shp->sftable[shp->lim.open_max+1] = iop;
5374887Schin 	sh_pushcontext(&buff,SH_JMPIO);
5384887Schin 	if(t->tre.tretyp&FPIN)
5398462SApril.Chin@Sun.COM 		sh_iosave(shp,0,shp->topfd,(char*)0);
5408462SApril.Chin@Sun.COM 	sh_iosave(shp,1,shp->topfd,(char*)0);
5414887Schin 	jmpval = sigsetjmp(buff.buff,0);
5424887Schin 	if(jmpval==0)
5434887Schin 	{
5444887Schin 		if(t->tre.tretyp&FPIN)
5458462SApril.Chin@Sun.COM 			sh_iorenumber(shp,shp->inpipe[0],0);
5468462SApril.Chin@Sun.COM 		sh_iorenumber(shp,shp->lim.open_max+1,1);
5474887Schin 		r = sh_exec(tchild,errorflg);
5484887Schin 		if(sffileno(sfstdout)>=0)
5494887Schin 			pv[0] = sfsetfd(sfstdout,10);
5504887Schin 		iop = sfswap(sfstdout,0);
5514887Schin 	}
5524887Schin 	sh_popcontext(&buff);
5538462SApril.Chin@Sun.COM 	shp->sftable[pv[0]] = iop;
5548462SApril.Chin@Sun.COM 	shp->fdstatus[pv[0]] = IOREAD|IODUP|IOSEEK;
5554887Schin 	sfset(iop,SF_WRITE,0);
5564887Schin 	sfseek(iop,0L,SEEK_SET);
5578462SApril.Chin@Sun.COM 	sh_iorestore(shp,buff.topfd,jmpval);
5584887Schin 	if(jmpval>SH_JMPIO)
5598462SApril.Chin@Sun.COM 		siglongjmp(*shp->jmplist,jmpval);
5604887Schin 	return(r);
5614887Schin }
5624887Schin #endif /* SHOPT_FASTPIPE */
5634887Schin 
5644887Schin /*
5654887Schin  * returns 1 when option -<c> is specified
5664887Schin  */
5674887Schin static int checkopt(char *argv[], int c)
5684887Schin {
5694887Schin 	char *cp;
5704887Schin 	while(cp = *++argv)
5714887Schin 	{
5724887Schin 		if(*cp=='+')
5734887Schin 			continue;
5744887Schin 		if(*cp!='-' || cp[1]=='-')
5754887Schin 			break;
5768462SApril.Chin@Sun.COM 		if(strchr(++cp,c))
5774887Schin 			return(1);
5788462SApril.Chin@Sun.COM 		if(*cp=='h' && cp[1]==0 && *++argv==0)
5798462SApril.Chin@Sun.COM 			break;
5804887Schin 	}
5814887Schin 	return(0);
5824887Schin }
5834887Schin 
5844887Schin static void free_list(struct openlist *olist)
5854887Schin {
5864887Schin 	struct openlist *item,*next;
5874887Schin 	for(item=olist;item;item=next)
5884887Schin 	{
5894887Schin 		next = item->next;
5904887Schin 		free((void*)item);
5914887Schin 	}
5924887Schin }
5934887Schin 
5948462SApril.Chin@Sun.COM /*
5958462SApril.Chin@Sun.COM  * set ${.sh.name} and ${.sh.subscript}
5968462SApril.Chin@Sun.COM  * set _ to reference for ${.sh.name}[$.sh.subscript]
5978462SApril.Chin@Sun.COM  */
5988462SApril.Chin@Sun.COM static int set_instance(Namval_t *nq, Namval_t *node, struct Namref *nr)
5998462SApril.Chin@Sun.COM {
6008462SApril.Chin@Sun.COM 	char		*cp = nv_name(nq);
6018462SApril.Chin@Sun.COM 	Namarr_t	*ap;
6028462SApril.Chin@Sun.COM 	memset(nr,0,sizeof(*nr));
6038462SApril.Chin@Sun.COM 	nr->np = nq;
6048462SApril.Chin@Sun.COM 	nr->root = sh.var_tree;
6058462SApril.Chin@Sun.COM 	nr->table = sh.last_table;
6068462SApril.Chin@Sun.COM 	if(sh.var_tree!=sh.var_base && !nv_open(cp,nr->root,NV_VARNAME|NV_NOREF|NV_NOSCOPE|NV_NOADD|NV_NOFAIL))
6078462SApril.Chin@Sun.COM 		nr->root = sh.var_base;
6088462SApril.Chin@Sun.COM 	nv_putval(SH_NAMENOD, cp, NV_NOFREE);
6098462SApril.Chin@Sun.COM 	memcpy(node,L_ARGNOD,sizeof(*node));
6108462SApril.Chin@Sun.COM 	L_ARGNOD->nvalue.nrp = nr;
6118462SApril.Chin@Sun.COM 	L_ARGNOD->nvflag = NV_REF|NV_NOFREE;
6128462SApril.Chin@Sun.COM 	L_ARGNOD->nvfun = 0;
6138462SApril.Chin@Sun.COM 	L_ARGNOD->nvenv = 0;
6148462SApril.Chin@Sun.COM 	if((ap=nv_arrayptr(nq)) && (cp = nv_getsub(nq)) && (cp = strdup(cp)))
6158462SApril.Chin@Sun.COM 	{
6168462SApril.Chin@Sun.COM 		nv_putval(SH_SUBSCRNOD,nr->sub=cp,NV_NOFREE);
6178462SApril.Chin@Sun.COM 		return(ap->nelem&ARRAY_SCAN);
6188462SApril.Chin@Sun.COM 	}
6198462SApril.Chin@Sun.COM 	return(0);
6208462SApril.Chin@Sun.COM }
6218462SApril.Chin@Sun.COM 
6228462SApril.Chin@Sun.COM static void unset_instance(Namval_t *nq, Namval_t *node, struct Namref *nr,long mode)
6238462SApril.Chin@Sun.COM {
6248462SApril.Chin@Sun.COM 	L_ARGNOD->nvalue.nrp = node->nvalue.nrp;
6258462SApril.Chin@Sun.COM 	L_ARGNOD->nvflag = node->nvflag;
6268462SApril.Chin@Sun.COM 	L_ARGNOD->nvfun = node->nvfun;
6278462SApril.Chin@Sun.COM 	if(nr->sub)
6288462SApril.Chin@Sun.COM 	{
6298462SApril.Chin@Sun.COM 		nv_putsub(nq, nr->sub, mode);
6308462SApril.Chin@Sun.COM 		free((void*)nr->sub);
6318462SApril.Chin@Sun.COM 	}
6328462SApril.Chin@Sun.COM 	nv_unset(SH_NAMENOD);
6338462SApril.Chin@Sun.COM 	nv_unset(SH_SUBSCRNOD);
6348462SApril.Chin@Sun.COM }
6354887Schin 
6364887Schin int sh_exec(register const Shnode_t *t, int flags)
6374887Schin {
6388462SApril.Chin@Sun.COM 	register Shell_t	*shp = &sh;
6398462SApril.Chin@Sun.COM 	Stk_t			*stkp = shp->stk;
6404887Schin 	sh_sigcheck();
6418462SApril.Chin@Sun.COM 	if(t && !shp->st.execbrk && !sh_isoption(SH_NOEXEC))
6424887Schin 	{
6434887Schin 		register int 	type = flags;
6444887Schin 		register char	*com0 = 0;
6454887Schin 		int 		errorflg = (type&sh_state(SH_ERREXIT))|OPTIMIZE;
6464887Schin 		int 		execflg = (type&sh_state(SH_NOFORK));
6474887Schin 		int 		mainloop = (type&sh_state(SH_INTERACTIVE));
6488462SApril.Chin@Sun.COM #if SHOPT_AMP || SHOPT_SPAWN
6494887Schin 		int		ntflag = (type&sh_state(SH_NTFORK));
6504887Schin #endif
6518462SApril.Chin@Sun.COM 		int		topfd = shp->topfd;
6528462SApril.Chin@Sun.COM 		char 		*sav=stkptr(stkp,0);
6538462SApril.Chin@Sun.COM 		char		*cp=0, **com=0, *comn;
6544887Schin 		int		argn;
6554887Schin 		int 		skipexitset = 0;
6564887Schin 		int		was_interactive = 0;
6574887Schin 		int		was_errexit = sh_isstate(SH_ERREXIT);
6584887Schin 		int		was_monitor = sh_isstate(SH_MONITOR);
6594887Schin 		int		echeck = 0;
6604887Schin 		if(flags&sh_state(SH_INTERACTIVE))
6614887Schin 		{
6624887Schin 			pipejob = 0;
6634887Schin 			job.curpgid = 0;
6644887Schin 			flags &= ~sh_state(SH_INTERACTIVE);
6654887Schin 		}
6664887Schin 		sh_offstate(SH_ERREXIT);
6674887Schin 		sh_offstate(SH_DEFPATH);
6684887Schin 		if(was_errexit&flags)
6694887Schin 			sh_onstate(SH_ERREXIT);
6704887Schin 		if(was_monitor&flags)
6714887Schin 			sh_onstate(SH_MONITOR);
6724887Schin 		type = t->tre.tretyp;
6738462SApril.Chin@Sun.COM 		if(!shp->intrap)
6748462SApril.Chin@Sun.COM 			shp->oldexit=shp->exitval;
6758462SApril.Chin@Sun.COM 		shp->exitval=0;
6768462SApril.Chin@Sun.COM 		shp->lastsig = 0;
6778462SApril.Chin@Sun.COM 		shp->lastpath = 0;
6784887Schin 		switch(type&COMMSK)
6794887Schin 		{
6804887Schin 		    case TCOM:
6814887Schin 		    {
6824887Schin 			register struct argnod	*argp;
6834887Schin 			char		*trap;
6844887Schin 			Namval_t	*np, *nq, *last_table;
6854887Schin 			struct ionod	*io;
6868462SApril.Chin@Sun.COM 			int		command=0, flgs=NV_ASSIGN;
6878462SApril.Chin@Sun.COM 			shp->bltindata.invariant = type>>(COMBITS+2);
6888462SApril.Chin@Sun.COM 			type &= (COMMSK|COMSCAN);
6898462SApril.Chin@Sun.COM 			sh_stats(STAT_SCMDS);
6908462SApril.Chin@Sun.COM 			error_info.line = t->com.comline-shp->st.firstline;
6918462SApril.Chin@Sun.COM 			com = sh_argbuild(shp,&argn,&(t->com),OPTIMIZE);
6924887Schin 			echeck = 1;
6934887Schin 			if(t->tre.tretyp&COMSCAN)
6944887Schin 			{
6954887Schin 				argp = t->com.comarg;
6964887Schin 				if(argp && *com && !(argp->argflag&ARG_RAW))
6974887Schin 					sh_sigcheck();
6984887Schin 			}
6994887Schin 			np = (Namval_t*)(t->com.comnamp);
7004887Schin 			nq = (Namval_t*)(t->com.comnamq);
7014887Schin 			com0 = com[0];
7028462SApril.Chin@Sun.COM 			shp->xargexit = 0;
7034887Schin 			while(np==SYSCOMMAND)
7044887Schin 			{
7058462SApril.Chin@Sun.COM 				register int n = b_command(0,com,&shp->bltindata);
7064887Schin 				if(n==0)
7074887Schin 					break;
7084887Schin 				command += n;
7094887Schin 				np = 0;
7104887Schin 				if(!(com0= *(com+=n)))
7114887Schin 					break;
7128462SApril.Chin@Sun.COM 				np = nv_bfsearch(com0, shp->bltin_tree, &nq, &cp);
7134887Schin 			}
7148462SApril.Chin@Sun.COM 			if(shp->xargexit)
7154887Schin 			{
7168462SApril.Chin@Sun.COM 				shp->xargmin -= command;
7178462SApril.Chin@Sun.COM 				shp->xargmax -= command;
7184887Schin 			}
7194887Schin 			else
7208462SApril.Chin@Sun.COM 				shp->xargmin = 0;
7214887Schin 			argn -= command;
7224887Schin 			if(!command && np && is_abuiltin(np))
7238462SApril.Chin@Sun.COM 				np = dtsearch(shp->fun_tree,np);
7248462SApril.Chin@Sun.COM 			if(com0)
7254887Schin 			{
7268462SApril.Chin@Sun.COM 				if(!np && !strchr(com0,'/'))
7274887Schin 				{
7288462SApril.Chin@Sun.COM 					Dt_t *root = command?shp->bltin_tree:shp->fun_tree;
7298462SApril.Chin@Sun.COM 					np = nv_bfsearch(com0, root, &nq, &cp);
7308462SApril.Chin@Sun.COM #if SHOPT_NAMESPACE
7318462SApril.Chin@Sun.COM 					if(shp->namespace && !nq && !cp)
7328462SApril.Chin@Sun.COM 					{
7338462SApril.Chin@Sun.COM 						int offset = stktell(stkp);
7348462SApril.Chin@Sun.COM 						sfputr(stkp,nv_name(shp->namespace),-1);
7358462SApril.Chin@Sun.COM 						sfputc(stkp,'.');
7368462SApril.Chin@Sun.COM 						sfputr(stkp,com0,0);
7378462SApril.Chin@Sun.COM 						stkseek(stkp,offset);
7388462SApril.Chin@Sun.COM 						np = nv_bfsearch(stkptr(stkp,offset), root, &nq, &cp);
7398462SApril.Chin@Sun.COM 					}
7408462SApril.Chin@Sun.COM #endif /* SHOPT_NAMESPACE */
7414887Schin 				}
7428462SApril.Chin@Sun.COM 				comn = com[argn-1];
7434887Schin 			}
7444887Schin 			io = t->tre.treio;
7458462SApril.Chin@Sun.COM 			if(shp->envlist = argp = t->com.comset)
7464887Schin 			{
7478462SApril.Chin@Sun.COM 				if(argn==0 || (np && nv_isattr(np,BLT_SPC)))
7484887Schin 				{
7498462SApril.Chin@Sun.COM 					if(argn)
7508462SApril.Chin@Sun.COM 					{
7518462SApril.Chin@Sun.COM 						if(checkopt(com,'A'))
7528462SApril.Chin@Sun.COM 							flgs |= NV_ARRAY;
7538462SApril.Chin@Sun.COM 						else if(checkopt(com,'a'))
7548462SApril.Chin@Sun.COM 							flgs |= NV_IARRAY;
7558462SApril.Chin@Sun.COM 					}
7564887Schin #if SHOPT_BASH
7574887Schin 					if(np==SYSLOCAL)
7584887Schin 					{
7594887Schin 						if(!nv_getval(SH_FUNNAMENOD))
7604887Schin 							errormsg(SH_DICT,ERROR_exit(1),"%s: can only be used in a function",com0);
7618462SApril.Chin@Sun.COM 						if(!shp->st.var_local)
7624887Schin 						{
7638462SApril.Chin@Sun.COM 							sh_scope(shp,(struct argnod*)0,0);
7648462SApril.Chin@Sun.COM 							shp->st.var_local = shp->var_tree;
7654887Schin 						}
7664887Schin 
7674887Schin 					}
7684887Schin 					if(np==SYSTYPESET || np==SYSLOCAL)
7694887Schin #else
7708462SApril.Chin@Sun.COM 					if(np==SYSTYPESET ||  (np && np->nvalue.bfp==SYSTYPESET->nvalue.bfp))
7714887Schin #endif
7724887Schin 					{
7738462SApril.Chin@Sun.COM 						if(np!=SYSTYPESET)
7748462SApril.Chin@Sun.COM 							shp->typeinit = np;
7758462SApril.Chin@Sun.COM 						if(checkopt(com,'C'))
7768462SApril.Chin@Sun.COM 							flgs |= NV_COMVAR;
7778462SApril.Chin@Sun.COM 						if(checkopt(com,'S'))
7788462SApril.Chin@Sun.COM 							flgs |= NV_STATIC;
7794887Schin 						if(checkopt(com,'n'))
7804887Schin 							flgs |= NV_NOREF;
7814887Schin #if SHOPT_TYPEDEF
7828462SApril.Chin@Sun.COM 						else if(argn>=3 && checkopt(com,'T'))
7834887Schin 						{
7848462SApril.Chin@Sun.COM 							shp->prefix = NV_CLASS;
7854887Schin 							flgs |= NV_TYPE;
7864887Schin 
7874887Schin 						}
7884887Schin #endif /* SHOPT_TYPEDEF */
7898462SApril.Chin@Sun.COM 						if((shp->fn_depth && !shp->prefix) || np==SYSLOCAL)
7904887Schin 							flgs |= NV_NOSCOPE;
7914887Schin 					}
7924887Schin 					else if(np==SYSEXPORT)
7934887Schin 						flgs |= NV_EXPORT;
7948462SApril.Chin@Sun.COM 					if(flgs&(NV_EXPORT|NV_NOREF))
7958462SApril.Chin@Sun.COM 						flgs |= NV_IDENT;
7968462SApril.Chin@Sun.COM 					else
7978462SApril.Chin@Sun.COM 						flgs |= NV_VARNAME;
7984887Schin #if 0
7994887Schin 					if(OPTIMIZE)
8004887Schin 						flgs |= NV_TAGGED;
8014887Schin #endif
8024887Schin 					nv_setlist(argp,flgs);
8038462SApril.Chin@Sun.COM 					if(np==shp->typeinit)
8048462SApril.Chin@Sun.COM 						shp->typeinit = 0;
8058462SApril.Chin@Sun.COM 					shp->envlist = argp;
8064887Schin 					argp = NULL;
8074887Schin 				}
8084887Schin 			}
8098462SApril.Chin@Sun.COM 			last_table = shp->last_table;
8108462SApril.Chin@Sun.COM 			shp->last_table = 0;
8114887Schin 			if((io||argn))
8124887Schin 			{
8138462SApril.Chin@Sun.COM 				Shbltin_t *bp=0;
8144887Schin 				static char *argv[1];
8158462SApril.Chin@Sun.COM 				int tflags = 1;
8168462SApril.Chin@Sun.COM 				if(np &&  nv_isattr(np,BLT_DCL))
8178462SApril.Chin@Sun.COM 					tflags |= 2;
8184887Schin 				if(argn==0)
8194887Schin 				{
8204887Schin 					/* fake 'true' built-in */
8214887Schin 					np = SYSTRUE;
8224887Schin 					*argv = nv_name(np);
8234887Schin 					com = argv;
8244887Schin 				}
8254887Schin 				/* set +x doesn't echo */
8264887Schin 				else if((np!=SYSSET) && sh_isoption(SH_XTRACE))
8278462SApril.Chin@Sun.COM 					sh_trace(com-command,tflags);
8284887Schin 				else if((t->tre.tretyp&FSHOWME) && sh_isoption(SH_SHOWME))
8294887Schin 				{
8304887Schin 					int ison = sh_isoption(SH_XTRACE);
8314887Schin 					if(!ison)
8324887Schin 						sh_onoption(SH_XTRACE);
8338462SApril.Chin@Sun.COM 					sh_trace(com-command,tflags);
8344887Schin 					if(io)
8358462SApril.Chin@Sun.COM 						sh_redirect(shp,io,SH_SHOWME);
8364887Schin 					if(!ison)
8374887Schin 						sh_offoption(SH_XTRACE);
8384887Schin 					break;
8394887Schin 				}
8408462SApril.Chin@Sun.COM 				if(trap=shp->st.trap[SH_DEBUGTRAP])
8418462SApril.Chin@Sun.COM 				{
8428462SApril.Chin@Sun.COM 					int n = sh_debug(shp,trap,(char*)0,(char*)0, com, ARG_RAW);
8438462SApril.Chin@Sun.COM 					if(n==255 && shp->fn_depth+shp->dot_depth)
8448462SApril.Chin@Sun.COM 					{
8458462SApril.Chin@Sun.COM 						np = SYSRETURN;
8468462SApril.Chin@Sun.COM 						argn = 1;
8478462SApril.Chin@Sun.COM 						com[0] = np->nvname;
8488462SApril.Chin@Sun.COM 						com[1] = 0;
8498462SApril.Chin@Sun.COM 						io = 0;
8508462SApril.Chin@Sun.COM 						argp = 0;
8518462SApril.Chin@Sun.COM 					}
8528462SApril.Chin@Sun.COM 					else if(n==2)
8538462SApril.Chin@Sun.COM 						break;
8548462SApril.Chin@Sun.COM 				}
8554887Schin 				if(io)
8568462SApril.Chin@Sun.COM 					sfsync(shp->outpool);
8578462SApril.Chin@Sun.COM 				shp->lastpath = 0;
8584887Schin 				if(!np  && !strchr(com0,'/'))
8594887Schin 				{
8608462SApril.Chin@Sun.COM 					if(path_search(com0,NIL(Pathcomp_t**),1))
8618462SApril.Chin@Sun.COM 					{
8628462SApril.Chin@Sun.COM 						error_info.line = t->com.comline-shp->st.firstline;
8638462SApril.Chin@Sun.COM 						if((np=nv_search(com0,shp->fun_tree,0)) && !np->nvalue.ip)
8648462SApril.Chin@Sun.COM 						{
8658462SApril.Chin@Sun.COM 							Namval_t *mp=nv_search(com0,shp->bltin_tree,0);
8668462SApril.Chin@Sun.COM 							if(mp)
8678462SApril.Chin@Sun.COM 								np = mp;
8688462SApril.Chin@Sun.COM 						}
8698462SApril.Chin@Sun.COM 					}
8704887Schin 					else
8714887Schin 					{
8728462SApril.Chin@Sun.COM 						if((np=nv_search(com0,shp->track_tree,0)) && !nv_isattr(np,NV_NOALIAS) && np->nvalue.cp)
8738462SApril.Chin@Sun.COM 							np=nv_search(nv_getval(np),shp->bltin_tree,0);
8744887Schin 						else
8754887Schin 							np = 0;
8764887Schin 					}
8774887Schin 				}
8784887Schin 				/* check for builtins */
8794887Schin 				if(np && is_abuiltin(np))
8804887Schin 				{
8818462SApril.Chin@Sun.COM 					volatile int scope=0, share=0;
8828462SApril.Chin@Sun.COM 					volatile void *save_ptr;
8838462SApril.Chin@Sun.COM 					volatile void *save_data;
8848462SApril.Chin@Sun.COM 					int jmpval, save_prompt;
8854887Schin 					struct checkpt buff;
8864887Schin 					unsigned long was_vi=0, was_emacs=0, was_gmacs=0;
8874887Schin 					struct stat statb;
8888462SApril.Chin@Sun.COM 					bp = &shp->bltindata;
8898462SApril.Chin@Sun.COM 					save_ptr = bp->ptr;
8908462SApril.Chin@Sun.COM 					save_data = bp->data;
8918462SApril.Chin@Sun.COM 					memset(&statb, 0, sizeof(struct stat));
8924887Schin 					if(strchr(nv_name(np),'/'))
8934887Schin 					{
8944887Schin 						/*
8954887Schin 						 * disable editors for built-in
8964887Schin 						 * versions of commands on PATH
8974887Schin 						 */
8984887Schin 						was_vi = sh_isoption(SH_VI);
8994887Schin 						was_emacs = sh_isoption(SH_EMACS);
9004887Schin 						was_gmacs = sh_isoption(SH_GMACS);
9014887Schin 						sh_offoption(SH_VI);
9024887Schin 						sh_offoption(SH_EMACS);
9034887Schin 						sh_offoption(SH_GMACS);
9044887Schin 					}
9054887Schin 					sh_pushcontext(&buff,SH_JMPCMD);
9064887Schin 					jmpval = sigsetjmp(buff.buff,1);
9074887Schin 					if(jmpval == 0)
9084887Schin 					{
9094887Schin 						if(!(nv_isattr(np,BLT_ENV)))
9104887Schin 							error_info.flags |= ERROR_SILENT;
9114887Schin 						errorpush(&buff.err,0);
9124887Schin 						if(io)
9134887Schin 						{
9144887Schin 							struct openlist *item;
9154887Schin 							if(np==SYSLOGIN)
9164887Schin 								type=1;
9174887Schin 							else if(np==SYSEXEC)
9184887Schin 								type=1+!com[1];
9194887Schin 							else
9208462SApril.Chin@Sun.COM 								type = (execflg && !shp->subshell && !shp->st.trapcom[0]);
9218462SApril.Chin@Sun.COM 							sh_redirect(shp,io,type);
9224887Schin 							for(item=buff.olist;item;item=item->next)
9234887Schin 								item->strm=0;
9244887Schin 						}
9254887Schin 						if(!(nv_isattr(np,BLT_ENV)))
9264887Schin 						{
9278462SApril.Chin@Sun.COM 							if(bp->nosfio)
9288462SApril.Chin@Sun.COM 							{
9298462SApril.Chin@Sun.COM 								if(!shp->pwd)
9308462SApril.Chin@Sun.COM 									path_pwd(0);
9318462SApril.Chin@Sun.COM 								if(shp->pwd)
9328462SApril.Chin@Sun.COM 									stat(".",&statb);
9338462SApril.Chin@Sun.COM 							}
9348462SApril.Chin@Sun.COM 							sfsync(NULL);
9354887Schin 							share = sfset(sfstdin,SF_SHARE,0);
9364887Schin 							sh_onstate(SH_STOPOK);
9374887Schin 							sfpool(sfstderr,NIL(Sfio_t*),SF_WRITE);
9384887Schin 							sfset(sfstderr,SF_LINE,1);
9398462SApril.Chin@Sun.COM 							save_prompt = shp->nextprompt;
9408462SApril.Chin@Sun.COM 							shp->nextprompt = 0;
9414887Schin 						}
9424887Schin 						if(argp)
9434887Schin 						{
9444887Schin 							scope++;
9458462SApril.Chin@Sun.COM 							sh_scope(shp,argp,0);
9464887Schin 						}
9474887Schin 						opt_info.index = opt_info.offset = 0;
9484887Schin 						opt_info.disc = 0;
9494887Schin 						error_info.id = *com;
9508462SApril.Chin@Sun.COM 						if(argn)
9518462SApril.Chin@Sun.COM 							shp->exitval = 0;
9528462SApril.Chin@Sun.COM 						shp->bltinfun = funptr(np);
9538462SApril.Chin@Sun.COM 						bp->bnode = np;
9548462SApril.Chin@Sun.COM 						bp->vnode = nq;
9558462SApril.Chin@Sun.COM 						bp->ptr = nv_context(np);
9568462SApril.Chin@Sun.COM 						bp->data = t->com.comstate;
9578462SApril.Chin@Sun.COM 						bp->sigset = 0;
9588462SApril.Chin@Sun.COM 						bp->notify = 0;
9598462SApril.Chin@Sun.COM 						bp->flags = (OPTIMIZE!=0);
9608462SApril.Chin@Sun.COM 						if(shp->subshell && nv_isattr(np,BLT_NOSFIO))
9618462SApril.Chin@Sun.COM 							sh_subtmpfile(0);
9628462SApril.Chin@Sun.COM 						if(execflg && !shp->subshell &&
9638462SApril.Chin@Sun.COM 							!shp->st.trapcom[0] && !shp->st.trap[SH_ERRTRAP] && shp->fn_depth==0 && !nv_isattr(np,BLT_ENV))
9644887Schin 						{
9654887Schin 							/* do close-on-exec */
9664887Schin 							int fd;
9678462SApril.Chin@Sun.COM 							for(fd=0; fd < shp->lim.open_max; fd++)
9688462SApril.Chin@Sun.COM 								if((shp->fdstatus[fd]&IOCLEX)&&fd!=shp->infd)
9694887Schin 									sh_close(fd);
9704887Schin 						}
9718462SApril.Chin@Sun.COM 						if(argn)
9728462SApril.Chin@Sun.COM 							shp->exitval = (*shp->bltinfun)(argn,com,(void*)bp);
9734887Schin 						if(error_info.flags&ERROR_INTERACTIVE)
9744887Schin 							tty_check(ERRIO);
9758462SApril.Chin@Sun.COM 						((Shnode_t*)t)->com.comstate = shp->bltindata.data;
9768462SApril.Chin@Sun.COM 						bp->data = (void*)save_data;
9778462SApril.Chin@Sun.COM 						if(!nv_isattr(np,BLT_EXIT) && shp->exitval!=SH_RUNPROG)
9788462SApril.Chin@Sun.COM 							shp->exitval &= SH_EXITMASK;
9794887Schin 					}
9804887Schin 					else
9814887Schin 					{
9824887Schin 						struct openlist *item;
9834887Schin 						for(item=buff.olist;item;item=item->next)
9844887Schin 						{
9854887Schin 							if(item->strm)
9864887Schin 							{
9874887Schin 								sfclrlock(item->strm);
9888462SApril.Chin@Sun.COM 								if(shp->hist_ptr && item->strm == shp->hist_ptr->histfp)
9898462SApril.Chin@Sun.COM 									hist_close(shp->hist_ptr);
9904887Schin 								else
9914887Schin 									sfclose(item->strm);
9924887Schin 							}
9934887Schin 						}
9948462SApril.Chin@Sun.COM 						if(shp->bltinfun && (error_info.flags&ERROR_NOTIFY))
9958462SApril.Chin@Sun.COM 							(*shp->bltinfun)(-2,com,(void*)bp);
9964887Schin 						/* failure on special built-ins fatal */
9974887Schin 						if(jmpval<=SH_JMPCMD  && (!nv_isattr(np,BLT_SPC) || command))
9984887Schin 							jmpval=0;
9994887Schin 					}
10008462SApril.Chin@Sun.COM 					if(bp && bp->ptr!= nv_context(np))
10018462SApril.Chin@Sun.COM 						np->nvfun = (Namfun_t*)bp->ptr;
10024887Schin 					if(!(nv_isattr(np,BLT_ENV)))
10034887Schin 					{
10048462SApril.Chin@Sun.COM 						if(bp->nosfio && shp->pwd)
10054887Schin 						{
10064887Schin 							struct stat stata;
10074887Schin 							stat(".",&stata);
10084887Schin 							/* restore directory changed */
10094887Schin 							if(statb.st_ino!=stata.st_ino || statb.st_dev!=stata.st_dev)
10108462SApril.Chin@Sun.COM 								chdir(shp->pwd);
10114887Schin 						}
10124887Schin 						sh_offstate(SH_STOPOK);
10134887Schin 						if(share&SF_SHARE)
10144887Schin 							sfset(sfstdin,SF_PUBLIC|SF_SHARE,1);
10154887Schin 						sfset(sfstderr,SF_LINE,0);
10168462SApril.Chin@Sun.COM 						sfpool(sfstderr,shp->outpool,SF_WRITE);
10174887Schin 						sfpool(sfstdin,NIL(Sfio_t*),SF_WRITE);
10188462SApril.Chin@Sun.COM 						shp->nextprompt = save_prompt;
10194887Schin 					}
10204887Schin 					sh_popcontext(&buff);
10214887Schin 					errorpop(&buff.err);
10224887Schin 					error_info.flags &= ~ERROR_SILENT;
10238462SApril.Chin@Sun.COM 					shp->bltinfun = 0;
10244887Schin 					if(buff.olist)
10254887Schin 						free_list(buff.olist);
10264887Schin 					if(was_vi)
10274887Schin 						sh_onoption(SH_VI);
10284887Schin 					else if(was_emacs)
10294887Schin 						sh_onoption(SH_EMACS);
10304887Schin 					else if(was_gmacs)
10314887Schin 						sh_onoption(SH_GMACS);
10324887Schin 					if(scope)
10338462SApril.Chin@Sun.COM 						sh_unscope(shp);
10348462SApril.Chin@Sun.COM 					bp->ptr = (void*)save_ptr;
10358462SApril.Chin@Sun.COM 					bp->data = (void*)save_data;
10364887Schin 					/* don't restore for subshell exec */
10378462SApril.Chin@Sun.COM 					if((shp->topfd>topfd) && !(shp->subshell && np==SYSEXEC))
10388462SApril.Chin@Sun.COM 						sh_iorestore(shp,topfd,jmpval);
10394887Schin 					if(jmpval)
10408462SApril.Chin@Sun.COM 						siglongjmp(*shp->jmplist,jmpval);
10418462SApril.Chin@Sun.COM #if 0
10428462SApril.Chin@Sun.COM 					if(flgs&NV_STATIC)
10438462SApril.Chin@Sun.COM 						((Shnode_t*)t)->com.comset = 0;
10448462SApril.Chin@Sun.COM #endif
10458462SApril.Chin@Sun.COM 					if(shp->exitval >=0)
10464887Schin 						goto setexit;
10474887Schin 					np = 0;
10484887Schin 					type=0;
10494887Schin 				}
10504887Schin 				/* check for functions */
10514887Schin 				if(!command && np && nv_isattr(np,NV_FUNCTION))
10524887Schin 				{
10538462SApril.Chin@Sun.COM 					volatile int indx;
10548462SApril.Chin@Sun.COM 					int jmpval=0;
10554887Schin 					struct checkpt buff;
10564887Schin 					Namval_t node;
10578462SApril.Chin@Sun.COM 					struct Namref	nr;
10588462SApril.Chin@Sun.COM 					long		mode;
10594887Schin 					register struct slnod *slp;
10604887Schin 					if(!np->nvalue.ip)
10614887Schin 					{
10628462SApril.Chin@Sun.COM 						indx = path_search(com0,NIL(Pathcomp_t**),0);
10634887Schin 						if(indx==1)
10648462SApril.Chin@Sun.COM 							np = nv_search(com0,shp->fun_tree,HASH_NOSCOPE);
10658462SApril.Chin@Sun.COM 
10664887Schin 						if(!np->nvalue.ip)
10674887Schin 						{
10684887Schin 							if(indx==1)
10694887Schin 							{
10704887Schin 								errormsg(SH_DICT,ERROR_exit(0),e_defined,com0);
10718462SApril.Chin@Sun.COM 								shp->exitval = ERROR_NOEXEC;
10724887Schin 							}
10734887Schin 							else
10744887Schin 							{
10754887Schin 								errormsg(SH_DICT,ERROR_exit(0),e_found,"function");
10768462SApril.Chin@Sun.COM 								shp->exitval = ERROR_NOENT;
10774887Schin 							}
10784887Schin 							goto setexit;
10794887Schin 						}
10804887Schin 					}
10814887Schin 					/* increase refcnt for unset */
10824887Schin 					slp = (struct slnod*)np->nvenv;
10834887Schin 					sh_funstaks(slp->slchild,1);
10844887Schin 					staklink(slp->slptr);
10854887Schin 					if(nq)
10864887Schin 					{
10878462SApril.Chin@Sun.COM 						shp->last_table = last_table;
10888462SApril.Chin@Sun.COM 						mode = set_instance(nq,&node,&nr);
10894887Schin 					}
10904887Schin 					if(io)
10914887Schin 					{
10928462SApril.Chin@Sun.COM 						indx = shp->topfd;
10934887Schin 						sh_pushcontext(&buff,SH_JMPCMD);
10944887Schin 						jmpval = sigsetjmp(buff.buff,0);
10954887Schin 					}
10964887Schin 					if(jmpval == 0)
10974887Schin 					{
10984887Schin 						if(io)
10998462SApril.Chin@Sun.COM 							indx = sh_redirect(shp,io,execflg);
11008462SApril.Chin@Sun.COM 						sh_funct(shp,np,argn,com,t->com.comset,(flags&~OPTIMIZE_FLAG));
11014887Schin 					}
11024887Schin 					if(io)
11034887Schin 					{
11044887Schin 						if(buff.olist)
11054887Schin 							free_list(buff.olist);
11064887Schin 						sh_popcontext(&buff);
11078462SApril.Chin@Sun.COM 						sh_iorestore(shp,indx,jmpval);
11084887Schin 					}
11094887Schin 					if(nq)
11108462SApril.Chin@Sun.COM 						unset_instance(nq,&node,&nr,mode);
11114887Schin 					sh_funstaks(slp->slchild,-1);
11124887Schin 					stakdelete(slp->slptr);
11134887Schin 					if(jmpval > SH_JMPFUN)
11148462SApril.Chin@Sun.COM 						siglongjmp(*shp->jmplist,jmpval);
11154887Schin 					goto setexit;
11164887Schin 				}
11174887Schin 			}
11184887Schin 			else if(!io)
11194887Schin 			{
11204887Schin 			setexit:
11214887Schin 				exitset();
11224887Schin 				break;
11234887Schin 			}
11244887Schin 		    }
11254887Schin 		    case TFORK:
11264887Schin 		    {
11274887Schin 			register pid_t parent;
11284887Schin 			int no_fork,jobid;
11294887Schin 			int pipes[2];
11304887Schin 			no_fork = (execflg && !(type&(FAMP|FPOU)) &&
11318462SApril.Chin@Sun.COM #if SHOPT_AMP || SHOPT_SPAWN
11328462SApril.Chin@Sun.COM 				!ntflag &&
11338462SApril.Chin@Sun.COM #endif
11348462SApril.Chin@Sun.COM 				!shp->subshell && !shp->st.trapcom[0] &&
11358462SApril.Chin@Sun.COM 				!shp->st.trap[SH_ERRTRAP] && shp->fn_depth==0 &&
11368462SApril.Chin@Sun.COM 				!(pipejob && sh_isoption(SH_PIPEFAIL)));
11378462SApril.Chin@Sun.COM 			if(shp->subshell)
11388462SApril.Chin@Sun.COM 				sh_subtmpfile(1);
11398462SApril.Chin@Sun.COM 			if(sh_isstate(SH_PROFILE) || shp->dot_depth)
11404887Schin 			{
11414887Schin 				/* disable foreground job monitor */
11424887Schin 				if(!(type&FAMP))
11434887Schin 					sh_offstate(SH_MONITOR);
11444887Schin #if SHOPT_DEVFD
11454887Schin 				else if(!(type&FINT))
11464887Schin 					sh_offstate(SH_MONITOR);
11474887Schin #endif /* SHOPT_DEVFD */
11484887Schin 			}
11494887Schin 			if(no_fork)
11504887Schin 				job.parent=parent=0;
11514887Schin 			else
11524887Schin 			{
11534887Schin 				if(type&FCOOP)
11548462SApril.Chin@Sun.COM 					coproc_init(shp,pipes);
11554887Schin 				nv_getval(RANDNOD);
11564887Schin #if SHOPT_AMP
11574887Schin 				if((type&(FAMP|FINT)) == (FAMP|FINT))
11588462SApril.Chin@Sun.COM 					parent = sh_ntfork(shp,t,com,&jobid,ntflag);
11594887Schin 				else
11604887Schin 					parent = sh_fork(type,&jobid);
11614887Schin 				if(parent<0)
11624887Schin 					break;
11634887Schin #else
11644887Schin #if SHOPT_SPAWN
11654887Schin #   ifdef _lib_fork
11664887Schin 				if(com)
11678462SApril.Chin@Sun.COM 					parent = sh_ntfork(shp,t,com,&jobid,ntflag);
11684887Schin 				else
11694887Schin 					parent = sh_fork(type,&jobid);
11704887Schin #   else
11718462SApril.Chin@Sun.COM 				if((parent = sh_ntfork(shp,t,com,&jobid,ntflag))<=0)
11724887Schin 					break;
11734887Schin #   endif /* _lib_fork */
11744887Schin 				if(parent<0)
11754887Schin 					break;
11764887Schin #else
11774887Schin 				parent = sh_fork(type,&jobid);
11784887Schin #endif /* SHOPT_SPAWN */
11794887Schin #endif
11804887Schin 			}
11814887Schin 			if(job.parent=parent)
11824887Schin 			/* This is the parent branch of fork
11834887Schin 			 * It may or may not wait for the child
11844887Schin 			 */
11854887Schin 			{
11864887Schin 				if(type&FPCL)
11878462SApril.Chin@Sun.COM 					sh_close(shp->inpipe[0]);
11884887Schin 				if(type&(FCOOP|FAMP))
11898462SApril.Chin@Sun.COM 					shp->bckpid = parent;
11908462SApril.Chin@Sun.COM 				else if(!(type&(FAMP|FPOU)))
11914887Schin 				{
11928462SApril.Chin@Sun.COM 					if(shp->topfd > topfd)
11938462SApril.Chin@Sun.COM 						sh_iorestore(shp,topfd,0);
11948462SApril.Chin@Sun.COM 					if(!sh_isoption(SH_MONITOR))
11958462SApril.Chin@Sun.COM 					{
11968462SApril.Chin@Sun.COM 						if(!(shp->sigflag[SIGINT]&(SH_SIGFAULT|SH_SIGOFF)))
11978462SApril.Chin@Sun.COM 							sh_sigtrap(SIGINT);
11988462SApril.Chin@Sun.COM 						shp->trapnote |= SH_SIGIGNORE;
11998462SApril.Chin@Sun.COM 					}
12008462SApril.Chin@Sun.COM 					if(execflg && shp->subshell)
12018462SApril.Chin@Sun.COM 					{
12028462SApril.Chin@Sun.COM 						shp->spid = parent;
12038462SApril.Chin@Sun.COM 						job.pwlist->p_env--;
12048462SApril.Chin@Sun.COM 					}
12058462SApril.Chin@Sun.COM 					else
12068462SApril.Chin@Sun.COM 						job_wait(parent);
12078462SApril.Chin@Sun.COM 					if(!sh_isoption(SH_MONITOR))
12088462SApril.Chin@Sun.COM 					{
12098462SApril.Chin@Sun.COM 						shp->trapnote &= ~SH_SIGIGNORE;
12108462SApril.Chin@Sun.COM 						if(shp->exitval == (SH_EXITSIG|SIGINT))
12118462SApril.Chin@Sun.COM 							sh_fault(SIGINT);
12128462SApril.Chin@Sun.COM 					}
12134887Schin 				}
12144887Schin 				if(type&FAMP)
12154887Schin 				{
12164887Schin 					if(sh_isstate(SH_PROFILE) || sh_isstate(SH_INTERACTIVE))
12174887Schin 					{
12184887Schin 						/* print job number */
12194887Schin #ifdef JOBS
12204887Schin 						sfprintf(sfstderr,"[%d]\t%d\n",jobid,parent);
12214887Schin #else
12224887Schin 						sfprintf(sfstderr,"%d\n",parent);
12234887Schin #endif /* JOBS */
12244887Schin 					}
12254887Schin 				}
12264887Schin 				break;
12274887Schin 			}
12284887Schin 			else
12294887Schin 			/*
12304887Schin 			 * this is the FORKED branch (child) of execute
12314887Schin 			 */
12324887Schin 			{
12338462SApril.Chin@Sun.COM 				volatile int jmpval;
12344887Schin 				struct checkpt buff;
12354887Schin 				if(no_fork)
12364887Schin 					sh_sigreset(2);
12374887Schin 				sh_pushcontext(&buff,SH_JMPEXIT);
12384887Schin 				jmpval = sigsetjmp(buff.buff,0);
12394887Schin 				if(jmpval)
12404887Schin 					goto done;
12414887Schin 				if((type&FINT) && !sh_isstate(SH_MONITOR))
12424887Schin 				{
12434887Schin 					/* default std input for & */
12444887Schin 					signal(SIGINT,SIG_IGN);
12454887Schin 					signal(SIGQUIT,SIG_IGN);
12468462SApril.Chin@Sun.COM 					if(!shp->st.ioset)
12474887Schin 					{
12484887Schin 						if(sh_close(0)>=0)
12494887Schin 							sh_chkopen(e_devnull);
12504887Schin 					}
12514887Schin 				}
12524887Schin 				sh_offstate(SH_MONITOR);
12534887Schin 				/* pipe in or out */
12544887Schin #ifdef _lib_nice
12554887Schin 				if((type&FAMP) && sh_isoption(SH_BGNICE))
12564887Schin 					nice(4);
12574887Schin #endif /* _lib_nice */
12584887Schin 				if(type&FPIN)
12594887Schin 				{
12608462SApril.Chin@Sun.COM 					sh_iorenumber(shp,shp->inpipe[0],0);
12614887Schin 					if(!(type&FPOU) || (type&FCOOP))
12628462SApril.Chin@Sun.COM 						sh_close(shp->inpipe[1]);
12634887Schin 				}
12644887Schin 				if(type&FPOU)
12654887Schin 				{
12668462SApril.Chin@Sun.COM 					sh_iorenumber(shp,shp->outpipe[1],1);
12678462SApril.Chin@Sun.COM 					sh_pclose(shp->outpipe);
12684887Schin 				}
12694887Schin 				if((type&COMMSK)!=TCOM)
12708462SApril.Chin@Sun.COM 					error_info.line = t->fork.forkline-shp->st.firstline;
12718462SApril.Chin@Sun.COM 				if(shp->topfd)
12728462SApril.Chin@Sun.COM 					sh_iounsave(shp);
12738462SApril.Chin@Sun.COM 				topfd = shp->topfd;
12748462SApril.Chin@Sun.COM 				sh_redirect(shp,t->tre.treio,1);
12758462SApril.Chin@Sun.COM 				if(shp->topfd > topfd)
12768462SApril.Chin@Sun.COM 				{
12778462SApril.Chin@Sun.COM 					while((parent = vfork()) < 0)
12788462SApril.Chin@Sun.COM 						_sh_fork(parent, 0, (int*)0);
12798462SApril.Chin@Sun.COM 					if(parent)
12808462SApril.Chin@Sun.COM 					{
12818462SApril.Chin@Sun.COM 						job_clear();
12828462SApril.Chin@Sun.COM 						job_post(parent,0);
12838462SApril.Chin@Sun.COM 						job_wait(parent);
12848462SApril.Chin@Sun.COM 						sh_iorestore(shp,topfd,SH_JMPCMD);
12858462SApril.Chin@Sun.COM 						sh_done(shp,(shp->exitval&SH_EXITSIG)?(shp->exitval&SH_EXITMASK):0);
12868462SApril.Chin@Sun.COM 
12878462SApril.Chin@Sun.COM 					}
12888462SApril.Chin@Sun.COM 				}
12894887Schin 				if((type&COMMSK)!=TCOM)
12904887Schin 				{
12914887Schin 					/* don't clear job table for out
12924887Schin 					   pipes so that jobs comand can
12934887Schin 					   be used in a pipeline
12944887Schin 					 */
12954887Schin 					if(!no_fork && !(type&FPOU))
12964887Schin 						job_clear();
12974887Schin 					sh_exec(t->fork.forktre,flags|sh_state(SH_NOFORK));
12984887Schin 				}
12994887Schin 				else if(com0)
13004887Schin 				{
13014887Schin 					sh_offoption(SH_ERREXIT);
13028462SApril.Chin@Sun.COM 					sh_freeup(shp);
13034887Schin 					path_exec(com0,com,t->com.comset);
13044887Schin 				}
13054887Schin 			done:
13064887Schin 				sh_popcontext(&buff);
13074887Schin 				if(jmpval>SH_JMPEXIT)
13088462SApril.Chin@Sun.COM 					siglongjmp(*shp->jmplist,jmpval);
13098462SApril.Chin@Sun.COM 				sh_done(shp,0);
13104887Schin 			}
13114887Schin 		    }
13124887Schin 
13134887Schin 		    case TSETIO:
13144887Schin 		    {
13154887Schin 		    /*
13164887Schin 		     * don't create a new process, just
13174887Schin 		     * save and restore io-streams
13184887Schin 		     */
13194887Schin 			pid_t	pid;
13204887Schin 			int jmpval, waitall;
13214887Schin 			struct checkpt buff;
13228462SApril.Chin@Sun.COM 			if(shp->subshell)
13234887Schin 				execflg = 0;
13244887Schin 			sh_pushcontext(&buff,SH_JMPIO);
13254887Schin 			if(type&FPIN)
13264887Schin 			{
13274887Schin 				was_interactive = sh_isstate(SH_INTERACTIVE);
13284887Schin 				sh_offstate(SH_INTERACTIVE);
13294887Schin 				if(!execflg)
13308462SApril.Chin@Sun.COM 					sh_iosave(shp,0,shp->topfd,(char*)0);
13318462SApril.Chin@Sun.COM 				sh_iorenumber(shp,shp->inpipe[0],0);
13324887Schin 				/*
13334887Schin 				 * if read end of pipe is a simple command
13344887Schin 				 * treat as non-sharable to improve performance
13354887Schin 				 */
13364887Schin 				if((t->fork.forktre->tre.tretyp&COMMSK)==TCOM)
13374887Schin 					sfset(sfstdin,SF_PUBLIC|SF_SHARE,0);
13384887Schin 				waitall = job.waitall;
13394887Schin 				job.waitall = 0;
13404887Schin 				pid = job.parent;
13414887Schin 			}
13424887Schin 			else
13438462SApril.Chin@Sun.COM 				error_info.line = t->fork.forkline-shp->st.firstline;
13444887Schin 			jmpval = sigsetjmp(buff.buff,0);
13454887Schin 			if(jmpval==0)
13464887Schin 			{
13478462SApril.Chin@Sun.COM 				sh_redirect(shp,t->fork.forkio,execflg);
13484887Schin 				(t->fork.forktre)->tre.tretyp |= t->tre.tretyp&FSHOWME;
13494887Schin 				sh_exec(t->fork.forktre,flags);
13504887Schin 			}
13518462SApril.Chin@Sun.COM 			else
13528462SApril.Chin@Sun.COM 				sfsync(shp->outpool);
13534887Schin 			sh_popcontext(&buff);
13548462SApril.Chin@Sun.COM 			sh_iorestore(shp,buff.topfd,jmpval);
13554887Schin 			if(buff.olist)
13564887Schin 				free_list(buff.olist);
13574887Schin 			if(type&FPIN)
13584887Schin 			{
13594887Schin 				job.waitall = waitall;
13608462SApril.Chin@Sun.COM 				type = shp->exitval;
13614887Schin 				if(!(type&SH_EXITSIG))
13624887Schin 				{
13634887Schin 					/* wait for remainder of pipline */
13644887Schin 					job_wait(waitall?pid:0);
13654887Schin 					if(type || !sh_isoption(SH_PIPEFAIL))
13668462SApril.Chin@Sun.COM 						shp->exitval = type;
13674887Schin 				}
13688462SApril.Chin@Sun.COM 				shp->st.ioset = 0;
13694887Schin 			}
13704887Schin 			if(jmpval>SH_JMPIO)
13718462SApril.Chin@Sun.COM 				siglongjmp(*shp->jmplist,jmpval);
13724887Schin 			break;
13734887Schin 		    }
13744887Schin 
13754887Schin 		    case TPAR:
13764887Schin 			echeck = 1;
13774887Schin 			flags &= ~OPTIMIZE_FLAG;
13788462SApril.Chin@Sun.COM 			if(!shp->subshell && !shp->st.trapcom[0] && !shp->st.trap[SH_ERRTRAP] && (flags&sh_state(SH_NOFORK)))
13794887Schin 			{
13804887Schin 				int jmpval;
13814887Schin 				struct checkpt buff;
13824887Schin 				sh_pushcontext(&buff,SH_JMPEXIT);
13834887Schin 				jmpval = sigsetjmp(buff.buff,0);
13844887Schin 				if(jmpval==0)
13854887Schin 					sh_exec(t->par.partre,flags);
13864887Schin 				sh_popcontext(&buff);
13874887Schin 				if(jmpval > SH_JMPEXIT)
13888462SApril.Chin@Sun.COM 					siglongjmp(*shp->jmplist,jmpval);
13898462SApril.Chin@Sun.COM 				sh_done(shp,0);
13904887Schin 			}
13914887Schin 			else
13924887Schin 				sh_subshell(t->par.partre,flags,0);
13934887Schin 			break;
13944887Schin 
13954887Schin 		    case TFIL:
13964887Schin 		    {
13974887Schin 		    /*
13984887Schin 		     * This code sets up a pipe.
13994887Schin 		     * All elements of the pipe are started by the parent.
14004887Schin 		     * The last element executes in current environment
14014887Schin 		     */
14024887Schin 			int	pvo[2];	/* old pipe for multi-stage */
14034887Schin 			int	pvn[2];	/* current set up pipe */
14044887Schin 			int	savepipe = pipejob;
14054887Schin 			int	showme = t->tre.tretyp&FSHOWME;
14064887Schin 			pid_t	savepgid = job.curpgid;
14078462SApril.Chin@Sun.COM 			job.curpgid = 0;
14088462SApril.Chin@Sun.COM 			if(shp->subshell)
1409*8810SCasper.Dik@Sun.COM 			{
1410*8810SCasper.Dik@Sun.COM 				if(shp->subshare)
1411*8810SCasper.Dik@Sun.COM 					sh_subtmpfile(0);
1412*8810SCasper.Dik@Sun.COM 				else
1413*8810SCasper.Dik@Sun.COM 					sh_subfork();
1414*8810SCasper.Dik@Sun.COM 			}
14158462SApril.Chin@Sun.COM 			shp->inpipe = pvo;
14168462SApril.Chin@Sun.COM 			shp->outpipe = pvn;
14174887Schin 			pvo[1] = -1;
14184887Schin 			if(sh_isoption(SH_PIPEFAIL))
14194887Schin 				job.waitall = 1;
14204887Schin 			else
14214887Schin 				job.waitall |= !pipejob && sh_isstate(SH_MONITOR);
14224887Schin 			do
14234887Schin 			{
14244887Schin #if SHOPT_FASTPIPE
14258462SApril.Chin@Sun.COM 				type = pipe_exec(shp,pvn,t->lst.lstlef, errorflg);
14264887Schin #else
14274887Schin 				/* create the pipe */
14284887Schin 				sh_pipe(pvn);
14294887Schin 				/* execute out part of pipe no wait */
14304887Schin 				(t->lst.lstlef)->tre.tretyp |= showme;
14314887Schin 				type = sh_exec(t->lst.lstlef, errorflg);
14324887Schin #endif /* SHOPT_FASTPIPE */
14334887Schin 				pipejob=1;
14344887Schin 				/* save the pipe stream-ids */
14354887Schin 				pvo[0] = pvn[0];
14364887Schin 				/* close out-part of pipe */
14374887Schin 				sh_close(pvn[1]);
14384887Schin 				/* pipeline all in one process group */
14394887Schin 				t = t->lst.lstrit;
14404887Schin 			}
14414887Schin 			/* repeat until end of pipeline */
14424887Schin 			while(!type && t->tre.tretyp==TFIL);
14438462SApril.Chin@Sun.COM 			shp->inpipe = pvn;
14448462SApril.Chin@Sun.COM 			shp->outpipe = 0;
14454887Schin 			if(type == 0)
14464887Schin 			{
14474887Schin 				/*
14484887Schin 				 * execute last element of pipeline
14494887Schin 				 * in the current process
14504887Schin 				 */
14514887Schin 				((Shnode_t*)t)->tre.tretyp |= showme;
14524887Schin 				sh_exec(t,flags);
14534887Schin 			}
14544887Schin 			else
14554887Schin 				/* execution failure, close pipe */
14564887Schin 				sh_pclose(pvn);
14574887Schin 			pipejob = savepipe;
14584887Schin #ifdef SIGTSTP
14594887Schin 			if(!pipejob && sh_isstate(SH_MONITOR))
14608462SApril.Chin@Sun.COM 				tcsetpgrp(JOBTTY,shp->pid);
14614887Schin #endif /*SIGTSTP */
14624887Schin 			job.curpgid = savepgid;
14634887Schin 			break;
14644887Schin 		    }
14654887Schin 
14664887Schin 		    case TLST:
14674887Schin 		    {
14684887Schin 			/*  a list of commands are executed here */
14694887Schin 			do
14704887Schin 			{
14714887Schin 				sh_exec(t->lst.lstlef,errorflg|OPTIMIZE);
14724887Schin 				t = t->lst.lstrit;
14734887Schin 			}
14744887Schin 			while(t->tre.tretyp == TLST);
14754887Schin 			sh_exec(t,flags);
14764887Schin 			break;
14774887Schin 		    }
14784887Schin 
14794887Schin 		    case TAND:
14804887Schin 			if(type&TTEST)
14814887Schin 				skipexitset++;
14824887Schin 			if(sh_exec(t->lst.lstlef,OPTIMIZE)==0)
14834887Schin 				sh_exec(t->lst.lstrit,flags);
14844887Schin 			break;
14854887Schin 
14864887Schin 		    case TORF:
14874887Schin 			if(type&TTEST)
14884887Schin 				skipexitset++;
14894887Schin 			if(sh_exec(t->lst.lstlef,OPTIMIZE)!=0)
14904887Schin 				sh_exec(t->lst.lstrit,flags);
14914887Schin 			break;
14924887Schin 
14934887Schin 		    case TFOR: /* for and select */
14944887Schin 		    {
14954887Schin 			register char **args;
14964887Schin 			register int nargs;
14974887Schin 			register Namval_t *np;
14984887Schin 			int flag = errorflg|OPTIMIZE_FLAG;
14994887Schin 			struct dolnod	*argsav=0;
15004887Schin 			struct comnod	*tp;
15014887Schin 			char *cp, *trap, *nullptr = 0;
15024887Schin 			int nameref, refresh=1;
15038462SApril.Chin@Sun.COM 			char *av[5];
15044887Schin #if SHOPT_OPTIMIZE
15058462SApril.Chin@Sun.COM 			int  jmpval = ((struct checkpt*)shp->jmplist)->mode;
15064887Schin 			struct checkpt buff;
15078462SApril.Chin@Sun.COM 			void *optlist = shp->optlist;
15088462SApril.Chin@Sun.COM 			shp->optlist = 0;
15094887Schin 			sh_tclear(t->for_.fortre);
15104887Schin 			sh_pushcontext(&buff,jmpval);
15114887Schin 			jmpval = sigsetjmp(buff.buff,0);
15124887Schin 			if(jmpval)
15134887Schin 				goto endfor;
15144887Schin #endif /* SHOPT_OPTIMIZE */
15158462SApril.Chin@Sun.COM 			error_info.line = t->for_.forline-shp->st.firstline;
15164887Schin 			if(!(tp=t->for_.forlst))
15174887Schin 			{
15188462SApril.Chin@Sun.COM 				args=shp->st.dolv+1;
15198462SApril.Chin@Sun.COM 				nargs = shp->st.dolc;
15208462SApril.Chin@Sun.COM 				argsav=sh_arguse(shp);
15214887Schin 			}
15224887Schin 			else
15234887Schin 			{
15248462SApril.Chin@Sun.COM 				args=sh_argbuild(shp,&argn,tp,0);
15254887Schin 				nargs = argn;
15264887Schin 			}
15278462SApril.Chin@Sun.COM 			np = nv_open(t->for_.fornam, shp->var_tree,NV_NOASSIGN|NV_NOARRAY|NV_VARNAME|NV_NOREF);
15284887Schin 			nameref = nv_isref(np)!=0;
15298462SApril.Chin@Sun.COM 			shp->st.loopcnt++;
15304887Schin 			cp = *args;
15318462SApril.Chin@Sun.COM 			while(cp && shp->st.execbrk==0)
15324887Schin 			{
15334887Schin 				if(t->tre.tretyp&COMSCAN)
15344887Schin 				{
15354887Schin 					char *val;
15364887Schin 					int save_prompt;
15374887Schin 					/* reuse register */
15384887Schin 					if(refresh)
15394887Schin 					{
15404887Schin 						sh_menu(sfstderr,nargs,args);
15414887Schin 						refresh = 0;
15424887Schin 					}
15438462SApril.Chin@Sun.COM 					save_prompt = shp->nextprompt;
15448462SApril.Chin@Sun.COM 					shp->nextprompt = 3;
15458462SApril.Chin@Sun.COM 					shp->timeout = 0;
15468462SApril.Chin@Sun.COM 					shp->exitval=sh_readline(shp,&nullptr,0,1,1000*shp->st.tmout);
15478462SApril.Chin@Sun.COM 					shp->nextprompt = save_prompt;
15488462SApril.Chin@Sun.COM 					if(shp->exitval||sfeof(sfstdin)||sferror(sfstdin))
15494887Schin 					{
15508462SApril.Chin@Sun.COM 						shp->exitval = 1;
15514887Schin 						break;
15524887Schin 					}
15538462SApril.Chin@Sun.COM 					if(!(val=nv_getval(sh_scoped(shp,REPLYNOD))))
15544887Schin 						continue;
15554887Schin 					else
15564887Schin 					{
15574887Schin 						if(*(cp=val) == 0)
15584887Schin 						{
15594887Schin 							refresh++;
15604887Schin 							goto check;
15614887Schin 						}
15624887Schin 						while(type = *cp++)
15634887Schin 							if(type < '0' && type > '9')
15644887Schin 								break;
15654887Schin 						if(type!=0)
15664887Schin 							type = nargs;
15674887Schin 						else
15684887Schin 							type = (int)strtol(val, (char**)0, 10)-1;
15694887Schin 						if(type<0 || type >= nargs)
15704887Schin 							cp = "";
15714887Schin 						else
15724887Schin 							cp = args[type];
15734887Schin 					}
15744887Schin 				}
15754887Schin 				if(nameref)
15764887Schin 					nv_offattr(np,NV_REF);
15774887Schin 				else if(nv_isattr(np, NV_ARRAY))
15784887Schin 					nv_putsub(np,NIL(char*),0L);
15794887Schin 				nv_putval(np,cp,0);
15804887Schin 				if(nameref)
15814887Schin 					nv_setref(np,(Dt_t*)0,NV_VARNAME);
15828462SApril.Chin@Sun.COM 				if(trap=shp->st.trap[SH_DEBUGTRAP])
15834887Schin 				{
15844887Schin 					av[0] = (t->tre.tretyp&COMSCAN)?"select":"for";
15854887Schin 					av[1] = t->for_.fornam;
15868462SApril.Chin@Sun.COM 					av[2] = "in";
15874887Schin 					av[3] = cp;
15888462SApril.Chin@Sun.COM 					av[4] = 0;
15898462SApril.Chin@Sun.COM 					sh_debug(shp,trap,(char*)0,(char*)0,av,0);
15904887Schin 				}
15914887Schin 				sh_exec(t->for_.fortre,flag);
15924887Schin 				flag &= ~OPTIMIZE_FLAG;
15934887Schin 				if(t->tre.tretyp&COMSCAN)
15944887Schin 				{
15958462SApril.Chin@Sun.COM 					if((cp=nv_getval(sh_scoped(shp,REPLYNOD))) && *cp==0)
15964887Schin 						refresh++;
15974887Schin 				}
15984887Schin 				else
15994887Schin 					cp = *++args;
16004887Schin 			check:
16018462SApril.Chin@Sun.COM 				if(shp->st.breakcnt<0)
16028462SApril.Chin@Sun.COM 					shp->st.execbrk = (++shp->st.breakcnt !=0);
16034887Schin 			}
16044887Schin #if SHOPT_OPTIMIZE
16054887Schin 		endfor:
16064887Schin 			sh_popcontext(&buff);
16074887Schin 			sh_tclear(t->for_.fortre);
16088462SApril.Chin@Sun.COM 			sh_optclear(shp,optlist);
16094887Schin 			if(jmpval)
16108462SApril.Chin@Sun.COM 				siglongjmp(*shp->jmplist,jmpval);
16114887Schin #endif /*SHOPT_OPTIMIZE */
16128462SApril.Chin@Sun.COM 			if(shp->st.breakcnt>0)
16138462SApril.Chin@Sun.COM 				shp->st.execbrk = (--shp->st.breakcnt !=0);
16148462SApril.Chin@Sun.COM 			shp->st.loopcnt--;
16158462SApril.Chin@Sun.COM 			sh_argfree(shp,argsav,0);
16164887Schin 			nv_close(np);
16174887Schin 			break;
16184887Schin 		    }
16194887Schin 
16204887Schin 		    case TWH: /* while and until */
16214887Schin 		    {
16228462SApril.Chin@Sun.COM 			volatile int 	r=0;
16234887Schin 			int first = OPTIMIZE_FLAG;
16244887Schin 			Shnode_t *tt = t->wh.whtre;
16254887Schin #if SHOPT_FILESCAN
16264887Schin 			Sfio_t *iop=0;
16274887Schin 			int savein,fd;
16284887Schin #endif /*SHOPT_FILESCAN*/
16294887Schin #if SHOPT_OPTIMIZE
16308462SApril.Chin@Sun.COM 			int  jmpval = ((struct checkpt*)shp->jmplist)->mode;
16314887Schin 			struct checkpt buff;
16328462SApril.Chin@Sun.COM 			void *optlist = shp->optlist;
16338462SApril.Chin@Sun.COM 			shp->optlist = 0;
16344887Schin 			sh_tclear(t->wh.whtre);
16354887Schin 			sh_tclear(t->wh.dotre);
16364887Schin 			sh_pushcontext(&buff,jmpval);
16374887Schin 			jmpval = sigsetjmp(buff.buff,0);
16384887Schin 			if(jmpval)
16394887Schin 				goto endwhile;
16404887Schin #endif /* SHOPT_OPTIMIZE */
16414887Schin #if SHOPT_FILESCAN
16424887Schin 			if(type==TWH && tt->tre.tretyp==TCOM && !tt->com.comarg && tt->com.comio)
16434887Schin 			{
16448462SApril.Chin@Sun.COM 				fd = sh_redirect(shp,tt->com.comio,3);
16454887Schin 				savein = dup(0);
16464887Schin 				if(fd==0)
16474887Schin 					fd = savein;
16484887Schin 				iop = sfnew(NULL,NULL,SF_UNBOUND,fd,SF_READ);
16494887Schin 				close(0);
16504887Schin 				open("/dev/null",O_RDONLY);
16518462SApril.Chin@Sun.COM 				shp->offsets[0] = -1;
16528462SApril.Chin@Sun.COM 				shp->offsets[1] = 0;
16534887Schin 				if(tt->com.comset)
16544887Schin 					nv_setlist(tt->com.comset,NV_IDENT|NV_ASSIGN);
16554887Schin 			}
16564887Schin #endif /*SHOPT_FILESCAN */
16578462SApril.Chin@Sun.COM 			shp->st.loopcnt++;
16588462SApril.Chin@Sun.COM 			while(shp->st.execbrk==0)
16594887Schin 			{
16604887Schin #if SHOPT_FILESCAN
16614887Schin 				if(iop)
16624887Schin 				{
16638462SApril.Chin@Sun.COM 					if(!(shp->cur_line=sfgetr(iop,'\n',SF_STRING)))
16644887Schin 						break;
16654887Schin 				}
16664887Schin 				else
16674887Schin #endif /*SHOPT_FILESCAN */
16684887Schin 				if((sh_exec(tt,first)==0)!=(type==TWH))
16694887Schin 					break;
16704887Schin 				r = sh_exec(t->wh.dotre,first|errorflg);
16718462SApril.Chin@Sun.COM 				if(shp->st.breakcnt<0)
16728462SApril.Chin@Sun.COM 					shp->st.execbrk = (++shp->st.breakcnt !=0);
16734887Schin 				/* This is for the arithmetic for */
16748462SApril.Chin@Sun.COM 				if(shp->st.execbrk==0 && t->wh.whinc)
16754887Schin 					sh_exec((Shnode_t*)t->wh.whinc,first);
16764887Schin 				first = 0;
16774887Schin 				errorflg &= ~OPTIMIZE_FLAG;
16784887Schin #if SHOPT_FILESCAN
16798462SApril.Chin@Sun.COM 				shp->offsets[0] = -1;
16808462SApril.Chin@Sun.COM 				shp->offsets[1] = 0;
16814887Schin #endif /*SHOPT_FILESCAN */
16824887Schin 			}
16834887Schin #if SHOPT_OPTIMIZE
16844887Schin 		endwhile:
16854887Schin 			sh_popcontext(&buff);
16864887Schin 			sh_tclear(t->wh.whtre);
16874887Schin 			sh_tclear(t->wh.dotre);
16888462SApril.Chin@Sun.COM 			sh_optclear(shp,optlist);
16894887Schin 			if(jmpval)
16908462SApril.Chin@Sun.COM 				siglongjmp(*shp->jmplist,jmpval);
16914887Schin #endif /*SHOPT_OPTIMIZE */
16928462SApril.Chin@Sun.COM 			if(shp->st.breakcnt>0)
16938462SApril.Chin@Sun.COM 				shp->st.execbrk = (--shp->st.breakcnt !=0);
16948462SApril.Chin@Sun.COM 			shp->st.loopcnt--;
16958462SApril.Chin@Sun.COM 			shp->exitval= r;
16964887Schin #if SHOPT_FILESCAN
16974887Schin 			if(iop)
16984887Schin 			{
16994887Schin 				sfclose(iop);
17004887Schin 				close(0);
17014887Schin 				dup(savein);
17028462SApril.Chin@Sun.COM 				shp->cur_line = 0;
17034887Schin 			}
17044887Schin #endif /*SHOPT_FILESCAN */
17054887Schin 			break;
17064887Schin 		    }
17074887Schin 		    case TARITH: /* (( expression )) */
17084887Schin 		    {
17094887Schin 			register char *trap;
17108462SApril.Chin@Sun.COM 			char *arg[4];
17118462SApril.Chin@Sun.COM 			error_info.line = t->ar.arline-shp->st.firstline;
17128462SApril.Chin@Sun.COM 			arg[0] = "((";
17134887Schin 			if(!(t->ar.arexpr->argflag&ARG_RAW))
17148462SApril.Chin@Sun.COM 				arg[1] = sh_macpat(shp,t->ar.arexpr,OPTIMIZE|ARG_ARITH);
17154887Schin 			else
17164887Schin 				arg[1] = t->ar.arexpr->argval;
17178462SApril.Chin@Sun.COM 			arg[2] = "))";
17188462SApril.Chin@Sun.COM 			arg[3] = 0;
17198462SApril.Chin@Sun.COM 			if(trap=shp->st.trap[SH_DEBUGTRAP])
17208462SApril.Chin@Sun.COM 				sh_debug(shp,trap,(char*)0, (char*)0, arg, ARG_ARITH);
17214887Schin 			if(sh_isoption(SH_XTRACE))
17224887Schin 			{
17234887Schin 				sh_trace(NIL(char**),0);
17244887Schin 				sfprintf(sfstderr,"((%s))\n",arg[1]);
17254887Schin 			}
17264887Schin 			if(t->ar.arcomp)
17278462SApril.Chin@Sun.COM 				shp->exitval  = !arith_exec((Arith_t*)t->ar.arcomp);
17284887Schin 			else
17298462SApril.Chin@Sun.COM 				shp->exitval = !sh_arith(arg[1]);
17304887Schin 			break;
17314887Schin 		    }
17324887Schin 
17334887Schin 		    case TIF:
17344887Schin 			if(sh_exec(t->if_.iftre,OPTIMIZE)==0)
17354887Schin 				sh_exec(t->if_.thtre,flags);
17364887Schin 			else if(t->if_.eltre)
17374887Schin 				sh_exec(t->if_.eltre, flags);
17384887Schin 			else
17398462SApril.Chin@Sun.COM 				shp->exitval=0; /* force zero exit for if-then-fi */
17404887Schin 			break;
17414887Schin 
17424887Schin 		    case TSW:
17434887Schin 		    {
17444887Schin 			Shnode_t *tt = (Shnode_t*)t;
17458462SApril.Chin@Sun.COM 			char *trap, *r = sh_macpat(shp,tt->sw.swarg,OPTIMIZE);
17468462SApril.Chin@Sun.COM 			error_info.line = t->sw.swline-shp->st.firstline;
17474887Schin 			t= (Shnode_t*)(tt->sw.swlst);
17488462SApril.Chin@Sun.COM 			if(trap=shp->st.trap[SH_DEBUGTRAP])
17494887Schin 			{
17508462SApril.Chin@Sun.COM 				char *av[4];
17518462SApril.Chin@Sun.COM 				av[0] = "case";
17524887Schin 				av[1] = r;
17538462SApril.Chin@Sun.COM 				av[2] = "in";
17548462SApril.Chin@Sun.COM 				av[3] = 0;
17558462SApril.Chin@Sun.COM 				sh_debug(shp,trap, (char*)0, (char*)0, av, 0);
17564887Schin 			}
17574887Schin 			while(t)
17584887Schin 			{
17594887Schin 				register struct argnod	*rex=(struct argnod*)t->reg.regptr;
17604887Schin 				while(rex)
17614887Schin 				{
17624887Schin 					register char *s;
17634887Schin 					if(rex->argflag&ARG_MAC)
17644887Schin 					{
17658462SApril.Chin@Sun.COM 						s = sh_macpat(shp,rex,OPTIMIZE|ARG_EXP);
17664887Schin 						while(*s=='\\' && s[1]==0)
17674887Schin 							s+=2;
17684887Schin 					}
17694887Schin 					else
17704887Schin 						s = rex->argval;
17714887Schin 					type = (rex->argflag&ARG_RAW);
17724887Schin 					if((type && strcmp(r,s)==0) ||
17734887Schin 						(!type && (strmatch(r,s)
17744887Schin 						|| trim_eq(r,s))))
17754887Schin 					{
17764887Schin 						do	sh_exec(t->reg.regcom,(t->reg.regflag?0:flags));
17774887Schin 						while(t->reg.regflag &&
17784887Schin 							(t=(Shnode_t*)t->reg.regnxt));
17794887Schin 						t=0;
17804887Schin 						break;
17814887Schin 					}
17824887Schin 					else
17834887Schin 						rex=rex->argnxt.ap;
17844887Schin 				}
17854887Schin 				if(t)
17864887Schin 					t=(Shnode_t*)t->reg.regnxt;
17874887Schin 			}
17884887Schin 			break;
17894887Schin 		    }
17904887Schin 
17914887Schin 		    case TTIME:
17924887Schin 		    {
17934887Schin 			/* time the command */
17944887Schin 			struct tms before,after;
17954887Schin 			const char *format = e_timeformat;
17964887Schin 			clock_t at, tm[3];
17974887Schin #ifdef timeofday
17984887Schin 			struct timeval tb,ta;
17994887Schin #else
18004887Schin 			clock_t bt;
18014887Schin #endif	/* timeofday */
18024887Schin 			if(type!=TTIME)
18034887Schin 			{
18044887Schin 				sh_exec(t->par.partre,OPTIMIZE);
18058462SApril.Chin@Sun.COM 				shp->exitval = !shp->exitval;
18064887Schin 				break;
18074887Schin 			}
18084887Schin 			if(t->par.partre)
18094887Schin 			{
18104887Schin 				long timer_on;
18114887Schin 				timer_on = sh_isstate(SH_TIMING);
18124887Schin #ifdef timeofday
18134887Schin 				timeofday(&tb);
18144887Schin 				times(&before);
18154887Schin #else
18164887Schin 				bt = times(&before);
18174887Schin #endif	/* timeofday */
18184887Schin 				job.waitall = 1;
18194887Schin 				sh_onstate(SH_TIMING);
18204887Schin 				sh_exec(t->par.partre,OPTIMIZE);
18214887Schin 				if(!timer_on)
18224887Schin 					sh_offstate(SH_TIMING);
18234887Schin 				job.waitall = 0;
18244887Schin 			}
18254887Schin 			else
18264887Schin 			{
18274887Schin #ifndef timeofday
18284887Schin 				bt = 0;
18294887Schin #endif	/* timeofday */
18304887Schin 				before.tms_utime = before.tms_cutime = 0;
18314887Schin 				before.tms_stime = before.tms_cstime = 0;
18324887Schin 			}
18334887Schin #ifdef timeofday
18344887Schin 			times(&after);
18354887Schin 			timeofday(&ta);
18368462SApril.Chin@Sun.COM 			at = shp->lim.clk_tck*(ta.tv_sec-tb.tv_sec);
18378462SApril.Chin@Sun.COM 			at +=  ((shp->lim.clk_tck*(((1000000L/2)/shp->lim.clk_tck)+(ta.tv_usec-tb.tv_usec)))/1000000L);
18384887Schin #else
18394887Schin 			at = times(&after) - bt;
18404887Schin #endif	/* timeofday */
18414887Schin 			tm[0] = at;
18424887Schin 			if(t->par.partre)
18434887Schin 			{
18448462SApril.Chin@Sun.COM 				Namval_t *np = nv_open("TIMEFORMAT",shp->var_tree,NV_NOADD);
18454887Schin 				if(np)
18464887Schin 				{
18474887Schin 					format = nv_getval(np);
18484887Schin 					nv_close(np);
18494887Schin 				}
18504887Schin 				if(!format)
18514887Schin 					format = e_timeformat;
18524887Schin 			}
18534887Schin 			else
18544887Schin 				format = strchr(format+1,'\n')+1;
18554887Schin 			tm[1] = after.tms_utime - before.tms_utime;
18564887Schin 			tm[1] += after.tms_cutime - before.tms_cutime;
18574887Schin 			tm[2] = after.tms_stime - before.tms_stime;
18584887Schin 			tm[2] += after.tms_cstime - before.tms_cstime;
18594887Schin 			if(format && *format)
18608462SApril.Chin@Sun.COM 				p_time(shp,sfstderr,sh_translate(format),tm);
18614887Schin 			break;
18624887Schin 		    }
18634887Schin 		    case TFUN:
18644887Schin 		    {
18654887Schin 			register Namval_t *np;
18664887Schin 			register struct slnod *slp;
18674887Schin 			register char *fname = ((struct functnod*)t)->functnam;
18684887Schin 			register char *cp = strrchr(fname,'.');
18694887Schin 			register Namval_t *npv=0;
18704887Schin #if SHOPT_NAMESPACE
18714887Schin 			if(t->tre.tretyp==TNSPACE)
18724887Schin 			{
18734887Schin 				Dt_t *root,*oldroot, *top=0;
18748462SApril.Chin@Sun.COM 				Namval_t *oldnspace = shp->namespace;
18758462SApril.Chin@Sun.COM 				int offset = stktell(stkp);
18768462SApril.Chin@Sun.COM 				long optindex = shp->st.optindex;
18774887Schin 				if(cp)
18784887Schin 					errormsg(SH_DICT,ERROR_exit(1),e_ident,fname);
18798462SApril.Chin@Sun.COM 				sfputc(stkp,'.');
18808462SApril.Chin@Sun.COM 				sfputr(stkp,fname,0);
18818462SApril.Chin@Sun.COM 				np = nv_open(stkptr(stkp,offset),shp->var_base,NV_NOASSIGN|NV_NOARRAY|NV_VARNAME);
18828462SApril.Chin@Sun.COM 				offset = stktell(stkp);
18838462SApril.Chin@Sun.COM 				shp->namespace = np;
18844887Schin 				if(!(root=nv_dict(np)))
18854887Schin 				{
18864887Schin 					root = dtopen(&_Nvdisc,Dtoset);
18874887Schin 					nv_putval(np,(char*)root,NV_TABLE|NV_NOFREE);
18888462SApril.Chin@Sun.COM 					shp->st.optindex = 1;
18894887Schin 				}
18908462SApril.Chin@Sun.COM 				if(oldnspace && dtvnext(dtvnext(shp->var_tree)))
18918462SApril.Chin@Sun.COM 					top = dtview(shp->var_tree,0);
18928462SApril.Chin@Sun.COM 				else if(dtvnext(shp->var_tree))
18938462SApril.Chin@Sun.COM 					top = dtview(shp->var_tree,0);
18948462SApril.Chin@Sun.COM 				oldroot = shp->var_tree;
18958462SApril.Chin@Sun.COM 				dtview(root,shp->var_base);
18968462SApril.Chin@Sun.COM 				shp->var_tree = root;
18974887Schin 				if(top)
18988462SApril.Chin@Sun.COM 					dtview(shp->var_tree,top);
18994887Schin 				sh_exec(t->for_.fortre,flags);
19008462SApril.Chin@Sun.COM 				if(dtvnext(shp->var_tree))
19018462SApril.Chin@Sun.COM 					top = dtview(shp->var_tree,0);
19028462SApril.Chin@Sun.COM 				shp->var_tree = oldroot;
19034887Schin 				if(top)
19048462SApril.Chin@Sun.COM 					dtview(top,shp->var_tree);
19058462SApril.Chin@Sun.COM 				shp->namespace = oldnspace;
19068462SApril.Chin@Sun.COM 				shp->st.optindex = optindex;
19074887Schin 				break;
19084887Schin 			}
19094887Schin #endif /* SHOPT_NAMESPACE */
19104887Schin 			/* look for discipline functions */
19118462SApril.Chin@Sun.COM 			error_info.line = t->funct.functline-shp->st.firstline;
19124887Schin 			/* Function names cannot be special builtin */
19138462SApril.Chin@Sun.COM 			if(cp || shp->prefix)
19144887Schin 			{
19158462SApril.Chin@Sun.COM 				int offset = stktell(stkp);
19168462SApril.Chin@Sun.COM 				if(shp->prefix)
19174887Schin 				{
19188462SApril.Chin@Sun.COM 					cp = shp->prefix;
19198462SApril.Chin@Sun.COM 					shp->prefix = 0;
19208462SApril.Chin@Sun.COM 					npv = nv_open(cp,shp->var_tree,NV_NOASSIGN|NV_NOARRAY|NV_VARNAME);
19218462SApril.Chin@Sun.COM 					shp->prefix = cp;
19224887Schin 					cp = fname;
19234887Schin 				}
19244887Schin 				else
19254887Schin 				{
19268462SApril.Chin@Sun.COM 					sfwrite(stkp,fname,cp++-fname);
19278462SApril.Chin@Sun.COM 					sfputc(stkp,0);
19288462SApril.Chin@Sun.COM 					npv = nv_open(stkptr(stkp,offset),shp->var_tree,NV_NOASSIGN|NV_NOARRAY|NV_VARNAME);
19294887Schin 				}
19308462SApril.Chin@Sun.COM 				offset = stktell(stkp);
19318462SApril.Chin@Sun.COM 				sfprintf(stkp,"%s.%s%c",nv_name(npv),cp,0);
19328462SApril.Chin@Sun.COM 				fname = stkptr(stkp,offset);
19334887Schin 			}
19348462SApril.Chin@Sun.COM 			else if((np=nv_search(fname,shp->bltin_tree,0)) && nv_isattr(np,BLT_SPC))
19354887Schin 				errormsg(SH_DICT,ERROR_exit(1),e_badfun,fname);
19364887Schin #if SHOPT_NAMESPACE
19378462SApril.Chin@Sun.COM 			else if(shp->namespace)
19384887Schin 			{
19398462SApril.Chin@Sun.COM 				int offset = stktell(stkp);
19408462SApril.Chin@Sun.COM 				sfputr(stkp,nv_name(shp->namespace),-1);
19418462SApril.Chin@Sun.COM 				sfputc(stkp,'.');
19428462SApril.Chin@Sun.COM 				sfputr(stkp,fname,0);
19438462SApril.Chin@Sun.COM 				fname = stkptr(stkp,offset);
19444887Schin 			}
19454887Schin #endif /* SHOPT_NAMESPACE */
19464887Schin 			np = nv_open(fname,sh_subfuntree(1),NV_NOASSIGN|NV_NOARRAY|NV_VARNAME|NV_NOSCOPE);
19474887Schin 			if(npv)
19484887Schin 			{
19498462SApril.Chin@Sun.COM 				Namval_t *tp = npv;
19508462SApril.Chin@Sun.COM 				if(!shp->mktype)
19518462SApril.Chin@Sun.COM 				{
19528462SApril.Chin@Sun.COM 					if(shp->typeinit)
19538462SApril.Chin@Sun.COM 					{
19548462SApril.Chin@Sun.COM 						if(tp=nv_open(shp->typeinit->nvname,shp->typedict,NV_IDENT|NV_NOFAIL))
19558462SApril.Chin@Sun.COM 							nv_close(npv);
19568462SApril.Chin@Sun.COM 						else
19578462SApril.Chin@Sun.COM 							tp = npv;
19588462SApril.Chin@Sun.COM 					}
19598462SApril.Chin@Sun.COM 					cp = nv_setdisc(tp,cp,np,(Namfun_t*)tp);
19608462SApril.Chin@Sun.COM 				}
19618462SApril.Chin@Sun.COM 				nv_close(tp);
19624887Schin 				if(!cp)
19634887Schin 					errormsg(SH_DICT,ERROR_exit(1),e_baddisc,fname);
19644887Schin 			}
19654887Schin 			if(np->nvalue.rp)
19664887Schin 			{
19674887Schin 				slp = (struct slnod*)np->nvenv;
19684887Schin 				sh_funstaks(slp->slchild,-1);
19694887Schin 				stakdelete(slp->slptr);
19708462SApril.Chin@Sun.COM 				if(shp->funload)
19718462SApril.Chin@Sun.COM 				{
19728462SApril.Chin@Sun.COM 					free((void*)np->nvalue.rp);
19738462SApril.Chin@Sun.COM 					np->nvalue.rp = 0;
19748462SApril.Chin@Sun.COM 				}
19758462SApril.Chin@Sun.COM 
19764887Schin 			}
19778462SApril.Chin@Sun.COM 			if(!np->nvalue.rp)
19788462SApril.Chin@Sun.COM 			{
19798462SApril.Chin@Sun.COM 				np->nvalue.rp = new_of(struct Ufunction,shp->funload?sizeof(Dtlink_t):0);
19808462SApril.Chin@Sun.COM 				memset((void*)np->nvalue.rp,0,sizeof(struct Ufunction));
19818462SApril.Chin@Sun.COM 			}
19824887Schin 			if(t->funct.functstak)
19834887Schin 			{
19848462SApril.Chin@Sun.COM 				static Dtdisc_t		_Rpdisc =
19858462SApril.Chin@Sun.COM 				{
19868462SApril.Chin@Sun.COM 				        offsetof(struct Ufunction,fname), -1, sizeof(struct Ufunction)
19878462SApril.Chin@Sun.COM 				};
19884887Schin 				struct functnod *fp;
19894887Schin 				slp = t->funct.functstak;
19904887Schin 				sh_funstaks(slp->slchild,1);
19914887Schin 				staklink(slp->slptr);
19924887Schin 				np->nvenv = (char*)slp;
19934887Schin 				nv_funtree(np) = (int*)(t->funct.functtre);
19944887Schin 				np->nvalue.rp->hoffset = t->funct.functloc;
19954887Schin 				np->nvalue.rp->lineno = t->funct.functline;
19968462SApril.Chin@Sun.COM 				np->nvalue.rp->nspace = shp->namespace;
19974887Schin 				np->nvalue.rp->fname = 0;
19988462SApril.Chin@Sun.COM 				np->nvalue.rp->fdict = shp->fun_tree;
19994887Schin 				fp = (struct functnod*)(slp+1);
20004887Schin 				if(fp->functtyp==(TFUN|FAMP))
20014887Schin 					np->nvalue.rp->fname = fp->functnam;
20024887Schin 				nv_setsize(np,fp->functline);
20034887Schin 				nv_offattr(np,NV_FPOSIX);
20048462SApril.Chin@Sun.COM 				if(shp->funload)
20058462SApril.Chin@Sun.COM 				{
20068462SApril.Chin@Sun.COM 					struct Ufunction *rp = np->nvalue.rp;
20078462SApril.Chin@Sun.COM 					rp->np = np;
20088462SApril.Chin@Sun.COM 					if(!shp->fpathdict)
20098462SApril.Chin@Sun.COM 						shp->fpathdict = dtopen(&_Rpdisc,Dtbag);
20108462SApril.Chin@Sun.COM 					if(shp->fpathdict)
20118462SApril.Chin@Sun.COM 						dtinsert(shp->fpathdict,rp);
20128462SApril.Chin@Sun.COM 				}
20134887Schin 			}
20144887Schin 			else
20154887Schin 				nv_unset(np);
20164887Schin 			if(type&FPOSIX)
20174887Schin 				nv_onattr(np,NV_FUNCTION|NV_FPOSIX);
20184887Schin 			else
20194887Schin 				nv_onattr(np,NV_FUNCTION);
20204887Schin 			if(type&FPIN)
20214887Schin 				nv_onattr(np,NV_FTMP);
20228462SApril.Chin@Sun.COM 			if(type&FOPTGET)
20238462SApril.Chin@Sun.COM 				nv_onattr(np,NV_OPTGET);
20244887Schin 			break;
20254887Schin 		    }
20264887Schin 
20274887Schin 		    /* new test compound command */
20284887Schin 		    case TTST:
20294887Schin 		    {
20304887Schin 			register int n;
20314887Schin 			register char *left;
20324887Schin 			int negate = (type&TNEGATE)!=0;
20334887Schin 			if(type&TTEST)
20344887Schin 				skipexitset++;
20358462SApril.Chin@Sun.COM 			error_info.line = t->tst.tstline-shp->st.firstline;
20364887Schin 			echeck = 1;
20374887Schin 			if((type&TPAREN)==TPAREN)
20384887Schin 			{
20394887Schin 				sh_exec(t->lst.lstlef,OPTIMIZE);
20408462SApril.Chin@Sun.COM 				n = !shp->exitval;
20414887Schin 			}
20424887Schin 			else
20434887Schin 			{
20444887Schin 				register int traceon=0;
20454887Schin 				register char *right;
20464887Schin 				register char *trap;
20474887Schin 				char *argv[6];
20484887Schin 				n = type>>TSHIFT;
20498462SApril.Chin@Sun.COM 				left = sh_macpat(shp,&(t->lst.lstlef->arg),OPTIMIZE);
20504887Schin 				if(type&TBINARY)
20518462SApril.Chin@Sun.COM 					right = sh_macpat(shp,&(t->lst.lstrit->arg),((n==TEST_PEQ||n==TEST_PNE)?ARG_EXP:0)|OPTIMIZE);
20528462SApril.Chin@Sun.COM 				if(trap=shp->st.trap[SH_DEBUGTRAP])
20534887Schin 					argv[0] = (type&TNEGATE)?((char*)e_tstbegin):"[[";
20544887Schin 				if(sh_isoption(SH_XTRACE))
20554887Schin 				{
20564887Schin 					traceon = sh_trace(NIL(char**),0);
20574887Schin 					sfwrite(sfstderr,e_tstbegin,(type&TNEGATE?5:3));
20584887Schin 				}
20594887Schin 				if(type&TUNARY)
20604887Schin 				{
20614887Schin 					if(traceon)
20624887Schin 						sfprintf(sfstderr,"-%c %s",n,sh_fmtq(left));
20634887Schin 					if(trap)
20644887Schin 					{
20654887Schin 						char unop[3];
20664887Schin 						unop[0] = '-';
20674887Schin 						unop[1] = n;
20684887Schin 						unop[2] = 0;
20694887Schin 						argv[1] = unop;
20704887Schin 						argv[2] = left;
20714887Schin 						argv[3] = "]]";
20724887Schin 						argv[4] = 0;
20738462SApril.Chin@Sun.COM 						sh_debug(shp,trap,(char*)0,(char*)0,argv, 0);
20744887Schin 					}
20754887Schin 					n = test_unop(n,left);
20764887Schin 				}
20774887Schin 				else if(type&TBINARY)
20784887Schin 				{
20794887Schin 					char *op;
20804887Schin 					int pattern = 0;
20814887Schin 					if(trap || traceon)
20824887Schin 						op = (char*)(shtab_testops+(n&037)-1)->sh_name;
20834887Schin 					type >>= TSHIFT;
20844887Schin 					if(type==TEST_PEQ || type==TEST_PNE)
20854887Schin 						pattern=ARG_EXP;
20864887Schin 					if(trap)
20874887Schin 					{
20884887Schin 						argv[1] = left;
20894887Schin 						argv[2] = op;
20904887Schin 						argv[3] = right;
20914887Schin 						argv[4] = "]]";
20924887Schin 						argv[5] = 0;
20938462SApril.Chin@Sun.COM 						sh_debug(shp,trap,(char*)0,(char*)0,argv, pattern);
20944887Schin 					}
20954887Schin 					n = test_binop(n,left,right);
20964887Schin 					if(traceon)
20974887Schin 					{
20984887Schin 						sfprintf(sfstderr,"%s %s ",sh_fmtq(left),op);
20994887Schin 						if(pattern)
21004887Schin 							out_pattern(sfstderr,right,-1);
21014887Schin 						else
21024887Schin 							sfputr(sfstderr,sh_fmtq(right),-1);
21034887Schin 					}
21044887Schin 				}
21054887Schin 				if(traceon)
21064887Schin 					sfwrite(sfstderr,e_tstend,4);
21074887Schin 			}
21088462SApril.Chin@Sun.COM 			shp->exitval = ((!n)^negate);
21094887Schin 			if(!skipexitset)
21104887Schin 				exitset();
21114887Schin 			break;
21124887Schin 		    }
21134887Schin 		}
21148462SApril.Chin@Sun.COM 		if(shp->trapnote || (shp->exitval && sh_isstate(SH_ERREXIT)) &&
21154887Schin 			t && echeck)
21164887Schin 			sh_chktrap();
21174887Schin 		/* set $_ */
21184887Schin 		if(mainloop && com0)
21194887Schin 		{
21204887Schin 			/* store last argument here if it fits */
21214887Schin 			static char	lastarg[32];
21224887Schin 			if(sh_isstate(SH_FORKED))
21238462SApril.Chin@Sun.COM 				sh_done(shp,0);
21248462SApril.Chin@Sun.COM 			if(shp->lastarg!= lastarg && shp->lastarg)
21258462SApril.Chin@Sun.COM 				free(shp->lastarg);
21268462SApril.Chin@Sun.COM 			if(strlen(comn) < sizeof(lastarg))
21274887Schin 			{
21284887Schin 				nv_onattr(L_ARGNOD,NV_NOFREE);
21298462SApril.Chin@Sun.COM 				shp->lastarg = strcpy(lastarg,comn);
21304887Schin 			}
21314887Schin 			else
21324887Schin 			{
21334887Schin 				nv_offattr(L_ARGNOD,NV_NOFREE);
21348462SApril.Chin@Sun.COM 				shp->lastarg = strdup(comn);
21354887Schin 			}
21364887Schin 		}
21374887Schin 		if(!skipexitset)
21384887Schin 			exitset();
21394887Schin 		if(!(OPTIMIZE))
21404887Schin 		{
21418462SApril.Chin@Sun.COM 			if(sav != stkptr(stkp,0))
21428462SApril.Chin@Sun.COM 				stkset(stkp,sav,0);
21438462SApril.Chin@Sun.COM 			else if(stktell(stkp))
21448462SApril.Chin@Sun.COM 				stkseek(stkp,0);
21454887Schin 		}
21468462SApril.Chin@Sun.COM 		if(shp->trapnote&SH_SIGSET)
21478462SApril.Chin@Sun.COM 			sh_exit(SH_EXITSIG|shp->lastsig);
21484887Schin 		if(was_interactive)
21494887Schin 			sh_onstate(SH_INTERACTIVE);
21504887Schin 		if(was_monitor && sh_isoption(SH_MONITOR))
21514887Schin 			sh_onstate(SH_MONITOR);
21524887Schin 		if(was_errexit)
21534887Schin 			sh_onstate(SH_ERREXIT);
21544887Schin 	}
21558462SApril.Chin@Sun.COM 	return(shp->exitval);
21568462SApril.Chin@Sun.COM }
21578462SApril.Chin@Sun.COM 
21588462SApril.Chin@Sun.COM int sh_run(int argn, char *argv[])
21598462SApril.Chin@Sun.COM {
21608462SApril.Chin@Sun.COM 	register struct dolnod	*dp;
21618462SApril.Chin@Sun.COM 	register struct comnod	*t = (struct comnod*)stakalloc(sizeof(struct comnod));
21628462SApril.Chin@Sun.COM 	int			savtop = staktell();
21638462SApril.Chin@Sun.COM 	char			*savptr = stakfreeze(0);
21648462SApril.Chin@Sun.COM 	Opt_t			*op, *np = optctx(0, 0);
21658462SApril.Chin@Sun.COM 	Shbltin_t		bltindata;
21668462SApril.Chin@Sun.COM 	bltindata = sh.bltindata;
21678462SApril.Chin@Sun.COM 	op = optctx(np, 0);
21688462SApril.Chin@Sun.COM 	memset(t, 0, sizeof(struct comnod));
21698462SApril.Chin@Sun.COM 	dp = (struct dolnod*)stakalloc((unsigned)sizeof(struct dolnod) + ARG_SPARE*sizeof(char*) + argn*sizeof(char*));
21708462SApril.Chin@Sun.COM 	dp->dolnum = argn;
21718462SApril.Chin@Sun.COM 	dp->dolbot = ARG_SPARE;
21728462SApril.Chin@Sun.COM 	memcpy(dp->dolval+ARG_SPARE, argv, (argn+1)*sizeof(char*));
21738462SApril.Chin@Sun.COM 	t->comarg = (struct argnod*)dp;
21748462SApril.Chin@Sun.COM 	if(!strchr(argv[0],'/'))
21758462SApril.Chin@Sun.COM 		t->comnamp = (void*)nv_bfsearch(argv[0],sh.fun_tree,(Namval_t**)&t->comnamq,(char**)0);
21768462SApril.Chin@Sun.COM 	argn=sh_exec((Shnode_t*)t,sh_isstate(SH_ERREXIT));
21778462SApril.Chin@Sun.COM 	optctx(op,np);
21788462SApril.Chin@Sun.COM 	sh.bltindata = bltindata;
21798462SApril.Chin@Sun.COM 	if(savptr!=stakptr(0))
21808462SApril.Chin@Sun.COM 		stakset(savptr,savtop);
21818462SApril.Chin@Sun.COM 	else
21828462SApril.Chin@Sun.COM 		stakseek(savtop);
21838462SApril.Chin@Sun.COM 	return(argn);
21844887Schin }
21854887Schin 
21864887Schin /*
21874887Schin  * test for equality with second argument trimmed
21884887Schin  * returns 1 if r == trim(s) otherwise 0
21894887Schin  */
21904887Schin 
21914887Schin static int trim_eq(register const char *r,register const char *s)
21924887Schin {
21934887Schin 	register char c;
21944887Schin 	while(c = *s++)
21954887Schin 	{
21964887Schin 		if(c=='\\')
21974887Schin 			c = *s++;
21984887Schin 		if(c && c != *r++)
21994887Schin 			return(0);
22004887Schin 	}
22014887Schin 	return(*r==0);
22024887Schin }
22034887Schin 
22044887Schin /*
22054887Schin  * print out the command line if set -x is on
22064887Schin  */
22074887Schin 
22084887Schin int sh_trace(register char *argv[], register int nl)
22094887Schin {
22108462SApril.Chin@Sun.COM 	Shell_t	*shp = &sh;
22114887Schin 	register char *cp;
22124887Schin 	register int bracket = 0;
22138462SApril.Chin@Sun.COM 	int decl = (nl&2);
22148462SApril.Chin@Sun.COM 	nl &= ~2;
22154887Schin 	if(sh_isoption(SH_XTRACE))
22164887Schin 	{
22174887Schin 		/* make this trace atomic */
22184887Schin 		sfset(sfstderr,SF_SHARE|SF_PUBLIC,0);
22198462SApril.Chin@Sun.COM 		if(!(cp=nv_getval(sh_scoped(shp,PS4NOD))))
22204887Schin 			cp = "+ ";
22214887Schin 		else
22224887Schin 		{
22234887Schin 			sh_offoption(SH_XTRACE);
22248462SApril.Chin@Sun.COM 			cp = sh_mactry(shp,cp);
22254887Schin 			sh_onoption(SH_XTRACE);
22264887Schin 		}
22274887Schin 		if(*cp)
22284887Schin 			sfputr(sfstderr,cp,-1);
22294887Schin 		if(argv)
22304887Schin 		{
22314887Schin 			char *argv0 = *argv;
22324887Schin 			nl = (nl?'\n':-1);
22334887Schin 			/* don't quote [ and [[ */
22344887Schin 			if(*(cp=argv[0])=='[' && (!cp[1] || !cp[2]&&cp[1]=='['))
22354887Schin 			{
22364887Schin 				sfputr(sfstderr,cp,*++argv?' ':nl);
22374887Schin 				bracket = 1;
22384887Schin 			}
22394887Schin 			while(cp = *argv++)
22404887Schin 			{
22414887Schin 				if(bracket==0 || *argv || *cp!=']')
22424887Schin 					cp = sh_fmtq(cp);
22438462SApril.Chin@Sun.COM 				if(decl && shp->prefix && cp!=argv0 && *cp!='-')
22444887Schin 				{
22454887Schin 					if(*cp=='.' && cp[1]==0)
22468462SApril.Chin@Sun.COM 						cp = shp->prefix;
22474887Schin 					else
22488462SApril.Chin@Sun.COM 						sfputr(sfstderr,shp->prefix,'.');
22494887Schin 				}
22504887Schin 				sfputr(sfstderr,cp,*argv?' ':nl);
22514887Schin 			}
22524887Schin 			sfset(sfstderr,SF_SHARE|SF_PUBLIC,1);
22534887Schin 		}
22544887Schin 		return(1);
22554887Schin 	}
22564887Schin 	return(0);
22574887Schin }
22584887Schin 
22594887Schin /*
22604887Schin  * This routine creates a subshell by calling fork() or vfork()
22614887Schin  * If ((flags&COMASK)==TCOM), then vfork() is permitted
22624887Schin  * If fork fails, the shell sleeps for exponentially longer periods
22634887Schin  *   and tries again until a limit is reached.
22644887Schin  * SH_FORKLIM is the max period between forks - power of 2 usually.
22654887Schin  * Currently shell tries after 2,4,8,16, and 32 seconds and then quits
22664887Schin  * Failures cause the routine to error exit.
22674887Schin  * Parent links to here-documents are removed by the child
22684887Schin  * Traps are reset by the child
22694887Schin  * The process-id of the child is returned to the parent, 0 to the child.
22704887Schin  */
22714887Schin 
22724887Schin static void timed_out(void *handle)
22734887Schin {
22744887Schin 	NOT_USED(handle);
22754887Schin 	timeout = 0;
22764887Schin }
22774887Schin 
22784887Schin 
22794887Schin /*
22804887Schin  * called by parent and child after fork by sh_fork()
22814887Schin  */
22824887Schin pid_t _sh_fork(register pid_t parent,int flags,int *jobid)
22834887Schin {
22844887Schin 	static long forkcnt = 1000L;
22858462SApril.Chin@Sun.COM 	Shell_t	*shp = &sh;
22864887Schin 	pid_t	curpgid = job.curpgid;
22874887Schin 	pid_t	postid = (flags&FAMP)?0:curpgid;
22888462SApril.Chin@Sun.COM 	int	sig,nochild;
22894887Schin 	if(parent<0)
22904887Schin 	{
22918462SApril.Chin@Sun.COM 		sh_sigcheck();
22924887Schin 		if((forkcnt *= 2) > 1000L*SH_FORKLIM)
22934887Schin 		{
22944887Schin 			forkcnt=1000L;
22954887Schin 			errormsg(SH_DICT,ERROR_system(ERROR_NOEXEC),e_nofork);
22964887Schin 		}
22974887Schin 		timeout = (void*)sh_timeradd(forkcnt, 0, timed_out, NIL(void*));
22988462SApril.Chin@Sun.COM 		nochild = job_wait((pid_t)1);
22994887Schin 		if(timeout)
23004887Schin 		{
23018462SApril.Chin@Sun.COM 			if(nochild)
23028462SApril.Chin@Sun.COM 				pause();
23038462SApril.Chin@Sun.COM 			else if(forkcnt>1000L)
23048462SApril.Chin@Sun.COM 				forkcnt /= 2;
23054887Schin 			timerdel(timeout);
23068462SApril.Chin@Sun.COM 			timeout = 0;
23074887Schin 		}
23084887Schin 		return(-1);
23094887Schin 	}
23108462SApril.Chin@Sun.COM 	forkcnt = 1000L;
23114887Schin 	if(parent)
23124887Schin 	{
23138462SApril.Chin@Sun.COM 		int myjob,waitall=job.waitall;
23148462SApril.Chin@Sun.COM 		shp->nforks++;
23154887Schin 		if(job.toclear)
23164887Schin 			job_clear();
23178462SApril.Chin@Sun.COM 		job.waitall = waitall;
23184887Schin #ifdef JOBS
23194887Schin 		/* first process defines process group */
23204887Schin 		if(sh_isstate(SH_MONITOR))
23214887Schin 		{
23224887Schin 			/*
23234887Schin 			 * errno==EPERM means that an earlier processes
23244887Schin 			 * completed.  Make parent the job group id.
23254887Schin 			 */
23264887Schin 			if(postid==0)
23274887Schin 				job.curpgid = parent;
23284887Schin 			if(job.jobcontrol || (flags&FAMP))
23294887Schin 			{
23304887Schin 				if(setpgid(parent,job.curpgid)<0 && errno==EPERM)
23314887Schin 					setpgid(parent,parent);
23324887Schin 			}
23334887Schin 		}
23344887Schin #endif /* JOBS */
23354887Schin 		if(!sh_isstate(SH_MONITOR) && job.waitall && postid==0)
23364887Schin 			job.curpgid = parent;
23374887Schin 		if(flags&FCOOP)
23388462SApril.Chin@Sun.COM 			shp->cpid = parent;
23394887Schin 		myjob = job_post(parent,postid);
23404887Schin 		if(flags&FAMP)
23414887Schin 			job.curpgid = curpgid;
23424887Schin 		if(jobid)
23434887Schin 			*jobid = myjob;
23444887Schin 		return(parent);
23454887Schin 	}
23464887Schin #if !_std_malloc
23474887Schin 	vmtrace(-1);
23484887Schin #endif
23494887Schin 	/* This is the child process */
23508462SApril.Chin@Sun.COM 	if(shp->trapnote&SH_SIGTERM)
23514887Schin 		sh_exit(SH_EXITSIG|SIGTERM);
23528462SApril.Chin@Sun.COM 	shp->nforks=0;
23534887Schin 	timerdel(NIL(void*));
23544887Schin #ifdef JOBS
23554887Schin 	if(!job.jobcontrol && !(flags&FAMP))
23564887Schin 		sh_offstate(SH_MONITOR);
23574887Schin 	if(sh_isstate(SH_MONITOR))
23584887Schin 	{
23594887Schin 		parent = getpid();
23604887Schin 		if(postid==0)
23614887Schin 			job.curpgid = parent;
23624887Schin 		while(setpgid(0,job.curpgid)<0 && job.curpgid!=parent)
23634887Schin 			job.curpgid = parent;
23644887Schin #   ifdef SIGTSTP
23654887Schin 		if(job.curpgid==parent &&  !(flags&FAMP))
23664887Schin 			tcsetpgrp(job.fd,job.curpgid);
23674887Schin #   endif /* SIGTSTP */
23684887Schin 	}
23694887Schin #   ifdef SIGTSTP
23704887Schin 	if(job.jobcontrol)
23714887Schin 	{
23724887Schin 		signal(SIGTTIN,SIG_DFL);
23734887Schin 		signal(SIGTTOU,SIG_DFL);
23744887Schin 		signal(SIGTSTP,SIG_DFL);
23754887Schin 	}
23764887Schin #   endif /* SIGTSTP */
23774887Schin 	job.jobcontrol = 0;
23784887Schin #endif /* JOBS */
23794887Schin 	job.toclear = 1;
23808462SApril.Chin@Sun.COM 	shp->login_sh = 0;
23814887Schin 	sh_offoption(SH_LOGIN_SHELL);
23824887Schin 	sh_onstate(SH_FORKED);
23834887Schin 	sh_onstate(SH_NOLOG);
23848462SApril.Chin@Sun.COM 	if (shp->fn_reset)
23858462SApril.Chin@Sun.COM 		shp->fn_depth = shp->fn_reset = 0;
23864887Schin #if SHOPT_ACCT
23874887Schin 	sh_accsusp();
23884887Schin #endif	/* SHOPT_ACCT */
23894887Schin 	/* Reset remaining signals to parent */
23904887Schin 	/* except for those `lost' by trap   */
23914887Schin 	sh_sigreset(2);
23928462SApril.Chin@Sun.COM 	shp->subshell = 0;
23938462SApril.Chin@Sun.COM 	if((flags&FAMP) && shp->coutpipe>1)
23948462SApril.Chin@Sun.COM 		sh_close(shp->coutpipe);
23958462SApril.Chin@Sun.COM 	sig = shp->savesig;
23968462SApril.Chin@Sun.COM 	shp->savesig = 0;
23974887Schin 	if(sig>0)
23984887Schin 		sh_fault(sig);
23994887Schin 	sh_sigcheck();
24004887Schin 	return(0);
24014887Schin }
24024887Schin 
24034887Schin pid_t sh_fork(int flags, int *jobid)
24044887Schin {
24054887Schin 	register pid_t parent;
24064887Schin 	register int sig;
24074887Schin #if SHOPT_FASTPIPE
24084887Schin 	if(sffileno(sfstdin)<0)
24094887Schin 	{
24104887Schin 		off_t current = sfseek(sfstdin,(off_t)0,SEEK_CUR);
24114887Schin 		sfseek(sfstdin,(off_t)0,SEEK_END);
24124887Schin 		sfdisc(sfstdin,SF_POPDISC);
24134887Schin 		fcntl(sffileno(sfstdin),F_SETFD,0);
24144887Schin 		sh_iostream(0);
24154887Schin 		sfseek(sfstdin,current,SEEK_SET);
24164887Schin 	}
24174887Schin #endif /* SHOPT_FASTPIPE */
24184887Schin 	if(!sh.pathlist)
24194887Schin 		path_get("");
24204887Schin 	sfsync(NIL(Sfio_t*));
24214887Schin 	sh.trapnote &= ~SH_SIGTERM;
24224887Schin 	job_fork(-1);
24234887Schin 	sh.savesig = -1;
24244887Schin 	while(_sh_fork(parent=fork(),flags,jobid) < 0);
24258462SApril.Chin@Sun.COM 	sh_stats(STAT_FORKS);
24264887Schin 	sig = sh.savesig;
24274887Schin 	sh.savesig = 0;
24284887Schin 	if(sig>0)
24294887Schin 		sh_fault(sig);
24304887Schin 	job_fork(parent);
24314887Schin 	return(parent);
24324887Schin }
24334887Schin 
24344887Schin /*
24354887Schin  * add exports from previous scope to the new scope
24364887Schin  */
24374887Schin static void  local_exports(register Namval_t *np, void *data)
24384887Schin {
24394887Schin 	register Namval_t	*mp;
24404887Schin 	register char		*cp;
24414887Schin 	if(nv_isarray(np))
24424887Schin 		nv_putsub(np,NIL(char*),0);
24434887Schin 	if((cp = nv_getval(np)) && (mp = nv_search(nv_name(np), sh.var_tree, NV_ADD|HASH_NOSCOPE)) && nv_isnull(mp))
24444887Schin 		nv_putval(mp, cp, 0);
24454887Schin }
24464887Schin 
24474887Schin /*
24484887Schin  * This routine is used to execute the given function <fun> in a new scope
24494887Schin  * If <fun> is NULL, then arg points to a structure containing a pointer
24504887Schin  *  to a function that will be executed in the current environment.
24514887Schin  */
24524887Schin int sh_funscope(int argn, char *argv[],int(*fun)(void*),void *arg,int execflg)
24534887Schin {
24548462SApril.Chin@Sun.COM 	register char		*trap;
24558462SApril.Chin@Sun.COM 	register int		nsig;
24568462SApril.Chin@Sun.COM 	register Shell_t	*shp =  &sh;
24578462SApril.Chin@Sun.COM 	struct dolnod		*argsav=0,*saveargfor;
24588462SApril.Chin@Sun.COM 	struct sh_scoped	savst, *prevscope = shp->st.self;
24598462SApril.Chin@Sun.COM 	struct argnod		*envlist=0;
24608462SApril.Chin@Sun.COM 	int			jmpval;
24618462SApril.Chin@Sun.COM 	volatile int		r = 0;
24628462SApril.Chin@Sun.COM 	char 			*savstak;
24638462SApril.Chin@Sun.COM 	struct funenv		*fp;
24648462SApril.Chin@Sun.COM 	struct checkpt		buff;
24658462SApril.Chin@Sun.COM 	Namval_t		*nspace = shp->namespace;
24668462SApril.Chin@Sun.COM 	if(shp->fn_depth==0)
24678462SApril.Chin@Sun.COM 		shp->glob_options =  shp->options;
24688462SApril.Chin@Sun.COM 	else
24698462SApril.Chin@Sun.COM 		shp->options = shp->glob_options;
24708462SApril.Chin@Sun.COM #if 0
24718462SApril.Chin@Sun.COM 	shp->st.lineno = error_info.line;
24728462SApril.Chin@Sun.COM #endif
24738462SApril.Chin@Sun.COM 	*prevscope = shp->st;
24744887Schin 	sh_offoption(SH_ERREXIT);
24758462SApril.Chin@Sun.COM 	shp->st.prevst = prevscope;
24768462SApril.Chin@Sun.COM 	shp->st.self = &savst;
24778462SApril.Chin@Sun.COM 	shp->topscope = (Shscope_t*)shp->st.self;
24788462SApril.Chin@Sun.COM 	shp->st.opterror = shp->st.optchar = 0;
24798462SApril.Chin@Sun.COM 	shp->st.optindex = 1;
24808462SApril.Chin@Sun.COM 	shp->st.loopcnt = 0;
24814887Schin 	if(!fun)
24824887Schin 	{
24834887Schin 		fp = (struct funenv*)arg;
24848462SApril.Chin@Sun.COM 		shp->st.real_fun = (fp->node)->nvalue.rp;
24854887Schin 		envlist = fp->env;
24864887Schin 	}
24878462SApril.Chin@Sun.COM 	prevscope->save_tree = shp->var_tree;
24888462SApril.Chin@Sun.COM 	sh_scope(shp,envlist,1);
24898462SApril.Chin@Sun.COM 	if(dtvnext(prevscope->save_tree)!= (shp->namespace?shp->var_base:0))
24904887Schin 	{
24914887Schin 		/* eliminate parent scope */
24924887Schin 		nv_scan(prevscope->save_tree, local_exports,(void*)0, NV_EXPORT, NV_EXPORT|NV_NOSCOPE);
24934887Schin 	}
24948462SApril.Chin@Sun.COM 	shp->st.save_tree = shp->var_tree;
24954887Schin 	if(!fun)
24964887Schin 	{
24974887Schin 		Namval_t *np;
24984887Schin 		if(nv_isattr(fp->node,NV_TAGGED))
24994887Schin 			sh_onoption(SH_XTRACE);
25004887Schin 		else
25014887Schin 			sh_offoption(SH_XTRACE);
25024887Schin #if SHOPT_NAMESPACE
25038462SApril.Chin@Sun.COM 		if((np=(fp->node)->nvalue.rp->nspace) && np!=shp->namespace)
25044887Schin 		{
25058462SApril.Chin@Sun.COM 			Dt_t *dt = shp->var_tree;
25064887Schin 			dtview(dt,0);
25074887Schin 			dtview(dt,nv_dict(np));
25088462SApril.Chin@Sun.COM 			shp->var_tree = nv_dict(np);
25098462SApril.Chin@Sun.COM 			shp->namespace = np;
25104887Schin 		}
25114887Schin #endif /* SHOPT_NAMESPACE */
25124887Schin 	}
25138462SApril.Chin@Sun.COM 	shp->st.cmdname = argv[0];
25144887Schin 	/* save trap table */
25158462SApril.Chin@Sun.COM 	if((nsig=shp->st.trapmax*sizeof(char*))>0 || shp->st.trapcom[0])
25164887Schin 	{
25174887Schin 		nsig += sizeof(char*);
25188462SApril.Chin@Sun.COM 		memcpy(savstak=stakalloc(nsig),(char*)&shp->st.trapcom[0],nsig);
25194887Schin 	}
25204887Schin 	sh_sigreset(0);
25218462SApril.Chin@Sun.COM 	argsav = sh_argnew(shp,argv,&saveargfor);
25224887Schin 	sh_pushcontext(&buff,SH_JMPFUN);
25234887Schin 	errorpush(&buff.err,0);
25244887Schin 	error_info.id = argv[0];
25258462SApril.Chin@Sun.COM 	shp->st.var_local = shp->var_tree;
25264887Schin 	jmpval = sigsetjmp(buff.buff,0);
25274887Schin 	if(!fun)
25284887Schin 	{
25298462SApril.Chin@Sun.COM 		shp->st.filename = fp->node->nvalue.rp->fname;
25308462SApril.Chin@Sun.COM 		shp->st.funname = nv_name(fp->node);
25318462SApril.Chin@Sun.COM 		nv_putval(SH_PATHNAMENOD,shp->st.filename,NV_NOFREE);
25328462SApril.Chin@Sun.COM 		nv_putval(SH_FUNNAMENOD,shp->st.funname,NV_NOFREE);
25334887Schin 	}
25344887Schin 	if(jmpval == 0)
25354887Schin 	{
25368462SApril.Chin@Sun.COM 		if(shp->fn_depth++ > MAXDEPTH)
25378462SApril.Chin@Sun.COM 			siglongjmp(*shp->jmplist,SH_JMPERRFN);
25384887Schin 		else if(fun)
25394887Schin 			r= (*fun)(arg);
25404887Schin 		else
25414887Schin 		{
25424887Schin 			sh_exec((Shnode_t*)(nv_funtree((fp->node))),execflg|SH_ERREXIT);
25438462SApril.Chin@Sun.COM 			r = shp->exitval;
25444887Schin 		}
25454887Schin 	}
25468462SApril.Chin@Sun.COM 	if(--shp->fn_depth==1 && jmpval==SH_JMPERRFN)
25474887Schin 		errormsg(SH_DICT,ERROR_exit(1),e_toodeep,argv[0]);
25484887Schin 	sh_popcontext(&buff);
25498462SApril.Chin@Sun.COM 	if (shp->st.self != &savst)
25508462SApril.Chin@Sun.COM 		shp->var_tree = (Dt_t*)savst.save_tree;
25518462SApril.Chin@Sun.COM 	sh_unscope(shp);
25528462SApril.Chin@Sun.COM 	shp->namespace = nspace;
25538462SApril.Chin@Sun.COM 	shp->var_tree = (Dt_t*)prevscope->save_tree;
25548462SApril.Chin@Sun.COM 	if(shp->topscope != (Shscope_t*)shp->st.self)
25558462SApril.Chin@Sun.COM 		sh_setscope(shp->topscope);
25568462SApril.Chin@Sun.COM 	sh_argreset(shp,argsav,saveargfor);
25578462SApril.Chin@Sun.COM 	trap = shp->st.trapcom[0];
25588462SApril.Chin@Sun.COM 	shp->st.trapcom[0] = 0;
25594887Schin 	sh_sigreset(1);
25608462SApril.Chin@Sun.COM 	if (shp->st.self != &savst)
25618462SApril.Chin@Sun.COM 		*shp->st.self = shp->st;
25628462SApril.Chin@Sun.COM 	shp->st = *prevscope;
25638462SApril.Chin@Sun.COM 	shp->topscope = (Shscope_t*)prevscope;
25648462SApril.Chin@Sun.COM 	nv_getval(sh_scoped(shp,IFSNOD));
25654887Schin 	if(nsig)
25668462SApril.Chin@Sun.COM 		memcpy((char*)&shp->st.trapcom[0],savstak,nsig);
25678462SApril.Chin@Sun.COM 	shp->trapnote=0;
25684887Schin 	if(nsig)
25694887Schin 		stakset(savstak,0);
25708462SApril.Chin@Sun.COM 	shp->options = shp->glob_options;
25714887Schin 	if(trap)
25724887Schin 	{
25734887Schin 		sh_trap(trap,0);
25744887Schin 		free(trap);
25754887Schin 	}
25768462SApril.Chin@Sun.COM 	if(shp->exitval > SH_EXITSIG)
25778462SApril.Chin@Sun.COM 		sh_fault(shp->exitval&SH_EXITMASK);
25784887Schin 	if(jmpval > SH_JMPFUN)
25794887Schin 	{
25804887Schin 		sh_chktrap();
25818462SApril.Chin@Sun.COM 		siglongjmp(*shp->jmplist,jmpval);
25824887Schin 	}
25834887Schin 	return(r);
25844887Schin }
25854887Schin 
25868462SApril.Chin@Sun.COM static void sh_funct(Shell_t *shp,Namval_t *np,int argn, char *argv[],struct argnod *envlist,int execflg)
25874887Schin {
25884887Schin 	struct funenv fun;
25894887Schin 	char *fname = nv_getval(SH_FUNNAMENOD);
25908462SApril.Chin@Sun.COM 	struct Level	*lp =(struct Level*)(SH_LEVELNOD->nvfun);
25918462SApril.Chin@Sun.COM 	int		level;
25928462SApril.Chin@Sun.COM 	sh_stats(STAT_FUNCT);
25938462SApril.Chin@Sun.COM 	if(!lp->hdr.disc)
25948462SApril.Chin@Sun.COM 		lp = init_level(0);
25958462SApril.Chin@Sun.COM 	if((struct sh_scoped*)shp->topscope != shp->st.self)
25968462SApril.Chin@Sun.COM 		sh_setscope(shp->topscope);
25978462SApril.Chin@Sun.COM 	level = lp->maxlevel = shp->dot_depth + shp->fn_depth+1;
25988462SApril.Chin@Sun.COM 	SH_LEVELNOD->nvalue.s = lp->maxlevel;
25998462SApril.Chin@Sun.COM 	shp->st.lineno = error_info.line;
26004887Schin 	if(nv_isattr(np,NV_FPOSIX))
26014887Schin 	{
26024887Schin 		char *save;
26038462SApril.Chin@Sun.COM 		int loopcnt = shp->st.loopcnt;
26048462SApril.Chin@Sun.COM 		shp->posix_fun = np;
26058462SApril.Chin@Sun.COM 		save = argv[-1];
26068462SApril.Chin@Sun.COM 		argv[-1] = 0;
26078462SApril.Chin@Sun.COM 		shp->st.funname = nv_name(np);
26088462SApril.Chin@Sun.COM 		nv_putval(SH_FUNNAMENOD, nv_name(np),NV_NOFREE);
26094887Schin 		opt_info.index = opt_info.offset = 0;
26104887Schin 		error_info.errors = 0;
26118462SApril.Chin@Sun.COM 		shp->st.loopcnt = 0;
26128462SApril.Chin@Sun.COM 		b_dot_cmd(argn+1,argv-1,&shp->bltindata);
26138462SApril.Chin@Sun.COM 		shp->st.loopcnt = loopcnt;
26144887Schin 		argv[-1] = save;
26154887Schin 	}
26164887Schin 	else
26174887Schin 	{
26184887Schin 		fun.env = envlist;
26194887Schin 		fun.node = np;
26204887Schin 		sh_funscope(argn,argv,0,&fun,execflg);
26214887Schin 	}
26228462SApril.Chin@Sun.COM 	if(level-- != nv_getnum(SH_LEVELNOD))
26238462SApril.Chin@Sun.COM 	{
26248462SApril.Chin@Sun.COM 		Shscope_t *sp = sh_getscope(0,SEEK_END);
26258462SApril.Chin@Sun.COM 		sh_setscope(sp);
26268462SApril.Chin@Sun.COM 	}
26278462SApril.Chin@Sun.COM 	lp->maxlevel = level;
26288462SApril.Chin@Sun.COM 	SH_LEVELNOD->nvalue.s = lp->maxlevel;
26298462SApril.Chin@Sun.COM #if 0
26308462SApril.Chin@Sun.COM 	nv_putval(SH_FUNNAMENOD,shp->st.funname,NV_NOFREE);
26318462SApril.Chin@Sun.COM #else
26324887Schin 	nv_putval(SH_FUNNAMENOD,fname,NV_NOFREE);
26338462SApril.Chin@Sun.COM #endif
26348462SApril.Chin@Sun.COM 	nv_putval(SH_PATHNAMENOD,shp->st.filename,NV_NOFREE);
26354887Schin }
26364887Schin 
26374887Schin /*
26384887Schin  * external interface to execute a function without arguments
26394887Schin  * <np> is the function node
26404887Schin  * If <nq> is not-null, then sh.name and sh.subscript will be set
26414887Schin  */
26424887Schin int sh_fun(Namval_t *np, Namval_t *nq, char *argv[])
26434887Schin {
26448462SApril.Chin@Sun.COM 	Shell_t		*shp = &sh;
26454887Schin 	register int offset;
26464887Schin 	register char *base;
26474887Schin 	Namval_t node;
26488462SApril.Chin@Sun.COM 	struct Namref	nr;
26498462SApril.Chin@Sun.COM 	long		mode;
26508462SApril.Chin@Sun.COM 	char		*prefix = shp->prefix;
26514887Schin 	int n=0;
26524887Schin 	char *av[2];
26534887Schin 	Fcin_t save;
26544887Schin 	fcsave(&save);
26554887Schin 	if((offset=staktell())>0)
26564887Schin 		base=stakfreeze(0);
26578462SApril.Chin@Sun.COM 	shp->prefix = 0;
26584887Schin 	if(!argv)
26594887Schin 	{
26604887Schin 		argv = av;
26614887Schin 		argv[1]=0;
26624887Schin 	}
26634887Schin 	argv[0] = nv_name(np);
26644887Schin 	while(argv[n])
26654887Schin 		n++;
26664887Schin 	if(nq)
26678462SApril.Chin@Sun.COM 		mode = set_instance(nq,&node, &nr);
26684887Schin 	if(is_abuiltin(np))
26694887Schin 	{
26704887Schin 		int jmpval;
26714887Schin 		struct checkpt buff;
26728462SApril.Chin@Sun.COM 		Shbltin_t *bp = &sh.bltindata;
26734887Schin 		sh_pushcontext(&buff,SH_JMPCMD);
26744887Schin 		jmpval = sigsetjmp(buff.buff,1);
26754887Schin 		if(jmpval == 0)
26764887Schin 		{
26778462SApril.Chin@Sun.COM 			bp->bnode = np;
26788462SApril.Chin@Sun.COM 			bp->ptr = nv_context(np);
26794887Schin 			errorpush(&buff.err,0);
26804887Schin 			error_info.id = argv[0];
26814887Schin 			opt_info.index = opt_info.offset = 0;
26824887Schin 			opt_info.disc = 0;
26834887Schin 			sh.exitval = 0;
26848462SApril.Chin@Sun.COM 			sh.exitval = (*funptr(np))(n,argv,(void*)bp);
26854887Schin 		}
26864887Schin 		sh_popcontext(&buff);
26874887Schin 		if(jmpval>SH_JMPCMD)
26884887Schin 			siglongjmp(*sh.jmplist,jmpval);
26894887Schin 	}
26904887Schin 	else
26918462SApril.Chin@Sun.COM 		sh_funct(shp,np,n,argv,(struct argnod*)0,sh_isstate(SH_ERREXIT));
26924887Schin 	if(nq)
26938462SApril.Chin@Sun.COM 		unset_instance(nq, &node, &nr, mode);
26944887Schin 	fcrestore(&save);
26954887Schin 	if(offset>0)
26964887Schin 		stakset(base,offset);
26978462SApril.Chin@Sun.COM 	shp->prefix = prefix;
26984887Schin 	return(sh.exitval);
26994887Schin }
27004887Schin 
27014887Schin /*
27024887Schin  * This dummy routine is called by built-ins that do recursion
27034887Schin  * on the file system (chmod, chgrp, chown).  It causes
27044887Schin  * the shell to invoke the non-builtin version in this case
27054887Schin  */
27064887Schin int cmdrecurse(int argc, char* argv[], int ac, char* av[])
27074887Schin {
27084887Schin 	NOT_USED(argc);
27094887Schin 	NOT_USED(argv[0]);
27104887Schin 	NOT_USED(ac);
27114887Schin 	NOT_USED(av[0]);
27124887Schin 	return(SH_RUNPROG);
27134887Schin }
27144887Schin 
27154887Schin /*
27164887Schin  * set up pipe for cooperating process
27174887Schin  */
27188462SApril.Chin@Sun.COM static void coproc_init(Shell_t *shp, int pipes[])
27194887Schin {
27204887Schin 	int outfd;
27218462SApril.Chin@Sun.COM 	if(shp->coutpipe>=0 && shp->cpid)
27224887Schin 		errormsg(SH_DICT,ERROR_exit(1),e_pexists);
27238462SApril.Chin@Sun.COM 	shp->cpid = 0;
27248462SApril.Chin@Sun.COM 	if(shp->cpipe[0]<=0 || shp->cpipe[1]<=0)
27254887Schin 	{
27264887Schin 		/* first co-process */
27278462SApril.Chin@Sun.COM 		sh_pclose(shp->cpipe);
27288462SApril.Chin@Sun.COM 		sh_pipe(shp->cpipe);
27298462SApril.Chin@Sun.COM 		if((outfd=shp->cpipe[1]) < 10)
27304887Schin 		{
27318462SApril.Chin@Sun.COM 		        int fd=fcntl(shp->cpipe[1],F_DUPFD,10);
27324887Schin 			if(fd>=10)
27334887Schin 			{
27348462SApril.Chin@Sun.COM 			        shp->fdstatus[fd] = (shp->fdstatus[outfd]&~IOCLEX);
27354887Schin 				close(outfd);
27368462SApril.Chin@Sun.COM 			        shp->fdstatus[outfd] = IOCLOSE;
27378462SApril.Chin@Sun.COM 				shp->cpipe[1] = fd;
27384887Schin 			}
27394887Schin 		}
27408462SApril.Chin@Sun.COM 		if(fcntl(*shp->cpipe,F_SETFD,FD_CLOEXEC)>=0)
27418462SApril.Chin@Sun.COM 			shp->fdstatus[shp->cpipe[0]] |= IOCLEX;
27428462SApril.Chin@Sun.COM 		shp->fdptrs[shp->cpipe[0]] = shp->cpipe;
27434887Schin 
27448462SApril.Chin@Sun.COM 		if(fcntl(shp->cpipe[1],F_SETFD,FD_CLOEXEC) >=0)
27458462SApril.Chin@Sun.COM 			shp->fdstatus[shp->cpipe[1]] |= IOCLEX;
27464887Schin 	}
27478462SApril.Chin@Sun.COM 	shp->outpipe = shp->cpipe;
27488462SApril.Chin@Sun.COM 	sh_pipe(shp->inpipe=pipes);
27498462SApril.Chin@Sun.COM 	shp->coutpipe = shp->inpipe[1];
27508462SApril.Chin@Sun.COM 	shp->fdptrs[shp->coutpipe] = &shp->coutpipe;
27518462SApril.Chin@Sun.COM 	if(fcntl(shp->outpipe[0],F_SETFD,FD_CLOEXEC)>=0)
27528462SApril.Chin@Sun.COM 		shp->fdstatus[shp->outpipe[0]] |= IOCLEX;
27534887Schin }
27544887Schin 
27554887Schin #if SHOPT_SPAWN
27564887Schin 
27574887Schin 
27584887Schin #if SHOPT_AMP || !defined(_lib_fork)
27594887Schin /*
27604887Schin  * print out function definition
27614887Schin  */
27624887Schin static void print_fun(register Namval_t* np, void *data)
27634887Schin {
27644887Schin 	register char *format;
27654887Schin 	NOT_USED(data);
27664887Schin 	if(!is_afunction(np) || !np->nvalue.ip)
27674887Schin 		return;
27684887Schin 	if(nv_isattr(np,NV_FPOSIX))
27694887Schin 		format="%s()\n{ ";
27704887Schin 	else
27714887Schin 		format="function %s\n{ ";
27724887Schin 	sfprintf(sfstdout,format,nv_name(np));
27734887Schin 	sh_deparse(sfstdout,(Shnode_t*)(nv_funtree(np)),0);
27744887Schin 	sfwrite(sfstdout,"}\n",2);
27754887Schin }
27764887Schin 
27774887Schin /*
27784887Schin  * create a shell script consisting of t->fork.forktre and execute it
27794887Schin  */
27804887Schin static int run_subshell(const Shnode_t *t,pid_t grp)
27814887Schin {
27828462SApril.Chin@Sun.COM 	static const char prolog[] = "(print $(typeset +A);set; typeset -p; print .sh.dollar=$$;set +o)";
27834887Schin 	register int i, fd, trace = sh_isoption(SH_XTRACE);
27844887Schin 	int pin,pout;
27854887Schin 	pid_t pid;
27864887Schin 	char *arglist[2], *envlist[2], devfd[12], *cp;
27874887Schin 	Sfio_t *sp = sftmp(0);
27884887Schin 	envlist[0] = "_=" SH_ID;
27894887Schin 	envlist[1] = 0;
27904887Schin 	arglist[0] = error_info.id?error_info.id:sh.shname;
27914887Schin 	if(*arglist[0]=='-')
27924887Schin 		arglist[0]++;
27934887Schin 	arglist[1] = devfd;
27944887Schin 	strncpy(devfd,e_devfdNN,sizeof(devfd));
27954887Schin 	arglist[2] = 0;
27964887Schin 	sfstack(sfstdout,sp);
27974887Schin 	if(trace)
27984887Schin 		sh_offoption(SH_XTRACE);
27994887Schin 	sfwrite(sfstdout,"typeset -A -- ",14);
28004887Schin 	sh_trap(prolog,0);
28014887Schin 	nv_scan(sh.fun_tree, print_fun, (void*)0,0, 0);
28024887Schin 	if(sh.st.dolc>0)
28034887Schin 	{
28044887Schin 		/* pass the positional parameters */
28054887Schin 		char **argv = sh.st.dolv+1;
28064887Schin 		sfwrite(sfstdout,"set --",6);
28074887Schin 		while(*argv)
28084887Schin 			sfprintf(sfstdout," %s",sh_fmtq(*argv++));
28094887Schin 		sfputc(sfstdout,'\n');
28104887Schin 	}
28114887Schin 	pin = (sh.inpipe?sh.inpipe[1]:0);
28124887Schin 	pout = (sh.outpipe?sh.outpipe[0]:0);
28134887Schin 	for(i=3; i < 10; i++)
28144887Schin 	{
28154887Schin 		if(sh.fdstatus[i]&IOCLEX && i!=pin && i!=pout)
28164887Schin 		{
28174887Schin 			sfprintf(sfstdout,"exec %d<&%d\n",i,i);
28184887Schin 			fcntl(i,F_SETFD,0);
28194887Schin 		}
28204887Schin 	}
28214887Schin 	sfprintf(sfstdout,"LINENO=%d\n",t->fork.forkline);
28224887Schin 	if(trace)
28234887Schin 	{
28244887Schin 		sfwrite(sfstdout,"set -x\n",7);
28254887Schin 		sh_onoption(SH_XTRACE);
28264887Schin 	}
28274887Schin 	sfstack(sfstdout,NIL(Sfio_t*));
28284887Schin 	sh_deparse(sp,t->fork.forktre,0);
28294887Schin 	sfseek(sp,(Sfoff_t)0,SEEK_SET);
28304887Schin 	fd = sh_dup(sffileno(sp));
28314887Schin 	cp = devfd+8;
28324887Schin 	if(fd>9)
28334887Schin 		*cp++ = '0' + (fd/10);
28344887Schin 	*cp++ = '0' + fd%10;
28354887Schin 	*cp = 0;
28364887Schin 	sfclose(sp);
28374887Schin 	sfsync(NIL(Sfio_t*));
28384887Schin 	if(!sh.shpath)
28394887Schin 		sh.shpath = pathshell();
28404887Schin 	pid = spawnveg(sh.shpath,arglist,envlist,grp);
28414887Schin 	close(fd);
28424887Schin 	for(i=3; i < 10; i++)
28434887Schin 	{
28444887Schin 		if(sh.fdstatus[i]&IOCLEX && i!=pin && i!=pout)
28454887Schin 			fcntl(i,F_SETFD,FD_CLOEXEC);
28464887Schin 	}
28474887Schin 	if(pid <=0)
28484887Schin 		errormsg(SH_DICT,ERROR_system(ERROR_NOEXEC),e_exec,arglist[0]);
28494887Schin 	return(pid);
28504887Schin }
28514887Schin #endif /* !_lib_fork */
28524887Schin 
28534887Schin static void sigreset(int mode)
28544887Schin {
28554887Schin 	register char   *trap;
28564887Schin 	register int sig=sh.st.trapmax;
28574887Schin 	while(sig-- > 0)
28584887Schin 	{
28594887Schin 		if((trap=sh.st.trapcom[sig]) && *trap==0)
28604887Schin 			signal(sig,mode?sh_fault:SIG_IGN);
28614887Schin 	}
28624887Schin }
28634887Schin 
28644887Schin /*
28654887Schin  * A combined fork/exec for systems with slow or non-existent fork()
28664887Schin  */
28678462SApril.Chin@Sun.COM static pid_t sh_ntfork(Shell_t *shp,const Shnode_t *t,char *argv[],int *jobid,int flag)
28684887Schin {
28694887Schin 	static pid_t	spawnpid;
28704887Schin 	static int	savetype;
28714887Schin 	static int	savejobid;
28728462SApril.Chin@Sun.COM 	struct checkpt	buff;
28738462SApril.Chin@Sun.COM 	int		otype=0, jmpval;
28748462SApril.Chin@Sun.COM 	volatile int	jobwasset=0, scope=0, sigwasset=0;
28758462SApril.Chin@Sun.COM 	char		**arge, *path;
28768462SApril.Chin@Sun.COM 	volatile pid_t	grp = 0;
28778462SApril.Chin@Sun.COM 	Pathcomp_t	*pp;
28784887Schin 	if(flag)
28794887Schin 	{
28804887Schin 		otype = savetype;
28814887Schin 		savetype=0;
28824887Schin 	}
28834887Schin #   if SHOPT_AMP || !defined(_lib_fork)
28844887Schin 	if(!argv)
28854887Schin 	{
28864887Schin 		register Shnode_t *tchild = t->fork.forktre;
28874887Schin 		int optimize=0;
28884887Schin 		otype = t->tre.tretyp;
28894887Schin 		savetype = otype;
28904887Schin 		spawnpid = 0;
28914887Schin #	ifndef _lib_fork
28924887Schin 		if((tchild->tre.tretyp&COMMSK)==TCOM)
28934887Schin 		{
28944887Schin 			Namval_t *np = (Namval_t*)(tchild->com.comnamp);
28954887Schin 			if(np)
28964887Schin 			{
28974887Schin 				path = nv_name(np);
28984887Schin 				if(!nv_isattr(np,BLT_ENV))
28994887Schin 					np=0;
29004887Schin 				else if(strcmp(path,"echo")==0 || memcmp(path,"print",5)==0)
29014887Schin 					np=0;
29024887Schin 			}
29034887Schin 			else if(!tchild->com.comarg)
29044887Schin 				optimize=1;
29054887Schin 			else if(tchild->com.comtyp&COMSCAN)
29064887Schin 			{
29074887Schin 				if(tchild->com.comarg->argflag&ARG_RAW)
29084887Schin 					path = tchild->com.comarg->argval;
29094887Schin 				else
29104887Schin 					path = 0;
29114887Schin 			}
29124887Schin 			else
29134887Schin 				path = ((struct dolnod*)tchild->com.comarg)->dolval[ARG_SPARE];
29144887Schin 			if(!np && path && !nv_search(path,shp->fun_tree,0))
29154887Schin 				optimize=1;
29164887Schin 		}
29174887Schin #	endif
29184887Schin 		sh_pushcontext(&buff,SH_JMPIO);
29194887Schin 		jmpval = sigsetjmp(buff.buff,0);
29204887Schin 		{
29214887Schin 			if((otype&FINT) && !sh_isstate(SH_MONITOR))
29224887Schin 			{
29234887Schin 				signal(SIGQUIT,SIG_IGN);
29244887Schin 				signal(SIGINT,SIG_IGN);
29254887Schin 				if(!shp->st.ioset)
29264887Schin 				{
29278462SApril.Chin@Sun.COM 					sh_iosave(shp,0,buff.topfd,(char*)0);
29288462SApril.Chin@Sun.COM 					sh_iorenumber(shp,sh_chkopen(e_devnull),0);
29294887Schin 				}
29304887Schin 			}
29314887Schin 			if(otype&FPIN)
29324887Schin 			{
29334887Schin 				int fd = shp->inpipe[1];
29348462SApril.Chin@Sun.COM 				sh_iosave(shp,0,buff.topfd,(char*)0);
29358462SApril.Chin@Sun.COM 				sh_iorenumber(shp,shp->inpipe[0],0);
29364887Schin 				if(fd>=0 && (!(otype&FPOU) || (otype&FCOOP)) && fcntl(fd,F_SETFD,FD_CLOEXEC)>=0)
29374887Schin 					shp->fdstatus[fd] |= IOCLEX;
29384887Schin 			}
29394887Schin 			if(otype&FPOU)
29404887Schin 			{
29418462SApril.Chin@Sun.COM 				sh_iosave(shp,1,buff.topfd,(char*)0);
29428462SApril.Chin@Sun.COM 				sh_iorenumber(shp,sh_dup(shp->outpipe[1]),1);
29434887Schin 				if(fcntl(shp->outpipe[0],F_SETFD,FD_CLOEXEC)>=0)
29444887Schin 					shp->fdstatus[shp->outpipe[0]] |= IOCLEX;
29454887Schin 			}
29464887Schin 
29474887Schin 			if(t->fork.forkio)
29488462SApril.Chin@Sun.COM 				sh_redirect(shp,t->fork.forkio,0);
29494887Schin 			if(optimize==0)
29504887Schin 			{
29514887Schin #ifdef SIGTSTP
29524887Schin 				if(job.jobcontrol)
29534887Schin 				{
29544887Schin 					signal(SIGTTIN,SIG_DFL);
29554887Schin 					signal(SIGTTOU,SIG_DFL);
29564887Schin 				}
29574887Schin #endif /* SIGTSTP */
29584887Schin #ifdef JOBS
29594887Schin 				if(sh_isstate(SH_MONITOR) && (job.jobcontrol || (otype&FAMP)))
29604887Schin 				{
29614887Schin 					if((otype&FAMP) || job.curpgid==0)
29624887Schin 						grp = 1;
29634887Schin 					else
29644887Schin 						grp = job.curpgid;
29654887Schin 				}
29664887Schin #endif /* JOBS */
29674887Schin 				spawnpid = run_subshell(t,grp);
29684887Schin 			}
29694887Schin 			else
29704887Schin 			{
29714887Schin 				sh_exec(tchild,SH_NTFORK);
29724887Schin 				if(jobid)
29734887Schin 					*jobid = savejobid;
29744887Schin 			}
29754887Schin 		}
29764887Schin 		sh_popcontext(&buff);
29774887Schin 		if((otype&FINT) && !sh_isstate(SH_MONITOR))
29784887Schin 		{
29794887Schin 			signal(SIGQUIT,sh_fault);
29804887Schin 			signal(SIGINT,sh_fault);
29814887Schin 		}
29824887Schin 		if((otype&FPIN) && (!(otype&FPOU) || (otype&FCOOP)) && fcntl(shp->inpipe[1],F_SETFD,FD_CLOEXEC)>=0)
29834887Schin 			shp->fdstatus[shp->inpipe[1]] &= ~IOCLEX;
29844887Schin 		if(t->fork.forkio || otype)
29858462SApril.Chin@Sun.COM 			sh_iorestore(shp,buff.topfd,jmpval);
29864887Schin 		if(optimize==0)
29874887Schin 		{
29884887Schin #ifdef SIGTSTP
29894887Schin 			if(job.jobcontrol)
29904887Schin 			{
29914887Schin 				signal(SIGTTIN,SIG_IGN);
29924887Schin 				signal(SIGTTOU,SIG_IGN);
29934887Schin 			}
29944887Schin #endif /* SIGTSTP */
29954887Schin 			if(spawnpid>0)
29964887Schin 				_sh_fork(spawnpid,otype,jobid);
29974887Schin 			if(grp>0 && !(otype&FAMP))
29984887Schin 			{
29994887Schin 				while(tcsetpgrp(job.fd,job.curpgid)<0 && job.curpgid!=spawnpid)
30004887Schin 					job.curpgid = spawnpid;
30014887Schin 			}
30024887Schin 		}
30034887Schin 		savetype=0;
30044887Schin 		if(jmpval>SH_JMPIO)
30054887Schin 			siglongjmp(*shp->jmplist,jmpval);
30064887Schin 		if(spawnpid<0 && (otype&FCOOP))
30074887Schin 		{
30084887Schin 			sh_close(shp->coutpipe);
30094887Schin 			sh_close(shp->cpipe[1]);
30104887Schin 			shp->cpipe[1] = -1;
30114887Schin 			shp->coutpipe = -1;
30124887Schin 		}
30134887Schin 		shp->exitval = 0;
30144887Schin 		return(spawnpid);
30154887Schin 	}
30164887Schin #   endif /* !_lib_fork */
30174887Schin 	sh_pushcontext(&buff,SH_JMPCMD);
30184887Schin 	errorpush(&buff.err,ERROR_SILENT);
30194887Schin 	jmpval = sigsetjmp(buff.buff,0);
30204887Schin 	if(jmpval == 0)
30214887Schin 	{
30224887Schin 		if((otype&FINT) && !sh_isstate(SH_MONITOR))
30234887Schin 		{
30244887Schin 			signal(SIGQUIT,SIG_IGN);
30254887Schin 			signal(SIGINT,SIG_IGN);
30264887Schin 		}
30274887Schin 		spawnpid = -1;
30284887Schin 		if(t->com.comio)
30298462SApril.Chin@Sun.COM 			sh_redirect(shp,t->com.comio,0);
30304887Schin 		error_info.id = *argv;
30314887Schin 		if(t->com.comset)
30324887Schin 		{
30334887Schin 			scope++;
30348462SApril.Chin@Sun.COM 			sh_scope(shp,t->com.comset,0);
30354887Schin 		}
30364887Schin 		if(!strchr(path=argv[0],'/'))
30374887Schin 		{
30384887Schin 			Namval_t *np;
30394887Schin 			if((np=nv_search(path,shp->track_tree,0)) && !nv_isattr(np,NV_NOALIAS) && np->nvalue.cp)
30404887Schin 				path = nv_getval(np);
30414887Schin 			else if(path_absolute(path,NIL(Pathcomp_t*)))
30424887Schin 			{
30438462SApril.Chin@Sun.COM 			path = stkptr(shp->stk,PATH_OFFSET);
30448462SApril.Chin@Sun.COM 			stkfreeze(shp->stk,0);
30458462SApril.Chin@Sun.COM 		}
30468462SApril.Chin@Sun.COM 		else
30478462SApril.Chin@Sun.COM 		{
30488462SApril.Chin@Sun.COM 			pp=path_get(path);
30498462SApril.Chin@Sun.COM 			while(pp)
30504887Schin 			{
30518462SApril.Chin@Sun.COM 				if(pp->len==1 && *pp->name=='.')
30528462SApril.Chin@Sun.COM 					break;
30538462SApril.Chin@Sun.COM 				pp = pp->next;
30544887Schin 			}
30558462SApril.Chin@Sun.COM 			if(!pp)
30568462SApril.Chin@Sun.COM 				path = 0;
30574887Schin 		}
30588462SApril.Chin@Sun.COM 	}
30598462SApril.Chin@Sun.COM 	else if(sh_isoption(SH_RESTRICTED))
30608462SApril.Chin@Sun.COM 		errormsg(SH_DICT,ERROR_exit(1),e_restricted,path);
30618462SApril.Chin@Sun.COM 	if(!path)
30628462SApril.Chin@Sun.COM 	{
30638462SApril.Chin@Sun.COM 		spawnpid = -1;
30648462SApril.Chin@Sun.COM 		goto fail;
30658462SApril.Chin@Sun.COM 	}
30668462SApril.Chin@Sun.COM 	arge = sh_envgen();
30678462SApril.Chin@Sun.COM 	shp->exitval = 0;
30684887Schin #ifdef SIGTSTP
30694887Schin 		if(job.jobcontrol)
30704887Schin 		{
30714887Schin 			signal(SIGTTIN,SIG_DFL);
30724887Schin 			signal(SIGTTOU,SIG_DFL);
30734887Schin 			jobwasset++;
30744887Schin 		}
30754887Schin #endif /* SIGTSTP */
30764887Schin #ifdef JOBS
30774887Schin 		if(sh_isstate(SH_MONITOR) && (job.jobcontrol || (otype&FAMP)))
30784887Schin 		{
30794887Schin 			if((otype&FAMP) || job.curpgid==0)
30804887Schin 				grp = 1;
30814887Schin 			else
30824887Schin 				grp = job.curpgid;
30834887Schin 		}
30844887Schin #endif /* JOBS */
30854887Schin 
30864887Schin 		sfsync(NIL(Sfio_t*));
30874887Schin 		sigreset(0);	/* set signals to ignore */
30884887Schin 		sigwasset++;
30894887Schin 	        /* find first path that has a library component */
30904887Schin 		for(pp=path_get(argv[0]); pp && !pp->lib ; pp=pp->next);
30914887Schin 		spawnpid = path_spawn(path,argv,arge,pp,(grp<<1)|1);
30924887Schin 		if(spawnpid < 0 && errno==ENOEXEC)
30934887Schin 		{
30944887Schin 			char *devfd;
30954887Schin 			int fd = open(path,O_RDONLY);
30964887Schin 			argv[-1] = argv[0];
30974887Schin 			argv[0] = path;
30984887Schin 			if(fd>=0)
30994887Schin 			{
31004887Schin 				struct stat statb;
31014887Schin 				sfprintf(sh.strbuf,"/dev/fd/%d",fd);
31024887Schin 				if(stat(devfd=sfstruse(sh.strbuf),&statb)>=0)
31034887Schin 					argv[0] =  devfd;
31044887Schin 			}
31054887Schin 			if(!shp->shpath)
31064887Schin 				shp->shpath = pathshell();
31074887Schin 			spawnpid = path_spawn(shp->shpath,&argv[-1],arge,pp,(grp<<1)|1);
31084887Schin 			if(fd>=0)
31094887Schin 				close(fd);
31104887Schin 			argv[0] = argv[-1];
31114887Schin 		}
31124887Schin 	fail:
31134887Schin 		if(spawnpid < 0) switch(errno=shp->path_err)
31144887Schin 		{
31154887Schin 		    case ENOENT:
31164887Schin 			errormsg(SH_DICT,ERROR_system(ERROR_NOENT),e_found+4);
31174887Schin 		    default:
31184887Schin 			errormsg(SH_DICT,ERROR_system(ERROR_NOEXEC),e_exec+4);
31194887Schin 		}
31204887Schin 	}
31214887Schin 	else
31224887Schin 		exitset();
31234887Schin 	sh_popcontext(&buff);
31244887Schin 	if(buff.olist)
31254887Schin 		free_list(buff.olist);
31264887Schin #ifdef SIGTSTP
31274887Schin 	if(jobwasset)
31284887Schin 	{
31294887Schin 		signal(SIGTTIN,SIG_IGN);
31304887Schin 		signal(SIGTTOU,SIG_IGN);
31314887Schin 	}
31324887Schin #endif /* SIGTSTP */
31334887Schin 	if(sigwasset)
31344887Schin 		sigreset(1);	/* restore ignored signals */
31354887Schin 	if(scope)
31364887Schin 	{
31378462SApril.Chin@Sun.COM 		sh_unscope(shp);
31384887Schin 		if(jmpval==SH_JMPSCRIPT)
31394887Schin 			nv_setlist(t->com.comset,NV_EXPORT|NV_IDENT|NV_ASSIGN);
31404887Schin 	}
31414887Schin 	if(t->com.comio)
31428462SApril.Chin@Sun.COM 		sh_iorestore(shp,buff.topfd,jmpval);
31434887Schin 	if(jmpval>SH_JMPCMD)
31444887Schin 		siglongjmp(*shp->jmplist,jmpval);
31454887Schin 	if(spawnpid>0)
31464887Schin 	{
31474887Schin 		_sh_fork(spawnpid,otype,jobid);
31484887Schin #ifdef JOBS
31494887Schin 		if(grp==1)
31504887Schin 			job.curpgid = spawnpid;
31514887Schin #   ifdef SIGTSTP
31524887Schin 		if(grp>0 && !(otype&FAMP))
31534887Schin 		{
31544887Schin 			while(tcsetpgrp(job.fd,job.curpgid)<0 && job.curpgid!=spawnpid)
31554887Schin 				job.curpgid = spawnpid;
31564887Schin 		}
31574887Schin #   endif /* SIGTSTP */
31584887Schin #endif /* JOBS */
31594887Schin 		savejobid = *jobid;
31604887Schin 		if(otype)
31614887Schin 			return(0);
31624887Schin 	}
31634887Schin 	return(spawnpid);
31644887Schin }
31654887Schin 
31664887Schin #   ifdef _was_lib_fork
31674887Schin #	define _lib_fork	1
31684887Schin #   endif
31694887Schin #   ifndef _lib_fork
31704887Schin 	pid_t fork(void)
31714887Schin 	{
31724887Schin 		errormsg(SH_DICT,ERROR_exit(3),e_notimp,"fork");
31734887Schin 		return(-1);
31744887Schin 	}
31754887Schin #   endif /* _lib_fork */
31764887Schin #endif /* SHOPT_SPAWN */
3177