/*

 *      Copyright (c) 1984, 1985, 1986 AT&T
 *      All Rights Reserved

 *      THIS IS UNPUBLISHED PROPRIETARY SOURCE 
 *      CODE OF AT&T.
 *      The copyright notice above does not 
 *      evidence any actual or intended
 *      publication of such source code.

 */
/* @(#)args.c	1.1 */
/*
 * UNIX shell
 *
 * S. R. Bourne
 * Rewritten by David Korn
 * AT&T Bell Laboratories
 *
 */

#include	"flags.h"
#include	"defs.h"
#include	"sym.h"
#include	"mode.h"
#include	"name.h"
#include	"io.h"
#include	"builtins.h"
#include	"brkincr.h"
#include	"stak.h"
#ifdef DEVFD
# ifdef JOBS
#include	"jobs.h"
# endif /* JOBS */
#endif	/* DEVFD */


void	arg_set();
void	arg_reset();
void	arg_clear();
DOLPTR	arg_free();
DOLPTR	arg_use();
DOLPTR	arg_new();
int	arg_opts();
char	**arg_build();
char	*arg_dolminus();
#ifdef DEVFD
void	close_pipes();
#endif	/* DEVFD */

extern char *malloc();
extern char *macro();
extern char *movstr();
extern char *strchr();
extern char *itos();
extern void assign();
extern void failed();
extern void chkpipe();
extern void exitsh();
extern void free();
extern void gsort();
extern void trim();
extern void p_str();
extern void p_nchr();
extern void p_setout();
extern char *qvalup();

static int	arg_expand();
static DOLPTR	copyargs();
static void	print_opts();
static int	split();

static char	*null;
static DOLPTR argfor;	/* linked list of blocks to be cleaned up */
static DOLPTR dolh;
static char flagadr[12];
static const char flagchar[] =
{
	'i',	'n',	'v',	't',	's',	'x',	'e',	'r',	'k',
	'u', 'f',	'a',	'm',	'h',	'p',	'c', 0
};
static const optflag flagval[]  =
{
	INTFLG,	NOEXEC,	READPR,	ONEFLG, STDFLG,	EXECPR,	ERRFLG,	RSHFLG,	KEYFLG,
	NOSET,	NOGLOB,	ALLEXP,	MONITOR, HASHALL, PRIVM, CFLAG, 0
};

/* ======== option handling	======== */

/*
 *  This routine turns options on and off
 *  The options "sicr" are illegal from set command.
 *  The -o option is used to set option by name
 *  This routine returns the number of non-option arguments
 */

int arg_opts(argc,argv)
char **argv;
int  argc;
{
	register char *cp;
	register int c;
	register char **argp=argv;
	register char *flagc;
	register optflag newflags=flags;
	register optflag opt;
	char minus;
	int sort = 0;
	int setflag = eq(*argp,bset);
	while((cp= *++argp) && ((c= *cp) == '-' || c=='+'))
	{
		minus = (c == '-');
		argc--;
		if((c= *++cp)==0)
		{
			newflags &= ~(EXECPR|READPR);
			argp++;
			break;
		}
		else if(c == '-')
		{
			if(setflag)
				states |= RWAIT;
			argp++;
			break;
		}
		while(c= *cp++)
		{
			if(setflag)
			{
				if(c=='s')
				{
					sort++;
					continue;
				}
				else if(strchr("icr",c))
					failed(argv[1], badopt);
			}
			if(c=='c' && minus && argc>=2 && comdiv==0)
			{
				comdiv= *++argp;
				argc--;
				newflags |= CFLAG;
				continue;
			}
			if(flagc=strchr(flagchar,c))
				opt = flagval[flagc-flagchar];
			else if(c != 'o')
				failed(argv[1],badopt);
			else
			{
				argp++;
				if(*argp==NULL)
				{
					print_opts(newflags);
					argp--;
					continue;
				}
				else
				{
					argc--;
					c=syslook(*argp,option_flags);
					opt = 1L<<c;
					if(opt&(1|INTFLG|RSHFLG))
						failed(*argp,badopt);
				}
			}
			if(minus)
			{
#if ESH || VSH
				if(opt&(EDITVI|EMACS|GMACS))
					newflags &= ~ (EDITVI|EMACS|GMACS);
#endif
				newflags |= opt;
			}
			else
				newflags &= ~opt;
		}
	}
	/* cannot set -n for interactive shells since there is no way out */
	if(is_option(INTFLG))
		newflags &= ~NOEXEC;
#ifdef RAWONLY
	if(is_option(EDITVI))
		newflags |= VIRAW;
#endif	/* RAWONLY */
	if(sort)
	{
		if(argc>1)
			gsort(argp,argc-1);
		else
			gsort(dolv+1,dolc);
	}
	if((newflags&PRIVM) && !is_option(PRIVM))
		assign(PATHNOD,defpath);
	flags = newflags;
	return(argc);
}

/*
 * returns the value of $-
 */

char *arg_dolminus()
{
	register char *flagc=flagchar;
	register char *flagp=flagadr;
	while(*flagc)
	{
		if(flags&flagval[flagc-flagchar])
			*flagp++ = *flagc;
		flagc++;
	}
	*flagp++=0;
	return(flagadr);
}

/*
 * set up positional parameters 
 */

void arg_set(argi)
char *argi[];
{
	register char **argp=argi;
	register int size = 0; /* count number of bytes needed for strings */
	register int 	argn=0;
	register char *cp;
	/* count args and number of bytes of arglist */
	while((cp=(char*)*argp++) != ENDARGS)
	{
		size += strlen(cp);
	}
	/* free old ones unless on for loop chain */
	argn = argp - argi;
	arg_free(dolh,0);
	dolh=copyargs(argi, --argn, size);
	dolc=argn-1;
}

/*
 * free the argument list if the use count is 1
 * If count is greater than 1 decrement count and return same blk
 * Free the argument list if the use count is 1 and return next blk
 * Delete the blk from the argfor chain
 * If flag is set, then the block dolh is not freed
 */

DOLPTR arg_free(blk,flag)
DOLPTR 	blk;
{
	register DOLPTR	argr=blk;
	register DOLPTR	argblk;
	if(argblk=argr)
	{
		if((--argblk->doluse)==0)
		{
			if(flag && argblk==dolh)
				dolh->doluse = 1;
			else
			{
				/* delete from chain */
				if(argfor == argblk)
					argfor = argblk->dolnxt;
				else
				{
					for(argr=argfor;argr;argr=argr->dolnxt)
						if(argr->dolnxt==argblk)
							break;
					if(argr==0)
					{
						return(NULL);
					}
					argr->dolnxt = argblk->dolnxt;
				}
				free((char*)argblk);
			}
			argr = argblk->dolnxt;
		}
	}
	return(argr);
}

/*
 * grab space for arglist and link argblock for cleanup
 * The strings are copied after the argment vector
 */

static DOLPTR copyargs(from, n, size)
char *from[];
{
	register DOLPTR dp=(DOLPTR)malloc((unsigned)(DOLTYPE + n*sizeof(char*) + size + n));
	register char **pp;
	register char *sp;
	dp->doluse=1;	/* use count */
	/* link into chain */
	dp->dolnxt = argfor;
	argfor = dp;
	pp= dp->dolarg;
	dolv=pp;
	sp = (char*)dp + DOLTYPE + n*sizeof(char*);
	while(n--)
	{
		*pp++ = sp;
		sp = movstr(*from++,sp) + 1;
	}
	*pp = ENDARGS;
	return(dp);
}

/*
 *  used to set new argument chain for functions
 */

DOLPTR arg_new(argi,savargfor)
char *argi[];
DOLPTR *savargfor;
{
	register DOLPTR olddolh = dolh;
	*savargfor = argfor;
	dolh = NULL;
	argfor = NULL;
	arg_set(argi);
	return(olddolh);
}

/*
 * reset arguments as they were before function
 */

void arg_reset(blk,afor)
DOLPTR blk;
DOLPTR afor;
{
	while(argfor=arg_free(argfor,0));
	dolh = blk;
	argfor = afor;
}

void arg_clear()
{
	/* force `for' $* lists to go away */
	while(argfor=arg_free(argfor,1));
	/* clean up io files */
	argfor = dolh;
	while(pop(0));
#ifdef DEVFD
	close_pipes();
#endif	/* DEVFD */
}

/*
 * increase the use count so that an arg_set will not make it go away
 */

DOLPTR arg_use()
{
	register DOLPTR dh;
	if(dh=dolh)
		dh->doluse++;
	return(dh);
}

/*
 *  Print option settings on standard output
 */

static void print_opts(oflags)
#ifndef pdp11
register
#endif	/* pdp11 */
optflag oflags;
{
	register SYSPTR	syscan = option_flags;
#ifndef pdp11
	register
#endif	/* pdp11 */
	optflag value;
	p_setout(standout);
	p_str(opt_heading,NL);
	while(value=syscan->sysval)
	{
		value = 1<<value;
		p_str(syscan->sysnam,SP);
		p_nchr(SP,16-strlen(syscan->sysnam));
		if(oflags&value)
			p_str(on_,NL);
		else
			p_str(off_,NL);
		syscan++;
	}
}


/*
 * build an argument list
 */

char **arg_build(nargs,comptr)
int 	*nargs;
COMPTR	comptr;
{
	register ARGPTR	argp;
	{
		register COMPTR	ac = comptr;
		register ARGPTR	schain;
		/* see if the arguments have already been expanded */
		if(ac->comarg==NULL)
		{
			*nargs = 0;
			return(&null);
		}
		else if((ac->comtyp&COMSCAN)==0)
		{
			*nargs = ((DOLPTR)ac->comarg)->doluse;
			return(((DOLPTR)ac->comarg)->dolarg+1);
		}
		schain = gchain;
		gchain = NULL;
		*nargs = arg_expand(ac);
		argp = gchain;
		gchain = schain;
	}
	{
		register char	**comargn;
		register int	argn;
		register char	**comargm;
		argn = *nargs;
		argn++;	/* allow room to prepend interpreter name */
		comargn=(char **) getstak(BYTESPERWORD*argn+BYTESPERWORD);
		comargm = comargn += argn;
		*comargn = ENDARGS;
		while(argp)
		{
			*--comargn = argp->argval;
			if((argp->argflag&A_RAW)==0)
				trim(*comargn);
			if((argp=argp->argchn)==0 || (argp->argflag&A_MAKE))
			{
				if((argn=comargm-comargn)>1)
					gsort(comargn,argn);
				comargm = comargn;
			}
		}
		return(comargn);
	}
}

#ifdef DEVFD
static FILE *to_close[15];

void close_pipes()
{
	register FILE **fd = to_close;
	while(*fd)
	{
		fclose(*fd);
		*fd++ = NULL;
	}
}
#endif	/* DEVFD */

/* Argument list generation */

static int arg_expand(ac)
COMPTR		ac;
{
	register ARGPTR	argp;
	register int 	count=0;
#ifdef DEVFD
	int indx = 0;
	close_pipes();
#endif	/* DEVFD */
	if(ac)
	{
		argp = ac->comarg;
		while(argp)
		{
			argp->argflag &= ~A_MAKE;
#ifdef DEVFD
			if(*argp->argval==0 && (argp->argflag&A_EXP))
			{
				/* argument of the form (cmd) */
				register ARGPTR ap;
				char *cp;
				FILE *pv[2];
				int fd;
				ap = (ARGPTR)locstak();
				ap->argflag |= A_MAKE;
				ap->argflag &= ~A_RAW;
				ap->argchn= gchain;
				gchain = ap;
				count++;
				cp = movstr(devfd,ap->argval);
				chkpipe(pv);
				fd = argp->argflag&A_RAW;
				endstak(movstr(itos(fileno(pv[fd])),cp));
				if(fd)
					execute((TREPTR)argp->argchn,states&ERRFLG,pv,(FILE**)0);
				else
					execute((TREPTR)argp->argchn,states&ERRFLG,(FILE**)0,pv);
#ifdef JOBS
				jobstat.j_flag++;
#endif	/* JOBS */
				fclose(pv[1-fd]);
				to_close[indx++] = pv[fd];
			}
			else
#endif	/* DEVFD */
			if((argp->argflag&A_RAW)==0)
			{
				register char *ap; ap = argp->argval;
				if(argp->argflag&A_MAC)
					ap = macro(ap);
				count += split(ap,argp->argflag&A_MAC);
			}
			else
			{
				argp->argchn= gchain;
				gchain = argp;
				argp->argflag |= A_MAKE;
				count++;
			}
			argp = argp->argnxt;
		}
	}
	return(count);
}

static int split(s,macflg) /* blank interpretation routine */
char *s;
{
	register char *argp;
	register int 	c;
	register ARGPTR ap;
	int 	count=0;
	int expflag = (is_option(NOGLOB)==0);
	char *seps = (macflg?qvalup(IFSNOD):NULL);
	if(seps==NULL || *seps==0)
		seps = sptbnl;
	while(1)
	{
		if(trapnote&SIGSET)
			exitsh(SIGFAIL);
		ap = (ARGPTR)locstak();
		argp = ap->argval;
		while(c= *s++)
		{
			if(c == ESCAPE)
			{
				c = *s++;
				if(c!='/')
					*argp++ = ESCAPE;
			}
			else if(strchr(seps,c))
				break;
			if(argp >= brkend)
				setbrk(BRKINCR);
			*argp++ = c;
		}
	/* This allows contiguous visible delimiters to count as delimiters */
		if(argp==ap->argval)
		{
			if(c==0)
				return(count);
			if(macflg==0 || strchr(sptbnl,c))
				continue;
		}
		else if(c==0)
		{
			s--;
		}
		/* file name generation */
		endstak(argp);
		ap->argflag &= ~(A_RAW|A_MAKE);
		if(expflag && (c=expand(ap->argval,0)))
			count += c;
		else
		{
			count++;
			ap->argchn= gchain;
			gchain = ap;
		}
		gchain->argflag |= A_MAKE;
	}
}