d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
628683cb81
freebsd-dev/contrib/tcsh/sh.func.c
Mark Peek 9ccc37e320 Update to tcsh 6.18.01.
2012-02-22 03:36:15 +00:00

2684 lines
57 KiB
C
Raw Blame History

/* $Header: /p/tcsh/cvsroot/tcsh/sh.func.c,v 3.162 2011/02/26 00:07:06 christos Exp $ */
/*
* sh.func.c: csh builtin functions
*/
/*-
* Copyright (c) 1980, 1991 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "sh.h"
RCSID("$tcsh: sh.func.c,v 3.162 2011/02/26 00:07:06 christos Exp $")
#include "ed.h"
#include "tw.h"
#include "tc.h"
#ifdef WINNT_NATIVE
#include "nt.const.h"
#endif /* WINNT_NATIVE */
#if defined (NLS_CATALOGS) && defined(HAVE_ICONV)
static iconv_t catgets_iconv; /* Or (iconv_t)-1 */
#endif
/*
* C shell
*/
extern int MapsAreInited;
extern int NLSMapsAreInited;
extern int GotTermCaps;
static int zlast = -1;
static void islogin (void);
static void preread (void);
static void doagain (void);
static const char *isrchx (int);
static void search (int, int, Char *);
static int getword (struct Strbuf *);
static struct wordent *histgetword (struct wordent *);
static void toend (void);
static void xecho (int, Char **);
static int islocale_var (Char *);
static void wpfree (struct whyle *);
const struct biltins *
isbfunc(struct command *t)
{
Char *cp = t->t_dcom[0];
const struct biltins *bp, *bp1, *bp2;
static struct biltins label = {"", dozip, 0, 0};
static struct biltins foregnd = {"%job", dofg1, 0, 0};
static struct biltins backgnd = {"%job &", dobg1, 0, 0};
/*
* We never match a builtin that has quoted the first
* character; this has been the traditional way to escape
* builtin commands.
*/
if (*cp & QUOTE)
return NULL;
if (*cp != ':' && lastchr(cp) == ':') {
label.bname = short2str(cp);
return (&label);
}
if (*cp == '%') {
if (t->t_dflg & F_AMPERSAND) {
t->t_dflg &= ~F_AMPERSAND;
backgnd.bname = short2str(cp);
return (&backgnd);
}
foregnd.bname = short2str(cp);
return (&foregnd);
}
#ifdef WARP
/*
* This is a perhaps kludgy way to determine if the warp builtin is to be
* acknowledged or not. If checkwarp() fails, then we are to assume that
* the warp command is invalid, and carry on as we would handle any other
* non-builtin command. -- JDK 2/4/88
*/
if (eq(STRwarp, cp) && !checkwarp()) {
return (0); /* this builtin disabled */
}
#endif /* WARP */
/*
* Binary search Bp1 is the beginning of the current search range. Bp2 is
* one past the end.
*/
for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
int i;
bp = bp1 + ((bp2 - bp1) >> 1);
if ((i = ((char) *cp) - *bp->bname) == 0 &&
(i = StrQcmp(cp, str2short(bp->bname))) == 0)
return bp;
if (i < 0)
bp2 = bp;
else
bp1 = bp + 1;
}
#ifdef WINNT_NATIVE
return nt_check_additional_builtins(cp);
#endif /*WINNT_NATIVE*/
return (0);
}
void
func(struct command *t, const struct biltins *bp)
{
int i;
xechoit(t->t_dcom);
setname(bp->bname);
i = blklen(t->t_dcom) - 1;
if (i < bp->minargs)
stderror(ERR_NAME | ERR_TOOFEW);
if (i > bp->maxargs)
stderror(ERR_NAME | ERR_TOOMANY);
(*bp->bfunct) (t->t_dcom, t);
}
/*ARGSUSED*/
void
doonintr(Char **v, struct command *c)
{
Char *cp;
Char *vv = v[1];
USE(c);
if (parintr.sa_handler == SIG_IGN)
return;
if (setintr && intty)
stderror(ERR_NAME | ERR_TERMINAL);
cp = gointr;
gointr = 0;
xfree(cp);
if (vv == 0) {
if (setintr)
sigset_interrupting(SIGINT, queue_pintr);
else
(void) signal(SIGINT, SIG_DFL);
gointr = 0;
}
else if (eq((vv = strip(vv)), STRminus)) {
(void) signal(SIGINT, SIG_IGN);
gointr = Strsave(STRminus);
}
else {
gointr = Strsave(vv);
sigset_interrupting(SIGINT, queue_pintr);
}
}
/*ARGSUSED*/
void
donohup(Char **v, struct command *c)
{
USE(c);
USE(v);
if (intty)
stderror(ERR_NAME | ERR_TERMINAL);
if (setintr == 0) {
(void) signal(SIGHUP, SIG_IGN);
phup_disabled = 1;
#ifdef CC
submit(getpid());
#endif /* CC */
}
}
/*ARGSUSED*/
void
dohup(Char **v, struct command *c)
{
USE(c);
USE(v);
if (intty)
stderror(ERR_NAME | ERR_TERMINAL);
if (setintr == 0)
(void) signal(SIGHUP, SIG_DFL);
}
/*ARGSUSED*/
void
dozip(Char **v, struct command *c)
{
USE(c);
USE(v);
}
/*ARGSUSED*/
void
dofiletest(Char **v, struct command *c)
{
Char **globbed, **fileptr, *ftest, *res;
USE(c);
if (*(ftest = *++v) != '-')
stderror(ERR_NAME | ERR_FILEINQ);
++v;
v = glob_all_or_error(v);
globbed = v;
cleanup_push(globbed, blk_cleanup);
while (*(fileptr = v++) != '\0') {
res = filetest(ftest, &fileptr, 0);
cleanup_push(res, xfree);
xprintf("%S", res);
cleanup_until(res);
if (*v)
xprintf(" ");
}
xprintf("\n");
cleanup_until(globbed);
}
void
prvars(void)
{
plist(&shvhed, VAR_ALL);
}
/*ARGSUSED*/
void
doalias(Char **v, struct command *c)
{
struct varent *vp;
Char *p;
USE(c);
v++;
p = *v++;
if (p == 0)
plist(&aliases, VAR_ALL);
else if (*v == 0) {
vp = adrof1(strip(p), &aliases);
if (vp && vp->vec)
blkpr(vp->vec), xputchar('\n');
}
else {
if (eq(p, STRalias) || eq(p, STRunalias)) {
setname(short2str(p));
stderror(ERR_NAME | ERR_DANGER);
}
set1(strip(p), saveblk(v), &aliases, VAR_READWRITE);
tw_cmd_free();
}
}
/*ARGSUSED*/
void
unalias(Char **v, struct command *c)
{
USE(c);
unset1(v, &aliases);
tw_cmd_free();
}
/*ARGSUSED*/
void
dologout(Char **v, struct command *c)
{
USE(c);
USE(v);
islogin();
goodbye(NULL, NULL);
}
/*ARGSUSED*/
void
dologin(Char **v, struct command *c)
{
#ifdef WINNT_NATIVE
USE(c);
USE(v);
#else /* !WINNT_NATIVE */
char **p = short2blk(v);
USE(c);
cleanup_push((Char **)p, blk_cleanup);
islogin();
rechist(NULL, adrof(STRsavehist) != NULL);
sigaction(SIGTERM, &parterm, NULL);
(void) execv(_PATH_BIN_LOGIN, p);
(void) execv(_PATH_USRBIN_LOGIN, p);
cleanup_until((Char **)p);
untty();
xexit(1);
#endif /* !WINNT_NATIVE */
}
#ifdef NEWGRP
/*ARGSUSED*/
void
donewgrp(Char **v, struct command *c)
{
char **p;
if (chkstop == 0 && setintr)
panystop(0);
sigaction(SIGTERM, &parterm, NULL);
p = short2blk(v);
/*
* From Beto Appleton (beto@aixwiz.austin.ibm.com)
* Newgrp can take 2 arguments...
*/
(void) execv(_PATH_BIN_NEWGRP, p);
(void) execv(_PATH_USRBIN_NEWGRP, p);
blkfree((Char **) p);
untty();
xexit(1);
}
#endif /* NEWGRP */
static void
islogin(void)
{
if (chkstop == 0 && setintr)
panystop(0);
if (loginsh)
return;
stderror(ERR_NOTLOGIN);
}
void
doif(Char **v, struct command *kp)
{
int i;
Char **vv;
v++;
i = noexec ? 1 : expr(&v);
vv = v;
if (*vv == NULL)
stderror(ERR_NAME | ERR_EMPTYIF);
if (eq(*vv, STRthen)) {
if (*++vv)
stderror(ERR_NAME | ERR_IMPRTHEN);
setname(short2str(STRthen));
/*
* If expression was zero, then scan to else , otherwise just fall into
* following code.
*/
if (!i)
search(TC_IF, 0, NULL);
return;
}
/*
* Simple command attached to this if. Left shift the node in this tree,
* munging it so we can reexecute it.
*/
if (i) {
lshift(kp->t_dcom, vv - kp->t_dcom);
reexecute(kp);
donefds();
}
}
/*
* Reexecute a command, being careful not
* to redo i/o redirection, which is already set up.
*/
void
reexecute(struct command *kp)
{
kp->t_dflg &= F_SAVE;
kp->t_dflg |= F_REPEAT;
/*
* If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
* pgrp's as the jobs would then have no way to get the tty (we can't give
* it to them, and our parent wouldn't know their pgrp, etc.
*/
execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
}
/*ARGSUSED*/
void
doelse (Char **v, struct command *c)
{
USE(c);
USE(v);
if (!noexec)
search(TC_ELSE, 0, NULL);
}
/*ARGSUSED*/
void
dogoto(Char **v, struct command *c)
{
Char *lp;
USE(c);
lp = globone(v[1], G_ERROR);
cleanup_push(lp, xfree);
if (!noexec)
gotolab(lp);
cleanup_until(lp);
}
void
gotolab(Char *lab)
{
struct whyle *wp;
/*
* While we still can, locate any unknown ends of existing loops. This
* obscure code is the WORST result of the fact that we don't really parse.
*/
zlast = TC_GOTO;
for (wp = whyles; wp; wp = wp->w_next)
if (wp->w_end.type == TCSH_F_SEEK && wp->w_end.f_seek == 0) {
search(TC_BREAK, 0, NULL);
btell(&wp->w_end);
}
else {
bseek(&wp->w_end);
}
search(TC_GOTO, 0, lab);
/*
* Eliminate loops which were exited.
*/
wfree();
}
/*ARGSUSED*/
void
doswitch(Char **v, struct command *c)
{
Char *cp, *lp;
USE(c);
v++;
if (!*v || *(*v++) != '(')
stderror(ERR_SYNTAX);
cp = **v == ')' ? STRNULL : *v++;
if (*(*v++) != ')')
v--;
if (*v)
stderror(ERR_SYNTAX);
lp = globone(cp, G_ERROR);
cleanup_push(lp, xfree);
if (!noexec)
search(TC_SWITCH, 0, lp);
cleanup_until(lp);
}
/*ARGSUSED*/
void
dobreak(Char **v, struct command *c)
{
USE(v);
USE(c);
if (whyles == NULL)
stderror(ERR_NAME | ERR_NOTWHILE);
if (!noexec)
toend();
}
/*ARGSUSED*/
void
doexit(Char **v, struct command *c)
{
USE(c);
if (chkstop == 0 && (intty || intact) && evalvec == 0)
panystop(0);
/*
* Don't DEMAND parentheses here either.
*/
v++;
if (*v) {
setv(STRstatus, putn(expr(&v)), VAR_READWRITE);
if (*v)
stderror(ERR_NAME | ERR_EXPRESSION);
}
btoeof();
#if 0
if (intty)
#endif
/* Always close, why only on ttys? */
xclose(SHIN);
}
/*ARGSUSED*/
void
doforeach(Char **v, struct command *c)
{
Char *cp, *sp;
struct whyle *nwp;
int gflag;
USE(c);
v++;
cp = sp = strip(*v);
if (!letter(*cp))
stderror(ERR_NAME | ERR_VARBEGIN);
do {
cp++;
} while (alnum(*cp));
if (*cp != '\0')
stderror(ERR_NAME | ERR_VARALNUM);
cp = *v++;
if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
stderror(ERR_NAME | ERR_NOPAREN);
v++;
gflag = tglob(v);
if (gflag) {
v = globall(v, gflag);
if (v == 0 && !noexec)
stderror(ERR_NAME | ERR_NOMATCH);
}
else {
v = saveblk(v);
trim(v);
}
nwp = xcalloc(1, sizeof *nwp);
nwp->w_fe = nwp->w_fe0 = v;
btell(&nwp->w_start);
nwp->w_fename = Strsave(cp);
nwp->w_next = whyles;
nwp->w_end.type = TCSH_F_SEEK;
whyles = nwp;
/*
* Pre-read the loop so as to be more comprehensible to a terminal user.
*/
zlast = TC_FOREACH;
if (intty)
preread();
if (!noexec)
doagain();
}
/*ARGSUSED*/
void
dowhile(Char **v, struct command *c)
{
int status;
int again = whyles != 0 &&
SEEKEQ(&whyles->w_start, &lineloc) &&
whyles->w_fename == 0;
USE(c);
v++;
/*
* Implement prereading here also, taking care not to evaluate the
* expression before the loop has been read up from a terminal.
*/
if (noexec)
status = 0;
else if (intty && !again)
status = !exp0(&v, 1);
else
status = !expr(&v);
if (*v && !noexec)
stderror(ERR_NAME | ERR_EXPRESSION);
if (!again) {
struct whyle *nwp = xcalloc(1, sizeof(*nwp));
nwp->w_start = lineloc;
nwp->w_end.type = TCSH_F_SEEK;
nwp->w_end.f_seek = 0;
nwp->w_end.a_seek = 0;
nwp->w_next = whyles;
whyles = nwp;
zlast = TC_WHILE;
if (intty) {
/*
* The tty preread
*/
preread();
doagain();
return;
}
}
if (status)
/* We ain't gonna loop no more, no more! */
toend();
}
static void
preread(void)
{
int old_pintr_disabled;
whyles->w_end.type = TCSH_I_SEEK;
if (setintr)
pintr_push_enable(&old_pintr_disabled);
search(TC_BREAK, 0, NULL); /* read the expression in */
if (setintr)
cleanup_until(&old_pintr_disabled);
btell(&whyles->w_end);
}
/*ARGSUSED*/
void
doend(Char **v, struct command *c)
{
USE(v);
USE(c);
if (!whyles)
stderror(ERR_NAME | ERR_NOTWHILE);
btell(&whyles->w_end);
if (!noexec)
doagain();
}
/*ARGSUSED*/
void
docontin(Char **v, struct command *c)
{
USE(v);
USE(c);
if (!whyles)
stderror(ERR_NAME | ERR_NOTWHILE);
if (!noexec)
doagain();
}
static void
doagain(void)
{
/* Repeating a while is simple */
if (whyles->w_fename == 0) {
bseek(&whyles->w_start);
return;
}
/*
* The foreach variable list actually has a spurious word ")" at the end of
* the w_fe list. Thus we are at the of the list if one word beyond this
* is 0.
*/
if (!whyles->w_fe[1]) {
dobreak(NULL, NULL);
return;
}
setv(whyles->w_fename, quote(Strsave(*whyles->w_fe++)), VAR_READWRITE);
bseek(&whyles->w_start);
}
void
dorepeat(Char **v, struct command *kp)
{
int i = 1;
do {
i *= getn(v[1]);
lshift(v, 2);
} while (v[0] != NULL && Strcmp(v[0], STRrepeat) == 0);
if (noexec)
i = 1;
if (setintr) {
pintr_disabled++;
cleanup_push(&pintr_disabled, disabled_cleanup);
}
while (i > 0) {
if (setintr && pintr_disabled == 1) {
cleanup_until(&pintr_disabled);
pintr_disabled++;
cleanup_push(&pintr_disabled, disabled_cleanup);
}
reexecute(kp);
--i;
}
if (setintr && pintr_disabled == 1)
cleanup_until(&pintr_disabled);
donefds();
}
/*ARGSUSED*/
void
doswbrk(Char **v, struct command *c)
{
USE(v);
USE(c);
if (!noexec)
search(TC_BRKSW, 0, NULL);
}
int
srchx(Char *cp)
{
struct srch *sp, *sp1, *sp2;
int i;
/*
* Ignore keywords inside heredocs
*/
if (inheredoc)
return -1;
/*
* Binary search Sp1 is the beginning of the current search range. Sp2 is
* one past the end.
*/
for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
sp = sp1 + ((sp2 - sp1) >> 1);
if ((i = *cp - *sp->s_name) == 0 &&
(i = Strcmp(cp, str2short(sp->s_name))) == 0)
return sp->s_value;
if (i < 0)
sp2 = sp;
else
sp1 = sp + 1;
}
return (-1);
}
static const char *
isrchx(int n)
{
struct srch *sp, *sp2;
for (sp = srchn, sp2 = srchn + nsrchn; sp < sp2; sp++)
if (sp->s_value == n)
return (sp->s_name);
return ("");
}
static int Stype;
static Char *Sgoal;
static void
search(int type, int level, Char *goal)
{
struct Strbuf word = Strbuf_INIT;
Char *cp;
struct whyle *wp;
int wlevel = 0;
struct wordent *histent = NULL, *ohistent = NULL;
Stype = type;
Sgoal = goal;
if (type == TC_GOTO) {
struct Ain a;
a.type = TCSH_F_SEEK;
a.f_seek = 0;
a.a_seek = 0;
bseek(&a);
}
cleanup_push(&word, Strbuf_cleanup);
do {
if (intty) {
histent = xmalloc(sizeof(*histent));
ohistent = xmalloc(sizeof(*histent));
ohistent->word = STRNULL;
ohistent->next = histent;
histent->prev = ohistent;
}
if (intty && fseekp == feobp && aret == TCSH_F_SEEK)
printprompt(1, isrchx(type == TC_BREAK ? zlast : type));
/* xprintf("? "), flush(); */
(void) getword(&word);
Strbuf_terminate(&word);
if (intty && Strlen(word.s) > 0) {
histent->word = Strsave(word.s);
histent->next = xmalloc(sizeof(*histent));
histent->next->prev = histent;
histent = histent->next;
}
switch (srchx(word.s)) {
case TC_ELSE:
if (level == 0 && type == TC_IF)
goto end;
break;
case TC_IF:
while (getword(&word))
continue;
if ((type == TC_IF || type == TC_ELSE) &&
eq(word.s, STRthen))
level++;
break;
case TC_ENDIF:
if (type == TC_IF || type == TC_ELSE)
level--;
break;
case TC_FOREACH:
case TC_WHILE:
wlevel++;
if (type == TC_BREAK)
level++;
break;
case TC_END:
if (type == TC_BRKSW) {
if (wlevel == 0) {
wp = whyles;
if (wp) {
whyles = wp->w_next;
wpfree(wp);
}
}
}
if (type == TC_BREAK)
level--;
wlevel--;
break;
case TC_SWITCH:
if (type == TC_SWITCH || type == TC_BRKSW)
level++;
break;
case TC_ENDSW:
if (type == TC_SWITCH || type == TC_BRKSW)
level--;
break;
case TC_LABEL:
if (type == TC_GOTO && getword(&word) && eq(word.s, goal))
level = -1;
break;
default:
if (type != TC_GOTO && (type != TC_SWITCH || level != 0))
break;
if (word.len == 0 || word.s[word.len - 1] != ':')
break;
word.s[--word.len] = 0;
if ((type == TC_GOTO && eq(word.s, goal)) ||
(type == TC_SWITCH && eq(word.s, STRdefault)))
level = -1;
break;
case TC_CASE:
if (type != TC_SWITCH || level != 0)
break;
(void) getword(&word);
if (word.len != 0 && word.s[word.len - 1] == ':')
word.s[--word.len] = 0;
cp = strip(Dfix1(word.s));
cleanup_push(cp, xfree);
if (Gmatch(goal, cp))
level = -1;
cleanup_until(cp);
break;
case TC_DEFAULT:
if (type == TC_SWITCH && level == 0)
level = -1;
break;
}
if (intty) {
ohistent->prev = histgetword(histent);
ohistent->prev->next = ohistent;
savehist(ohistent, 0);
freelex(ohistent);
xfree(ohistent);
} else
(void) getword(NULL);
} while (level >= 0);
end:
cleanup_until(&word);
}
static struct wordent *
histgetword(struct wordent *histent)
{
int found = 0, first;
eChar c, d;
int e;
struct Strbuf *tmp;
tmp = xmalloc(sizeof(*tmp));
tmp->size = 0;
tmp->s = NULL;
c = readc(1);
d = 0;
e = 0;
for (;;) {
tmp->len = 0;
Strbuf_terminate (tmp);
while (c == ' ' || c == '\t')
c = readc(1);
if (c == '#')
do
c = readc(1);
while (c != CHAR_ERR && c != '\n');
if (c == CHAR_ERR)
goto past;
if (c == '\n')
goto nl;
unreadc(c);
found = 1;
first = 1;
do {
e = (c == '\\');
c = readc(1);
if (c == '\\' && !e) {
if ((c = readc(1)) == '\n') {
e = 1;
c = ' ';
} else {
unreadc(c);
c = '\\';
}
}
if ((c == '\'' || c == '"') && !e) {
if (d == 0)
d = c;
else if (d == c)
d = 0;
}
if (c == CHAR_ERR)
goto past;
Strbuf_append1(tmp, (Char) c);
if (!first && !d && c == '(' && !e) {
break;
}
first = 0;
} while (d || e || (c != ' ' && c != '\t' && c != '\n'));
tmp->len--;
if (tmp->len) {
Strbuf_terminate(tmp);
histent->word = Strsave(tmp->s);
histent->next = xmalloc(sizeof (*histent));
histent->next->prev = histent;
histent = histent->next;
}
if (c == '\n') {
nl:
tmp->len = 0;
Strbuf_append1(tmp, (Char) c);
Strbuf_terminate(tmp);
histent->word = Strsave(tmp->s);
return histent;
}
}
past:
switch (Stype) {
case TC_IF:
stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
break;
case TC_ELSE:
stderror(ERR_NAME | ERR_NOTFOUND, "endif");
break;
case TC_BRKSW:
case TC_SWITCH:
stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
break;
case TC_BREAK:
stderror(ERR_NAME | ERR_NOTFOUND, "end");
break;
case TC_GOTO:
setname(short2str(Sgoal));
stderror(ERR_NAME | ERR_NOTFOUND, "label");
break;
default:
break;
}
/* NOTREACHED */
return NULL;
}
static int
getword(struct Strbuf *wp)
{
int found = 0, first;
eChar c, d;
if (wp)
wp->len = 0;
c = readc(1);
d = 0;
do {
while (c == ' ' || c == '\t')
c = readc(1);
if (c == '#')
do
c = readc(1);
while (c != CHAR_ERR && c != '\n');
if (c == CHAR_ERR)
goto past;
if (c == '\n') {
if (wp)
break;
return (0);
}
unreadc(c);
found = 1;
first = 1;
do {
c = readc(1);
if (c == '\\' && (c = readc(1)) == '\n')
c = ' ';
if (c == '\'' || c == '"') {
if (d == 0)
d = c;
else if (d == c)
d = 0;
}
if (c == CHAR_ERR)
goto past;
if (wp)
Strbuf_append1(wp, (Char) c);
if (!first && !d && c == '(') {
if (wp)
goto past_word_end;
else
break;
}
first = 0;
} while ((d || (c != ' ' && c != '\t')) && c != '\n');
} while (wp == 0);
past_word_end:
unreadc(c);
if (found) {
wp->len--;
Strbuf_terminate(wp);
}
return (found);
past:
switch (Stype) {
case TC_IF:
stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
break;
case TC_ELSE:
stderror(ERR_NAME | ERR_NOTFOUND, "endif");
break;
case TC_BRKSW:
case TC_SWITCH:
stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
break;
case TC_BREAK:
stderror(ERR_NAME | ERR_NOTFOUND, "end");
break;
case TC_GOTO:
setname(short2str(Sgoal));
stderror(ERR_NAME | ERR_NOTFOUND, "label");
break;
default:
break;
}
/* NOTREACHED */
return (0);
}
static void
toend(void)
{
if (whyles->w_end.type == TCSH_F_SEEK && whyles->w_end.f_seek == 0) {
search(TC_BREAK, 0, NULL);
btell(&whyles->w_end);
whyles->w_end.f_seek--;
}
else {
bseek(&whyles->w_end);
}
wfree();
}
static void
wpfree(struct whyle *wp)
{
if (wp->w_fe0)
blkfree(wp->w_fe0);
xfree(wp->w_fename);
xfree(wp);
}
void
wfree(void)
{
struct Ain o;
struct whyle *nwp;
#ifdef lint
nwp = NULL; /* sun lint is dumb! */
#endif
#ifdef FDEBUG
static const char foo[] = "IAFE";
#endif /* FDEBUG */
btell(&o);
#ifdef FDEBUG
xprintf("o->type %c o->a_seek %d o->f_seek %d\n",
foo[o.type + 1], o.a_seek, o.f_seek);
#endif /* FDEBUG */
for (; whyles; whyles = nwp) {
struct whyle *wp = whyles;
nwp = wp->w_next;
#ifdef FDEBUG
xprintf("start->type %c start->a_seek %d start->f_seek %d\n",
foo[wp->w_start.type+1],
wp->w_start.a_seek, wp->w_start.f_seek);
xprintf("end->type %c end->a_seek %d end->f_seek %d\n",
foo[wp->w_end.type + 1], wp->w_end.a_seek, wp->w_end.f_seek);
#endif /* FDEBUG */
/*
* XXX: We free loops that have different seek types.
*/
if (wp->w_end.type != TCSH_I_SEEK && wp->w_start.type == wp->w_end.type &&
wp->w_start.type == o.type) {
if (wp->w_end.type == TCSH_F_SEEK) {
if (o.f_seek >= wp->w_start.f_seek &&
(wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
break;
}
else {
if (o.a_seek >= wp->w_start.a_seek &&
(wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
break;
}
}
wpfree(wp);
}
}
/*ARGSUSED*/
void
doecho(Char **v, struct command *c)
{
USE(c);
xecho(' ', v);
}
/*ARGSUSED*/
void
doglob(Char **v, struct command *c)
{
USE(c);
xecho(0, v);
flush();
}
static void
xecho(int sep, Char **v)
{
Char *cp, **globbed = NULL;
int nonl = 0;
int echo_style = ECHO_STYLE;
struct varent *vp;
if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL &&
vp->vec[0] != NULL) {
if (Strcmp(vp->vec[0], STRbsd) == 0)
echo_style = BSD_ECHO;
else if (Strcmp(vp->vec[0], STRsysv) == 0)
echo_style = SYSV_ECHO;
else if (Strcmp(vp->vec[0], STRboth) == 0)
echo_style = BOTH_ECHO;
else if (Strcmp(vp->vec[0], STRnone) == 0)
echo_style = NONE_ECHO;
}
v++;
if (*v == 0)
goto done;
if (setintr) {
int old_pintr_disabled;
pintr_push_enable(&old_pintr_disabled);
v = glob_all_or_error(v);
cleanup_until(&old_pintr_disabled);
} else {
v = glob_all_or_error(v);
}
globbed = v;
if (globbed != NULL)
cleanup_push(globbed, blk_cleanup);
if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
nonl++, v++;
while ((cp = *v++) != 0) {
Char c;
if (setintr) {
int old_pintr_disabled;
pintr_push_enable(&old_pintr_disabled);
cleanup_until(&old_pintr_disabled);
}
while ((c = *cp++) != 0) {
if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
switch (c = *cp++) {
case 'a':
c = '\a';
break;
case 'b':
c = '\b';
break;
case 'c':
nonl = 1;
goto done;
case 'e':
#if 0 /* Windows does not understand \e */
c = '\e';
#else
c = CTL_ESC('\033');
#endif
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case '\\':
c = '\\';
break;
case '0':
c = 0;
if (*cp >= '0' && *cp < '8')
c = c * 8 + *cp++ - '0';
if (*cp >= '0' && *cp < '8')
c = c * 8 + *cp++ - '0';
if (*cp >= '0' && *cp < '8')
c = c * 8 + *cp++ - '0';
break;
case '\0':
c = '\\';
cp--;
break;
default:
xputchar('\\' | QUOTE);
break;
}
}
xputwchar(c | QUOTE);
}
if (*v)
xputchar(sep | QUOTE);
}
done:
if (sep && nonl == 0)
xputchar('\n');
else
flush();
if (globbed != NULL)
cleanup_until(globbed);
}
/* check whether an environment variable should invoke 'set_locale()' */
static int
islocale_var(Char *var)
{
static Char *locale_vars[] = {
STRLANG, STRLC_ALL, STRLC_CTYPE, STRLC_NUMERIC,
STRLC_TIME, STRLC_COLLATE, STRLC_MESSAGES, STRLC_MONETARY, 0
};
Char **v;
for (v = locale_vars; *v; ++v)
if (eq(var, *v))
return 1;
return 0;
}
static void
xlate_cr_cleanup(void *dummy)
{
USE(dummy);
xlate_cr = 0;
}
/*ARGSUSED*/
void
doprintenv(Char **v, struct command *c)
{
Char *e;
USE(c);
v++;
if (*v == 0) {
Char **ep;
xlate_cr = 1;
cleanup_push(&xlate_cr, xlate_cr_cleanup);
for (ep = STR_environ; *ep; ep++) {
if (setintr) {
int old_pintr_disabled;
pintr_push_enable(&old_pintr_disabled);
cleanup_until(&old_pintr_disabled);
}
xprintf("%S\n", *ep);
}
cleanup_until(&xlate_cr);
}
else if ((e = tgetenv(*v)) != NULL) {
int old_output_raw;
old_output_raw = output_raw;
output_raw = 1;
cleanup_push(&old_output_raw, output_raw_restore);
xprintf("%S\n", e);
cleanup_until(&old_output_raw);
}
else
setcopy(STRstatus, STR1, VAR_READWRITE);
}
/* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
(and anything else with a modern compiler) */
/*ARGSUSED*/
void
dosetenv(Char **v, struct command *c)
{
Char *vp, *lp;
USE(c);
if (*++v == 0) {
doprintenv(--v, 0);
return;
}
vp = *v++;
lp = vp;
if (!letter(*lp))
stderror(ERR_NAME | ERR_VARBEGIN);
do {
lp++;
} while (alnum(*lp));
if (*lp != '\0')
stderror(ERR_NAME | ERR_VARALNUM);
if ((lp = *v++) == 0)
lp = STRNULL;
lp = globone(lp, G_APPEND);
cleanup_push(lp, xfree);
tsetenv(vp, lp);
if (eq(vp, STRKPATH)) {
importpath(lp);
dohash(NULL, NULL);
cleanup_until(lp);
return;
}
#ifdef apollo
if (eq(vp, STRSYSTYPE)) {
dohash(NULL, NULL);
cleanup_until(lp);
return;
}
#endif /* apollo */
/* dspkanji/dspmbyte autosetting */
/* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
#if defined(DSPMBYTE)
if(eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) {
autoset_dspmbyte(lp);
}
#endif
if (islocale_var(vp)) {
#ifdef NLS
int k;
# ifdef SETLOCALEBUG
dont_free = 1;
# endif /* SETLOCALEBUG */
(void) setlocale(LC_ALL, "");
# ifdef LC_COLLATE
(void) setlocale(LC_COLLATE, "");
# endif
# ifdef LC_CTYPE
(void) setlocale(LC_CTYPE, ""); /* for iscntrl */
# endif /* LC_CTYPE */
# if defined(AUTOSET_KANJI)
autoset_kanji();
# endif /* AUTOSET_KANJI */
# ifdef NLS_CATALOGS
# ifdef LC_MESSAGES
(void) setlocale(LC_MESSAGES, "");
# endif /* LC_MESSAGES */
nlsclose();
nlsinit();
# endif /* NLS_CATALOGS */
# ifdef SETLOCALEBUG
dont_free = 0;
# endif /* SETLOCALEBUG */
# ifdef STRCOLLBUG
fix_strcoll_bug();
# endif /* STRCOLLBUG */
tw_cmd_free(); /* since the collation sequence has changed */
for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
continue;
AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
#else /* !NLS */
AsciiOnly = 0;
#endif /* NLS */
NLSMapsAreInited = 0;
ed_Init();
if (MapsAreInited && !NLSMapsAreInited)
ed_InitNLSMaps();
cleanup_until(lp);
return;
}
#ifdef NLS_CATALOGS
if (eq(vp, STRNLSPATH)) {
nlsclose();
nlsinit();
}
#endif
if (eq(vp, STRNOREBIND)) {
NoNLSRebind = 1;
MapsAreInited = 0;
NLSMapsAreInited = 0;
ed_InitMaps();
cleanup_until(lp);
return;
}
#ifdef WINNT_NATIVE
if (eq(vp, STRtcshlang)) {
nlsinit();
cleanup_until(lp);
return;
}
#endif /* WINNT_NATIVE */
if (eq(vp, STRKTERM)) {
char *t;
setv(STRterm, quote(lp), VAR_READWRITE); /* lp memory used here */
cleanup_ignore(lp);
cleanup_until(lp);
t = short2str(lp);
if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
editing = 1;
noediting = 0;
setNS(STRedit);
}
GotTermCaps = 0;
ed_Init();
return;
}
if (eq(vp, STRKHOME)) {
Char *canon;
/*
* convert to canonical pathname (possibly resolving symlinks)
*/
canon = dcanon(lp, lp);
cleanup_ignore(lp);
cleanup_until(lp);
cleanup_push(canon, xfree);
setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
cleanup_ignore(canon);
cleanup_until(canon);
/* fix directory stack for new tilde home */
dtilde();
return;
}
if (eq(vp, STRKSHLVL)) {
setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
cleanup_ignore(lp);
cleanup_until(lp);
return;
}
if (eq(vp, STRKUSER)) {
setv(STRuser, quote(lp), VAR_READWRITE); /* lp memory used here */
cleanup_ignore(lp);
cleanup_until(lp);
return;
}
if (eq(vp, STRKGROUP)) {
setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
cleanup_ignore(lp);
cleanup_until(lp);
return;
}
#ifdef COLOR_LS_F
if (eq(vp, STRLS_COLORS)) {
parseLS_COLORS(lp);
cleanup_until(lp);
return;
}
#endif /* COLOR_LS_F */
#ifdef SIG_WINDOW
/*
* Load/Update $LINES $COLUMNS
*/
if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
eq(vp, STRTERMCAP)) {
cleanup_until(lp);
check_window_size(1);
return;
}
/*
* Change the size to the one directed by $LINES and $COLUMNS
*/
if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
#if 0
GotTermCaps = 0;
#endif
cleanup_until(lp);
ed_Init();
return;
}
#endif /* SIG_WINDOW */
cleanup_until(lp);
}
/*ARGSUSED*/
void
dounsetenv(Char **v, struct command *c)
{
Char **ep, *p, *n, *name;
int i, maxi;
USE(c);
/*
* Find the longest environment variable
*/
for (maxi = 0, ep = STR_environ; *ep; ep++) {
for (i = 0, p = *ep; *p && *p != '='; p++, i++)
continue;
if (i > maxi)
maxi = i;
}
name = xmalloc((maxi + 1) * sizeof(Char));
cleanup_push(name, xfree);
while (++v && *v)
for (maxi = 1; maxi;)
for (maxi = 0, ep = STR_environ; *ep; ep++) {
for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
continue;
*n = '\0';
if (!Gmatch(name, *v))
continue;
maxi = 1;
/* Unset the name. This wasn't being done until
* later but most of the stuff following won't
* work (particularly the setlocale() and getenv()
* stuff) as intended until the name is actually
* removed. (sg)
*/
Unsetenv(name);
if (eq(name, STRNOREBIND)) {
NoNLSRebind = 0;
MapsAreInited = 0;
NLSMapsAreInited = 0;
ed_InitMaps();
}
#ifdef apollo
else if (eq(name, STRSYSTYPE))
dohash(NULL, NULL);
#endif /* apollo */
else if (islocale_var(name)) {
#ifdef NLS
int k;
# ifdef SETLOCALEBUG
dont_free = 1;
# endif /* SETLOCALEBUG */
(void) setlocale(LC_ALL, "");
# ifdef LC_COLLATE
(void) setlocale(LC_COLLATE, "");
# endif
# ifdef LC_CTYPE
(void) setlocale(LC_CTYPE, ""); /* for iscntrl */
# endif /* LC_CTYPE */
# ifdef NLS_CATALOGS
# ifdef LC_MESSAGES
(void) setlocale(LC_MESSAGES, "");
# endif /* LC_MESSAGES */
nlsclose();
nlsinit();
# endif /* NLS_CATALOGS */
# ifdef SETLOCALEBUG
dont_free = 0;
# endif /* SETLOCALEBUG */
# ifdef STRCOLLBUG
fix_strcoll_bug();
# endif /* STRCOLLBUG */
tw_cmd_free();/* since the collation sequence has changed */
for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
continue;
AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
#else /* !NLS */
AsciiOnly = getenv("LANG") == NULL &&
getenv("LC_CTYPE") == NULL;
#endif /* NLS */
NLSMapsAreInited = 0;
ed_Init();
if (MapsAreInited && !NLSMapsAreInited)
ed_InitNLSMaps();
}
#ifdef WINNT_NATIVE
else if (eq(name,(STRtcshlang))) {
nls_dll_unload();
nlsinit();
}
#endif /* WINNT_NATIVE */
#ifdef COLOR_LS_F
else if (eq(name, STRLS_COLORS))
parseLS_COLORS(n);
#endif /* COLOR_LS_F */
#ifdef NLS_CATALOGS
else if (eq(name, STRNLSPATH)) {
nlsclose();
nlsinit();
}
#endif
/*
* start again cause the environment changes
*/
break;
}
cleanup_until(name);
}
void
tsetenv(const Char *name, const Char *val)
{
#ifdef SETENV_IN_LIB
/*
* XXX: This does not work right, since tcsh cannot track changes to
* the environment this way. (the builtin setenv without arguments does
* not print the right stuff neither does unsetenv). This was for Mach,
* it is not needed anymore.
*/
#undef setenv
char *cname;
if (name == NULL)
return;
cname = strsave(short2str(name));
setenv(cname, short2str(val), 1);
xfree(cname);
#else /* !SETENV_IN_LIB */
Char **ep = STR_environ;
const Char *ccp;
Char *cp, *dp;
Char *blk[2];
Char **oep = ep;
#ifdef WINNT_NATIVE
nt_set_env(name,val);
#endif /* WINNT_NATIVE */
for (; *ep; ep++) {
#ifdef WINNT_NATIVE
for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
ccp++, dp++)
#else
for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
#endif /* WINNT_NATIVE */
continue;
if (*ccp != 0 || *dp != '=')
continue;
cp = Strspl(STRequal, val);
xfree(*ep);
*ep = strip(Strspl(name, cp));
xfree(cp);
blkfree((Char **) environ);
environ = short2blk(STR_environ);
return;
}
cp = Strspl(name, STRequal);
blk[0] = strip(Strspl(cp, val));
xfree(cp);
blk[1] = 0;
STR_environ = blkspl(STR_environ, blk);
blkfree((Char **) environ);
environ = short2blk(STR_environ);
xfree(oep);
#endif /* SETENV_IN_LIB */
}
void
Unsetenv(Char *name)
{
Char **ep = STR_environ;
Char *cp, *dp;
Char **oep = ep;
#ifdef WINNT_NATIVE
nt_set_env(name,NULL);
#endif /*WINNT_NATIVE */
for (; *ep; ep++) {
for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
continue;
if (*cp != 0 || *dp != '=')
continue;
cp = *ep;
*ep = 0;
STR_environ = blkspl(STR_environ, ep + 1);
blkfree((Char **) environ);
environ = short2blk(STR_environ);
*ep = cp;
xfree(cp);
xfree(oep);
return;
}
}
/*ARGSUSED*/
void
doumask(Char **v, struct command *c)
{
Char *cp = v[1];
int i;
USE(c);
if (cp == 0) {
i = (int)umask(0);
(void) umask(i);
xprintf("%o\n", i);
return;
}
i = 0;
while (Isdigit(*cp) && *cp != '8' && *cp != '9')
i = i * 8 + *cp++ - '0';
if (*cp || i < 0 || i > 0777)
stderror(ERR_NAME | ERR_MASK);
(void) umask(i);
}
#ifndef HAVENOLIMIT
# ifndef BSDLIMIT
typedef long RLIM_TYPE;
# ifdef _OSD_POSIX /* BS2000 */
# include <ulimit.h>
# endif
# ifndef RLIM_INFINITY
# if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
extern RLIM_TYPE ulimit();
# endif /* ! _MINIX && !__clipper__ */
# define RLIM_INFINITY 0x003fffff
# define RLIMIT_FSIZE 1
# endif /* RLIM_INFINITY */
# ifdef aiws
# define toset(a) (((a) == 3) ? 1004 : (a) + 1)
# define RLIMIT_DATA 3
# define RLIMIT_STACK 1005
# else /* aiws */
# define toset(a) ((a) + 1)
# endif /* aiws */
# else /* BSDLIMIT */
# if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
typedef rlim_t RLIM_TYPE;
# else
# if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
typedef rlim_t RLIM_TYPE;
# else
# if defined(_SX)
typedef long long RLIM_TYPE;
# else /* !_SX */
typedef unsigned long RLIM_TYPE;
# endif /* _SX */
# endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
# endif /* BSD4_4 && !__386BSD__ */
# endif /* BSDLIMIT */
# if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
/* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
/* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
# ifndef RLIMIT_CPU
# define RLIMIT_CPU 0
# define RLIMIT_FSIZE 1
# define RLIMIT_DATA 2
# define RLIMIT_STACK 3
# define RLIMIT_CORE 4
# define RLIMIT_RSS 5
# define RLIMIT_NOFILE 6
# endif /* RLIMIT_CPU */
# ifndef RLIM_INFINITY
# define RLIM_INFINITY 0x7fffffff
# endif /* RLIM_INFINITY */
/*
* old versions of HP/UX counted limits in 512 bytes
*/
# ifndef SIGRTMIN
# define FILESIZE512
# endif /* SIGRTMIN */
# endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
# if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
/* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
/* sh.h. However, some SVR4 limits are defined in <sys/resource.h>. Rather */
/* than include both and get warnings, we define the extra SVR4 limits here. */
/* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
/* RLIMIT_VMEM based on it? */
# ifndef RLIMIT_VMEM
# define RLIMIT_VMEM 6
# endif
# ifndef RLIMIT_AS
# define RLIMIT_AS RLIMIT_VMEM
# endif
# endif /* SYSVREL > 3 && BSDLIMIT */
# if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
# if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
# define RLIMIT_VMEM RLIMIT_AS
# endif
/*
* Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
* Linux headers: When the left hand does not know what the right hand does.
*/
# if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
# define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
# endif
# endif
struct limits limits[] =
{
# ifdef RLIMIT_CPU
{ RLIMIT_CPU, "cputime", 1, "seconds" },
# endif /* RLIMIT_CPU */
# ifdef RLIMIT_FSIZE
# ifndef aiws
{ RLIMIT_FSIZE, "filesize", 1024, "kbytes" },
# else
{ RLIMIT_FSIZE, "filesize", 512, "blocks" },
# endif /* aiws */
# endif /* RLIMIT_FSIZE */
# ifdef RLIMIT_DATA
{ RLIMIT_DATA, "datasize", 1024, "kbytes" },
# endif /* RLIMIT_DATA */
# ifdef RLIMIT_STACK
# ifndef aiws
{ RLIMIT_STACK, "stacksize", 1024, "kbytes" },
# else
{ RLIMIT_STACK, "stacksize", 1024 * 1024, "kbytes"},
# endif /* aiws */
# endif /* RLIMIT_STACK */
# ifdef RLIMIT_CORE
{ RLIMIT_CORE, "coredumpsize", 1024, "kbytes" },
# endif /* RLIMIT_CORE */
# ifdef RLIMIT_RSS
{ RLIMIT_RSS, "memoryuse", 1024, "kbytes" },
# endif /* RLIMIT_RSS */
# ifdef RLIMIT_UMEM
{ RLIMIT_UMEM, "memoryuse", 1024, "kbytes" },
# endif /* RLIMIT_UMEM */
# ifdef RLIMIT_VMEM
{ RLIMIT_VMEM, "vmemoryuse", 1024, "kbytes" },
# endif /* RLIMIT_VMEM */
# if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
{ RLIMIT_HEAP, "heapsize", 1024, "kbytes" },
# endif /* RLIMIT_HEAP */
# ifdef RLIMIT_NOFILE
{ RLIMIT_NOFILE, "descriptors", 1, "" },
# endif /* RLIMIT_NOFILE */
# ifdef RLIMIT_CONCUR
{ RLIMIT_CONCUR, "concurrency", 1, "thread(s)" },
# endif /* RLIMIT_CONCUR */
# ifdef RLIMIT_MEMLOCK
{ RLIMIT_MEMLOCK, "memorylocked", 1024, "kbytes" },
# endif /* RLIMIT_MEMLOCK */
# ifdef RLIMIT_NPROC
{ RLIMIT_NPROC, "maxproc", 1, "" },
# endif /* RLIMIT_NPROC */
# if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
{ RLIMIT_OFILE, "openfiles", 1, "" },
# endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
# ifdef RLIMIT_SBSIZE
{ RLIMIT_SBSIZE, "sbsize", 1, "" },
# endif /* RLIMIT_SBSIZE */
# ifdef RLIMIT_SWAP
{ RLIMIT_SWAP, "swapsize", 1024, "kbytes" },
# endif /* RLIMIT_SWAP */
# ifdef RLIMIT_LOCKS
{ RLIMIT_LOCKS, "maxlocks", 1, "" },
# endif /* RLIMIT_LOCKS */
# ifdef RLIMIT_SIGPENDING
{ RLIMIT_SIGPENDING,"maxsignal", 1, "" },
# endif /* RLIMIT_SIGPENDING */
# ifdef RLIMIT_MSGQUEUE
{ RLIMIT_MSGQUEUE, "maxmessage", 1, "" },
# endif /* RLIMIT_MSGQUEUE */
# ifdef RLIMIT_NICE
{ RLIMIT_NICE, "maxnice", 1, "" },
# endif /* RLIMIT_NICE */
# ifdef RLIMIT_RTPRIO
{ RLIMIT_RTPRIO, "maxrtprio", 1, "" },
# endif /* RLIMIT_RTPRIO */
# ifdef RLIMIT_RTTIME
{ RLIMIT_RTTIME, "maxrttime", 1, "usec" },
# endif /* RLIMIT_RTTIME */
{ -1, NULL, 0, NULL }
};
static struct limits *findlim (Char *);
static RLIM_TYPE getval (struct limits *, Char **);
static int strtail (Char *, const char *);
static void limtail (Char *, const char *);
static void limtail2 (Char *, const char *, const char *);
static void plim (struct limits *, int);
static int setlim (struct limits *, int, RLIM_TYPE);
#ifdef convex
static RLIM_TYPE
restrict_limit(double value)
{
/*
* is f too large to cope with? return the maximum or minimum int
*/
if (value > (double) INT_MAX)
return (RLIM_TYPE) INT_MAX;
else if (value < (double) INT_MIN)
return (RLIM_TYPE) INT_MIN;
else
return (RLIM_TYPE) value;
}
#else /* !convex */
# define restrict_limit(x) ((RLIM_TYPE) (x))
#endif /* convex */
static struct limits *
findlim(Char *cp)
{
struct limits *lp, *res;
res = NULL;
for (lp = limits; lp->limconst >= 0; lp++)
if (prefix(cp, str2short(lp->limname))) {
if (res)
stderror(ERR_NAME | ERR_AMBIG);
res = lp;
}
if (res)
return (res);
stderror(ERR_NAME | ERR_LIMIT);
/* NOTREACHED */
return (0);
}
/*ARGSUSED*/
void
dolimit(Char **v, struct command *c)
{
struct limits *lp;
RLIM_TYPE limit;
int hard = 0;
USE(c);
v++;
if (*v && eq(*v, STRmh)) {
hard = 1;
v++;
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
plim(lp, hard);
return;
}
lp = findlim(v[0]);
if (v[1] == 0) {
plim(lp, hard);
return;
}
limit = getval(lp, v + 1);
if (setlim(lp, hard, limit) < 0)
stderror(ERR_SILENT);
}
static RLIM_TYPE
getval(struct limits *lp, Char **v)
{
float f;
Char *cp = *v++;
f = atof(short2str(cp));
# ifdef convex
/*
* is f too large to cope with. limit f to minint, maxint - X-6768 by
* strike
*/
if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
stderror(ERR_NAME | ERR_TOOLARGE);
}
# endif /* convex */
while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
cp++;
if (*cp == 0) {
if (*v == 0)
return restrict_limit((f * lp->limdiv) + 0.5);
cp = *v;
}
switch (*cp) {
# ifdef RLIMIT_CPU
case ':':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
case 'h':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "hours");
f *= 3600.0;
break;
# endif /* RLIMIT_CPU */
case 'm':
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU) {
limtail(cp, "minutes");
f *= 60.0;
break;
}
# endif /* RLIMIT_CPU */
limtail2(cp, "megabytes", "mbytes");
f *= 1024.0 * 1024.0;
break;
# ifdef RLIMIT_CPU
case 's':
if (lp->limconst != RLIMIT_CPU)
goto badscal;
limtail(cp, "seconds");
break;
# endif /* RLIMIT_CPU */
case 'G':
*cp = 'g';
/*FALLTHROUGH*/
case 'g':
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU)
goto badscal;
# endif /* RLIMIT_CPU */
limtail2(cp, "gigabytes", "gbytes");
f *= 1024.0 * 1024.0 * 1024.0;
break;
case 'M':
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU)
goto badscal;
# endif /* RLIMIT_CPU */
*cp = 'm';
limtail2(cp, "megabytes", "mbytes");
f *= 1024.0 * 1024.0;
break;
case 'k':
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU)
goto badscal;
# endif /* RLIMIT_CPU */
limtail2(cp, "kilobytes", "kbytes");
f *= 1024.0;
break;
case 'b':
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU)
goto badscal;
# endif /* RLIMIT_CPU */
limtail(cp, "blocks");
f *= 512.0;
break;
case 'u':
limtail(cp, "unlimited");
return ((RLIM_TYPE) RLIM_INFINITY);
default:
# ifdef RLIMIT_CPU
badscal:
# endif /* RLIMIT_CPU */
stderror(ERR_NAME | ERR_SCALEF);
}
# ifdef convex
return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
# else
f += 0.5;
if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
return ((RLIM_TYPE) RLIM_INFINITY);
else
return ((RLIM_TYPE) f);
# endif /* convex */
}
static int
strtail(Char *cp, const char *str)
{
while (*cp && *cp == (Char)*str)
cp++, str++;
return (*cp != '\0');
}
static void
limtail(Char *cp, const char *str)
{
if (strtail(cp, str))
stderror(ERR_BADSCALE, str);
}
static void
limtail2(Char *cp, const char *str1, const char *str2)
{
if (strtail(cp, str1) && strtail(cp, str2))
stderror(ERR_BADSCALE, str1);
}
/*ARGSUSED*/
static void
plim(struct limits *lp, int hard)
{
# ifdef BSDLIMIT
struct rlimit rlim;
# endif /* BSDLIMIT */
RLIM_TYPE limit;
int xdiv = lp->limdiv;
xprintf("%-13.13s", lp->limname);
# ifndef BSDLIMIT
limit = ulimit(lp->limconst, 0);
# ifdef aiws
if (lp->limconst == RLIMIT_DATA)
limit -= 0x20000000;
# endif /* aiws */
# else /* BSDLIMIT */
(void) getrlimit(lp->limconst, &rlim);
limit = hard ? rlim.rlim_max : rlim.rlim_cur;
# endif /* BSDLIMIT */
# if !defined(BSDLIMIT) || defined(FILESIZE512)
/*
* Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
* blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
*/
if (lp->limconst == RLIMIT_FSIZE) {
if (limit >= (RLIM_INFINITY / 512))
limit = RLIM_INFINITY;
else
xdiv = (xdiv == 1024 ? 2 : 1);
}
# endif /* !BSDLIMIT || FILESIZE512 */
if (limit == RLIM_INFINITY)
xprintf("unlimited");
else
# if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
if (lp->limconst == RLIMIT_CPU &&
(unsigned long)limit >= 0x7ffffffdUL)
xprintf("unlimited");
else
# endif
# ifdef RLIMIT_CPU
if (lp->limconst == RLIMIT_CPU)
psecs(limit);
else
# endif /* RLIMIT_CPU */
xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
xputchar('\n');
}
/*ARGSUSED*/
void
dounlimit(Char **v, struct command *c)
{
struct limits *lp;
int lerr = 0;
int hard = 0;
int force = 0;
USE(c);
while (*++v && **v == '-') {
Char *vp = *v;
while (*++vp)
switch (*vp) {
case 'f':
force = 1;
break;
case 'h':
hard = 1;
break;
default:
stderror(ERR_ULIMUS);
break;
}
}
if (*v == 0) {
for (lp = limits; lp->limconst >= 0; lp++)
if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
lerr++;
if (!force && lerr)
stderror(ERR_SILENT);
return;
}
while (*v) {
lp = findlim(*v++);
if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
stderror(ERR_SILENT);
}
}
static int
setlim(struct limits *lp, int hard, RLIM_TYPE limit)
{
# ifdef BSDLIMIT
struct rlimit rlim;
(void) getrlimit(lp->limconst, &rlim);
# ifdef FILESIZE512
/* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
limit /= 512;
# endif /* FILESIZE512 */
if (hard)
rlim.rlim_max = limit;
else if (limit == RLIM_INFINITY && euid != 0)
rlim.rlim_cur = rlim.rlim_max;
else
rlim.rlim_cur = limit;
if (rlim.rlim_cur > rlim.rlim_max)
rlim.rlim_max = rlim.rlim_cur;
if (setrlimit(lp->limconst, &rlim) < 0) {
# else /* BSDLIMIT */
if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
limit /= 512;
# ifdef aiws
if (lp->limconst == RLIMIT_DATA)
limit += 0x20000000;
# endif /* aiws */
if (ulimit(toset(lp->limconst), limit) < 0) {
# endif /* BSDLIMIT */
int err;
char *op, *type;
err = errno;
op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
CGETS(15, 3, "set"));
cleanup_push(op, xfree);
type = strsave(hard ? CGETS(15, 4, " hard") : "");
cleanup_push(type, xfree);
xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
lp->limname, op, type, strerror(err));
cleanup_until(op);
return (-1);
}
return (0);
}
#endif /* !HAVENOLIMIT */
/*ARGSUSED*/
void
dosuspend(Char **v, struct command *c)
{
#ifdef BSDJOBS
struct sigaction old;
#endif /* BSDJOBS */
USE(c);
USE(v);
if (loginsh)
stderror(ERR_SUSPLOG);
untty();
#ifdef BSDJOBS
sigaction(SIGTSTP, NULL, &old);
signal(SIGTSTP, SIG_DFL);
(void) kill(0, SIGTSTP);
/* the shell stops here */
sigaction(SIGTSTP, &old, NULL);
#else /* !BSDJOBS */
stderror(ERR_JOBCONTROL);
#endif /* BSDJOBS */
#ifdef BSDJOBS
if (tpgrp != -1) {
if (grabpgrp(FSHTTY, opgrp) == -1)
stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
(void) setpgid(0, shpgrp);
(void) tcsetpgrp(FSHTTY, shpgrp);
}
#endif /* BSDJOBS */
(void) setdisc(FSHTTY);
}
/* This is the dreaded EVAL built-in.
* If you don't fiddle with file descriptors, and reset didfds,
* this command will either ignore redirection inside or outside
* its arguments, e.g. eval "date >x" vs. eval "date" >x
* The stuff here seems to work, but I did it by trial and error rather
* than really knowing what was going on. If tpgrp is zero, we are
* probably a background eval, e.g. "eval date &", and we want to
* make sure that any processes we start stay in our pgrp.
* This is also the case for "time eval date" -- stay in same pgrp.
* Otherwise, under stty tostop, processes will stop in the wrong
* pgrp, with no way for the shell to get them going again. -IAN!
*/
struct doeval_state
{
Char **evalvec, *evalp;
int didfds;
#ifndef CLOSE_ON_EXEC
int didcch;
#endif
int saveIN, saveOUT, saveDIAG;
int SHIN, SHOUT, SHDIAG;
};
static void
doeval_cleanup(void *xstate)
{
struct doeval_state *state;
state = xstate;
evalvec = state->evalvec;
evalp = state->evalp;
doneinp = 0;
#ifndef CLOSE_ON_EXEC
didcch = state->didcch;
#endif /* CLOSE_ON_EXEC */
didfds = state->didfds;
xclose(SHIN);
xclose(SHOUT);
xclose(SHDIAG);
close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
}
static Char **Ggv;
/*ARGSUSED*/
void
doeval(Char **v, struct command *c)
{
struct doeval_state state;
int gflag, my_reenter;
Char **gv;
jmp_buf_t osetexit;
USE(c);
v++;
if (*v == 0)
return;
gflag = tglob(v);
if (gflag) {
gv = v = globall(v, gflag);
if (v == 0)
stderror(ERR_NOMATCH);
cleanup_push(gv, blk_cleanup);
v = copyblk(v);
}
else {
gv = NULL;
v = copyblk(v);
trim(v);
}
Ggv = gv;
state.evalvec = evalvec;
state.evalp = evalp;
state.didfds = didfds;
#ifndef CLOSE_ON_EXEC
state.didcch = didcch;
#endif /* CLOSE_ON_EXEC */
state.SHIN = SHIN;
state.SHOUT = SHOUT;
state.SHDIAG = SHDIAG;
(void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1);
(void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1);
(void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1);
cleanup_push(&state, doeval_cleanup);
getexit(osetexit);
/* PWP: setjmp/longjmp bugfix for optimizing compilers */
#ifdef cray
my_reenter = 1; /* assume non-zero return val */
if (setexit() == 0) {
my_reenter = 0; /* Oh well, we were wrong */
#else /* !cray */
if ((my_reenter = setexit()) == 0) {
#endif /* cray */
evalvec = v;
evalp = 0;
(void)close_on_exec(SHIN = dcopy(0, -1), 1);
(void)close_on_exec(SHOUT = dcopy(1, -1), 1);
(void)close_on_exec(SHDIAG = dcopy(2, -1), 1);
#ifndef CLOSE_ON_EXEC
didcch = 0;
#endif /* CLOSE_ON_EXEC */
didfds = 0;
gv = Ggv;
process(0);
Ggv = gv;
}
if (my_reenter == 0) {
cleanup_until(&state);
if (Ggv)
cleanup_until(Ggv);
}
resexit(osetexit);
if (my_reenter)
stderror(ERR_SILENT);
}
/*************************************************************************/
/* print list of builtin commands */
static void
lbuffed_cleanup (void *dummy)
{
USE(dummy);
lbuffed = 1;
}
/*ARGSUSED*/
void
dobuiltins(Char **v, struct command *c)
{
/* would use print_by_column() in tw.parse.c but that assumes
* we have an array of Char * to pass.. (sg)
*/
const struct biltins *b;
int row, col, columns, rows;
unsigned int w, maxwidth;
USE(c);
USE(v);
lbuffed = 0; /* turn off line buffering */
cleanup_push(&lbuffed, lbuffed_cleanup);
/* find widest string */
for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b)
maxwidth = max(maxwidth, strlen(b->bname));
++maxwidth; /* for space */
columns = (TermH + 1) / maxwidth; /* PWP: terminal size change */
if (!columns)
columns = 1;
rows = (nbfunc + (columns - 1)) / columns;
for (b = bfunc, row = 0; row < rows; row++) {
for (col = 0; col < columns; col++) {
if (b < &bfunc[nbfunc]) {
w = strlen(b->bname);
xprintf("%s", b->bname);
if (col < (columns - 1)) /* Not last column? */
for (; w < maxwidth; w++)
xputchar(' ');
++b;
}
}
if (row < (rows - 1)) {
if (Tty_raw_mode)
xputchar('\r');
xputchar('\n');
}
}
#ifdef WINNT_NATIVE
nt_print_builtins(maxwidth);
#else
if (Tty_raw_mode)
xputchar('\r');
xputchar('\n');
#endif /* WINNT_NATIVE */
cleanup_until(&lbuffed); /* turn back on line buffering */
flush();
}
#ifdef NLS_CATALOGS
char *
xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
{
char *res;
errno = 0;
while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
handle_pending_signals();
errno = 0;
}
return res;
}
# if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
char *
iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
{
static char *buf = NULL;
static size_t buf_size = 0;
char *orig, *dest, *p;
ICONV_CONST char *src;
size_t src_size, dest_size;
orig = xcatgets(ctd, set_id, msg_id, s);
if (catgets_iconv == (iconv_t)-1 || orig == s)
return orig;
src = orig;
src_size = strlen(src) + 1;
if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
return orig;
dest = buf;
while (src_size != 0) {
dest_size = buf + buf_size - dest;
if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
== (size_t)-1) {
switch (errno) {
case E2BIG:
if ((p = xrealloc(buf, buf_size * 2)) == NULL)
return orig;
buf_size *= 2;
dest = p + (dest - buf);
buf = p;
break;
case EILSEQ: case EINVAL: default:
return orig;
}
}
}
return buf;
}
# endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
#endif /* NLS_CATALOGS */
void
nlsinit(void)
{
#ifdef NLS_CATALOGS
static const char default_catalog[] = "tcsh";
char *catalog = (char *)(intptr_t)default_catalog;
if (adrof(STRcatalog) != NULL)
catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
#ifdef NL_CAT_LOCALE /* POSIX-compliant. */
/*
* Check if LC_MESSAGES is set in the environment and use it, if so.
* If not, fall back to the setting of LANG.
*/
catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
#else /* pre-POSIX */
# ifndef MCLoadBySet
# define MCLoadBySet 0
# endif
catd = catopen(catalog, MCLoadBySet);
#endif
if (catalog != default_catalog)
xfree(catalog);
#if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
/* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */
catgets_iconv = iconv_open (nl_langinfo (CODESET),
xcatgets(catd, 255, 1, "UTF-8"));
#endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
#endif /* NLS_CATALOGS */
#ifdef WINNT_NATIVE
nls_dll_init();
#endif /* WINNT_NATIVE */
errinit(); /* init the errorlist in correct locale */
mesginit(); /* init the messages for signals */
dateinit(); /* init the messages for dates */
editinit(); /* init the editor messages */
terminit(); /* init the termcap messages */
}
void
nlsclose(void)
{
#ifdef NLS_CATALOGS
#if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
if (catgets_iconv != (iconv_t)-1) {
iconv_close(catgets_iconv);
catgets_iconv = (iconv_t)-1;
}
#endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
if (catd != (nl_catd)-1) {
/*
* catclose can call other functions which can call longjmp
* making us re-enter this code. Prevent infinite recursion
* by resetting catd. Problem reported and solved by:
* Gerhard Niklasch
*/
nl_catd oldcatd = catd;
catd = (nl_catd)-1;
while (catclose(oldcatd) == -1 && errno == EINTR)
handle_pending_signals();
}
#endif /* NLS_CATALOGS */
}
Reference in New Issue View Git Blame Copy Permalink