1 /* $OpenBSD: tree.c,v 1.21 2015/09/01 13:12:31 tedu Exp $ */ 2 3 /*- 4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 5 * 2011, 2012, 2013, 2015, 2016, 2017 6 * mirabilos <m (at) mirbsd.org> 7 * 8 * Provided that these terms and disclaimer and all copyright notices 9 * are retained or reproduced in an accompanying document, permission 10 * is granted to deal in this work without restriction, including un- 11 * limited rights to use, publicly perform, distribute, sell, modify, 12 * merge, give away, or sublicence. 13 * 14 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 15 * the utmost extent permitted by applicable law, neither express nor 16 * implied; without malicious intent or gross negligence. In no event 17 * may a licensor, author or contributor be held liable for indirect, 18 * direct, other damage, loss, or other issues arising in any way out 19 * of dealing in the work, even if advised of the possibility of such 20 * damage or existence of a defect, except proven that it results out 21 * of said person's immediate fault when using the work as intended. 22 */ 23 24 #include "sh.h" 25 26 __RCSID("$MirOS: src/bin/mksh/tree.c,v 1.95 2018/01/14 00:03:05 tg Exp $"); 27 28 #define INDENT 8 29 30 static void ptree(struct op *, int, struct shf *); 31 static void pioact(struct shf *, struct ioword *); 32 static const char *wdvarput(struct shf *, const char *, int, int); 33 static void vfptreef(struct shf *, int, const char *, va_list); 34 static struct ioword **iocopy(struct ioword **, Area *); 35 static void iofree(struct ioword **, Area *); 36 37 /* "foo& ; bar" and "foo |& ; bar" are invalid */ 38 static bool prevent_semicolon; 39 40 static const char Telif_pT[] = "elif %T"; 41 42 /* 43 * print a command tree 44 */ 45 static void 46 ptree(struct op *t, int indent, struct shf *shf) 47 { 48 const char **w; 49 struct ioword **ioact; 50 struct op *t1; 51 int i; 52 const char *ccp; 53 54 Chain: 55 if (t == NULL) 56 return; 57 switch (t->type) { 58 case TCOM: 59 prevent_semicolon = false; 60 /* special-case 'var=<<EOF' (cf. exec.c:execute) */ 61 if (t->args && 62 /* we have zero arguments, i.e. no program to run */ 63 t->args[0] == NULL && 64 /* we have exactly one variable assignment */ 65 t->vars[0] != NULL && t->vars[1] == NULL && 66 /* we have exactly one I/O redirection */ 67 t->ioact != NULL && t->ioact[0] != NULL && 68 t->ioact[1] == NULL && 69 /* of type "here document" (or "here string") */ 70 (t->ioact[0]->ioflag & IOTYPE) == IOHERE && 71 /* the variable assignment begins with a valid varname */ 72 (ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] && 73 /* and has no right-hand side (i.e. "varname=") */ 74 ccp[0] == CHAR && ((ccp[1] == '=' && ccp[2] == EOS) || 75 /* or "varname+=" */ (ccp[1] == '+' && ccp[2] == CHAR && 76 ccp[3] == '=' && ccp[4] == EOS))) { 77 fptreef(shf, indent, Tf_S, t->vars[0]); 78 break; 79 } 80 81 if (t->vars) { 82 w = (const char **)t->vars; 83 while (*w) 84 fptreef(shf, indent, Tf_S_, *w++); 85 } else 86 shf_puts("#no-vars# ", shf); 87 if (t->args) { 88 w = t->args; 89 if (*w && **w == CHAR) { 90 char *cp = wdstrip(*w++, WDS_TPUTS); 91 92 if (valid_alias_name(cp)) 93 shf_putc('\\', shf); 94 shf_puts(cp, shf); 95 shf_putc(' ', shf); 96 afree(cp, ATEMP); 97 } 98 while (*w) 99 fptreef(shf, indent, Tf_S_, *w++); 100 } else 101 shf_puts("#no-args# ", shf); 102 break; 103 case TEXEC: 104 t = t->left; 105 goto Chain; 106 case TPAREN: 107 fptreef(shf, indent + 2, "( %T) ", t->left); 108 break; 109 case TPIPE: 110 fptreef(shf, indent, "%T| ", t->left); 111 t = t->right; 112 goto Chain; 113 case TLIST: 114 fptreef(shf, indent, "%T%;", t->left); 115 t = t->right; 116 goto Chain; 117 case TOR: 118 case TAND: 119 fptreef(shf, indent, "%T%s %T", 120 t->left, (t->type == TOR) ? "||" : "&&", t->right); 121 break; 122 case TBANG: 123 shf_puts("! ", shf); 124 prevent_semicolon = false; 125 t = t->right; 126 goto Chain; 127 case TDBRACKET: 128 w = t->args; 129 shf_puts("[[", shf); 130 while (*w) 131 fptreef(shf, indent, Tf__S, *w++); 132 shf_puts(" ]] ", shf); 133 break; 134 case TSELECT: 135 case TFOR: 136 fptreef(shf, indent, "%s %s ", 137 (t->type == TFOR) ? "for" : Tselect, t->str); 138 if (t->vars != NULL) { 139 shf_puts("in ", shf); 140 w = (const char **)t->vars; 141 while (*w) 142 fptreef(shf, indent, Tf_S_, *w++); 143 fptreef(shf, indent, Tft_end); 144 } 145 fptreef(shf, indent + INDENT, "do%N%T", t->left); 146 fptreef(shf, indent, "%;done "); 147 break; 148 case TCASE: 149 fptreef(shf, indent, "case %S in", t->str); 150 for (t1 = t->left; t1 != NULL; t1 = t1->right) { 151 fptreef(shf, indent, "%N("); 152 w = (const char **)t1->vars; 153 while (*w) { 154 fptreef(shf, indent, "%S%c", *w, 155 (w[1] != NULL) ? '|' : ')'); 156 ++w; 157 } 158 fptreef(shf, indent + INDENT, "%N%T%N;%c", t1->left, 159 t1->u.charflag); 160 } 161 fptreef(shf, indent, "%Nesac "); 162 break; 163 case TELIF: 164 internal_errorf(TELIF_unexpected); 165 /* FALLTHROUGH */ 166 case TIF: 167 i = 2; 168 t1 = t; 169 goto process_TIF; 170 do { 171 t1 = t1->right; 172 i = 0; 173 fptreef(shf, indent, Tft_end); 174 process_TIF: 175 /* 5 == strlen("elif ") */ 176 fptreef(shf, indent + 5 - i, Telif_pT + i, t1->left); 177 t1 = t1->right; 178 if (t1->left != NULL) { 179 fptreef(shf, indent, Tft_end); 180 fptreef(shf, indent + INDENT, "%s%N%T", 181 "then", t1->left); 182 } 183 } while (t1->right && t1->right->type == TELIF); 184 if (t1->right != NULL) { 185 fptreef(shf, indent, Tft_end); 186 fptreef(shf, indent + INDENT, "%s%N%T", 187 "else", t1->right); 188 } 189 fptreef(shf, indent, "%;fi "); 190 break; 191 case TWHILE: 192 case TUNTIL: 193 /* 6 == strlen("while "/"until ") */ 194 fptreef(shf, indent + 6, Tf_s_T, 195 (t->type == TWHILE) ? "while" : "until", 196 t->left); 197 fptreef(shf, indent, Tft_end); 198 fptreef(shf, indent + INDENT, "do%N%T", t->right); 199 fptreef(shf, indent, "%;done "); 200 break; 201 case TBRACE: 202 fptreef(shf, indent + INDENT, "{%N%T", t->left); 203 fptreef(shf, indent, "%;} "); 204 break; 205 case TCOPROC: 206 fptreef(shf, indent, "%T|& ", t->left); 207 prevent_semicolon = true; 208 break; 209 case TASYNC: 210 fptreef(shf, indent, "%T& ", t->left); 211 prevent_semicolon = true; 212 break; 213 case TFUNCT: 214 fpFUNCTf(shf, indent, tobool(t->u.ksh_func), t->str, t->left); 215 break; 216 case TTIME: 217 fptreef(shf, indent, Tf_s_T, Ttime, t->left); 218 break; 219 default: 220 shf_puts("<botch>", shf); 221 prevent_semicolon = false; 222 break; 223 } 224 if ((ioact = t->ioact) != NULL) { 225 bool need_nl = false; 226 227 while (*ioact != NULL) 228 pioact(shf, *ioact++); 229 /* Print here documents after everything else... */ 230 ioact = t->ioact; 231 while (*ioact != NULL) { 232 struct ioword *iop = *ioact++; 233 234 /* heredoc is NULL when tracing (set -x) */ 235 if ((iop->ioflag & (IOTYPE | IOHERESTR)) == IOHERE && 236 iop->heredoc) { 237 shf_putc('\n', shf); 238 shf_puts(iop->heredoc, shf); 239 fptreef(shf, indent, Tf_s, 240 evalstr(iop->delim, 0)); 241 need_nl = true; 242 } 243 } 244 /* 245 * Last delimiter must be followed by a newline (this 246 * often leads to an extra blank line, but it's not 247 * worth worrying about) 248 */ 249 if (need_nl) { 250 shf_putc('\n', shf); 251 prevent_semicolon = true; 252 } 253 } 254 } 255 256 static void 257 pioact(struct shf *shf, struct ioword *iop) 258 { 259 unsigned short flag = iop->ioflag; 260 unsigned short type = flag & IOTYPE; 261 short expected; 262 263 expected = (type == IOREAD || type == IORDWR || type == IOHERE) ? 0 : 264 (type == IOCAT || type == IOWRITE) ? 1 : 265 (type == IODUP && (iop->unit == !(flag & IORDUP))) ? iop->unit : 266 iop->unit + 1; 267 if (iop->unit != expected) 268 shf_fprintf(shf, Tf_d, (int)iop->unit); 269 270 switch (type) { 271 case IOREAD: 272 shf_putc('<', shf); 273 break; 274 case IOHERE: 275 shf_puts("<<", shf); 276 if (flag & IOSKIP) 277 shf_putc('-', shf); 278 else if (flag & IOHERESTR) 279 shf_putc('<', shf); 280 break; 281 case IOCAT: 282 shf_puts(">>", shf); 283 break; 284 case IOWRITE: 285 shf_putc('>', shf); 286 if (flag & IOCLOB) 287 shf_putc('|', shf); 288 break; 289 case IORDWR: 290 shf_puts("<>", shf); 291 break; 292 case IODUP: 293 shf_puts(flag & IORDUP ? "<&" : ">&", shf); 294 break; 295 } 296 /* name/delim are NULL when printing syntax errors */ 297 if (type == IOHERE) { 298 if (iop->delim && !(iop->ioflag & IONDELIM)) 299 wdvarput(shf, iop->delim, 0, WDS_TPUTS); 300 } else if (iop->ioname) { 301 if (flag & IONAMEXP) 302 print_value_quoted(shf, iop->ioname); 303 else 304 wdvarput(shf, iop->ioname, 0, WDS_TPUTS); 305 } 306 shf_putc(' ', shf); 307 prevent_semicolon = false; 308 } 309 310 /* variant of fputs for ptreef and wdstrip */ 311 static const char * 312 wdvarput(struct shf *shf, const char *wp, int quotelevel, int opmode) 313 { 314 int c; 315 const char *cs; 316 317 /*- 318 * problems: 319 * `...` -> $(...) 320 * 'foo' -> "foo" 321 * x${foo:-"hi"} -> x${foo:-hi} unless WDS_TPUTS 322 * x${foo:-'hi'} -> x${foo:-hi} 323 * could change encoding to: 324 * OQUOTE ["'] ... CQUOTE ["'] 325 * COMSUB [(`] ...\0 (handle $ ` \ and maybe " in `...` case) 326 */ 327 while (/* CONSTCOND */ 1) 328 switch (*wp++) { 329 case EOS: 330 return (--wp); 331 case ADELIM: 332 if (ord(*wp) == ORD(/*{*/ '}')) { 333 ++wp; 334 goto wdvarput_csubst; 335 } 336 /* FALLTHROUGH */ 337 case CHAR: 338 c = ord(*wp++); 339 shf_putc(c, shf); 340 break; 341 case QCHAR: 342 c = ord(*wp++); 343 if (opmode & WDS_TPUTS) 344 switch (c) { 345 case ORD('\n'): 346 if (quotelevel == 0) { 347 c = ORD('\''); 348 shf_putc(c, shf); 349 shf_putc(ORD('\n'), shf); 350 } 351 break; 352 default: 353 if (quotelevel == 0) 354 /* FALLTHROUGH */ 355 case ORD('"'): 356 case ORD('`'): 357 case ORD('$'): 358 case ORD('\\'): 359 shf_putc(ORD('\\'), shf); 360 break; 361 } 362 shf_putc(c, shf); 363 break; 364 case COMASUB: 365 case COMSUB: 366 shf_puts("$(", shf); 367 cs = ")"; 368 if (ord(*wp) == ORD('(' /*)*/)) 369 shf_putc(' ', shf); 370 pSUB: 371 while ((c = *wp++) != 0) 372 shf_putc(c, shf); 373 shf_puts(cs, shf); 374 break; 375 case FUNASUB: 376 case FUNSUB: 377 c = ORD(' '); 378 if (0) 379 /* FALLTHROUGH */ 380 case VALSUB: 381 c = ORD('|'); 382 shf_putc('$', shf); 383 shf_putc('{', shf); 384 shf_putc(c, shf); 385 cs = ";}"; 386 goto pSUB; 387 case EXPRSUB: 388 shf_puts("$((", shf); 389 cs = "))"; 390 goto pSUB; 391 case OQUOTE: 392 if (opmode & WDS_TPUTS) { 393 quotelevel++; 394 shf_putc('"', shf); 395 } 396 break; 397 case CQUOTE: 398 if (opmode & WDS_TPUTS) { 399 if (quotelevel) 400 quotelevel--; 401 shf_putc('"', shf); 402 } 403 break; 404 case OSUBST: 405 shf_putc('$', shf); 406 if (ord(*wp++) == ORD('{')) 407 shf_putc('{', shf); 408 while ((c = *wp++) != 0) 409 shf_putc(c, shf); 410 wp = wdvarput(shf, wp, 0, opmode); 411 break; 412 case CSUBST: 413 if (ord(*wp++) == ORD('}')) { 414 wdvarput_csubst: 415 shf_putc('}', shf); 416 } 417 return (wp); 418 case OPAT: 419 shf_putchar(*wp++, shf); 420 shf_putc('(', shf); 421 break; 422 case SPAT: 423 c = ORD('|'); 424 if (0) 425 /* FALLTHROUGH */ 426 case CPAT: 427 c = ORD(/*(*/ ')'); 428 shf_putc(c, shf); 429 break; 430 } 431 } 432 433 /* 434 * this is the _only_ way to reliably handle 435 * variable args with an ANSI compiler 436 */ 437 /* VARARGS */ 438 void 439 fptreef(struct shf *shf, int indent, const char *fmt, ...) 440 { 441 va_list va; 442 443 va_start(va, fmt); 444 vfptreef(shf, indent, fmt, va); 445 va_end(va); 446 } 447 448 /* VARARGS */ 449 char * 450 snptreef(char *s, ssize_t n, const char *fmt, ...) 451 { 452 va_list va; 453 struct shf shf; 454 455 shf_sopen(s, n, SHF_WR | (s ? 0 : SHF_DYNAMIC), &shf); 456 457 va_start(va, fmt); 458 vfptreef(&shf, 0, fmt, va); 459 va_end(va); 460 461 /* shf_sclose NUL terminates */ 462 return (shf_sclose(&shf)); 463 } 464 465 static void 466 vfptreef(struct shf *shf, int indent, const char *fmt, va_list va) 467 { 468 int c; 469 470 while ((c = ord(*fmt++))) { 471 if (c == '%') { 472 switch ((c = ord(*fmt++))) { 473 case ORD('c'): 474 /* character (octet, probably) */ 475 shf_putchar(va_arg(va, int), shf); 476 break; 477 case ORD('s'): 478 /* string */ 479 shf_puts(va_arg(va, char *), shf); 480 break; 481 case ORD('S'): 482 /* word */ 483 wdvarput(shf, va_arg(va, char *), 0, WDS_TPUTS); 484 break; 485 case ORD('d'): 486 /* signed decimal */ 487 shf_fprintf(shf, Tf_d, va_arg(va, int)); 488 break; 489 case ORD('u'): 490 /* unsigned decimal */ 491 shf_fprintf(shf, "%u", va_arg(va, unsigned int)); 492 break; 493 case ORD('T'): 494 /* format tree */ 495 ptree(va_arg(va, struct op *), indent, shf); 496 goto dont_trash_prevent_semicolon; 497 case ORD(';'): 498 /* newline or ; */ 499 case ORD('N'): 500 /* newline or space */ 501 if (shf->flags & SHF_STRING) { 502 if ((unsigned int)c == ORD(';') && 503 !prevent_semicolon) 504 shf_putc(';', shf); 505 shf_putc(' ', shf); 506 } else { 507 int i; 508 509 shf_putc('\n', shf); 510 i = indent; 511 while (i >= 8) { 512 shf_putc('\t', shf); 513 i -= 8; 514 } 515 while (i--) 516 shf_putc(' ', shf); 517 } 518 break; 519 case ORD('R'): 520 /* I/O redirection */ 521 pioact(shf, va_arg(va, struct ioword *)); 522 break; 523 default: 524 shf_putc(c, shf); 525 break; 526 } 527 } else 528 shf_putc(c, shf); 529 prevent_semicolon = false; 530 dont_trash_prevent_semicolon: 531 ; 532 } 533 } 534 535 /* 536 * copy tree (for function definition) 537 */ 538 struct op * 539 tcopy(struct op *t, Area *ap) 540 { 541 struct op *r; 542 const char **tw; 543 char **rw; 544 545 if (t == NULL) 546 return (NULL); 547 548 r = alloc(sizeof(struct op), ap); 549 550 r->type = t->type; 551 r->u.evalflags = t->u.evalflags; 552 553 if (t->type == TCASE) 554 r->str = wdcopy(t->str, ap); 555 else 556 strdupx(r->str, t->str, ap); 557 558 if (t->vars == NULL) 559 r->vars = NULL; 560 else { 561 tw = (const char **)t->vars; 562 while (*tw) 563 ++tw; 564 rw = r->vars = alloc2(tw - (const char **)t->vars + 1, 565 sizeof(*tw), ap); 566 tw = (const char **)t->vars; 567 while (*tw) 568 *rw++ = wdcopy(*tw++, ap); 569 *rw = NULL; 570 } 571 572 if (t->args == NULL) 573 r->args = NULL; 574 else { 575 tw = t->args; 576 while (*tw) 577 ++tw; 578 r->args = (const char **)(rw = alloc2(tw - t->args + 1, 579 sizeof(*tw), ap)); 580 tw = t->args; 581 while (*tw) 582 *rw++ = wdcopy(*tw++, ap); 583 *rw = NULL; 584 } 585 586 r->ioact = (t->ioact == NULL) ? NULL : iocopy(t->ioact, ap); 587 588 r->left = tcopy(t->left, ap); 589 r->right = tcopy(t->right, ap); 590 r->lineno = t->lineno; 591 592 return (r); 593 } 594 595 char * 596 wdcopy(const char *wp, Area *ap) 597 { 598 size_t len; 599 600 len = wdscan(wp, EOS) - wp; 601 return (memcpy(alloc(len, ap), wp, len)); 602 } 603 604 /* return the position of prefix c in wp plus 1 */ 605 const char * 606 wdscan(const char *wp, int c) 607 { 608 int nest = 0; 609 610 while (/* CONSTCOND */ 1) 611 switch (*wp++) { 612 case EOS: 613 return (wp); 614 case ADELIM: 615 if (c == ADELIM && nest == 0) 616 return (wp + 1); 617 if (ord(*wp) == ORD(/*{*/ '}')) 618 goto wdscan_csubst; 619 /* FALLTHROUGH */ 620 case CHAR: 621 case QCHAR: 622 wp++; 623 break; 624 case COMASUB: 625 case COMSUB: 626 case FUNASUB: 627 case FUNSUB: 628 case VALSUB: 629 case EXPRSUB: 630 while (*wp++ != 0) 631 ; 632 break; 633 case OQUOTE: 634 case CQUOTE: 635 break; 636 case OSUBST: 637 nest++; 638 while (*wp++ != '\0') 639 ; 640 break; 641 case CSUBST: 642 wdscan_csubst: 643 wp++; 644 if (c == CSUBST && nest == 0) 645 return (wp); 646 nest--; 647 break; 648 case OPAT: 649 nest++; 650 wp++; 651 break; 652 case SPAT: 653 case CPAT: 654 if (c == wp[-1] && nest == 0) 655 return (wp); 656 if (wp[-1] == CPAT) 657 nest--; 658 break; 659 default: 660 internal_warningf( 661 "wdscan: unknown char 0x%X (carrying on)", 662 (unsigned char)wp[-1]); 663 } 664 } 665 666 /* 667 * return a copy of wp without any of the mark up characters and with 668 * quote characters (" ' \) stripped. (string is allocated from ATEMP) 669 */ 670 char * 671 wdstrip(const char *wp, int opmode) 672 { 673 struct shf shf; 674 675 shf_sopen(NULL, 32, SHF_WR | SHF_DYNAMIC, &shf); 676 wdvarput(&shf, wp, 0, opmode); 677 /* shf_sclose NUL terminates */ 678 return (shf_sclose(&shf)); 679 } 680 681 static struct ioword ** 682 iocopy(struct ioword **iow, Area *ap) 683 { 684 struct ioword **ior; 685 int i; 686 687 ior = iow; 688 while (*ior) 689 ++ior; 690 ior = alloc2(ior - iow + 1, sizeof(struct ioword *), ap); 691 692 for (i = 0; iow[i] != NULL; i++) { 693 struct ioword *p, *q; 694 695 p = iow[i]; 696 q = alloc(sizeof(struct ioword), ap); 697 ior[i] = q; 698 *q = *p; 699 if (p->ioname != NULL) 700 q->ioname = wdcopy(p->ioname, ap); 701 if (p->delim != NULL) 702 q->delim = wdcopy(p->delim, ap); 703 if (p->heredoc != NULL) 704 strdupx(q->heredoc, p->heredoc, ap); 705 } 706 ior[i] = NULL; 707 708 return (ior); 709 } 710 711 /* 712 * free tree (for function definition) 713 */ 714 void 715 tfree(struct op *t, Area *ap) 716 { 717 char **w; 718 719 if (t == NULL) 720 return; 721 722 afree(t->str, ap); 723 724 if (t->vars != NULL) { 725 for (w = t->vars; *w != NULL; w++) 726 afree(*w, ap); 727 afree(t->vars, ap); 728 } 729 730 if (t->args != NULL) { 731 /*XXX we assume the caller is right */ 732 union mksh_ccphack cw; 733 734 cw.ro = t->args; 735 for (w = cw.rw; *w != NULL; w++) 736 afree(*w, ap); 737 afree(t->args, ap); 738 } 739 740 if (t->ioact != NULL) 741 iofree(t->ioact, ap); 742 743 tfree(t->left, ap); 744 tfree(t->right, ap); 745 746 afree(t, ap); 747 } 748 749 static void 750 iofree(struct ioword **iow, Area *ap) 751 { 752 struct ioword **iop; 753 struct ioword *p; 754 755 iop = iow; 756 while ((p = *iop++) != NULL) { 757 afree(p->ioname, ap); 758 afree(p->delim, ap); 759 afree(p->heredoc, ap); 760 afree(p, ap); 761 } 762 afree(iow, ap); 763 } 764 765 void 766 fpFUNCTf(struct shf *shf, int i, bool isksh, const char *k, struct op *v) 767 { 768 if (isksh) 769 fptreef(shf, i, "%s %s %T", Tfunction, k, v); 770 else if (ktsearch(&keywords, k, hash(k))) 771 fptreef(shf, i, "%s %s() %T", Tfunction, k, v); 772 else 773 fptreef(shf, i, "%s() %T", k, v); 774 } 775 776 777 /* for jobs.c */ 778 void 779 vistree(char *dst, size_t sz, struct op *t) 780 { 781 unsigned int c; 782 char *cp, *buf; 783 size_t n; 784 785 buf = alloc(sz + 16, ATEMP); 786 snptreef(buf, sz + 16, Tf_T, t); 787 cp = buf; 788 vist_loop: 789 if (UTFMODE && (n = utf_mbtowc(&c, cp)) != (size_t)-1) { 790 if (c == 0 || n >= sz) 791 /* NUL or not enough free space */ 792 goto vist_out; 793 /* copy multibyte char */ 794 sz -= n; 795 while (n--) 796 *dst++ = *cp++; 797 goto vist_loop; 798 } 799 if (--sz == 0 || (c = ord(*cp++)) == 0) 800 /* NUL or not enough free space */ 801 goto vist_out; 802 if (ksh_isctrl(c)) { 803 /* C0 or C1 control character or DEL */ 804 if (--sz == 0) 805 /* not enough free space for two chars */ 806 goto vist_out; 807 *dst++ = '^'; 808 c = ksh_unctrl(c); 809 } else if (UTFMODE && rtt2asc(c) > 0x7F) { 810 /* better not try to display broken multibyte chars */ 811 /* also go easy on the Unicode: no U+FFFD here */ 812 c = ORD('?'); 813 } 814 *dst++ = c; 815 goto vist_loop; 816 817 vist_out: 818 *dst = '\0'; 819 afree(buf, ATEMP); 820 } 821 822 #ifdef DEBUG 823 void 824 dumpchar(struct shf *shf, int c) 825 { 826 if (ksh_isctrl(c)) { 827 /* C0 or C1 control character or DEL */ 828 shf_putc('^', shf); 829 c = ksh_unctrl(c); 830 } 831 shf_putc(c, shf); 832 } 833 834 /* see: wdvarput */ 835 static const char * 836 dumpwdvar_i(struct shf *shf, const char *wp, int quotelevel) 837 { 838 int c; 839 840 while (/* CONSTCOND */ 1) { 841 switch(*wp++) { 842 case EOS: 843 shf_puts("EOS", shf); 844 return (--wp); 845 case ADELIM: 846 if (ord(*wp) == ORD(/*{*/ '}')) { 847 shf_puts(/*{*/ "]ADELIM(})", shf); 848 return (wp + 1); 849 } 850 shf_puts("ADELIM=", shf); 851 if (0) 852 /* FALLTHROUGH */ 853 case CHAR: 854 shf_puts("CHAR=", shf); 855 dumpchar(shf, *wp++); 856 break; 857 case QCHAR: 858 shf_puts("QCHAR<", shf); 859 c = ord(*wp++); 860 if (quotelevel == 0 || c == ORD('"') || 861 c == ORD('\\') || ctype(c, C_DOLAR | C_GRAVE)) 862 shf_putc('\\', shf); 863 dumpchar(shf, c); 864 goto closeandout; 865 case COMASUB: 866 shf_puts("COMASUB<", shf); 867 goto dumpsub; 868 case COMSUB: 869 shf_puts("COMSUB<", shf); 870 dumpsub: 871 while ((c = *wp++) != 0) 872 dumpchar(shf, c); 873 closeandout: 874 shf_putc('>', shf); 875 break; 876 case FUNASUB: 877 shf_puts("FUNASUB<", shf); 878 goto dumpsub; 879 case FUNSUB: 880 shf_puts("FUNSUB<", shf); 881 goto dumpsub; 882 case VALSUB: 883 shf_puts("VALSUB<", shf); 884 goto dumpsub; 885 case EXPRSUB: 886 shf_puts("EXPRSUB<", shf); 887 goto dumpsub; 888 case OQUOTE: 889 shf_fprintf(shf, "OQUOTE{%d" /*}*/, ++quotelevel); 890 break; 891 case CQUOTE: 892 shf_fprintf(shf, /*{*/ "%d}CQUOTE", quotelevel); 893 if (quotelevel) 894 quotelevel--; 895 else 896 shf_puts("(err)", shf); 897 break; 898 case OSUBST: 899 shf_puts("OSUBST(", shf); 900 dumpchar(shf, *wp++); 901 shf_puts(")[", shf); 902 while ((c = *wp++) != 0) 903 dumpchar(shf, c); 904 shf_putc('|', shf); 905 wp = dumpwdvar_i(shf, wp, 0); 906 break; 907 case CSUBST: 908 shf_puts("]CSUBST(", shf); 909 dumpchar(shf, *wp++); 910 shf_putc(')', shf); 911 return (wp); 912 case OPAT: 913 shf_puts("OPAT=", shf); 914 dumpchar(shf, *wp++); 915 break; 916 case SPAT: 917 shf_puts("SPAT", shf); 918 break; 919 case CPAT: 920 shf_puts("CPAT", shf); 921 break; 922 default: 923 shf_fprintf(shf, "INVAL<%u>", (uint8_t)wp[-1]); 924 break; 925 } 926 shf_putc(' ', shf); 927 } 928 } 929 void 930 dumpwdvar(struct shf *shf, const char *wp) 931 { 932 dumpwdvar_i(shf, wp, 0); 933 } 934 935 void 936 dumpioact(struct shf *shf, struct op *t) 937 { 938 struct ioword **ioact, *iop; 939 940 if ((ioact = t->ioact) == NULL) 941 return; 942 943 shf_puts("{IOACT", shf); 944 while ((iop = *ioact++) != NULL) { 945 unsigned short type = iop->ioflag & IOTYPE; 946 #define DT(x) case x: shf_puts(#x, shf); break; 947 #define DB(x) if (iop->ioflag & x) shf_puts("|" #x, shf); 948 949 shf_putc(';', shf); 950 switch (type) { 951 DT(IOREAD) 952 DT(IOWRITE) 953 DT(IORDWR) 954 DT(IOHERE) 955 DT(IOCAT) 956 DT(IODUP) 957 default: 958 shf_fprintf(shf, "unk%d", type); 959 } 960 DB(IOEVAL) 961 DB(IOSKIP) 962 DB(IOCLOB) 963 DB(IORDUP) 964 DB(IONAMEXP) 965 DB(IOBASH) 966 DB(IOHERESTR) 967 DB(IONDELIM) 968 shf_fprintf(shf, ",unit=%d", (int)iop->unit); 969 if (iop->delim && !(iop->ioflag & IONDELIM)) { 970 shf_puts(",delim<", shf); 971 dumpwdvar(shf, iop->delim); 972 shf_putc('>', shf); 973 } 974 if (iop->ioname) { 975 if (iop->ioflag & IONAMEXP) { 976 shf_puts(",name=", shf); 977 print_value_quoted(shf, iop->ioname); 978 } else { 979 shf_puts(",name<", shf); 980 dumpwdvar(shf, iop->ioname); 981 shf_putc('>', shf); 982 } 983 } 984 if (iop->heredoc) { 985 shf_puts(",heredoc=", shf); 986 print_value_quoted(shf, iop->heredoc); 987 } 988 #undef DT 989 #undef DB 990 } 991 shf_putc('}', shf); 992 } 993 994 void 995 dumptree(struct shf *shf, struct op *t) 996 { 997 int i, j; 998 const char **w, *name; 999 struct op *t1; 1000 static int nesting; 1001 1002 for (i = 0; i < nesting; ++i) 1003 shf_putc('\t', shf); 1004 ++nesting; 1005 shf_puts("{tree:" /*}*/, shf); 1006 if (t == NULL) { 1007 name = "(null)"; 1008 goto out; 1009 } 1010 dumpioact(shf, t); 1011 switch (t->type) { 1012 #define OPEN(x) case x: name = #x; shf_puts(" {" #x ":", shf); /*}*/ 1013 1014 OPEN(TCOM) 1015 if (t->vars) { 1016 i = 0; 1017 w = (const char **)t->vars; 1018 while (*w) { 1019 shf_putc('\n', shf); 1020 for (j = 0; j < nesting; ++j) 1021 shf_putc('\t', shf); 1022 shf_fprintf(shf, " var%d<", i++); 1023 dumpwdvar(shf, *w++); 1024 shf_putc('>', shf); 1025 } 1026 } else 1027 shf_puts(" #no-vars#", shf); 1028 if (t->args) { 1029 i = 0; 1030 w = t->args; 1031 while (*w) { 1032 shf_putc('\n', shf); 1033 for (j = 0; j < nesting; ++j) 1034 shf_putc('\t', shf); 1035 shf_fprintf(shf, " arg%d<", i++); 1036 dumpwdvar(shf, *w++); 1037 shf_putc('>', shf); 1038 } 1039 } else 1040 shf_puts(" #no-args#", shf); 1041 break; 1042 OPEN(TEXEC) 1043 dumpleftandout: 1044 t = t->left; 1045 dumpandout: 1046 shf_putc('\n', shf); 1047 dumptree(shf, t); 1048 break; 1049 OPEN(TPAREN) 1050 goto dumpleftandout; 1051 OPEN(TPIPE) 1052 dumpleftmidrightandout: 1053 shf_putc('\n', shf); 1054 dumptree(shf, t->left); 1055 /* middumprightandout: (unused) */ 1056 shf_fprintf(shf, "/%s:", name); 1057 dumprightandout: 1058 t = t->right; 1059 goto dumpandout; 1060 OPEN(TLIST) 1061 goto dumpleftmidrightandout; 1062 OPEN(TOR) 1063 goto dumpleftmidrightandout; 1064 OPEN(TAND) 1065 goto dumpleftmidrightandout; 1066 OPEN(TBANG) 1067 goto dumprightandout; 1068 OPEN(TDBRACKET) 1069 i = 0; 1070 w = t->args; 1071 while (*w) { 1072 shf_putc('\n', shf); 1073 for (j = 0; j < nesting; ++j) 1074 shf_putc('\t', shf); 1075 shf_fprintf(shf, " arg%d<", i++); 1076 dumpwdvar(shf, *w++); 1077 shf_putc('>', shf); 1078 } 1079 break; 1080 OPEN(TFOR) 1081 dumpfor: 1082 shf_fprintf(shf, " str<%s>", t->str); 1083 if (t->vars != NULL) { 1084 i = 0; 1085 w = (const char **)t->vars; 1086 while (*w) { 1087 shf_putc('\n', shf); 1088 for (j = 0; j < nesting; ++j) 1089 shf_putc('\t', shf); 1090 shf_fprintf(shf, " var%d<", i++); 1091 dumpwdvar(shf, *w++); 1092 shf_putc('>', shf); 1093 } 1094 } 1095 goto dumpleftandout; 1096 OPEN(TSELECT) 1097 goto dumpfor; 1098 OPEN(TCASE) 1099 shf_fprintf(shf, " str<%s>", t->str); 1100 i = 0; 1101 for (t1 = t->left; t1 != NULL; t1 = t1->right) { 1102 shf_putc('\n', shf); 1103 for (j = 0; j < nesting; ++j) 1104 shf_putc('\t', shf); 1105 shf_fprintf(shf, " sub%d[(", i); 1106 w = (const char **)t1->vars; 1107 while (*w) { 1108 dumpwdvar(shf, *w); 1109 if (w[1] != NULL) 1110 shf_putc('|', shf); 1111 ++w; 1112 } 1113 shf_putc(')', shf); 1114 dumpioact(shf, t); 1115 shf_putc('\n', shf); 1116 dumptree(shf, t1->left); 1117 shf_fprintf(shf, " ;%c/%d]", t1->u.charflag, i++); 1118 } 1119 break; 1120 OPEN(TWHILE) 1121 goto dumpleftmidrightandout; 1122 OPEN(TUNTIL) 1123 goto dumpleftmidrightandout; 1124 OPEN(TBRACE) 1125 goto dumpleftandout; 1126 OPEN(TCOPROC) 1127 goto dumpleftandout; 1128 OPEN(TASYNC) 1129 goto dumpleftandout; 1130 OPEN(TFUNCT) 1131 shf_fprintf(shf, " str<%s> ksh<%s>", t->str, 1132 t->u.ksh_func ? Ttrue : Tfalse); 1133 goto dumpleftandout; 1134 OPEN(TTIME) 1135 goto dumpleftandout; 1136 OPEN(TIF) 1137 dumpif: 1138 shf_putc('\n', shf); 1139 dumptree(shf, t->left); 1140 t = t->right; 1141 dumpioact(shf, t); 1142 if (t->left != NULL) { 1143 shf_puts(" /TTHEN:\n", shf); 1144 dumptree(shf, t->left); 1145 } 1146 if (t->right && t->right->type == TELIF) { 1147 shf_puts(" /TELIF:", shf); 1148 t = t->right; 1149 dumpioact(shf, t); 1150 goto dumpif; 1151 } 1152 if (t->right != NULL) { 1153 shf_puts(" /TELSE:\n", shf); 1154 dumptree(shf, t->right); 1155 } 1156 break; 1157 OPEN(TEOF) 1158 dumpunexpected: 1159 shf_puts(Tunexpected, shf); 1160 break; 1161 OPEN(TELIF) 1162 goto dumpunexpected; 1163 OPEN(TPAT) 1164 goto dumpunexpected; 1165 default: 1166 name = "TINVALID"; 1167 shf_fprintf(shf, "{T<%d>:" /*}*/, t->type); 1168 goto dumpunexpected; 1169 1170 #undef OPEN 1171 } 1172 out: 1173 shf_fprintf(shf, /*{*/ " /%s}\n", name); 1174 --nesting; 1175 } 1176 #endif 1177
