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, 0); 231 cleanup_push(res, xfree); 232 xprintf("%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 setv(STRstatus, putn(expr(&v)), VAR_READWRITE); 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 *cp, **globbed = NULL; 1203 int nonl = 0; 1204 int echo_style = ECHO_STYLE; 1205 struct varent *vp; 1206 1207 if ((vp = adrof(STRecho_style)) != NULL && vp->vec != NULL && 1208 vp->vec[0] != NULL) { 1209 if (Strcmp(vp->vec[0], STRbsd) == 0) 1210 echo_style = BSD_ECHO; 1211 else if (Strcmp(vp->vec[0], STRsysv) == 0) 1212 echo_style = SYSV_ECHO; 1213 else if (Strcmp(vp->vec[0], STRboth) == 0) 1214 echo_style = BOTH_ECHO; 1215 else if (Strcmp(vp->vec[0], STRnone) == 0) 1216 echo_style = NONE_ECHO; 1217 } 1218 1219 v++; 1220 if (*v == 0) 1221 goto done; 1222 if (setintr) { 1223 int old_pintr_disabled; 1224 pintr_push_enable(&old_pintr_disabled); 1225 v = glob_all_or_error(v); 1226 cleanup_until(&old_pintr_disabled); 1227 } else { 1228 v = glob_all_or_error(v); 1229 } 1230 globbed = v; 1231 if (globbed != NULL) 1232 cleanup_push(globbed, blk_cleanup); 1233 1234 if ((echo_style & BSD_ECHO) != 0 && sep == ' ' && *v && eq(*v, STRmn)) 1235 nonl++, v++; 1236 1237 while ((cp = *v++) != 0) { 1238 Char c; 1239 1240 if (setintr) { 1241 int old_pintr_disabled; 1242 1243 pintr_push_enable(&old_pintr_disabled); 1244 cleanup_until(&old_pintr_disabled); 1245 } 1246 while ((c = *cp++) != 0) { 1247 if ((echo_style & SYSV_ECHO) != 0 && c == '\\') { 1248 switch (c = *cp++) { 1249 case 'a': 1250 c = '\a'; 1251 break; 1252 case 'b': 1253 c = '\b'; 1254 break; 1255 case 'c': 1256 nonl = 1; 1257 goto done; 1258 case 'e': 1259 #if 0 /* Windows does not understand \e */ 1260 c = '\e'; 1261 #else 1262 c = CTL_ESC('\033'); 1263 #endif 1264 break; 1265 case 'f': 1266 c = '\f'; 1267 break; 1268 case 'n': 1269 c = '\n'; 1270 break; 1271 case 'r': 1272 c = '\r'; 1273 break; 1274 case 't': 1275 c = '\t'; 1276 break; 1277 case 'v': 1278 c = '\v'; 1279 break; 1280 case '\\': 1281 c = '\\'; 1282 break; 1283 case '0': 1284 c = 0; 1285 if (*cp >= '0' && *cp < '8') 1286 c = c * 8 + *cp++ - '0'; 1287 if (*cp >= '0' && *cp < '8') 1288 c = c * 8 + *cp++ - '0'; 1289 if (*cp >= '0' && *cp < '8') 1290 c = c * 8 + *cp++ - '0'; 1291 break; 1292 case '\0': 1293 c = '\\'; 1294 cp--; 1295 break; 1296 default: 1297 xputchar('\\' | QUOTE); 1298 break; 1299 } 1300 } 1301 xputwchar(c | QUOTE); 1302 1303 } 1304 if (*v) 1305 xputchar(sep | QUOTE); 1306 } 1307 done: 1308 if (sep && nonl == 0) 1309 xputchar('\n'); 1310 else 1311 flush(); 1312 if (globbed != NULL) 1313 cleanup_until(globbed); 1314 } 1315 1316 /* check whether an environment variable should invoke 'set_locale()' */ 1317 static int 1318 islocale_var(Char *var) 1319 { 1320 static Char *locale_vars[] = { 1321 STRLANG, STRLC_ALL, STRLC_CTYPE, STRLC_NUMERIC, 1322 STRLC_TIME, STRLC_COLLATE, STRLC_MESSAGES, STRLC_MONETARY, 0 1323 }; 1324 Char **v; 1325 1326 for (v = locale_vars; *v; ++v) 1327 if (eq(var, *v)) 1328 return 1; 1329 return 0; 1330 } 1331 1332 static void 1333 xlate_cr_cleanup(void *dummy) 1334 { 1335 USE(dummy); 1336 xlate_cr = 0; 1337 } 1338 1339 /*ARGSUSED*/ 1340 void 1341 doprintenv(Char **v, struct command *c) 1342 { 1343 Char *e; 1344 1345 USE(c); 1346 v++; 1347 if (*v == 0) { 1348 Char **ep; 1349 1350 xlate_cr = 1; 1351 cleanup_push(&xlate_cr, xlate_cr_cleanup); 1352 for (ep = STR_environ; *ep; ep++) { 1353 if (setintr) { 1354 int old_pintr_disabled; 1355 1356 pintr_push_enable(&old_pintr_disabled); 1357 cleanup_until(&old_pintr_disabled); 1358 } 1359 xprintf("%S\n", *ep); 1360 } 1361 cleanup_until(&xlate_cr); 1362 } 1363 else if ((e = tgetenv(*v)) != NULL) { 1364 int old_output_raw; 1365 1366 old_output_raw = output_raw; 1367 output_raw = 1; 1368 cleanup_push(&old_output_raw, output_raw_restore); 1369 xprintf("%S\n", e); 1370 cleanup_until(&old_output_raw); 1371 } 1372 else 1373 setcopy(STRstatus, STR1, VAR_READWRITE); 1374 } 1375 1376 /* from "Karl Berry." <karl%mote.umb.edu@relay.cs.net> -- for NeXT things 1377 (and anything else with a modern compiler) */ 1378 1379 /*ARGSUSED*/ 1380 void 1381 dosetenv(Char **v, struct command *c) 1382 { 1383 Char *vp, *lp; 1384 1385 USE(c); 1386 if (*++v == 0) { 1387 doprintenv(--v, 0); 1388 return; 1389 } 1390 1391 vp = *v++; 1392 lp = vp; 1393 1394 if (!letter(*lp)) 1395 stderror(ERR_NAME | ERR_VARBEGIN); 1396 do { 1397 lp++; 1398 } while (alnum(*lp) || *lp == '.'); 1399 if (*lp != '\0') 1400 stderror(ERR_NAME | ERR_VARALNUM); 1401 1402 if ((lp = *v++) == 0) 1403 lp = STRNULL; 1404 1405 lp = globone(lp, G_APPEND); 1406 cleanup_push(lp, xfree); 1407 tsetenv(vp, lp); 1408 if (eq(vp, STRKPATH)) { 1409 importpath(lp); 1410 dohash(NULL, NULL); 1411 cleanup_until(lp); 1412 return; 1413 } 1414 1415 #ifdef apollo 1416 if (eq(vp, STRSYSTYPE)) { 1417 dohash(NULL, NULL); 1418 cleanup_until(lp); 1419 return; 1420 } 1421 #endif /* apollo */ 1422 1423 /* dspkanji/dspmbyte autosetting */ 1424 /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */ 1425 #if defined(DSPMBYTE) 1426 if(eq(vp, STRLANG) && !adrof(CHECK_MBYTEVAR)) { 1427 autoset_dspmbyte(lp); 1428 } 1429 #endif 1430 1431 if (islocale_var(vp)) { 1432 #ifdef NLS 1433 int k; 1434 1435 # ifdef SETLOCALEBUG 1436 dont_free = 1; 1437 # endif /* SETLOCALEBUG */ 1438 (void) setlocale(LC_ALL, ""); 1439 # ifdef LC_COLLATE 1440 (void) setlocale(LC_COLLATE, ""); 1441 # endif 1442 # ifdef LC_CTYPE 1443 (void) setlocale(LC_CTYPE, ""); /* for iscntrl */ 1444 # endif /* LC_CTYPE */ 1445 # if defined(AUTOSET_KANJI) 1446 autoset_kanji(); 1447 # endif /* AUTOSET_KANJI */ 1448 # ifdef NLS_CATALOGS 1449 # ifdef LC_MESSAGES 1450 (void) setlocale(LC_MESSAGES, ""); 1451 # endif /* LC_MESSAGES */ 1452 nlsclose(); 1453 nlsinit(); 1454 # endif /* NLS_CATALOGS */ 1455 # ifdef SETLOCALEBUG 1456 dont_free = 0; 1457 # endif /* SETLOCALEBUG */ 1458 # ifdef STRCOLLBUG 1459 fix_strcoll_bug(); 1460 # endif /* STRCOLLBUG */ 1461 tw_cmd_free(); /* since the collation sequence has changed */ 1462 for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++) 1463 continue; 1464 AsciiOnly = MB_CUR_MAX == 1 && k > 0377; 1465 #else /* !NLS */ 1466 AsciiOnly = 0; 1467 #endif /* NLS */ 1468 NLSMapsAreInited = 0; 1469 ed_Init(); 1470 if (MapsAreInited && !NLSMapsAreInited) 1471 ed_InitNLSMaps(); 1472 cleanup_until(lp); 1473 return; 1474 } 1475 1476 #ifdef NLS_CATALOGS 1477 if (eq(vp, STRNLSPATH)) { 1478 nlsclose(); 1479 nlsinit(); 1480 } 1481 #endif 1482 1483 if (eq(vp, STRNOREBIND)) { 1484 NoNLSRebind = 1; 1485 MapsAreInited = 0; 1486 NLSMapsAreInited = 0; 1487 ed_InitMaps(); 1488 cleanup_until(lp); 1489 return; 1490 } 1491 #ifdef WINNT_NATIVE 1492 if (eq(vp, STRtcshlang)) { 1493 nlsinit(); 1494 cleanup_until(lp); 1495 return; 1496 } 1497 #endif /* WINNT_NATIVE */ 1498 if (eq(vp, STRKTERM)) { 1499 char *t; 1500 1501 setv(STRterm, quote(lp), VAR_READWRITE); /* lp memory used here */ 1502 cleanup_ignore(lp); 1503 cleanup_until(lp); 1504 t = short2str(lp); 1505 if (noediting && strcmp(t, "unknown") != 0 && strcmp(t,"dumb") != 0) { 1506 editing = 1; 1507 noediting = 0; 1508 setNS(STRedit); 1509 } 1510 GotTermCaps = 0; 1511 ed_Init(); 1512 return; 1513 } 1514 1515 if (eq(vp, STRKHOME)) { 1516 Char *canon; 1517 /* 1518 * convert to canonical pathname (possibly resolving symlinks) 1519 */ 1520 canon = dcanon(lp, lp); 1521 cleanup_ignore(lp); 1522 cleanup_until(lp); 1523 cleanup_push(canon, xfree); 1524 setv(STRhome, quote(canon), VAR_READWRITE); /* lp memory used here */ 1525 cleanup_ignore(canon); 1526 cleanup_until(canon); 1527 1528 /* fix directory stack for new tilde home */ 1529 dtilde(); 1530 return; 1531 } 1532 1533 if (eq(vp, STRKSHLVL)) { 1534 setv(STRshlvl, quote(lp), VAR_READWRITE); /* lp memory used here */ 1535 cleanup_ignore(lp); 1536 cleanup_until(lp); 1537 return; 1538 } 1539 1540 if (eq(vp, STRKUSER)) { 1541 setv(STRuser, quote(lp), VAR_READWRITE); /* lp memory used here */ 1542 cleanup_ignore(lp); 1543 cleanup_until(lp); 1544 return; 1545 } 1546 1547 if (eq(vp, STRKGROUP)) { 1548 setv(STRgroup, quote(lp), VAR_READWRITE); /* lp memory used here */ 1549 cleanup_ignore(lp); 1550 cleanup_until(lp); 1551 return; 1552 } 1553 1554 #ifdef COLOR_LS_F 1555 if (eq(vp, STRLS_COLORS)) { 1556 parseLS_COLORS(lp); 1557 cleanup_until(lp); 1558 return; 1559 } 1560 if (eq(vp, STRLSCOLORS)) { 1561 parseLSCOLORS(lp); 1562 cleanup_until(lp); 1563 return; 1564 } 1565 #endif /* COLOR_LS_F */ 1566 1567 #ifdef SIG_WINDOW 1568 /* 1569 * Load/Update $LINES $COLUMNS 1570 */ 1571 if ((eq(lp, STRNULL) && (eq(vp, STRLINES) || eq(vp, STRCOLUMNS))) || 1572 eq(vp, STRTERMCAP)) { 1573 cleanup_until(lp); 1574 check_window_size(1); 1575 return; 1576 } 1577 1578 /* 1579 * Change the size to the one directed by $LINES and $COLUMNS 1580 */ 1581 if (eq(vp, STRLINES) || eq(vp, STRCOLUMNS)) { 1582 #if 0 1583 GotTermCaps = 0; 1584 #endif 1585 cleanup_until(lp); 1586 ed_Init(); 1587 return; 1588 } 1589 #endif /* SIG_WINDOW */ 1590 cleanup_until(lp); 1591 } 1592 1593 /*ARGSUSED*/ 1594 void 1595 dounsetenv(Char **v, struct command *c) 1596 { 1597 Char **ep, *p, *n, *name; 1598 int i, maxi; 1599 1600 USE(c); 1601 /* 1602 * Find the longest environment variable 1603 */ 1604 for (maxi = 0, ep = STR_environ; *ep; ep++) { 1605 for (i = 0, p = *ep; *p && *p != '='; p++, i++) 1606 continue; 1607 if (i > maxi) 1608 maxi = i; 1609 } 1610 1611 name = xmalloc((maxi + 1) * sizeof(Char)); 1612 cleanup_push(name, xfree); 1613 1614 while (++v && *v) 1615 for (maxi = 1; maxi;) 1616 for (maxi = 0, ep = STR_environ; *ep; ep++) { 1617 for (n = name, p = *ep; *p && *p != '='; *n++ = *p++) 1618 continue; 1619 *n = '\0'; 1620 if (!Gmatch(name, *v)) 1621 continue; 1622 maxi = 1; 1623 1624 /* Unset the name. This wasn't being done until 1625 * later but most of the stuff following won't 1626 * work (particularly the setlocale() and getenv() 1627 * stuff) as intended until the name is actually 1628 * removed. (sg) 1629 */ 1630 Unsetenv(name); 1631 1632 if (eq(name, STRNOREBIND)) { 1633 NoNLSRebind = 0; 1634 MapsAreInited = 0; 1635 NLSMapsAreInited = 0; 1636 ed_InitMaps(); 1637 } 1638 #ifdef apollo 1639 else if (eq(name, STRSYSTYPE)) 1640 dohash(NULL, NULL); 1641 #endif /* apollo */ 1642 else if (islocale_var(name)) { 1643 #ifdef NLS 1644 int k; 1645 1646 # ifdef SETLOCALEBUG 1647 dont_free = 1; 1648 # endif /* SETLOCALEBUG */ 1649 (void) setlocale(LC_ALL, ""); 1650 # ifdef LC_COLLATE 1651 (void) setlocale(LC_COLLATE, ""); 1652 # endif 1653 # ifdef LC_CTYPE 1654 (void) setlocale(LC_CTYPE, ""); /* for iscntrl */ 1655 # endif /* LC_CTYPE */ 1656 # ifdef NLS_CATALOGS 1657 # ifdef LC_MESSAGES 1658 (void) setlocale(LC_MESSAGES, ""); 1659 # endif /* LC_MESSAGES */ 1660 nlsclose(); 1661 nlsinit(); 1662 # endif /* NLS_CATALOGS */ 1663 # ifdef SETLOCALEBUG 1664 dont_free = 0; 1665 # endif /* SETLOCALEBUG */ 1666 # ifdef STRCOLLBUG 1667 fix_strcoll_bug(); 1668 # endif /* STRCOLLBUG */ 1669 tw_cmd_free();/* since the collation sequence has changed */ 1670 for (k = 0200; k <= 0377 && !Isprint(CTL_ESC(k)); k++) 1671 continue; 1672 AsciiOnly = MB_CUR_MAX == 1 && k > 0377; 1673 #else /* !NLS */ 1674 AsciiOnly = getenv("LANG") == NULL && 1675 getenv("LC_CTYPE") == NULL; 1676 #endif /* NLS */ 1677 NLSMapsAreInited = 0; 1678 ed_Init(); 1679 if (MapsAreInited && !NLSMapsAreInited) 1680 ed_InitNLSMaps(); 1681 1682 } 1683 #ifdef WINNT_NATIVE 1684 else if (eq(name,(STRtcshlang))) { 1685 nls_dll_unload(); 1686 nlsinit(); 1687 } 1688 #endif /* WINNT_NATIVE */ 1689 #ifdef COLOR_LS_F 1690 else if (eq(name, STRLS_COLORS)) 1691 parseLS_COLORS(n); 1692 else if (eq(name, STRLSCOLORS)) 1693 parseLSCOLORS(n); 1694 #endif /* COLOR_LS_F */ 1695 #ifdef NLS_CATALOGS 1696 else if (eq(name, STRNLSPATH)) { 1697 nlsclose(); 1698 nlsinit(); 1699 } 1700 #endif 1701 /* 1702 * start again cause the environment changes 1703 */ 1704 break; 1705 } 1706 cleanup_until(name); 1707 } 1708 1709 void 1710 tsetenv(const Char *name, const Char *val) 1711 { 1712 #ifdef SETENV_IN_LIB 1713 /* 1714 * XXX: This does not work right, since tcsh cannot track changes to 1715 * the environment this way. (the builtin setenv without arguments does 1716 * not print the right stuff neither does unsetenv). This was for Mach, 1717 * it is not needed anymore. 1718 */ 1719 #undef setenv 1720 char *cname; 1721 1722 if (name == NULL) 1723 return; 1724 cname = strsave(short2str(name)); 1725 setenv(cname, short2str(val), 1); 1726 xfree(cname); 1727 #else /* !SETENV_IN_LIB */ 1728 Char **ep = STR_environ; 1729 const Char *ccp; 1730 Char *cp, *dp; 1731 Char *blk[2]; 1732 Char **oep = ep; 1733 1734 #ifdef WINNT_NATIVE 1735 nt_set_env(name,val); 1736 #endif /* WINNT_NATIVE */ 1737 for (; *ep; ep++) { 1738 #ifdef WINNT_NATIVE 1739 for (ccp = name, dp = *ep; *ccp && Tolower(*ccp & TRIM) == Tolower(*dp); 1740 ccp++, dp++) 1741 #else 1742 for (ccp = name, dp = *ep; *ccp && (*ccp & TRIM) == *dp; ccp++, dp++) 1743 #endif /* WINNT_NATIVE */ 1744 continue; 1745 if (*ccp != 0 || *dp != '=') 1746 continue; 1747 cp = Strspl(STRequal, val); 1748 xfree(*ep); 1749 *ep = strip(Strspl(name, cp)); 1750 xfree(cp); 1751 blkfree((Char **) environ); 1752 environ = short2blk(STR_environ); 1753 return; 1754 } 1755 cp = Strspl(name, STRequal); 1756 blk[0] = strip(Strspl(cp, val)); 1757 xfree(cp); 1758 blk[1] = 0; 1759 STR_environ = blkspl(STR_environ, blk); 1760 blkfree((Char **) environ); 1761 environ = short2blk(STR_environ); 1762 xfree(oep); 1763 #endif /* SETENV_IN_LIB */ 1764 } 1765 1766 void 1767 Unsetenv(Char *name) 1768 { 1769 Char **ep = STR_environ; 1770 Char *cp, *dp; 1771 Char **oep = ep; 1772 1773 #ifdef WINNT_NATIVE 1774 nt_set_env(name,NULL); 1775 #endif /*WINNT_NATIVE */ 1776 for (; *ep; ep++) { 1777 for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++) 1778 continue; 1779 if (*cp != 0 || *dp != '=') 1780 continue; 1781 cp = *ep; 1782 *ep = 0; 1783 STR_environ = blkspl(STR_environ, ep + 1); 1784 blkfree((Char **) environ); 1785 environ = short2blk(STR_environ); 1786 *ep = cp; 1787 xfree(cp); 1788 xfree(oep); 1789 return; 1790 } 1791 } 1792 1793 /*ARGSUSED*/ 1794 void 1795 doumask(Char **v, struct command *c) 1796 { 1797 Char *cp = v[1]; 1798 int i; 1799 1800 USE(c); 1801 if (cp == 0) { 1802 i = (int)umask(0); 1803 (void) umask(i); 1804 xprintf("%o\n", i); 1805 return; 1806 } 1807 i = 0; 1808 while (Isdigit(*cp) && *cp != '8' && *cp != '9') 1809 i = i * 8 + *cp++ - '0'; 1810 if (*cp || i < 0 || i > 0777) 1811 stderror(ERR_NAME | ERR_MASK); 1812 (void) umask(i); 1813 } 1814 1815 #ifndef HAVENOLIMIT 1816 # ifndef BSDLIMIT 1817 typedef long RLIM_TYPE; 1818 # ifdef _OSD_POSIX /* BS2000 */ 1819 # include <ulimit.h> 1820 # endif 1821 # ifndef RLIM_INFINITY 1822 # if !defined(_MINIX) && !defined(__clipper__) && !defined(_CRAY) 1823 extern RLIM_TYPE ulimit(); 1824 # endif /* ! _MINIX && !__clipper__ */ 1825 # define RLIM_INFINITY 0x003fffff 1826 # define RLIMIT_FSIZE 1 1827 # endif /* RLIM_INFINITY */ 1828 # ifdef aiws 1829 # define toset(a) (((a) == 3) ? 1004 : (a) + 1) 1830 # define RLIMIT_DATA 3 1831 # define RLIMIT_STACK 1005 1832 # else /* aiws */ 1833 # define toset(a) ((a) + 1) 1834 # endif /* aiws */ 1835 # else /* BSDLIMIT */ 1836 # if (defined(BSD4_4) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) || (HPUXVERSION >= 1100)) && !defined(__386BSD__) 1837 typedef rlim_t RLIM_TYPE; 1838 # else 1839 # if defined(SOLARIS2) || (defined(sgi) && SYSVREL > 3) 1840 typedef rlim_t RLIM_TYPE; 1841 # else 1842 # if defined(_SX) 1843 typedef long long RLIM_TYPE; 1844 # else /* !_SX */ 1845 typedef unsigned long RLIM_TYPE; 1846 # endif /* _SX */ 1847 # endif /* SOLARIS2 || (sgi && SYSVREL > 3) */ 1848 # endif /* BSD4_4 && !__386BSD__ */ 1849 # endif /* BSDLIMIT */ 1850 1851 # if (HPUXVERSION > 700) && (HPUXVERSION < 1100) && defined(BSDLIMIT) 1852 /* Yes hpux8.0 has limits but <sys/resource.h> does not make them public */ 1853 /* Yes, we could have defined _KERNEL, and -I/etc/conf/h, but is that better? */ 1854 # ifndef RLIMIT_CPU 1855 # define RLIMIT_CPU 0 1856 # define RLIMIT_FSIZE 1 1857 # define RLIMIT_DATA 2 1858 # define RLIMIT_STACK 3 1859 # define RLIMIT_CORE 4 1860 # define RLIMIT_RSS 5 1861 # define RLIMIT_NOFILE 6 1862 # endif /* RLIMIT_CPU */ 1863 # ifndef RLIM_INFINITY 1864 # define RLIM_INFINITY 0x7fffffff 1865 # endif /* RLIM_INFINITY */ 1866 /* 1867 * old versions of HP/UX counted limits in 512 bytes 1868 */ 1869 # ifndef SIGRTMIN 1870 # define FILESIZE512 1871 # endif /* SIGRTMIN */ 1872 # endif /* (HPUXVERSION > 700) && (HPUXVERSION < 1100) && BSDLIMIT */ 1873 1874 # if SYSVREL > 3 && defined(BSDLIMIT) && !defined(_SX) 1875 /* In order to use rusage, we included "/usr/ucbinclude/sys/resource.h" in */ 1876 /* sh.h. However, some SVR4 limits are defined in <sys/resource.h>. Rather */ 1877 /* than include both and get warnings, we define the extra SVR4 limits here. */ 1878 /* XXX: I don't understand if RLIMIT_AS is defined, why don't we define */ 1879 /* RLIMIT_VMEM based on it? */ 1880 # ifndef RLIMIT_VMEM 1881 # define RLIMIT_VMEM 6 1882 # endif 1883 # ifndef RLIMIT_AS 1884 # define RLIMIT_AS RLIMIT_VMEM 1885 # endif 1886 # endif /* SYSVREL > 3 && BSDLIMIT */ 1887 1888 # if (defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) 1889 # if defined(RLIMIT_AS) && !defined(RLIMIT_VMEM) 1890 # define RLIMIT_VMEM RLIMIT_AS 1891 # endif 1892 /* 1893 * Oh well, <asm-generic/resource.h> has it, but <bits/resource.h> does not 1894 * Linux headers: When the left hand does not know what the right hand does. 1895 */ 1896 # if defined(RLIMIT_RTPRIO) && !defined(RLIMIT_RTTIME) 1897 # define RLIMIT_RTTIME (RLIMIT_RTPRIO + 1) 1898 # endif 1899 # endif 1900 1901 struct limits limits[] = 1902 { 1903 # ifdef RLIMIT_CPU 1904 { RLIMIT_CPU, "cputime", 1, "seconds" }, 1905 # endif /* RLIMIT_CPU */ 1906 1907 # ifdef RLIMIT_FSIZE 1908 # ifndef aiws 1909 { RLIMIT_FSIZE, "filesize", 1024, "kbytes" }, 1910 # else 1911 { RLIMIT_FSIZE, "filesize", 512, "blocks" }, 1912 # endif /* aiws */ 1913 # endif /* RLIMIT_FSIZE */ 1914 1915 # ifdef RLIMIT_DATA 1916 { RLIMIT_DATA, "datasize", 1024, "kbytes" }, 1917 # endif /* RLIMIT_DATA */ 1918 1919 # ifdef RLIMIT_STACK 1920 # ifndef aiws 1921 { RLIMIT_STACK, "stacksize", 1024, "kbytes" }, 1922 # else 1923 { RLIMIT_STACK, "stacksize", 1024 * 1024, "kbytes"}, 1924 # endif /* aiws */ 1925 # endif /* RLIMIT_STACK */ 1926 1927 # ifdef RLIMIT_CORE 1928 { RLIMIT_CORE, "coredumpsize", 1024, "kbytes" }, 1929 # endif /* RLIMIT_CORE */ 1930 1931 # ifdef RLIMIT_RSS 1932 { RLIMIT_RSS, "memoryuse", 1024, "kbytes" }, 1933 # endif /* RLIMIT_RSS */ 1934 1935 # ifdef RLIMIT_UMEM 1936 { RLIMIT_UMEM, "memoryuse", 1024, "kbytes" }, 1937 # endif /* RLIMIT_UMEM */ 1938 1939 # ifdef RLIMIT_VMEM 1940 { RLIMIT_VMEM, "vmemoryuse", 1024, "kbytes" }, 1941 # endif /* RLIMIT_VMEM */ 1942 1943 # if defined(RLIMIT_HEAP) /* found on BS2000/OSD systems */ 1944 { RLIMIT_HEAP, "heapsize", 1024, "kbytes" }, 1945 # endif /* RLIMIT_HEAP */ 1946 1947 # ifdef RLIMIT_NOFILE 1948 { RLIMIT_NOFILE, "descriptors", 1, "" }, 1949 # endif /* RLIMIT_NOFILE */ 1950 1951 # ifdef RLIMIT_NPTS 1952 { RLIMIT_NPTS, "pseudoterminals", 1, "" }, 1953 # endif /* RLIMIT_NPTS */ 1954 1955 # ifdef RLIMIT_KQUEUES 1956 { RLIMIT_KQUEUES, "kqueues", 1, "" }, 1957 # endif /* RLIMIT_KQUEUES */ 1958 1959 # ifdef RLIMIT_CONCUR 1960 { RLIMIT_CONCUR, "concurrency", 1, "thread(s)" }, 1961 # endif /* RLIMIT_CONCUR */ 1962 1963 # ifdef RLIMIT_MEMLOCK 1964 { RLIMIT_MEMLOCK, "memorylocked", 1024, "kbytes" }, 1965 # endif /* RLIMIT_MEMLOCK */ 1966 1967 # ifdef RLIMIT_NPROC 1968 { RLIMIT_NPROC, "maxproc", 1, "" }, 1969 # endif /* RLIMIT_NPROC */ 1970 1971 # ifdef RLIMIT_NTHR 1972 { RLIMIT_NTHR, "maxthread", 1, "" }, 1973 # endif /* RLIMIT_NTHR */ 1974 1975 # if defined(RLIMIT_OFILE) && !defined(RLIMIT_NOFILE) 1976 { RLIMIT_OFILE, "openfiles", 1, "" }, 1977 # endif /* RLIMIT_OFILE && !defined(RLIMIT_NOFILE) */ 1978 1979 # ifdef RLIMIT_SBSIZE 1980 { RLIMIT_SBSIZE, "sbsize", 1, "" }, 1981 # endif /* RLIMIT_SBSIZE */ 1982 1983 #ifdef RLIMIT_POSIXLOCKS 1984 { RLIMIT_POSIXLOCKS, "posixlocks", 1, "" }, 1985 #endif /* RLIMIT_POSIXLOCKS */ 1986 1987 # ifdef RLIMIT_SWAP 1988 { RLIMIT_SWAP, "swapsize", 1024, "kbytes" }, 1989 # endif /* RLIMIT_SWAP */ 1990 1991 # ifdef RLIMIT_LOCKS 1992 { RLIMIT_LOCKS, "maxlocks", 1, "" }, 1993 # endif /* RLIMIT_LOCKS */ 1994 1995 # ifdef RLIMIT_POSIXLOCKS 1996 { RLIMIT_POSIXLOCKS,"posixlocks", 1, "" }, 1997 # endif /* RLIMIT_POSIXLOCKS */ 1998 1999 # ifdef RLIMIT_SIGPENDING 2000 { RLIMIT_SIGPENDING,"maxsignal", 1, "" }, 2001 # endif /* RLIMIT_SIGPENDING */ 2002 2003 # ifdef RLIMIT_MSGQUEUE 2004 { RLIMIT_MSGQUEUE, "maxmessage", 1, "" }, 2005 # endif /* RLIMIT_MSGQUEUE */ 2006 2007 # ifdef RLIMIT_NICE 2008 { RLIMIT_NICE, "maxnice", 1, "" }, 2009 # endif /* RLIMIT_NICE */ 2010 2011 # ifdef RLIMIT_RTPRIO 2012 { RLIMIT_RTPRIO, "maxrtprio", 1, "" }, 2013 # endif /* RLIMIT_RTPRIO */ 2014 2015 # ifdef RLIMIT_RTTIME 2016 { RLIMIT_RTTIME, "maxrttime", 1, "usec" }, 2017 # endif /* RLIMIT_RTTIME */ 2018 2019 { -1, NULL, 0, NULL } 2020 }; 2021 2022 static struct limits *findlim (Char *); 2023 static RLIM_TYPE getval (struct limits *, Char **); 2024 static int strtail (Char *, const char *); 2025 static void limtail (Char *, const char *); 2026 static void limtail2 (Char *, const char *, const char *); 2027 static void plim (struct limits *, int); 2028 static int setlim (struct limits *, int, RLIM_TYPE); 2029 2030 #ifdef convex 2031 static RLIM_TYPE 2032 restrict_limit(double value) 2033 { 2034 /* 2035 * is f too large to cope with? return the maximum or minimum int 2036 */ 2037 if (value > (double) INT_MAX) 2038 return (RLIM_TYPE) INT_MAX; 2039 else if (value < (double) INT_MIN) 2040 return (RLIM_TYPE) INT_MIN; 2041 else 2042 return (RLIM_TYPE) value; 2043 } 2044 #else /* !convex */ 2045 # define restrict_limit(x) ((RLIM_TYPE) (x)) 2046 #endif /* convex */ 2047 2048 2049 static struct limits * 2050 findlim(Char *cp) 2051 { 2052 struct limits *lp, *res; 2053 2054 res = NULL; 2055 for (lp = limits; lp->limconst >= 0; lp++) 2056 if (prefix(cp, str2short(lp->limname))) { 2057 if (res) 2058 stderror(ERR_NAME | ERR_AMBIG); 2059 res = lp; 2060 } 2061 if (res) 2062 return (res); 2063 stderror(ERR_NAME | ERR_LIMIT); 2064 /* NOTREACHED */ 2065 return (0); 2066 } 2067 2068 /*ARGSUSED*/ 2069 void 2070 dolimit(Char **v, struct command *c) 2071 { 2072 struct limits *lp; 2073 RLIM_TYPE limit; 2074 int hard = 0; 2075 2076 USE(c); 2077 v++; 2078 if (*v && eq(*v, STRmh)) { 2079 hard = 1; 2080 v++; 2081 } 2082 if (*v == 0) { 2083 for (lp = limits; lp->limconst >= 0; lp++) 2084 plim(lp, hard); 2085 return; 2086 } 2087 lp = findlim(v[0]); 2088 if (v[1] == 0) { 2089 plim(lp, hard); 2090 return; 2091 } 2092 limit = getval(lp, v + 1); 2093 if (setlim(lp, hard, limit) < 0) 2094 stderror(ERR_SILENT); 2095 } 2096 2097 static RLIM_TYPE 2098 getval(struct limits *lp, Char **v) 2099 { 2100 float f; 2101 Char *cp = *v++; 2102 2103 f = atof(short2str(cp)); 2104 2105 # ifdef convex 2106 /* 2107 * is f too large to cope with. limit f to minint, maxint - X-6768 by 2108 * strike 2109 */ 2110 if ((f < (double) INT_MIN) || (f > (double) INT_MAX)) { 2111 stderror(ERR_NAME | ERR_TOOLARGE); 2112 } 2113 # endif /* convex */ 2114 2115 while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E') 2116 cp++; 2117 if (*cp == 0) { 2118 if (*v == 0) 2119 return restrict_limit((f * lp->limdiv) + 0.5); 2120 cp = *v; 2121 } 2122 switch (*cp) { 2123 # ifdef RLIMIT_CPU 2124 case ':': 2125 if (lp->limconst != RLIMIT_CPU) 2126 goto badscal; 2127 return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f * 60.0 + atof(short2str(cp + 1)))); 2128 case 'h': 2129 if (lp->limconst != RLIMIT_CPU) 2130 goto badscal; 2131 limtail(cp, "hours"); 2132 f *= 3600.0; 2133 break; 2134 # endif /* RLIMIT_CPU */ 2135 case 'm': 2136 # ifdef RLIMIT_CPU 2137 if (lp->limconst == RLIMIT_CPU) { 2138 limtail(cp, "minutes"); 2139 f *= 60.0; 2140 break; 2141 } 2142 # endif /* RLIMIT_CPU */ 2143 limtail2(cp, "megabytes", "mbytes"); 2144 f *= 1024.0 * 1024.0; 2145 break; 2146 # ifdef RLIMIT_CPU 2147 case 's': 2148 if (lp->limconst != RLIMIT_CPU) 2149 goto badscal; 2150 limtail(cp, "seconds"); 2151 break; 2152 # endif /* RLIMIT_CPU */ 2153 case 'G': 2154 *cp = 'g'; 2155 /*FALLTHROUGH*/ 2156 case 'g': 2157 # ifdef RLIMIT_CPU 2158 if (lp->limconst == RLIMIT_CPU) 2159 goto badscal; 2160 # endif /* RLIMIT_CPU */ 2161 limtail2(cp, "gigabytes", "gbytes"); 2162 f *= 1024.0 * 1024.0 * 1024.0; 2163 break; 2164 case 'M': 2165 # ifdef RLIMIT_CPU 2166 if (lp->limconst == RLIMIT_CPU) 2167 goto badscal; 2168 # endif /* RLIMIT_CPU */ 2169 *cp = 'm'; 2170 limtail2(cp, "megabytes", "mbytes"); 2171 f *= 1024.0 * 1024.0; 2172 break; 2173 case 'k': 2174 # ifdef RLIMIT_CPU 2175 if (lp->limconst == RLIMIT_CPU) 2176 goto badscal; 2177 # endif /* RLIMIT_CPU */ 2178 limtail2(cp, "kilobytes", "kbytes"); 2179 f *= 1024.0; 2180 break; 2181 case 'b': 2182 # ifdef RLIMIT_CPU 2183 if (lp->limconst == RLIMIT_CPU) 2184 goto badscal; 2185 # endif /* RLIMIT_CPU */ 2186 limtail(cp, "blocks"); 2187 f *= 512.0; 2188 break; 2189 case 'u': 2190 limtail(cp, "unlimited"); 2191 return ((RLIM_TYPE) RLIM_INFINITY); 2192 default: 2193 # ifdef RLIMIT_CPU 2194 badscal: 2195 # endif /* RLIMIT_CPU */ 2196 stderror(ERR_NAME | ERR_SCALEF); 2197 } 2198 # ifdef convex 2199 return f == 0.0 ? (RLIM_TYPE) 0 : restrict_limit((f + 0.5)); 2200 # else 2201 f += 0.5; 2202 if (f > (float) ((RLIM_TYPE) RLIM_INFINITY)) 2203 return ((RLIM_TYPE) RLIM_INFINITY); 2204 else 2205 return ((RLIM_TYPE) f); 2206 # endif /* convex */ 2207 } 2208 2209 static int 2210 strtail(Char *cp, const char *str) 2211 { 2212 while (*cp && *cp == (Char)*str) 2213 cp++, str++; 2214 return (*cp != '\0'); 2215 } 2216 2217 static void 2218 limtail(Char *cp, const char *str) 2219 { 2220 if (strtail(cp, str)) 2221 stderror(ERR_BADSCALE, str); 2222 } 2223 2224 static void 2225 limtail2(Char *cp, const char *str1, const char *str2) 2226 { 2227 if (strtail(cp, str1) && strtail(cp, str2)) 2228 stderror(ERR_BADSCALE, str1); 2229 } 2230 2231 /*ARGSUSED*/ 2232 static void 2233 plim(struct limits *lp, int hard) 2234 { 2235 # ifdef BSDLIMIT 2236 struct rlimit rlim; 2237 # endif /* BSDLIMIT */ 2238 RLIM_TYPE limit; 2239 int xdiv = lp->limdiv; 2240 2241 xprintf("%-13.13s", lp->limname); 2242 2243 # ifndef BSDLIMIT 2244 limit = ulimit(lp->limconst, 0); 2245 # ifdef aiws 2246 if (lp->limconst == RLIMIT_DATA) 2247 limit -= 0x20000000; 2248 # endif /* aiws */ 2249 # else /* BSDLIMIT */ 2250 (void) getrlimit(lp->limconst, &rlim); 2251 limit = hard ? rlim.rlim_max : rlim.rlim_cur; 2252 # endif /* BSDLIMIT */ 2253 2254 # if !defined(BSDLIMIT) || defined(FILESIZE512) 2255 /* 2256 * Christos: filesize comes in 512 blocks. we divide by 2 to get 1024 2257 * blocks. Note we cannot pre-multiply cause we might overflow (A/UX) 2258 */ 2259 if (lp->limconst == RLIMIT_FSIZE) { 2260 if (limit >= (RLIM_INFINITY / 512)) 2261 limit = RLIM_INFINITY; 2262 else 2263 xdiv = (xdiv == 1024 ? 2 : 1); 2264 } 2265 # endif /* !BSDLIMIT || FILESIZE512 */ 2266 2267 if (limit == RLIM_INFINITY) 2268 xprintf("unlimited"); 2269 else 2270 # if defined(RLIMIT_CPU) && defined(_OSD_POSIX) 2271 if (lp->limconst == RLIMIT_CPU && 2272 (unsigned long)limit >= 0x7ffffffdUL) 2273 xprintf("unlimited"); 2274 else 2275 # endif 2276 # ifdef RLIMIT_CPU 2277 if (lp->limconst == RLIMIT_CPU) 2278 psecs(limit); 2279 else 2280 # endif /* RLIMIT_CPU */ 2281 xprintf("%ld %s", (long) (limit / xdiv), lp->limscale); 2282 xputchar('\n'); 2283 } 2284 2285 /*ARGSUSED*/ 2286 void 2287 dounlimit(Char **v, struct command *c) 2288 { 2289 struct limits *lp; 2290 int lerr = 0; 2291 int hard = 0; 2292 int force = 0; 2293 2294 USE(c); 2295 while (*++v && **v == '-') { 2296 Char *vp = *v; 2297 while (*++vp) 2298 switch (*vp) { 2299 case 'f': 2300 force = 1; 2301 break; 2302 case 'h': 2303 hard = 1; 2304 break; 2305 default: 2306 stderror(ERR_ULIMUS); 2307 break; 2308 } 2309 } 2310 2311 if (*v == 0) { 2312 for (lp = limits; lp->limconst >= 0; lp++) 2313 if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0) 2314 lerr++; 2315 if (!force && lerr) 2316 stderror(ERR_SILENT); 2317 return; 2318 } 2319 while (*v) { 2320 lp = findlim(*v++); 2321 if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0 && !force) 2322 stderror(ERR_SILENT); 2323 } 2324 } 2325 2326 static int 2327 setlim(struct limits *lp, int hard, RLIM_TYPE limit) 2328 { 2329 # ifdef BSDLIMIT 2330 struct rlimit rlim; 2331 2332 (void) getrlimit(lp->limconst, &rlim); 2333 2334 # ifdef FILESIZE512 2335 /* Even though hpux has setrlimit(), it expects fsize in 512 byte blocks */ 2336 if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE) 2337 limit /= 512; 2338 # endif /* FILESIZE512 */ 2339 if (hard) 2340 rlim.rlim_max = limit; 2341 else if (limit == RLIM_INFINITY && euid != 0) 2342 rlim.rlim_cur = rlim.rlim_max; 2343 else 2344 rlim.rlim_cur = limit; 2345 2346 if (rlim.rlim_cur > rlim.rlim_max) 2347 rlim.rlim_max = rlim.rlim_cur; 2348 2349 if (setrlimit(lp->limconst, &rlim) < 0) { 2350 # else /* BSDLIMIT */ 2351 if (limit != RLIM_INFINITY && lp->limconst == RLIMIT_FSIZE) 2352 limit /= 512; 2353 # ifdef aiws 2354 if (lp->limconst == RLIMIT_DATA) 2355 limit += 0x20000000; 2356 # endif /* aiws */ 2357 if (ulimit(toset(lp->limconst), limit) < 0) { 2358 # endif /* BSDLIMIT */ 2359 int err; 2360 char *op, *type; 2361 2362 err = errno; 2363 op = strsave(limit == RLIM_INFINITY ? CGETS(15, 2, "remove") : 2364 CGETS(15, 3, "set")); 2365 cleanup_push(op, xfree); 2366 type = strsave(hard ? CGETS(15, 4, " hard") : ""); 2367 cleanup_push(type, xfree); 2368 xprintf(CGETS(15, 1, "%s: %s: Can't %s%s limit (%s)\n"), bname, 2369 lp->limname, op, type, strerror(err)); 2370 cleanup_until(op); 2371 return (-1); 2372 } 2373 return (0); 2374 } 2375 2376 #endif /* !HAVENOLIMIT */ 2377 2378 /*ARGSUSED*/ 2379 void 2380 dosuspend(Char **v, struct command *c) 2381 { 2382 #ifdef BSDJOBS 2383 struct sigaction old; 2384 #endif /* BSDJOBS */ 2385 2386 USE(c); 2387 USE(v); 2388 2389 if (loginsh) 2390 stderror(ERR_SUSPLOG); 2391 untty(); 2392 2393 #ifdef BSDJOBS 2394 sigaction(SIGTSTP, NULL, &old); 2395 signal(SIGTSTP, SIG_DFL); 2396 (void) kill(0, SIGTSTP); 2397 /* the shell stops here */ 2398 sigaction(SIGTSTP, &old, NULL); 2399 #else /* !BSDJOBS */ 2400 stderror(ERR_JOBCONTROL); 2401 #endif /* BSDJOBS */ 2402 2403 #ifdef BSDJOBS 2404 if (tpgrp != -1) { 2405 if (grabpgrp(FSHTTY, opgrp) == -1) 2406 stderror(ERR_SYSTEM, "tcgetpgrp", strerror(errno)); 2407 (void) setpgid(0, shpgrp); 2408 (void) tcsetpgrp(FSHTTY, shpgrp); 2409 } 2410 #endif /* BSDJOBS */ 2411 (void) setdisc(FSHTTY); 2412 } 2413 2414 /* This is the dreaded EVAL built-in. 2415 * If you don't fiddle with file descriptors, and reset didfds, 2416 * this command will either ignore redirection inside or outside 2417 * its arguments, e.g. eval "date >x" vs. eval "date" >x 2418 * The stuff here seems to work, but I did it by trial and error rather 2419 * than really knowing what was going on. If tpgrp is zero, we are 2420 * probably a background eval, e.g. "eval date &", and we want to 2421 * make sure that any processes we start stay in our pgrp. 2422 * This is also the case for "time eval date" -- stay in same pgrp. 2423 * Otherwise, under stty tostop, processes will stop in the wrong 2424 * pgrp, with no way for the shell to get them going again. -IAN! 2425 */ 2426 2427 struct doeval_state 2428 { 2429 Char **evalvec, *evalp; 2430 int didfds; 2431 #ifndef CLOSE_ON_EXEC 2432 int didcch; 2433 #endif 2434 int saveIN, saveOUT, saveDIAG; 2435 int SHIN, SHOUT, SHDIAG; 2436 }; 2437 2438 static void 2439 doeval_cleanup(void *xstate) 2440 { 2441 struct doeval_state *state; 2442 2443 state = xstate; 2444 evalvec = state->evalvec; 2445 evalp = state->evalp; 2446 doneinp = 0; 2447 #ifndef CLOSE_ON_EXEC 2448 didcch = state->didcch; 2449 #endif /* CLOSE_ON_EXEC */ 2450 didfds = state->didfds; 2451 if (state->saveIN != SHIN) 2452 xclose(SHIN); 2453 if (state->saveOUT != SHOUT) 2454 xclose(SHOUT); 2455 if (state->saveDIAG != SHDIAG) 2456 xclose(SHDIAG); 2457 close_on_exec(SHIN = dmove(state->saveIN, state->SHIN), 1); 2458 close_on_exec(SHOUT = dmove(state->saveOUT, state->SHOUT), 1); 2459 close_on_exec(SHDIAG = dmove(state->saveDIAG, state->SHDIAG), 1); 2460 if (didfds) { 2461 close_on_exec(dcopy(SHIN, 0), 1); 2462 close_on_exec(dcopy(SHOUT, 1), 1); 2463 close_on_exec(dcopy(SHDIAG, 2), 1); 2464 } 2465 } 2466 2467 static Char **Ggv; 2468 /*ARGSUSED*/ 2469 void 2470 doeval(Char **v, struct command *c) 2471 { 2472 struct doeval_state state; 2473 int gflag, my_reenter; 2474 Char **gv; 2475 jmp_buf_t osetexit; 2476 2477 USE(c); 2478 v++; 2479 if (*v == 0) 2480 return; 2481 gflag = tglob(v); 2482 if (gflag) { 2483 gv = v = globall(v, gflag); 2484 if (v == 0) 2485 stderror(ERR_NOMATCH); 2486 cleanup_push(gv, blk_cleanup); 2487 v = copyblk(v); 2488 } 2489 else { 2490 gv = NULL; 2491 v = copyblk(v); 2492 trim(v); 2493 } 2494 2495 Ggv = gv; 2496 state.evalvec = evalvec; 2497 state.evalp = evalp; 2498 state.didfds = didfds; 2499 #ifndef CLOSE_ON_EXEC 2500 state.didcch = didcch; 2501 #endif /* CLOSE_ON_EXEC */ 2502 state.SHIN = SHIN; 2503 state.SHOUT = SHOUT; 2504 state.SHDIAG = SHDIAG; 2505 2506 (void)close_on_exec(state.saveIN = dcopy(SHIN, -1), 1); 2507 (void)close_on_exec(state.saveOUT = dcopy(SHOUT, -1), 1); 2508 (void)close_on_exec(state.saveDIAG = dcopy(SHDIAG, -1), 1); 2509 2510 cleanup_push(&state, doeval_cleanup); 2511 2512 getexit(osetexit); 2513 2514 /* PWP: setjmp/longjmp bugfix for optimizing compilers */ 2515 #ifdef cray 2516 my_reenter = 1; /* assume non-zero return val */ 2517 if (setexit() == 0) { 2518 my_reenter = 0; /* Oh well, we were wrong */ 2519 #else /* !cray */ 2520 if ((my_reenter = setexit()) == 0) { 2521 #endif /* cray */ 2522 evalvec = v; 2523 evalp = 0; 2524 (void)close_on_exec(SHIN = dcopy(0, -1), 1); 2525 (void)close_on_exec(SHOUT = dcopy(1, -1), 1); 2526 (void)close_on_exec(SHDIAG = dcopy(2, -1), 1); 2527 #ifndef CLOSE_ON_EXEC 2528 didcch = 0; 2529 #endif /* CLOSE_ON_EXEC */ 2530 didfds = 0; 2531 gv = Ggv; 2532 process(0); 2533 Ggv = gv; 2534 } 2535 2536 if (my_reenter == 0) { 2537 cleanup_until(&state); 2538 if (Ggv) 2539 cleanup_until(Ggv); 2540 } 2541 2542 resexit(osetexit); 2543 if (my_reenter) 2544 stderror(ERR_SILENT); 2545 } 2546 2547 /*************************************************************************/ 2548 /* print list of builtin commands */ 2549 2550 static void 2551 lbuffed_cleanup (void *dummy) 2552 { 2553 USE(dummy); 2554 lbuffed = 1; 2555 } 2556 2557 /*ARGSUSED*/ 2558 void 2559 dobuiltins(Char **v, struct command *c) 2560 { 2561 /* would use print_by_column() in tw.parse.c but that assumes 2562 * we have an array of Char * to pass.. (sg) 2563 */ 2564 const struct biltins *b; 2565 int row, col, columns, rows; 2566 unsigned int w, maxwidth; 2567 2568 USE(c); 2569 USE(v); 2570 lbuffed = 0; /* turn off line buffering */ 2571 cleanup_push(&lbuffed, lbuffed_cleanup); 2572 2573 /* find widest string */ 2574 for (maxwidth = 0, b = bfunc; b < &bfunc[nbfunc]; ++b) 2575 maxwidth = max(maxwidth, strlen(b->bname)); 2576 ++maxwidth; /* for space */ 2577 2578 columns = (TermH + 1) / maxwidth; /* PWP: terminal size change */ 2579 if (!columns) 2580 columns = 1; 2581 rows = (nbfunc + (columns - 1)) / columns; 2582 2583 for (b = bfunc, row = 0; row < rows; row++) { 2584 for (col = 0; col < columns; col++) { 2585 if (b < &bfunc[nbfunc]) { 2586 w = strlen(b->bname); 2587 xprintf("%s", b->bname); 2588 if (col < (columns - 1)) /* Not last column? */ 2589 for (; w < maxwidth; w++) 2590 xputchar(' '); 2591 ++b; 2592 } 2593 } 2594 if (row < (rows - 1)) { 2595 if (Tty_raw_mode) 2596 xputchar('\r'); 2597 xputchar('\n'); 2598 } 2599 } 2600 #ifdef WINNT_NATIVE 2601 nt_print_builtins(maxwidth); 2602 #else 2603 if (Tty_raw_mode) 2604 xputchar('\r'); 2605 xputchar('\n'); 2606 #endif /* WINNT_NATIVE */ 2607 2608 cleanup_until(&lbuffed); /* turn back on line buffering */ 2609 flush(); 2610 } 2611 2612 #ifdef NLS_CATALOGS 2613 char * 2614 xcatgets(nl_catd ctd, int set_id, int msg_id, const char *s) 2615 { 2616 char *res; 2617 2618 errno = 0; 2619 while ((res = catgets(ctd, set_id, msg_id, s)) == s && errno == EINTR) { 2620 handle_pending_signals(); 2621 errno = 0; 2622 } 2623 return res; 2624 } 2625 2626 2627 # if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO) 2628 char * 2629 iconv_catgets(nl_catd ctd, int set_id, int msg_id, const char *s) 2630 { 2631 static char *buf = NULL; 2632 static size_t buf_size = 0; 2633 2634 char *orig, *dest, *p; 2635 ICONV_CONST char *src; 2636 size_t src_size, dest_size; 2637 2638 orig = xcatgets(ctd, set_id, msg_id, s); 2639 if (catgets_iconv == (iconv_t)-1 || orig == s) 2640 return orig; 2641 src = orig; 2642 src_size = strlen(src) + 1; 2643 if (buf == NULL && (buf = xmalloc(buf_size = src_size + 32)) == NULL) 2644 return orig; 2645 dest = buf; 2646 while (src_size != 0) { 2647 dest_size = buf + buf_size - dest; 2648 if (iconv(catgets_iconv, &src, &src_size, &dest, &dest_size) 2649 == (size_t)-1) { 2650 switch (errno) { 2651 case E2BIG: 2652 if ((p = xrealloc(buf, buf_size * 2)) == NULL) 2653 return orig; 2654 buf_size *= 2; 2655 dest = p + (dest - buf); 2656 buf = p; 2657 break; 2658 2659 case EILSEQ: case EINVAL: default: 2660 return orig; 2661 } 2662 } 2663 } 2664 return buf; 2665 } 2666 # endif /* HAVE_ICONV && HAVE_NL_LANGINFO */ 2667 #endif /* NLS_CATALOGS */ 2668 2669 void 2670 nlsinit(void) 2671 { 2672 #ifdef NLS_CATALOGS 2673 static const char default_catalog[] = "tcsh"; 2674 2675 char *catalog = (char *)(intptr_t)default_catalog; 2676 2677 if (adrof(STRcatalog) != NULL) 2678 catalog = xasprintf("tcsh.%s", short2str(varval(STRcatalog))); 2679 #ifdef NL_CAT_LOCALE /* POSIX-compliant. */ 2680 /* 2681 * Check if LC_MESSAGES is set in the environment and use it, if so. 2682 * If not, fall back to the setting of LANG. 2683 */ 2684 catd = catopen(catalog, tgetenv(STRLC_MESSAGES) ? NL_CAT_LOCALE : 0); 2685 #else /* pre-POSIX */ 2686 # ifndef MCLoadBySet 2687 # define MCLoadBySet 0 2688 # endif 2689 catd = catopen(catalog, MCLoadBySet); 2690 #endif 2691 if (catalog != default_catalog) 2692 xfree(catalog); 2693 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO) 2694 /* xcatgets (), not CGETS, the charset name should be in ASCII anyway. */ 2695 catgets_iconv = iconv_open (nl_langinfo (CODESET), 2696 xcatgets(catd, 255, 1, "UTF-8")); 2697 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */ 2698 #endif /* NLS_CATALOGS */ 2699 #ifdef WINNT_NATIVE 2700 nls_dll_init(); 2701 #endif /* WINNT_NATIVE */ 2702 errinit(); /* init the errorlist in correct locale */ 2703 mesginit(); /* init the messages for signals */ 2704 dateinit(); /* init the messages for dates */ 2705 editinit(); /* init the editor messages */ 2706 terminit(); /* init the termcap messages */ 2707 } 2708 2709 void 2710 nlsclose(void) 2711 { 2712 #ifdef NLS_CATALOGS 2713 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO) 2714 if (catgets_iconv != (iconv_t)-1) { 2715 iconv_close(catgets_iconv); 2716 catgets_iconv = (iconv_t)-1; 2717 } 2718 #endif /* HAVE_ICONV && HAVE_NL_LANGINFO */ 2719 if (catd != (nl_catd)-1) { 2720 /* 2721 * catclose can call other functions which can call longjmp 2722 * making us re-enter this code. Prevent infinite recursion 2723 * by resetting catd. Problem reported and solved by: 2724 * Gerhard Niklasch 2725 */ 2726 nl_catd oldcatd = catd; 2727 catd = (nl_catd)-1; 2728 while (catclose(oldcatd) == -1 && errno == EINTR) 2729 handle_pending_signals(); 2730 } 2731 #endif /* NLS_CATALOGS */ 2732 } 2733 2734 int 2735 getYN(const char *prompt) 2736 { 2737 int doit; 2738 char c; 2739 2740 xprintf("%s", prompt); 2741 flush(); 2742 (void) force_read(SHIN, &c, sizeof(c)); 2743 /* 2744 * Perhaps we should use the yesexpr from the 2745 * actual locale 2746 */ 2747 doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL); 2748 while (c != '\n' && force_read(SHIN, &c, sizeof(c)) == sizeof(c)) 2749 continue; 2750 return doit; 2751 } 2752