1 /* $OpenBSD: syn.c,v 1.30 2015/09/01 13:12:31 tedu Exp $ */ 2 3 /*- 4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 5 * 2011, 2012, 2013, 2014, 2015, 2016, 2017, 6 * 2018 7 * mirabilos <m (at) mirbsd.org> 8 * 9 * Provided that these terms and disclaimer and all copyright notices 10 * are retained or reproduced in an accompanying document, permission 11 * is granted to deal in this work without restriction, including un- 12 * limited rights to use, publicly perform, distribute, sell, modify, 13 * merge, give away, or sublicence. 14 * 15 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 16 * the utmost extent permitted by applicable law, neither express nor 17 * implied; without malicious intent or gross negligence. In no event 18 * may a licensor, author or contributor be held liable for indirect, 19 * direct, other damage, loss, or other issues arising in any way out 20 * of dealing in the work, even if advised of the possibility of such 21 * damage or existence of a defect, except proven that it results out 22 * of said person's immediate fault when using the work as intended. 23 */ 24 25 #include "sh.h" 26 27 __RCSID("$MirOS: src/bin/mksh/syn.c,v 1.127 2018/01/14 00:22:30 tg Exp $"); 28 29 struct nesting_state { 30 int start_token; /* token than began nesting (eg, FOR) */ 31 int start_line; /* line nesting began on */ 32 }; 33 34 struct yyrecursive_state { 35 struct ioword *old_heres[HERES]; 36 struct yyrecursive_state *next; 37 struct ioword **old_herep; 38 int old_symbol; 39 unsigned int old_nesting_type; 40 bool old_reject; 41 }; 42 43 static void yyparse(bool); 44 static struct op *pipeline(int, int); 45 static struct op *andor(int); 46 static struct op *c_list(int, bool); 47 static struct ioword *synio(int); 48 static struct op *nested(int, int, int, int); 49 static struct op *get_command(int, int); 50 static struct op *dogroup(int); 51 static struct op *thenpart(int); 52 static struct op *elsepart(int); 53 static struct op *caselist(int); 54 static struct op *casepart(int, int); 55 static struct op *function_body(char *, int, bool); 56 static char **wordlist(int); 57 static struct op *block(int, struct op *, struct op *); 58 static struct op *newtp(int); 59 static void syntaxerr(const char *) MKSH_A_NORETURN; 60 static void nesting_push(struct nesting_state *, int); 61 static void nesting_pop(struct nesting_state *); 62 static int inalias(struct source *) MKSH_A_PURE; 63 static Test_op dbtestp_isa(Test_env *, Test_meta); 64 static const char *dbtestp_getopnd(Test_env *, Test_op, bool); 65 static int dbtestp_eval(Test_env *, Test_op, const char *, 66 const char *, bool); 67 static void dbtestp_error(Test_env *, int, const char *) MKSH_A_NORETURN; 68 69 static struct op *outtree; /* yyparse output */ 70 static struct nesting_state nesting; /* \n changed to ; */ 71 72 static bool reject; /* token(cf) gets symbol again */ 73 static int symbol; /* yylex value */ 74 75 #define REJECT (reject = true) 76 #define ACCEPT (reject = false) 77 #define token(cf) ((reject) ? (ACCEPT, symbol) : (symbol = yylex(cf))) 78 #define tpeek(cf) ((reject) ? (symbol) : (REJECT, symbol = yylex(cf))) 79 #define musthave(c,cf) do { \ 80 if ((unsigned int)token(cf) != (unsigned int)(c)) \ 81 syntaxerr(NULL); \ 82 } while (/* CONSTCOND */ 0) 83 84 static const char Tcbrace[] = "}"; 85 static const char Tesac[] = "esac"; 86 87 static void 88 yyparse(bool doalias) 89 { 90 int c; 91 92 ACCEPT; 93 94 outtree = c_list(doalias ? ALIAS : 0, source->type == SSTRING); 95 c = tpeek(0); 96 if (c == 0 && !outtree) 97 outtree = newtp(TEOF); 98 else if (!cinttype(c, C_LF | C_NUL)) 99 syntaxerr(NULL); 100 } 101 102 static struct op * 103 pipeline(int cf, int sALIAS) 104 { 105 struct op *t, *p, *tl = NULL; 106 107 t = get_command(cf, sALIAS); 108 if (t != NULL) { 109 while (token(0) == '|') { 110 if ((p = get_command(CONTIN, sALIAS)) == NULL) 111 syntaxerr(NULL); 112 if (tl == NULL) 113 t = tl = block(TPIPE, t, p); 114 else 115 tl = tl->right = block(TPIPE, tl->right, p); 116 } 117 REJECT; 118 } 119 return (t); 120 } 121 122 static struct op * 123 andor(int sALIAS) 124 { 125 struct op *t, *p; 126 int c; 127 128 t = pipeline(0, sALIAS); 129 if (t != NULL) { 130 while ((c = token(0)) == LOGAND || c == LOGOR) { 131 if ((p = pipeline(CONTIN, sALIAS)) == NULL) 132 syntaxerr(NULL); 133 t = block(c == LOGAND? TAND: TOR, t, p); 134 } 135 REJECT; 136 } 137 return (t); 138 } 139 140 static struct op * 141 c_list(int sALIAS, bool multi) 142 { 143 struct op *t = NULL, *p, *tl = NULL; 144 int c; 145 bool have_sep; 146 147 while (/* CONSTCOND */ 1) { 148 p = andor(sALIAS); 149 /* 150 * Token has always been read/rejected at this point, so 151 * we don't worry about what flags to pass token() 152 */ 153 c = token(0); 154 have_sep = true; 155 if (c == '\n' && (multi || inalias(source))) { 156 if (!p) 157 /* ignore blank lines */ 158 continue; 159 } else if (!p) 160 break; 161 else if (c == '&' || c == COPROC) 162 p = block(c == '&' ? TASYNC : TCOPROC, p, NULL); 163 else if (c != ';') 164 have_sep = false; 165 if (!t) 166 t = p; 167 else if (!tl) 168 t = tl = block(TLIST, t, p); 169 else 170 tl = tl->right = block(TLIST, tl->right, p); 171 if (!have_sep) 172 break; 173 } 174 REJECT; 175 return (t); 176 } 177 178 static const char IONDELIM_delim[] = { CHAR, '<', CHAR, '<', EOS }; 179 180 static struct ioword * 181 synio(int cf) 182 { 183 struct ioword *iop; 184 static struct ioword *nextiop; 185 bool ishere; 186 187 if (nextiop != NULL) { 188 iop = nextiop; 189 nextiop = NULL; 190 return (iop); 191 } 192 193 if (tpeek(cf) != REDIR) 194 return (NULL); 195 ACCEPT; 196 iop = yylval.iop; 197 ishere = (iop->ioflag & IOTYPE) == IOHERE; 198 if (iop->ioflag & IOHERESTR) { 199 musthave(LWORD, 0); 200 } else if (ishere && tpeek(HEREDELIM) == '\n') { 201 ACCEPT; 202 yylval.cp = wdcopy(IONDELIM_delim, ATEMP); 203 iop->ioflag |= IOEVAL | IONDELIM; 204 } else 205 musthave(LWORD, ishere ? HEREDELIM : 0); 206 if (ishere) { 207 iop->delim = yylval.cp; 208 if (*ident != 0 && !(iop->ioflag & IOHERESTR)) { 209 /* unquoted */ 210 iop->ioflag |= IOEVAL; 211 } 212 if (herep > &heres[HERES - 1]) 213 yyerror(Tf_toomany, "<<"); 214 *herep++ = iop; 215 } else 216 iop->ioname = yylval.cp; 217 218 if (iop->ioflag & IOBASH) { 219 char *cp; 220 221 nextiop = alloc(sizeof(*iop), ATEMP); 222 nextiop->ioname = cp = alloc(3, ATEMP); 223 *cp++ = CHAR; 224 *cp++ = digits_lc[iop->unit % 10]; 225 *cp = EOS; 226 227 iop->ioflag &= ~IOBASH; 228 nextiop->unit = 2; 229 nextiop->ioflag = IODUP; 230 nextiop->delim = NULL; 231 nextiop->heredoc = NULL; 232 } 233 return (iop); 234 } 235 236 static struct op * 237 nested(int type, int smark, int emark, int sALIAS) 238 { 239 struct op *t; 240 struct nesting_state old_nesting; 241 242 nesting_push(&old_nesting, smark); 243 t = c_list(sALIAS, true); 244 musthave(emark, KEYWORD|sALIAS); 245 nesting_pop(&old_nesting); 246 return (block(type, t, NULL)); 247 } 248 249 static const char builtin_cmd[] = { 250 QCHAR, '\\', CHAR, 'b', CHAR, 'u', CHAR, 'i', 251 CHAR, 'l', CHAR, 't', CHAR, 'i', CHAR, 'n', EOS 252 }; 253 static const char let_cmd[] = { 254 CHAR, 'l', CHAR, 'e', CHAR, 't', EOS 255 }; 256 static const char setA_cmd0[] = { 257 CHAR, 's', CHAR, 'e', CHAR, 't', EOS 258 }; 259 static const char setA_cmd1[] = { 260 CHAR, '-', CHAR, 'A', EOS 261 }; 262 static const char setA_cmd2[] = { 263 CHAR, '-', CHAR, '-', EOS 264 }; 265 266 static struct op * 267 get_command(int cf, int sALIAS) 268 { 269 struct op *t; 270 int c, iopn = 0, syniocf, lno; 271 struct ioword *iop, **iops; 272 XPtrV args, vars; 273 struct nesting_state old_nesting; 274 275 /* NUFILE is small enough to leave this addition unchecked */ 276 iops = alloc2((NUFILE + 1), sizeof(struct ioword *), ATEMP); 277 XPinit(args, 16); 278 XPinit(vars, 16); 279 280 syniocf = KEYWORD|sALIAS; 281 switch (c = token(cf|KEYWORD|sALIAS|CMDASN)) { 282 default: 283 REJECT; 284 afree(iops, ATEMP); 285 XPfree(args); 286 XPfree(vars); 287 /* empty line */ 288 return (NULL); 289 290 case LWORD: 291 case REDIR: 292 REJECT; 293 syniocf &= ~(KEYWORD|sALIAS); 294 t = newtp(TCOM); 295 t->lineno = source->line; 296 goto get_command_start; 297 while (/* CONSTCOND */ 1) { 298 bool check_decl_utility; 299 300 if (XPsize(args) == 0) { 301 get_command_start: 302 check_decl_utility = true; 303 cf = sALIAS | CMDASN; 304 } else if (t->u.evalflags) 305 cf = CMDWORD | CMDASN; 306 else 307 cf = CMDWORD; 308 switch (tpeek(cf)) { 309 case REDIR: 310 while ((iop = synio(cf)) != NULL) { 311 if (iopn >= NUFILE) 312 yyerror(Tf_toomany, 313 Tredirection); 314 iops[iopn++] = iop; 315 } 316 break; 317 318 case LWORD: 319 ACCEPT; 320 if (check_decl_utility) { 321 struct tbl *tt = get_builtin(ident); 322 uint32_t flag; 323 324 flag = tt ? tt->flag : 0; 325 if (flag & DECL_UTIL) 326 t->u.evalflags = DOVACHECK; 327 if (!(flag & DECL_FWDR)) 328 check_decl_utility = false; 329 } 330 if ((XPsize(args) == 0 || Flag(FKEYWORD)) && 331 is_wdvarassign(yylval.cp)) 332 XPput(vars, yylval.cp); 333 else 334 XPput(args, yylval.cp); 335 break; 336 337 case ORD('(' /*)*/): 338 if (XPsize(args) == 0 && XPsize(vars) == 1 && 339 is_wdvarassign(yylval.cp)) { 340 char *tcp; 341 342 /* wdarrassign: foo=(bar) */ 343 ACCEPT; 344 345 /* manipulate the vars string */ 346 tcp = XPptrv(vars)[(vars.len = 0)]; 347 /* 'varname=' -> 'varname' */ 348 tcp[wdscan(tcp, EOS) - tcp - 3] = EOS; 349 350 /* construct new args strings */ 351 XPput(args, wdcopy(builtin_cmd, ATEMP)); 352 XPput(args, wdcopy(setA_cmd0, ATEMP)); 353 XPput(args, wdcopy(setA_cmd1, ATEMP)); 354 XPput(args, tcp); 355 XPput(args, wdcopy(setA_cmd2, ATEMP)); 356 357 /* slurp in words till closing paren */ 358 while (token(CONTIN) == LWORD) 359 XPput(args, yylval.cp); 360 if (symbol != /*(*/ ')') 361 syntaxerr(NULL); 362 } else { 363 /* 364 * Check for "> foo (echo hi)" 365 * which AT&T ksh allows (not 366 * POSIX, but not disallowed) 367 */ 368 afree(t, ATEMP); 369 if (XPsize(args) == 0 && 370 XPsize(vars) == 0) { 371 ACCEPT; 372 goto Subshell; 373 } 374 375 /* must be a function */ 376 if (iopn != 0 || XPsize(args) != 1 || 377 XPsize(vars) != 0) 378 syntaxerr(NULL); 379 ACCEPT; 380 musthave(/*(*/ ')', 0); 381 t = function_body(XPptrv(args)[0], 382 sALIAS, false); 383 } 384 goto Leave; 385 386 default: 387 goto Leave; 388 } 389 } 390 Leave: 391 break; 392 393 case ORD('(' /*)*/): { 394 unsigned int subshell_nesting_type_saved; 395 Subshell: 396 subshell_nesting_type_saved = subshell_nesting_type; 397 subshell_nesting_type = ORD(')'); 398 t = nested(TPAREN, ORD('('), ORD(')'), sALIAS); 399 subshell_nesting_type = subshell_nesting_type_saved; 400 break; 401 } 402 403 case ORD('{' /*}*/): 404 t = nested(TBRACE, ORD('{'), ORD('}'), sALIAS); 405 break; 406 407 case MDPAREN: 408 /* leave KEYWORD in syniocf (allow if (( 1 )) then ...) */ 409 lno = source->line; 410 ACCEPT; 411 switch (token(LETEXPR)) { 412 case LWORD: 413 break; 414 case ORD('(' /*)*/): 415 c = ORD('('); 416 goto Subshell; 417 default: 418 syntaxerr(NULL); 419 } 420 t = newtp(TCOM); 421 t->lineno = lno; 422 XPput(args, wdcopy(builtin_cmd, ATEMP)); 423 XPput(args, wdcopy(let_cmd, ATEMP)); 424 XPput(args, yylval.cp); 425 break; 426 427 case DBRACKET: /* [[ .. ]] */ 428 /* leave KEYWORD in syniocf (allow if [[ -n 1 ]] then ...) */ 429 t = newtp(TDBRACKET); 430 ACCEPT; 431 { 432 Test_env te; 433 434 te.flags = TEF_DBRACKET; 435 te.pos.av = &args; 436 te.isa = dbtestp_isa; 437 te.getopnd = dbtestp_getopnd; 438 te.eval = dbtestp_eval; 439 te.error = dbtestp_error; 440 441 test_parse(&te); 442 } 443 break; 444 445 case FOR: 446 case SELECT: 447 t = newtp((c == FOR) ? TFOR : TSELECT); 448 musthave(LWORD, CMDASN); 449 if (!is_wdvarname(yylval.cp, true)) 450 yyerror("%s: bad identifier", 451 c == FOR ? "for" : Tselect); 452 strdupx(t->str, ident, ATEMP); 453 nesting_push(&old_nesting, c); 454 t->vars = wordlist(sALIAS); 455 t->left = dogroup(sALIAS); 456 nesting_pop(&old_nesting); 457 break; 458 459 case WHILE: 460 case UNTIL: 461 nesting_push(&old_nesting, c); 462 t = newtp((c == WHILE) ? TWHILE : TUNTIL); 463 t->left = c_list(sALIAS, true); 464 t->right = dogroup(sALIAS); 465 nesting_pop(&old_nesting); 466 break; 467 468 case CASE: 469 t = newtp(TCASE); 470 musthave(LWORD, 0); 471 t->str = yylval.cp; 472 nesting_push(&old_nesting, c); 473 t->left = caselist(sALIAS); 474 nesting_pop(&old_nesting); 475 break; 476 477 case IF: 478 nesting_push(&old_nesting, c); 479 t = newtp(TIF); 480 t->left = c_list(sALIAS, true); 481 t->right = thenpart(sALIAS); 482 musthave(FI, KEYWORD|sALIAS); 483 nesting_pop(&old_nesting); 484 break; 485 486 case BANG: 487 syniocf &= ~(KEYWORD|sALIAS); 488 t = pipeline(0, sALIAS); 489 if (t == NULL) 490 syntaxerr(NULL); 491 t = block(TBANG, NULL, t); 492 break; 493 494 case TIME: 495 syniocf &= ~(KEYWORD|sALIAS); 496 t = pipeline(0, sALIAS); 497 if (t && t->type == TCOM) { 498 t->str = alloc(2, ATEMP); 499 /* TF_* flags */ 500 t->str[0] = '\0'; 501 t->str[1] = '\0'; 502 } 503 t = block(TTIME, t, NULL); 504 break; 505 506 case FUNCTION: 507 musthave(LWORD, 0); 508 t = function_body(yylval.cp, sALIAS, true); 509 break; 510 } 511 512 while ((iop = synio(syniocf)) != NULL) { 513 if (iopn >= NUFILE) 514 yyerror(Tf_toomany, Tredirection); 515 iops[iopn++] = iop; 516 } 517 518 if (iopn == 0) { 519 afree(iops, ATEMP); 520 t->ioact = NULL; 521 } else { 522 iops[iopn++] = NULL; 523 iops = aresize2(iops, iopn, sizeof(struct ioword *), ATEMP); 524 t->ioact = iops; 525 } 526 527 if (t->type == TCOM || t->type == TDBRACKET) { 528 XPput(args, NULL); 529 t->args = (const char **)XPclose(args); 530 XPput(vars, NULL); 531 t->vars = (char **)XPclose(vars); 532 } else { 533 XPfree(args); 534 XPfree(vars); 535 } 536 537 if (c == MDPAREN) { 538 t = block(TBRACE, t, NULL); 539 t->ioact = t->left->ioact; 540 t->left->ioact = NULL; 541 } 542 543 return (t); 544 } 545 546 static struct op * 547 dogroup(int sALIAS) 548 { 549 int c; 550 struct op *list; 551 552 c = token(CONTIN|KEYWORD|sALIAS); 553 /* 554 * A {...} can be used instead of do...done for for/select loops 555 * but not for while/until loops - we don't need to check if it 556 * is a while loop because it would have been parsed as part of 557 * the conditional command list... 558 */ 559 if (c == DO) 560 c = DONE; 561 else if ((unsigned int)c == ORD('{')) 562 c = ORD('}'); 563 else 564 syntaxerr(NULL); 565 list = c_list(sALIAS, true); 566 musthave(c, KEYWORD|sALIAS); 567 return (list); 568 } 569 570 static struct op * 571 thenpart(int sALIAS) 572 { 573 struct op *t; 574 575 musthave(THEN, KEYWORD|sALIAS); 576 t = newtp(0); 577 t->left = c_list(sALIAS, true); 578 if (t->left == NULL) 579 syntaxerr(NULL); 580 t->right = elsepart(sALIAS); 581 return (t); 582 } 583 584 static struct op * 585 elsepart(int sALIAS) 586 { 587 struct op *t; 588 589 switch (token(KEYWORD|sALIAS|CMDASN)) { 590 case ELSE: 591 if ((t = c_list(sALIAS, true)) == NULL) 592 syntaxerr(NULL); 593 return (t); 594 595 case ELIF: 596 t = newtp(TELIF); 597 t->left = c_list(sALIAS, true); 598 t->right = thenpart(sALIAS); 599 return (t); 600 601 default: 602 REJECT; 603 } 604 return (NULL); 605 } 606 607 static struct op * 608 caselist(int sALIAS) 609 { 610 struct op *t, *tl; 611 int c; 612 613 c = token(CONTIN|KEYWORD|sALIAS); 614 /* A {...} can be used instead of in...esac for case statements */ 615 if (c == IN) 616 c = ESAC; 617 else if ((unsigned int)c == ORD('{')) 618 c = ORD('}'); 619 else 620 syntaxerr(NULL); 621 t = tl = NULL; 622 /* no ALIAS here */ 623 while ((tpeek(CONTIN|KEYWORD|ESACONLY)) != c) { 624 struct op *tc = casepart(c, sALIAS); 625 if (tl == NULL) 626 t = tl = tc, tl->right = NULL; 627 else 628 tl->right = tc, tl = tc; 629 } 630 musthave(c, KEYWORD|sALIAS); 631 return (t); 632 } 633 634 static struct op * 635 casepart(int endtok, int sALIAS) 636 { 637 struct op *t; 638 XPtrV ptns; 639 640 XPinit(ptns, 16); 641 t = newtp(TPAT); 642 /* no ALIAS here */ 643 if ((unsigned int)token(CONTIN | KEYWORD) != ORD('(')) 644 REJECT; 645 do { 646 switch (token(0)) { 647 case LWORD: 648 break; 649 case ORD('}'): 650 case ESAC: 651 if (symbol != endtok) { 652 strdupx(yylval.cp, (unsigned int)symbol == 653 ORD('}') ? Tcbrace : Tesac, ATEMP); 654 break; 655 } 656 /* FALLTHROUGH */ 657 default: 658 syntaxerr(NULL); 659 } 660 XPput(ptns, yylval.cp); 661 } while (token(0) == '|'); 662 REJECT; 663 XPput(ptns, NULL); 664 t->vars = (char **)XPclose(ptns); 665 musthave(ORD(')'), 0); 666 667 t->left = c_list(sALIAS, true); 668 669 /* initialise to default for ;; or omitted */ 670 t->u.charflag = ORD(';'); 671 /* SUSv4 requires the ;; except in the last casepart */ 672 if ((tpeek(CONTIN|KEYWORD|sALIAS)) != endtok) 673 switch (symbol) { 674 default: 675 syntaxerr(NULL); 676 case BRKEV: 677 t->u.charflag = ORD('|'); 678 if (0) 679 /* FALLTHROUGH */ 680 case BRKFT: 681 t->u.charflag = ORD('&'); 682 /* FALLTHROUGH */ 683 case BREAK: 684 /* initialised above, but we need to eat the token */ 685 ACCEPT; 686 } 687 return (t); 688 } 689 690 static struct op * 691 function_body(char *name, int sALIAS, 692 /* function foo { ... } vs foo() { .. } */ 693 bool ksh_func) 694 { 695 char *sname, *p; 696 struct op *t; 697 698 sname = wdstrip(name, 0); 699 /*- 700 * Check for valid characters in name. POSIX and AT&T ksh93 say 701 * only allow [a-zA-Z_0-9] but this allows more as old pdkshs 702 * have allowed more; the following were never allowed: 703 * NUL TAB NL SP " $ & ' ( ) ; < = > \ ` | 704 * C_QUOTE|C_SPC covers all but adds # * ? [ ] 705 */ 706 for (p = sname; *p; p++) 707 if (ctype(*p, C_QUOTE | C_SPC)) 708 yyerror(Tinvname, sname, Tfunction); 709 710 /* 711 * Note that POSIX allows only compound statements after foo(), 712 * sh and AT&T ksh allow any command, go with the later since it 713 * shouldn't break anything. However, for function foo, AT&T ksh 714 * only accepts an open-brace. 715 */ 716 if (ksh_func) { 717 if ((unsigned int)tpeek(CONTIN|KEYWORD|sALIAS) == ORD('(' /*)*/)) { 718 /* function foo () { //}*/ 719 ACCEPT; 720 musthave(ORD(/*(*/ ')'), 0); 721 /* degrade to POSIX function */ 722 ksh_func = false; 723 } 724 musthave(ORD('{' /*}*/), CONTIN|KEYWORD|sALIAS); 725 REJECT; 726 } 727 728 t = newtp(TFUNCT); 729 t->str = sname; 730 t->u.ksh_func = tobool(ksh_func); 731 t->lineno = source->line; 732 733 if ((t->left = get_command(CONTIN, sALIAS)) == NULL) { 734 char *tv; 735 /* 736 * Probably something like foo() followed by EOF or ';'. 737 * This is accepted by sh and ksh88. 738 * To make "typeset -f foo" work reliably (so its output can 739 * be used as input), we pretend there is a colon here. 740 */ 741 t->left = newtp(TCOM); 742 /* (2 * sizeof(char *)) is small enough */ 743 t->left->args = alloc(2 * sizeof(char *), ATEMP); 744 t->left->args[0] = tv = alloc(3, ATEMP); 745 tv[0] = QCHAR; 746 tv[1] = ':'; 747 tv[2] = EOS; 748 t->left->args[1] = NULL; 749 t->left->vars = alloc(sizeof(char *), ATEMP); 750 t->left->vars[0] = NULL; 751 t->left->lineno = 1; 752 } 753 754 return (t); 755 } 756 757 static char ** 758 wordlist(int sALIAS) 759 { 760 int c; 761 XPtrV args; 762 763 XPinit(args, 16); 764 /* POSIX does not do alias expansion here... */ 765 if ((c = token(CONTIN|KEYWORD|sALIAS)) != IN) { 766 if (c != ';') 767 /* non-POSIX, but AT&T ksh accepts a ; here */ 768 REJECT; 769 return (NULL); 770 } 771 while ((c = token(0)) == LWORD) 772 XPput(args, yylval.cp); 773 if (c != '\n' && c != ';') 774 syntaxerr(NULL); 775 XPput(args, NULL); 776 return ((char **)XPclose(args)); 777 } 778 779 /* 780 * supporting functions 781 */ 782 783 static struct op * 784 block(int type, struct op *t1, struct op *t2) 785 { 786 struct op *t; 787 788 t = newtp(type); 789 t->left = t1; 790 t->right = t2; 791 return (t); 792 } 793 794 static const struct tokeninfo { 795 const char *name; 796 short val; 797 short reserved; 798 } tokentab[] = { 799 /* Reserved words */ 800 { "if", IF, true }, 801 { "then", THEN, true }, 802 { "else", ELSE, true }, 803 { "elif", ELIF, true }, 804 { "fi", FI, true }, 805 { "case", CASE, true }, 806 { Tesac, ESAC, true }, 807 { "for", FOR, true }, 808 { Tselect, SELECT, true }, 809 { "while", WHILE, true }, 810 { "until", UNTIL, true }, 811 { "do", DO, true }, 812 { "done", DONE, true }, 813 { "in", IN, true }, 814 { Tfunction, FUNCTION, true }, 815 { Ttime, TIME, true }, 816 { "{", ORD('{'), true }, 817 { Tcbrace, ORD('}'), true }, 818 { "!", BANG, true }, 819 { "[[", DBRACKET, true }, 820 /* Lexical tokens (0[EOF], LWORD and REDIR handled specially) */ 821 { "&&", LOGAND, false }, 822 { "||", LOGOR, false }, 823 { ";;", BREAK, false }, 824 { ";|", BRKEV, false }, 825 { ";&", BRKFT, false }, 826 { "((", MDPAREN, false }, 827 { "|&", COPROC, false }, 828 /* and some special cases... */ 829 { "newline", ORD('\n'), false }, 830 { NULL, 0, false } 831 }; 832 833 void 834 initkeywords(void) 835 { 836 struct tokeninfo const *tt; 837 struct tbl *p; 838 839 ktinit(APERM, &keywords, 840 /* currently 28 keywords: 75% of 64 = 2^6 */ 841 6); 842 for (tt = tokentab; tt->name; tt++) { 843 if (tt->reserved) { 844 p = ktenter(&keywords, tt->name, hash(tt->name)); 845 p->flag |= DEFINED|ISSET; 846 p->type = CKEYWD; 847 p->val.i = tt->val; 848 } 849 } 850 } 851 852 static void 853 syntaxerr(const char *what) 854 { 855 /* 23<<- is the longest redirection, I think */ 856 char redir[8]; 857 const char *s; 858 struct tokeninfo const *tt; 859 int c; 860 861 if (!what) 862 what = Tunexpected; 863 REJECT; 864 c = token(0); 865 Again: 866 switch (c) { 867 case 0: 868 if (nesting.start_token) { 869 c = nesting.start_token; 870 source->errline = nesting.start_line; 871 what = "unmatched"; 872 goto Again; 873 } 874 /* don't quote the EOF */ 875 yyerror("%s: unexpected EOF", Tsynerr); 876 /* NOTREACHED */ 877 878 case LWORD: 879 s = snptreef(NULL, 32, Tf_S, yylval.cp); 880 break; 881 882 case REDIR: 883 s = snptreef(redir, sizeof(redir), Tft_R, yylval.iop); 884 break; 885 886 default: 887 for (tt = tokentab; tt->name; tt++) 888 if (tt->val == c) 889 break; 890 if (tt->name) 891 s = tt->name; 892 else { 893 if (c > 0 && c < 256) { 894 redir[0] = c; 895 redir[1] = '\0'; 896 } else 897 shf_snprintf(redir, sizeof(redir), 898 "?%d", c); 899 s = redir; 900 } 901 } 902 yyerror(Tf_sD_s_qs, Tsynerr, what, s); 903 } 904 905 static void 906 nesting_push(struct nesting_state *save, int tok) 907 { 908 *save = nesting; 909 nesting.start_token = tok; 910 nesting.start_line = source->line; 911 } 912 913 static void 914 nesting_pop(struct nesting_state *saved) 915 { 916 nesting = *saved; 917 } 918 919 static struct op * 920 newtp(int type) 921 { 922 struct op *t; 923 924 t = alloc(sizeof(struct op), ATEMP); 925 t->type = type; 926 t->u.evalflags = 0; 927 t->args = NULL; 928 t->vars = NULL; 929 t->ioact = NULL; 930 t->left = t->right = NULL; 931 t->str = NULL; 932 return (t); 933 } 934 935 struct op * 936 compile(Source *s, bool skiputf8bom, bool doalias) 937 { 938 nesting.start_token = 0; 939 nesting.start_line = 0; 940 herep = heres; 941 source = s; 942 if (skiputf8bom) 943 yyskiputf8bom(); 944 yyparse(doalias); 945 return (outtree); 946 } 947 948 /* Check if we are in the middle of reading an alias */ 949 static int 950 inalias(struct source *s) 951 { 952 while (s && s->type == SALIAS) { 953 if (!(s->flags & SF_ALIASEND)) 954 return (1); 955 s = s->next; 956 } 957 return (0); 958 } 959 960 961 /* 962 * Order important - indexed by Test_meta values 963 * Note that ||, &&, ( and ) can't appear in as unquoted strings 964 * in normal shell input, so these can be interpreted unambiguously 965 * in the evaluation pass. 966 */ 967 static const char dbtest_or[] = { CHAR, '|', CHAR, '|', EOS }; 968 static const char dbtest_and[] = { CHAR, '&', CHAR, '&', EOS }; 969 static const char dbtest_not[] = { CHAR, '!', EOS }; 970 static const char dbtest_oparen[] = { CHAR, '(', EOS }; 971 static const char dbtest_cparen[] = { CHAR, ')', EOS }; 972 const char * const dbtest_tokens[] = { 973 dbtest_or, dbtest_and, dbtest_not, 974 dbtest_oparen, dbtest_cparen 975 }; 976 static const char db_close[] = { CHAR, ']', CHAR, ']', EOS }; 977 static const char db_lthan[] = { CHAR, '<', EOS }; 978 static const char db_gthan[] = { CHAR, '>', EOS }; 979 980 /* 981 * Test if the current token is a whatever. Accepts the current token if 982 * it is. Returns 0 if it is not, non-zero if it is (in the case of 983 * TM_UNOP and TM_BINOP, the returned value is a Test_op). 984 */ 985 static Test_op 986 dbtestp_isa(Test_env *te, Test_meta meta) 987 { 988 int c = tpeek(CMDASN | (meta == TM_BINOP ? 0 : CONTIN)); 989 bool uqword; 990 char *save = NULL; 991 Test_op ret = TO_NONOP; 992 993 /* unquoted word? */ 994 uqword = c == LWORD && *ident; 995 996 if (meta == TM_OR) 997 ret = c == LOGOR ? TO_NONNULL : TO_NONOP; 998 else if (meta == TM_AND) 999 ret = c == LOGAND ? TO_NONNULL : TO_NONOP; 1000 else if (meta == TM_NOT) 1001 ret = (uqword && !strcmp(yylval.cp, 1002 dbtest_tokens[(int)TM_NOT])) ? TO_NONNULL : TO_NONOP; 1003 else if (meta == TM_OPAREN) 1004 ret = (unsigned int)c == ORD('(') /*)*/ ? TO_NONNULL : TO_NONOP; 1005 else if (meta == TM_CPAREN) 1006 ret = (unsigned int)c == /*(*/ ORD(')') ? TO_NONNULL : TO_NONOP; 1007 else if (meta == TM_UNOP || meta == TM_BINOP) { 1008 if (meta == TM_BINOP && c == REDIR && 1009 (yylval.iop->ioflag == IOREAD || 1010 yylval.iop->ioflag == IOWRITE)) { 1011 ret = TO_NONNULL; 1012 save = wdcopy(yylval.iop->ioflag == IOREAD ? 1013 db_lthan : db_gthan, ATEMP); 1014 } else if (uqword && (ret = test_isop(meta, ident))) 1015 save = yylval.cp; 1016 } else 1017 /* meta == TM_END */ 1018 ret = (uqword && !strcmp(yylval.cp, 1019 db_close)) ? TO_NONNULL : TO_NONOP; 1020 if (ret != TO_NONOP) { 1021 ACCEPT; 1022 if ((unsigned int)meta < NELEM(dbtest_tokens)) 1023 save = wdcopy(dbtest_tokens[(int)meta], ATEMP); 1024 if (save) 1025 XPput(*te->pos.av, save); 1026 } 1027 return (ret); 1028 } 1029 1030 static const char * 1031 dbtestp_getopnd(Test_env *te, Test_op op MKSH_A_UNUSED, 1032 bool do_eval MKSH_A_UNUSED) 1033 { 1034 int c = tpeek(CMDASN); 1035 1036 if (c != LWORD) 1037 return (NULL); 1038 1039 ACCEPT; 1040 XPput(*te->pos.av, yylval.cp); 1041 1042 return (null); 1043 } 1044 1045 static int 1046 dbtestp_eval(Test_env *te MKSH_A_UNUSED, Test_op op MKSH_A_UNUSED, 1047 const char *opnd1 MKSH_A_UNUSED, const char *opnd2 MKSH_A_UNUSED, 1048 bool do_eval MKSH_A_UNUSED) 1049 { 1050 return (1); 1051 } 1052 1053 static void 1054 dbtestp_error(Test_env *te, int offset, const char *msg) 1055 { 1056 te->flags |= TEF_ERROR; 1057 1058 if (offset < 0) { 1059 REJECT; 1060 /* Kludgy to say the least... */ 1061 symbol = LWORD; 1062 yylval.cp = *(XPptrv(*te->pos.av) + XPsize(*te->pos.av) + 1063 offset); 1064 } 1065 syntaxerr(msg); 1066 } 1067 1068 #if HAVE_SELECT 1069 1070 #ifndef EOVERFLOW 1071 #ifdef ERANGE 1072 #define EOVERFLOW ERANGE 1073 #else 1074 #define EOVERFLOW EINVAL 1075 #endif 1076 #endif 1077 1078 bool 1079 parse_usec(const char *s, struct timeval *tv) 1080 { 1081 struct timeval tt; 1082 int i; 1083 1084 tv->tv_sec = 0; 1085 /* parse integral part */ 1086 while (ctype(*s, C_DIGIT)) { 1087 tt.tv_sec = tv->tv_sec * 10 + ksh_numdig(*s++); 1088 /*XXX this overflow check maybe UB */ 1089 if (tt.tv_sec / 10 != tv->tv_sec) { 1090 errno = EOVERFLOW; 1091 return (true); 1092 } 1093 tv->tv_sec = tt.tv_sec; 1094 } 1095 1096 tv->tv_usec = 0; 1097 if (!*s) 1098 /* no decimal fraction */ 1099 return (false); 1100 else if (*s++ != '.') { 1101 /* junk after integral part */ 1102 errno = EINVAL; 1103 return (true); 1104 } 1105 1106 /* parse decimal fraction */ 1107 i = 100000; 1108 while (ctype(*s, C_DIGIT)) { 1109 tv->tv_usec += i * ksh_numdig(*s++); 1110 if (i == 1) 1111 break; 1112 i /= 10; 1113 } 1114 /* check for junk after fractional part */ 1115 while (ctype(*s, C_DIGIT)) 1116 ++s; 1117 if (*s) { 1118 errno = EINVAL; 1119 return (true); 1120 } 1121 1122 /* end of input string reached, no errors */ 1123 return (false); 1124 } 1125 #endif 1126 1127 /* 1128 * Helper function called from within lex.c:yylex() to parse 1129 * a COMSUB recursively using the main shell parser and lexer 1130 */ 1131 char * 1132 yyrecursive(int subtype) 1133 { 1134 struct op *t; 1135 char *cp; 1136 struct yyrecursive_state *ys; 1137 unsigned int stok, etok; 1138 1139 if (subtype != COMSUB) { 1140 stok = ORD('{'); 1141 etok = ORD('}'); 1142 } else { 1143 stok = ORD('('); 1144 etok = ORD(')'); 1145 } 1146 1147 ys = alloc(sizeof(struct yyrecursive_state), ATEMP); 1148 1149 /* tell the lexer to accept a closing parenthesis as EOD */ 1150 ys->old_nesting_type = subshell_nesting_type; 1151 subshell_nesting_type = etok; 1152 1153 /* push reject state, parse recursively, pop reject state */ 1154 ys->old_reject = reject; 1155 ys->old_symbol = symbol; 1156 ACCEPT; 1157 memcpy(ys->old_heres, heres, sizeof(heres)); 1158 ys->old_herep = herep; 1159 herep = heres; 1160 ys->next = e->yyrecursive_statep; 1161 e->yyrecursive_statep = ys; 1162 /* we use TPAREN as a helper container here */ 1163 t = nested(TPAREN, stok, etok, ALIAS); 1164 yyrecursive_pop(false); 1165 1166 /* t->left because nested(TPAREN, ...) hides our goodies there */ 1167 cp = snptreef(NULL, 0, Tf_T, t->left); 1168 tfree(t, ATEMP); 1169 1170 return (cp); 1171 } 1172 1173 void 1174 yyrecursive_pop(bool popall) 1175 { 1176 struct yyrecursive_state *ys; 1177 1178 popnext: 1179 if (!(ys = e->yyrecursive_statep)) 1180 return; 1181 e->yyrecursive_statep = ys->next; 1182 1183 memcpy(heres, ys->old_heres, sizeof(heres)); 1184 herep = ys->old_herep; 1185 reject = ys->old_reject; 1186 symbol = ys->old_symbol; 1187 1188 subshell_nesting_type = ys->old_nesting_type; 1189 1190 afree(ys, ATEMP); 1191 if (popall) 1192 goto popnext; 1193 } 1194