contrib/tcsh-6/sh.func.c

   1 /*
   2  * sh.func.c: csh builtin functions
   3  */
   4 /*-
   5  * Copyright (c) 1980, 1991 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 #include "sh.h"
  33 #include "ed.h"
  34 #include "tw.h"
  35 #include "tc.h"
  36 #ifdef WINNT_NATIVE
  37 #include "nt.const.h"
  38 #endif /* WINNT_NATIVE */
  39
  40 #if defined (NLS_CATALOGS) && defined(HAVE_ICONV)
  41 static iconv_t catgets_iconv; /* Or (iconv_t)-1 */
  42 #endif
  43
  44 /*
  45  * C shell
  46  */
  47
  48 extern int MapsAreInited;
  49 extern int NLSMapsAreInited;
  50 extern int GotTermCaps;
  51
  52 static int zlast = -1;
  53
  54 static  void    islogin         (void);
  55 static  void    preread         (void);
  56 static  void    doagain         (void);
  57 static  const char *isrchx      (int);
  58 static  void    search          (int, int, Char *);
  59 static  int     getword         (struct Strbuf *);
  60 static  struct wordent  *histgetword    (struct wordent *);
  61 static  void    toend           (void);
  62 static  void    xecho           (int, Char **);
  63 static  int     islocale_var    (Char *);
  64 static  void    wpfree          (struct whyle *);
  65
  66 const struct biltins *
  67 isbfunc(struct command *t)
  68 {
  69     Char *cp = t->t_dcom[0];
  70     const struct biltins *bp, *bp1, *bp2;
  71     static struct biltins label = {"", dozip, 0, 0};
  72     static struct biltins foregnd = {"%job", dofg1, 0, 0};
  73     static struct biltins backgnd = {"%job &", dobg1, 0, 0};
  74
  75     /*
  76      * We never match a builtin that has quoted the first
  77      * character; this has been the traditional way to escape
  78      * builtin commands.
  79      */
  80     if (*cp & QUOTE)
  81         return NULL;
  82
  83     if (*cp != ':' && lastchr(cp) == ':') {
  84         label.bname = short2str(cp);
  85         return (&label);
  86     }
  87     if (*cp == '%') {
  88         if (t->t_dflg & F_AMPERSAND) {
  89             t->t_dflg &= ~F_AMPERSAND;
  90             backgnd.bname = short2str(cp);
  91             return (&backgnd);
  92         }
  93         foregnd.bname = short2str(cp);
  94         return (&foregnd);
  95     }
  96 #ifdef WARP
  97     /*
  98      * This is a perhaps kludgy way to determine if the warp builtin is to be
  99      * acknowledged or not.  If checkwarp() fails, then we are to assume that
 100      * the warp command is invalid, and carry on as we would handle any other
 101      * non-builtin command.         -- JDK 2/4/88
 102      */
 103     if (eq(STRwarp, cp) && !checkwarp()) {
 104         return (0);             /* this builtin disabled */
 105     }
 106 #endif /* WARP */
 107     /*
 108      * Binary search Bp1 is the beginning of the current search range. Bp2 is
 109      * one past the end.
 110      */
 111     for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
 112         int i;
 113
 114         bp = bp1 + ((bp2 - bp1) >> 1);
 115         if ((i = ((char) *cp) - *bp->bname) == 0 &&
 116             (i = StrQcmp(cp, str2short(bp->bname))) == 0)
 117             return bp;
 118         if (i < 0)
 119             bp2 = bp;
 120         else
 121             bp1 = bp + 1;
 122     }
 123 #ifdef WINNT_NATIVE
 124     return nt_check_additional_builtins(cp);
 125 #endif /*WINNT_NATIVE*/
 126     return (0);
 127 }
 128
 129 void
 130 func(struct command *t, const struct biltins *bp)
 131 {
 132     int     i;
 133
 134     xechoit(t->t_dcom);
 135     setname(bp->bname);
 136     i = blklen(t->t_dcom) - 1;
 137     if (i < bp->minargs)
 138         stderror(ERR_NAME | ERR_TOOFEW);
 139     if (i > bp->maxargs)
 140         stderror(ERR_NAME | ERR_TOOMANY);
 141     (*bp->bfunct) (t->t_dcom, t);
 142 }
 143
 144 /*ARGSUSED*/
 145 void
 146 doonintr(Char **v, struct command *c)
 147 {
 148     Char *cp;
 149     Char *vv = v[1];
 150
 151     USE(c);
 152     if (parintr.sa_handler == SIG_IGN)
 153         return;
 154     if (setintr && intty)
 155         stderror(ERR_NAME | ERR_TERMINAL);
 156     cp = gointr;
 157     gointr = 0;
 158     xfree(cp);
 159     if (vv == 0) {
 160         if (setintr)
 161             sigset_interrupting(SIGINT, queue_pintr);
 162         else
 163             (void) signal(SIGINT, SIG_DFL);
 164         gointr = 0;
 165     }
 166     else if (eq((vv = strip(vv)), STRminus)) {
 167         (void) signal(SIGINT, SIG_IGN);
 168         gointr = Strsave(STRminus);
 169     }
 170     else {
 171         gointr = Strsave(vv);
 172         sigset_interrupting(SIGINT, queue_pintr);
 173     }
 174 }
 175
 176 /*ARGSUSED*/
 177 void
 178 donohup(Char **v, struct command *c)
 179 {
 180     USE(c);
 181     USE(v);
 182     if (intty)
 183         stderror(ERR_NAME | ERR_TERMINAL);
 184     if (setintr == 0) {
 185         (void) signal(SIGHUP, SIG_IGN);
 186         phup_disabled = 1;
 187 #ifdef CC
 188         submit(getpid());
 189 #endif /* CC */
 190     }
 191 }
 192
 193 /*ARGSUSED*/
 194 void
 195 dohup(Char **v, struct command *c)
 196 {
 197     USE(c);
 198     USE(v);
 199     if (intty)
 200         stderror(ERR_NAME | ERR_TERMINAL);
 201     if (setintr == 0)
 202         sigset_interrupting(SIGHUP, SIG_DFL);
 203 }
 204
 205
 206 /*ARGSUSED*/
 207 void
 208 dozip(Char **v, struct command *c)
 209 {
 210     USE(c);
 211     USE(v);
 212 }
 213
 214 /*ARGSUSED*/
 215 void
 216 dofiletest(Char **v, struct command *c)
 217 {
 218     Char **globbed, **fileptr, *ftest, *res;
 219
 220     USE(c);
 221     if (*(ftest = *++v) != '-')
 222         stderror(ERR_NAME | ERR_FILEINQ);
 223     ++v;
 224
 225     v = glob_all_or_error(v);
 226     globbed = v;
 227     cleanup_push(globbed, blk_cleanup);
 228
 229     while (*(fileptr = v++) != NULL) {
 230         res = filetest(ftest, &fileptr, TEXP_NOGLOB);
 231         cleanup_push(res, xfree);
 232         xprintf("%" TCSH_S, res);
 233         cleanup_until(res);
 234         if (*v)
 235             xprintf(" ");
 236     }
 237     xprintf("\n");
 238
 239     cleanup_until(globbed);
 240 }
 241
 242 void
 243 prvars(void)
 244 {
 245     plist(&shvhed, VAR_ALL);
 246 }
 247
 248 /*ARGSUSED*/
 249 void
 250 doalias(Char **v, struct command *c)
 251 {
 252     struct varent *vp;
 253     Char *p;
 254
 255     USE(c);
 256     v++;
 257     p = *v++;
 258     if (p == 0)
 259         plist(&aliases, VAR_ALL);
 260     else if (*v == 0) {
 261         vp = adrof1(strip(p), &aliases);
 262         if (vp && vp->vec)
 263             blkpr(vp->vec), xputchar('\n');
 264     }
 265     else {
 266         if (eq(p, STRalias) || eq(p, STRunalias)) {
 267             setname(short2str(p));
 268             stderror(ERR_NAME | ERR_DANGER);
 269         }
 270         set1(strip(p), saveblk(v), &aliases, VAR_READWRITE);
 271         tw_cmd_free();
 272     }
 273 }
 274
 275 /*ARGSUSED*/
 276 void
 277 unalias(Char **v, struct command *c)
 278 {
 279     USE(c);
 280     unset1(v, &aliases);
 281     tw_cmd_free();
 282 }
 283
 284 /*ARGSUSED*/
 285 void
 286 dologout(Char **v, struct command *c)
 287 {
 288     USE(c);
 289     USE(v);
 290     islogin();
 291     goodbye(NULL, NULL);
 292 }
 293
 294 /*ARGSUSED*/
 295 void
 296 dologin(Char **v, struct command *c)
 297 {
 298 #ifdef WINNT_NATIVE
 299     USE(c);
 300     USE(v);
 301 #else /* !WINNT_NATIVE */
 302     char **p = short2blk(v);
 303
 304     USE(c);
 305     cleanup_push((Char **)p, blk_cleanup);
 306     islogin();
 307     rechist(NULL, adrof(STRsavehist) != NULL);
 308     sigaction(SIGTERM, &parterm, NULL);
 309     (void) execv(_PATH_BIN_LOGIN, p);
 310     (void) execv(_PATH_USRBIN_LOGIN, p);
 311     cleanup_until((Char **)p);
 312     untty();
 313     xexit(1);
 314 #endif /* !WINNT_NATIVE */
 315 }
 316
 317
 318 #ifdef NEWGRP
 319 /*ARGSUSED*/
 320 void
 321 donewgrp(Char **v, struct command *c)
 322 {
 323     char **p;
 324     if (chkstop == 0 && setintr)
 325         panystop(0);
 326     sigaction(SIGTERM, &parterm, NULL);
 327     p = short2blk(v);
 328     /*
 329      * From Beto Appleton (beto@aixwiz.austin.ibm.com)
 330      * Newgrp can take 2 arguments...
 331      */
 332     (void) execv(_PATH_BIN_NEWGRP, p);
 333     (void) execv(_PATH_USRBIN_NEWGRP, p);
 334     blkfree((Char **) p);
 335     untty();
 336     xexit(1);
 337 }
 338 #endif /* NEWGRP */
 339
 340 static void
 341 islogin(void)
 342 {
 343     if (chkstop == 0 && setintr)
 344         panystop(0);
 345     if (loginsh)
 346         return;
 347     stderror(ERR_NOTLOGIN);
 348 }
 349
 350 void
 351 doif(Char **v, struct command *kp)
 352 {
 353     int i;
 354     Char **vv;
 355
 356     v++;
 357     i = noexec ? 1 : expr(&v);
 358     vv = v;
 359     if (*vv == NULL)
 360         stderror(ERR_NAME | ERR_EMPTYIF);
 361     if (eq(*vv, STRthen)) {
 362         if (*++vv)
 363             stderror(ERR_NAME | ERR_IMPRTHEN);
 364         setname(short2str(STRthen));
 365         /*
 366          * If expression was zero, then scan to else , otherwise just fall into
 367          * following code.
 368          */
 369         if (!i)
 370             search(TC_IF, 0, NULL);
 371         return;
 372     }
 373     /*
 374      * Simple command attached to this if. Left shift the node in this tree,
 375      * munging it so we can reexecute it.
 376      */
 377     if (i) {
 378         lshift(kp->t_dcom, vv - kp->t_dcom);
 379         reexecute(kp);
 380         donefds();
 381     }
 382 }
 383
 384 /*
 385  * Reexecute a command, being careful not
 386  * to redo i/o redirection, which is already set up.
 387  */
 388 void
 389 reexecute(struct command *kp)
 390 {
 391     kp->t_dflg &= F_SAVE;
 392     kp->t_dflg |= F_REPEAT;
 393     /*
 394      * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
 395      * pgrp's as the jobs would then have no way to get the tty (we can't give
 396      * it to them, and our parent wouldn't know their pgrp, etc.
 397      */
 398     execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL, TRUE);
 399 }
 400
 401 /*ARGSUSED*/
 402 void
 403 doelse (Char **v, struct command *c)
 404 {
 405     USE(c);
 406     USE(v);
 407     if (!noexec)
 408         search(TC_ELSE, 0, NULL);
 409 }
 410
 411 /*ARGSUSED*/
 412 void
 413 dogoto(Char **v, struct command *c)
 414 {
 415     Char   *lp;
 416
 417     USE(c);
 418     lp = globone(v[1], G_ERROR);
 419     cleanup_push(lp, xfree);
 420     if (!noexec)
 421         gotolab(lp);
 422     cleanup_until(lp);
 423 }
 424
 425 void
 426 gotolab(Char *lab)
 427 {
 428     struct whyle *wp;
 429     /*
 430      * While we still can, locate any unknown ends of existing loops. This
 431      * obscure code is the WORST result of the fact that we don't really parse.
 432      */
 433     zlast = TC_GOTO;
 434     for (wp = whyles; wp; wp = wp->w_next)
 435         if (wp->w_end.type == TCSH_F_SEEK && wp->w_end.f_seek == 0) {
 436             search(TC_BREAK, 0, NULL);
 437             btell(&wp->w_end);
 438         }
 439         else {
 440             bseek(&wp->w_end);
 441         }
 442     search(TC_GOTO, 0, lab);
 443     /*
 444      * Eliminate loops which were exited.
 445      */
 446     wfree();
 447 }
 448
 449 /*ARGSUSED*/
 450 void
 451 doswitch(Char **v, struct command *c)
 452 {
 453     Char *cp, *lp;
 454
 455     USE(c);
 456     v++;
 457     if (!*v || *(*v++) != '(')
 458         stderror(ERR_SYNTAX);
 459     cp = **v == ')' ? STRNULL : *v++;
 460     if (*(*v++) != ')')
 461         v--;
 462     if (*v)
 463         stderror(ERR_SYNTAX);
 464     lp = globone(cp, G_ERROR);
 465     cleanup_push(lp, xfree);
 466     if (!noexec)
 467         search(TC_SWITCH, 0, lp);
 468     cleanup_until(lp);
 469 }
 470
 471 /*ARGSUSED*/
 472 void
 473 dobreak(Char **v, struct command *c)
 474 {
 475     USE(v);
 476     USE(c);
 477     if (whyles == NULL)
 478         stderror(ERR_NAME | ERR_NOTWHILE);
 479     if (!noexec)
 480         toend();
 481 }
 482
 483 /*ARGSUSED*/
 484 void
 485 doexit(Char **v, struct command *c)
 486 {
 487     USE(c);
 488
 489     if (chkstop == 0 && (intty || intact) && evalvec == 0)
 490         panystop(0);
 491     /*
 492      * Don't DEMAND parentheses here either.
 493      */
 494     v++;
 495     if (*v) {
 496         setstrstatus(putn(expr(&v)));
 497         if (*v)
 498             stderror(ERR_NAME | ERR_EXPRESSION);
 499     }
 500     btoeof();
 501 #if 0
 502     if (intty)
 503 #endif
 504     /* Always close, why only on ttys? */
 505         xclose(SHIN);
 506 }
 507
 508 /*ARGSUSED*/
 509 void
 510 doforeach(Char **v, struct command *c)
 511 {
 512     Char *cp, *sp;
 513     struct whyle *nwp;
 514     int gflag;
 515
 516     USE(c);
 517     v++;
 518     cp = sp = strip(*v);
 519     if (!letter(*cp))
 520         stderror(ERR_NAME | ERR_VARBEGIN);
 521     do {
 522         cp++;
 523     } while (alnum(*cp));
 524     if (*cp != '\0')
 525         stderror(ERR_NAME | ERR_VARALNUM);
 526     cp = *v++;
 527     if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
 528         stderror(ERR_NAME | ERR_NOPAREN);
 529     v++;
 530     gflag = tglob(v);
 531     if (gflag) {
 532         v = globall(v, gflag);
 533         if (v == 0 && !noexec)
 534             stderror(ERR_NAME | ERR_NOMATCH);
 535     }
 536     else {
 537         v = saveblk(v);
 538         trim(v);
 539     }
 540     nwp = xcalloc(1, sizeof *nwp);
 541     nwp->w_fe = nwp->w_fe0 = v;
 542     btell(&nwp->w_start);
 543     nwp->w_fename = Strsave(cp);
 544     nwp->w_next = whyles;
 545     nwp->w_end.type = TCSH_F_SEEK;
 546     whyles = nwp;
 547     /*
 548      * Pre-read the loop so as to be more comprehensible to a terminal user.
 549      */
 550     zlast = TC_FOREACH;
 551     if (intty)
 552         preread();
 553     if (!noexec)
 554         doagain();
 555 }
 556
 557 /*ARGSUSED*/
 558 void
 559 dowhile(Char **v, struct command *c)
 560 {
 561     int status;
 562     int again = whyles != 0 &&
 563                           SEEKEQ(&whyles->w_start, &lineloc) &&
 564                           whyles->w_fename == 0;
 565
 566     USE(c);
 567     v++;
 568     /*
 569      * Implement prereading here also, taking care not to evaluate the
 570      * expression before the loop has been read up from a terminal.
 571      */
 572     if (noexec)
 573         status = 0;
 574     else if (intty && !again)
 575         status = !exp0(&v, 1);
 576     else
 577         status = !expr(&v);
 578     if (*v && !noexec)
 579         stderror(ERR_NAME | ERR_EXPRESSION);
 580     if (!again) {
 581         struct whyle *nwp = xcalloc(1, sizeof(*nwp));
 582
 583         nwp->w_start = lineloc;
 584         nwp->w_end.type = TCSH_F_SEEK;
 585         nwp->w_end.f_seek = 0;
 586         nwp->w_end.a_seek = 0;
 587         nwp->w_next = whyles;
 588         whyles = nwp;
 589         zlast = TC_WHILE;
 590         if (intty) {
 591             /*
 592              * The tty preread
 593              */
 594             preread();
 595             doagain();
 596             return;
 597         }
 598     }
 599     if (status)
 600         /* We ain't gonna loop no more, no more! */
 601         toend();
 602 }
 603
 604 static void
 605 preread(void)
 606 {
 607     int old_pintr_disabled;
 608
 609     whyles->w_end.type = TCSH_I_SEEK;
 610     if (setintr)
 611         pintr_push_enable(&old_pintr_disabled);
 612     search(TC_BREAK, 0, NULL);          /* read the expression in */
 613     if (setintr)
 614         cleanup_until(&old_pintr_disabled);
 615     btell(&whyles->w_end);
 616 }
 617
 618 /*ARGSUSED*/
 619 void
 620 doend(Char **v, struct command *c)
 621 {
 622     USE(v);
 623     USE(c);
 624     if (!whyles)
 625         stderror(ERR_NAME | ERR_NOTWHILE);
 626     btell(&whyles->w_end);
 627     if (!noexec)
 628         doagain();
 629 }
 630
 631 /*ARGSUSED*/
 632 void
 633 docontin(Char **v, struct command *c)
 634 {
 635     USE(v);
 636     USE(c);
 637     if (!whyles)
 638         stderror(ERR_NAME | ERR_NOTWHILE);
 639     if (!noexec)
 640         doagain();
 641 }
 642
 643 static void
 644 doagain(void)
 645 {
 646     /* Repeating a while is simple */
 647     if (whyles->w_fename == 0) {
 648         bseek(&whyles->w_start);
 649         return;
 650     }
 651     /*
 652      * The foreach variable list actually has a spurious word ")" at the end of
 653      * the w_fe list.  Thus we are at the of the list if one word beyond this
 654      * is 0.
 655      */
 656     if (!whyles->w_fe[1]) {
 657         dobreak(NULL, NULL);
 658         return;
 659     }
 660     setv(whyles->w_fename, quote(Strsave(*whyles->w_fe++)), VAR_READWRITE);
 661     bseek(&whyles->w_start);
 662 }
 663
 664 void
 665 dorepeat(Char **v, struct command *kp)
 666 {
 667     int i = 1;
 668
 669     do {
 670         i *= getn(v[1]);
 671         lshift(v, 2);
 672     } while (v[0] != NULL && Strcmp(v[0], STRrepeat) == 0);
 673     if (noexec)
 674         i = 1;
 675
 676     if (setintr) {
 677         pintr_disabled++;
 678         cleanup_push(&pintr_disabled, disabled_cleanup);
 679     }
 680     while (i > 0) {
 681         if (setintr && pintr_disabled == 1) {
 682             cleanup_until(&pintr_disabled);
 683             pintr_disabled++;
 684             cleanup_push(&pintr_disabled, disabled_cleanup);
 685         }
 686         reexecute(kp);
 687         --i;
 688     }
 689     if (setintr && pintr_disabled == 1)
 690         cleanup_until(&pintr_disabled);
 691     donefds();
 692 }
 693
 694 /*ARGSUSED*/
 695 void
 696 doswbrk(Char **v, struct command *c)
 697 {
 698     USE(v);
 699     USE(c);
 700     if (!noexec)
 701         search(TC_BRKSW, 0, NULL);
 702 }
 703
 704 int
 705 srchx(Char *cp)
 706 {
 707     struct srch *sp, *sp1, *sp2;
 708     int i;
 709
 710     /*
 711      * Ignore keywords inside heredocs
 712      */
 713     if (inheredoc)
 714         return -1;
 715
 716     /*
 717      * Binary search Sp1 is the beginning of the current search range. Sp2 is
 718      * one past the end.
 719      */
 720     for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
 721         sp = sp1 + ((sp2 - sp1) >> 1);
 722         if ((i = *cp - *sp->s_name) == 0 &&
 723             (i = Strcmp(cp, str2short(sp->s_name))) == 0)
 724             return sp->s_value;
 725         if (i < 0)
 726             sp2 = sp;
 727         else
 728             sp1 = sp + 1;
 729     }
 730     return (-1);
 731 }
 732
 733 static const char *
 734 isrchx(int n)
 735 {
 736     struct srch *sp, *sp2;
 737
 738     for (sp = srchn, sp2 = srchn + nsrchn; sp < sp2; sp++)
 739         if (sp->s_value == n)
 740             return (sp->s_name);
 741     return ("");
 742 }
 743
 744
 745 static int Stype;
 746 static Char *Sgoal;
 747
 748 static void
 749 search(int type, int level, Char *goal)
 750 {
 751     struct Strbuf word = Strbuf_INIT;
 752     Char *cp;
 753     struct whyle *wp;
 754     int wlevel = 0;
 755     struct wordent *histent = NULL, *ohistent = NULL;
 756
 757     Stype = type;
 758     Sgoal = goal;
 759     if (type == TC_GOTO) {
 760         struct Ain a;
 761         a.type = TCSH_F_SEEK;
 762         a.f_seek = 0;
 763         a.a_seek = 0;
 764         bseek(&a);
 765     }
 766     cleanup_push(&word, Strbuf_cleanup);
 767     do {
 768
 769         if (intty) {
 770             histent = xmalloc(sizeof(*histent));
 771             ohistent = xmalloc(sizeof(*histent));
 772             ohistent->word = STRNULL;
 773             ohistent->next = histent;
 774             histent->prev = ohistent;
 775         }
 776
 777         if (intty && fseekp == feobp && aret == TCSH_F_SEEK)
 778             printprompt(1, isrchx(type == TC_BREAK ? zlast : type));
 779         /* xprintf("? "), flush(); */
 780         (void) getword(&word);
 781         Strbuf_terminate(&word);
 782
 783         if (intty && Strlen(word.s) > 0) {
 784             histent->word = Strsave(word.s);
 785             histent->next = xmalloc(sizeof(*histent));
 786             histent->next->prev = histent;
 787             histent = histent->next;
 788         }
 789
 790         switch (srchx(word.s)) {
 791
 792         case TC_ELSE:
 793             if (level == 0 && type == TC_IF)
 794                 goto end;
 795             break;
 796
 797         case TC_IF:
 798             while (getword(&word)) {
 799                 if (intty) {
 800                     histent->word = Strsave(word.s);
 801                     histent->next = xmalloc(sizeof(*histent));
 802                     histent->next->prev = histent;
 803                     histent = histent->next;
 804                 }
 805                 continue;
 806             }
 807
 808             if ((type == TC_IF || type == TC_ELSE) &&
 809                 eq(word.s, STRthen))
 810                 level++;
 811             break;
 812
 813         case TC_ENDIF:
 814             if (type == TC_IF || type == TC_ELSE)
 815                 level--;
 816             break;
 817
 818         case TC_FOREACH:
 819         case TC_WHILE:
 820             wlevel++;
 821             if (type == TC_BREAK)
 822                 level++;
 823             break;
 824
 825         case TC_END:
 826             if (type == TC_BRKSW) {
 827                 if (wlevel == 0) {
 828                     wp = whyles;
 829                     if (wp) {
 830                             whyles = wp->w_next;
 831                             wpfree(wp);
 832                     }
 833                 }
 834             }
 835             if (type == TC_BREAK)
 836                 level--;
 837             wlevel--;
 838             break;
 839
 840         case TC_SWITCH:
 841             if (type == TC_SWITCH || type == TC_BRKSW)
 842                 level++;
 843             break;
 844
 845         case TC_ENDSW:
 846             if (type == TC_SWITCH || type == TC_BRKSW)
 847                 level--;
 848             break;
 849
 850         case TC_LABEL:
 851             if (type == TC_GOTO && getword(&word) && eq(word.s, goal))
 852                 level = -1;
 853             break;
 854
 855         default:
 856             if (type != TC_GOTO && (type != TC_SWITCH || level != 0))
 857                 break;
 858             if (word.len == 0 || word.s[word.len - 1] != ':')
 859                 break;
 860             word.s[--word.len] = 0;
 861             if ((type == TC_GOTO && eq(word.s, goal)) ||
 862                 (type == TC_SWITCH && eq(word.s, STRdefault)))
 863                 level = -1;
 864             break;
 865
 866         case TC_CASE:
 867             if (type != TC_SWITCH || level != 0)
 868                 break;
 869             (void) getword(&word);
 870             if (word.len != 0 && word.s[word.len - 1] == ':')
 871                 word.s[--word.len] = 0;
 872             cp = strip(Dfix1(word.s));
 873             cleanup_push(cp, xfree);
 874             if (Gmatch(goal, cp))
 875                 level = -1;
 876             cleanup_until(cp);
 877             break;
 878
 879         case TC_DEFAULT:
 880             if (type == TC_SWITCH && level == 0)
 881                 level = -1;
 882             break;
 883         }
 884         if (intty) {
 885             ohistent->prev = histgetword(histent);
 886             ohistent->prev->next = ohistent;
 887             savehist(ohistent, 0);
 888             freelex(ohistent);
 889             xfree(ohistent);
 890         } else
 891             (void) getword(NULL);
 892     } while (level >= 0);
 893  end:
 894     cleanup_until(&word);
 895 }
 896
 897 static struct wordent *
 898 histgetword(struct wordent *histent)
 899 {
 900     int first;
 901     eChar c, d;
 902     int e;
 903     struct Strbuf *tmp;
 904     tmp = xmalloc(sizeof(*tmp));
 905     tmp->size = 0;
 906     tmp->s = NULL;
 907     c = readc(1);
 908     d = 0;
 909     e = 0;
 910     for (;;) {
 911         tmp->len = 0;
 912         Strbuf_terminate (tmp);
 913         while (c == ' ' || c == '\t')
 914             c = readc(1);
 915         if (c == '#')
 916             do
 917                 c = readc(1);
 918             while (c != CHAR_ERR && c != '\n');
 919         if (c == CHAR_ERR)
 920             goto past;
 921         if (c == '\n')
 922             goto nl;
 923         unreadc(c);
 924         first = 1;
 925         do {
 926             e = (c == '\\');
 927             c = readc(1);
 928             if (c == '\\' && !e) {
 929                 if ((c = readc(1)) == '\n') {
 930                     e = 1;
 931                     c = ' ';
 932                 } else {
 933                     unreadc(c);
 934                     c = '\\';
 935                 }
 936             }
 937             if ((c == '\'' || c == '"') && !e) {
 938                 if (d == 0)
 939                     d = c;
 940                 else if (d == c)
 941                     d = 0;
 942             }
 943             if (c == CHAR_ERR)
 944                 goto past;
 945
 946             Strbuf_append1(tmp, (Char) c);
 947
 948             if (!first && !d && c == '(' && !e) {
 949                 break;
 950             }
 951             first = 0;
 952         } while (d || e || (c != ' ' && c != '\t' && c != '\n'));
 953         tmp->len--;
 954         if (tmp->len) {
 955             Strbuf_terminate(tmp);
 956             histent->word = Strsave(tmp->s);
 957             histent->next = xmalloc(sizeof (*histent));
 958             histent->next->prev = histent;
 959             histent = histent->next;
 960         }
 961         if (c == '\n') {
 962         nl:
 963             tmp->len = 0;
 964             Strbuf_append1(tmp, (Char) c);
 965             Strbuf_terminate(tmp);
 966             histent->word = Strsave(tmp->s);
 967             return histent;
 968         }
 969     }
 970
 971 past:
 972     switch (Stype) {
 973
 974     case TC_IF:
 975         stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
 976         break;
 977
 978     case TC_ELSE:
 979         stderror(ERR_NAME | ERR_NOTFOUND, "endif");
 980         break;
 981
 982     case TC_BRKSW:
 983     case TC_SWITCH:
 984         stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
 985         break;
 986
 987     case TC_BREAK:
 988         stderror(ERR_NAME | ERR_NOTFOUND, "end");
 989         break;
 990
 991     case TC_GOTO:
 992         setname(short2str(Sgoal));
 993         stderror(ERR_NAME | ERR_NOTFOUND, "label");
 994         break;
 995
 996     default:
 997         break;
 998     }
 999     /* NOTREACHED */
1000     return NULL;
1001 }
1002
1003 static int
1004 getword(struct Strbuf *wp)
1005 {
1006     int found = 0, first;
1007     eChar c, d;
1008
1009     if (wp)
1010         wp->len = 0;
1011     c = readc(1);
1012     d = 0;
1013     do {
1014         while (c == ' ' || c == '\t')
1015             c = readc(1);
1016         if (c == '#')
1017             do
1018                 c = readc(1);
1019             while (c != CHAR_ERR && c != '\n');
1020         if (c == CHAR_ERR)
1021             goto past;
1022         if (c == '\n') {
1023             if (wp)
1024                 break;
1025             return (0);
1026         }
1027         unreadc(c);
1028         found = 1;
1029         first = 1;
1030         do {
1031             c = readc(1);
1032             if (c == '\\' && (c = readc(1)) == '\n')
1033                 c = ' ';
1034             if (c == '\'' || c == '"') {
1035                 if (d == 0)
1036                     d = c;
1037                 else if (d == c)
1038                     d = 0;
1039             }
1040             if (c == CHAR_ERR)
1041                 goto past;
1042             if (wp)
1043                 Strbuf_append1(wp, (Char) c);
1044             if (!d && c == ')') {
1045                 if (!first && wp) {
1046                     goto past_word_end;
1047                 } else {
1048                     if (wp) {
1049                         wp->len = 1;
1050                         Strbuf_terminate(wp);
1051                     }
1052                     return found;
1053                 }
1054             }
1055             if (!first && !d && c == '(') {
1056                 if (wp)
1057                     goto past_word_end;
1058                 else
1059                     break;
1060             }
1061             first = 0;
1062         } while ((d || (c != ' ' && c != '\t')) && c != '\n');
1063     } while (wp == 0);
1064
1065  past_word_end:
1066     unreadc(c);
1067     if (found) {
1068         wp->len--;
1069         Strbuf_terminate(wp);
1070     }
1071
1072     return (found);
1073
1074 past:
1075     switch (Stype) {
1076
1077     case TC_IF:
1078         stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
1079         break;
1080
1081     case TC_ELSE:
1082         stderror(ERR_NAME | ERR_NOTFOUND, "endif");
1083         break;
1084
1085     case TC_BRKSW:
1086     case TC_SWITCH:
1087         stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
1088         break;
1089
1090     case TC_BREAK:
1091         stderror(ERR_NAME | ERR_NOTFOUND, "end");
1092         break;
1093
1094     case TC_GOTO:
1095         setname(short2str(Sgoal));
1096         stderror(ERR_NAME | ERR_NOTFOUND, "label");
1097         break;
1098
1099     default:
1100         break;
1101     }
1102     /* NOTREACHED */
1103     return (0);
1104 }
1105
1106 static void
1107 toend(void)
1108 {
1109     if (whyles->w_end.type == TCSH_F_SEEK && whyles->w_end.f_seek == 0) {
1110         search(TC_BREAK, 0, NULL);
1111         btell(&whyles->w_end);
1112         whyles->w_end.f_seek--;
1113     }
1114     else {
1115         bseek(&whyles->w_end);
1116     }
1117     wfree();
1118 }
1119
1120 static void
1121 wpfree(struct whyle *wp)
1122 {
1123         if (wp->w_fe0)
1124             blkfree(wp->w_fe0);
1125         xfree(wp->w_fename);
1126         xfree(wp);
1127 }
1128
1129 void
1130 wfree(void)
1131 {
1132     struct Ain    o;
1133     struct whyle *nwp;
1134 #ifdef lint
1135     nwp = NULL; /* sun lint is dumb! */
1136 #endif
1137
1138 #ifdef FDEBUG
1139     static const char foo[] = "IAFE";
1140 #endif /* FDEBUG */
1141
1142     btell(&o);
1143
1144 #ifdef FDEBUG
1145     xprintf("o->type %c o->a_seek %d o->f_seek %d\n",
1146             foo[o.type + 1], o.a_seek, o.f_seek);
1147 #endif /* FDEBUG */
1148
1149     for (; whyles; whyles = nwp) {
1150         struct whyle *wp = whyles;
1151         nwp = wp->w_next;
1152
1153 #ifdef FDEBUG
1154         xprintf("start->type %c start->a_seek %d start->f_seek %d\n",
1155                 foo[wp->w_start.type+1],
1156                 wp->w_start.a_seek, wp->w_start.f_seek);
1157         xprintf("end->type %c end->a_seek %d end->f_seek %d\n",
1158                 foo[wp->w_end.type + 1], wp->w_end.a_seek, wp->w_end.f_seek);
1159 #endif /* FDEBUG */
1160
1161         /*
1162          * XXX: We free loops that have different seek types.
1163          */
1164         if (wp->w_end.type != TCSH_I_SEEK && wp->w_start.type == wp->w_end.type &&
1165             wp->w_start.type == o.type) {
1166             if (wp->w_end.type == TCSH_F_SEEK) {
1167                 if (o.f_seek >= wp->w_start.f_seek &&
1168                     (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
1169                     break;
1170             }
1171             else {
1172                 if (o.a_seek >= wp->w_start.a_seek &&
1173                     (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
1174                     break;
1175             }
1176         }
1177
1178         wpfree(wp);
1179     }
1180 }
1181
1182 /*ARGSUSED*/
1183 void
1184 doecho(Char **v, struct command *c)
1185 {
1186     USE(c);
1187     xecho(' ', v);
1188 }
1189
1190 /*ARGSUSED*/
1191 void
1192 doglob(Char **v, struct command *c)
1193 {
1194     USE(c);
1195     xecho(0, v);
1196     flush();
1197 }
1198
1199 static void
1200 xecho(int sep, Char **v)
1201 {
1202     Char **globbed = NULL;
1203     const Char *cp;
1204     int     nonl = 0;
1205     int     echo_style = ECHO_STYLE;
1206     struct varent *vp;
1207
1208     if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL &&
1209         vp->vec[0] != NULL) {
1210         if (Strcmp(vp->vec[0], STRbsd) == 0)
1211             echo_style = BSD_ECHO;
1212         else if (Strcmp(vp->vec[0], STRsysv) == 0)
1213             echo_style = SYSV_ECHO;
1214         else if (Strcmp(vp->vec[0], STRboth) == 0)
1215             echo_style = BOTH_ECHO;
1216         else if (Strcmp(vp->vec[0], STRnone) == 0)
1217             echo_style = NONE_ECHO;
1218     }
1219
1220     v++;
1221     if (*v == 0)
1222         goto done;
1223     if (setintr) {
1224         int old_pintr_disabled;
1225         pintr_push_enable(&old_pintr_disabled);
1226         v = glob_all_or_error(v);
1227         cleanup_until(&old_pintr_disabled);
1228     } else {
1229         v = glob_all_or_error(v);
1230     }
1231     globbed = v;
1232     if (globbed != NULL)
1233         cleanup_push(globbed, blk_cleanup);
1234
1235     if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn))
1236         nonl++, v++;
1237
1238     while ((cp = *v++) != 0) {
1239         eChar c;
1240
1241         if (setintr) {
1242             int old_pintr_disabled;
1243
1244             pintr_push_enable(&old_pintr_disabled);
1245             cleanup_until(&old_pintr_disabled);
1246         }
1247         for (; (c = *cp) != 0; cp++) {
1248             if ((echo_style & SYSV_ECHO) != 0 && c == '\\') {
1249                 if ((c = parseescape(&cp, FALSE)) == CHAR_ERR)
1250                     c = '\\';
1251             }
1252             xputwchar(c | QUOTE);
1253         }
1254         if (*v)
1255             xputchar(sep | QUOTE);
1256     }
1257 done:
1258     if (sep && nonl == 0)
1259         xputchar('\n');
1260     else
1261         flush();
1262     if (globbed != NULL)
1263         cleanup_until(globbed);
1264 }
1265
1266 /* check whether an environment variable should invoke 'set_locale()' */
1267 static int
1268 islocale_var(Char *var)
1269 {
1270     static Char *locale_vars[] = {
1271         STRLANG,        STRLC_ALL,      STRLC_CTYPE,    STRLC_NUMERIC,
1272         STRLC_TIME,     STRLC_COLLATE,  STRLC_MESSAGES, STRLC_MONETARY, 0
1273     };
1274     Char **v;
1275
1276     for (v = locale_vars; *v; ++v)
1277         if (eq(var, *v))
1278             return 1;
1279     return 0;
1280 }
1281
1282 static void
1283 xlate_cr_cleanup(void *dummy)
1284 {
1285     USE(dummy);
1286     xlate_cr = 0;
1287 }
1288
1289 /*ARGSUSED*/
1290 void
1291 doprintenv(Char **v, struct command *c)
1292 {
1293     Char   *e;
1294
1295     USE(c);
1296     v++;
1297     if (*v == 0) {
1298         Char **ep;
1299
1300         xlate_cr = 1;
1301         cleanup_push(&xlate_cr, xlate_cr_cleanup);
1302         for (ep = STR_environ; *ep; ep++) {
1303             if (setintr) {
1304                 int old_pintr_disabled;
1305
1306                 pintr_push_enable(&old_pintr_disabled);
1307                 cleanup_until(&old_pintr_disabled);
1308             }
1309             xprintf("%" TCSH_S "\n", *ep);
1310         }
1311         cleanup_until(&xlate_cr);
1312     }
1313     else if ((e = tgetenv(*v)) != NULL) {
1314         int old_output_raw;
1315
1316         old_output_raw = output_raw;
1317         output_raw = 1;
1318         cleanup_push(&old_output_raw, output_raw_restore);
1319         xprintf("%" TCSH_S "\n", e);
1320         cleanup_until(&old_output_raw);
1321     }
1322     else
1323         setstatus(1);
1324 }
1325
1326 /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things
1327    (and anything else with a modern compiler) */
1328
1329 /*ARGSUSED*/
1330 void
1331 dosetenv(Char **v, struct command *c)
1332 {
1333     Char   *vp, *lp;
1334
1335     USE(c);
1336     if (*++v == 0) {
1337         doprintenv(--v, 0);
1338         return;
1339     }
1340
1341     vp = *v++;
1342     lp = vp;
1343
1344     if (!letter(*lp))
1345         stderror(ERR_NAME | ERR_VARBEGIN);
1346     do {
1347         lp++;
1348     } while (alnum(*lp) || *lp == '.');
1349     if (*lp != '\0')
1350         stderror(ERR_NAME | ERR_VARALNUM);
1351
1352     if ((lp = *v++) == 0)
1353         lp = STRNULL;
1354
1355     lp = globone(lp, G_APPEND);
1356     cleanup_push(lp, xfree);
1357     tsetenv(vp, lp);
1358     if (eq(vp, STRKPATH)) {
1359         importpath(lp);
1360         dohash(NULL, NULL);
1361         cleanup_until(lp);
1362         return;
1363     }
1364
1365 #ifdef apollo
1366     if (eq(vp, STRSYSTYPE)) {
1367         dohash(NULL, NULL);
1368         cleanup_until(lp);
1369         return;
1370     }
1371 #endif /* apollo */
1372
1373     /* dspkanji/dspmbyte autosetting */
1374     /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
1375 #if defined(DSPMBYTE)
1376     if (eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) {
1377         autoset_dspmbyte(lp);
1378     }
1379 #endif
1380
1381     if (islocale_var(vp)) {
1382 #ifdef NLS
1383         int     k;
1384
1385 # ifdef SETLOCALEBUG
1386         dont_free = 1;
1387 # endif /* SETLOCALEBUG */
1388         (void) setlocale(LC_ALL, "");
1389 # ifdef LC_COLLATE
1390         (void) setlocale(LC_COLLATE, "");
1391 # endif
1392 # ifdef LC_CTYPE
1393         (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1394 # endif /* LC_CTYPE */
1395 # if defined(AUTOSET_KANJI)
1396         autoset_kanji();
1397 # endif /* AUTOSET_KANJI */
1398 # ifdef NLS_CATALOGS
1399 #  ifdef LC_MESSAGES
1400         (void) setlocale(LC_MESSAGES, "");
1401 #  endif /* LC_MESSAGES */
1402         nlsclose();
1403         nlsinit();
1404 # endif /* NLS_CATALOGS */
1405 # ifdef SETLOCALEBUG
1406         dont_free = 0;
1407 # endif /* SETLOCALEBUG */
1408 # ifdef STRCOLLBUG
1409         fix_strcoll_bug();
1410 # endif /* STRCOLLBUG */
1411         tw_cmd_free();  /* since the collation sequence has changed */
1412         for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1413             continue;
1414         AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1415 #else /* !NLS */
1416         AsciiOnly = 0;
1417 #endif /* NLS */
1418         NLSMapsAreInited = 0;
1419         ed_Init();
1420         if (MapsAreInited && !NLSMapsAreInited)
1421             ed_InitNLSMaps();
1422         cleanup_until(lp);
1423         return;
1424     }
1425
1426 #ifdef NLS_CATALOGS
1427     if (eq(vp, STRNLSPATH)) {
1428         nlsclose();
1429         nlsinit();
1430     }
1431 #endif
1432
1433     if (eq(vp, STRNOREBIND)) {
1434         NoNLSRebind = 1;
1435         MapsAreInited = 0;
1436         NLSMapsAreInited = 0;
1437         ed_InitMaps();
1438         cleanup_until(lp);
1439         return;
1440     }
1441 #ifdef WINNT_NATIVE
1442     if (eq(vp, STRtcshlang)) {
1443         nlsinit();
1444         cleanup_until(lp);
1445         return;
1446     }
1447 #endif /* WINNT_NATIVE */
1448     if (eq(vp, STRKTERM)) {
1449         char *t;
1450
1451         setv(STRterm, quote(lp), VAR_READWRITE);        /* lp memory used here */
1452         cleanup_ignore(lp);
1453         cleanup_until(lp);
1454         t = short2str(lp);
1455         if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) {
1456             editing = 1;
1457             noediting = 0;
1458             setNS(STRedit);
1459         }
1460         GotTermCaps = 0;
1461         ed_Init();
1462         return;
1463     }
1464
1465     if (eq(vp, STRKHOME)) {
1466         Char *canon;
1467         /*
1468          * convert to canonical pathname (possibly resolving symlinks)
1469          */
1470         cleanup_ignore(lp);
1471         canon = dcanon(lp, lp);
1472         cleanup_push(canon, xfree);
1473         setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */
1474         cleanup_ignore(canon);
1475         cleanup_until(canon);
1476
1477         /* fix directory stack for new tilde home */
1478         dtilde();
1479         return;
1480     }
1481
1482     if (eq(vp, STRKSHLVL)) {
1483         setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */
1484         cleanup_ignore(lp);
1485         cleanup_until(lp);
1486         return;
1487     }
1488
1489     if (eq(vp, STRKUSER)) {
1490         setv(STRuser, quote(lp), VAR_READWRITE);        /* lp memory used here */
1491         cleanup_ignore(lp);
1492         cleanup_until(lp);
1493         return;
1494     }
1495
1496     if (eq(vp, STRKGROUP)) {
1497         setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */
1498         cleanup_ignore(lp);
1499         cleanup_until(lp);
1500         return;
1501     }
1502
1503 #ifdef COLOR_LS_F
1504     if (eq(vp, STRLS_COLORS)) {
1505         parseLS_COLORS(lp);
1506         cleanup_until(lp);
1507         return;
1508     }
1509     if (eq(vp, STRLSCOLORS)) {
1510         parseLSCOLORS(lp);
1511         cleanup_until(lp);
1512         return;
1513     }
1514 #endif /* COLOR_LS_F */
1515
1516 #ifdef SIG_WINDOW
1517     /*
1518      * Load/Update $LINES $COLUMNS
1519      */
1520     if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) ||
1521         eq(vp, STRTERMCAP)) {
1522         cleanup_until(lp);
1523         check_window_size(1);
1524         return;
1525     }
1526
1527     /*
1528      * Change the size to the one directed by $LINES and $COLUMNS
1529      */
1530     if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) {
1531 #if 0
1532         GotTermCaps = 0;
1533 #endif
1534         cleanup_until(lp);
1535         ed_Init();
1536         return;
1537     }
1538 #endif /* SIG_WINDOW */
1539     cleanup_until(lp);
1540 }
1541
1542 /*ARGSUSED*/
1543 void
1544 dounsetenv(Char **v, struct command *c)
1545 {
1546     Char  **ep, *p, *n, *name;
1547     int     i, maxi;
1548
1549     USE(c);
1550     /*
1551      * Find the longest environment variable
1552      */
1553     for (maxi = 0, ep = STR_environ; *ep; ep++) {
1554         for (i = 0, p = *ep; *p && *p != '='; p++, i++)
1555             continue;
1556         if (i > maxi)
1557             maxi = i;
1558     }
1559
1560     name = xmalloc((maxi + 1) * sizeof(Char));
1561     cleanup_push(name, xfree);
1562
1563     while (++v && *v)
1564         for (maxi = 1; maxi;)
1565             for (maxi = 0, ep = STR_environ; *ep; ep++) {
1566                 for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
1567                     continue;
1568                 *n = '\0';
1569                 if (!Gmatch(name, *v))
1570                     continue;
1571                 maxi = 1;
1572
1573                 /* Unset the name. This wasn't being done until
1574                  * later but most of the stuff following won't
1575                  * work (particularly the setlocale() and getenv()
1576                  * stuff) as intended until the name is actually
1577                  * removed. (sg)
1578                  */
1579                 Unsetenv(name);
1580
1581                 if (eq(name, STRNOREBIND)) {
1582                     NoNLSRebind = 0;
1583                     MapsAreInited = 0;
1584                     NLSMapsAreInited = 0;
1585                     ed_InitMaps();
1586                 }
1587 #ifdef apollo
1588                 else if (eq(name, STRSYSTYPE))
1589                     dohash(NULL, NULL);
1590 #endif /* apollo */
1591                 else if (islocale_var(name)) {
1592 #ifdef NLS
1593                     int     k;
1594
1595 # ifdef SETLOCALEBUG
1596                     dont_free = 1;
1597 # endif /* SETLOCALEBUG */
1598                     (void) setlocale(LC_ALL, "");
1599 # ifdef LC_COLLATE
1600                     (void) setlocale(LC_COLLATE, "");
1601 # endif
1602 # ifdef LC_CTYPE
1603                     (void) setlocale(LC_CTYPE, ""); /* for iscntrl */
1604 # endif /* LC_CTYPE */
1605 # ifdef NLS_CATALOGS
1606 #  ifdef LC_MESSAGES
1607                     (void) setlocale(LC_MESSAGES, "");
1608 #  endif /* LC_MESSAGES */
1609                     nlsclose();
1610                     nlsinit();
1611 # endif /* NLS_CATALOGS */
1612 # ifdef SETLOCALEBUG
1613                     dont_free = 0;
1614 # endif /* SETLOCALEBUG */
1615 # ifdef STRCOLLBUG
1616                     fix_strcoll_bug();
1617 # endif /* STRCOLLBUG */
1618                     tw_cmd_free();/* since the collation sequence has changed */
1619                     for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++)
1620                         continue;
1621                     AsciiOnly = MB_CUR_MAX == 1 && k > 0377;
1622 #else /* !NLS */
1623                     AsciiOnly = getenv("LANG") == NULL &&
1624                         getenv("LC_CTYPE") == NULL;
1625 #endif /* NLS */
1626                     NLSMapsAreInited = 0;
1627                     ed_Init();
1628                     if (MapsAreInited && !NLSMapsAreInited)
1629                         ed_InitNLSMaps();
1630
1631                 }
1632 #ifdef WINNT_NATIVE
1633                 else if (eq(name,(STRtcshlang))) {
1634                     nls_dll_unload();
1635                     nlsinit();
1636                 }
1637 #endif /* WINNT_NATIVE */
1638 #ifdef COLOR_LS_F
1639                 else if (eq(name, STRLS_COLORS))
1640                     parseLS_COLORS(n);
1641                 else if (eq(name, STRLSCOLORS))
1642                     parseLSCOLORS(n);
1643 #endif /* COLOR_LS_F */
1644 #ifdef NLS_CATALOGS
1645                 else if (eq(name, STRNLSPATH)) {
1646                     nlsclose();
1647                     nlsinit();
1648                 }
1649 #endif
1650                 /*
1651                  * start again cause the environment changes
1652                  */
1653                 break;
1654             }
1655     cleanup_until(name);
1656 }
1657
1658 void
1659 tsetenv(const Char *name, const Char *val)
1660 {
1661 #ifdef SETENV_IN_LIB
1662 /*
1663  * XXX: This does not work right, since tcsh cannot track changes to
1664  * the environment this way. (the builtin setenv without arguments does
1665  * not print the right stuff neither does unsetenv). This was for Mach,
1666  * it is not needed anymore.
1667  */
1668 #undef setenv
1669     char   *cname;
1670
1671     if (name == NULL)
1672         return;
1673     cname = strsave(short2str(name));
1674     setenv(cname, short2str(val), 1);
1675     xfree(cname);
1676 #else /* !SETENV_IN_LIB */
1677     Char **ep = STR_environ;
1678     const Char *ccp;
1679     Char *cp, *dp;
1680     Char   *blk[2];
1681     Char  **oep = ep;
1682
1683 #ifdef WINNT_NATIVE
1684     nt_set_env(name,val);
1685 #endif /* WINNT_NATIVE */
1686     for (; *ep; ep++) {
1687 #ifdef WINNT_NATIVE
1688         for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp);
1689                                 ccp++, dp++)
1690 #else
1691         for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++)
1692 #endif /* WINNT_NATIVE */
1693             continue;
1694         if (*ccp != 0 || *dp != '=')
1695             continue;
1696         cp = Strspl(STRequal, val);
1697         xfree(*ep);
1698         *ep = strip(Strspl(name, cp));
1699         xfree(cp);
1700         blkfree((Char **) environ);
1701         environ = short2blk(STR_environ);
1702         return;
1703     }
1704     cp = Strspl(name, STRequal);
1705     blk[0] = strip(Strspl(cp, val));
1706     xfree(cp);
1707     blk[1] = 0;
1708     STR_environ = blkspl(STR_environ, blk);
1709     blkfree((Char **) environ);
1710     environ = short2blk(STR_environ);
1711     xfree(oep);
1712 #endif /* SETENV_IN_LIB */
1713 }
1714
1715 void
1716 Unsetenv(Char *name)
1717 {
1718     Char **ep = STR_environ;
1719     Char *cp, *dp;
1720     Char **oep = ep;
1721
1722 #ifdef WINNT_NATIVE
1723         nt_set_env(name,NULL);
1724 #endif /*WINNT_NATIVE */
1725     for (; *ep; ep++) {
1726         for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
1727             continue;
1728         if (*cp != 0 || *dp != '=')
1729             continue;
1730         cp = *ep;
1731         *ep = 0;
1732         STR_environ = blkspl(STR_environ, ep + 1);
1733         blkfree((Char **) environ);
1734         environ = short2blk(STR_environ);
1735         *ep = cp;
1736         xfree(cp);
1737         xfree(oep);
1738         return;
1739     }
1740 }
1741
1742 /*ARGSUSED*/
1743 void
1744 doumask(Char **v, struct command *c)
1745 {
1746     Char *cp = v[1];
1747     int i;
1748
1749     USE(c);
1750     if (cp == 0) {
1751         i = (int)umask(0);
1752         (void) umask(i);
1753         xprintf("%o\n", i);
1754         return;
1755     }
1756     i = 0;
1757     while (Isdigit(*cp) && *cp != '8' && *cp != '9')
1758         i = i * 8 + *cp++ - '0';
1759     if (*cp || i < 0 || i > 0777)
1760         stderror(ERR_NAME | ERR_MASK);
1761     (void) umask(i);
1762 }
1763
1764 #ifndef HAVENOLIMIT
1765 # ifndef BSDLIMIT
1766    typedef long RLIM_TYPE;
1767 #  ifdef _OSD_POSIX /* BS2000 */
1768 #   include <ulimit.h>
1769 #  endif
1770 #  ifndef RLIM_INFINITY
1771 #   if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY)
1772     extern RLIM_TYPE ulimit();
1773 #   endif /* ! _MINIX && !__clipper__ */
1774 #   define RLIM_INFINITY 0x003fffff
1775 #   define RLIMIT_FSIZE 1
1776 #  endif /* RLIM_INFINITY */
1777 #  ifdef aiws
1778 #   define toset(a) (((a) == 3) ? 1004 : (a) + 1)
1779 #   define RLIMIT_DATA  3
1780 #   define RLIMIT_STACK 1005
1781 #  else /* aiws */
1782 #   define toset(a) ((a) + 1)
1783 #  endif /* aiws */
1784 # else /* BSDLIMIT */
1785 #  if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__)
1786     typedef rlim_t RLIM_TYPE;
1787 #  else
1788 #   if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3)
1789      typedef rlim_t RLIM_TYPE;
1790 #   else
1791 #    if defined(_SX)
1792       typedef long long RLIM_TYPE;
1793 #    else /* !_SX */
1794       typedef unsigned long RLIM_TYPE;
1795 #    endif /* _SX */
1796 #   endif /* SOLARIS2 || (sgi && SYSVREL > 3) */
1797 #  endif /* BSD4_4 && !__386BSD__  */
1798 # endif /* BSDLIMIT */
1799
1800 # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT)
1801 /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */
1802 /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */
1803 #  ifndef RLIMIT_CPU
1804 #   define RLIMIT_CPU           0
1805 #   define RLIMIT_FSIZE         1
1806 #   define RLIMIT_DATA          2
1807 #   define RLIMIT_STACK         3
1808 #   define RLIMIT_CORE          4
1809 #   define RLIMIT_RSS           5
1810 #   define RLIMIT_NOFILE        6
1811 #  endif /* RLIMIT_CPU */
1812 #  ifndef RLIM_INFINITY
1813 #   define RLIM_INFINITY        0x7fffffff
1814 #  endif /* RLIM_INFINITY */
1815    /*
1816     * old versions of HP/UX counted limits in 512 bytes
1817     */
1818 #  ifndef SIGRTMIN
1819 #   define FILESIZE512
1820 #  endif /* SIGRTMIN */
1821 # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */
1822
1823 # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX)
1824 /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */
1825 /* sh.h.  However, some SVR4 limits are defined in <sys/resource.h>.  Rather */
1826 /* than include both and get warnings, we define the extra SVR4 limits here. */
1827 /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */
1828 /* RLIMIT_VMEM based on it? */
1829 #  ifndef RLIMIT_VMEM
1830 #   define RLIMIT_VMEM  6
1831 #  endif
1832 #  ifndef RLIMIT_AS
1833 #   define RLIMIT_AS    RLIMIT_VMEM
1834 #  endif
1835 # endif /* SYSVREL > 3 && BSDLIMIT */
1836
1837 # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
1838 #  if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM)
1839 #   define RLIMIT_VMEM  RLIMIT_AS
1840 #  endif
1841 /*
1842  * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not
1843  * Linux headers: When the left hand does not know what the right hand does.
1844  */
1845 #  if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME)
1846 #   define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1)
1847 #  endif
1848 # endif
1849
1850 struct limits limits[] =
1851 {
1852 # ifdef RLIMIT_CPU
1853     { RLIMIT_CPU,       "cputime",      1,      "seconds"       },
1854 # endif /* RLIMIT_CPU */
1855
1856 # ifdef RLIMIT_FSIZE
1857 #  ifndef aiws
1858     { RLIMIT_FSIZE,     "filesize",     1024,   "kbytes"        },
1859 #  else
1860     { RLIMIT_FSIZE,     "filesize",     512,    "blocks"        },
1861 #  endif /* aiws */
1862 # endif /* RLIMIT_FSIZE */
1863
1864 # ifdef RLIMIT_DATA
1865     { RLIMIT_DATA,      "datasize",     1024,   "kbytes"        },
1866 # endif /* RLIMIT_DATA */
1867
1868 # ifdef RLIMIT_STACK
1869 #  ifndef aiws
1870     { RLIMIT_STACK,     "stacksize",    1024,   "kbytes"        },
1871 #  else
1872     { RLIMIT_STACK,     "stacksize",    1024 * 1024,    "kbytes"},
1873 #  endif /* aiws */
1874 # endif /* RLIMIT_STACK */
1875
1876 # ifdef RLIMIT_CORE
1877     { RLIMIT_CORE,      "coredumpsize", 1024,   "kbytes"        },
1878 # endif /* RLIMIT_CORE */
1879
1880 # ifdef RLIMIT_RSS
1881     { RLIMIT_RSS,       "memoryuse",    1024,   "kbytes"        },
1882 # endif /* RLIMIT_RSS */
1883
1884 # ifdef RLIMIT_UMEM
1885     { RLIMIT_UMEM,      "memoryuse",    1024,   "kbytes"        },
1886 # endif /* RLIMIT_UMEM */
1887
1888 # ifdef RLIMIT_VMEM
1889     { RLIMIT_VMEM,      "vmemoryuse",   1024,   "kbytes"        },
1890 # endif /* RLIMIT_VMEM */
1891
1892 # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */
1893     { RLIMIT_HEAP,      "heapsize",     1024,   "kbytes"        },
1894 # endif /* RLIMIT_HEAP */
1895
1896 # ifdef RLIMIT_NOFILE
1897     { RLIMIT_NOFILE,    "descriptors", 1,       ""              },
1898 # endif /* RLIMIT_NOFILE */
1899
1900 # ifdef RLIMIT_NPTS
1901     { RLIMIT_NPTS,      "pseudoterminals", 1,   ""              },
1902 # endif /* RLIMIT_NPTS */
1903
1904 # ifdef RLIMIT_KQUEUES
1905     { RLIMIT_KQUEUES,   "kqueues",      1,      ""              },
1906 # endif /* RLIMIT_KQUEUES */
1907
1908 # ifdef RLIMIT_CONCUR
1909     { RLIMIT_CONCUR,    "concurrency", 1,       "thread(s)"     },
1910 # endif /* RLIMIT_CONCUR */
1911
1912 # ifdef RLIMIT_MEMLOCK
1913     { RLIMIT_MEMLOCK,   "memorylocked", 1024,   "kbytes"        },
1914 # endif /* RLIMIT_MEMLOCK */
1915
1916 # ifdef RLIMIT_NPROC
1917     { RLIMIT_NPROC,     "maxproc",      1,      ""              },
1918 # endif /* RLIMIT_NPROC */
1919
1920 # ifdef RLIMIT_NTHR
1921     { RLIMIT_NTHR,      "maxthread",    1,      ""              },
1922 # endif /* RLIMIT_NTHR */
1923
1924 # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE)
1925     { RLIMIT_OFILE,     "openfiles",    1,      ""              },
1926 # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */
1927
1928 # ifdef RLIMIT_SBSIZE
1929     { RLIMIT_SBSIZE,    "sbsize",       1,      ""              },
1930 # endif /* RLIMIT_SBSIZE */
1931
1932 # ifdef RLIMIT_SWAP
1933     { RLIMIT_SWAP,      "swapsize",     1024,   "kbytes"        },
1934 # endif /* RLIMIT_SWAP */
1935
1936 # ifdef RLIMIT_LOCKS
1937     { RLIMIT_LOCKS,     "maxlocks",     1,      ""              },
1938 # endif /* RLIMIT_LOCKS */
1939
1940 # ifdef RLIMIT_POSIXLOCKS
1941     { RLIMIT_POSIXLOCKS,"posixlocks",   1,      ""              },
1942 # endif /* RLIMIT_POSIXLOCKS */
1943
1944 # ifdef RLIMIT_SIGPENDING
1945     { RLIMIT_SIGPENDING,"maxsignal",    1,      ""              },
1946 # endif /* RLIMIT_SIGPENDING */
1947
1948 # ifdef RLIMIT_MSGQUEUE
1949     { RLIMIT_MSGQUEUE,  "maxmessage",   1,      ""              },
1950 # endif /* RLIMIT_MSGQUEUE */
1951
1952 # ifdef RLIMIT_NICE
1953     { RLIMIT_NICE,      "maxnice",      1,      ""              },
1954 # endif /* RLIMIT_NICE */
1955
1956 # ifdef RLIMIT_RTPRIO
1957     { RLIMIT_RTPRIO,    "maxrtprio",    1,      ""              },
1958 # endif /* RLIMIT_RTPRIO */
1959
1960 # ifdef RLIMIT_RTTIME
1961     { RLIMIT_RTTIME,    "maxrttime",    1,      "usec"          },
1962 # endif /* RLIMIT_RTTIME */
1963
1964     { -1,               NULL,           0,      NULL            }
1965 };
1966
1967 static struct limits *findlim   (Char *);
1968 static RLIM_TYPE getval         (struct limits *, Char **);
1969 static int strtail              (Char *, const char *);
1970 static void limtail             (Char *, const char *);
1971 static void limtail2            (Char *, const char *, const char *);
1972 static void plim                (struct limits *, int);
1973 static int setlim               (struct limits *, int, RLIM_TYPE);
1974
1975 #ifdef convex
1976 static  RLIM_TYPE
1977 restrict_limit(double value)
1978 {
1979     /*
1980      * is f too large to cope with? return the maximum or minimum int
1981      */
1982     if (value > (double) INT_MAX)
1983         return (RLIM_TYPE) INT_MAX;
1984     else if (value < (double) INT_MIN)
1985         return (RLIM_TYPE) INT_MIN;
1986     else
1987         return (RLIM_TYPE) value;
1988 }
1989 #else /* !convex */
1990 # define restrict_limit(x)      ((RLIM_TYPE) (x))
1991 #endif /* convex */
1992
1993
1994 static struct limits *
1995 findlim(Char *cp)
1996 {
1997     struct limits *lp, *res;
1998
1999     res = NULL;
2000     for (lp = limits; lp->limconst >= 0; lp++)
2001         if (prefix(cp, str2short(lp->limname))) {
2002             if (res)
2003                 stderror(ERR_NAME | ERR_AMBIG);
2004             res = lp;
2005         }
2006     if (res)
2007         return (res);
2008     stderror(ERR_NAME | ERR_LIMIT);
2009     /* NOTREACHED */
2010     return (0);
2011 }
2012
2013 /*ARGSUSED*/
2014 void
2015 dolimit(Char **v, struct command *c)
2016 {
2017     struct limits *lp;
2018     RLIM_TYPE limit;
2019     int    hard = 0;
2020
2021     USE(c);
2022     v++;
2023     if (*v && eq(*v, STRmh)) {
2024         hard = 1;
2025         v++;
2026     }
2027     if (*v == 0) {
2028         for (lp = limits; lp->limconst >= 0; lp++)
2029             plim(lp, hard);
2030         return;
2031     }
2032     lp = findlim(v[0]);
2033     if (v[1] == 0) {
2034         plim(lp, hard);
2035         return;
2036     }
2037     limit = getval(lp, v + 1);
2038     if (setlim(lp, hard, limit) < 0)
2039         stderror(ERR_SILENT);
2040 }
2041
2042 static  RLIM_TYPE
2043 getval(struct limits *lp, Char **v)
2044 {
2045     float f;
2046     Char   *cp = *v++;
2047
2048     f = atof(short2str(cp));
2049
2050 # ifdef convex
2051     /*
2052      * is f too large to cope with. limit f to minint, maxint  - X-6768 by
2053      * strike
2054      */
2055     if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) {
2056         stderror(ERR_NAME | ERR_TOOLARGE);
2057     }
2058 # endif /* convex */
2059
2060     while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
2061         cp++;
2062     if (*cp == 0) {
2063         if (*v == 0)
2064             return restrict_limit((f * lp->limdiv) + 0.5);
2065         cp = *v;
2066     }
2067     switch (*cp) {
2068 # ifdef RLIMIT_CPU
2069     case ':':
2070         if (lp->limconst != RLIMIT_CPU)
2071             goto badscal;
2072         return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1))));
2073     case 'h':
2074         if (lp->limconst != RLIMIT_CPU)
2075             goto badscal;
2076         limtail(cp, "hours");
2077         f *= 3600.0;
2078         break;
2079 # endif /* RLIMIT_CPU */
2080     case 'm':
2081 # ifdef RLIMIT_CPU
2082         if (lp->limconst == RLIMIT_CPU) {
2083             limtail(cp, "minutes");
2084             f *= 60.0;
2085             break;
2086         }
2087 # endif /* RLIMIT_CPU */
2088         limtail2(cp, "megabytes", "mbytes");
2089         f *= 1024.0 * 1024.0;
2090         break;
2091 # ifdef RLIMIT_CPU
2092     case 's':
2093         if (lp->limconst != RLIMIT_CPU)
2094             goto badscal;
2095         limtail(cp, "seconds");
2096         break;
2097 # endif /* RLIMIT_CPU */
2098     case 'G':
2099         *cp = 'g';
2100         /*FALLTHROUGH*/
2101     case 'g':
2102 # ifdef RLIMIT_CPU
2103         if (lp->limconst == RLIMIT_CPU)
2104             goto badscal;
2105 # endif /* RLIMIT_CPU */
2106         limtail2(cp, "gigabytes", "gbytes");
2107         f *= 1024.0 * 1024.0 * 1024.0;
2108         break;
2109     case 'M':
2110 # ifdef RLIMIT_CPU
2111         if (lp->limconst == RLIMIT_CPU)
2112             goto badscal;
2113 # endif /* RLIMIT_CPU */
2114         *cp = 'm';
2115         limtail2(cp, "megabytes", "mbytes");
2116         f *= 1024.0 * 1024.0;
2117         break;
2118     case 'k':
2119 # ifdef RLIMIT_CPU
2120         if (lp->limconst == RLIMIT_CPU)
2121             goto badscal;
2122 # endif /* RLIMIT_CPU */
2123         limtail2(cp, "kilobytes", "kbytes");
2124         f *= 1024.0;
2125         break;
2126     case 'b':
2127 # ifdef RLIMIT_CPU
2128         if (lp->limconst == RLIMIT_CPU)
2129             goto badscal;
2130 # endif /* RLIMIT_CPU */
2131         limtail(cp, "blocks");
2132         f *= 512.0;
2133         break;
2134     case 'u':
2135         limtail(cp, "unlimited");
2136         return ((RLIM_TYPE) RLIM_INFINITY);
2137     default:
2138 # ifdef RLIMIT_CPU
2139 badscal:
2140 # endif /* RLIMIT_CPU */
2141         stderror(ERR_NAME | ERR_SCALEF);
2142     }
2143 # ifdef convex
2144     return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5));
2145 # else
2146     f += 0.5;
2147     if (f > (float) ((RLIM_TYPE) RLIM_INFINITY))
2148         return ((RLIM_TYPE) RLIM_INFINITY);
2149     else
2150         return ((RLIM_TYPE) f);
2151 # endif /* convex */
2152 }
2153
2154 static int
2155 strtail(Char *cp, const char *str)
2156 {
2157     while (*cp && *cp == (Char)*str)
2158         cp++, str++;
2159     return (*cp != '\0');
2160 }
2161
2162 static void
2163 limtail(Char *cp, const char *str)
2164 {
2165     if (strtail(cp, str))
2166         stderror(ERR_BADSCALE, str);
2167 }
2168
2169 static void
2170 limtail2(Char *cp, const char *str1, const char *str2)
2171 {
2172     if (strtail(cp, str1) && strtail(cp, str2))
2173         stderror(ERR_BADSCALE, str1);
2174 }
2175
2176 /*ARGSUSED*/
2177 static void
2178 plim(struct limits *lp, int hard)
2179 {
2180 # ifdef BSDLIMIT
2181     struct rlimit rlim;
2182 # endif /* BSDLIMIT */
2183     RLIM_TYPE limit;
2184     int     xdiv = lp->limdiv;
2185
2186     xprintf("%-13.13s", lp->limname);
2187
2188 # ifndef BSDLIMIT
2189     limit = ulimit(lp->limconst, 0);
2190 #  ifdef aiws
2191     if (lp->limconst == RLIMIT_DATA)
2192         limit -= 0x20000000;
2193 #  endif /* aiws */
2194 # else /* BSDLIMIT */
2195     (void) getrlimit(lp->limconst, &rlim);
2196     limit = hard ? rlim.rlim_max : rlim.rlim_cur;
2197 # endif /* BSDLIMIT */
2198
2199 # if !defined(BSDLIMIT) || defined(FILESIZE512)
2200     /*
2201      * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024
2202      * blocks. Note we cannot pre-multiply cause we might overflow (A/UX)
2203      */
2204     if (lp->limconst == RLIMIT_FSIZE) {
2205         if (limit >= (RLIM_INFINITY / 512))
2206             limit = RLIM_INFINITY;
2207         else
2208             xdiv = (xdiv == 1024 ? 2 : 1);
2209     }
2210 # endif /* !BSDLIMIT || FILESIZE512 */
2211
2212     if (limit == RLIM_INFINITY)
2213         xprintf("unlimited");
2214     else
2215 # if defined(RLIMIT_CPU) && defined(_OSD_POSIX)
2216     if (lp->limconst == RLIMIT_CPU &&
2217         (unsigned long)limit >= 0x7ffffffdUL)
2218         xprintf("unlimited");
2219     else
2220 # endif
2221 # ifdef RLIMIT_CPU
2222     if (lp->limconst == RLIMIT_CPU)
2223         psecs(limit);
2224     else
2225 # endif /* RLIMIT_CPU */
2226         xprintf("%ld %s", (long) (limit / xdiv), lp->limscale);
2227     xputchar('\n');
2228 }
2229
2230 /*ARGSUSED*/
2231 void
2232 dounlimit(Char **v, struct command *c)
2233 {
2234     struct limits *lp;
2235     int    lerr = 0;
2236     int    hard = 0;
2237     int    force = 0;
2238
2239     USE(c);
2240     while (*++v && **v == '-') {
2241         Char   *vp = *v;
2242         while (*++vp)
2243             switch (*vp) {
2244             case 'f':
2245                 force = 1;
2246                 break;
2247             case 'h':
2248                 hard = 1;
2249                 break;
2250             default:
2251                 stderror(ERR_ULIMUS);
2252                 break;
2253             }
2254     }
2255
2256     if (*v == 0) {
2257         for (lp = limits; lp->limconst >= 0; lp++)
2258             if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
2259                 lerr++;
2260         if (!force && lerr)
2261             stderror(ERR_SILENT);
2262         return;
2263     }
2264     while (*v) {
2265         lp = findlim(*v++);
2266         if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force)
2267             stderror(ERR_SILENT);
2268     }
2269 }
2270
2271 static int
2272 setlim(struct limits *lp, int hard, RLIM_TYPE limit)
2273 {
2274 # ifdef BSDLIMIT
2275     struct rlimit rlim;
2276
2277     (void) getrlimit(lp->limconst, &rlim);
2278
2279 #  ifdef FILESIZE512
2280     /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */
2281     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2282         limit /= 512;
2283 #  endif /* FILESIZE512 */
2284     if (hard)
2285         rlim.rlim_max = limit;
2286     else if (limit == RLIM_INFINITY && euid != 0)
2287         rlim.rlim_cur = rlim.rlim_max;
2288     else
2289         rlim.rlim_cur = limit;
2290
2291     if (rlim.rlim_cur > rlim.rlim_max)
2292         rlim.rlim_max = rlim.rlim_cur;
2293
2294     if (setrlimit(lp->limconst, &rlim) < 0) {
2295 # else /* BSDLIMIT */
2296     if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE)
2297         limit /= 512;
2298 # ifdef aiws
2299     if (lp->limconst == RLIMIT_DATA)
2300         limit += 0x20000000;
2301 # endif /* aiws */
2302     if (ulimit(toset(lp->limconst), limit) < 0) {
2303 # endif /* BSDLIMIT */
2304         int err;
2305         char *op, *type;
2306
2307         err = errno;
2308         op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") :
2309                         CGETS(15, 3, "set"));
2310         cleanup_push(op, xfree);
2311         type = strsave(hard ? CGETS(15, 4, " hard") : "");
2312         cleanup_push(type, xfree);
2313         xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname,
2314             lp->limname, op, type, strerror(err));
2315         cleanup_until(op);
2316         return (-1);
2317     }
2318     return (0);
2319 }
2320
2321 #endif /* !HAVENOLIMIT */
2322
2323 /*ARGSUSED*/
2324 void
2325 dosuspend(Char **v, struct command *c)
2326 {
2327 #ifdef BSDJOBS
2328     struct sigaction old;
2329 #endif /* BSDJOBS */
2330
2331     USE(c);
2332     USE(v);
2333
2334     if (loginsh)
2335         stderror(ERR_SUSPLOG);
2336     untty();
2337
2338 #ifdef BSDJOBS
2339     sigaction(SIGTSTP, NULL, &old);
2340     signal(SIGTSTP, SIG_DFL);
2341     (void) kill(0, SIGTSTP);
2342     /* the shell stops here */
2343     sigaction(SIGTSTP, &old, NULL);
2344 #else /* !BSDJOBS */
2345     stderror(ERR_JOBCONTROL);
2346 #endif /* BSDJOBS */
2347
2348 #ifdef BSDJOBS
2349     if (tpgrp != -1) {
2350         if (grabpgrp(FSHTTY, opgrp) == -1)
2351             stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno));
2352         (void) setpgid(0, shpgrp);
2353         (void) tcsetpgrp(FSHTTY, shpgrp);
2354     }
2355 #endif /* BSDJOBS */
2356     (void) setdisc(FSHTTY);
2357 }
2358
2359 /* This is the dreaded EVAL built-in.
2360  *   If you don't fiddle with file descriptors, and reset didfds,
2361  *   this command will either ignore redirection inside or outside
2362  *   its arguments, e.g. eval "date >x"  vs.  eval "date" >x
2363  *   The stuff here seems to work, but I did it by trial and error rather
2364  *   than really knowing what was going on.  If tpgrp is zero, we are
2365  *   probably a background eval, e.g. "eval date &", and we want to
2366  *   make sure that any processes we start stay in our pgrp.
2367  *   This is also the case for "time eval date" -- stay in same pgrp.
2368  *   Otherwise, under stty tostop, processes will stop in the wrong
2369  *   pgrp, with no way for the shell to get them going again.  -IAN!
2370  */
2371
2372 struct doeval_state
2373 {
2374     Char **evalvec, *evalp;
2375     int didfds;
2376 #ifndef CLOSE_ON_EXEC
2377     int didcch;
2378 #endif
2379     int saveIN, saveOUT, saveDIAG;
2380     int SHIN, SHOUT, SHDIAG;
2381 };
2382
2383 static void
2384 doeval_cleanup(void *xstate)
2385 {
2386     struct doeval_state *state;
2387
2388     state = xstate;
2389     evalvec = state->evalvec;
2390     evalp = state->evalp;
2391     doneinp = 0;
2392 #ifndef CLOSE_ON_EXEC
2393     didcch = state->didcch;
2394 #endif /* CLOSE_ON_EXEC */
2395     didfds = state->didfds;
2396     if (state->saveIN != SHIN)
2397         xclose(SHIN);
2398     if (state->saveOUT != SHOUT)
2399         xclose(SHOUT);
2400     if (state->saveDIAG != SHDIAG)
2401         xclose(SHDIAG);
2402     close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1);
2403     close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1);
2404     close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1);
2405     if (didfds) {
2406         close_on_exec(dcopy(SHIN, 0), 1);
2407         close_on_exec(dcopy(SHOUT, 1), 1);
2408         close_on_exec(dcopy(SHDIAG, 2), 1);
2409     }
2410 }
2411
2412 static Char **Ggv;
2413 /*ARGSUSED*/
2414 void
2415 doeval(Char **v, struct command *c)
2416 {
2417     struct doeval_state state;
2418     int gflag, my_reenter;
2419     Char **gv;
2420     jmp_buf_t osetexit;
2421
2422     USE(c);
2423     v++;
2424     if (*v == 0)
2425         return;
2426     gflag = tglob(v);
2427     if (gflag) {
2428         gv = v = globall(v, gflag);
2429         if (v == 0)
2430             stderror(ERR_NOMATCH);
2431         cleanup_push(gv, blk_cleanup);
2432         v = copyblk(v);
2433     }
2434     else {
2435         gv = NULL;
2436         v = copyblk(v);
2437         trim(v);
2438     }
2439
2440     Ggv = gv;
2441     state.evalvec = evalvec;
2442     state.evalp = evalp;
2443     state.didfds = didfds;
2444 #ifndef CLOSE_ON_EXEC
2445     state.didcch = didcch;
2446 #endif /* CLOSE_ON_EXEC */
2447     state.SHIN = SHIN;
2448     state.SHOUT = SHOUT;
2449     state.SHDIAG = SHDIAG;
2450
2451     (void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1);
2452     (void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1);
2453     (void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1);
2454
2455     cleanup_push(&state, doeval_cleanup);
2456
2457     getexit(osetexit);
2458
2459     /* PWP: setjmp/longjmp bugfix for optimizing compilers */
2460 #ifdef cray
2461     my_reenter = 1;             /* assume non-zero return val */
2462     if (setexit() == 0) {
2463         my_reenter = 0;         /* Oh well, we were wrong */
2464 #else /* !cray */
2465     if ((my_reenter = setexit()) == 0) {
2466 #endif /* cray */
2467         evalvec = v;
2468         evalp = 0;
2469         (void)close_on_exec(SHIN = dcopy(0, -1), 1);
2470         (void)close_on_exec(SHOUT = dcopy(1, -1), 1);
2471         (void)close_on_exec(SHDIAG = dcopy(2, -1), 1);
2472 #ifndef CLOSE_ON_EXEC
2473         didcch = 0;
2474 #endif /* CLOSE_ON_EXEC */
2475         didfds = 0;
2476         gv = Ggv;
2477         process(0);
2478         Ggv = gv;
2479     }
2480
2481     if (my_reenter == 0) {
2482         cleanup_until(&state);
2483         if (Ggv)
2484             cleanup_until(Ggv);
2485     }
2486
2487     resexit(osetexit);
2488     if (my_reenter)
2489         stderror(ERR_SILENT);
2490 }
2491
2492 /*************************************************************************/
2493 /* print list of builtin commands */
2494
2495 static void
2496 lbuffed_cleanup (void *dummy)
2497 {
2498     USE(dummy);
2499     lbuffed = 1;
2500 }
2501
2502 /*ARGSUSED*/
2503 void
2504 dobuiltins(Char **v, struct command *c)
2505 {
2506     /* would use print_by_column() in tw.parse.c but that assumes
2507      * we have an array of Char * to pass.. (sg)
2508      */
2509     const struct biltins *b;
2510     int row, col, columns, rows;
2511     unsigned int w, maxwidth;
2512
2513     USE(c);
2514     USE(v);
2515     lbuffed = 0;                /* turn off line buffering */
2516     cleanup_push(&lbuffed, lbuffed_cleanup);
2517
2518     /* find widest string */
2519     for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b)
2520         maxwidth = max(maxwidth, strlen(b->bname));
2521     ++maxwidth;                                 /* for space */
2522
2523     columns = (TermH + 1) / maxwidth;   /* PWP: terminal size change */
2524     if (!columns)
2525         columns = 1;
2526     rows = (nbfunc + (columns - 1)) / columns;
2527
2528     for (b = bfunc, row = 0; row < rows; row++) {
2529         for (col = 0; col < columns; col++) {
2530             if (b < &bfunc[nbfunc]) {
2531                 w = strlen(b->bname);
2532                 xprintf("%s", b->bname);
2533                 if (col < (columns - 1))        /* Not last column? */
2534                     for (; w < maxwidth; w++)
2535                         xputchar(' ');
2536                 ++b;
2537             }
2538         }
2539         if (row < (rows - 1)) {
2540             if (Tty_raw_mode)
2541                 xputchar('\r');
2542             xputchar('\n');
2543         }
2544     }
2545 #ifdef WINNT_NATIVE
2546     nt_print_builtins(maxwidth);
2547 #else
2548     if (Tty_raw_mode)
2549         xputchar('\r');
2550     xputchar('\n');
2551 #endif /* WINNT_NATIVE */
2552
2553     cleanup_until(&lbuffed);            /* turn back on line buffering */
2554     flush();
2555 }
2556
2557 #ifdef NLS_CATALOGS
2558 char *
2559 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2560 {
2561     char *res;
2562
2563     errno = 0;
2564     while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) {
2565         handle_pending_signals();
2566         errno = 0;
2567     }
2568     return res;
2569 }
2570
2571
2572 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2573 char *
2574 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s)
2575 {
2576     static char *buf = NULL;
2577     static size_t buf_size = 0;
2578
2579     char *orig, *dest, *p;
2580     ICONV_CONST char *src;
2581     size_t src_size, dest_size;
2582
2583     orig = xcatgets(ctd, set_id, msg_id, s);
2584     if (catgets_iconv == (iconv_t)-1 || orig == s)
2585         return orig;
2586     src = orig;
2587     src_size = strlen(src) + 1;
2588     if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL)
2589         return orig;
2590     dest = buf;
2591     while (src_size != 0) {
2592         dest_size = buf + buf_size - dest;
2593         if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size)
2594             == (size_t)-1) {
2595             switch (errno) {
2596             case E2BIG:
2597                 if ((p = xrealloc(buf, buf_size * 2)) == NULL)
2598                     return orig;
2599                 buf_size *= 2;
2600                 dest = p + (dest - buf);
2601                 buf = p;
2602                 break;
2603
2604             case EILSEQ: case EINVAL: default:
2605                 return orig;
2606             }
2607         }
2608     }
2609     return buf;
2610 }
2611 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2612 #endif /* NLS_CATALOGS */
2613
2614 void
2615 nlsinit(void)
2616 {
2617 #ifdef NLS_CATALOGS
2618     static const char default_catalog[] = "tcsh";
2619
2620     char *catalog = (char *)(intptr_t)default_catalog;
2621
2622     if (adrof(STRcatalog) != NULL)
2623         catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog)));
2624 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */
2625     /*
2626      * Check if LC_MESSAGES is set in the environment and use it, if so.
2627      * If not, fall back to the setting of LANG.
2628      */
2629     catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0);
2630 #else /* pre-POSIX */
2631 # ifndef MCLoadBySet
2632 #  define MCLoadBySet 0
2633 #  endif
2634     catd = catopen(catalog, MCLoadBySet);
2635 #endif
2636     if (catalog != default_catalog)
2637         xfree(catalog);
2638 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2639     /* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */
2640     catgets_iconv = iconv_open (nl_langinfo (CODESET),
2641                                 xcatgets(catd, 255, 1, "UTF-8"));
2642 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2643 #endif /* NLS_CATALOGS */
2644 #ifdef WINNT_NATIVE
2645     nls_dll_init();
2646 #endif /* WINNT_NATIVE */
2647     errinit();          /* init the errorlist in correct locale */
2648     mesginit();         /* init the messages for signals */
2649     dateinit();         /* init the messages for dates */
2650     editinit();         /* init the editor messages */
2651     terminit();         /* init the termcap messages */
2652 }
2653
2654 void
2655 nlsclose(void)
2656 {
2657 #ifdef NLS_CATALOGS
2658 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO)
2659     if (catgets_iconv != (iconv_t)-1) {
2660         iconv_close(catgets_iconv);
2661         catgets_iconv = (iconv_t)-1;
2662     }
2663 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */
2664     if (catd != (nl_catd)-1) {
2665         /*
2666          * catclose can call other functions which can call longjmp
2667          * making us re-enter this code. Prevent infinite recursion
2668          * by resetting catd. Problem reported and solved by:
2669          * Gerhard Niklasch
2670          */
2671         nl_catd oldcatd = catd;
2672         catd = (nl_catd)-1;
2673         while (catclose(oldcatd) == -1 && errno == EINTR)
2674             handle_pending_signals();
2675     }
2676 #endif /* NLS_CATALOGS */
2677 }
2678
2679 int
2680 getYN(const char *prompt)
2681 {
2682     int doit;
2683     char c;
2684
2685     xprintf("%s", prompt);
2686     flush();
2687     (void) force_read(SHIN, &c, sizeof(c));
2688     /*
2689      * Perhaps we should use the yesexpr from the
2690      * actual locale
2691      */
2692     doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
2693     while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c))
2694         continue;
2695     return doit;
2696 }