bin/sh/jobs.c

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