syn.c revision 1.3
1 /* $NetBSD: syn.c,v 1.3 1998/10/09 02:45:34 erh Exp $ */ 2 3 /* 4 * shell parser (C version) 5 */ 6 7 #include "sh.h" 8 #include "c_test.h" 9 10 struct multiline_state { 11 int on; /* set in multiline commands (\n becomes ;) */ 12 int start_token; /* token multiline is for (eg, FOR, {, etc.) */ 13 int start_line; /* line multiline command started on */ 14 }; 15 16 static void yyparse ARGS((void)); 17 static struct op *pipeline ARGS((int cf)); 18 static struct op *andor ARGS((void)); 19 static struct op *c_list ARGS((void)); 20 static struct ioword *synio ARGS((int cf)); 21 static void musthave ARGS((int c, int cf)); 22 static struct op *nested ARGS((int type, int smark, int emark)); 23 static struct op *get_command ARGS((int cf)); 24 static struct op *dogroup ARGS((void)); 25 static struct op *thenpart ARGS((void)); 26 static struct op *elsepart ARGS((void)); 27 static struct op *caselist ARGS((void)); 28 static struct op *casepart ARGS((int endtok)); 29 static struct op *function_body ARGS((char *name, int ksh_func)); 30 static char ** wordlist ARGS((void)); 31 static struct op *block ARGS((int type, struct op *t1, struct op *t2, 32 char **wp)); 33 static struct op *newtp ARGS((int type)); 34 static void syntaxerr ARGS((const char *what)) 35 GCC_FUNC_ATTR(noreturn); 36 static void multiline_push ARGS((struct multiline_state *save, int tok)); 37 static void multiline_pop ARGS((struct multiline_state *saved)); 38 static int assign_command ARGS((char *s)); 39 static int inalias ARGS((struct source *s)); 40 #ifdef KSH 41 static int dbtestp_isa ARGS((Test_env *te, Test_meta meta)); 42 static const char *dbtestp_getopnd ARGS((Test_env *te, Test_op op, 43 int do_eval)); 44 static int dbtestp_eval ARGS((Test_env *te, Test_op op, const char *opnd1, 45 const char *opnd2, int do_eval)); 46 static void dbtestp_error ARGS((Test_env *te, int offset, const char *msg)); 47 #endif /* KSH */ 48 49 static struct op *outtree; /* yyparse output */ 50 51 static struct multiline_state multiline; /* \n changed to ; */ 52 53 static int reject; /* token(cf) gets symbol again */ 54 static int symbol; /* yylex value */ 55 56 #define REJECT (reject = 1) 57 #define ACCEPT (reject = 0) 58 #define token(cf) \ 59 ((reject) ? (ACCEPT, symbol) : (symbol = yylex(cf))) 60 #define tpeek(cf) \ 61 ((reject) ? (symbol) : (REJECT, symbol = yylex(cf))) 62 63 static void 64 yyparse() 65 { 66 int c; 67 68 ACCEPT; 69 yynerrs = 0; 70 71 outtree = c_list(); 72 c = tpeek(0); 73 if (c == 0 && !outtree) 74 outtree = newtp(TEOF); 75 else if (c != '\n' && c != 0) 76 syntaxerr((char *) 0); 77 } 78 79 static struct op * 80 pipeline(cf) 81 int cf; 82 { 83 register struct op *t, *p, *tl = NULL; 84 85 t = get_command(cf); 86 if (t != NULL) { 87 while (token(0) == '|') { 88 if ((p = get_command(CONTIN)) == NULL) 89 syntaxerr((char *) 0); 90 if (tl == NULL) 91 t = tl = block(TPIPE, t, p, NOWORDS); 92 else 93 tl = tl->right = block(TPIPE, tl->right, p, NOWORDS); 94 } 95 REJECT; 96 } 97 return (t); 98 } 99 100 static struct op * 101 andor() 102 { 103 register struct op *t, *p; 104 register int c; 105 106 t = pipeline(0); 107 if (t != NULL) { 108 while ((c = token(0)) == LOGAND || c == LOGOR) { 109 if ((p = pipeline(CONTIN)) == NULL) 110 syntaxerr((char *) 0); 111 t = block(c == LOGAND? TAND: TOR, t, p, NOWORDS); 112 } 113 REJECT; 114 } 115 return (t); 116 } 117 118 static struct op * 119 c_list() 120 { 121 register struct op *t, *p, *tl = NULL; 122 register int c; 123 124 t = andor(); 125 if (t != NULL) { 126 /* Token has always been read/rejected at this point, so 127 * we don't worray about what flags to pass token() 128 */ 129 while ((c = token(0)) == ';' || c == '&' || c == COPROC || 130 (c == '\n' && (multiline.on || inalias(source)))) 131 { 132 if (c == '&' || c == COPROC) { 133 int type = c == '&' ? TASYNC : TCOPROC; 134 if (tl) 135 tl->right = block(type, tl->right, 136 NOBLOCK, NOWORDS); 137 else 138 t = block(type, t, NOBLOCK, NOWORDS); 139 } 140 if ((p = andor()) == NULL) 141 return (t); 142 if (tl == NULL) 143 t = tl = block(TLIST, t, p, NOWORDS); 144 else 145 tl = tl->right = block(TLIST, tl->right, p, NOWORDS); 146 } 147 REJECT; 148 } 149 return (t); 150 } 151 152 static struct ioword * 153 synio(cf) 154 int cf; 155 { 156 register struct ioword *iop; 157 int ishere; 158 159 if (tpeek(cf) != REDIR) 160 return NULL; 161 ACCEPT; 162 iop = yylval.iop; 163 ishere = (iop->flag&IOTYPE) == IOHERE; 164 musthave(LWORD, ishere ? HEREDELIM : 0); 165 if (ishere) { 166 iop->delim = yylval.cp; 167 if (*ident != 0) /* unquoted */ 168 iop->flag |= IOEVAL; 169 if (herep >= &heres[HERES]) 170 yyerror("too many <<'s\n"); 171 *herep++ = iop; 172 } else 173 iop->name = yylval.cp; 174 return iop; 175 } 176 177 static void 178 musthave(c, cf) 179 int c, cf; 180 { 181 if ((token(cf)) != c) 182 syntaxerr((char *) 0); 183 } 184 185 static struct op * 186 nested(type, smark, emark) 187 int type, smark, emark; 188 { 189 register struct op *t; 190 struct multiline_state old_multiline; 191 192 multiline_push(&old_multiline, smark); 193 t = c_list(); 194 musthave(emark, KEYWORD|ALIAS); 195 multiline_pop(&old_multiline); 196 return (block(type, t, NOBLOCK, NOWORDS)); 197 } 198 199 static struct op * 200 get_command(cf) 201 int cf; 202 { 203 register struct op *t; 204 register int c, iopn = 0, syniocf; 205 struct ioword *iop, **iops; 206 XPtrV args, vars; 207 struct multiline_state old_multiline; 208 209 iops = (struct ioword **) alloc(sizeofN(struct ioword *, NUFILE+1), 210 ATEMP); 211 XPinit(args, 16); 212 XPinit(vars, 16); 213 214 /* Don't want to pass CONTIN if reading interactively as just hitting 215 * return would print PS2 instead of PS1. 216 */ 217 if (multiline.on || inalias(source)) 218 cf = CONTIN; 219 syniocf = KEYWORD|ALIAS; 220 switch (c = token(cf|KEYWORD|ALIAS|VARASN)) { 221 default: 222 REJECT; 223 afree((void*) iops, ATEMP); 224 XPfree(args); 225 XPfree(vars); 226 return NULL; /* empty line */ 227 228 case LWORD: 229 case REDIR: 230 REJECT; 231 syniocf &= ~(KEYWORD|ALIAS); 232 t = newtp(TCOM); 233 while (1) { 234 cf = (t->u.evalflags ? ARRAYVAR : 0) 235 | (XPsize(args) == 0 ? ALIAS|VARASN : CMDWORD); 236 switch (tpeek(cf)) { 237 case REDIR: 238 if (iopn >= NUFILE) 239 yyerror("too many redirections\n"); 240 iops[iopn++] = synio(cf); 241 break; 242 243 case LWORD: 244 ACCEPT; 245 /* the iopn == 0 and XPsize(vars) == 0 are 246 * dubious but at&t ksh acts this way 247 */ 248 if (iopn == 0 && XPsize(vars) == 0 249 && XPsize(args) == 0 250 && assign_command(ident)) 251 t->u.evalflags = DOVACHECK; 252 if ((XPsize(args) == 0 || Flag(FKEYWORD)) 253 && is_wdvarassign(yylval.cp)) 254 XPput(vars, yylval.cp); 255 else 256 XPput(args, yylval.cp); 257 break; 258 259 case '(': 260 /* Check for "> foo (echo hi)", which at&t ksh 261 * allows (not POSIX, but not disallowed) 262 */ 263 afree(t, ATEMP); 264 if (XPsize(args) == 0 && XPsize(vars) == 0) { 265 ACCEPT; 266 goto Subshell; 267 } 268 /* Must be a function */ 269 if (iopn != 0 || XPsize(args) != 1 270 || XPsize(vars) != 0) 271 syntaxerr((char *) 0); 272 ACCEPT; 273 /*(*/ 274 musthave(')', 0); 275 t = function_body(XPptrv(args)[0], FALSE); 276 goto Leave; 277 278 default: 279 goto Leave; 280 } 281 } 282 Leave: 283 break; 284 285 Subshell: 286 case '(': 287 t = nested(TPAREN, '(', ')'); 288 break; 289 290 case '{': /*}*/ 291 t = nested(TBRACE, '{', '}'); 292 break; 293 294 #ifdef KSH 295 case MDPAREN: 296 { 297 static const char let_cmd[] = { CHAR, 'l', CHAR, 'e', 298 CHAR, 't', EOS }; 299 syniocf &= ~(KEYWORD|ALIAS); 300 t = newtp(TCOM); 301 ACCEPT; 302 XPput(args, wdcopy(let_cmd, ATEMP)); 303 musthave(LWORD,LETEXPR); 304 XPput(args, yylval.cp); 305 break; 306 } 307 #endif /* KSH */ 308 309 #ifdef KSH 310 case DBRACKET: /* [[ .. ]] */ 311 syniocf &= ~(KEYWORD|ALIAS); 312 t = newtp(TDBRACKET); 313 ACCEPT; 314 { 315 Test_env te; 316 317 te.flags = TEF_DBRACKET; 318 te.pos.av = &args; 319 te.isa = dbtestp_isa; 320 te.getopnd = dbtestp_getopnd; 321 te.eval = dbtestp_eval; 322 te.error = dbtestp_error; 323 324 test_parse(&te); 325 } 326 break; 327 #endif /* KSH */ 328 329 case FOR: 330 case SELECT: 331 t = newtp((c == FOR) ? TFOR : TSELECT); 332 musthave(LWORD, ARRAYVAR); 333 if (!is_wdvarname(yylval.cp, TRUE)) 334 yyerror("%s: bad identifier\n", 335 c == FOR ? "for" : "select"); 336 t->str = str_save(ident, ATEMP); 337 multiline_push(&old_multiline, c); 338 t->vars = wordlist(); 339 t->left = dogroup(); 340 multiline_pop(&old_multiline); 341 break; 342 343 case WHILE: 344 case UNTIL: 345 multiline_push(&old_multiline, c); 346 t = newtp((c == WHILE) ? TWHILE : TUNTIL); 347 t->left = c_list(); 348 t->right = dogroup(); 349 multiline_pop(&old_multiline); 350 break; 351 352 case CASE: 353 t = newtp(TCASE); 354 musthave(LWORD, 0); 355 t->str = yylval.cp; 356 multiline_push(&old_multiline, c); 357 t->left = caselist(); 358 multiline_pop(&old_multiline); 359 break; 360 361 case IF: 362 multiline_push(&old_multiline, c); 363 t = newtp(TIF); 364 t->left = c_list(); 365 t->right = thenpart(); 366 musthave(FI, KEYWORD|ALIAS); 367 multiline_pop(&old_multiline); 368 break; 369 370 case BANG: 371 syniocf &= ~(KEYWORD|ALIAS); 372 t = pipeline(0); 373 if (t == (struct op *) 0) 374 syntaxerr((char *) 0); 375 t = block(TBANG, NOBLOCK, t, NOWORDS); 376 break; 377 378 case TIME: 379 syniocf &= ~(KEYWORD|ALIAS); 380 t = pipeline(0); 381 t = block(TTIME, t, NOBLOCK, NOWORDS); 382 break; 383 384 case FUNCTION: 385 musthave(LWORD, 0); 386 t = function_body(yylval.cp, TRUE); 387 break; 388 } 389 390 while ((iop = synio(syniocf)) != NULL) { 391 if (iopn >= NUFILE) 392 yyerror("too many redirections\n"); 393 iops[iopn++] = iop; 394 } 395 396 if (iopn == 0) { 397 afree((void*) iops, ATEMP); 398 t->ioact = NULL; 399 } else { 400 iops[iopn++] = NULL; 401 iops = (struct ioword **) aresize((void*) iops, 402 sizeofN(struct ioword *, iopn), ATEMP); 403 t->ioact = iops; 404 } 405 406 if (t->type == TCOM || t->type == TDBRACKET) { 407 XPput(args, NULL); 408 t->args = (char **) XPclose(args); 409 XPput(vars, NULL); 410 t->vars = (char **) XPclose(vars); 411 } else { 412 XPfree(args); 413 XPfree(vars); 414 } 415 416 return t; 417 } 418 419 static struct op * 420 dogroup() 421 { 422 register int c; 423 register struct op *list; 424 425 c = token(CONTIN|KEYWORD|ALIAS); 426 /* A {...} can be used instead of do...done for for/select loops 427 * but not for while/until loops - we don't need to check if it 428 * is a while loop because it would have been parsed as part of 429 * the conditional command list... 430 */ 431 if (c == DO) 432 c = DONE; 433 else if (c == '{') 434 c = '}'; 435 else 436 syntaxerr((char *) 0); 437 list = c_list(); 438 musthave(c, KEYWORD|ALIAS); 439 return list; 440 } 441 442 static struct op * 443 thenpart() 444 { 445 register struct op *t; 446 447 musthave(THEN, KEYWORD|ALIAS); 448 t = newtp(0); 449 t->left = c_list(); 450 if (t->left == NULL) 451 syntaxerr((char *) 0); 452 t->right = elsepart(); 453 return (t); 454 } 455 456 static struct op * 457 elsepart() 458 { 459 register struct op *t; 460 461 switch (token(KEYWORD|ALIAS|VARASN)) { 462 case ELSE: 463 if ((t = c_list()) == NULL) 464 syntaxerr((char *) 0); 465 return (t); 466 467 case ELIF: 468 t = newtp(TELIF); 469 t->left = c_list(); 470 t->right = thenpart(); 471 return (t); 472 473 default: 474 REJECT; 475 } 476 return NULL; 477 } 478 479 static struct op * 480 caselist() 481 { 482 register struct op *t, *tl; 483 int c; 484 485 c = token(CONTIN|KEYWORD|ALIAS); 486 /* A {...} can be used instead of in...esac for case statements */ 487 if (c == IN) 488 c = ESAC; 489 else if (c == '{') 490 c = '}'; 491 else 492 syntaxerr((char *) 0); 493 t = tl = NULL; 494 while ((tpeek(CONTIN|KEYWORD|ESACONLY)) != c) { /* no ALIAS here */ 495 struct op *tc = casepart(c); 496 if (tl == NULL) 497 t = tl = tc, tl->right = NULL; 498 else 499 tl->right = tc, tl = tc; 500 } 501 musthave(c, KEYWORD|ALIAS); 502 return (t); 503 } 504 505 static struct op * 506 casepart(endtok) 507 int endtok; 508 { 509 register struct op *t; 510 register int c; 511 XPtrV ptns; 512 513 XPinit(ptns, 16); 514 t = newtp(TPAT); 515 c = token(CONTIN|KEYWORD); /* no ALIAS here */ 516 if (c != '(') 517 REJECT; 518 do { 519 musthave(LWORD, 0); 520 XPput(ptns, yylval.cp); 521 } while ((c = token(0)) == '|'); 522 REJECT; 523 XPput(ptns, NULL); 524 t->vars = (char **) XPclose(ptns); 525 musthave(')', 0); 526 527 t->left = c_list(); 528 if ((tpeek(CONTIN|KEYWORD|ALIAS)) != endtok) 529 musthave(BREAK, CONTIN|KEYWORD|ALIAS); 530 return (t); 531 } 532 533 static struct op * 534 function_body(name, ksh_func) 535 char *name; 536 int ksh_func; /* function foo { ... } vs foo() { .. } */ 537 { 538 XString xs; 539 char *xp, *p; 540 struct op *t; 541 int old_func_parse; 542 543 Xinit(xs, xp, 16, ATEMP); 544 for (p = name; ; ) { 545 if ((*p == EOS && Xlength(xs, xp) == 0) 546 || (*p != EOS && *p != CHAR && *p != QCHAR 547 && *p != OQUOTE && *p != CQUOTE)) 548 { 549 p = snptreef((char *) 0, 32, "%S", name); 550 yyerror("%s: invalid function name\n", p); 551 } 552 Xcheck(xs, xp); 553 if (*p == EOS) { 554 Xput(xs, xp, '\0'); 555 break; 556 } else if (*p == CHAR || *p == QCHAR) { 557 Xput(xs, xp, p[1]); 558 p += 2; 559 } else 560 p++; /* OQUOTE/CQUOTE */ 561 } 562 t = newtp(TFUNCT); 563 t->str = Xclose(xs, xp); 564 t->u.ksh_func = ksh_func; 565 566 /* Note that POSIX allows only compound statements after foo(), sh and 567 * at&t ksh allow any command, go with the later since it shouldn't 568 * break anything. However, for function foo, at&t ksh only accepts 569 * an open-brace. 570 */ 571 if (ksh_func) { 572 musthave('{', CONTIN|KEYWORD|ALIAS); /* } */ 573 REJECT; 574 } 575 576 old_func_parse = e->flags & EF_FUNC_PARSE; 577 e->flags |= EF_FUNC_PARSE; 578 if ((t->left = get_command(CONTIN)) == (struct op *) 0) { 579 /* create empty command so foo(): will work */ 580 t->left = newtp(TCOM); 581 t->left->args = (char **) alloc(sizeof(char *), ATEMP); 582 t->left->args[0] = (char *) 0; 583 t->left->vars = (char **) alloc(sizeof(char *), ATEMP); 584 t->left->vars[0] = (char *) 0; 585 } 586 if (!old_func_parse) 587 e->flags &= ~EF_FUNC_PARSE; 588 589 return t; 590 } 591 592 static char ** 593 wordlist() 594 { 595 register int c; 596 XPtrV args; 597 598 XPinit(args, 16); 599 if ((c = token(CONTIN|KEYWORD|ALIAS)) != IN) { 600 if (c != ';') /* non-POSIX, but at&t ksh accepts a ; here */ 601 REJECT; 602 return NULL; 603 } 604 while ((c = token(0)) == LWORD) 605 XPput(args, yylval.cp); 606 if (c != '\n' && c != ';') 607 syntaxerr((char *) 0); 608 if (XPsize(args) == 0) { 609 XPfree(args); 610 return NULL; 611 } else { 612 XPput(args, NULL); 613 return (char **) XPclose(args); 614 } 615 } 616 617 /* 618 * supporting functions 619 */ 620 621 static struct op * 622 block(type, t1, t2, wp) 623 int type; 624 struct op *t1, *t2; 625 char **wp; 626 { 627 register struct op *t; 628 629 t = newtp(type); 630 t->left = t1; 631 t->right = t2; 632 t->vars = wp; 633 return (t); 634 } 635 636 const struct tokeninfo { 637 const char *name; 638 short val; 639 short reserved; 640 } tokentab[] = { 641 /* Reserved words */ 642 { "if", IF, TRUE }, 643 { "then", THEN, TRUE }, 644 { "else", ELSE, TRUE }, 645 { "elif", ELIF, TRUE }, 646 { "fi", FI, TRUE }, 647 { "case", CASE, TRUE }, 648 { "esac", ESAC, TRUE }, 649 { "for", FOR, TRUE }, 650 #ifdef KSH 651 { "select", SELECT, TRUE }, 652 #endif /* KSH */ 653 { "while", WHILE, TRUE }, 654 { "until", UNTIL, TRUE }, 655 { "do", DO, TRUE }, 656 { "done", DONE, TRUE }, 657 { "in", IN, TRUE }, 658 { "function", FUNCTION, TRUE }, 659 { "time", TIME, TRUE }, 660 { "{", '{', TRUE }, 661 { "}", '}', TRUE }, 662 { "!", BANG, TRUE }, 663 #ifdef KSH 664 { "[[", DBRACKET, TRUE }, 665 #endif /* KSH */ 666 /* Lexical tokens (0[EOF], LWORD and REDIR handled specially) */ 667 { "&&", LOGAND, FALSE }, 668 { "||", LOGOR, FALSE }, 669 { ";;", BREAK, FALSE }, 670 #ifdef KSH 671 { "((", MDPAREN, FALSE }, 672 { "|&", COPROC, FALSE }, 673 #endif /* KSH */ 674 /* and some special cases... */ 675 { "newline", '\n', FALSE }, 676 { 0 } 677 }; 678 679 void 680 initkeywords() 681 { 682 register struct tokeninfo const *tt; 683 register struct tbl *p; 684 685 tinit(&keywords, APERM, 32); /* must be 2^n (currently 20 keywords) */ 686 for (tt = tokentab; tt->name; tt++) { 687 if (tt->reserved) { 688 p = tenter(&keywords, tt->name, hash(tt->name)); 689 p->flag |= DEFINED|ISSET; 690 p->type = CKEYWD; 691 p->val.i = tt->val; 692 } 693 } 694 } 695 696 static void 697 syntaxerr(what) 698 const char *what; 699 { 700 char redir[6]; /* 2<<- is the longest redirection, I think */ 701 const char *s; 702 struct tokeninfo const *tt; 703 int c; 704 705 if (!what) 706 what = "unexpected"; 707 REJECT; 708 c = token(0); 709 Again: 710 switch (c) { 711 case 0: 712 if (multiline.on && multiline.start_token) { 713 multiline.on = FALSE; /* avoid infinate loops */ 714 c = multiline.start_token; 715 source->errline = multiline.start_line; 716 what = "unmatched"; 717 goto Again; 718 } 719 /* don't quote the EOF */ 720 yyerror("syntax error: unexpected EOF\n"); 721 /*NOTREACHED*/ 722 723 case LWORD: 724 s = snptreef((char *) 0, 32, "%S", yylval.cp); 725 break; 726 727 case REDIR: 728 s = snptreef(redir, sizeof(redir), "%R", yylval.iop); 729 break; 730 731 default: 732 for (tt = tokentab; tt->name; tt++) 733 if (tt->val == c) 734 break; 735 if (tt->name) 736 s = tt->name; 737 else { 738 if (c > 0 && c < 256) { 739 redir[0] = c; 740 redir[1] = '\0'; 741 } else 742 shf_snprintf(redir, sizeof(redir), 743 "?%d", c); 744 s = redir; 745 } 746 } 747 yyerror("syntax error: `%s' %s\n", s, what); 748 } 749 750 static void 751 multiline_push(save, tok) 752 struct multiline_state *save; 753 int tok; 754 { 755 *save = multiline; 756 multiline.on = TRUE; 757 multiline.start_token = tok; 758 multiline.start_line = source->line; 759 } 760 761 static void 762 multiline_pop(saved) 763 struct multiline_state *saved; 764 { 765 multiline = *saved; 766 } 767 768 static struct op * 769 newtp(type) 770 int type; 771 { 772 register struct op *t; 773 774 t = (struct op *) alloc(sizeof(*t), ATEMP); 775 t->type = type; 776 t->u.evalflags = 0; 777 t->args = t->vars = NULL; 778 t->ioact = NULL; 779 t->left = t->right = NULL; 780 t->str = NULL; 781 return (t); 782 } 783 784 struct op * 785 compile(s) 786 Source *s; 787 { 788 yynerrs = 0; 789 multiline.on = s->type == SSTRING; 790 multiline.start_token = 0; 791 multiline.start_line = 0; 792 herep = heres; 793 source = s; 794 yyparse(); 795 return outtree; 796 } 797 798 /* This kludge exists to take care of sh/at&t ksh oddity in which 799 * the arguments of alias/export/readonly/typeset have no field 800 * splitting, file globbing, or (normal) tilde expansion done. 801 * at&t ksh seems to do something similar to this since 802 * $ touch a=a; typeset a=[ab]; echo "$a" 803 * a=[ab] 804 * $ x=typeset; $x a=[ab]; echo "$a" 805 * a=a 806 * $ 807 */ 808 static int 809 assign_command(s) 810 char *s; 811 { 812 char c = *s; 813 814 if (Flag(FPOSIX) || !*s) 815 return 0; 816 return (c == 'a' && strcmp(s, "alias") == 0) 817 || (c == 'e' && strcmp(s, "export") == 0) 818 || (c == 'r' && strcmp(s, "readonly") == 0) 819 || (c == 't' && strcmp(s, "typeset") == 0); 820 } 821 822 /* Check if we are in the middle of reading an alias */ 823 static int 824 inalias(s) 825 struct source *s; 826 { 827 for (; s && s->type == SALIAS; s = s->next) 828 if (!(s->flags & SF_ALIASEND)) 829 return 1; 830 return 0; 831 } 832 833 834 #ifdef KSH 835 /* Order important - indexed by Test_meta values 836 * Note that ||, &&, ( and ) can't appear in as unquoted strings 837 * in normal shell input, so these can be interpreted unambiguously 838 * in the evaluation pass. 839 */ 840 static const char dbtest_or[] = { CHAR, '|', CHAR, '|', EOS }; 841 static const char dbtest_and[] = { CHAR, '&', CHAR, '&', EOS }; 842 static const char dbtest_not[] = { CHAR, '!', EOS }; 843 static const char dbtest_oparen[] = { CHAR, '(', EOS }; 844 static const char dbtest_cparen[] = { CHAR, ')', EOS }; 845 const char *const dbtest_tokens[] = { 846 dbtest_or, dbtest_and, dbtest_not, 847 dbtest_oparen, dbtest_cparen 848 }; 849 const char db_close[] = { CHAR, ']', CHAR, ']', EOS }; 850 const char db_lthan[] = { CHAR, '<', EOS }; 851 const char db_gthan[] = { CHAR, '>', EOS }; 852 853 /* Test if the current token is a whatever. Accepts the current token if 854 * it is. Returns 0 if it is not, non-zero if it is (in the case of 855 * TM_UNOP and TM_BINOP, the returned value is a Test_op). 856 */ 857 static int 858 dbtestp_isa(te, meta) 859 Test_env *te; 860 Test_meta meta; 861 { 862 int c = tpeek(ARRAYVAR | (meta == TM_BINOP ? 0 : CONTIN)); 863 int uqword = 0; 864 char *save = (char *) 0; 865 int ret = 0; 866 867 /* unquoted word? */ 868 uqword = c == LWORD && *ident; 869 870 if (meta == TM_OR) 871 ret = c == LOGOR; 872 else if (meta == TM_AND) 873 ret = c == LOGAND; 874 else if (meta == TM_NOT) 875 ret = uqword && strcmp(yylval.cp, dbtest_tokens[(int) TM_NOT]) == 0; 876 else if (meta == TM_OPAREN) 877 ret = c == '(' /*)*/; 878 else if (meta == TM_CPAREN) 879 ret = c == /*(*/ ')'; 880 else if (meta == TM_UNOP || meta == TM_BINOP) { 881 if (meta == TM_BINOP && c == REDIR 882 && (yylval.iop->flag == IOREAD 883 || yylval.iop->flag == IOWRITE)) 884 { 885 ret = 1; 886 save = wdcopy(yylval.iop->flag == IOREAD ? 887 db_lthan : db_gthan, ATEMP); 888 } else if (uqword && (ret = (int) test_isop(te, meta, ident))) 889 save = yylval.cp; 890 } else /* meta == TM_END */ 891 ret = uqword && strcmp(yylval.cp, db_close) == 0; 892 if (ret) { 893 ACCEPT; 894 if (meta != TM_END) { 895 if (!save) 896 save = wdcopy(dbtest_tokens[(int) meta], ATEMP); 897 XPput(*te->pos.av, save); 898 } 899 } 900 return ret; 901 } 902 903 static const char * 904 dbtestp_getopnd(te, op, do_eval) 905 Test_env *te; 906 Test_op op; 907 int do_eval; 908 { 909 int c = tpeek(ARRAYVAR); 910 911 if (c != LWORD) 912 return (const char *) 0; 913 914 ACCEPT; 915 XPput(*te->pos.av, yylval.cp); 916 917 return null; 918 } 919 920 static int 921 dbtestp_eval(te, op, opnd1, opnd2, do_eval) 922 Test_env *te; 923 Test_op op; 924 const char *opnd1; 925 const char *opnd2; 926 int do_eval; 927 { 928 return 1; 929 } 930 931 static void 932 dbtestp_error(te, offset, msg) 933 Test_env *te; 934 int offset; 935 const char *msg; 936 { 937 te->flags |= TEF_ERROR; 938 939 if (offset < 0) { 940 REJECT; 941 /* Kludgy to say the least... */ 942 symbol = LWORD; 943 yylval.cp = *(XPptrv(*te->pos.av) + XPsize(*te->pos.av) 944 + offset); 945 } 946 syntaxerr(msg); 947 } 948 #endif /* KSH */ 949
Indexes created Tue Sep 23 20:09:58 GMT 2025