1 /* $Header: /src/pub/tcsh/sh.parse.c,v 3.11 2002/03/08 17:36:46 christos Exp $ */ 2 /* 3 * sh.parse.c: Interpret a list of tokens 4 */ 5 /*- 6 * Copyright (c) 1980, 1991 The Regents of the University of California. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 #include "sh.h" 34 35 RCSID("$Id: sh.parse.c,v 3.11 2002/03/08 17:36:46 christos Exp $") 36 37 /* 38 * C shell 39 */ 40 static void asyntax __P((struct wordent *, struct wordent *)); 41 static void asyn0 __P((struct wordent *, struct wordent *)); 42 static void asyn3 __P((struct wordent *, struct wordent *)); 43 static struct wordent *freenod __P((struct wordent *, struct wordent *)); 44 static struct command *syn0 __P((struct wordent *, struct wordent *, int)); 45 static struct command *syn1 __P((struct wordent *, struct wordent *, int)); 46 static struct command *syn1a __P((struct wordent *, struct wordent *, int)); 47 static struct command *syn1b __P((struct wordent *, struct wordent *, int)); 48 static struct command *syn2 __P((struct wordent *, struct wordent *, int)); 49 static struct command *syn3 __P((struct wordent *, struct wordent *, int)); 50 51 #define ALEFT 51 /* max of 50 alias expansions */ 52 #define HLEFT 11 /* max of 10 history expansions */ 53 /* 54 * Perform aliasing on the word list lexp 55 * Do a (very rudimentary) parse to separate into commands. 56 * If word 0 of a command has an alias, do it. 57 * Repeat a maximum of 50 times. 58 */ 59 static int aleft; 60 extern int hleft; 61 void 62 alias(lexp) 63 register struct wordent *lexp; 64 { 65 jmp_buf_t osetexit; 66 67 aleft = ALEFT; 68 hleft = HLEFT; 69 getexit(osetexit); 70 (void) setexit(); 71 if (haderr) { 72 resexit(osetexit); 73 reset(); 74 } 75 if (--aleft == 0) 76 stderror(ERR_ALIASLOOP); 77 asyntax(lexp->next, lexp); 78 resexit(osetexit); 79 } 80 81 static void 82 asyntax(p1, p2) 83 register struct wordent *p1, *p2; 84 { 85 while (p1 != p2) 86 if (any(";&\n", p1->word[0])) 87 p1 = p1->next; 88 else { 89 asyn0(p1, p2); 90 return; 91 } 92 } 93 94 static void 95 asyn0(p1, p2) 96 struct wordent *p1; 97 register struct wordent *p2; 98 { 99 register struct wordent *p; 100 register int l = 0; 101 102 for (p = p1; p != p2; p = p->next) 103 switch (p->word[0]) { 104 105 case '(': 106 l++; 107 continue; 108 109 case ')': 110 l--; 111 if (l < 0) 112 stderror(ERR_TOOMANYRP); 113 continue; 114 115 case '>': 116 if (p->next != p2 && eq(p->next->word, STRand)) 117 p = p->next; 118 continue; 119 120 case '&': 121 case '|': 122 case ';': 123 case '\n': 124 if (l != 0) 125 continue; 126 asyn3(p1, p); 127 asyntax(p->next, p2); 128 return; 129 130 default: 131 break; 132 } 133 if (l == 0) 134 asyn3(p1, p2); 135 } 136 137 static void 138 asyn3(p1, p2) 139 struct wordent *p1; 140 register struct wordent *p2; 141 { 142 register struct varent *ap; 143 struct wordent alout; 144 register bool redid; 145 146 if (p1 == p2) 147 return; 148 if (p1->word[0] == '(') { 149 for (p2 = p2->prev; p2->word[0] != ')'; p2 = p2->prev) 150 if (p2 == p1) 151 return; 152 if (p2 == p1->next) 153 return; 154 asyn0(p1->next, p2); 155 return; 156 } 157 ap = adrof1(p1->word, &aliases); 158 if (ap == 0) 159 return; 160 alhistp = p1->prev; 161 alhistt = p2; 162 alvec = ap->vec; 163 redid = lex(&alout); 164 alhistp = alhistt = 0; 165 alvec = 0; 166 if (seterr) { 167 freelex(&alout); 168 stderror(ERR_OLD); 169 } 170 if (p1->word[0] && eq(p1->word, alout.next->word)) { 171 Char *cp = alout.next->word; 172 173 alout.next->word = Strspl(STRQNULL, cp); 174 xfree((ptr_t) cp); 175 } 176 p1 = freenod(p1, redid ? p2 : p1->next); 177 if (alout.next != &alout) { 178 p1->next->prev = alout.prev->prev; 179 alout.prev->prev->next = p1->next; 180 alout.next->prev = p1; 181 p1->next = alout.next; 182 xfree((ptr_t) alout.prev->word); 183 xfree((ptr_t) (alout.prev)); 184 } 185 reset(); /* throw! */ 186 } 187 188 static struct wordent * 189 freenod(p1, p2) 190 register struct wordent *p1, *p2; 191 { 192 register struct wordent *retp = p1->prev; 193 194 while (p1 != p2) { 195 xfree((ptr_t) p1->word); 196 p1 = p1->next; 197 xfree((ptr_t) (p1->prev)); 198 } 199 retp->next = p2; 200 p2->prev = retp; 201 return (retp); 202 } 203 204 #define P_HERE 1 205 #define P_IN 2 206 #define P_OUT 4 207 #define P_DIAG 8 208 209 /* 210 * syntax 211 * empty 212 * syn0 213 */ 214 struct command * 215 syntax(p1, p2, flags) 216 register struct wordent *p1, *p2; 217 int flags; 218 { 219 220 while (p1 != p2) 221 if (any(";&\n", p1->word[0])) 222 p1 = p1->next; 223 else 224 return (syn0(p1, p2, flags)); 225 return (0); 226 } 227 228 /* 229 * syn0 230 * syn1 231 * syn1 & syntax 232 */ 233 static struct command * 234 syn0(p1, p2, flags) 235 struct wordent *p1, *p2; 236 int flags; 237 { 238 register struct wordent *p; 239 register struct command *t, *t1; 240 int l; 241 242 l = 0; 243 for (p = p1; p != p2; p = p->next) 244 switch (p->word[0]) { 245 246 case '(': 247 l++; 248 continue; 249 250 case ')': 251 l--; 252 if (l < 0) 253 seterror(ERR_TOOMANYRP); 254 continue; 255 256 case '|': 257 if (p->word[1] == '|') 258 continue; 259 /*FALLTHROUGH*/ 260 261 case '>': 262 if (p->next != p2 && eq(p->next->word, STRand)) 263 p = p->next; 264 continue; 265 266 case '&': 267 if (l != 0) 268 break; 269 if (p->word[1] == '&') 270 continue; 271 t1 = syn1(p1, p, flags); 272 if (t1->t_dtyp == NODE_LIST || 273 t1->t_dtyp == NODE_AND || 274 t1->t_dtyp == NODE_OR) { 275 t = (struct command *) xcalloc(1, sizeof(*t)); 276 t->t_dtyp = NODE_PAREN; 277 t->t_dflg = F_AMPERSAND | F_NOINTERRUPT; 278 t->t_dspr = t1; 279 t1 = t; 280 } 281 else 282 t1->t_dflg |= F_AMPERSAND | F_NOINTERRUPT; 283 t = (struct command *) xcalloc(1, sizeof(*t)); 284 t->t_dtyp = NODE_LIST; 285 t->t_dflg = 0; 286 t->t_dcar = t1; 287 t->t_dcdr = syntax(p, p2, flags); 288 return (t); 289 default: 290 break; 291 } 292 if (l == 0) 293 return (syn1(p1, p2, flags)); 294 seterror(ERR_TOOMANYLP); 295 return (0); 296 } 297 298 /* 299 * syn1 300 * syn1a 301 * syn1a ; syntax 302 */ 303 static struct command * 304 syn1(p1, p2, flags) 305 struct wordent *p1, *p2; 306 int flags; 307 { 308 register struct wordent *p; 309 register struct command *t; 310 int l; 311 312 l = 0; 313 for (p = p1; p != p2; p = p->next) 314 switch (p->word[0]) { 315 316 case '(': 317 l++; 318 continue; 319 320 case ')': 321 l--; 322 continue; 323 324 case ';': 325 case '\n': 326 if (l != 0) 327 break; 328 t = (struct command *) xcalloc(1, sizeof(*t)); 329 t->t_dtyp = NODE_LIST; 330 t->t_dcar = syn1a(p1, p, flags); 331 t->t_dcdr = syntax(p->next, p2, flags); 332 if (t->t_dcdr == 0) 333 t->t_dcdr = t->t_dcar, t->t_dcar = 0; 334 return (t); 335 336 default: 337 break; 338 } 339 return (syn1a(p1, p2, flags)); 340 } 341 342 /* 343 * syn1a 344 * syn1b 345 * syn1b || syn1a 346 */ 347 static struct command * 348 syn1a(p1, p2, flags) 349 struct wordent *p1, *p2; 350 int flags; 351 { 352 register struct wordent *p; 353 register struct command *t; 354 register int l = 0; 355 356 for (p = p1; p != p2; p = p->next) 357 switch (p->word[0]) { 358 359 case '(': 360 l++; 361 continue; 362 363 case ')': 364 l--; 365 continue; 366 367 case '|': 368 if (p->word[1] != '|') 369 continue; 370 if (l == 0) { 371 t = (struct command *) xcalloc(1, sizeof(*t)); 372 t->t_dtyp = NODE_OR; 373 t->t_dcar = syn1b(p1, p, flags); 374 t->t_dcdr = syn1a(p->next, p2, flags); 375 t->t_dflg = 0; 376 return (t); 377 } 378 continue; 379 380 default: 381 break; 382 } 383 return (syn1b(p1, p2, flags)); 384 } 385 386 /* 387 * syn1b 388 * syn2 389 * syn2 && syn1b 390 */ 391 static struct command * 392 syn1b(p1, p2, flags) 393 struct wordent *p1, *p2; 394 int flags; 395 { 396 register struct wordent *p; 397 register struct command *t; 398 register int l = 0; 399 400 for (p = p1; p != p2; p = p->next) 401 switch (p->word[0]) { 402 403 case '(': 404 l++; 405 continue; 406 407 case ')': 408 l--; 409 continue; 410 411 case '&': 412 if (p->word[1] == '&' && l == 0) { 413 t = (struct command *) xcalloc(1, sizeof(*t)); 414 t->t_dtyp = NODE_AND; 415 t->t_dcar = syn2(p1, p, flags); 416 t->t_dcdr = syn1b(p->next, p2, flags); 417 t->t_dflg = 0; 418 return (t); 419 } 420 continue; 421 422 default: 423 break; 424 } 425 return (syn2(p1, p2, flags)); 426 } 427 428 /* 429 * syn2 430 * syn3 431 * syn3 | syn2 432 * syn3 |& syn2 433 */ 434 static struct command * 435 syn2(p1, p2, flags) 436 struct wordent *p1, *p2; 437 int flags; 438 { 439 register struct wordent *p, *pn; 440 register struct command *t; 441 register int l = 0; 442 int f; 443 444 for (p = p1; p != p2; p = p->next) 445 switch (p->word[0]) { 446 447 case '(': 448 l++; 449 continue; 450 451 case ')': 452 l--; 453 continue; 454 455 case '|': 456 if (l != 0) 457 continue; 458 t = (struct command *) xcalloc(1, sizeof(*t)); 459 f = flags | P_OUT; 460 pn = p->next; 461 if (pn != p2 && pn->word[0] == '&') { 462 f |= P_DIAG; 463 t->t_dflg |= F_STDERR; 464 } 465 t->t_dtyp = NODE_PIPE; 466 t->t_dcar = syn3(p1, p, f); 467 if (pn != p2 && pn->word[0] == '&') 468 p = pn; 469 t->t_dcdr = syn2(p->next, p2, flags | P_IN); 470 return (t); 471 472 default: 473 break; 474 } 475 return (syn3(p1, p2, flags)); 476 } 477 478 static char RELPAR[] = {'<', '>', '(', ')', '\0'}; 479 480 /* 481 * syn3 482 * ( syn0 ) [ < in ] [ > out ] 483 * word word* [ < in ] [ > out ] 484 * KEYWORD ( word* ) word* [ < in ] [ > out ] 485 * 486 * KEYWORD = (@ exit foreach if set switch test while) 487 */ 488 static struct command * 489 syn3(p1, p2, flags) 490 struct wordent *p1, *p2; 491 int flags; 492 { 493 register struct wordent *p; 494 struct wordent *lp, *rp; 495 register struct command *t; 496 register int l; 497 Char **av; 498 int n, c; 499 bool specp = 0; 500 501 if (p1 != p2) { 502 p = p1; 503 again: 504 switch (srchx(p->word)) { 505 506 case TC_ELSE: 507 p = p->next; 508 if (p != p2) 509 goto again; 510 break; 511 512 case TC_EXIT: 513 case TC_FOREACH: 514 case TC_IF: 515 case TC_LET: 516 case TC_SET: 517 case TC_SWITCH: 518 case TC_WHILE: 519 specp = 1; 520 break; 521 default: 522 break; 523 } 524 } 525 n = 0; 526 l = 0; 527 for (p = p1; p != p2; p = p->next) 528 switch (p->word[0]) { 529 530 case '(': 531 if (specp) 532 n++; 533 l++; 534 continue; 535 536 case ')': 537 if (specp) 538 n++; 539 l--; 540 continue; 541 542 case '>': 543 case '<': 544 if (l != 0) { 545 if (specp) 546 n++; 547 continue; 548 } 549 if (p->next == p2) 550 continue; 551 if (any(RELPAR, p->next->word[0])) 552 continue; 553 n--; 554 continue; 555 556 default: 557 if (!specp && l != 0) 558 continue; 559 n++; 560 continue; 561 } 562 if (n < 0) 563 n = 0; 564 t = (struct command *) xcalloc(1, sizeof(*t)); 565 av = (Char **) xcalloc((size_t) (n + 1), sizeof(Char **)); 566 t->t_dcom = av; 567 n = 0; 568 if (p2->word[0] == ')') 569 t->t_dflg = F_NOFORK; 570 lp = 0; 571 rp = 0; 572 l = 0; 573 for (p = p1; p != p2; p = p->next) { 574 c = p->word[0]; 575 switch (c) { 576 577 case '(': 578 if (l == 0) { 579 if (lp != 0 && !specp) 580 seterror(ERR_BADPLP); 581 lp = p->next; 582 } 583 l++; 584 goto savep; 585 586 case ')': 587 l--; 588 if (l == 0) 589 rp = p; 590 goto savep; 591 592 case '>': 593 if (l != 0) 594 goto savep; 595 if (p->word[1] == '>') 596 t->t_dflg |= F_APPEND; 597 if (p->next != p2 && eq(p->next->word, STRand)) { 598 t->t_dflg |= F_STDERR, p = p->next; 599 if (flags & (P_OUT | P_DIAG)) { 600 seterror(ERR_OUTRED); 601 continue; 602 } 603 } 604 if (p->next != p2 && eq(p->next->word, STRbang)) 605 t->t_dflg |= F_OVERWRITE, p = p->next; 606 if (p->next == p2) { 607 seterror(ERR_MISRED); 608 continue; 609 } 610 p = p->next; 611 if (any(RELPAR, p->word[0])) { 612 seterror(ERR_MISRED); 613 continue; 614 } 615 if (((flags & P_OUT) && (flags & P_DIAG) == 0) || t->t_drit) 616 seterror(ERR_OUTRED); 617 else 618 t->t_drit = Strsave(p->word); 619 continue; 620 621 case '<': 622 if (l != 0) 623 goto savep; 624 if (p->word[1] == '<') 625 t->t_dflg |= F_READ; 626 if (p->next == p2) { 627 seterror(ERR_MISRED); 628 continue; 629 } 630 p = p->next; 631 if (any(RELPAR, p->word[0])) { 632 seterror(ERR_MISRED); 633 continue; 634 } 635 if ((flags & P_HERE) && (t->t_dflg & F_READ)) 636 seterror(ERR_REDPAR); 637 else if ((flags & P_IN) || t->t_dlef) 638 seterror(ERR_INRED); 639 else 640 t->t_dlef = Strsave(p->word); 641 continue; 642 643 savep: 644 if (!specp) 645 continue; 646 default: 647 if (l != 0 && !specp) 648 continue; 649 if (seterr == 0) 650 av[n] = Strsave(p->word); 651 n++; 652 continue; 653 } 654 } 655 if (lp != 0 && !specp) { 656 if (n != 0) 657 seterror(ERR_BADPLPS); 658 t->t_dtyp = NODE_PAREN; 659 t->t_dspr = syn0(lp, rp, P_HERE); 660 } 661 else { 662 if (n == 0) 663 seterror(ERR_NULLCOM); 664 t->t_dtyp = NODE_COMMAND; 665 } 666 return (t); 667 } 668 669 void 670 freesyn(t) 671 register struct command *t; 672 { 673 register Char **v; 674 675 if (t == 0) 676 return; 677 switch (t->t_dtyp) { 678 679 case NODE_COMMAND: 680 for (v = t->t_dcom; *v; v++) 681 xfree((ptr_t) * v); 682 xfree((ptr_t) (t->t_dcom)); 683 xfree((ptr_t) t->t_dlef); 684 xfree((ptr_t) t->t_drit); 685 break; 686 case NODE_PAREN: 687 freesyn(t->t_dspr); 688 xfree((ptr_t) t->t_dlef); 689 xfree((ptr_t) t->t_drit); 690 break; 691 692 case NODE_AND: 693 case NODE_OR: 694 case NODE_PIPE: 695 case NODE_LIST: 696 freesyn(t->t_dcar), freesyn(t->t_dcdr); 697 break; 698 default: 699 break; 700 } 701 xfree((ptr_t) t); 702 } 703