src/ash/jobs.c

   1 /*      $NetBSD: jobs.c,v 1.63 2005/06/01 15:41:19 lukem Exp $  */
   2
   3 /*-
   4  * Copyright (c) 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Kenneth Almquist.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #ifdef HAVE_SYS_CDEFS_H
  36 #include <sys/cdefs.h>
  37 #else
  38 #define _PATH_DEVNULL "/dev/null"
  39 #endif
  40 #ifndef lint
  41 #if 0
  42 static char sccsid[] = "@(#)jobs.c      8.5 (Berkeley) 5/4/95";
  43 #else
  44 __RCSID("$NetBSD: jobs.c,v 1.63 2005/06/01 15:41:19 lukem Exp $");
  45 #endif
  46 #endif /* not lint */
  47
  48 #include <fcntl.h>
  49 #ifdef __sun__
  50 #define sys_siglist _sys_siglist
  51 #endif
  52 #include <signal.h>
  53 #include <errno.h>
  54 #include <unistd.h>
  55 #include <stdlib.h>
  56 #ifndef __sun__
  57 #include <paths.h>
  58 #endif
  59 #include <sys/types.h>
  60 #include <sys/param.h>
  61 #if defined(BSD) || defined(__sun__)
  62 #include <sys/wait.h>
  63 #include <sys/time.h>
  64 #include <sys/resource.h>
  65 #endif
  66 #include <sys/ioctl.h>
  67
  68 #include "shell.h"
  69 #if JOBS
  70 #if OLD_TTY_DRIVER
  71 #include "sgtty.h"
  72 #else
  73 #include <termios.h>
  74 #endif
  75 #undef CEOF                     /* syntax.h redefines this */
  76 #endif
  77 #include "redir.h"
  78 #include "show.h"
  79 #include "main.h"
  80 #include "parser.h"
  81 #include "nodes.h"
  82 #include "jobs.h"
  83 #include "options.h"
  84 #include "trap.h"
  85 #include "syntax.h"
  86 #include "input.h"
  87 #include "output.h"
  88 #include "memalloc.h"
  89 #include "error.h"
  90 #include "mystring.h"
  91
  92
  93 static struct job *jobtab;              /* array of jobs */
  94 static int njobs;                       /* size of array */
  95 static int jobs_invalid;                /* set in child */
  96 MKINIT pid_t backgndpid = -1;   /* pid of last background process */
  97 #if JOBS
  98 int initialpgrp;                /* pgrp of shell on invocation */
  99 static int curjob = -1;         /* current job */
 100 #endif
 101 static int ttyfd = -1;
 102
 103 STATIC void restartjob(struct job *);
 104 STATIC void freejob(struct job *);
 105 STATIC struct job *getjob(const char *, int);
 106 STATIC int dowait(int, struct job *);
 107 STATIC int onsigchild(void);
 108 STATIC int waitproc(int, struct job *, int *);
 109 STATIC void cmdtxt(union node *);
 110 STATIC void cmdlist(union node *, int);
 111 STATIC void cmdputs(const char *);
 112
 113 #ifdef OLD_TTY_DRIVER
 114 static pid_t tcgetpgrp(int fd);
 115 static int tcsetpgrp(int fd, pid_t pgrp);
 116
 117 static pid_t
 118 tcgetpgrp(int fd)
 119 {
 120         pid_t pgrp;
 121         if (ioctl(fd, TIOCGPGRP, (char *)&pgrp) == -1)
 122                 return -1;
 123         else
 124                 return pgrp;
 125 }
 126
 127 static int
 128 tcsetpgrp(int fd, pid_tpgrp)
 129 {
 130         return ioctl(fd, TIOCSPGRP, (char *)&pgrp);
 131 }
 132 #endif
 133
 134 /*
 135  * Turn job control on and off.
 136  *
 137  * Note:  This code assumes that the third arg to ioctl is a character
 138  * pointer, which is true on Berkeley systems but not System V.  Since
 139  * System V doesn't have job control yet, this isn't a problem now.
 140  */
 141
 142 MKINIT int jobctl;
 143
 144 void
 145 setjobctl(int on)
 146 {
 147 #ifdef OLD_TTY_DRIVER
 148         int ldisc;
 149 #endif
 150
 151         if (on == jobctl || rootshell == 0)
 152                 return;
 153         if (on) {
 154 #if defined(FIOCLEX) || defined(FD_CLOEXEC)
 155                 int err;
 156                 int i;
 157                 if (ttyfd != -1)
 158                         close(ttyfd);
 159                 if ((ttyfd = open("/dev/tty", O_RDWR)) == -1) {
 160                         for (i = 0; i < 3; i++) {
 161                                 if (isatty(i) && (ttyfd = dup(i)) != -1)
 162                                         break;
 163                         }
 164                         if (i == 3)
 165                                 goto out;
 166                 }
 167                 /* Move to a high fd */
 168                 for (i = 10; i > 2; i--) {
 169                         if ((err = fcntl(ttyfd, F_DUPFD, (1 << i) - 1)) != -1)
 170                                 break;
 171                 }
 172                 if (err != -1) {
 173                         close(ttyfd);
 174                         ttyfd = err;
 175                 }
 176 #ifdef FIOCLEX
 177                 err = ioctl(ttyfd, FIOCLEX, 0);
 178 #elif FD_CLOEXEC
 179                 err = fcntl(ttyfd, F_SETFD,
 180                     fcntl(ttyfd, F_GETFD, 0) | FD_CLOEXEC);
 181 #endif
 182                 if (err == -1) {
 183                         close(ttyfd);
 184                         ttyfd = -1;
 185                         goto out;
 186                 }
 187 #else
 188                 out2str("sh: Need FIOCLEX or FD_CLOEXEC to support job control");
 189                 goto out;
 190 #endif
 191                 do { /* while we are in the background */
 192                         if ((initialpgrp = tcgetpgrp(ttyfd)) < 0) {
 193 out:
 194                                 out2str("sh: can't access tty; job control turned off\n");
 195                                 mflag = 0;
 196                                 return;
 197                         }
 198                         if (initialpgrp == -1)
 199                                 initialpgrp = getpgrp();
 200                         else if (initialpgrp != getpgrp()) {
 201                                 killpg(0, SIGTTIN);
 202                                 continue;
 203                         }
 204                 } while (0);
 205
 206 #ifdef OLD_TTY_DRIVER
 207                 if (ioctl(ttyfd, TIOCGETD, (char *)&ldisc) < 0
 208                     || ldisc != NTTYDISC) {
 209                         out2str("sh: need new tty driver to run job control; job control turned off\n");
 210                         mflag = 0;
 211                         return;
 212                 }
 213 #endif
 214                 setsignal(SIGTSTP, 0);
 215                 setsignal(SIGTTOU, 0);
 216                 setsignal(SIGTTIN, 0);
 217                 if (getpgid(0) != rootpid && setpgid(0, rootpid) == -1)
 218                         error("Cannot set process group (%s) at %d",
 219                             strerror(errno), __LINE__);
 220                 if (tcsetpgrp(ttyfd, rootpid) == -1)
 221                         error("Cannot set tty process group (%s) at %d",
 222                             strerror(errno), __LINE__);
 223         } else { /* turning job control off */
 224                 if (getpgid(0) != initialpgrp && setpgid(0, initialpgrp) == -1)
 225                         error("Cannot set process group (%s) at %d",
 226                             strerror(errno), __LINE__);
 227                 if (tcsetpgrp(ttyfd, initialpgrp) == -1)
 228                         error("Cannot set tty process group (%s) at %d",
 229                             strerror(errno), __LINE__);
 230                 close(ttyfd);
 231                 ttyfd = -1;
 232                 setsignal(SIGTSTP, 0);
 233                 setsignal(SIGTTOU, 0);
 234                 setsignal(SIGTTIN, 0);
 235         }
 236         jobctl = on;
 237 }
 238
 239
 240 #ifdef mkinit
 241 INCLUDE <stdlib.h>
 242
 243 SHELLPROC {
 244         backgndpid = -1;
 245 #if JOBS
 246         jobctl = 0;
 247 #endif
 248 }
 249
 250 #endif
 251
 252
 253
 254 #if JOBS
 255 int
 256 fgcmd(int argc, char **argv)
 257 {
 258         struct job *jp;
 259         int i;
 260         int status;
 261
 262         nextopt("");
 263         jp = getjob(*argptr, 0);
 264         if (jp->jobctl == 0)
 265                 error("job not created under job control");
 266         out1fmt("%s", jp->ps[0].cmd);
 267         for (i = 1; i < jp->nprocs; i++)
 268                 out1fmt(" | %s", jp->ps[i].cmd );
 269         out1c('\n');
 270         output_flushall();
 271
 272         for (i = 0; i < jp->nprocs; i++)
 273             if (tcsetpgrp(ttyfd, jp->ps[i].pid) != -1)
 274                     break;
 275
 276         if (i >= jp->nprocs) {
 277                 error("Cannot set tty process group (%s) at %d",
 278                     strerror(errno), __LINE__);
 279         }
 280         restartjob(jp);
 281         INTOFF;
 282         status = waitforjob(jp);
 283         INTON;
 284         return status;
 285 }
 286
 287 static void
 288 set_curjob(struct job *jp, int mode)
 289 {
 290         struct job *jp1, *jp2;
 291         int i, ji;
 292
 293         ji = jp - jobtab;
 294
 295         /* first remove from list */
 296         if (ji == curjob)
 297                 curjob = jp->prev_job;
 298         else {
 299                 for (i = 0; i < njobs; i++) {
 300                         if (jobtab[i].prev_job != ji)
 301                                 continue;
 302                         jobtab[i].prev_job = jp->prev_job;
 303                         break;
 304                 }
 305         }
 306
 307         /* Then re-insert in correct position */
 308         switch (mode) {
 309         case 0: /* job being deleted */
 310                 jp->prev_job = -1;
 311                 break;
 312         case 1: /* newly created job or backgrounded job,
 313                    put after all stopped jobs. */
 314                 if (curjob != -1 && jobtab[curjob].state == JOBSTOPPED) {
 315                         for (jp1 = jobtab + curjob; ; jp1 = jp2) {
 316                                 if (jp1->prev_job == -1)
 317                                         break;
 318                                 jp2 = jobtab + jp1->prev_job;
 319                                 if (jp2->state != JOBSTOPPED)
 320                                         break;
 321                         }
 322                         jp->prev_job = jp1->prev_job;
 323                         jp1->prev_job = ji;
 324                         break;
 325                 }
 326                 /* FALLTHROUGH */
 327         case 2: /* newly stopped job - becomes curjob */
 328                 jp->prev_job = curjob;
 329                 curjob = ji;
 330                 break;
 331         }
 332 }
 333
 334 int
 335 bgcmd(int argc, char **argv)
 336 {
 337         struct job *jp;
 338         int i;
 339
 340         nextopt("");
 341         do {
 342                 jp = getjob(*argptr, 0);
 343                 if (jp->jobctl == 0)
 344                         error("job not created under job control");
 345                 set_curjob(jp, 1);
 346                 out1fmt("[%ld] %s", (long)(jp - jobtab + 1), jp->ps[0].cmd);
 347                 for (i = 1; i < jp->nprocs; i++)
 348                         out1fmt(" | %s", jp->ps[i].cmd );
 349                 out1c('\n');
 350                 output_flushall();
 351                 restartjob(jp);
 352         } while (*argptr && *++argptr);
 353         return 0;
 354 }
 355
 356
 357 STATIC void
 358 restartjob(struct job *jp)
 359 {
 360         struct procstat *ps;
 361         int i;
 362
 363         if (jp->state == JOBDONE)
 364                 return;
 365         INTOFF;
 366         for (i = 0; i < jp->nprocs; i++)
 367                 if (killpg(jp->ps[i].pid, SIGCONT) != -1)
 368                         break;
 369         if (i >= jp->nprocs)
 370                 error("Cannot continue job (%s)", strerror(errno));
 371         for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
 372                 if (WIFSTOPPED(ps->status)) {
 373                         ps->status = -1;
 374                         jp->state = JOBRUNNING;
 375                 }
 376         }
 377         INTON;
 378 }
 379 #endif
 380
 381 static void
 382 showjob(struct output *out, struct job *jp, int mode)
 383 {
 384         int procno;
 385         int st;
 386         struct procstat *ps;
 387         int col;
 388         char s[64];
 389
 390 #if JOBS
 391         if (mode & SHOW_PGID) {
 392                 /* just output process (group) id of pipeline */
 393                 outfmt(out, "%ld\n", (long)jp->ps->pid);
 394                 return;
 395         }
 396 #endif
 397
 398         procno = jp->nprocs;
 399         if (!procno)
 400                 return;
 401
 402         if (mode & SHOW_PID)
 403                 mode |= SHOW_MULTILINE;
 404
 405         if ((procno > 1 && !(mode & SHOW_MULTILINE))
 406             || (mode & SHOW_SIGNALLED)) {
 407                 /* See if we have more than one status to report */
 408                 ps = jp->ps;
 409                 st = ps->status;
 410                 do {
 411                         int st1 = ps->status;
 412                         if (st1 != st)
 413                                 /* yes - need multi-line output */
 414                                 mode |= SHOW_MULTILINE;
 415                         if (st1 == -1 || !(mode & SHOW_SIGNALLED) || WIFEXITED(st1))
 416                                 continue;
 417                         if (WIFSTOPPED(st1) || ((st1 = WTERMSIG(st1) & 0x7f)
 418                             && st1 != SIGINT && st1 != SIGPIPE))
 419                                 mode |= SHOW_ISSIG;
 420
 421                 } while (ps++, --procno);
 422                 procno = jp->nprocs;
 423         }
 424
 425         if (mode & SHOW_SIGNALLED && !(mode & SHOW_ISSIG)) {
 426                 if (jp->state == JOBDONE && !(mode & SHOW_NO_FREE)) {
 427                         TRACE(("showjob: freeing job %d\n", jp - jobtab + 1));
 428                         freejob(jp);
 429                 }
 430                 return;
 431         }
 432
 433         for (ps = jp->ps; --procno >= 0; ps++) {        /* for each process */
 434                 if (ps == jp->ps)
 435                         fmtstr(s, 16, "[%ld] %c ",
 436                                 (long)(jp - jobtab + 1),
 437 #if JOBS
 438                                 jp == jobtab + curjob ? '+' :
 439                                 curjob != -1 && jp == jobtab +
 440                                             jobtab[curjob].prev_job ? '-' :
 441 #endif
 442                                 ' ');
 443                 else
 444                         fmtstr(s, 16, "      " );
 445                 col = strlen(s);
 446                 if (mode & SHOW_PID) {
 447                         fmtstr(s + col, 16, "%ld ", (long)ps->pid);
 448                              col += strlen(s + col);
 449                 }
 450                 if (ps->status == -1) {
 451                         scopy("Running", s + col);
 452                 } else if (WIFEXITED(ps->status)) {
 453                         st = WEXITSTATUS(ps->status);
 454                         if (st)
 455                                 fmtstr(s + col, 16, "Done(%d)", st);
 456                         else
 457                                 fmtstr(s + col, 16, "Done");
 458                 } else {
 459 #if JOBS
 460                         if (WIFSTOPPED(ps->status))
 461                                 st = WSTOPSIG(ps->status);
 462                         else /* WIFSIGNALED(ps->status) */
 463 #endif
 464                                 st = WTERMSIG(ps->status);
 465                         st &= 0x7f;
 466                         if (st < NSIG && sys_siglist[st])
 467                                 scopyn(sys_siglist[st], s + col, 32);
 468                         else
 469                                 fmtstr(s + col, 16, "Signal %d", st);
 470                         if (WCOREDUMP(ps->status)) {
 471                                 col += strlen(s + col);
 472                                 scopyn(" (core dumped)", s + col,  64 - col);
 473                         }
 474                 }
 475                 col += strlen(s + col);
 476                 outstr(s, out);
 477                 do {
 478                         outc(' ', out);
 479                         col++;
 480                 } while (col < 30);
 481                 outstr(ps->cmd, out);
 482                 if (mode & SHOW_MULTILINE) {
 483                         if (procno > 0) {
 484                                 outc(' ', out);
 485                                 outc('|', out);
 486                         }
 487                 } else {
 488                         while (--procno >= 0)
 489                                 outfmt(out, " | %s", (++ps)->cmd );
 490                 }
 491                 outc('\n', out);
 492         }
 493         flushout(out);
 494         jp->changed = 0;
 495         if (jp->state == JOBDONE && !(mode & SHOW_NO_FREE))
 496                 freejob(jp);
 497 }
 498
 499
 500 int
 501 jobscmd(int argc, char **argv)
 502 {
 503         int mode, m;
 504         int sv = jobs_invalid;
 505
 506         jobs_invalid = 0;
 507         mode = 0;
 508         while ((m = nextopt("lp")))
 509                 if (m == 'l')
 510                         mode = SHOW_PID;
 511                 else
 512                         mode = SHOW_PGID;
 513         if (*argptr)
 514                 do
 515                         showjob(out1, getjob(*argptr,0), mode);
 516                 while (*++argptr);
 517         else
 518                 showjobs(out1, mode);
 519         jobs_invalid = sv;
 520         return 0;
 521 }
 522
 523
 524 /*
 525  * Print a list of jobs.  If "change" is nonzero, only print jobs whose
 526  * statuses have changed since the last call to showjobs.
 527  *
 528  * If the shell is interrupted in the process of creating a job, the
 529  * result may be a job structure containing zero processes.  Such structures
 530  * will be freed here.
 531  */
 532
 533 void
 534 showjobs(struct output *out, int mode)
 535 {
 536         int jobno;
 537         struct job *jp;
 538         int silent = 0, gotpid;
 539
 540         TRACE(("showjobs(%x) called\n", mode));
 541
 542         /* If not even one one job changed, there is nothing to do */
 543         gotpid = dowait(0, NULL);
 544         while (dowait(0, NULL) > 0)
 545                 continue;
 546 #ifdef JOBS
 547         /*
 548          * Check if we are not in our foreground group, and if not
 549          * put us in it.
 550          */
 551         if (mflag && gotpid != -1 && tcgetpgrp(ttyfd) != getpid()) {
 552                 if (tcsetpgrp(ttyfd, getpid()) == -1)
 553                         error("Cannot set tty process group (%s) at %d",
 554                             strerror(errno), __LINE__);
 555                 TRACE(("repaired tty process group\n"));
 556                 silent = 1;
 557         }
 558 #endif
 559         if (jobs_invalid)
 560                 return;
 561
 562         for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
 563                 if (!jp->used)
 564                         continue;
 565                 if (jp->nprocs == 0) {
 566                         freejob(jp);
 567                         continue;
 568                 }
 569                 if ((mode & SHOW_CHANGED) && !jp->changed)
 570                         continue;
 571                 if (silent && jp->changed) {
 572                         jp->changed = 0;
 573                         continue;
 574                 }
 575                 showjob(out, jp, mode);
 576         }
 577 }
 578
 579 /*
 580  * Mark a job structure as unused.
 581  */
 582
 583 STATIC void
 584 freejob(struct job *jp)
 585 {
 586         INTOFF;
 587         if (jp->ps != &jp->ps0) {
 588                 ckfree(jp->ps);
 589                 jp->ps = &jp->ps0;
 590         }
 591         jp->nprocs = 0;
 592         jp->used = 0;
 593 #if JOBS
 594         set_curjob(jp, 0);
 595 #endif
 596         INTON;
 597 }
 598
 599
 600
 601 int
 602 waitcmd(int argc, char **argv)
 603 {
 604         struct job *job;
 605         int status, retval;
 606         struct job *jp;
 607
 608         nextopt("");
 609
 610         if (!*argptr) {
 611                 /* wait for all jobs */
 612                 jp = jobtab;
 613                 if (jobs_invalid)
 614                         return 0;
 615                 for (;;) {
 616                         if (jp >= jobtab + njobs) {
 617                                 /* no running procs */
 618                                 return 0;
 619                         }
 620                         if (!jp->used || jp->state != JOBRUNNING) {
 621                                 jp++;
 622                                 continue;
 623                         }
 624                         if (dowait(1, (struct job *)NULL) == -1)
 625                                return 128 + SIGINT;
 626                         jp = jobtab;
 627                 }
 628         }
 629
 630         retval = 127;           /* XXXGCC: -Wuninitialized */
 631         for (; *argptr; argptr++) {
 632                 job = getjob(*argptr, 1);
 633                 if (!job) {
 634                         retval = 127;
 635                         continue;
 636                 }
 637                 /* loop until process terminated or stopped */
 638                 while (job->state == JOBRUNNING) {
 639                         if (dowait(1, (struct job *)NULL) == -1)
 640                                return 128 + SIGINT;
 641                 }
 642                 status = job->ps[job->nprocs].status;
 643                 if (WIFEXITED(status))
 644                         retval = WEXITSTATUS(status);
 645 #if JOBS
 646                 else if (WIFSTOPPED(status))
 647                         retval = WSTOPSIG(status) + 128;
 648 #endif
 649                 else {
 650                         /* XXX: limits number of signals */
 651                         retval = WTERMSIG(status) + 128;
 652                 }
 653                 if (!iflag)
 654                         freejob(job);
 655         }
 656         return retval;
 657 }
 658
 659
 660
 661 int
 662 jobidcmd(int argc, char **argv)
 663 {
 664         struct job *jp;
 665         int i;
 666
 667         nextopt("");
 668         jp = getjob(*argptr, 0);
 669         for (i = 0 ; i < jp->nprocs ; ) {
 670                 out1fmt("%ld", (long)jp->ps[i].pid);
 671                 out1c(++i < jp->nprocs ? ' ' : '\n');
 672         }
 673         return 0;
 674 }
 675
 676 int
 677 getjobpgrp(const char *name)
 678 {
 679         struct job *jp;
 680
 681         jp = getjob(name, 1);
 682         if (jp == 0)
 683                 return 0;
 684         return -jp->ps[0].pid;
 685 }
 686
 687 /*
 688  * Convert a job name to a job structure.
 689  */
 690
 691 STATIC struct job *
 692 getjob(const char *name, int noerror)
 693 {
 694         int jobno = -1;
 695         struct job *jp;
 696         int pid;
 697         int i;
 698         const char *err_msg = "No such job: %s";
 699
 700         if (name == NULL) {
 701 #if JOBS
 702                 jobno = curjob;
 703 #endif
 704                 err_msg = "No current job";
 705         } else if (name[0] == '%') {
 706                 if (is_number(name + 1)) {
 707                         jobno = number(name + 1) - 1;
 708                 } else if (!name[2]) {
 709                         switch (name[1]) {
 710 #if JOBS
 711                         case 0:
 712                         case '+':
 713                         case '%':
 714                                 jobno = curjob;
 715                                 err_msg = "No current job";
 716                                 break;
 717                         case '-':
 718                                 jobno = curjob;
 719                                 if (jobno != -1)
 720                                         jobno = jobtab[jobno].prev_job;
 721                                 err_msg = "No previous job";
 722                                 break;
 723 #endif
 724                         default:
 725                                 goto check_pattern;
 726                         }
 727                 } else {
 728                         struct job *found;
 729     check_pattern:
 730                         found = NULL;
 731                         for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
 732                                 if (!jp->used || jp->nprocs <= 0)
 733                                         continue;
 734                                 if ((name[1] == '?'
 735                                         && strstr(jp->ps[0].cmd, name + 2))
 736                                     || prefix(name + 1, jp->ps[0].cmd)) {
 737                                         if (found) {
 738                                                 err_msg = "%s: ambiguous";
 739                                                 found = 0;
 740                                                 break;
 741                                         }
 742                                         found = jp;
 743                                 }
 744                         }
 745                         if (found)
 746                                 return found;
 747                 }
 748
 749         } else if (is_number(name)) {
 750                 pid = number(name);
 751                 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
 752                         if (jp->used && jp->nprocs > 0
 753                          && jp->ps[jp->nprocs - 1].pid == pid)
 754                                 return jp;
 755                 }
 756         }
 757
 758         if (!jobs_invalid && jobno >= 0 && jobno < njobs) {
 759                 jp = jobtab + jobno;
 760                 if (jp->used)
 761                         return jp;
 762         }
 763         if (!noerror)
 764                 error(err_msg, name);
 765         return 0;
 766 }
 767
 768
 769
 770 /*
 771  * Return a new job structure,
 772  */
 773
 774 struct job *
 775 makejob(union node *node, int nprocs)
 776 {
 777         int i;
 778         struct job *jp;
 779
 780         if (jobs_invalid) {
 781                 for (i = njobs, jp = jobtab ; --i >= 0 ; jp++) {
 782                         if (jp->used)
 783                                 freejob(jp);
 784                 }
 785                 jobs_invalid = 0;
 786         }
 787
 788         for (i = njobs, jp = jobtab ; ; jp++) {
 789                 if (--i < 0) {
 790                         INTOFF;
 791                         if (njobs == 0) {
 792                                 jobtab = ckmalloc(4 * sizeof jobtab[0]);
 793                         } else {
 794                                 jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
 795                                 memcpy(jp, jobtab, njobs * sizeof jp[0]);
 796                                 /* Relocate `ps' pointers */
 797                                 for (i = 0; i < njobs; i++)
 798                                         if (jp[i].ps == &jobtab[i].ps0)
 799                                                 jp[i].ps = &jp[i].ps0;
 800                                 ckfree(jobtab);
 801                                 jobtab = jp;
 802                         }
 803                         jp = jobtab + njobs;
 804                         for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
 805                         INTON;
 806                         break;
 807                 }
 808                 if (jp->used == 0)
 809                         break;
 810         }
 811         INTOFF;
 812         jp->state = JOBRUNNING;
 813         jp->used = 1;
 814         jp->changed = 0;
 815         jp->nprocs = 0;
 816 #if JOBS
 817         jp->jobctl = jobctl;
 818         set_curjob(jp, 1);
 819 #endif
 820         if (nprocs > 1) {
 821                 jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
 822         } else {
 823                 jp->ps = &jp->ps0;
 824         }
 825         INTON;
 826         TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
 827             jp - jobtab + 1));
 828         return jp;
 829 }
 830
 831
 832 /*
 833  * Fork off a subshell.  If we are doing job control, give the subshell its
 834  * own process group.  Jp is a job structure that the job is to be added to.
 835  * N is the command that will be evaluated by the child.  Both jp and n may
 836  * be NULL.  The mode parameter can be one of the following:
 837  *      FORK_FG - Fork off a foreground process.
 838  *      FORK_BG - Fork off a background process.
 839  *      FORK_NOJOB - Like FORK_FG, but don't give the process its own
 840  *                   process group even if job control is on.
 841  *
 842  * When job control is turned off, background processes have their standard
 843  * input redirected to /dev/null (except for the second and later processes
 844  * in a pipeline).
 845  */
 846
 847 int
 848 forkshell(struct job *jp, union node *n, int mode)
 849 {
 850         int pid;
 851
 852         TRACE(("forkshell(%%%d, %p, %d) called\n", jp - jobtab, n, mode));
 853         switch ((pid = fork())) {
 854         case -1:
 855                 TRACE(("Fork failed, errno=%d\n", errno));
 856                 INTON;
 857                 error("Cannot fork");
 858                 break;
 859         case 0:
 860                 forkchild(jp, n, mode, 0);
 861                 return 0;
 862         default:
 863                 return forkparent(jp, n, mode, pid);
 864         }
 865 }
 866
 867 int
 868 forkparent(struct job *jp, union node *n, int mode, pid_t pid)
 869 {
 870         int pgrp;
 871
 872         if (rootshell && mode != FORK_NOJOB && mflag) {
 873                 if (jp == NULL || jp->nprocs == 0)
 874                         pgrp = pid;
 875                 else
 876                         pgrp = jp->ps[0].pid;
 877                 /* This can fail because we are doing it in the child also */
 878                 (void)setpgid(pid, pgrp);
 879         }
 880         if (mode == FORK_BG)
 881                 backgndpid = pid;               /* set $! */
 882         if (jp) {
 883                 struct procstat *ps = &jp->ps[jp->nprocs++];
 884                 ps->pid = pid;
 885                 ps->status = -1;
 886                 ps->cmd[0] = 0;
 887                 if (/* iflag && rootshell && */ n)
 888                         commandtext(ps, n);
 889         }
 890         TRACE(("In parent shell:  child = %d\n", pid));
 891         return pid;
 892 }
 893
 894 void
 895 forkchild(struct job *jp, union node *n, int mode, int vforked)
 896 {
 897         int wasroot;
 898         int pgrp;
 899         const char *devnull = _PATH_DEVNULL;
 900         const char *nullerr = "Can't open %s";
 901
 902         wasroot = rootshell;
 903         TRACE(("Child shell %d\n", getpid()));
 904         if (!vforked)
 905                 rootshell = 0;
 906
 907         closescript(vforked);
 908         clear_traps(vforked);
 909 #if JOBS
 910         if (!vforked)
 911                 jobctl = 0;             /* do job control only in root shell */
 912         if (wasroot && mode != FORK_NOJOB && mflag) {
 913                 if (jp == NULL || jp->nprocs == 0)
 914                         pgrp = getpid();
 915                 else
 916                         pgrp = jp->ps[0].pid;
 917                 /* This can fail because we are doing it in the parent also */
 918                 (void)setpgid(0, pgrp);
 919                 if (mode == FORK_FG) {
 920                         if (tcsetpgrp(ttyfd, pgrp) == -1)
 921                                 error("Cannot set tty process group (%s) at %d",
 922                                     strerror(errno), __LINE__);
 923                 }
 924                 setsignal(SIGTSTP, vforked);
 925                 setsignal(SIGTTOU, vforked);
 926         } else if (mode == FORK_BG) {
 927                 ignoresig(SIGINT, vforked);
 928                 ignoresig(SIGQUIT, vforked);
 929                 if ((jp == NULL || jp->nprocs == 0) &&
 930                     ! fd0_redirected_p ()) {
 931                         close(0);
 932                         if (open(devnull, O_RDONLY) != 0)
 933                                 error(nullerr, devnull);
 934                 }
 935         }
 936 #else
 937         if (mode == FORK_BG) {
 938                 ignoresig(SIGINT, vforked);
 939                 ignoresig(SIGQUIT, vforked);
 940                 if ((jp == NULL || jp->nprocs == 0) &&
 941                     ! fd0_redirected_p ()) {
 942                         close(0);
 943                         if (open(devnull, O_RDONLY) != 0)
 944                                 error(nullerr, devnull);
 945                 }
 946         }
 947 #endif
 948         if (wasroot && iflag) {
 949                 setsignal(SIGINT, vforked);
 950                 setsignal(SIGQUIT, vforked);
 951                 setsignal(SIGTERM, vforked);
 952         }
 953
 954         if (!vforked)
 955                 jobs_invalid = 1;
 956 }
 957
 958 /*
 959  * Wait for job to finish.
 960  *
 961  * Under job control we have the problem that while a child process is
 962  * running interrupts generated by the user are sent to the child but not
 963  * to the shell.  This means that an infinite loop started by an inter-
 964  * active user may be hard to kill.  With job control turned off, an
 965  * interactive user may place an interactive program inside a loop.  If
 966  * the interactive program catches interrupts, the user doesn't want
 967  * these interrupts to also abort the loop.  The approach we take here
 968  * is to have the shell ignore interrupt signals while waiting for a
 969  * forground process to terminate, and then send itself an interrupt
 970  * signal if the child process was terminated by an interrupt signal.
 971  * Unfortunately, some programs want to do a bit of cleanup and then
 972  * exit on interrupt; unless these processes terminate themselves by
 973  * sending a signal to themselves (instead of calling exit) they will
 974  * confuse this approach.
 975  */
 976
 977 int
 978 waitforjob(struct job *jp)
 979 {
 980 #if JOBS
 981         int mypgrp = getpgrp();
 982 #endif
 983         int status;
 984         int st;
 985
 986         INTOFF;
 987         TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
 988         while (jp->state == JOBRUNNING) {
 989                 dowait(1, jp);
 990         }
 991 #if JOBS
 992         if (jp->jobctl) {
 993                 if (tcsetpgrp(ttyfd, mypgrp) == -1)
 994                         error("Cannot set tty process group (%s) at %d",
 995                             strerror(errno), __LINE__);
 996         }
 997         if (jp->state == JOBSTOPPED && curjob != jp - jobtab)
 998                 set_curjob(jp, 2);
 999 #endif
1000         status = jp->ps[jp->nprocs - 1].status;
1001         /* convert to 8 bits */
1002         if (WIFEXITED(status))
1003                 st = WEXITSTATUS(status);
1004 #if JOBS
1005         else if (WIFSTOPPED(status))
1006                 st = WSTOPSIG(status) + 128;
1007 #endif
1008         else
1009                 st = WTERMSIG(status) + 128;
1010         TRACE(("waitforjob: job %d, nproc %d, status %x, st %x\n",
1011                 jp - jobtab + 1, jp->nprocs, status, st ));
1012 #if JOBS
1013         if (jp->jobctl) {
1014                 /*
1015                  * This is truly gross.
1016                  * If we're doing job control, then we did a TIOCSPGRP which
1017                  * caused us (the shell) to no longer be in the controlling
1018                  * session -- so we wouldn't have seen any ^C/SIGINT.  So, we
1019                  * intuit from the subprocess exit status whether a SIGINT
1020                  * occurred, and if so interrupt ourselves.  Yuck.  - mycroft
1021                  */
1022                 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
1023                         raise(SIGINT);
1024         }
1025 #endif
1026         if (! JOBS || jp->state == JOBDONE)
1027                 freejob(jp);
1028         INTON;
1029         return st;
1030 }
1031
1032
1033
1034 /*
1035  * Wait for a process to terminate.
1036  */
1037
1038 STATIC int
1039 dowait(int block, struct job *job)
1040 {
1041         int pid;
1042         int status;
1043         struct procstat *sp;
1044         struct job *jp;
1045         struct job *thisjob;
1046         int done;
1047         int stopped;
1048         extern volatile char gotsig[];
1049
1050         TRACE(("dowait(%d) called\n", block));
1051         do {
1052                 pid = waitproc(block, job, &status);
1053                 TRACE(("wait returns pid %d, status %d\n", pid, status));
1054         } while (pid == -1 && errno == EINTR && gotsig[SIGINT - 1] == 0);
1055         if (pid <= 0)
1056                 return pid;
1057         INTOFF;
1058         thisjob = NULL;
1059         for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
1060                 if (jp->used) {
1061                         done = 1;
1062                         stopped = 1;
1063                         for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
1064                                 if (sp->pid == -1)
1065                                         continue;
1066                                 if (sp->pid == pid) {
1067                                         TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n", jp - jobtab + 1, pid, sp->status, status));
1068                                         sp->status = status;
1069                                         thisjob = jp;
1070                                 }
1071                                 if (sp->status == -1)
1072                                         stopped = 0;
1073                                 else if (WIFSTOPPED(sp->status))
1074                                         done = 0;
1075                         }
1076                         if (stopped) {          /* stopped or done */
1077                                 int state = done ? JOBDONE : JOBSTOPPED;
1078                                 if (jp->state != state) {
1079                                         TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
1080                                         jp->state = state;
1081 #if JOBS
1082                                         if (done)
1083                                                 set_curjob(jp, 0);
1084 #endif
1085                                 }
1086                         }
1087                 }
1088         }
1089
1090         if (thisjob && thisjob->state != JOBRUNNING) {
1091                 int mode = 0;
1092                 if (!rootshell || !iflag)
1093                         mode = SHOW_SIGNALLED;
1094                 if (job == thisjob)
1095                         mode = SHOW_SIGNALLED | SHOW_NO_FREE;
1096                 if (mode)
1097                         showjob(out2, thisjob, mode);
1098                 else {
1099                         TRACE(("Not printing status, rootshell=%d, job=%p\n",
1100                                 rootshell, job));
1101                         thisjob->changed = 1;
1102                 }
1103         }
1104
1105         INTON;
1106         return pid;
1107 }
1108
1109
1110
1111 /*
1112  * Do a wait system call.  If job control is compiled in, we accept
1113  * stopped processes.  If block is zero, we return a value of zero
1114  * rather than blocking.
1115  *
1116  * System V doesn't have a non-blocking wait system call.  It does
1117  * have a SIGCLD signal that is sent to a process when one of it's
1118  * children dies.  The obvious way to use SIGCLD would be to install
1119  * a handler for SIGCLD which simply bumped a counter when a SIGCLD
1120  * was received, and have waitproc bump another counter when it got
1121  * the status of a process.  Waitproc would then know that a wait
1122  * system call would not block if the two counters were different.
1123  * This approach doesn't work because if a process has children that
1124  * have not been waited for, System V will send it a SIGCLD when it
1125  * installs a signal handler for SIGCLD.  What this means is that when
1126  * a child exits, the shell will be sent SIGCLD signals continuously
1127  * until is runs out of stack space, unless it does a wait call before
1128  * restoring the signal handler.  The code below takes advantage of
1129  * this (mis)feature by installing a signal handler for SIGCLD and
1130  * then checking to see whether it was called.  If there are any
1131  * children to be waited for, it will be.
1132  *
1133  * If neither SYSV nor BSD is defined, we don't implement nonblocking
1134  * waits at all.  In this case, the user will not be informed when
1135  * a background process until the next time she runs a real program
1136  * (as opposed to running a builtin command or just typing return),
1137  * and the jobs command may give out of date information.
1138  */
1139
1140 #ifdef SYSV
1141 STATIC int gotsigchild;
1142
1143 STATIC int onsigchild() {
1144         gotsigchild = 1;
1145 }
1146 #endif
1147
1148
1149 STATIC int
1150 waitproc(int block, struct job *jp, int *status)
1151 {
1152 #ifdef BSD
1153         int flags = 0;
1154
1155 #if JOBS
1156         if (jp != NULL && jp->jobctl)
1157                 flags |= WUNTRACED;
1158 #endif
1159         if (block == 0)
1160                 flags |= WNOHANG;
1161         return wait3(status, flags, (struct rusage *)NULL);
1162 #else
1163 #ifdef SYSV
1164         int (*save)();
1165
1166         if (block == 0) {
1167                 gotsigchild = 0;
1168                 save = signal(SIGCLD, onsigchild);
1169                 signal(SIGCLD, save);
1170                 if (gotsigchild == 0)
1171                         return 0;
1172         }
1173         return wait(status);
1174 #else
1175         if (block == 0)
1176                 return 0;
1177         return wait(status);
1178 #endif
1179 #endif
1180 }
1181
1182 /*
1183  * return 1 if there are stopped jobs, otherwise 0
1184  */
1185 int job_warning = 0;
1186 int
1187 stoppedjobs(void)
1188 {
1189         int jobno;
1190         struct job *jp;
1191
1192         if (job_warning || jobs_invalid)
1193                 return (0);
1194         for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
1195                 if (jp->used == 0)
1196                         continue;
1197                 if (jp->state == JOBSTOPPED) {
1198                         out2str("You have stopped jobs.\n");
1199                         job_warning = 2;
1200                         return (1);
1201                 }
1202         }
1203
1204         return (0);
1205 }
1206
1207 /*
1208  * Return a string identifying a command (to be printed by the
1209  * jobs command).
1210  */
1211
1212 STATIC char *cmdnextc;
1213 STATIC int cmdnleft;
1214
1215 void
1216 commandtext(struct procstat *ps, union node *n)
1217 {
1218         int len;
1219
1220         cmdnextc = ps->cmd;
1221         if (iflag || mflag || sizeof ps->cmd < 100)
1222                 len = sizeof(ps->cmd);
1223         else
1224                 len = sizeof(ps->cmd) / 10;
1225         cmdnleft = len;
1226         cmdtxt(n);
1227         if (cmdnleft <= 0) {
1228                 char *p = ps->cmd + len - 4;
1229                 p[0] = '.';
1230                 p[1] = '.';
1231                 p[2] = '.';
1232                 p[3] = 0;
1233         } else
1234                 *cmdnextc = '\0';
1235         TRACE(("commandtext: ps->cmd %x, end %x, left %d\n\t\"%s\"\n",
1236                 ps->cmd, cmdnextc, cmdnleft, ps->cmd));
1237 }
1238
1239
1240 STATIC void
1241 cmdtxt(union node *n)
1242 {
1243         union node *np;
1244         struct nodelist *lp;
1245         const char *p;
1246         int i;
1247         char s[2];
1248
1249         if (n == NULL || cmdnleft <= 0)
1250                 return;
1251         switch (n->type) {
1252         case NSEMI:
1253                 cmdtxt(n->nbinary.ch1);
1254                 cmdputs("; ");
1255                 cmdtxt(n->nbinary.ch2);
1256                 break;
1257         case NAND:
1258                 cmdtxt(n->nbinary.ch1);
1259                 cmdputs(" && ");
1260                 cmdtxt(n->nbinary.ch2);
1261                 break;
1262         case NOR:
1263                 cmdtxt(n->nbinary.ch1);
1264                 cmdputs(" || ");
1265                 cmdtxt(n->nbinary.ch2);
1266                 break;
1267         case NPIPE:
1268                 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
1269                         cmdtxt(lp->n);
1270                         if (lp->next)
1271                                 cmdputs(" | ");
1272                 }
1273                 break;
1274         case NSUBSHELL:
1275                 cmdputs("(");
1276                 cmdtxt(n->nredir.n);
1277                 cmdputs(")");
1278                 break;
1279         case NREDIR:
1280         case NBACKGND:
1281                 cmdtxt(n->nredir.n);
1282                 break;
1283         case NIF:
1284                 cmdputs("if ");
1285                 cmdtxt(n->nif.test);
1286                 cmdputs("; then ");
1287                 cmdtxt(n->nif.ifpart);
1288                 if (n->nif.elsepart) {
1289                         cmdputs("; else ");
1290                         cmdtxt(n->nif.elsepart);
1291                 }
1292                 cmdputs("; fi");
1293                 break;
1294         case NWHILE:
1295                 cmdputs("while ");
1296                 goto until;
1297         case NUNTIL:
1298                 cmdputs("until ");
1299 until:
1300                 cmdtxt(n->nbinary.ch1);
1301                 cmdputs("; do ");
1302                 cmdtxt(n->nbinary.ch2);
1303                 cmdputs("; done");
1304                 break;
1305         case NFOR:
1306                 cmdputs("for ");
1307                 cmdputs(n->nfor.var);
1308                 cmdputs(" in ");
1309                 cmdlist(n->nfor.args, 1);
1310                 cmdputs("; do ");
1311                 cmdtxt(n->nfor.body);
1312                 cmdputs("; done");
1313                 break;
1314         case NCASE:
1315                 cmdputs("case ");
1316                 cmdputs(n->ncase.expr->narg.text);
1317                 cmdputs(" in ");
1318                 for (np = n->ncase.cases; np; np = np->nclist.next) {
1319                         cmdtxt(np->nclist.pattern);
1320                         cmdputs(") ");
1321                         cmdtxt(np->nclist.body);
1322                         cmdputs(";; ");
1323                 }
1324                 cmdputs("esac");
1325                 break;
1326         case NDEFUN:
1327                 cmdputs(n->narg.text);
1328                 cmdputs("() { ... }");
1329                 break;
1330         case NCMD:
1331                 cmdlist(n->ncmd.args, 1);
1332                 cmdlist(n->ncmd.redirect, 0);
1333                 break;
1334         case NARG:
1335                 cmdputs(n->narg.text);
1336                 break;
1337         case NTO:
1338                 p = ">";  i = 1;  goto redir;
1339         case NCLOBBER:
1340                 p = ">|";  i = 1;  goto redir;
1341         case NAPPEND:
1342                 p = ">>";  i = 1;  goto redir;
1343         case NTOFD:
1344                 p = ">&";  i = 1;  goto redir;
1345         case NFROM:
1346                 p = "<";  i = 0;  goto redir;
1347         case NFROMFD:
1348                 p = "<&";  i = 0;  goto redir;
1349         case NFROMTO:
1350                 p = "<>";  i = 0;  goto redir;
1351 redir:
1352                 if (n->nfile.fd != i) {
1353                         s[0] = n->nfile.fd + '0';
1354                         s[1] = '\0';
1355                         cmdputs(s);
1356                 }
1357                 cmdputs(p);
1358                 if (n->type == NTOFD || n->type == NFROMFD) {
1359                         s[0] = n->ndup.dupfd + '0';
1360                         s[1] = '\0';
1361                         cmdputs(s);
1362                 } else {
1363                         cmdtxt(n->nfile.fname);
1364                 }
1365                 break;
1366         case NHERE:
1367         case NXHERE:
1368                 cmdputs("<<...");
1369                 break;
1370         default:
1371                 cmdputs("???");
1372                 break;
1373         }
1374 }
1375
1376 STATIC void
1377 cmdlist(union node *np, int sep)
1378 {
1379         for (; np; np = np->narg.next) {
1380                 if (!sep)
1381                         cmdputs(" ");
1382                 cmdtxt(np);
1383                 if (sep && np->narg.next)
1384                         cmdputs(" ");
1385         }
1386 }
1387
1388
1389 STATIC void
1390 cmdputs(const char *s)
1391 {
1392         const char *p, *str = 0;
1393         char c, cc[2] = " ";
1394         char *nextc;
1395         int nleft;
1396         int subtype = 0;
1397         int quoted = 0;
1398         static char vstype[16][4] = { "", "}", "-", "+", "?", "=",
1399                                         "#", "##", "%", "%%" };
1400
1401         p = s;
1402         nextc = cmdnextc;
1403         nleft = cmdnleft;
1404         while (nleft > 0 && (c = *p++) != 0) {
1405                 switch (c) {
1406                 case CTLESC:
1407                         c = *p++;
1408                         break;
1409                 case CTLVAR:
1410                         subtype = *p++;
1411                         if ((subtype & VSTYPE) == VSLENGTH)
1412                                 str = "${#";
1413                         else
1414                                 str = "${";
1415                         if (!(subtype & VSQUOTE) != !(quoted & 1)) {
1416                                 quoted ^= 1;
1417                                 c = '"';
1418                         } else
1419                                 c = *str++;
1420                         break;
1421                 case CTLENDVAR:
1422                         if (quoted & 1) {
1423                                 c = '"';
1424                                 str = "}";
1425                         } else
1426                                 c = '}';
1427                         quoted >>= 1;
1428                         subtype = 0;
1429                         break;
1430                 case CTLBACKQ:
1431                         c = '$';
1432                         str = "(...)";
1433                         break;
1434                 case CTLBACKQ+CTLQUOTE:
1435                         c = '"';
1436                         str = "$(...)\"";
1437                         break;
1438                 case CTLARI:
1439                         c = '$';
1440                         str = "((";
1441                         break;
1442                 case CTLENDARI:
1443                         c = ')';
1444                         str = ")";
1445                         break;
1446                 case CTLQUOTEMARK:
1447                         quoted ^= 1;
1448                         c = '"';
1449                         break;
1450                 case '=':
1451                         if (subtype == 0)
1452                                 break;
1453                         str = vstype[subtype & VSTYPE];
1454                         if (subtype & VSNUL)
1455                                 c = ':';
1456                         else
1457                                 c = *str++;
1458                         if (c != '}')
1459                                 quoted <<= 1;
1460                         break;
1461                 case '\'':
1462                 case '\\':
1463                 case '"':
1464                 case '$':
1465                         /* These can only happen inside quotes */
1466                         cc[0] = c;
1467                         str = cc;
1468                         c = '\\';
1469                         break;
1470                 default:
1471                         break;
1472                 }
1473                 do {
1474                         *nextc++ = c;
1475                 } while (--nleft > 0 && str && (c = *str++));
1476                 str = 0;
1477         }
1478         if ((quoted & 1) && nleft) {
1479                 *nextc++ = '"';
1480                 nleft--;
1481         }
1482         cmdnleft = nleft;
1483         cmdnextc = nextc;
1484 }