/*
* 该函数包含一次shell交互的整个解释过程
* Preprocessor: 对输入的命令参数进行预处理
* Lexical scanning: 对命令参数进行词法分析，分割成token列表
* Syntax parser: 构建语法树
* Semantic analyzer: 设置语法树节点属性，I/O等
* Executor: 为每个命令分配进程并执行
*/
void main1()
{
char c, *cp;
int *t;
argp = args;
eargp = args+ARGSIZ-5; /* 初始化token列表*/
linep = line;
elinep = line+LINSIZ-5; /* 初始化命令参数缓冲区*/
error = 0; /* 错误计数清零*/
gflg = 0; /* 溢出标志位清零*/
do {
cp = linep;
word();
} while(*cp != '\n'); /* 扫描所有命令参数，生成token列表，遇上换行符终止*/
treep = trebuf;
treeend = &trebuf[TRESIZ]; /* 语法树缓冲区清零*/
if(gflg == 0) {
if(error == 0) {
setexit();
if (error)
return;
t = syntax(args, argp); /* Scanner没有发生缓冲溢出，没有错误计数，对token列表建立语法树 */
}
if(error != 0)
err("syntax error"); else /* 语法分析发生错误，提示并退出shell */
execute(t, NULL, NULL); /* 没有错误计数，从根节点开始进行语义分析 */
}
}
void
fg_proc_entry(struct process *pp)
{
jmp_buf_t osetexit;
int ohaderr;
Char oGettingInput;
size_t omark;
getexit(osetexit);
pintr_disabled++;
oGettingInput = GettingInput;
GettingInput = 0;
ohaderr = haderr; /* we need to ignore setting of haderr due to
* process getting stopped by a signal */
omark = cleanup_push_mark();
if (setexit() == 0) { /* come back here after pjwait */
pendjob();
(void) alarm(0); /* No autologout */
alrmcatch_disabled = 1;
if (!pstart(pp, 1)) {
pp->p_procid = 0;
stderror(ERR_BADJOB, pp->p_command, strerror(errno));
}
pjwait(pp);
}
setalarm(1); /* Autologout back on */
cleanup_pop_mark(omark);
resexit(osetexit);
haderr = ohaderr;
GettingInput = oGettingInput;
disabled_cleanup(&pintr_disabled);
}
void
source(char *fil, bool okfail)
{
jmp_buf osetexit;
register int saveinp, ointty, oerrno;
char *saveglobp;
short savepeekc;
signal(SIGINT, SIG_IGN);
saveinp = dup(0);
savepeekc = peekc;
saveglobp = globp;
peekc = 0; globp = 0;
if (saveinp < 0)
error("Too many nested sources");
if (slevel <= 0)
ttyindes = saveinp;
close(0);
if (open(fil, O_RDONLY) < 0) {
oerrno = errno;
setrupt();
dup(saveinp);
close(saveinp);
errno = oerrno;
if (!okfail)
filioerr(fil);
return;
}
slevel++;
ointty = intty;
intty = isatty(0);
oprompt = value(PROMPT);
value(PROMPT) &= intty;
getexit(osetexit);
setrupt();
if (setexit() == 0)
commands(1, 1);
else if (slevel > 1) {
close(0);
dup(saveinp);
close(saveinp);
slevel--;
resexit(osetexit);
reset();
}
intty = ointty;
value(PROMPT) = oprompt;
close(0);
dup(saveinp);
close(saveinp);
globp = saveglobp;
peekc = savepeekc;
slevel--;
resexit(osetexit);
}
fileinit()
{
register char *p;
register int i, j;
struct stat stbuf;
if (tline == INCRMT * (HBLKS+2))
return;
cleanup(0);
close(tfile);
tline = INCRMT * (HBLKS+2);
blocks[0] = HBLKS;
blocks[1] = HBLKS+1;
blocks[2] = -1;
dirtcnt = 0;
iblock = -1;
iblock2 = -1;
oblock = -1;
CP(tfname, svalue(DIRECTORY));
if (stat(tfname, &stbuf)) {
dumbness:
if (setexit() == 0)
filioerr(tfname);
else
putNFL();
cleanup(1);
exit(1);
}
if ((stbuf.st_mode & S_IFMT) != S_IFDIR) {
errno = ENOTDIR;
goto dumbness;
}
ichanged = 0;
ichang2 = 0;
ignore(strcat(tfname, "/ExXXXXX"));
for (p = strend(tfname), i = 5, j = getpid(); i > 0; i--, j /= 10)
*--p = j % 10 | '0';
tfile = creat(tfname, 0600);
if (tfile < 0)
goto dumbness;
#ifdef VMUNIX
{
extern stilinc; /* see below */
stilinc = 0;
}
#endif
havetmp = 1;
close(tfile);
tfile = open(tfname, 2);
if (tfile < 0)
goto dumbness;
/* brk((char *)fendcore); */
}
/*
* When a hangup occurs our actions are similar to a preserve
* command. If the buffer has not been [Modified], then we do
* nothing but remove the temporary files and exit.
* Otherwise, we sync the temp file and then attempt a preserve.
* If the preserve succeeds, we unlink our temp files.
* If the preserve fails, we leave the temp files as they are
* as they are a backup even without preservation if they
* are not removed.
*/
void
onhup(int i)
{
(void)i;
if (chng == 0) {
cleanup(1);
exit(0);
}
if (setexit() == 0) {
if (preserve()) {
cleanup(1);
exit(0);
}
}
exit(1);
}
void
alias(struct wordent *lex)
{
jmp_buf osetexit;
aleft = ALEFT;
hleft = HLEFT;
getexit(osetexit);
(void) setexit();
if (haderr) {
resexit(osetexit);
reset();
}
if (--aleft == 0)
stderror(ERR_ALIASLOOP);
asyntax(lex->next, lex);
resexit(osetexit);
}
main()
{
register i, t;
register char *cp;
extern char end[];
setuid(1);
itime[0] = fork();
if(itime[0])
exit();
setexit();
signal(1, reset);
time(itime);
while(*localtime(itime))
if(itime[1]-- == 0)
itime[0]--;
loop:
init();
for(i=60; i; i--) {
loct = localtime(itime);
for(cp = end; *cp != EOF;) {
flag = 0;
cp = cmp(cp, loct[1]); /* minute */
cp = cmp(cp, loct[2]); /* hour */
cp = cmp(cp, loct[3]); /* day */
cp = cmp(cp, loct[4]); /* month */
cp = cmp(cp, loct[6]); /* day of week */
if(flag == 0) {
slp();
ex(cp);
}
while(*cp++ != 0)
;
}
t = itime[1] + 60;
if(t < itime[1])
itime[0]++;
itime[1] = t;
}
slp();
goto loop;
}
/*
* When a hangup occurs our actions are similar to a preserve
* command. If the buffer has not been [Modified], then we do
* nothing but remove the temporary files and exit.
* Otherwise, we sync the temp file and then attempt a preserve.
* If the preserve succeeds, we unlink our temp files.
* If the preserve fails, we leave the temp files as they are
* as they are a backup even without preservation if they
* are not removed.
*/
void
onhup(int i)
{
(void)i;
/*
* USG tty driver can send multiple HUP's!!
*/
signal(SIGINT, SIG_IGN);
signal(SIGHUP, SIG_IGN);
if (chng == 0) {
cleanup(1);
ex_exit(0);
}
if (setexit() == 0) {
if (preserve()) {
cleanup(1);
ex_exit(0);
}
}
ex_exit(1);
}
int
main(int argc, char **argv)
{
int i = 0;
int fp;
#ifdef f32c
setup_f32c();
maxfiles = MAXFILES;
#else
catchsignal();
#endif
startfp(); /* start up the floating point hardware */
setup_fb(); /* video framebuffer */
#ifndef f32c
setupfiles(argc,argv);
setupmyterm(); /* set up files after processing files */
#endif
program = 0;
clear();
prints("Rabbit BASIC version 2.1.3 (built " __DATE__ ")\n");
if(setexit() == ERR_RESET){
drop_fns();
execute(); /* execute the line */
}
drop_fns();
docont();
stocurlin=0; /* say we are in immeadiate mode */
if(cursor) /* put cursor on a blank line */
prints( (char *)nl);
if (firstrun && (
#ifdef f32c
(fp = open("d:autoexec.bas",0)) > 0 ||
#endif
(fp = open("autoexec.bas",0)) > 0)) {
firstrun = 0;
readfi(fp, 0, 0);
close(fp);
clear();
if (program) {
stocurlin=program;
point= program->lin;
elsecount=0;
execute();
}
}
firstrun = 0;
prints("Ready\n");
for(;;){
do{
trapped=0;
line[0] = '>';
line[1] = 0;
VOID edit( (ival)1, (ival)1, (ival)0);
}while( trapped || ( !(i=compile(1, nline, 0)) && !linenumber));
if(!linenumber)
break;
insert(i);
}
if(inserted){
inserted=0;
clear();
closeall();
}
#ifdef MSDOS
lcount = 0;
#endif
clr_stack(bstack); /* reset the gosub stack */
bstack = estack = 0;
if(str_used) /* free any spare strings */
FREE_STR(str_used);
trap_env.e_stolin = 0; /* disable error traps */
intrap=0; /* say we are not in the error trap */
trapped=0; /* say we haven't got a cntrl-c */
cursor=0; /* cursor is at start of line */
elsecount=0; /* disallow elses as terminators */
point=nline; /* start executing at start of input line */
stocurlin=0; /* start of current line is null- see 'next' */
execute(); /* execute the line */
return(-1); /* see note below */
}
/*
* Karl Kleinpaste, 21oct1983.
* Set up a one-word alias command, for use for special things.
* This code is based on the mainline of process().
*/
void
aliasrun(int cnt, Char *s1, Char *s2)
{
struct wordent w, *new1, *new2; /* for holding alias name */
struct command *t = NULL;
jmp_buf_t osetexit;
int status;
size_t omark;
getexit(osetexit);
if (seterr) {
xfree(seterr);
seterr = NULL; /* don't repeatedly print err msg. */
}
w.word = STRNULL;
new1 = xcalloc(1, sizeof w);
new1->word = Strsave(s1);
if (cnt == 1) {
/* build a lex list with one word. */
w.next = w.prev = new1;
new1->next = new1->prev = &w;
}
else {
/* build a lex list with two words. */
new2 = xcalloc(1, sizeof w);
new2->word = Strsave(s2);
w.next = new2->prev = new1;
new1->next = w.prev = new2;
new1->prev = new2->next = &w;
}
cleanup_push(&w, lex_cleanup);
/* Save the old status */
status = getn(varval(STRstatus));
/* expand aliases like process() does. */
alias(&w);
/* build a syntax tree for the command. */
t = syntax(w.next, &w, 0);
cleanup_push(t, syntax_cleanup);
if (seterr)
stderror(ERR_OLD);
psavejob();
cleanup_push(&cnt, psavejob_cleanup); /* cnt is used only as a marker */
/* catch any errors here */
omark = cleanup_push_mark();
if (setexit() == 0)
/* execute the parse tree. */
/*
* From: Michael Schroeder <*****@*****.**>
* was execute(t, tpgrp);
*/
execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, TRUE);
/* reset the error catcher to the old place */
cleanup_pop_mark(omark);
resexit(osetexit);
if (haderr) {
haderr = 0;
/*
* Either precmd, or cwdcmd, or periodic had an error. Call it again so
* that it is removed
*/
if (precmd_active)
precmd();
if (postcmd_active)
postcmd();
#ifdef notdef
/*
* XXX: On the other hand, just interrupting them causes an error too.
* So if we hit ^C in the middle of cwdcmd or periodic the alias gets
* removed. We don't want that. Note that we want to remove precmd
* though, cause that could lead into an infinite loop. This should be
* fixed correctly, but then haderr should give us the whole exit
* status not just true or false.
*/
else if (cwdcmd_active)
cwd_cmd();
else if (beepcmd_active)
beep_cmd();
else if (periodic_active)
period_cmd();
#endif /* notdef */
}
cleanup_until(&w);
pendjob();
/* Restore status */
setv(STRstatus, putn((tcsh_number_t)status), VAR_READWRITE);
}
/*
* Main procedure. Process arguments and then
* transfer control to the main command processing loop
* in the routine commands. We are entered as either "ex", "edit", "vi"
* or "view" and the distinction is made here. Actually, we are "vi" if
* there is a 'v' in our name, "view" is there is a 'w', and "edit" if
* there is a 'd' in our name. For edit we just diddle options;
* for vi we actually force an early visual command.
*/
int
main(int ac, char **av)
{
#ifndef VMUNIX
char *erpath = EXSTRINGS;
#endif
register char *cp;
register int c;
bool recov = 0;
bool ivis;
bool itag = 0;
bool fast = 0;
#ifdef TRACE
register char *tracef;
#endif
/*
* Immediately grab the tty modes so that we wont
* get messed up if an interrupt comes in quickly.
*/
gTTY(1);
#ifndef USG3TTY
normf = tty.sg_flags;
#else
normf = tty;
#endif
ppid = getpid();
/*
* Defend against d's, v's, w's, and a's in directories of
* path leading to our true name.
*/
av[0] = tailpath(av[0]);
/*
* Figure out how we were invoked: ex, edit, vi, view.
*/
ivis = any('v', av[0]); /* "vi" */
if (any('w', av[0])) /* "view" */
value(READONLY) = 1;
if (any('d', av[0])) { /* "edit" */
value(OPEN) = 0;
value(REPORT) = 1;
value(MAGIC) = 0;
}
#ifndef VMUNIX
/*
* For debugging take files out of . if name is a.out.
*/
if (av[0][0] == 'a')
erpath = tailpath(erpath);
#endif
/*
* Open the error message file.
*/
draino();
#ifndef VMUNIX
erfile = open(erpath+4, O_RDONLY);
if (erfile < 0) {
erfile = open(erpath, O_RDONLY);
}
#endif
pstop();
/*
* Initialize interrupt handling.
*/
oldhup = signal(SIGHUP, SIG_IGN);
if (oldhup == SIG_DFL)
signal(SIGHUP, onhup);
oldquit = signal(SIGQUIT, SIG_IGN);
ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
signal(SIGTERM, onhup);
#ifdef SIGEMT
if (signal(SIGEMT, SIG_IGN) == SIG_DFL)
signal(SIGEMT, onemt);
#endif
/*
* Initialize end of core pointers.
* Normally we avoid breaking back to fendcore after each
* file since this can be expensive (much core-core copying).
* If your system can scatter load processes you could do
* this as ed does, saving a little core, but it will probably
* not often make much difference.
*/
#ifdef UNIX_SBRK
fendcore = (line *) sbrk(0);
endcore = fendcore - 2;
#else
# define LINELIMIT 0x8000
fendcore = malloc(LINELIMIT * sizeof(line *));
endcore = fendcore + LINELIMIT - 1;
#endif
/*
* Process flag arguments.
*/
ac--, av++;
while (ac && av[0][0] == '-') {
c = av[0][1];
if (c == 0) {
hush = 1;
value(AUTOPRINT) = 0;
fast++;
} else switch (c) {
case 'R':
value(READONLY) = 1;
break;
#ifdef TRACE
case 'T':
if (av[0][2] == 0)
tracef = "trace";
else {
tracef = tttrace;
tracef[8] = av[0][2];
if (tracef[8])
tracef[9] = av[0][3];
else
tracef[9] = 0;
}
trace = fopen(tracef, "w");
if (trace == NULL)
ex_printf("Trace create error\n");
setbuf(trace, tracbuf);
break;
#endif
#ifdef LISPCODE
case 'l':
value(LISP) = 1;
value(SHOWMATCH) = 1;
break;
#endif
case 'r':
recov++;
break;
case 't':
if (ac > 1 && av[1][0] != '-') {
ac--, av++;
itag = 1;
/* BUG: should check for too long tag. */
CP(lasttag, av[0]);
}
break;
case 'v':
ivis = 1;
break;
case 'w':
defwind = 0;
if (av[0][2] == 0) defwind = 3;
else for (cp = &av[0][2]; isdigit((int)*cp); cp++)
defwind = 10*defwind + *cp - '0';
break;
#ifdef CRYPT
case 'x':
/* -x: encrypted mode */
xflag = 1;
break;
#endif
default:
smerror("Unknown option %s\n", av[0]);
break;
}
ac--, av++;
}
#ifdef SIGTSTP
if (!hush && signal(SIGTSTP, SIG_IGN) == SIG_DFL)
signal(SIGTSTP, onsusp), dosusp++;
#endif
if (ac && av[0][0] == '+') {
firstpat = &av[0][1];
ac--, av++;
}
#ifdef CRYPT
if(xflag){
key = getpass(KEYPROMPT);
kflag = crinit(key, perm);
}
#endif
/*
* If we are doing a recover and no filename
* was given, then execute an exrecover command with
* the -r option to type out the list of saved file names.
* Otherwise set the remembered file name to the first argument
* file name so the "recover" initial command will find it.
*/
if (recov) {
if (ac == 0) {
ppid = 0;
setrupt();
execl(EXRECOVER, "exrecover", "-r", NULL);
filioerr(EXRECOVER);
ex_exit(1);
}
CP(savedfile, *av);
av++, ac--;
}
/*
* Initialize the argument list.
*/
argv0 = av;
argc0 = ac;
args0 = av[0];
erewind();
/*
* Initialize a temporary file (buffer) and
* set up terminal environment. Read user startup commands.
*/
if (setexit() == 0) {
setrupt();
intty = isatty(0);
value(PROMPT) = intty;
if ((cp = getenv("SHELL")))
CP(shell, cp);
if (fast || !intty)
setterm("dumb");
else {
gettmode();
if ((cp = getenv("TERM")) != 0 && *cp)
setterm(cp);
}
}
if (setexit() == 0 && !fast && intty) {
if ((globp = getenv("EXINIT")) && *globp)
commands(1,1);
else {
globp = 0;
if ((cp = getenv("HOME")) != 0 && *cp)
source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
}
}
init(); /* moved after prev 2 chunks to fix directory option */
/*
* Initial processing. Handle tag, recover, and file argument
* implied next commands. If going in as 'vi', then don't do
* anything, just set initev so we will do it later (from within
* visual).
*/
if (setexit() == 0) {
if (recov)
globp = "recover";
else if (itag)
globp = ivis ? "tag" : "tag|p";
else if (argc)
globp = "next";
if (ivis)
initev = globp;
else if (globp) {
inglobal = 1;
commands(1, 1);
inglobal = 0;
}
}
/*
* Vi command... go into visual.
* Strange... everything in vi usually happens
* before we ever "start".
*/
if (ivis) {
/*
* Don't have to be upward compatible with stupidity
* of starting editing at line $.
*/
if (dol > zero)
dot = one;
globp = "visual";
if (setexit() == 0)
commands(1, 1);
}
/*
* Clear out trash in state accumulated by startup,
* and then do the main command loop for a normal edit.
* If you quit out of a 'vi' command by doing Q or ^\,
* you also fall through to here.
*/
seenprompt = 1;
ungetchar(0);
globp = 0;
initev = 0;
setlastchar('\n');
setexit();
commands(0, 0);
cleanup(1);
return 0;
}
/*
* Ndo maclisp do function.
*/
lispval
Ndo()
{
register lispval current, where, handy;
register struct nament *mybnp;
register struct argent *lbot, *np;
lispval atom, temp;
lispval body, endtest, endform, varstuf, renewals[NDOVARS] ;
struct argent *start, *last, *getem, *savedlbot;
struct nament *savedbnp, *lastbnd;
int count, index, saveme[SAVSIZE], virgin = 1;
int myerrp; extern int errp;
savedlbot = lbot;
myerrp = errp;
savedbnp = bnp;
getexit(saveme); /* common nonlocal return */
if(retval = setexit()) {
errp = myerrp;
if(retval == BRRETN) {
resexit(saveme);
lbot = savedlbot;
popnames(savedbnp);
return((lispval) contval);
} else {
resexit(saveme);
lbot = savedlbot;
reset(retval);
}
}
current = lbot->val;
varstuf = current->car;
switch( TYPE(varstuf) ) {
case ATOM: /* This is old style maclisp do;
atom is var, cadr(current) = init;
caddr(current) = repeat etc. */
atom = varstuf;
if(varstuf==nil) goto newstyle;
bnp->atm = atom; /* save current binding of atom */
bnp++->val = atom->clb;
if(bnp > bnplim)
binderr();
current = current->cdr;
atom->clb = eval(current->car);
/* Init var. */
*renewals = (current = current->cdr)->car;
/* get repeat form */
endtest = (current = current->cdr)->car;
body = current->cdr;
while(TRUE) {
if(eval(endtest)!=nil) {
resexit(saveme);
popnames(savedbnp);
return(nil);
}
doprog(body);
atom->clb = eval(*renewals);
}
newstyle:
case DTPR: /* New style maclisp do; atom is
list of things of the form
(var init repeat) */
count = 0;
start = np;
for(where = varstuf; where != nil; where = where->cdr) {
/* do inits and count do vars. */
/* requires "simultaneous" eval
of all inits */
handy = where->car->cdr;
temp = nil;
if(handy !=nil)
temp = eval(handy->car);
protect(temp);
count++;
}
if(count > NDOVARS)
error("More than 15 do vars",FALSE);
bnp += count;
if(bnp >= bnplim) {
bnp = savedbnp;
namerr();
}
last = np;
where = varstuf;
mybnp = savedbnp;
getem = start;
for(index = 0; index < count; index++) {
handy = where->car;
/* get var name from group */
atom = handy->car;
mybnp->atm = atom;
mybnp->val = atom->clb;
/* Swap current binding of atom
for init val pushed on stack */
atom->clb = getem++->val;
/* As long as we are down here in the
list, save repeat form */
handy = handy->cdr->cdr;
if(handy==nil)
handy = CNIL; /* be sure not to rebind later */
else
handy = handy->car;
renewals[index] = handy;
/* more loop "increments" */
where = where->cdr;
mybnp++;
}
/* Examine End test and End form */
current = current->cdr;
handy = current->car;
body = current->cdr;
if (handy == nil) {
doprog(body);
popnames(savedbnp);
resexit(saveme);
return(nil);
}
endtest = handy->car;
endform = handy->cdr;
/* The following is the loop: */
loop:
if(eval(endtest)!=nil) {
for(handy = nil; endform!=nil; endform = endform->cdr){
handy = eval(endform->car);
}
resexit(saveme);
popnames(savedbnp);
return(handy);
}
doprog(body);
/* Simultaneously eval repeat forms */
for(index = 0; index < count; index++) {
temp = renewals[index];
if (temp == nil || temp == CNIL)
protect(temp);
else
protect(eval(temp));
}
getem = (np = last);
/* now simult. rebind all the atoms */
mybnp = savedbnp;
for(index = 0; index < count; index++, getem++) {
if( (getem)->val != CNIL ) /* if this atom has a repeat form */
mybnp->atm->clb = (getem)->val; /* rebind */
mybnp++;
}
goto loop;
}
}
static void
srcunit(int unit, int onlyown, int hflg)
{
/* We have to push down a lot of state here */
/* All this could go into a structure */
struct whyle *oldwhyl;
struct Bin saveB;
sigset_t nsigset, osigset;
jmp_buf oldexit;
Char *oarginp, *oevalp, **oevalvec, *ogointr;
Char OHIST;
int oSHIN, oinsource, oldintty, oonelflg;
int oenterhist, otell;
/* The (few) real local variables */
int my_reenter;
oSHIN = -1;
oldintty = intty;
oinsource = insource;
oldwhyl = whyles;
ogointr = gointr;
oarginp = arginp;
oevalp = evalp;
oevalvec = evalvec;
oonelflg = onelflg;
oenterhist = enterhist;
OHIST = HIST;
otell = cantell;
if (unit < 0)
return;
if (didfds)
donefds();
if (onlyown) {
struct stat stb;
if (fstat(unit, &stb) < 0) {
(void)close(unit);
return;
}
}
/*
* There is a critical section here while we are pushing down the input
* stream since we have stuff in different structures. If we weren't
* careful an interrupt could corrupt SHIN's Bin structure and kill the
* shell.
*
* We could avoid the critical region by grouping all the stuff in a single
* structure and pointing at it to move it all at once. This is less
* efficient globally on many variable references however.
*/
insource = 1;
getexit(oldexit);
if (setintr) {
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
}
/* Setup the new values of the state stuff saved above */
(void)memcpy(&saveB, &B, sizeof(B));
fbuf = NULL;
fseekp = feobp = fblocks = 0;
oSHIN = SHIN, SHIN = unit, arginp = 0, onelflg = 0;
intty = isatty(SHIN), whyles = 0, gointr = 0;
evalvec = 0;
evalp = 0;
enterhist = hflg;
if (enterhist)
HIST = '\0';
/*
* Now if we are allowing commands to be interrupted, we let ourselves be
* interrupted.
*/
if (setintr)
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
settell();
if ((my_reenter = setexit()) == 0)
process(0); /* 0 -> blow away on errors */
if (setintr)
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
if (oSHIN >= 0) {
int i;
/* We made it to the new state... free up its storage */
/* This code could get run twice but xfree doesn't care */
for (i = 0; i < fblocks; i++)
xfree((ptr_t) fbuf[i]);
xfree((ptr_t) fbuf);
/* Reset input arena */
(void)memcpy(&B, &saveB, sizeof(B));
(void)close(SHIN), SHIN = oSHIN;
arginp = oarginp, onelflg = oonelflg;
evalp = oevalp, evalvec = oevalvec;
intty = oldintty, whyles = oldwhyl, gointr = ogointr;
if (enterhist)
HIST = OHIST;
enterhist = oenterhist;
cantell = otell;
}
resexit(oldexit);
/*
* If process reset() (effectively an unwind) then we must also unwind.
*/
if (my_reenter)
stderror(ERR_SILENT);
insource = oinsource;
}
/* parseLS_COLORS():
* Parse the LS_COLORS environment variable
*/
void
parseLS_COLORS(const Char *value)
{
size_t i, len;
const Char *v; /* pointer in value */
char *c; /* pointer in colors */
Extension *volatile e; /* pointer in extensions */
jmp_buf_t osetexit;
size_t omark;
(void) &e;
/* init */
xfree(extensions);
for (i = 0; i < nvariables; i++)
variables[i].color = variables[i].defaultcolor;
colors = NULL;
extensions = NULL;
nextensions = 0;
if (value == NULL)
return;
len = Strlen(value);
/* allocate memory */
i = 1;
for (v = value; *v; v++)
if ((*v & CHAR) == ':')
i++;
extensions = xmalloc(len + i * sizeof(Extension));
colors = i * sizeof(Extension) + (char *)extensions;
nextensions = 0;
/* init pointers */
v = value;
c = colors;
e = &extensions[0];
/* Prevent from crashing if unknown parameters are given. */
omark = cleanup_push_mark();
getexit(osetexit);
if (setexit() == 0) {
/* parse */
while (*v) {
switch (*v & CHAR) {
case ':':
v++;
continue;
case '*': /* :*ext=color: */
v++;
if (getstring(&c, &v, &e->extension, '=') &&
0 < e->extension.len) {
v++;
getstring(&c, &v, &e->color, ':');
e++;
continue;
}
break;
default: /* :vl=color: */
if (v[0] && v[1] && (v[2] & CHAR) == '=') {
for (i = 0; i < nvariables; i++)
if ((Char)variables[i].variable[0] == (v[0] & CHAR) &&
(Char)variables[i].variable[1] == (v[1] & CHAR))
break;
if (i < nvariables) {
v += 3;
getstring(&c, &v, &variables[i].color, ':');
continue;
}
else
stderror(ERR_BADCOLORVAR, v[0], v[1]);
}
break;
}
while (*v && (*v & CHAR) != ':')
v++;
}
}
cleanup_pop_mark(omark);
resexit(osetexit);
nextensions = e - extensions;
}
/*
* Main procedure. Process arguments and then
* transfer control to the main command processing loop
* in the routine commands. We are entered as either "ex", "edit" or "vi"
* and the distinction is made here. Actually, we are "vi" if
* there is a 'v' in our name, and "edit" if there is a 'd' in our
* name. For edit we just diddle options; for vi we actually
* force an early visual command, setting the external initev so
* the q command in visual doesn't give command mode.
*/
int
main(int ac, char **av)
{
#if 0
char *erpath = EXSTRINGS;
#endif
register char *cp;
register int c;
bool recov = 0;
bool ivis = any('v', av[0]);
bool itag = 0;
bool fast = 0;
#ifdef TRACE
register char *tracef;
#endif
/*
* Immediately grab the tty modes so that we wont
* get messed up if an interrupt comes in quickly.
*/
gTTY(1);
normf = tty;
#if 0
/*
* For debugging take files out of . if name is a.out.
* If a 'd' in our name, then set options for edit.
*/
if (av[0][0] == 'a')
erpath += 9;
#endif
if (ivis) {
options[MAGIC].odefault = value(MAGIC) = 0;
options[BEAUTIFY].odefault = value(BEAUTIFY) = 1;
} else if (any('d', av[0])) {
value(OPEN) = 0;
value(REPORT) = 1;
value(MAGIC) = 0;
}
/*
* Open the error message file.
*/
draino();
#if 0
erfile = open(erpath, 0);
if (erfile < 0) {
flush();
exit(1);
}
#endif
pstop();
/*
* Initialize interrupt handling.
*/
oldhup = signal(SIGHUP, SIG_IGN);
if (oldhup == SIG_DFL)
signal(SIGHUP, onhup);
oldquit = signal(SIGQUIT, SIG_IGN);
ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
signal(SIGTERM, onhup);
/*
* Initialize end of core pointers.
* Normally we avoid breaking back to fendcore after each
* file since this can be expensive (much core-core copying).
* If your system can scatter load processes you could do
* this as ed does, saving a little core, but it will probably
* not often make much difference.
*/
#ifdef UNIX_SBRK
fendcore = (line *) sbrk(0);
endcore = fendcore - 2;
#else
# define LINELIMIT 0x8000
fendcore = malloc(LINELIMIT * sizeof(line *));
endcore = fendcore + LINELIMIT - 1;
#endif
/*
* Process flag arguments.
*/
ac--, av++;
while (ac && av[0][0] == '-') {
c = av[0][1];
if (c == 0) {
hush = 1;
value(AUTOPRINT) = 0;
fast++;
} else switch (c) {
#ifdef TRACE
case 'T':
if (av[0][2] == 0)
tracef = "trace";
else {
tracef = tttrace;
tracef[8] = av[0][2];
if (tracef[8])
tracef[9] = av[0][3];
else
tracef[9] = 0;
}
trace = fopen(tracef, "w");
if (trace == NULL)
ex_printf("Trace create error\n");
setbuf(trace, tracbuf);
break;
#endif
#ifdef LISP
case 'l':
value(LISP) = 1;
value(SHOWMATCH) = 1;
break;
#endif
case 'r':
recov++;
break;
case 't':
if (ac > 1 && av[1][0] != '-') {
ac--, av++;
itag = 1;
/* BUG: should check for too long tag. */
CP(lasttag, av[0]);
}
break;
case 'v':
globp = "";
ivis = 1;
break;
default:
smerror("Unknown option %s\n", av[0]);
break;
}
ac--, av++;
}
if (ac && av[0][0] == '+') {
firstln = getn(av[0] + 1);
if (firstln == 0)
firstln = 20000;
ac--, av++;
}
/*
* If we are doing a recover and no filename
* was given, then execute an exrecover command with
* the -r option to type out the list of saved file names.
* Otherwise set the remembered file name to the first argument
* file name so the "recover" initial command will find it.
*/
if (recov) {
if (ac == 0) {
die++;
setrupt();
execl(EXRECOVER, "exrecover", "-r", NULL);
filioerr(EXRECOVER);
exit(1);
}
CP(savedfile, *av);
av++, ac--;
}
/*
* Initialize the argument list.
*/
argv0 = av;
argc0 = ac;
args0 = av[0];
erewind();
/*
* Initialize a temporary file (buffer) and
* set up terminal environment. Read user startup commands.
*/
init();
if (setexit() == 0) {
setrupt();
intty = isatty(0);
if (fast || !intty)
setterm("dumb");
else {
gettmode();
if ((cp = getenv("TERM")) != 0)
setterm(cp);
if ((cp = getenv("HOME")) != 0)
source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
}
}
/*
* Initial processing. Handle tag, recover, and file argument
* implied next commands. If going in as 'vi', then don't do
* anything, just set initev so we will do it later (from within
* visual).
*/
if (setexit() == 0) {
if (recov)
globp = "recover";
else if (itag)
globp = ivis ? "tag" : "tag|p";
else if (argc)
globp = "next";
if (ivis)
initev = globp;
else if (globp) {
inglobal = 1;
commands(1, 1);
inglobal = 0;
}
}
/*
* Vi command... go into visual.
* Strange... everything in vi usually happens
* before we ever "start".
*/
if (ivis) {
/*
* Don't have to be upward compatible with stupidity
* of starting editing at line $.
*/
if (dol > zero)
dot = one;
globp = "visual";
if (setexit() == 0)
commands(1, 1);
}
/*
* Clear out trash in state accumulated by startup,
* and then do the main command loop for a normal edit.
* If you quit out of a 'vi' command by doing Q or ^\,
* you also fall through to here.
*/
ungetchar(0);
globp = 0;
initev = 0;
setlastchar('\n');
setexit();
commands(0, 0);
cleanup(1);
return 0;
}
static void
backeval(struct blk_buf *bb, struct Strbuf *word, Char *cp, int literal)
{
ssize_t icnt;
Char c, *ip;
struct command faket;
int hadnl;
int pvec[2], quoted;
Char *fakecom[2], ibuf[BUFSIZE];
char tibuf[BUFSIZE];
hadnl = 0;
icnt = 0;
quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
faket.t_dtyp = NODE_COMMAND;
faket.t_dflg = F_BACKQ;
faket.t_dlef = 0;
faket.t_drit = 0;
faket.t_dspr = 0;
faket.t_dcom = fakecom;
fakecom[0] = STRfakecom1;
fakecom[1] = 0;
/*
* We do the psave job to temporarily change the current job so that the
* following fork is considered a separate job. This is so that when
* backquotes are used in a builtin function that calls glob the "current
* job" is not corrupted. We only need one level of pushed jobs as long as
* we are sure to fork here.
*/
psavejob();
cleanup_push(&faket, psavejob_cleanup); /* faket is only a marker */
/*
* It would be nicer if we could integrate this redirection more with the
* routines in sh.sem.c by doing a fake execute on a builtin function that
* was piped out.
*/
mypipe(pvec);
cleanup_push(&pvec[0], open_cleanup);
cleanup_push(&pvec[1], open_cleanup);
if (pfork(&faket, -1) == 0) {
jmp_buf_t osetexit;
struct command *t;
size_t omark;
xclose(pvec[0]);
(void) dmove(pvec[1], 1);
(void) dmove(SHDIAG, 2);
initdesc();
closem();
arginp = cp;
for (arginp = cp; *cp; cp++) {
*cp &= TRIM;
if (is_set(STRcsubstnonl) && (*cp == '\n' || *cp == '\r'))
*cp = ' ';
}
/*
* In the child ``forget'' everything about current aliases or
* eval vectors.
*/
alvec = NULL;
evalvec = NULL;
alvecp = NULL;
evalp = NULL;
omark = cleanup_push_mark();
getexit(osetexit);
for (;;) {
(void) setexit();
justpr = 0;
if (haderr) {
/* unwind */
doneinp = 0;
cleanup_pop_mark(omark);
resexit(osetexit);
reset();
}
if (seterr) {
xfree(seterr);
seterr = NULL;
}
(void) lex(¶ml);
cleanup_push(¶ml, lex_cleanup);
if (seterr)
stderror(ERR_OLD);
alias(¶ml);
t = syntax(paraml.next, ¶ml, 0);
if (t == NULL)
return;
cleanup_push(t, syntax_cleanup);
/* The F_BACKQ flag must set so the job output is correct if
* printexitvalue is set. If it's not set, the job output
* will have "Exit N" appended where N is the exit status. */
t->t_dflg = F_BACKQ|F_NOFORK;
if (seterr)
stderror(ERR_OLD);
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN);
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGTTOU
signal(SIGTTOU, SIG_IGN);
#endif
execute(t, -1, NULL, NULL, TRUE);
cleanup_until(¶ml);
}
}
cleanup_until(&pvec[1]);
c = 0;
ip = NULL;
do {
ssize_t cnt = 0;
char *tmp;
tmp = tibuf;
for (;;) {
while (icnt == 0) {
int i, eof;
ip = ibuf;
icnt = xread(pvec[0], tmp, tibuf + BUFSIZE - tmp);
eof = 0;
if (icnt <= 0) {
if (tmp == tibuf)
goto eof;
icnt = 0;
eof = 1;
}
icnt += tmp - tibuf;
i = 0;
tmp = tibuf;
while (tmp < tibuf + icnt) {
int len;
len = normal_mbtowc(&ip[i], tmp, tibuf + icnt - tmp);
if (len == -1) {
reset_mbtowc();
if (!eof && (size_t)(tibuf + icnt - tmp) < MB_CUR_MAX) {
break; /* Maybe a partial character */
}
ip[i] = (unsigned char) *tmp | INVALID_BYTE; /* Error */
}
if (len <= 0)
len = 1;
i++;
tmp += len;
}
if (tmp != tibuf)
memmove (tibuf, tmp, tibuf + icnt - tmp);
tmp = tibuf + (tibuf + icnt - tmp);
icnt = i;
}
if (hadnl)
break;
--icnt;
c = (*ip++ & TRIM);
if (c == 0)
break;
#if defined(WINNT_NATIVE) || defined(__CYGWIN__)
if (c == '\r')
c = ' ';
#endif /* WINNT_NATIVE || __CYGWIN__ */
if (c == '\n') {
/*
* Continue around the loop one more time, so that we can eat
* the last newline without terminating this word.
*/
hadnl = 1;
continue;
}
if (!quoted && (c == ' ' || c == '\t'))
break;
cnt++;
Strbuf_append1(word, c | quoted);
}
/*
* Unless at end-of-file, we will form a new word here if there were
* characters in the word, or in any case when we take text literally.
* If we didn't make empty words here when literal was set then we
* would lose blank lines.
*/
if (c != 0 && (cnt || literal))
pword(bb, word);
hadnl = 0;
} while (c > 0);
eof:
cleanup_until(&pvec[0]);
pwait();
cleanup_until(&faket); /* psavejob_cleanup(); */
}
/*VARARGS 1*/
void
execute(struct command *t, volatile int wanttty, int *pipein, int *pipeout,
int do_glob)
{
int forked = 0;
const struct biltins * volatile bifunc;
pid_t pid = 0;
int pv[2];
sigset_t set;
static sigset_t csigset;
#ifdef VFORK
static int onosigchld = 0;
#endif /* VFORK */
static int nosigchld = 0;
(void) &wanttty;
(void) &forked;
(void) &bifunc;
if (t == 0)
return;
#ifdef WINNT_NATIVE
{
if ((varval(STRNTslowexec) == STRNULL) &&
!t->t_dcdr && !t->t_dcar && !t->t_dflg && !didfds &&
(intty || intact) && (t->t_dtyp == NODE_COMMAND) &&
!isbfunc(t)) {
if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
(void) Strcpy(t->t_dcom[0], t->t_dcom[0] + 1);
Dfix(t);
if (nt_try_fast_exec(t) == 0)
return;
}
}
#endif /* WINNT_NATIVE */
/*
* Ed [email protected] & Dominic [email protected]
* Sat Feb 25 03:13:11 PST 1995
* try implicit cd if we have a 1 word command
*/
if (implicit_cd && (intty || intact) && t->t_dcom && t->t_dcom[0] &&
t->t_dcom[0][0] && (blklen(t->t_dcom) == 1) && !noexec) {
Char *sCName;
struct stat stbuf;
char *pathname;
sCName = dollar(t->t_dcom[0]);
if (sCName != NULL && sCName[0] == '~') {
struct Strbuf buf = Strbuf_INIT;
const Char *name_end;
for (name_end = sCName + 1; *name_end != '\0' && *name_end != '/';
name_end++)
continue;
if (name_end != sCName + 1) {
Char *name, *home;
name = Strnsave(sCName + 1, name_end - (sCName + 1));
home = gethdir(name);
if (home != NULL) {
Strbuf_append(&buf, home);
xfree(home);
} else
Strbuf_append(&buf, name);
xfree(name);
} else
Strbuf_append(&buf, varval(STRhome));
Strbuf_append(&buf, name_end);
xfree(sCName);
sCName = Strbuf_finish(&buf);
}
pathname = short2str(sCName);
xfree(sCName);
/* if this is a dir, tack a "cd" on as the first arg */
if (pathname != NULL &&
((stat(pathname, &stbuf) != -1 && S_ISDIR(stbuf.st_mode))
#ifdef WINNT_NATIVE
|| (pathname[0] && pathname[1] == ':' && pathname[2] == '\0')
#endif /* WINNT_NATIVE */
)) {
Char *vCD[2];
Char **ot_dcom = t->t_dcom;
vCD[0] = Strsave(STRcd);
vCD[1] = NULL;
t->t_dcom = blkspl(vCD, ot_dcom);
xfree(ot_dcom);
if (implicit_cd > 1) {
blkpr(t->t_dcom);
xputchar( '\n' );
}
}
}
/*
* From: Michael Schroeder <*****@*****.**>
* Don't check for wantty > 0...
*/
if (t->t_dflg & F_AMPERSAND)
wanttty = 0;
switch (t->t_dtyp) {
case NODE_COMMAND:
if ((t->t_dcom[0][0] & (QUOTE | TRIM)) == QUOTE)
memmove(t->t_dcom[0], t->t_dcom[0] + 1,
(Strlen(t->t_dcom[0] + 1) + 1) * sizeof (*t->t_dcom[0]));
if ((t->t_dflg & F_REPEAT) == 0)
Dfix(t); /* $ " ' \ */
if (t->t_dcom[0] == 0) {
return;
}
/*FALLTHROUGH*/
case NODE_PAREN:
#ifdef BACKPIPE
if (t->t_dflg & F_PIPEIN)
mypipe(pipein);
#else /* !BACKPIPE */
if (t->t_dflg & F_PIPEOUT)
mypipe(pipeout);
#endif /* BACKPIPE */
/*
* Must do << early so parent will know where input pointer should be.
* If noexec then this is all we do.
*/
if (t->t_dflg & F_READ) {
xclose(0);
heredoc(t->t_dlef);
if (noexec)
xclose(0);
}
setcopy(STRstatus, STR0, VAR_READWRITE);
/*
* This mess is the necessary kludge to handle the prefix builtins:
* nice, nohup, time. These commands can also be used by themselves,
* and this is not handled here. This will also work when loops are
* parsed.
*/
while (t->t_dtyp == NODE_COMMAND)
if (eq(t->t_dcom[0], STRnice)) {
if (t->t_dcom[1]) {
if (strchr("+-", t->t_dcom[1][0])) {
if (t->t_dcom[2]) {
setname("nice");
t->t_nice = (unsigned char)getn(t->t_dcom[1]);
lshift(t->t_dcom, 2);
t->t_dflg |= F_NICE;
}
else
break;
}
else {
t->t_nice = 4;
lshift(t->t_dcom, 1);
t->t_dflg |= F_NICE;
}
}
else
break;
}
else if (eq(t->t_dcom[0], STRnohup)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_NOHUP;
lshift(t->t_dcom, 1);
}
else
break;
}
else if (eq(t->t_dcom[0], STRhup)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_HUP;
lshift(t->t_dcom, 1);
}
else
break;
}
else if (eq(t->t_dcom[0], STRtime)) {
if (t->t_dcom[1]) {
t->t_dflg |= F_TIME;
lshift(t->t_dcom, 1);
}
else
break;
}
#ifdef F_VER
else if (eq(t->t_dcom[0], STRver))
if (t->t_dcom[1] && t->t_dcom[2]) {
setname("ver");
t->t_systype = getv(t->t_dcom[1]);
lshift(t->t_dcom, 2);
t->t_dflg |= F_VER;
}
else
break;
#endif /* F_VER */
else
break;
/* is it a command */
if (t->t_dtyp == NODE_COMMAND) {
/*
* Check if we have a builtin function and remember which one.
*/
bifunc = isbfunc(t);
if (noexec) {
/*
* Continue for builtins that are part of the scripting language
*/
if (bifunc == NULL)
break;
if (bifunc->bfunct != (bfunc_t)dobreak &&
bifunc->bfunct != (bfunc_t)docontin &&
bifunc->bfunct != (bfunc_t)doelse &&
bifunc->bfunct != (bfunc_t)doend &&
bifunc->bfunct != (bfunc_t)doforeach&&
bifunc->bfunct != (bfunc_t)dogoto &&
bifunc->bfunct != (bfunc_t)doif &&
bifunc->bfunct != (bfunc_t)dorepeat &&
bifunc->bfunct != (bfunc_t)doswbrk &&
bifunc->bfunct != (bfunc_t)doswitch &&
bifunc->bfunct != (bfunc_t)dowhile &&
bifunc->bfunct != (bfunc_t)dozip)
break;
}
}
else { /* not a command */
bifunc = NULL;
if (noexec)
break;
}
/*
* GrP Executing a command - run jobcmd hook
* Don't run for builtins
* Don't run if we're not in a tty
* Don't run if we're not really executing
*/
/*
* CR - Charles Ross Aug 2005
* added "isoutatty".
* The new behavior is that the jobcmd won't be executed
* if stdout (SHOUT) isnt attached to a tty.. IE when
* redirecting, or using backquotes etc..
*/
if (t->t_dtyp == NODE_COMMAND && !bifunc && !noexec && intty && isoutatty) {
Char *cmd = unparse(t);
cleanup_push(cmd, xfree);
job_cmd(cmd);
cleanup_until(cmd);
}
/*
* We fork only if we are timed, or are not the end of a parenthesized
* list and not a simple builtin function. Simple meaning one that is
* not pipedout, niced, nohupped, or &'d. It would be nice(?) to not
* fork in some of these cases.
*/
#ifdef BACKPIPE
/*
* Can't have NOFORK for the tail of a pipe - because it is not the
* last command spawned (even if it is at the end of a parenthesised
* list).
*/
if (t->t_dflg & F_PIPEIN)
t->t_dflg &= ~(F_NOFORK);
#else
/*
* "command | builtin" may cause major misbehaviour as noted in
* in the BUGS file entry
* Subject: Redirected input to built-in functions misbehaves badly
* forking when the builtin is the end of the pipe corrects the
* problem.
*/
if (bifunc && (t->t_dflg & F_PIPEIN))
t->t_dflg &= ~(F_NOFORK);
#endif /* BACKPIPE */
/*
* Prevent forking cd, pushd, popd, chdir cause this will cause the
* shell not to change dir! (XXX: but only for nice?)
*/
if (bifunc && (bifunc->bfunct == (bfunc_t)dochngd ||
bifunc->bfunct == (bfunc_t)dopushd ||
bifunc->bfunct == (bfunc_t)dopopd))
t->t_dflg &= ~(F_NICE);
if (((t->t_dflg & F_TIME) || ((t->t_dflg & F_NOFORK) == 0 &&
(!bifunc || t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NICE | F_NOHUP | F_HUP)))) ||
/*
* We have to fork for eval too.
*/
(bifunc && (t->t_dflg & F_PIPEIN) != 0 &&
bifunc->bfunct == (bfunc_t)doeval)) {
#ifdef VFORK
if (t->t_dtyp == NODE_PAREN ||
t->t_dflg & (F_REPEAT | F_AMPERSAND) || bifunc)
#endif /* VFORK */
{
forked++;
/*
* We need to block SIGCHLD here, so that if the process does
* not die before we can set the process group
*/
if (wanttty >= 0 && !nosigchld) {
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &set, &csigset);
nosigchld = 1;
}
pid = pfork(t, wanttty);
if (pid == 0 && nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
else if (pid != 0 && (t->t_dflg & F_AMPERSAND))
backpid = pid;
}
#ifdef VFORK
else {
int ochild, osetintr, ohaderr, odidfds;
int oSHIN, oSHOUT, oSHDIAG, oOLDSTD, otpgrp;
int oisoutatty, oisdiagatty;
sigset_t oset, ocsigset;
# ifndef CLOSE_ON_EXEC
int odidcch;
# endif /* !CLOSE_ON_EXEC */
/*
* Prepare for the vfork by saving everything that the child
* corrupts before it exec's. Note that in some signal
* implementations which keep the signal info in user space
* (e.g. Sun's) it will also be necessary to save and restore
* the current sigvec's for the signals the child touches
* before it exec's.
*/
/*
* Sooooo true... If this is a Sun, save the sigvec's. (Skip
* Gilbrech - 11/22/87)
*/
# ifdef SAVESIGVEC
struct sigaction savesv[NSIGSAVED];
sigset_t savesm;
# endif /* SAVESIGVEC */
if (wanttty >= 0 && !nosigchld && !noexec) {
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
(void)sigprocmask(SIG_BLOCK, &set, &csigset);
nosigchld = 1;
}
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigaddset(&set, SIGINT);
(void)sigprocmask(SIG_BLOCK, &set, &oset);
ochild = child;
osetintr = setintr;
ohaderr = haderr;
odidfds = didfds;
# ifndef CLOSE_ON_EXEC
odidcch = didcch;
# endif /* !CLOSE_ON_EXEC */
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHDIAG = SHDIAG;
oOLDSTD = OLDSTD;
otpgrp = tpgrp;
oisoutatty = isoutatty;
oisdiagatty = isdiagatty;
ocsigset = csigset;
onosigchld = nosigchld;
Vsav = Vdp = 0;
Vexpath = 0;
Vt = 0;
# ifdef SAVESIGVEC
savesigvec(savesv, savesm);
# endif /* SAVESIGVEC */
if (use_fork)
pid = fork();
else
pid = vfork();
if (pid < 0) {
# ifdef SAVESIGVEC
restoresigvec(savesv, savesm);
# endif /* SAVESIGVEC */
sigprocmask(SIG_SETMASK, &oset, NULL);
stderror(ERR_NOPROC);
}
forked++;
if (pid) { /* parent */
# ifdef SAVESIGVEC
restoresigvec(savesv, savesm);
# endif /* SAVESIGVEC */
child = ochild;
setintr = osetintr;
haderr = ohaderr;
didfds = odidfds;
SHIN = oSHIN;
# ifndef CLOSE_ON_EXEC
didcch = odidcch;
# endif /* !CLOSE_ON_EXEC */
SHOUT = oSHOUT;
SHDIAG = oSHDIAG;
OLDSTD = oOLDSTD;
tpgrp = otpgrp;
isoutatty = oisoutatty;
isdiagatty = oisdiagatty;
csigset = ocsigset;
nosigchld = onosigchld;
xfree(Vsav);
Vsav = 0;
xfree(Vdp);
Vdp = 0;
xfree(Vexpath);
Vexpath = 0;
blk_cleanup(Vt);
Vt = 0;
/* this is from pfork() */
palloc(pid, t);
sigprocmask(SIG_SETMASK, &oset, NULL);
}
else { /* child */
/* this is from pfork() */
pid_t pgrp;
int ignint = 0;
if (nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if (setintr)
ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
|| (gointr && eq(gointr, STRminus));
pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
child++;
if (setintr) {
setintr = 0;
/*
* casts made right for SunOS 4.0 by Douglas C. Schmidt
* <*****@*****.**>
* (thanks! -- PWP)
*
* ignint ifs cleaned by Johan Widen <[email protected]>
* (thanks again)
*/
if (ignint) {
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGQUIT, SIG_IGN);
}
else {
(void) signal(SIGINT, vffree);
(void) signal(SIGQUIT, SIG_DFL);
}
# ifdef BSDJOBS
if (wanttty >= 0) {
(void) signal(SIGTSTP, SIG_DFL);
(void) signal(SIGTTIN, SIG_DFL);
(void) signal(SIGTTOU, SIG_DFL);
}
# endif /* BSDJOBS */
sigaction(SIGTERM, &parterm, NULL);
}
else if (tpgrp == -1 &&
(t->t_dflg & F_NOINTERRUPT)) {
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGQUIT, SIG_IGN);
}
pgetty(wanttty, pgrp);
if (t->t_dflg & F_NOHUP)
(void) signal(SIGHUP, SIG_IGN);
if (t->t_dflg & F_HUP)
(void) signal(SIGHUP, SIG_DFL);
if (t->t_dflg & F_NICE) {
int nval = SIGN_EXTEND_CHAR(t->t_nice);
# if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
stderror(ERR_SYSTEM, "setpriority",
strerror(errno));
# else /* !HAVE_SETPRIORITY || !PRIO_PROCESS */
(void) nice(nval);
# endif /* HAVE_SETPRIORITY && PRIO_PROCESS */
}
# ifdef F_VER
if (t->t_dflg & F_VER) {
tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
dohash(NULL, NULL);
}
# endif /* F_VER */
}
}
#endif /* VFORK */
}
if (pid != 0) {
/*
* It would be better if we could wait for the whole job when we
* knew the last process had been started. Pwait, in fact, does
* wait for the whole job anyway, but this test doesn't really
* express our intentions.
*/
#ifdef BACKPIPE
if (didfds == 0 && t->t_dflg & F_PIPEOUT) {
xclose(pipeout[0]);
xclose(pipeout[1]);
}
if ((t->t_dflg & F_PIPEIN) != 0)
break;
#else /* !BACKPIPE */
if (didfds == 0 && t->t_dflg & F_PIPEIN) {
xclose(pipein[0]);
xclose(pipein[1]);
}
if ((t->t_dflg & F_PIPEOUT) != 0)
break;
#endif /* BACKPIPE */
if (nosigchld) {
sigprocmask(SIG_SETMASK, &csigset, NULL);
nosigchld = 0;
}
if ((t->t_dflg & F_AMPERSAND) == 0)
pwait();
break;
}
doio(t, pipein, pipeout);
#ifdef BACKPIPE
if (t->t_dflg & F_PIPEIN) {
xclose(pipein[0]);
xclose(pipein[1]);
}
#else /* !BACKPIPE */
if (t->t_dflg & F_PIPEOUT) {
xclose(pipeout[0]);
xclose(pipeout[1]);
}
#endif /* BACKPIPE */
/*
* Perform a builtin function. If we are not forked, arrange for
* possible stopping
*/
if (bifunc) {
if (forked) {
func(t, bifunc);
exitstat();
} else {
jmp_buf_t oldexit;
int ohaderr = haderr;
getexit(oldexit);
if (setexit() == 0)
func(t, bifunc);
resexit(oldexit);
haderr = ohaderr;
if (adrof(STRprintexitvalue)) {
int rv = getn(varval(STRstatus));
if (rv != 0)
xprintf(CGETS(17, 2, "Exit %d\n"), rv);
}
}
break;
}
if (t->t_dtyp != NODE_PAREN) {
doexec(t, do_glob);
/* NOTREACHED */
}
/*
* For () commands must put new 0,1,2 in FSH* and recurse
*/
if ((OLDSTD = dcopy(0, FOLDSTD)) >= 0)
(void)close_on_exec(OLDSTD, 1);
if ((SHOUT = dcopy(1, FSHOUT)) >= 0) {
(void)close_on_exec(SHOUT, 1);
isoutatty = isatty(SHOUT);
}
if ((SHDIAG = dcopy(2, FSHDIAG)) >= 0) {
(void)close_on_exec(SHDIAG, 1);
isdiagatty = isatty(SHDIAG);
}
xclose(SHIN);
SHIN = -1;
#ifndef CLOSE_ON_EXEC
didcch = 0;
#else
(void) close_on_exec(FSHOUT, 1);
(void) close_on_exec(FSHDIAG, 1);
(void) close_on_exec(FOLDSTD, 1);
#endif /* !CLOSE_ON_EXEC */
didfds = 0;
wanttty = -1;
t->t_dspr->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dspr, wanttty, NULL, NULL, do_glob);
exitstat();
case NODE_PIPE:
#ifdef BACKPIPE
t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
(F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcar, wanttty, pipein, pv, do_glob);
#else /* !BACKPIPE */
t->t_dcar->t_dflg |= F_PIPEOUT | (t->t_dflg &
(F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcar, wanttty, pipein, pv, do_glob);
t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
(F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT | F_BACKQ));
execute(t->t_dcdr, wanttty, pv, pipeout, do_glob);
#endif /* BACKPIPE */
break;
case NODE_LIST:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
/*
* In strange case of A&B make a new job after A
*/
if (t->t_dcar->t_dflg & F_AMPERSAND && t->t_dcdr &&
(t->t_dcdr->t_dflg & F_AMPERSAND) == 0)
pendjob();
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
}
break;
case NODE_OR:
case NODE_AND:
if (t->t_dcar) {
t->t_dcar->t_dflg |= t->t_dflg & (F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcar, wanttty, NULL, NULL, do_glob);
if ((getn(varval(STRstatus)) == 0) !=
(t->t_dtyp == NODE_AND)) {
return;
}
}
if (t->t_dcdr) {
t->t_dcdr->t_dflg |= t->t_dflg &
(F_NOFORK | F_NOINTERRUPT | F_BACKQ);
execute(t->t_dcdr, wanttty, NULL, NULL, do_glob);
}
break;
default:
break;
}
/*
* Fall through for all breaks from switch
*
* If there will be no more executions of this command, flush all file
* descriptors. Places that turn on the F_REPEAT bit are responsible for
* doing donefds after the last re-execution
*/
if (didfds && !(t->t_dflg & F_REPEAT))
donefds();
}
/*
* Interpret user commands one by one. If standard input is not a tty,
* print no prompt.
*/
void
commands(void)
{
int n, eofloop = 0;
char linebuf[LINESIZE];
if (!sourcing) {
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
(void)signal(SIGINT, intr);
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
(void)signal(SIGHUP, hangup);
(void)signal(SIGTSTP, stop);
(void)signal(SIGTTOU, stop);
(void)signal(SIGTTIN, stop);
}
setexit();
for (;;) {
/*
* Print the prompt, if needed. Clear out
* string space, and flush the output.
*/
if (!sourcing && value("interactive") != NULL) {
if ((value("autoinc") != NULL) && (incfile() > 0))
printf("New mail has arrived.\n");
reset_on_stop = 1;
printf("%s", prompt);
}
(void)fflush(stdout);
sreset();
/*
* Read a line of commands from the current input
* and handle end of file specially.
*/
n = 0;
for (;;) {
if (readline(input, &linebuf[n], LINESIZE - n) < 0) {
if (n == 0)
n = -1;
break;
}
if ((n = strlen(linebuf)) == 0)
break;
n--;
if (linebuf[n] != '\\')
break;
linebuf[n++] = ' ';
}
reset_on_stop = 0;
if (n < 0) {
/* eof */
if (loading)
break;
if (sourcing) {
unstack();
continue;
}
if (value("interactive") != NULL &&
value("ignoreeof") != NULL &&
++eofloop < 25) {
printf("Use \"quit\" to quit.\n");
continue;
}
break;
}
eofloop = 0;
if (execute(linebuf, 0))
break;
}
}
/*ARGSUSED*/
void
execash(Char **t, struct command *kp)
{
jmp_buf osetexit;
sig_t osigint, osigquit, osigterm;
int my_reenter, odidfds, oOLDSTD, oSHERR, oSHIN, oSHOUT;
int saveDIAG, saveIN, saveOUT, saveSTD;
if (chkstop == 0 && setintr)
panystop(0);
/*
* Hmm, we don't really want to do that now because we might
* fail, but what is the choice
*/
rechist();
osigint = signal(SIGINT, parintr);
osigquit = signal(SIGQUIT, parintr);
osigterm = signal(SIGTERM, parterm);
odidfds = didfds;
oSHIN = SHIN;
oSHOUT = SHOUT;
oSHERR = SHERR;
oOLDSTD = OLDSTD;
saveIN = dcopy(SHIN, -1);
saveOUT = dcopy(SHOUT, -1);
saveDIAG = dcopy(SHERR, -1);
saveSTD = dcopy(OLDSTD, -1);
lshift(kp->t_dcom, 1);
getexit(osetexit);
if ((my_reenter = setexit()) == 0) {
SHIN = dcopy(0, -1);
SHOUT = dcopy(1, -1);
SHERR = dcopy(2, -1);
didfds = 0;
doexec(t, kp);
}
(void)signal(SIGINT, osigint);
(void)signal(SIGQUIT, osigquit);
(void)signal(SIGTERM, osigterm);
doneinp = 0;
didfds = odidfds;
(void)close(SHIN);
(void)close(SHOUT);
(void)close(SHERR);
(void)close(OLDSTD);
SHIN = dmove(saveIN, oSHIN);
SHOUT = dmove(saveOUT, oSHOUT);
SHERR = dmove(saveDIAG, oSHERR);
OLDSTD = dmove(saveSTD, oOLDSTD);
resexit(osetexit);
if (my_reenter)
stderror(ERR_SILENT);
}
int
main(int argc, char *argv[])
{
struct sigaction oact;
Char *cp;
char *tcp, **tempv;
const char *ecp;
sigset_t nsigset;
int f;
cshin = stdin;
cshout = stdout;
csherr = stderr;
setprogname(argv[0]);
settimes(); /* Immed. estab. timing base */
/*
* Initialize non constant strings
*/
#ifdef _PATH_BSHELL
STR_BSHELL = SAVE(_PATH_BSHELL);
#endif
#ifdef _PATH_CSHELL
STR_SHELLPATH = SAVE(_PATH_CSHELL);
#endif
STR_environ = blk2short(environ);
environ = short2blk(STR_environ); /* So that we can free it */
STR_WORD_CHARS = SAVE(WORD_CHARS);
HIST = '!';
HISTSUB = '^';
word_chars = STR_WORD_CHARS;
tempv = argv;
if (eq(str2short(tempv[0]), STRaout)) /* A.out's are quittable */
quitit = 1;
uid = getuid();
gid = getgid();
euid = geteuid();
egid = getegid();
/*
* We are a login shell if: 1. we were invoked as -<something> and we had
* no arguments 2. or we were invoked only with the -l flag
*/
loginsh = (**tempv == '-' && argc == 1) ||
(argc == 2 && tempv[1][0] == '-' && tempv[1][1] == 'l' &&
tempv[1][2] == '\0');
if (loginsh && **tempv != '-') {
/*
* Mangle the argv space
*/
tempv[1][0] = '\0';
tempv[1][1] = '\0';
tempv[1] = NULL;
for (tcp = *tempv; *tcp++;)
continue;
for (tcp--; tcp >= *tempv; tcp--)
tcp[1] = tcp[0];
*++tcp = '-';
argc--;
}
if (loginsh)
(void)time(&chktim);
AsciiOnly = 1;
#ifdef NLS
(void)setlocale(LC_ALL, "");
{
int k;
for (k = 0200; k <= 0377 && !Isprint(k); k++)
continue;
AsciiOnly = k > 0377;
}
#else
AsciiOnly = getenv("LANG") == NULL && getenv("LC_CTYPE") == NULL;
#endif /* NLS */
/*
* Move the descriptors to safe places. The variable didfds is 0 while we
* have only FSH* to work with. When didfds is true, we have 0,1,2 and
* prefer to use these.
*/
initdesc();
/*
* XXX: This is to keep programs that use stdio happy.
* what we really want is freunopen() ....
* Closing cshin cshout and csherr (which are really stdin stdout
* and stderr at this point and then reopening them in the same order
* gives us again stdin == cshin stdout == cshout and stderr == csherr.
* If that was not the case builtins like printf that use stdio
* would break. But in any case we could fix that with memcpy and
* a bit of pointer manipulation...
* Fortunately this is not needed under the current implementation
* of stdio.
*/
(void)fclose(cshin);
(void)fclose(cshout);
(void)fclose(csherr);
if (!(cshin = funopen2((void *) &SHIN, readf, writef, seekf, NULL,
closef)))
exit(1);
if (!(cshout = funopen2((void *) &SHOUT, readf, writef, seekf, NULL,
closef)))
exit(1);
if (!(csherr = funopen2((void *) &SHERR, readf, writef, seekf, NULL,
closef)))
exit(1);
(void)setvbuf(cshin, NULL, _IOLBF, 0);
(void)setvbuf(cshout, NULL, _IOLBF, 0);
(void)setvbuf(csherr, NULL, _IOLBF, 0);
/*
* Initialize the shell variables. ARGV and PROMPT are initialized later.
* STATUS is also munged in several places. CHILD is munged when
* forking/waiting
*/
set(STRstatus, Strsave(STR0));
if ((ecp = getenv("HOME")) != NULL)
cp = quote(SAVE(ecp));
else
cp = NULL;
if (cp == NULL)
fast = 1; /* No home -> can't read scripts */
else
set(STRhome, cp);
dinit(cp); /* dinit thinks that HOME == cwd in a login
* shell */
/*
* Grab other useful things from the environment. Should we grab
* everything??
*/
if ((ecp = getenv("LOGNAME")) != NULL ||
(ecp = getenv("USER")) != NULL)
set(STRuser, quote(SAVE(ecp)));
if ((ecp = getenv("TERM")) != NULL)
set(STRterm, quote(SAVE(ecp)));
/*
* Re-initialize path if set in environment
*/
if ((ecp = getenv("PATH")) == NULL) {
#ifdef _PATH_DEFPATH
importpath(str2short(_PATH_DEFPATH));
#else
setq(STRpath, defaultpath(), &shvhed);
#endif
} else {
importpath(str2short(ecp));
}
set(STRshell, Strsave(STR_SHELLPATH));
doldol = putn((int) getpid()); /* For $$ */
shtemp = Strspl(STRtmpsh, doldol); /* For << */
/*
* Record the interrupt states from the parent process. If the parent is
* non-interruptible our hand must be forced or we (and our children) won't
* be either. Our children inherit termination from our parent. We catch it
* only if we are the login shell.
*/
/* parents interruptibility */
(void)sigaction(SIGINT, NULL, &oact);
parintr = oact.sa_handler;
(void)sigaction(SIGTERM, NULL, &oact);
parterm = oact.sa_handler;
/* catch these all, login shell or not */
(void)signal(SIGHUP, phup); /* exit processing on HUP */
(void)signal(SIGXCPU, phup); /* ...and on XCPU */
(void)signal(SIGXFSZ, phup); /* ...and on XFSZ */
/*
* Process the arguments.
*
* Note that processing of -v/-x is actually delayed till after script
* processing.
*
* We set the first character of our name to be '-' if we are a shell
* running interruptible commands. Many programs which examine ps'es
* use this to filter such shells out.
*/
argc--, tempv++;
while (argc > 0 && (tcp = tempv[0])[0] == '-' && *++tcp != '\0' && !batch) {
do
switch (*tcp++) {
case 0: /* - Interruptible, no prompt */
prompt = 0;
setintr = 1;
nofile = 1;
break;
case 'b': /* -b Next arg is input file */
batch = 1;
break;
case 'c': /* -c Command input from arg */
if (argc == 1)
xexit(0);
argc--, tempv++;
arginp = SAVE(tempv[0]);
prompt = 0;
nofile = 1;
break;
case 'e': /* -e Exit on any error */
exiterr = 1;
break;
case 'f': /* -f Fast start */
fast = 1;
break;
case 'i': /* -i Interactive, even if !intty */
intact = 1;
nofile = 1;
break;
case 'm': /* -m read .cshrc (from su) */
mflag = 1;
break;
case 'n': /* -n Don't execute */
noexec = 1;
break;
case 'q': /* -q (Undoc'd) ... die on quit */
quitit = 1;
break;
case 's': /* -s Read from std input */
nofile = 1;
break;
case 't': /* -t Read one line from input */
onelflg = 2;
prompt = 0;
nofile = 1;
break;
case 'v': /* -v Echo hist expanded input */
nverbose = 1; /* ... later */
break;
case 'x': /* -x Echo just before execution */
nexececho = 1; /* ... later */
break;
case 'V': /* -V Echo hist expanded input */
setNS(STRverbose); /* NOW! */
break;
case 'X': /* -X Echo just before execution */
setNS(STRecho); /* NOW! */
break;
} while (*tcp);
tempv++, argc--;
}
if (quitit) /* With all due haste, for debugging */
(void)signal(SIGQUIT, SIG_DFL);
/*
* Unless prevented by -, -c, -i, -s, or -t, if there are remaining
* arguments the first of them is the name of a shell file from which to
* read commands.
*/
if (nofile == 0 && argc > 0) {
nofile = open(tempv[0], O_RDONLY);
if (nofile < 0) {
child = 1; /* So this doesn't return */
stderror(ERR_SYSTEM, tempv[0], strerror(errno));
}
ffile = SAVE(tempv[0]);
/*
* Replace FSHIN. Handle /dev/std{in,out,err} specially
* since once they are closed we cannot open them again.
* In that case we use our own saved descriptors
*/
if ((SHIN = dmove(nofile, FSHIN)) < 0)
switch(nofile) {
case 0:
SHIN = FSHIN;
break;
case 1:
SHIN = FSHOUT;
break;
case 2:
SHIN = FSHERR;
break;
default:
stderror(ERR_SYSTEM, tempv[0], strerror(errno));
/* NOTREACHED */
}
(void)ioctl(SHIN, FIOCLEX, NULL);
prompt = 0;
/* argc not used any more */ tempv++;
}
intty = isatty(SHIN);
intty |= intact;
if (intty || (intact && isatty(SHOUT))) {
if (!batch && (uid != euid || gid != egid)) {
errno = EACCES;
child = 1; /* So this doesn't return */
stderror(ERR_SYSTEM, "csh", strerror(errno));
}
}
/*
* Decide whether we should play with signals or not. If we are explicitly
* told (via -i, or -) or we are a login shell (arg0 starts with -) or the
* input and output are both the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")
* Note that in only the login shell is it likely that parent may have set
* signals to be ignored
*/
if (loginsh || intact || (intty && isatty(SHOUT)))
setintr = 1;
settell();
/*
* Save the remaining arguments in argv.
*/
setq(STRargv, blk2short(tempv), &shvhed);
/*
* Set up the prompt.
*/
if (prompt) {
set(STRprompt, Strsave(uid == 0 ? STRsymhash : STRsymcent));
/* that's a meta-questionmark */
set(STRprompt2, Strsave(STRmquestion));
}
/*
* If we are an interactive shell, then start fiddling with the signals;
* this is a tricky game.
*/
shpgrp = getpgrp();
opgrp = tpgrp = -1;
if (setintr) {
**argv = '-';
if (!quitit) /* Wary! */
(void)signal(SIGQUIT, SIG_IGN);
(void)signal(SIGINT, pintr);
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
(void)signal(SIGTERM, SIG_IGN);
if (quitit == 0 && arginp == 0) {
(void)signal(SIGTSTP, SIG_IGN);
(void)signal(SIGTTIN, SIG_IGN);
(void)signal(SIGTTOU, SIG_IGN);
/*
* Wait till in foreground, in case someone stupidly runs csh &
* dont want to try to grab away the tty.
*/
if (isatty(FSHERR))
f = FSHERR;
else if (isatty(FSHOUT))
f = FSHOUT;
else if (isatty(OLDSTD))
f = OLDSTD;
else
f = -1;
retry:
if ((tpgrp = tcgetpgrp(f)) != -1) {
if (tpgrp != shpgrp) {
sig_t old = signal(SIGTTIN, SIG_DFL);
(void)kill(0, SIGTTIN);
(void)signal(SIGTTIN, old);
goto retry;
}
opgrp = shpgrp;
shpgrp = getpid();
tpgrp = shpgrp;
/*
* Setpgid will fail if we are a session leader and
* mypid == mypgrp (POSIX 4.3.3)
*/
if (opgrp != shpgrp)
if (setpgid(0, shpgrp) == -1)
goto notty;
/*
* We do that after we set our process group, to make sure
* that the process group belongs to a process in the same
* session as the tty (our process and our group) (POSIX 7.2.4)
*/
if (tcsetpgrp(f, shpgrp) == -1)
goto notty;
(void)ioctl(dcopy(f, FSHTTY), FIOCLEX, NULL);
}
if (tpgrp == -1) {
notty:
(void)fprintf(csherr, "Warning: no access to tty (%s).\n",
strerror(errno));
(void)fprintf(csherr, "Thus no job control in this shell.\n");
}
}
}
if ((setintr == 0) && (parintr == SIG_DFL))
setintr = 1;
(void)signal(SIGCHLD, pchild); /* while signals not ready */
/*
* Set an exit here in case of an interrupt or error reading the shell
* start-up scripts.
*/
reenter = setexit(); /* PWP */
haderr = 0; /* In case second time through */
if (!fast && reenter == 0) {
/* Will have value(STRhome) here because set fast if don't */
{
sig_t oparintr;
sigset_t osigset;
int osetintr;
oparintr = parintr;
osetintr = setintr;
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
setintr = 0;
parintr = SIG_IGN; /* Disable onintr */
#ifdef _PATH_DOTCSHRC
(void)srcfile(_PATH_DOTCSHRC, 0, 0);
#endif
if (!fast && !arginp && !onelflg)
dohash(NULL, NULL);
#ifdef _PATH_DOTLOGIN
if (loginsh)
(void)srcfile(_PATH_DOTLOGIN, 0, 0);
#endif
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
setintr = osetintr;
parintr = oparintr;
}
(void)srccat(value(STRhome), STRsldotcshrc);
if (!fast && !arginp && !onelflg && !havhash)
dohash(NULL, NULL);
/*
* Source history before .login so that it is available in .login
*/
if ((cp = value(STRhistfile)) != STRNULL)
tildehist[2] = cp;
dosource(tildehist, NULL);
if (loginsh)
(void)srccat(value(STRhome), STRsldotlogin);
}
/*
* Now are ready for the -v and -x flags
*/
if (nverbose)
setNS(STRverbose);
if (nexececho)
setNS(STRecho);
/*
* All the rest of the world is inside this call. The argument to process
* indicates whether it should catch "error unwinds". Thus if we are a
* interactive shell our call here will never return by being blown past on
* an error.
*/
process(setintr);
/*
* Mop-up.
*/
if (intty) {
if (loginsh) {
(void)fprintf(cshout, "logout\n");
(void)close(SHIN);
child = 1;
goodbye();
}
else {
(void)fprintf(cshout, "exit\n");
}
}
rechist();
exitstat();
/* NOTREACHED */
}
