1 /* 2 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 7 /* All Rights Reserved */ 8 9 /* 10 * Copyright (c) 1980 Regents of the University of California. 11 * All rights reserved. The Berkeley Software License Agreement 12 * specifies the terms and conditions for redistribution. 13 */ 14 15 #pragma ident "%Z%%M% %I% %E% SMI" 16 17 #include "sh.h" 18 #include "sh.tconst.h" 19 20 /* 21 * C shell 22 */ 23 24 void asyntax(struct wordent *, struct wordent *); 25 void asyn0(struct wordent *, struct wordent *); 26 void asyn3(struct wordent *, struct wordent *); 27 void chr_blkfree(char **); 28 struct command *syn0(struct wordent *, struct wordent *, int); 29 struct command *syn1(struct wordent *, struct wordent *, int); 30 struct command *syn1a(struct wordent *, struct wordent *, int); 31 struct command *syn1b(struct wordent *, struct wordent *, int); 32 struct command *syn2(struct wordent *, struct wordent *, int); 33 struct command *syn3(struct wordent *, struct wordent *, int); 34 struct wordent *freenod(struct wordent *, struct wordent *); 35 36 /* 37 * Perform aliasing on the word list lex 38 * Do a (very rudimentary) parse to separate into commands. 39 * If word 0 of a command has an alias, do it. 40 * Repeat a maximum of 20 times. 41 */ 42 void 43 alias(struct wordent *lex) 44 { 45 int aleft = 21; 46 jmp_buf osetexit; 47 48 #ifdef TRACE 49 tprintf("TRACE- alias()\n"); 50 #endif 51 getexit(osetexit); 52 setexit(); 53 if (haderr) { 54 resexit(osetexit); 55 reset(); 56 } 57 if (--aleft == 0) 58 error("Alias loop"); 59 asyntax(lex->next, lex); 60 resexit(osetexit); 61 } 62 63 void 64 asyntax(struct wordent *p1, struct wordent *p2) 65 { 66 #ifdef TRACE 67 tprintf("TRACE- asyntax()\n"); 68 #endif 69 70 while (p1 != p2) 71 /* if (any(p1->word[0], ";&\n")) */ /* For char -> tchar */ 72 if (p1->word[0] == ';' || 73 p1->word[0] == '&' || 74 p1->word[0] == '\n') 75 p1 = p1->next; 76 else { 77 asyn0(p1, p2); 78 return; 79 } 80 } 81 82 void 83 asyn0(struct wordent *p1, struct wordent *p2) 84 { 85 struct wordent *p; 86 int l = 0; 87 88 #ifdef TRACE 89 tprintf("TRACE- asyn0()\n"); 90 #endif 91 for (p = p1; p != p2; p = p->next) 92 switch (p->word[0]) { 93 94 case '(': 95 l++; 96 continue; 97 98 case ')': 99 l--; 100 if (l < 0) 101 error("Too many )'s"); 102 continue; 103 104 case '>': 105 if (p->next != p2 && eq(p->next->word, S_AND /* "&"*/)) 106 p = p->next; 107 continue; 108 109 case '&': 110 case '|': 111 case ';': 112 case '\n': 113 if (l != 0) 114 continue; 115 asyn3(p1, p); 116 asyntax(p->next, p2); 117 return; 118 } 119 if (l == 0) 120 asyn3(p1, p2); 121 } 122 123 void 124 asyn3(struct wordent *p1, struct wordent *p2) 125 { 126 struct varent *ap; 127 struct wordent alout; 128 bool redid; 129 130 #ifdef TRACE 131 tprintf("TRACE- asyn3()\n"); 132 #endif 133 if (p1 == p2) 134 return; 135 if (p1->word[0] == '(') { 136 for (p2 = p2->prev; p2->word[0] != ')'; p2 = p2->prev) 137 if (p2 == p1) 138 return; 139 if (p2 == p1->next) 140 return; 141 asyn0(p1->next, p2); 142 return; 143 } 144 ap = adrof1(p1->word, &aliases); 145 if (ap == 0) 146 return; 147 alhistp = p1->prev; 148 alhistt = p2; 149 alvec = ap->vec; 150 redid = lex(&alout); 151 alhistp = alhistt = 0; 152 alvec = 0; 153 if (err) { 154 freelex(&alout); 155 error("%s", gettext(err)); 156 } 157 if (p1->word[0] && eq(p1->word, alout.next->word)) { 158 tchar *cp = alout.next->word; 159 160 alout.next->word = strspl(S_TOPBIT /* "\200" */, cp); 161 xfree(cp); 162 } 163 p1 = freenod(p1, redid ? p2 : p1->next); 164 if (alout.next != &alout) { 165 p1->next->prev = alout.prev->prev; 166 alout.prev->prev->next = p1->next; 167 alout.next->prev = p1; 168 p1->next = alout.next; 169 xfree(alout.prev->word); 170 xfree(alout.prev); 171 } 172 reset(); /* throw! */ 173 } 174 175 struct wordent * 176 freenod(struct wordent *p1, struct wordent *p2) 177 { 178 struct wordent *retp = p1->prev; 179 180 #ifdef TRACE 181 tprintf("TRACE- freenod()\n"); 182 #endif 183 while (p1 != p2) { 184 xfree(p1->word); 185 p1 = p1->next; 186 xfree(p1->prev); 187 } 188 retp->next = p2; 189 p2->prev = retp; 190 return (retp); 191 } 192 193 #define PHERE 1 194 #define PIN 2 195 #define POUT 4 196 #define PDIAG 8 197 198 /* 199 * syntax 200 * empty 201 * syn0 202 */ 203 struct command * 204 syntax(struct wordent *p1, struct wordent *p2, int flags) 205 { 206 #ifdef TRACE 207 tprintf("TRACE- syntax()\n"); 208 #endif 209 210 while (p1 != p2) 211 /* if (any(p1->word[0], ";&\n")) */ /* for char -> tchar */ 212 if (p1->word[0] == ';' || 213 p1->word[0] == '&' || 214 p1->word[0] == '\n') 215 p1 = p1->next; 216 else 217 return (syn0(p1, p2, flags)); 218 return (0); 219 } 220 221 /* 222 * syn0 223 * syn1 224 * syn1 & syntax 225 */ 226 struct command * 227 syn0(struct wordent *p1, struct wordent *p2, int flags) 228 { 229 struct wordent *p; 230 struct command *t, *t1; 231 int l; 232 233 #ifdef TRACE 234 tprintf("TRACE- syn0()\n"); 235 #endif 236 l = 0; 237 for (p = p1; p != p2; p = p->next) 238 switch (p->word[0]) { 239 240 case '(': 241 l++; 242 continue; 243 244 case ')': 245 l--; 246 if (l < 0) 247 seterr("Too many )'s"); 248 continue; 249 250 case '|': 251 if (p->word[1] == '|') 252 continue; 253 /* fall into ... */ 254 255 case '>': 256 if (p->next != p2 && eq(p->next->word, S_AND /* "&" */)) 257 p = p->next; 258 continue; 259 260 case '&': 261 if (l != 0) 262 break; 263 if (p->word[1] == '&') 264 continue; 265 t1 = syn1(p1, p, flags); 266 if (t1->t_dtyp == TLST || 267 t1->t_dtyp == TAND || 268 t1->t_dtyp == TOR) { 269 t = (struct command *)xcalloc(1, sizeof (*t)); 270 t->t_dtyp = TPAR; 271 t->t_dflg = FAND|FINT; 272 t->t_dspr = t1; 273 t1 = t; 274 } else 275 t1->t_dflg |= FAND|FINT; 276 t = (struct command *)xcalloc(1, sizeof (*t)); 277 t->t_dtyp = TLST; 278 t->t_dflg = 0; 279 t->t_dcar = t1; 280 t->t_dcdr = syntax(p, p2, flags); 281 return (t); 282 } 283 if (l == 0) 284 return (syn1(p1, p2, flags)); 285 seterr("Too many ('s"); 286 return (0); 287 } 288 289 /* 290 * syn1 291 * syn1a 292 * syn1a ; syntax 293 */ 294 struct command * 295 syn1(struct wordent *p1, struct wordent *p2, int flags) 296 { 297 struct wordent *p; 298 struct command *t; 299 int l; 300 301 #ifdef TRACE 302 tprintf("TRACE- syn1()\n"); 303 #endif 304 l = 0; 305 for (p = p1; p != p2; p = p->next) 306 switch (p->word[0]) { 307 308 case '(': 309 l++; 310 continue; 311 312 case ')': 313 l--; 314 continue; 315 316 case ';': 317 case '\n': 318 if (l != 0) 319 break; 320 t = (struct command *)xcalloc(1, sizeof (*t)); 321 t->t_dtyp = TLST; 322 t->t_dcar = syn1a(p1, p, flags); 323 t->t_dcdr = syntax(p->next, p2, flags); 324 if (t->t_dcdr == 0) 325 t->t_dcdr = t->t_dcar, t->t_dcar = 0; 326 return (t); 327 } 328 return (syn1a(p1, p2, flags)); 329 } 330 331 /* 332 * syn1a 333 * syn1b 334 * syn1b || syn1a 335 */ 336 struct command * 337 syn1a(struct wordent *p1, struct wordent *p2, int flags) 338 { 339 struct wordent *p; 340 struct command *t; 341 int l = 0; 342 343 #ifdef TRACE 344 tprintf("TRACE- syn1a()\n"); 345 #endif 346 for (p = p1; p != p2; p = p->next) 347 switch (p->word[0]) { 348 349 case '(': 350 l++; 351 continue; 352 353 case ')': 354 l--; 355 continue; 356 357 case '|': 358 if (p->word[1] != '|') 359 continue; 360 if (l == 0) { 361 t = (struct command *)xcalloc(1, sizeof (*t)); 362 t->t_dtyp = TOR; 363 t->t_dcar = syn1b(p1, p, flags); 364 t->t_dcdr = syn1a(p->next, p2, flags); 365 t->t_dflg = 0; 366 return (t); 367 } 368 continue; 369 } 370 return (syn1b(p1, p2, flags)); 371 } 372 373 /* 374 * syn1b 375 * syn2 376 * syn2 && syn1b 377 */ 378 struct command * 379 syn1b(struct wordent *p1, struct wordent *p2, int flags) 380 { 381 struct wordent *p; 382 struct command *t; 383 int l = 0; 384 385 #ifdef TRACE 386 tprintf("TRACE- syn1b()\n"); 387 #endif 388 l = 0; 389 for (p = p1; p != p2; p = p->next) 390 switch (p->word[0]) { 391 392 case '(': 393 l++; 394 continue; 395 396 case ')': 397 l--; 398 continue; 399 400 case '&': 401 if (p->word[1] == '&' && l == 0) { 402 t = (struct command *)xcalloc(1, sizeof (*t)); 403 t->t_dtyp = TAND; 404 t->t_dcar = syn2(p1, p, flags); 405 t->t_dcdr = syn1b(p->next, p2, flags); 406 t->t_dflg = 0; 407 return (t); 408 } 409 continue; 410 } 411 return (syn2(p1, p2, flags)); 412 } 413 414 /* 415 * syn2 416 * syn3 417 * syn3 | syn2 418 * syn3 |& syn2 419 */ 420 struct command * 421 syn2(struct wordent *p1, struct wordent *p2, int flags) 422 { 423 struct wordent *p, *pn; 424 struct command *t; 425 int l = 0; 426 int f; 427 428 #ifdef TRACE 429 tprintf("TRACE- syn2()\n"); 430 #endif 431 for (p = p1; p != p2; p = p->next) 432 switch (p->word[0]) { 433 434 case '(': 435 l++; 436 continue; 437 438 case ')': 439 l--; 440 continue; 441 442 case '|': 443 if (l != 0) 444 continue; 445 t = (struct command *)xcalloc(1, sizeof (*t)); 446 f = flags | POUT; 447 pn = p->next; 448 if (pn != p2 && pn->word[0] == '&') { 449 f |= PDIAG; 450 t->t_dflg |= FDIAG; 451 } 452 t->t_dtyp = TFIL; 453 t->t_dcar = syn3(p1, p, f); 454 if (pn != p2 && pn->word[0] == '&') 455 p = pn; 456 t->t_dcdr = syn2(p->next, p2, flags | PIN); 457 return (t); 458 } 459 return (syn3(p1, p2, flags)); 460 } 461 462 tchar RELPAR[] = {'<', '>', '(', ')', 0}; /* "<>()" */ 463 464 /* 465 * syn3 466 * ( syn0 ) [ < in ] [ > out ] 467 * word word* [ < in ] [ > out ] 468 * KEYWORD ( word* ) word* [ < in ] [ > out ] 469 * 470 * KEYWORD = (@ exit foreach if set switch test while) 471 */ 472 struct command * 473 syn3(struct wordent *p1, struct wordent *p2, int flags) 474 { 475 struct wordent *p; 476 struct wordent *lp, *rp; 477 struct command *t; 478 int l; 479 tchar **av; 480 int n, c; 481 bool specp = 0; 482 483 #ifdef TRACE 484 tprintf("TRACE- syn3()\n"); 485 #endif 486 if (p1 != p2) { 487 p = p1; 488 again: 489 switch (srchx(p->word)) { 490 491 case ZELSE: 492 p = p->next; 493 if (p != p2) 494 goto again; 495 break; 496 497 case ZEXIT: 498 case ZFOREACH: 499 case ZIF: 500 case ZLET: 501 case ZSET: 502 case ZSWITCH: 503 case ZWHILE: 504 specp = 1; 505 break; 506 } 507 } 508 n = 0; 509 l = 0; 510 for (p = p1; p != p2; p = p->next) 511 switch (p->word[0]) { 512 513 case '(': 514 if (specp) 515 n++; 516 l++; 517 continue; 518 519 case ')': 520 if (specp) 521 n++; 522 l--; 523 continue; 524 525 case '>': 526 case '<': 527 if (l != 0) { 528 if (specp) 529 n++; 530 continue; 531 } 532 if (p->next == p2) 533 continue; 534 if (any(p->next->word[0], RELPAR)) 535 continue; 536 n--; 537 continue; 538 539 default: 540 if (!specp && l != 0) 541 continue; 542 n++; 543 continue; 544 } 545 if (n < 0) 546 n = 0; 547 t = (struct command *)xcalloc(1, sizeof (*t)); 548 av = (tchar **)xcalloc((unsigned)(n + 1), sizeof (tchar **)); 549 t->t_dcom = av; 550 n = 0; 551 if (p2->word[0] == ')') 552 t->t_dflg = FPAR; 553 lp = 0; 554 rp = 0; 555 l = 0; 556 for (p = p1; p != p2; p = p->next) { 557 c = p->word[0]; 558 switch (c) { 559 560 case '(': 561 if (l == 0) { 562 if (lp != 0 && !specp) 563 seterr("Badly placed ("); 564 lp = p->next; 565 } 566 l++; 567 goto savep; 568 569 case ')': 570 l--; 571 if (l == 0) 572 rp = p; 573 goto savep; 574 575 case '>': 576 if (l != 0) 577 goto savep; 578 if (p->word[1] == '>') 579 t->t_dflg |= FCAT; 580 if (p->next != p2 && eq(p->next->word, S_AND /* "&" */)) { 581 t->t_dflg |= FDIAG, p = p->next; 582 if (flags & (POUT|PDIAG)) 583 goto badout; 584 } 585 if (p->next != p2 && eq(p->next->word, S_EXAS /* "!" */)) 586 t->t_dflg |= FANY, p = p->next; 587 if (p->next == p2) { 588 missfile: 589 seterr("Missing name for redirect"); 590 continue; 591 } 592 p = p->next; 593 if (any(p->word[0], RELPAR)) 594 goto missfile; 595 if ((flags & POUT) && (flags & PDIAG) == 0 || t->t_drit) 596 badout: 597 seterr("Ambiguous output redirect"); 598 else 599 t->t_drit = savestr(p->word); 600 continue; 601 602 case '<': 603 if (l != 0) 604 goto savep; 605 if (p->word[1] == '<') 606 t->t_dflg |= FHERE; 607 if (p->next == p2) 608 goto missfile; 609 p = p->next; 610 if (any(p->word[0], RELPAR)) 611 goto missfile; 612 if ((flags & PHERE) && (t->t_dflg & FHERE)) 613 seterr("Can't << within ()'s"); 614 else if ((flags & PIN) || t->t_dlef) 615 seterr("Ambiguous input redirect"); 616 else 617 t->t_dlef = savestr(p->word); 618 continue; 619 620 savep: 621 if (!specp) 622 continue; 623 default: 624 if (l != 0 && !specp) 625 continue; 626 if (err == 0) 627 av[n] = savestr(p->word); 628 n++; 629 continue; 630 } 631 } 632 if (lp != 0 && !specp) { 633 if (n != 0) 634 seterr("Badly placed ()'s"); 635 t->t_dtyp = TPAR; 636 t->t_dspr = syn0(lp, rp, PHERE); 637 } else { 638 if (n == 0) 639 seterr("Invalid null command"); 640 t->t_dtyp = TCOM; 641 } 642 return (t); 643 } 644 645 void 646 freesyn(struct command *t) 647 { 648 #ifdef TRACE 649 tprintf("TRACE- freesyn()\n"); 650 #endif 651 if (t == 0) 652 return; 653 switch (t->t_dtyp) { 654 655 case TCOM: 656 blkfree(t->t_dcom); 657 if (t->cfname) 658 xfree(t->cfname); 659 if (t->cargs) 660 chr_blkfree(t->cargs); 661 goto lr; 662 663 case TPAR: 664 freesyn(t->t_dspr); 665 /* fall into ... */ 666 667 lr: 668 xfree(t->t_dlef); 669 xfree(t->t_drit); 670 break; 671 672 case TAND: 673 case TOR: 674 case TFIL: 675 case TLST: 676 freesyn(t->t_dcar), freesyn(t->t_dcdr); 677 break; 678 } 679 xfree(t); 680 } 681 682 683 void 684 chr_blkfree(char **vec) 685 { 686 char **av; 687 688 for (av = vec; *av; av++) 689 xfree(*av); 690 xfree(vec); 691 } 692