bin/ksh/exec.c

   1 /*      $OpenBSD: exec.c,v 1.73 2018/03/15 16:51:29 anton Exp $ */
   2
   3 /*
   4  * execute command tree
   5  */
   6
   7 #include <sys/stat.h>
   8
   9 #include <ctype.h>
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <paths.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17
  18 #include "sh.h"
  19 #include "c_test.h"
  20
  21 /* Does ps4 get parameter substitutions done? */
  22 # define PS4_SUBSTITUTE(s)      substitute((s), 0)
  23
  24 static int      comexec(struct op *, struct tbl *volatile, char **,
  25                     int volatile, volatile int *);
  26 static void     scriptexec(struct op *, char **);
  27 static int      call_builtin(struct tbl *, char **);
  28 static int      iosetup(struct ioword *, struct tbl *);
  29 static int      herein(const char *, int);
  30 static char     *do_selectargs(char **, bool);
  31 static int      dbteste_isa(Test_env *, Test_meta);
  32 static const char *dbteste_getopnd(Test_env *, Test_op, int);
  33 static int      dbteste_eval(Test_env *, Test_op, const char *, const char *,
  34                     int);
  35 static void     dbteste_error(Test_env *, int, const char *);
  36
  37
  38 /*
  39  * execute command tree
  40  */
  41 int
  42 execute(struct op *volatile t,
  43     volatile int flags,         /* if XEXEC don't fork */
  44     volatile int *xerrok)       /* inform recursive callers in -e mode that
  45                                  * short-circuit && or || shouldn't be treated
  46                                  * as an error */
  47 {
  48         int i, dummy = 0, save_xerrok = 0;
  49         volatile int rv = 0;
  50         int pv[2];
  51         char ** volatile ap;
  52         char *s, *cp;
  53         struct ioword **iowp;
  54         struct tbl *tp = NULL;
  55
  56         if (t == NULL)
  57                 return 0;
  58
  59         /* Caller doesn't care if XERROK should propagate. */
  60         if (xerrok == NULL)
  61                 xerrok = &dummy;
  62
  63         /* Is this the end of a pipeline?  If so, we want to evaluate the
  64          * command arguments
  65         bool eval_done = false;
  66         if ((flags&XFORK) && !(flags&XEXEC) && (flags&XPCLOSE)) {
  67                 eval_done = true;
  68                 tp = eval_execute_args(t, &ap);
  69         }
  70          */
  71         if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
  72                 return exchild(t, flags & ~XTIME, xerrok, -1); /* run in sub-process */
  73
  74         newenv(E_EXEC);
  75         if (trap)
  76                 runtraps(0);
  77
  78         if (t->type == TCOM) {
  79                 /* Clear subst_exstat before argument expansion.  Used by
  80                  * null commands (see comexec() and c_eval()) and by c_set().
  81                  */
  82                 subst_exstat = 0;
  83
  84                 current_lineno = t->lineno;     /* for $LINENO */
  85
  86                 /* POSIX says expand command words first, then redirections,
  87                  * and assignments last..
  88                  */
  89                 ap = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
  90                 if (flags & XTIME)
  91                         /* Allow option parsing (bizarre, but POSIX) */
  92                         timex_hook(t, &ap);
  93                 if (Flag(FXTRACE) && ap[0]) {
  94                         shf_fprintf(shl_out, "%s",
  95                                 PS4_SUBSTITUTE(str_val(global("PS4"))));
  96                         for (i = 0; ap[i]; i++)
  97                                 shf_fprintf(shl_out, "%s%s", ap[i],
  98                                     ap[i + 1] ? " " : "\n");
  99                         shf_flush(shl_out);
 100                 }
 101                 if (ap[0])
 102                         tp = findcom(ap[0], FC_BI|FC_FUNC);
 103         }
 104         flags &= ~XTIME;
 105
 106         if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
 107                 genv->savefd = areallocarray(NULL, NUFILE, sizeof(short), ATEMP);
 108                 /* initialize to not redirected */
 109                 memset(genv->savefd, 0, NUFILE * sizeof(short));
 110         }
 111
 112         /* do redirection, to be restored in quitenv() */
 113         if (t->ioact != NULL)
 114                 for (iowp = t->ioact; *iowp != NULL; iowp++) {
 115                         if (iosetup(*iowp, tp) < 0) {
 116                                 exstat = rv = 1;
 117                                 /* Redirection failures for special commands
 118                                  * cause (non-interactive) shell to exit.
 119                                  */
 120                                 if (tp && tp->type == CSHELL &&
 121                                     (tp->flag & SPEC_BI))
 122                                         errorf(NULL);
 123                                 /* Deal with FERREXIT, quitenv(), etc. */
 124                                 goto Break;
 125                         }
 126                 }
 127
 128         switch (t->type) {
 129         case TCOM:
 130                 rv = comexec(t, tp, ap, flags, xerrok);
 131                 break;
 132
 133         case TPAREN:
 134                 rv = execute(t->left, flags|XFORK, xerrok);
 135                 break;
 136
 137         case TPIPE:
 138                 flags |= XFORK;
 139                 flags &= ~XEXEC;
 140                 genv->savefd[0] = savefd(0);
 141                 genv->savefd[1] = savefd(1);
 142                 while (t->type == TPIPE) {
 143                         openpipe(pv);
 144                         (void) ksh_dup2(pv[1], 1, false); /* stdout of curr */
 145                         /* Let exchild() close pv[0] in child
 146                          * (if this isn't done, commands like
 147                          *    (: ; cat /etc/termcap) | sleep 1
 148                          *  will hang forever).
 149                          */
 150                         exchild(t->left, flags|XPIPEO|XCCLOSE, NULL, pv[0]);
 151                         (void) ksh_dup2(pv[0], 0, false); /* stdin of next */
 152                         closepipe(pv);
 153                         flags |= XPIPEI;
 154                         t = t->right;
 155                 }
 156                 restfd(1, genv->savefd[1]); /* stdout of last */
 157                 genv->savefd[1] = 0; /* no need to re-restore this */
 158                 /* Let exchild() close 0 in parent, after fork, before wait */
 159                 i = exchild(t, flags|XPCLOSE, xerrok, 0);
 160                 if (!(flags&XBGND) && !(flags&XXCOM))
 161                         rv = i;
 162                 break;
 163
 164         case TLIST:
 165                 while (t->type == TLIST) {
 166                         execute(t->left, flags & XERROK, NULL);
 167                         t = t->right;
 168                 }
 169                 rv = execute(t, flags & XERROK, xerrok);
 170                 break;
 171
 172         case TCOPROC:
 173             {
 174                 sigset_t        omask;
 175
 176                 /* Block sigchild as we are using things changed in the
 177                  * signal handler
 178                  */
 179                 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
 180                 genv->type = E_ERRH;
 181                 i = sigsetjmp(genv->jbuf, 0);
 182                 if (i) {
 183                         sigprocmask(SIG_SETMASK, &omask, NULL);
 184                         quitenv(NULL);
 185                         unwind(i);
 186                         /* NOTREACHED */
 187                 }
 188                 /* Already have a (live) co-process? */
 189                 if (coproc.job && coproc.write >= 0)
 190                         errorf("coprocess already exists");
 191
 192                 /* Can we re-use the existing co-process pipe? */
 193                 coproc_cleanup(true);
 194
 195                 /* do this before opening pipes, in case these fail */
 196                 genv->savefd[0] = savefd(0);
 197                 genv->savefd[1] = savefd(1);
 198
 199                 openpipe(pv);
 200                 if (pv[0] != 0) {
 201                         ksh_dup2(pv[0], 0, false);
 202                         close(pv[0]);
 203                 }
 204                 coproc.write = pv[1];
 205                 coproc.job = NULL;
 206
 207                 if (coproc.readw >= 0)
 208                         ksh_dup2(coproc.readw, 1, false);
 209                 else {
 210                         openpipe(pv);
 211                         coproc.read = pv[0];
 212                         ksh_dup2(pv[1], 1, false);
 213                         coproc.readw = pv[1];    /* closed before first read */
 214                         coproc.njobs = 0;
 215                         /* create new coprocess id */
 216                         ++coproc.id;
 217                 }
 218                 sigprocmask(SIG_SETMASK, &omask, NULL);
 219                 genv->type = E_EXEC; /* no more need for error handler */
 220
 221                 /* exchild() closes coproc.* in child after fork,
 222                  * will also increment coproc.njobs when the
 223                  * job is actually created.
 224                  */
 225                 flags &= ~XEXEC;
 226                 exchild(t->left, flags|XBGND|XFORK|XCOPROC|XCCLOSE,
 227                     NULL, coproc.readw);
 228                 break;
 229             }
 230
 231         case TASYNC:
 232                 /* XXX non-optimal, I think - "(foo &)", forks for (),
 233                  * forks again for async...  parent should optimize
 234                  * this to "foo &"...
 235                  */
 236                 rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);
 237                 break;
 238
 239         case TOR:
 240         case TAND:
 241                 rv = execute(t->left, XERROK, xerrok);
 242                 if ((rv == 0) == (t->type == TAND))
 243                         rv = execute(t->right, flags & XERROK, xerrok);
 244                 else {
 245                         flags |= XERROK;
 246                         *xerrok = 1;
 247                 }
 248                 break;
 249
 250         case TBANG:
 251                 rv = !execute(t->right, XERROK, xerrok);
 252                 flags |= XERROK;
 253                 *xerrok = 1;
 254                 break;
 255
 256         case TDBRACKET:
 257             {
 258                 Test_env te;
 259
 260                 te.flags = TEF_DBRACKET;
 261                 te.pos.wp = t->args;
 262                 te.isa = dbteste_isa;
 263                 te.getopnd = dbteste_getopnd;
 264                 te.eval = dbteste_eval;
 265                 te.error = dbteste_error;
 266
 267                 rv = test_parse(&te);
 268                 break;
 269             }
 270
 271         case TFOR:
 272         case TSELECT:
 273             {
 274                 volatile bool is_first = true;
 275                 ap = (t->vars != NULL) ? eval(t->vars, DOBLANK|DOGLOB|DOTILDE) :
 276                     genv->loc->argv + 1;
 277                 genv->type = E_LOOP;
 278                 while (1) {
 279                         i = sigsetjmp(genv->jbuf, 0);
 280                         if (!i)
 281                                 break;
 282                         if ((genv->flags&EF_BRKCONT_PASS) ||
 283                             (i != LBREAK && i != LCONTIN)) {
 284                                 quitenv(NULL);
 285                                 unwind(i);
 286                         } else if (i == LBREAK) {
 287                                 rv = 0;
 288                                 goto Break;
 289                         }
 290                 }
 291                 rv = 0; /* in case of a continue */
 292                 if (t->type == TFOR) {
 293                         save_xerrok = *xerrok;
 294                         while (*ap != NULL) {
 295                                 setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
 296                                 /* undo xerrok in all iterations except the
 297                                  * last */
 298                                 *xerrok = save_xerrok;
 299                                 rv = execute(t->left, flags & XERROK, xerrok);
 300                         }
 301                         /* ripple xerrok set at final iteration */
 302                 } else { /* TSELECT */
 303                         for (;;) {
 304                                 if (!(cp = do_selectargs(ap, is_first))) {
 305                                         rv = 1;
 306                                         break;
 307                                 }
 308                                 is_first = false;
 309                                 setstr(global(t->str), cp, KSH_UNWIND_ERROR);
 310                                 rv = execute(t->left, flags & XERROK, xerrok);
 311                         }
 312                 }
 313             }
 314                 break;
 315
 316         case TWHILE:
 317         case TUNTIL:
 318                 genv->type = E_LOOP;
 319                 while (1) {
 320                         i = sigsetjmp(genv->jbuf, 0);
 321                         if (!i)
 322                                 break;
 323                         if ((genv->flags&EF_BRKCONT_PASS) ||
 324                             (i != LBREAK && i != LCONTIN)) {
 325                                 quitenv(NULL);
 326                                 unwind(i);
 327                         } else if (i == LBREAK) {
 328                                 rv = 0;
 329                                 goto Break;
 330                         }
 331                 }
 332                 rv = 0; /* in case of a continue */
 333                 while ((execute(t->left, XERROK, NULL) == 0) == (t->type == TWHILE))
 334                         rv = execute(t->right, flags & XERROK, xerrok);
 335                 break;
 336
 337         case TIF:
 338         case TELIF:
 339                 if (t->right == NULL)
 340                         break;  /* should be error */
 341                 rv = execute(t->left, XERROK, NULL) == 0 ?
 342                     execute(t->right->left, flags & XERROK, xerrok) :
 343                     execute(t->right->right, flags & XERROK, xerrok);
 344                 break;
 345
 346         case TCASE:
 347                 cp = evalstr(t->str, DOTILDE);
 348                 for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {
 349                         for (ap = t->vars; *ap; ap++) {
 350                                 if ((s = evalstr(*ap, DOTILDE|DOPAT)) &&
 351                                     gmatch(cp, s, false))
 352                                         goto Found;
 353                         }
 354                 }
 355                 break;
 356           Found:
 357                 rv = execute(t->left, flags & XERROK, xerrok);
 358                 break;
 359
 360         case TBRACE:
 361                 rv = execute(t->left, flags & XERROK, xerrok);
 362                 break;
 363
 364         case TFUNCT:
 365                 rv = define(t->str, t);
 366                 break;
 367
 368         case TTIME:
 369                 /* Clear XEXEC so nested execute() call doesn't exit
 370                  * (allows "ls -l | time grep foo").
 371                  */
 372                 rv = timex(t, flags & ~XEXEC, xerrok);
 373                 break;
 374
 375         case TEXEC:             /* an eval'd TCOM */
 376                 s = t->args[0];
 377                 ap = makenv();
 378                 restoresigs();
 379                 cleanup_proc_env();
 380                 execve(t->str, t->args, ap);
 381                 if (errno == ENOEXEC)
 382                         scriptexec(t, ap);
 383                 else
 384                         errorf("%s: %s", s, strerror(errno));
 385         }
 386     Break:
 387         exstat = rv;
 388
 389         quitenv(NULL);          /* restores IO */
 390         if ((flags&XEXEC))
 391                 unwind(LEXIT);  /* exit child */
 392         if (rv != 0 && !(flags & XERROK) && !*xerrok) {
 393                 trapsig(SIGERR_);
 394                 if (Flag(FERREXIT))
 395                         unwind(LERROR);
 396         }
 397         return rv;
 398 }
 399
 400 /*
 401  * execute simple command
 402  */
 403
 404 static int
 405 comexec(struct op *t, struct tbl *volatile tp, char **ap, volatile int flags,
 406     volatile int *xerrok)
 407 {
 408         int i;
 409         volatile int rv = 0;
 410         char *cp;
 411         char **lastp;
 412         struct op texec;
 413         int type_flags;
 414         int keepasn_ok;
 415         int fcflags = FC_BI|FC_FUNC|FC_PATH;
 416         int bourne_function_call = 0;
 417
 418         /* snag the last argument for $_ XXX not the same as at&t ksh,
 419          * which only seems to set $_ after a newline (but not in
 420          * functions/dot scripts, but in interactive and script) -
 421          * perhaps save last arg here and set it in shell()?.
 422          */
 423         if (!Flag(FSH) && Flag(FTALKING) && *(lastp = ap)) {
 424                 while (*++lastp)
 425                         ;
 426                 /* setstr() can't fail here */
 427                 setstr(typeset("_", LOCAL, 0, INTEGER, 0), *--lastp,
 428                     KSH_RETURN_ERROR);
 429         }
 430
 431         /* Deal with the shell builtins builtin, exec and command since
 432          * they can be followed by other commands.  This must be done before
 433          * we know if we should create a local block, which must be done
 434          * before we can do a path search (in case the assignments change
 435          * PATH).
 436          * Odd cases:
 437          *   FOO=bar exec > /dev/null           FOO is kept but not exported
 438          *   FOO=bar exec foobar                FOO is exported
 439          *   FOO=bar command exec > /dev/null   FOO is neither kept nor exported
 440          *   FOO=bar command                    FOO is neither kept nor exported
 441          *   PATH=... foobar                    use new PATH in foobar search
 442          */
 443         keepasn_ok = 1;
 444         while (tp && tp->type == CSHELL) {
 445                 fcflags = FC_BI|FC_FUNC|FC_PATH;/* undo effects of command */
 446                 if (tp->val.f == c_builtin) {
 447                         if ((cp = *++ap) == NULL) {
 448                                 tp = NULL;
 449                                 break;
 450                         }
 451                         tp = findcom(cp, FC_BI);
 452                         if (tp == NULL)
 453                                 errorf("builtin: %s: not a builtin", cp);
 454                         continue;
 455                 } else if (tp->val.f == c_exec) {
 456                         if (ap[1] == NULL)
 457                                 break;
 458                         ap++;
 459                         flags |= XEXEC;
 460                 } else if (tp->val.f == c_command) {
 461                         int optc, saw_p = 0;
 462
 463                         /* Ugly dealing with options in two places (here and
 464                          * in c_command(), but such is life)
 465                          */
 466                         ksh_getopt_reset(&builtin_opt, 0);
 467                         while ((optc = ksh_getopt(ap, &builtin_opt, ":p")) == 'p')
 468                                 saw_p = 1;
 469                         if (optc != EOF)
 470                                 break;  /* command -vV or something */
 471                         /* don't look for functions */
 472                         fcflags = FC_BI|FC_PATH;
 473                         if (saw_p) {
 474                                 if (Flag(FRESTRICTED)) {
 475                                         warningf(true,
 476                                             "command -p: restricted");
 477                                         rv = 1;
 478                                         goto Leave;
 479                                 }
 480                                 fcflags |= FC_DEFPATH;
 481                         }
 482                         ap += builtin_opt.optind;
 483                         /* POSIX says special builtins lose their status
 484                          * if accessed using command.
 485                          */
 486                         keepasn_ok = 0;
 487                         if (!ap[0]) {
 488                                 /* ensure command with no args exits with 0 */
 489                                 subst_exstat = 0;
 490                                 break;
 491                         }
 492                 } else
 493                         break;
 494                 tp = findcom(ap[0], fcflags & (FC_BI|FC_FUNC));
 495         }
 496         if (keepasn_ok && (!ap[0] || (tp && (tp->flag & KEEPASN))))
 497                 type_flags = 0;
 498         else {
 499                 /* create new variable/function block */
 500                 newblock();
 501                 /* ksh functions don't keep assignments, POSIX functions do. */
 502                 if (keepasn_ok && tp && tp->type == CFUNC &&
 503                     !(tp->flag & FKSH)) {
 504                         bourne_function_call = 1;
 505                         type_flags = 0;
 506                 } else
 507                         type_flags = LOCAL|LOCAL_COPY|EXPORT;
 508         }
 509         if (Flag(FEXPORT))
 510                 type_flags |= EXPORT;
 511         for (i = 0; t->vars[i]; i++) {
 512                 cp = evalstr(t->vars[i], DOASNTILDE);
 513                 if (Flag(FXTRACE)) {
 514                         if (i == 0)
 515                                 shf_fprintf(shl_out, "%s",
 516                                     PS4_SUBSTITUTE(str_val(global("PS4"))));
 517                         shf_fprintf(shl_out, "%s%s", cp,
 518                             t->vars[i + 1] ? " " : "\n");
 519                         if (!t->vars[i + 1])
 520                                 shf_flush(shl_out);
 521                 }
 522                 typeset(cp, type_flags, 0, 0, 0);
 523                 if (bourne_function_call && !(type_flags & EXPORT))
 524                         typeset(cp, LOCAL|LOCAL_COPY|EXPORT, 0, 0, 0);
 525         }
 526
 527         if ((cp = *ap) == NULL) {
 528                 rv = subst_exstat;
 529                 goto Leave;
 530         } else if (!tp) {
 531                 if (Flag(FRESTRICTED) && strchr(cp, '/')) {
 532                         warningf(true, "%s: restricted", cp);
 533                         rv = 1;
 534                         goto Leave;
 535                 }
 536                 tp = findcom(cp, fcflags);
 537         }
 538
 539         switch (tp->type) {
 540         case CSHELL:                    /* shell built-in */
 541                 rv = call_builtin(tp, ap);
 542                 break;
 543
 544         case CFUNC:                     /* function call */
 545             {
 546                 volatile int old_xflag, old_inuse;
 547                 const char *volatile old_kshname;
 548
 549                 if (!(tp->flag & ISSET)) {
 550                         struct tbl *ftp;
 551
 552                         if (!tp->u.fpath) {
 553                                 if (tp->u2.errno_) {
 554                                         warningf(true,
 555                                             "%s: can't find function "
 556                                             "definition file - %s",
 557                                             cp, strerror(tp->u2.errno_));
 558                                         rv = 126;
 559                                 } else {
 560                                         warningf(true,
 561                                             "%s: can't find function "
 562                                             "definition file", cp);
 563                                         rv = 127;
 564                                 }
 565                                 break;
 566                         }
 567                         if (include(tp->u.fpath, 0, NULL, 0) < 0) {
 568                                 warningf(true,
 569                                     "%s: can't open function definition file %s - %s",
 570                                     cp, tp->u.fpath, strerror(errno));
 571                                 rv = 127;
 572                                 break;
 573                         }
 574                         if (!(ftp = findfunc(cp, hash(cp), false)) ||
 575                             !(ftp->flag & ISSET)) {
 576                                 warningf(true,
 577                                     "%s: function not defined by %s",
 578                                     cp, tp->u.fpath);
 579                                 rv = 127;
 580                                 break;
 581                         }
 582                         tp = ftp;
 583                 }
 584
 585                 /* ksh functions set $0 to function name, POSIX functions leave
 586                  * $0 unchanged.
 587                  */
 588                 old_kshname = kshname;
 589                 if (tp->flag & FKSH)
 590                         kshname = ap[0];
 591                 else
 592                         ap[0] = (char *) kshname;
 593                 genv->loc->argv = ap;
 594                 for (i = 0; *ap++ != NULL; i++)
 595                         ;
 596                 genv->loc->argc = i - 1;
 597                 /* ksh-style functions handle getopts sanely,
 598                  * bourne/posix functions are insane...
 599                  */
 600                 if (tp->flag & FKSH) {
 601                         genv->loc->flags |= BF_DOGETOPTS;
 602                         genv->loc->getopts_state = user_opt;
 603                         getopts_reset(1);
 604                 }
 605
 606                 old_xflag = Flag(FXTRACE);
 607                 Flag(FXTRACE) = tp->flag & TRACE ? true : false;
 608
 609                 old_inuse = tp->flag & FINUSE;
 610                 tp->flag |= FINUSE;
 611
 612                 genv->type = E_FUNC;
 613                 i = sigsetjmp(genv->jbuf, 0);
 614                 if (i == 0) {
 615                         /* seems odd to pass XERROK here, but at&t ksh does */
 616                         exstat = execute(tp->val.t, flags & XERROK, xerrok);
 617                         i = LRETURN;
 618                 }
 619                 kshname = old_kshname;
 620                 Flag(FXTRACE) = old_xflag;
 621                 tp->flag = (tp->flag & ~FINUSE) | old_inuse;
 622                 /* Were we deleted while executing?  If so, free the execution
 623                  * tree.  todo: Unfortunately, the table entry is never re-used
 624                  * until the lookup table is expanded.
 625                  */
 626                 if ((tp->flag & (FDELETE|FINUSE)) == FDELETE) {
 627                         if (tp->flag & ALLOC) {
 628                                 tp->flag &= ~ALLOC;
 629                                 tfree(tp->val.t, tp->areap);
 630                         }
 631                         tp->flag = 0;
 632                 }
 633                 switch (i) {
 634                 case LRETURN:
 635                 case LERROR:
 636                         rv = exstat;
 637                         break;
 638                 case LINTR:
 639                 case LEXIT:
 640                 case LLEAVE:
 641                 case LSHELL:
 642                         quitenv(NULL);
 643                         unwind(i);
 644                         /* NOTREACHED */
 645                 default:
 646                         quitenv(NULL);
 647                         internal_errorf("CFUNC %d", i);
 648                 }
 649                 break;
 650             }
 651
 652         case CEXEC:             /* executable command */
 653         case CTALIAS:           /* tracked alias */
 654                 if (!(tp->flag&ISSET)) {
 655                         /* errno_ will be set if the named command was found
 656                          * but could not be executed (permissions, no execute
 657                          * bit, directory, etc).  Print out a (hopefully)
 658                          * useful error message and set the exit status to 126.
 659                          */
 660                         if (tp->u2.errno_) {
 661                                 warningf(true, "%s: cannot execute - %s", cp,
 662                                     strerror(tp->u2.errno_));
 663                                 rv = 126;       /* POSIX */
 664                         } else {
 665                                 warningf(true, "%s: not found", cp);
 666                                 rv = 127;
 667                         }
 668                         break;
 669                 }
 670
 671                 if (!Flag(FSH)) {
 672                         /* set $_ to program's full path */
 673                         /* setstr() can't fail here */
 674                         setstr(typeset("_", LOCAL|EXPORT, 0, INTEGER, 0),
 675                             tp->val.s, KSH_RETURN_ERROR);
 676                 }
 677
 678                 if (flags&XEXEC) {
 679                         j_exit();
 680                         if (!(flags&XBGND) || Flag(FMONITOR)) {
 681                                 setexecsig(&sigtraps[SIGINT], SS_RESTORE_ORIG);
 682                                 setexecsig(&sigtraps[SIGQUIT], SS_RESTORE_ORIG);
 683                         }
 684                 }
 685
 686                 /* to fork we set up a TEXEC node and call execute */
 687                 memset(&texec, 0, sizeof(texec));
 688                 texec.type = TEXEC;
 689                 texec.left = t; /* for tprint */
 690                 texec.str = tp->val.s;
 691                 texec.args = ap;
 692                 rv = exchild(&texec, flags, xerrok, -1);
 693                 break;
 694         }
 695   Leave:
 696         if (flags & XEXEC) {
 697                 exstat = rv;
 698                 unwind(LLEAVE);
 699         }
 700         return rv;
 701 }
 702
 703 static void
 704 scriptexec(struct op *tp, char **ap)
 705 {
 706         char *shell;
 707
 708         shell = str_val(global("EXECSHELL"));
 709         if (shell && *shell)
 710                 shell = search(shell, search_path, X_OK, NULL);
 711         if (!shell || !*shell)
 712                 shell = _PATH_BSHELL;
 713
 714         *tp->args-- = tp->str;
 715         *tp->args = shell;
 716
 717         execve(tp->args[0], tp->args, ap);
 718
 719         /* report both the program that was run and the bogus shell */
 720         errorf("%s: %s: %s", tp->str, shell, strerror(errno));
 721 }
 722
 723 int
 724 shcomexec(char **wp)
 725 {
 726         struct tbl *tp;
 727
 728         tp = ktsearch(&builtins, *wp, hash(*wp));
 729         if (tp == NULL)
 730                 internal_errorf("%s: %s", __func__, *wp);
 731         return call_builtin(tp, wp);
 732 }
 733
 734 /*
 735  * Search function tables for a function.  If create set, a table entry
 736  * is created if none is found.
 737  */
 738 struct tbl *
 739 findfunc(const char *name, unsigned int h, int create)
 740 {
 741         struct block *l;
 742         struct tbl *tp = NULL;
 743
 744         for (l = genv->loc; l; l = l->next) {
 745                 tp = ktsearch(&l->funs, name, h);
 746                 if (tp)
 747                         break;
 748                 if (!l->next && create) {
 749                         tp = ktenter(&l->funs, name, h);
 750                         tp->flag = DEFINED;
 751                         tp->type = CFUNC;
 752                         tp->val.t = NULL;
 753                         break;
 754                 }
 755         }
 756         return tp;
 757 }
 758
 759 /*
 760  * define function.  Returns 1 if function is being undefined (t == 0) and
 761  * function did not exist, returns 0 otherwise.
 762  */
 763 int
 764 define(const char *name, struct op *t)
 765 {
 766         struct tbl *tp;
 767         int was_set = 0;
 768
 769         while (1) {
 770                 tp = findfunc(name, hash(name), true);
 771
 772                 if (tp->flag & ISSET)
 773                         was_set = 1;
 774                 /* If this function is currently being executed, we zap this
 775                  * table entry so findfunc() won't see it
 776                  */
 777                 if (tp->flag & FINUSE) {
 778                         tp->name[0] = '\0';
 779                         tp->flag &= ~DEFINED; /* ensure it won't be found */
 780                         tp->flag |= FDELETE;
 781                 } else
 782                         break;
 783         }
 784
 785         if (tp->flag & ALLOC) {
 786                 tp->flag &= ~(ISSET|ALLOC);
 787                 tfree(tp->val.t, tp->areap);
 788         }
 789
 790         if (t == NULL) {                /* undefine */
 791                 ktdelete(tp);
 792                 return was_set ? 0 : 1;
 793         }
 794
 795         tp->val.t = tcopy(t->left, tp->areap);
 796         tp->flag |= (ISSET|ALLOC);
 797         if (t->u.ksh_func)
 798                 tp->flag |= FKSH;
 799
 800         return 0;
 801 }
 802
 803 /*
 804  * add builtin
 805  */
 806 void
 807 builtin(const char *name, int (*func) (char **))
 808 {
 809         struct tbl *tp;
 810         int flag;
 811
 812         /* see if any flags should be set for this builtin */
 813         for (flag = 0; ; name++) {
 814                 if (*name == '=')       /* command does variable assignment */
 815                         flag |= KEEPASN;
 816                 else if (*name == '*')  /* POSIX special builtin */
 817                         flag |= SPEC_BI;
 818                 else if (*name == '+')  /* POSIX regular builtin */
 819                         flag |= REG_BI;
 820                 else
 821                         break;
 822         }
 823
 824         tp = ktenter(&builtins, name, hash(name));
 825         tp->flag = DEFINED | flag;
 826         tp->type = CSHELL;
 827         tp->val.f = func;
 828 }
 829
 830 /*
 831  * find command
 832  * either function, hashed command, or built-in (in that order)
 833  */
 834 struct tbl *
 835 findcom(const char *name, int flags)
 836 {
 837         static struct tbl temp;
 838         unsigned int h = hash(name);
 839         struct tbl *tp = NULL, *tbi;
 840         int insert = Flag(FTRACKALL);   /* insert if not found */
 841         char *fpath;                    /* for function autoloading */
 842         char *npath;
 843
 844         if (strchr(name, '/') != NULL) {
 845                 insert = 0;
 846                 /* prevent FPATH search below */
 847                 flags &= ~FC_FUNC;
 848                 goto Search;
 849         }
 850         tbi = (flags & FC_BI) ? ktsearch(&builtins, name, h) : NULL;
 851         /* POSIX says special builtins first, then functions, then
 852          * POSIX regular builtins, then search path...
 853          */
 854         if ((flags & FC_SPECBI) && tbi && (tbi->flag & SPEC_BI))
 855                 tp = tbi;
 856         if (!tp && (flags & FC_FUNC)) {
 857                 tp = findfunc(name, h, false);
 858                 if (tp && !(tp->flag & ISSET)) {
 859                         if ((fpath = str_val(global("FPATH"))) == null) {
 860                                 tp->u.fpath = NULL;
 861                                 tp->u2.errno_ = 0;
 862                         } else
 863                                 tp->u.fpath = search(name, fpath, R_OK,
 864                                     &tp->u2.errno_);
 865                 }
 866         }
 867         if (!tp && (flags & FC_REGBI) && tbi && (tbi->flag & REG_BI))
 868                 tp = tbi;
 869         /* todo: posix says non-special/non-regular builtins must
 870          * be triggered by some user-controllable means like a
 871          * special directory in PATH.  Requires modifications to
 872          * the search() function.  Tracked aliases should be
 873          * modified to allow tracking of builtin commands.
 874          * This should be under control of the FPOSIX flag.
 875          * If this is changed, also change c_whence...
 876          */
 877         if (!tp && (flags & FC_UNREGBI) && tbi)
 878                 tp = tbi;
 879         if (!tp && (flags & FC_PATH) && !(flags & FC_DEFPATH)) {
 880                 tp = ktsearch(&taliases, name, h);
 881                 if (tp && (tp->flag & ISSET) && access(tp->val.s, X_OK) != 0) {
 882                         if (tp->flag & ALLOC) {
 883                                 tp->flag &= ~ALLOC;
 884                                 afree(tp->val.s, APERM);
 885                         }
 886                         tp->flag &= ~ISSET;
 887                 }
 888         }
 889
 890   Search:
 891         if ((!tp || (tp->type == CTALIAS && !(tp->flag&ISSET))) &&
 892             (flags & FC_PATH)) {
 893                 if (!tp) {
 894                         if (insert && !(flags & FC_DEFPATH)) {
 895                                 tp = ktenter(&taliases, name, h);
 896                                 tp->type = CTALIAS;
 897                         } else {
 898                                 tp = &temp;
 899                                 tp->type = CEXEC;
 900                         }
 901                         tp->flag = DEFINED;     /* make ~ISSET */
 902                 }
 903                 npath = search(name, flags & FC_DEFPATH ? def_path :
 904                     search_path, X_OK, &tp->u2.errno_);
 905                 if (npath) {
 906                         if (tp == &temp) {
 907                                 tp->val.s = npath;
 908                         } else {
 909                                 tp->val.s = str_save(npath, APERM);
 910                                 if (npath != name)
 911                                         afree(npath, ATEMP);
 912                         }
 913                         tp->flag |= ISSET|ALLOC;
 914                 } else if ((flags & FC_FUNC) &&
 915                     (fpath = str_val(global("FPATH"))) != null &&
 916                     (npath = search(name, fpath, R_OK,
 917                     &tp->u2.errno_)) != NULL) {
 918                         /* An undocumented feature of at&t ksh is that it
 919                          * searches FPATH if a command is not found, even
 920                          * if the command hasn't been set up as an autoloaded
 921                          * function (ie, no typeset -uf).
 922                          */
 923                         tp = &temp;
 924                         tp->type = CFUNC;
 925                         tp->flag = DEFINED; /* make ~ISSET */
 926                         tp->u.fpath = npath;
 927                 }
 928         }
 929         return tp;
 930 }
 931
 932 /*
 933  * flush executable commands with relative paths
 934  */
 935 void
 936 flushcom(int all)       /* just relative or all */
 937 {
 938         struct tbl *tp;
 939         struct tstate ts;
 940
 941         for (ktwalk(&ts, &taliases); (tp = ktnext(&ts)) != NULL; )
 942                 if ((tp->flag&ISSET) && (all || tp->val.s[0] != '/')) {
 943                         if (tp->flag&ALLOC) {
 944                                 tp->flag &= ~(ALLOC|ISSET);
 945                                 afree(tp->val.s, APERM);
 946                         }
 947                         tp->flag &= ~ISSET;
 948                 }
 949 }
 950
 951 /* Check if path is something we want to find.  Returns -1 for failure. */
 952 int
 953 search_access(const char *path, int mode,
 954     int *errnop)        /* set if candidate found, but not suitable */
 955 {
 956         int ret, err = 0;
 957         struct stat statb;
 958
 959         if (stat(path, &statb) < 0)
 960                 return -1;
 961         ret = access(path, mode);
 962         if (ret < 0)
 963                 err = errno; /* File exists, but we can't access it */
 964         else if (mode == X_OK && (!S_ISREG(statb.st_mode) ||
 965             !(statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)))) {
 966             /* This 'cause access() says root can execute everything */
 967                 ret = -1;
 968                 err = S_ISDIR(statb.st_mode) ? EISDIR : EACCES;
 969         }
 970         if (err && errnop && !*errnop)
 971                 *errnop = err;
 972         return ret;
 973 }
 974
 975 /*
 976  * search for command with PATH
 977  */
 978 char *
 979 search(const char *name, const char *path,
 980     int mode,           /* R_OK or X_OK */
 981     int *errnop)        /* set if candidate found, but not suitable */
 982 {
 983         const char *sp, *p;
 984         char *xp;
 985         XString xs;
 986         int namelen;
 987
 988         if (errnop)
 989                 *errnop = 0;
 990         if (strchr(name, '/')) {
 991                 if (search_access(name, mode, errnop) == 0)
 992                         return (char *) name;
 993                 return NULL;
 994         }
 995
 996         namelen = strlen(name) + 1;
 997         Xinit(xs, xp, 128, ATEMP);
 998
 999         sp = path;
1000         while (sp != NULL) {
1001                 xp = Xstring(xs, xp);
1002                 if (!(p = strchr(sp, ':')))
1003                         p = sp + strlen(sp);
1004                 if (p != sp) {
1005                         XcheckN(xs, xp, p - sp);
1006                         memcpy(xp, sp, p - sp);
1007                         xp += p - sp;
1008                         *xp++ = '/';
1009                 }
1010                 sp = p;
1011                 XcheckN(xs, xp, namelen);
1012                 memcpy(xp, name, namelen);
1013                 if (search_access(Xstring(xs, xp), mode, errnop) == 0)
1014                         return Xclose(xs, xp + namelen);
1015                 if (*sp++ == '\0')
1016                         sp = NULL;
1017         }
1018         Xfree(xs, xp);
1019         return NULL;
1020 }
1021
1022 static int
1023 call_builtin(struct tbl *tp, char **wp)
1024 {
1025         int rv;
1026
1027         builtin_argv0 = wp[0];
1028         builtin_flag = tp->flag;
1029         shf_reopen(1, SHF_WR, shl_stdout);
1030         shl_stdout_ok = 1;
1031         ksh_getopt_reset(&builtin_opt, GF_ERROR);
1032         rv = (*tp->val.f)(wp);
1033         shf_flush(shl_stdout);
1034         shl_stdout_ok = 0;
1035         builtin_flag = 0;
1036         builtin_argv0 = NULL;
1037         return rv;
1038 }
1039
1040 /*
1041  * set up redirection, saving old fd's in e->savefd
1042  */
1043 static int
1044 iosetup(struct ioword *iop, struct tbl *tp)
1045 {
1046         int u = -1;
1047         char *cp = iop->name;
1048         int iotype = iop->flag & IOTYPE;
1049         int do_open = 1, do_close = 0, flags = 0;
1050         struct ioword iotmp;
1051         struct stat statb;
1052
1053         if (iotype != IOHERE)
1054                 cp = evalonestr(cp, DOTILDE|(Flag(FTALKING_I) ? DOGLOB : 0));
1055
1056         /* Used for tracing and error messages to print expanded cp */
1057         iotmp = *iop;
1058         iotmp.name = (iotype == IOHERE) ? NULL : cp;
1059         iotmp.flag |= IONAMEXP;
1060
1061         if (Flag(FXTRACE))
1062                 shellf("%s%s\n",
1063                     PS4_SUBSTITUTE(str_val(global("PS4"))),
1064                     snptreef(NULL, 32, "%R", &iotmp));
1065
1066         switch (iotype) {
1067         case IOREAD:
1068                 flags = O_RDONLY;
1069                 break;
1070
1071         case IOCAT:
1072                 flags = O_WRONLY | O_APPEND | O_CREAT;
1073                 break;
1074
1075         case IOWRITE:
1076                 flags = O_WRONLY | O_CREAT | O_TRUNC;
1077                 /* The stat() is here to allow redirections to
1078                  * things like /dev/null without error.
1079                  */
1080                 if (Flag(FNOCLOBBER) && !(iop->flag & IOCLOB) &&
1081                     (stat(cp, &statb) < 0 || S_ISREG(statb.st_mode)))
1082                         flags |= O_EXCL;
1083                 break;
1084
1085         case IORDWR:
1086                 flags = O_RDWR | O_CREAT;
1087                 break;
1088
1089         case IOHERE:
1090                 do_open = 0;
1091                 /* herein() returns -2 if error has been printed */
1092                 u = herein(iop->heredoc, iop->flag & IOEVAL);
1093                 /* cp may have wrong name */
1094                 break;
1095
1096         case IODUP:
1097             {
1098                 const char *emsg;
1099
1100                 do_open = 0;
1101                 if (*cp == '-' && !cp[1]) {
1102                         u = 1009;        /* prevent error return below */
1103                         do_close = 1;
1104                 } else if ((u = check_fd(cp,
1105                     X_OK | ((iop->flag & IORDUP) ? R_OK : W_OK),
1106                     &emsg)) < 0) {
1107                         warningf(true, "%s: %s",
1108                             snptreef(NULL, 32, "%R", &iotmp), emsg);
1109                         return -1;
1110                 }
1111                 if (u == iop->unit)
1112                         return 0;               /* "dup from" == "dup to" */
1113                 break;
1114             }
1115         }
1116
1117         if (do_open) {
1118                 if (Flag(FRESTRICTED) && (flags & O_CREAT)) {
1119                         warningf(true, "%s: restricted", cp);
1120                         return -1;
1121                 }
1122                 u = open(cp, flags, 0666);
1123         }
1124         if (u < 0) {
1125                 /* herein() may already have printed message */
1126                 if (u == -1)
1127                         warningf(true, "cannot %s %s: %s",
1128                             iotype == IODUP ? "dup" :
1129                             (iotype == IOREAD || iotype == IOHERE) ?
1130                             "open" : "create", cp, strerror(errno));
1131                 return -1;
1132         }
1133         /* Do not save if it has already been redirected (i.e. "cat >x >y"). */
1134         if (genv->savefd[iop->unit] == 0) {
1135                 /* If these are the same, it means unit was previously closed */
1136                 if (u == iop->unit)
1137                         genv->savefd[iop->unit] = -1;
1138                 else
1139                         /* c_exec() assumes e->savefd[fd] set for any
1140                          * redirections.  Ask savefd() not to close iop->unit;
1141                          * this allows error messages to be seen if iop->unit
1142                          * is 2; also means we can't lose the fd (eg, both
1143                          * dup2 below and dup2 in restfd() failing).
1144                          */
1145                         genv->savefd[iop->unit] = savefd(iop->unit);
1146         }
1147
1148         if (do_close)
1149                 close(iop->unit);
1150         else if (u != iop->unit) {
1151                 if (ksh_dup2(u, iop->unit, true) < 0) {
1152                         warningf(true,
1153                             "could not finish (dup) redirection %s: %s",
1154                             snptreef(NULL, 32, "%R", &iotmp),
1155                             strerror(errno));
1156                         if (iotype != IODUP)
1157                                 close(u);
1158                         return -1;
1159                 }
1160                 if (iotype != IODUP)
1161                         close(u);
1162                 /* Touching any co-process fd in an empty exec
1163                  * causes the shell to close its copies
1164                  */
1165                 else if (tp && tp->type == CSHELL && tp->val.f == c_exec) {
1166                         if (iop->flag & IORDUP) /* possible exec <&p */
1167                                 coproc_read_close(u);
1168                         else                    /* possible exec >&p */
1169                                 coproc_write_close(u);
1170                 }
1171         }
1172         if (u == 2) /* Clear any write errors */
1173                 shf_reopen(2, SHF_WR, shl_out);
1174         return 0;
1175 }
1176
1177 /*
1178  * open here document temp file.
1179  * if unquoted here, expand here temp file into second temp file.
1180  */
1181 static int
1182 herein(const char *content, int sub)
1183 {
1184         volatile int fd = -1;
1185         struct source *s, *volatile osource;
1186         struct shf *volatile shf;
1187         struct temp *h;
1188         int i;
1189
1190         /* ksh -c 'cat << EOF' can cause this... */
1191         if (content == NULL) {
1192                 warningf(true, "here document missing");
1193                 return -2; /* special to iosetup(): don't print error */
1194         }
1195
1196         /* Create temp file to hold content (done before newenv so temp
1197          * doesn't get removed too soon).
1198          */
1199         h = maketemp(ATEMP, TT_HEREDOC_EXP, &genv->temps);
1200         if (!(shf = h->shf) || (fd = open(h->name, O_RDONLY, 0)) < 0) {
1201                 warningf(true, "can't %s temporary file %s: %s",
1202                     !shf ? "create" : "open",
1203                     h->name, strerror(errno));
1204                 if (shf)
1205                         shf_close(shf);
1206                 return -2 /* special to iosetup(): don't print error */;
1207         }
1208
1209         osource = source;
1210         newenv(E_ERRH);
1211         i = sigsetjmp(genv->jbuf, 0);
1212         if (i) {
1213                 source = osource;
1214                 quitenv(shf);
1215                 close(fd);
1216                 return -2; /* special to iosetup(): don't print error */
1217         }
1218         if (sub) {
1219                 /* Do substitutions on the content of heredoc */
1220                 s = pushs(SSTRING, ATEMP);
1221                 s->start = s->str = content;
1222                 source = s;
1223                 if (yylex(ONEWORD|HEREDOC) != LWORD)
1224                         internal_errorf("%s: yylex", __func__);
1225                 source = osource;
1226                 shf_puts(evalstr(yylval.cp, 0), shf);
1227         } else
1228                 shf_puts(content, shf);
1229
1230         quitenv(NULL);
1231
1232         if (shf_close(shf) == EOF) {
1233                 close(fd);
1234                 warningf(true, "error writing %s: %s", h->name,
1235                     strerror(errno));
1236                 return -2; /* special to iosetup(): don't print error */
1237         }
1238
1239         return fd;
1240 }
1241
1242 /*
1243  *      ksh special - the select command processing section
1244  *      print the args in column form - assuming that we can
1245  */
1246 static char *
1247 do_selectargs(char **ap, bool print_menu)
1248 {
1249         static const char *const read_args[] = {
1250                 "read", "-r", "REPLY", NULL
1251         };
1252         const char *errstr;
1253         char *s;
1254         int i, argct;
1255
1256         for (argct = 0; ap[argct]; argct++)
1257                 ;
1258         while (1) {
1259                 /* Menu is printed if
1260                  *      - this is the first time around the select loop
1261                  *      - the user enters a blank line
1262                  *      - the REPLY parameter is empty
1263                  */
1264                 if (print_menu || !*str_val(global("REPLY")))
1265                         pr_menu(ap);
1266                 shellf("%s", str_val(global("PS3")));
1267                 if (call_builtin(findcom("read", FC_BI), (char **) read_args))
1268                         return NULL;
1269                 s = str_val(global("REPLY"));
1270                 if (*s) {
1271                         i = strtonum(s, 1, argct, &errstr);
1272                         if (errstr)
1273                                 return null;
1274                         return ap[i - 1];
1275                 }
1276                 print_menu = 1;
1277         }
1278 }
1279
1280 struct select_menu_info {
1281         char    *const *args;
1282         int     arg_width;
1283         int     num_width;
1284 };
1285
1286 static char *select_fmt_entry(void *arg, int i, char *buf, int buflen);
1287
1288 /* format a single select menu item */
1289 static char *
1290 select_fmt_entry(void *arg, int i, char *buf, int buflen)
1291 {
1292         struct select_menu_info *smi = (struct select_menu_info *) arg;
1293
1294         shf_snprintf(buf, buflen, "%*d) %s",
1295             smi->num_width, i + 1, smi->args[i]);
1296         return buf;
1297 }
1298
1299 /*
1300  *      print a select style menu
1301  */
1302 int
1303 pr_menu(char *const *ap)
1304 {
1305         struct select_menu_info smi;
1306         char *const *pp;
1307         int nwidth, dwidth;
1308         int i, n;
1309
1310         /* Width/column calculations were done once and saved, but this
1311          * means select can't be used recursively so we re-calculate each
1312          * time (could save in a structure that is returned, but its probably
1313          * not worth the bother).
1314          */
1315
1316         /*
1317          * get dimensions of the list
1318          */
1319         for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
1320                 i = strlen(*pp);
1321                 nwidth = (i > nwidth) ? i : nwidth;
1322         }
1323         /*
1324          * we will print an index of the form
1325          *      %d)
1326          * in front of each entry
1327          * get the max width of this
1328          */
1329         for (i = n, dwidth = 1; i >= 10; i /= 10)
1330                 dwidth++;
1331
1332         smi.args = ap;
1333         smi.arg_width = nwidth;
1334         smi.num_width = dwidth;
1335         print_columns(shl_out, n, select_fmt_entry, (void *) &smi,
1336             dwidth + nwidth + 2, 1);
1337
1338         return n;
1339 }
1340
1341 /* XXX: horrible kludge to fit within the framework */
1342
1343 static char *plain_fmt_entry(void *arg, int i, char *buf, int buflen);
1344
1345 static char *
1346 plain_fmt_entry(void *arg, int i, char *buf, int buflen)
1347 {
1348         shf_snprintf(buf, buflen, "%s", ((char *const *)arg)[i]);
1349         return buf;
1350 }
1351
1352 int
1353 pr_list(char *const *ap)
1354 {
1355         char *const *pp;
1356         int nwidth;
1357         int i, n;
1358
1359         for (n = 0, nwidth = 0, pp = ap; *pp; n++, pp++) {
1360                 i = strlen(*pp);
1361                 nwidth = (i > nwidth) ? i : nwidth;
1362         }
1363         print_columns(shl_out, n, plain_fmt_entry, (void *) ap, nwidth + 1, 0);
1364
1365         return n;
1366 }
1367
1368 /*
1369  *      [[ ... ]] evaluation routines
1370  */
1371
1372 extern const char *const dbtest_tokens[];
1373 extern const char db_close[];
1374
1375 /* Test if the current token is a whatever.  Accepts the current token if
1376  * it is.  Returns 0 if it is not, non-zero if it is (in the case of
1377  * TM_UNOP and TM_BINOP, the returned value is a Test_op).
1378  */
1379 static int
1380 dbteste_isa(Test_env *te, Test_meta meta)
1381 {
1382         int ret = 0;
1383         int uqword;
1384         char *p;
1385
1386         if (!*te->pos.wp)
1387                 return meta == TM_END;
1388
1389         /* unquoted word? */
1390         for (p = *te->pos.wp; *p == CHAR; p += 2)
1391                 ;
1392         uqword = *p == EOS;
1393
1394         if (meta == TM_UNOP || meta == TM_BINOP) {
1395                 if (uqword) {
1396                         char buf[8];    /* longer than the longest operator */
1397                         char *q = buf;
1398                         for (p = *te->pos.wp;
1399                             *p == CHAR && q < &buf[sizeof(buf) - 1]; p += 2)
1400                                 *q++ = p[1];
1401                         *q = '\0';
1402                         ret = (int) test_isop(te, meta, buf);
1403                 }
1404         } else if (meta == TM_END)
1405                 ret = 0;
1406         else
1407                 ret = uqword &&
1408                     strcmp(*te->pos.wp, dbtest_tokens[(int) meta]) == 0;
1409
1410         /* Accept the token? */
1411         if (ret)
1412                 te->pos.wp++;
1413
1414         return ret;
1415 }
1416
1417 static const char *
1418 dbteste_getopnd(Test_env *te, Test_op op, int do_eval)
1419 {
1420         char *s = *te->pos.wp;
1421
1422         if (!s)
1423                 return NULL;
1424
1425         te->pos.wp++;
1426
1427         if (!do_eval)
1428                 return null;
1429
1430         if (op == TO_STEQL || op == TO_STNEQ)
1431                 s = evalstr(s, DOTILDE | DOPAT);
1432         else
1433                 s = evalstr(s, DOTILDE);
1434
1435         return s;
1436 }
1437
1438 static int
1439 dbteste_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2,
1440     int do_eval)
1441 {
1442         return test_eval(te, op, opnd1, opnd2, do_eval);
1443 }
1444
1445 static void
1446 dbteste_error(Test_env *te, int offset, const char *msg)
1447 {
1448         te->flags |= TEF_ERROR;
1449         internal_warningf("%s: %s (offset %d)", __func__, msg, offset);
1450 }