Changeset 24 for branches/FREEBSD/src/kmk/job.c

Timestamp:

Nov 26, 2002, 10:24:54 PM (23 years ago)

Author:

bird

Message:

Import of RELENG_4_7_0_RELEASE

File:

• branches/FREEBSD/src/kmk/job.c (modified) (103 diffs)

branches/FREEBSD/src/kmk/job.c

@@ -1 +1 @@
 /*
- * Copyright (c) 1988, 1989, 1990, 1993
- *      The Regents of the University of California.  All rights reserved.
+ * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * Copyright (c) 1988, 1989 by Adam de Boor
  * Copyright (c) 1989 by Berkeley Softworks
@@ -36 +35 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- *
- * @(#)job.c    8.2 (Berkeley) 3/19/94
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/usr.bin/make/job.c,v 1.45 2002/10/09 03:42:10 jmallett Exp $");
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)job.c       8.2 (Berkeley) 3/19/94";
+#else
+static const char rcsid[] =
+  "$FreeBSD: src/usr.bin/make/job.c,v 1.17.2.2 2001/02/13 03:13:57 will Exp $";
+#endif
+#endif /* not lint */
 
 #ifndef OLD_JOKE
-#define OLD_JOKE 0
+#define OLD_JOKE 0
 #endif /* OLD_JOKE */
 
@@ -84 +87 @@
  *                              FAILURE if the spec was incorrect.
  *
- *      Job_Finish                      Perform any final processing which needs doing.
+ *      Job_End                 Perform any final processing which needs doing.
  *                              This includes the execution of any commands
  *                              which have been/were attached to the .END
@@ -107 +110 @@
 #include <sys/file.h>
 #include <sys/time.h>
-#include <sys/event.h>
 #include <sys/wait.h>
-#include <err.h>
+#include <fcntl.h>
 #include <errno.h>
-#include <fcntl.h>
+#include <utime.h>
 #include <stdio.h>
 #include <string.h>
 #include <signal.h>
-#include <unistd.h>
-#include <utime.h>
 #include "make.h"
 #include "hash.h"
@@ -134 +134 @@
 static int      errors = 0;         /* number of errors reported */
 static int      aborting = 0;       /* why is the make aborting? */
-#define ABORT_ERROR     1           /* Because of an error */
-#define ABORT_INTERRUPT 2           /* Because it was interrupted */
-#define ABORT_WAIT      3           /* Waiting for jobs to finish */
+#define ABORT_ERROR     1           /* Because of an error */
+#define ABORT_INTERRUPT 2           /* Because it was interrupted */
+#define ABORT_WAIT      3           /* Waiting for jobs to finish */
 
 /*
@@ -142 +142 @@
  * is a char! So when we go above 127 we turn negative!
  */
-#define FILENO(a) ((unsigned) fileno(a))
+#define FILENO(a) ((unsigned) fileno(a))
 
 /*
@@ -158 +158 @@
  * Return values from JobStart.
  */
-#define JOB_RUNNING     0       /* Job is running */
-#define JOB_ERROR       1       /* Error in starting the job */
-#define JOB_FINISHED    2       /* The job is already finished */
-#define JOB_STOPPED     3       /* The job is stopped */
+#define JOB_RUNNING     0       /* Job is running */
+#define JOB_ERROR       1       /* Error in starting the job */
+#define JOB_FINISHED    2       /* The job is already finished */
+#define JOB_STOPPED     3       /* The job is stopped */
 
 /*
@@ -196 +196 @@
     FALSE, "echo \"%s\"\n", "sh -c '%s || exit 0'\n",
 #endif
-    "v", "e",
-},
-    /*
-     * KSH description. The Korn shell has a superset of
-     * the Bourne shell's functionality.
-     */
-{
-    "ksh",
-    TRUE, "set -", "set -v", "set -", 5,
-    TRUE, "set -e", "set +e",
     "v", "e",
 },
@@ -239 +229 @@
                                  * nLocal equals maxLocal */
 #ifndef RMT_WILL_WATCH
-#ifdef USE_KQUEUE
-static int      kqfd;           /* File descriptor obtained by kqueue() */
-#else
 static fd_set   outputs;        /* Set of descriptors of pipes connected to
                                  * the output channels of children */
-#endif
 #endif
 
@@ -290 +276 @@
  * really ugly, use dramamine sparingly. You have been warned.
  */
-#define W_SETMASKED(st, val, fun)                               \
+#define W_SETMASKED(st, val, fun)                               \
         {                                                       \
                 int sh = (int) ~0;                              \
@@ -300 +286 @@
         }
 
-#define W_SETTERMSIG(st, val) W_SETMASKED(st, val, WTERMSIG)
-#define W_SETEXITSTATUS(st, val) W_SETMASKED(st, val, WEXITSTATUS)
-
-
-static int JobCondPassSig(void *, void *);
-static void JobPassSig(int);
-static int JobCmpPid(void *, void *);
-static int JobPrintCommand(void *, void *);
-static int JobSaveCommand(void *, void *);
-static void JobClose(Job *);
+#define W_SETTERMSIG(st, val) W_SETMASKED(st, val, WTERMSIG)
+#define W_SETEXITSTATUS(st, val) W_SETMASKED(st, val, WEXITSTATUS)
+
+
+static int JobCondPassSig __P((ClientData, ClientData));
+static void JobPassSig __P((int));
+static int JobCmpPid __P((ClientData, ClientData));
+static int JobPrintCommand __P((ClientData, ClientData));
+static int JobSaveCommand __P((ClientData, ClientData));
+static void JobClose __P((Job *));
 #ifdef REMOTE
-static int JobCmpRmtID(Job *, int);
+static int JobCmpRmtID __P((Job *, int));
 # ifdef RMT_WILL_WATCH
-static void JobLocalInput(int, Job *);
+static void JobLocalInput __P((int, Job *));
 # endif
 #else
-static void JobFinish(Job *, int *);
-static void JobExec(Job *, char **);
-#endif
-static void JobMakeArgv(Job *, char **);
-static void JobRestart(Job *);
-static int JobStart(GNode *, int, Job *);
-static char *JobOutput(Job *, char *, char *, int);
-static void JobDoOutput(Job *, Boolean);
-static Shell *JobMatchShell(char *);
-static void JobInterrupt(int, int);
-static void JobRestartJobs(void);
+static void JobFinish __P((Job *, int *));
+static void JobExec __P((Job *, char **));
+#endif
+static void JobMakeArgv __P((Job *, char **));
+static void JobRestart __P((Job *));
+static int JobStart __P((GNode *, int, Job *));
+static char *JobOutput __P((Job *, char *, char *, int));
+static void JobDoOutput __P((Job *, Boolean));
+static Shell *JobMatchShell __P((char *));
+static void JobInterrupt __P((int, int));
+static void JobRestartJobs __P((void));
 
 /*-
@@ -343 +329 @@
  */
 static int
-JobCondPassSig(void *jobp, void *signop)
+JobCondPassSig(jobp, signop)
+    ClientData          jobp;       /* Job to biff */
+    ClientData          signop;     /* Signal to send it */
 {
     Job *job = (Job *) jobp;
@@ -358 +346 @@
      * job as well.
      */
-    DEBUGF(JOB, ("JobCondPassSig passing signal %d to child %d.\n", signo, job->pid));
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout,
+                       "JobCondPassSig passing signal %d to child %d.\n",
+                       signo, job->pid);
+        (void) fflush(stdout);
+    }
     KILL(job->pid, signo);
 #endif
@@ -379 +372 @@
  */
 static void
-JobPassSig(int signo)
+JobPassSig(signo)
+    int     signo;      /* The signal number we've received */
 {
     sigset_t nmask, omask;
     struct sigaction act;
 
-    DEBUGF(JOB, ("JobPassSig(%d) called.\n", signo));
-    Lst_ForEach(jobs, JobCondPassSig, (void *) &signo);
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout, "JobPassSig(%d) called.\n", signo);
+        (void) fflush(stdout);
+    }
+    Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
 
     /*
@@ -419 +416 @@
     sigaction(signo, &act, NULL);
 
-    DEBUGF(JOB, ("JobPassSig passing signal to self, mask = %x.\n", ~0 & ~(1 << (signo-1))));
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout,
+                       "JobPassSig passing signal to self, mask = %x.\n",
+                       ~0 & ~(1 << (signo-1)));
+        (void) fflush(stdout);
+    }
     (void) signal(signo, SIG_DFL);
 
@@ -425 +427 @@
 
     signo = SIGCONT;
-    Lst_ForEach(jobs, JobCondPassSig, (void *) &signo);
+    Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
 
     (void) sigprocmask(SIG_SETMASK, &omask, NULL);
@@ -448 +450 @@
  */
 static int
-JobCmpPid(void *job, void *pid)
+JobCmpPid(job, pid)
+    ClientData        job;      /* job to examine */
+    ClientData        pid;      /* process id desired */
 {
     return *(int *) pid - ((Job *) job)->pid;
@@ -468 +472 @@
  */
 static int
-JobCmpRmtID(void *job, void *rmtID)
+JobCmpRmtID(job, rmtID)
+    ClientData      job;        /* job to examine */
+    ClientData      rmtID;      /* remote id desired */
 {
     return(*(int *) rmtID - *(int *) job->rmtID);
@@ -487 +493 @@
  *      made and return non-zero to signal that the end of the commands
  *      was reached. These commands are later attached to the postCommands
- *      node and executed by Job_Finish when all things are done.
+ *      node and executed by Job_End when all things are done.
  *      This function is called from JobStart via Lst_ForEach.
  *
@@ -502 +508 @@
  */
 static int
-JobPrintCommand(void *cmdp, void *jobp)
+JobPrintCommand(cmdp, jobp)
+    ClientData    cmdp;             /* command string to print */
+    ClientData    jobp;             /* job for which to print it */
 {
     Boolean       noSpecials;       /* true if we shouldn't worry about
@@ -525 +533 @@
         if ((job->flags & JOB_IGNDOTS) == 0) {
             job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
-                                                (void *)cmd));
+                                                (ClientData)cmd));
             return 1;
         }
@@ -531 +539 @@
     }
 
-#define DBPRINTF(fmt, arg)                      \
-   DEBUGF(JOB, (fmt, arg));                     \
+#define DBPRINTF(fmt, arg) if (DEBUG(JOB)) {    \
+        (void) fprintf(stdout, fmt, arg);       \
+        (void) fflush(stdout);                  \
+    }                                           \
    (void) fprintf(job->cmdFILE, fmt, arg);      \
    (void) fflush(job->cmdFILE);
@@ -542 +552 @@
      * the variables in the command.
      */
-    cmdNode = Lst_Member(job->node->commands, (void *)cmd);
+    cmdNode = Lst_Member(job->node->commands, (ClientData)cmd);
     cmdStart = cmd = Var_Subst(NULL, cmd, job->node, FALSE);
-    Lst_Replace(cmdNode, (void *)cmdStart);
+    Lst_Replace(cmdNode, (ClientData)cmdStart);
 
     cmdTemplate = "%s\n";
@@ -659 +669 @@
  */
 static int
-JobSaveCommand(void *cmd, void *gn)
-{
-    cmd = (void *) Var_Subst(NULL, (char *) cmd, (GNode *) gn, FALSE);
+JobSaveCommand(cmd, gn)
+    ClientData   cmd;
+    ClientData   gn;
+{
+    cmd = (ClientData) Var_Subst(NULL, (char *) cmd, (GNode *) gn, FALSE);
     (void) Lst_AtEnd(postCommands->commands, cmd);
     return(0);
@@ -681 +693 @@
  */
 static void
-JobClose(Job *job)
+JobClose(job)
+    Job *job;
 {
     if (usePipes) {
 #ifdef RMT_WILL_WATCH
         Rmt_Ignore(job->inPipe);
-#elif !defined(USE_KQUEUE)
+#else
         FD_CLR(job->inPipe, &outputs);
 #endif
@@ -725 +738 @@
 /*ARGSUSED*/
 static void
-JobFinish(Job *job, int *status)
+JobFinish(job, status)
+    Job         *job;             /* job to finish */
+    int         *status;          /* sub-why job went away */
 {
     Boolean      done;
@@ -794 +809 @@
              */
             out = fdopen(job->outFd, "w");
-            if (out == NULL)
-                Punt("Cannot fdopen");
         } else {
             out = stdout;
@@ -801 +814 @@
 
         if (WIFEXITED(*status)) {
-            DEBUGF(JOB, ("Process %d exited.\n", job->pid));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Process %d exited.\n", job->pid);
+                (void) fflush(stdout);
+            }
             if (WEXITSTATUS(*status) != 0) {
                 if (usePipes && job->node != lastNode) {
@@ -822 +838 @@
             }
         } else if (WIFSTOPPED(*status)) {
-            DEBUGF(JOB, ("Process %d stopped.\n", job->pid));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Process %d stopped.\n", job->pid);
+                (void) fflush(stdout);
+            }
             if (usePipes && job->node != lastNode) {
                 MESSAGE(out, job->node);
@@ -832 +851 @@
             }
             job->flags |= JOB_RESUME;
-            (void)Lst_AtEnd(stoppedJobs, (void *)job);
+            (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
 #ifdef REMOTE
             if (job->flags & JOB_REMIGRATE)
@@ -853 +872 @@
             }
             if (!(job->flags & JOB_CONTINUING)) {
-                DEBUGF(JOB, ("Warning: process %d was not continuing.\n", job->pid));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Warning: process %d was not continuing.\n",
+                                   job->pid);
+                    (void) fflush(stdout);
+                }
 #ifdef notdef
                 /*
@@ -865 +889 @@
             }
             job->flags &= ~JOB_CONTINUING;
-            Lst_AtEnd(jobs, (void *)job);
+            Lst_AtEnd(jobs, (ClientData)job);
             nJobs += 1;
             if (!(job->flags & JOB_REMOTE)) {
-                DEBUGF(JOB, ("Process %d is continuing locally.\n", job->pid));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Process %d is continuing locally.\n",
+                                   job->pid);
+                    (void) fflush(stdout);
+                }
                 nLocal += 1;
             }
             if (nJobs == maxJobs) {
                 jobFull = TRUE;
-                DEBUGF(JOB, ("Job queue is full.\n"));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "Job queue is full.\n");
+                    (void) fflush(stdout);
+                }
             }
             (void) fflush(out);
@@ -913 +945 @@
             done = FALSE;
             break;
-        default:
-            break;
         }
     } else {
@@ -932 +962 @@
          * on the .END target.
          */
-        if (job->tailCmds != NULL) {
+        if (job->tailCmds != NILLNODE) {
             Lst_ForEachFrom(job->node->commands, job->tailCmds,
                              JobSaveCommand,
-                            (void *)job->node);
+                            (ClientData)job->node);
         }
         job->node->made = MADE;
         Make_Update(job->node);
-        free(job);
+        free((Address)job);
     } else if (*status != 0) {
         errors += 1;
-        free(job);
+        free((Address)job);
     }
 
@@ -970 +1000 @@
  * Job_Touch --
  *      Touch the given target. Called by JobStart when the -t flag was
- *      given.  Prints messages unless told to be silent.
+ *      given
  *
  * Results:
@@ -981 +1011 @@
  */
 void
-Job_Touch(GNode *gn, Boolean silent)
+Job_Touch(gn, silent)
+    GNode         *gn;          /* the node of the file to touch */
+    Boolean       silent;       /* TRUE if should not print messages */
 {
     int           streamID;     /* ID of stream opened to do the touch */
@@ -1022 +1054 @@
                  */
                 if (read(streamID, &c, 1) == 1) {
-                    (void) lseek(streamID, (off_t)0, SEEK_SET);
+                    (void) lseek(streamID, 0L, SEEK_SET);
                     (void) write(streamID, &c, 1);
                 }
@@ -1050 +1082 @@
  */
 Boolean
-Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
+Job_CheckCommands(gn, abortProc)
+    GNode          *gn;             /* The target whose commands need
+                                     * verifying */
+    void         (*abortProc) __P((char *, ...));
+                        /* Function to abort with message */
 {
     if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) &&
@@ -1058 +1094 @@
          * commands
          */
-        if ((DEFAULT != NULL) && !Lst_IsEmpty(DEFAULT->commands)) {
+        if ((DEFAULT != NILGNODE) && !Lst_IsEmpty(DEFAULT->commands)) {
             char *p1;
             /*
@@ -1118 +1154 @@
 /*ARGSUSED*/
 static void
-JobLocalInput(int stream, Job *job)
+JobLocalInput(stream, job)
+    int     stream;     /* Stream that's ready (ignored) */
+    Job     *job;       /* Job to which the stream belongs */
 {
     JobDoOutput(job, FALSE);
@@ -1140 +1178 @@
  */
 static void
-JobExec(Job *job, char **argv)
+JobExec(job, argv)
+    Job           *job;         /* Job to execute */
+    char          **argv;
 {
     int           cpid;         /* ID of new child */
@@ -1147 +1187 @@
         int       i;
 
-        DEBUGF(JOB, ("Running %s %sly\n", job->node->name,
-               job->flags&JOB_REMOTE?"remote":"local"));
-        DEBUGF(JOB, ("\tCommand: "));
+        (void) fprintf(stdout, "Running %s %sly\n", job->node->name,
+                       job->flags&JOB_REMOTE?"remote":"local");
+        (void) fprintf(stdout, "\tCommand: ");
         for (i = 0; argv[i] != NULL; i++) {
-            DEBUGF(JOB, ("%s ", argv[i]));
-        }
-        DEBUGF(JOB, ("\n"));
+            (void) fprintf(stdout, "%s ", argv[i]);
+        }
+        (void) fprintf(stdout, "\n");
+        (void) fflush(stdout);
     }
 
@@ -1186 +1227 @@
             Punt("Cannot dup2: %s", strerror(errno));
         (void) fcntl(0, F_SETFD, 0);
-        (void) lseek(0, (off_t)0, SEEK_SET);
+        (void) lseek(0, 0, SEEK_SET);
 
         if (usePipes) {
@@ -1234 +1275 @@
            (void) execv(shellPath, argv);
 
-        (void) write(STDERR_FILENO, "Could not execute shell\n",
+        (void) write(2, "Could not execute shell\n",
                      sizeof("Could not execute shell"));
         _exit(1);
@@ -1249 +1290 @@
              * stream to watch in the outputs mask
              */
-#ifdef USE_KQUEUE
-            struct kevent       kev[2];
-#endif
             job->curPos = 0;
 
 #ifdef RMT_WILL_WATCH
             Rmt_Watch(job->inPipe, JobLocalInput, job);
-#elif defined(USE_KQUEUE)
-            EV_SET(&kev[0], job->inPipe, EVFILT_READ, EV_ADD, 0, 0, job);
-            EV_SET(&kev[1], job->pid, EVFILT_PROC, EV_ADD | EV_ONESHOT,
-                NOTE_EXIT, 0, NULL);
-            if (kevent(kqfd, kev, 2, NULL, 0, NULL) != 0) {
-                /* kevent() will fail if the job is already finished */
-                if (errno != EBADF && errno != ESRCH)
-                    Punt("kevent: %s", strerror(errno));
-            }
 #else
             FD_SET(job->inPipe, &outputs);
@@ -1298 +1327 @@
      */
     nJobs += 1;
-    (void) Lst_AtEnd(jobs, (void *)job);
+    (void) Lst_AtEnd(jobs, (ClientData)job);
     if (nJobs == maxJobs) {
         jobFull = TRUE;
@@ -1317 +1346 @@
  */
 static void
-JobMakeArgv(Job *job, char **argv)
+JobMakeArgv(job, argv)
+    Job           *job;
+    char          **argv;
 {
     int           argc;
@@ -1371 +1402 @@
  */
 static void
-JobRestart(Job *job)
+JobRestart(job)
+    Job           *job;         /* Job to restart */
 {
 #ifdef REMOTE
@@ -1430 +1462 @@
                    (void) fflush(stdout);
                 }
-                (void)Lst_AtFront(stoppedJobs, (void *)job);
+                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
                 jobFull = TRUE;
-                DEBUGF(JOB, ("Job queue is full.\n"));
+                if (DEBUG(JOB)) {
+                   (void) fprintf(stdout, "Job queue is full.\n");
+                   (void) fflush(stdout);
+                }
                 return;
             }
@@ -1448 +1483 @@
 #endif
 
-        (void)Lst_AtEnd(jobs, (void *)job);
+        (void)Lst_AtEnd(jobs, (ClientData)job);
         nJobs += 1;
         if (nJobs == maxJobs) {
             jobFull = TRUE;
-            DEBUGF(JOB, ("Job queue is full.\n"));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is full.\n");
+                (void) fflush(stdout);
+            }
         }
     } else if (job->flags & JOB_RESTART) {
@@ -1467 +1505 @@
         JobMakeArgv(job, argv);
 
-        DEBUGF(JOB, ("Restarting %s...", job->node->name));
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout, "Restarting %s...", job->node->name);
+            (void) fflush(stdout);
+        }
 #ifdef REMOTE
         if ((job->node->type&OP_NOEXPORT) ||
@@ -1483 +1524 @@
                  * back on the hold queue and mark the table full
                  */
-                DEBUGF(JOB, ("holding\n"));
-                (void)Lst_AtFront(stoppedJobs, (void *)job);
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "holding\n");
+                    (void) fflush(stdout);
+                }
+                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
                 jobFull = TRUE;
-                DEBUGF(JOB, ("Job queue is full.\n"));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "Job queue is full.\n");
+                    (void) fflush(stdout);
+                }
                 return;
             } else {
@@ -1492 +1539 @@
                  * Job may be run locally.
                  */
-                DEBUGF(JOB, ("running locally\n"));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "running locally\n");
+                    (void) fflush(stdout);
+                }
                 job->flags &= ~JOB_REMOTE;
             }
@@ -1501 +1551 @@
              * Can be exported. Hooray!
              */
-            DEBUGF(JOB, ("exporting\n"));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "exporting\n");
+                (void) fflush(stdout);
+            }
             job->flags |= JOB_REMOTE;
         }
@@ -1511 +1564 @@
          * we don't know...
          */
-        DEBUGF(JOB, ("Resuming %s...", job->node->name));
+        if (DEBUG(JOB)) {
+           (void) fprintf(stdout, "Resuming %s...", job->node->name);
+           (void) fflush(stdout);
+        }
         if (((job->flags & JOB_REMOTE) ||
             (nLocal < maxLocal) ||
@@ -1551 +1607 @@
 
                 job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
-                DEBUGF(JOB, ("done\n"));
+                if (DEBUG(JOB)) {
+                   (void) fprintf(stdout, "done\n");
+                   (void) fflush(stdout);
+                }
             } else {
                 Error("couldn't resume %s: %s",
@@ -1564 +1623 @@
              * place the job back on the list of stopped jobs.
              */
-            DEBUGF(JOB, ("table full\n"));
-            (void) Lst_AtFront(stoppedJobs, (void *)job);
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "table full\n");
+                (void) fflush(stdout);
+            }
+            (void) Lst_AtFront(stoppedJobs, (ClientData)job);
             jobFull = TRUE;
-            DEBUGF(JOB, ("Job queue is full.\n"));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is full.\n");
+                (void) fflush(stdout);
+            }
         }
     }
@@ -1589 +1654 @@
  */
 static int
-JobStart(GNode *gn, int flags, Job *previous)
-{
-    Job           *job;       /* new job descriptor */
+JobStart(gn, flags, previous)
+    GNode         *gn;        /* target to create */
+    int            flags;      /* flags for the job to override normal ones.
+                               * e.g. JOB_SPECIAL or JOB_IGNDOTS */
+    Job           *previous;  /* The previous Job structure for this node,
+                               * if any. */
+{
+    register Job  *job;       /* new job descriptor */
     char          *argv[4];   /* Argument vector to shell */
     Boolean       cmdsOK;     /* true if the nodes commands were all right */
@@ -1603 +1673 @@
     } else {
         job = (Job *) emalloc(sizeof(Job));
+        if (job == NULL) {
+            Punt("JobStart out of memory");
+        }
         flags |= JOB_FIRST;
     }
 
     job->node = gn;
-    job->tailCmds = NULL;
+    job->tailCmds = NILLNODE;
 
     /*
@@ -1682 +1755 @@
                 LstNode ln = Lst_Next(gn->commands);
 
-                if ((ln == NULL) ||
-                    JobPrintCommand((void *) Lst_Datum(ln),
-                                    (void *) job))
+                if ((ln == NILLNODE) ||
+                    JobPrintCommand((ClientData) Lst_Datum(ln),
+                                    (ClientData) job))
                 {
                     noExec = TRUE;
@@ -1709 +1782 @@
              */
             numCommands = 0;
-            Lst_ForEach(gn->commands, JobPrintCommand, (void *)job);
+            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
 
             /*
@@ -1735 +1808 @@
          */
         if (cmdsOK) {
-            Lst_ForEach(gn->commands, JobPrintCommand, (void *)job);
+            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
         }
         /*
@@ -1773 +1846 @@
         if (cmdsOK) {
             if (aborting == 0) {
-                if (job->tailCmds != NULL) {
+                if (job->tailCmds != NILLNODE) {
                     Lst_ForEachFrom(job->node->commands, job->tailCmds,
                                     JobSaveCommand,
-                                   (void *)job->node);
+                                   (ClientData)job->node);
                 }
                 job->node->made = MADE;
                 Make_Update(job->node);
             }
-            free(job);
+            free((Address)job);
             return(JOB_FINISHED);
         } else {
-            free(job);
+            free((Address)job);
             return(JOB_ERROR);
         }
@@ -1855 +1928 @@
         jobFull = TRUE;
 
-        DEBUGF(JOB, ("Can only run job locally.\n"));
+        if (DEBUG(JOB)) {
+           (void) fprintf(stdout, "Can only run job locally.\n");
+           (void) fflush(stdout);
+        }
         job->flags |= JOB_RESTART;
-        (void) Lst_AtEnd(stoppedJobs, (void *)job);
+        (void) Lst_AtEnd(stoppedJobs, (ClientData)job);
     } else {
         if ((nLocal >= maxLocal) && local) {
@@ -1865 +1941 @@
              */
             jobFull = TRUE;
-            DEBUGF(JOB, ("Local job queue is full.\n"));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Local job queue is full.\n");
+                (void) fflush(stdout);
+            }
         }
         JobExec(job, argv);
@@ -1873 +1952 @@
 
 static char *
-JobOutput(Job *job, char *cp, char *endp, int msg)
-{
-    char *ecp;
+JobOutput(job, cp, endp, msg)
+    register Job *job;
+    register char *cp, *endp;
+    int msg;
+{
+    register char *ecp;
 
     if (commandShell->noPrint) {
@@ -1943 +2025 @@
  */
 STATIC void
-JobDoOutput(Job *job, Boolean finish)
+JobDoOutput(job, finish)
+    register Job   *job;          /* the job whose output needs printing */
+    Boolean        finish;        /* TRUE if this is the last time we'll be
+                                   * called for this job */
 {
     Boolean       gotNL = FALSE;  /* true if got a newline */
     Boolean       fbuf;           /* true if our buffer filled up */
-    int           nr;             /* number of bytes read */
-    int           i;              /* auxiliary index into outBuf */
-    int           max;            /* limit for i (end of current data) */
+    register int  nr;             /* number of bytes read */
+    register int  i;              /* auxiliary index into outBuf */
+    register int  max;            /* limit for i (end of current data) */
     int           nRead;          /* (Temporary) number of bytes read */
 
@@ -1967 +2052 @@
                          JOB_BUFSIZE - job->curPos);
         if (nRead < 0) {
-            DEBUGF(JOB, ("JobDoOutput(piperead)"));
+            if (DEBUG(JOB)) {
+                perror("JobDoOutput(piperead)");
+            }
             nr = 0;
         } else {
@@ -2021 +2108 @@
              * first, overwriting the newline character if there was one.
              * So long as the line isn't one we should filter (according
-             * to the shell description), we print the line, preceded
+             * to the shell description), we print the line, preceeded
              * by a target banner if this target isn't the same as the
              * one for which we last printed something.
@@ -2087 +2174 @@
             (void) fflush(stdout);
             while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
-                char    *cp, *endp, *oendp;
+                register char   *cp, *endp, *oendp;
 
                 cp = inLine;
@@ -2134 +2221 @@
  */
 void
-Job_CatchChildren(Boolean block)
+Job_CatchChildren(block)
+    Boolean       block;        /* TRUE if should block on the wait. */
 {
     int           pid;          /* pid of dead child */
-    Job           *job;         /* job descriptor for dead child */
+    register Job  *job;         /* job descriptor for dead child */
     LstNode       jnode;        /* list element for finding job */
     int           status;       /* Exit/termination status */
@@ -2151 +2239 @@
                           (block?0:WNOHANG)|WUNTRACED)) > 0)
     {
-        DEBUGF(JOB, ("Process %d exited or stopped.\n", pid));
-
-        jnode = Lst_Find(jobs, (void *)&pid, JobCmpPid);
-
-        if (jnode == NULL) {
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
+            (void) fflush(stdout);
+        }
+
+
+        jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
+
+        if (jnode == NILLNODE) {
             if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGCONT)) {
-                jnode = Lst_Find(stoppedJobs, (void *) &pid, JobCmpPid);
-                if (jnode == NULL) {
+                jnode = Lst_Find(stoppedJobs, (ClientData) &pid, JobCmpPid);
+                if (jnode == NILLNODE) {
                     Error("Resumed child (%d) not in table", pid);
                     continue;
@@ -2172 +2264 @@
             (void) Lst_Remove(jobs, jnode);
             nJobs -= 1;
-            DEBUGF(JOB, ("Job queue is no longer full.\n"));
+            if (jobFull && DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is no longer full.\n");
+                (void) fflush(stdout);
+            }
             jobFull = FALSE;
 #ifdef REMOTE
             if (!(job->flags & JOB_REMOTE)) {
-                DEBUGF(JOB, ("Job queue has one fewer local process.\n"));
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Job queue has one fewer local process.\n");
+                    (void) fflush(stdout);
+                }
                 nLocal -= 1;
             }
@@ -2205 +2304 @@
  */
 void
-Job_CatchOutput(void)
+Job_CatchOutput()
 {
     int                   nfds;
-#ifdef USE_KQUEUE
-#define KEV_SIZE        4
-    struct kevent         kev[KEV_SIZE];
-    int                   i;
-#else
     struct timeval        timeout;
     fd_set                readfds;
-    LstNode               ln;
-    Job                   *job;
-#endif
+    register LstNode      ln;
+    register Job          *job;
 #ifdef RMT_WILL_WATCH
     int                   pnJobs;       /* Previous nJobs */
@@ -2247 +2340 @@
 #else
     if (usePipes) {
-#ifdef USE_KQUEUE
-        if ((nfds = kevent(kqfd, NULL, 0, kev, KEV_SIZE, NULL)) == -1) {
-            Punt("kevent: %s", strerror(errno));
-        } else {
-            for (i = 0; i < nfds; i++) {
-                if (kev[i].flags & EV_ERROR) {
-                    warnc(kev[i].data, "kevent");
-                    continue;
-                }
-                switch (kev[i].filter) {
-                case EVFILT_READ:
-                    JobDoOutput(kev[i].udata, FALSE);
-                    break;
-                case EVFILT_PROC:
-                    /* Just wake up and let Job_CatchChildren() collect the
-                     * terminated job. */
-                    break;
-                }
-            }
-        }
-#else
         readfds = outputs;
         timeout.tv_sec = SEL_SEC;
@@ -2279 +2351 @@
                 Punt("Cannot open job table");
             }
-            while (nfds && (ln = Lst_Next(jobs)) != NULL) {
+            while (nfds && (ln = Lst_Next(jobs)) != NILLNODE) {
                 job = (Job *) Lst_Datum(ln);
                 if (FD_ISSET(job->inPipe, &readfds)) {
@@ -2288 +2360 @@
             Lst_Close(jobs);
         }
-#endif /* !USE_KQUEUE */
     }
 #endif /* RMT_WILL_WATCH */
@@ -2308 +2379 @@
  */
 void
-Job_Make(GNode *gn)
+Job_Make(gn)
+    GNode   *gn;
 {
     (void) JobStart(gn, 0, NULL);
@@ -2316 +2388 @@
  *-----------------------------------------------------------------------
  * Job_Init --
- *      Initialize the process module, given a maximum number of jobs, and
- *      a maximum number of local jobs.
+ *      Initialize the process module
  *
  * Results:
@@ -2327 +2398 @@
  */
 void
-Job_Init(int maxproc, int maxlocal)
+Job_Init(maxproc, maxlocal)
+    int           maxproc;  /* the greatest number of jobs which may be
+                             * running at one time */
+    int           maxlocal; /* the greatest number of local jobs which may
+                             * be running at once. */
 {
     GNode         *begin;     /* node for commands to do at the very start */
@@ -2342 +2417 @@
     errors =      0;
 
-    lastNode =    NULL;
+    lastNode =    NILGNODE;
 
     if (maxJobs == 1 || beVerbose == 0
@@ -2414 +2489 @@
 #endif
 
-#ifdef USE_KQUEUE
-    if ((kqfd = kqueue()) == -1) {
-        Punt("kqueue: %s", strerror(errno));
-    }
-#endif
-
     begin = Targ_FindNode(".BEGIN", TARG_NOCREATE);
 
-    if (begin != NULL) {
+    if (begin != NILGNODE) {
         JobStart(begin, JOB_SPECIAL, (Job *)0);
         while (nJobs) {
@@ -2449 +2518 @@
  */
 Boolean
-Job_Full(void)
+Job_Full()
 {
     return(aborting || jobFull);
@@ -2471 +2540 @@
  */
 Boolean
-Job_Empty(void)
+Job_Empty()
 {
     if (nJobs == 0) {
@@ -2504 +2573 @@
  */
 static Shell *
-JobMatchShell(char *name)
-{
-    Shell         *sh;        /* Pointer into shells table */
-    Shell         *match;     /* Longest-matching shell */
-    char          *cp1,
+JobMatchShell(name)
+    char          *name;      /* Final component of shell path */
+{
+    register Shell *sh;       /* Pointer into shells table */
+    Shell          *match;    /* Longest-matching shell */
+    register char *cp1,
                   *cp2;
     char          *eoname;
@@ -2575 +2645 @@
  */
 ReturnStatus
-Job_ParseShell(char *line)
+Job_ParseShell(line)
+    char          *line;  /* The shell spec */
 {
     char          **words;
     int           wordCount;
-    char          **argv;
-    int           argc;
+    register char **argv;
+    register int  argc;
     char          *path;
     Shell         newShell;
     Boolean       fullSpec = FALSE;
 
-    while (isspace((unsigned char) *line)) {
+    while (isspace(*line)) {
         line++;
     }
     words = brk_string(line, &wordCount, TRUE);
 
-    memset(&newShell, 0, sizeof(newShell));
+    memset((Address)&newShell, 0, sizeof(newShell));
 
     /*
@@ -2686 +2757 @@
     }
 
+    /*
+     * Do not free up the words themselves, since they might be in use by the
+     * shell specification...
+     */
+    free(words);
     return SUCCESS;
 }
@@ -2703 +2779 @@
  */
 static void
-JobInterrupt(int runINTERRUPT, int signo)
+JobInterrupt(runINTERRUPT, signo)
+    int     runINTERRUPT;       /* Non-zero if commands for the .INTERRUPT
+                                 * target should be executed */
+    int     signo;              /* signal received */
 {
     LstNode       ln;           /* element in job table */
@@ -2711 +2790 @@
     aborting = ABORT_INTERRUPT;
 
-    (void) Lst_Open(jobs);
-    while ((ln = Lst_Next(jobs)) != NULL) {
+   (void) Lst_Open(jobs);
+    while ((ln = Lst_Next(jobs)) != NILLNODE) {
         job = (Job *) Lst_Datum(ln);
 
@@ -2744 +2823 @@
 #else
         if (job->pid) {
-            DEBUGF(JOB, ("JobInterrupt passing signal to child %d.\n",
-                   job->pid));
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout,
+                               "JobInterrupt passing signal to child %d.\n",
+                               job->pid);
+                (void) fflush(stdout);
+            }
             KILL(job->pid, signo);
         }
@@ -2752 +2835 @@
 
 #ifdef REMOTE
-    (void)Lst_Open(stoppedJobs);
-    while ((ln = Lst_Next(stoppedJobs)) != NULL) {
+   (void)Lst_Open(stoppedJobs);
+    while ((ln = Lst_Next(stoppedJobs)) != NILLNODE) {
         job = (Job *) Lst_Datum(ln);
 
         if (job->flags & JOB_RESTART) {
-            DEBUGF(JOB, "JobInterrupt skipping job on stopped queue"
-                   "-- it was waiting to be restarted.\n");
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "%s%s",
+                               "JobInterrupt skipping job on stopped queue",
+                               "-- it was waiting to be restarted.\n");
+                (void) fflush(stdout);
+            }
             continue;
         }
@@ -2772 +2859 @@
          * Resume the thing so it will take the signal.
          */
-        DEBUGF(JOB, ("JobInterrupt passing CONT to stopped child %d.\n", job->pid));
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout,
+                           "JobInterrupt passing CONT to stopped child %d.\n",
+                           job->pid);
+            (void) fflush(stdout);
+        }
         KILL(job->pid, SIGCONT);
 #ifdef RMT_WANTS_SIGNALS
@@ -2790 +2882 @@
             }
         } else if (job->pid) {
-            DEBUGF(JOB, "JobInterrupt passing interrupt to stopped child %d.\n",
-                   job->pid);
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout,
+                       "JobInterrupt passing interrupt to stopped child %d.\n",
+                               job->pid);
+                (void) fflush(stdout);
+            }
             KILL(job->pid, SIGINT);
         }
@@ -2801 +2897 @@
     if (runINTERRUPT && !touchFlag) {
         interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
-        if (interrupt != NULL) {
+        if (interrupt != NILGNODE) {
             ignoreErrors = FALSE;
 
@@ -2817 +2913 @@
 /*
  *-----------------------------------------------------------------------
- * Job_Finish --
+ * Job_End --
  *      Do final processing such as the running of the commands
  *      attached to the .END target.
@@ -2826 +2922 @@
  */
 int
-Job_Finish(void)
-{
-    if (postCommands != NULL && !Lst_IsEmpty(postCommands->commands)) {
+Job_End()
+{
+    if (postCommands != NILGNODE && !Lst_IsEmpty(postCommands->commands)) {
         if (errors) {
             Error("Errors reported so .END ignored");
@@ -2860 +2956 @@
  */
 void
-Job_Wait(void)
+Job_Wait()
 {
     aborting = ABORT_WAIT;
@@ -2887 +2983 @@
  */
 void
-Job_AbortAll(void)
+Job_AbortAll()
 {
     LstNode             ln;     /* element in job table */
@@ -2898 +2994 @@
 
         (void) Lst_Open(jobs);
-        while ((ln = Lst_Next(jobs)) != NULL) {
+        while ((ln = Lst_Next(jobs)) != NILLNODE) {
             job = (Job *) Lst_Datum(ln);
 
@@ -2932 +3028 @@
  * JobFlagForMigration --
  *      Handle the eviction of a child. Called from RmtStatusChange.
- *      Flags the child as remigratable and then suspends it.  Takes
- *      the ID of the host we used, for matching children.
+ *      Flags the child as remigratable and then suspends it.
  *
  * Results:
@@ -2944 +3039 @@
  */
 void
-JobFlagForMigration(int hostID)
-{
-    Job           *job;         /* job descriptor for dead child */
+JobFlagForMigration(hostID)
+    int           hostID;       /* ID of host we used, for matching children. */
+{
+    register Job  *job;         /* job descriptor for dead child */
     LstNode       jnode;        /* list element for finding job */
 
-    DEBUGF(JOB, ("JobFlagForMigration(%d) called.\n", hostID));
-    jnode = Lst_Find(jobs, (void *)hostID, JobCmpRmtID);
-
-    if (jnode == NULL) {
-        jnode = Lst_Find(stoppedJobs, (void *)hostID, JobCmpRmtID);
-                if (jnode == NULL) {
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout, "JobFlagForMigration(%d) called.\n", hostID);
+        (void) fflush(stdout);
+    }
+    jnode = Lst_Find(jobs, (ClientData)hostID, JobCmpRmtID);
+
+    if (jnode == NILLNODE) {
+        jnode = Lst_Find(stoppedJobs, (ClientData)hostID, JobCmpRmtID);
+                if (jnode == NILLNODE) {
                     if (DEBUG(JOB)) {
                         Error("Evicting host(%d) not in table", hostID);
@@ -2963 +3062 @@
     job = (Job *) Lst_Datum(jnode);
 
-    DEBUGF(JOB, ("JobFlagForMigration(%d) found job '%s'.\n", hostID, job->node->name));
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout,
+                       "JobFlagForMigration(%d) found job '%s'.\n", hostID,
+                       job->node->name);
+        (void) fflush(stdout);
+    }
 
     KILL(job->pid, SIGSTOP);
@@ -2989 +3093 @@
  */
 static void
-JobRestartJobs(void)
+JobRestartJobs()
 {
     while (!jobFull && !Lst_IsEmpty(stoppedJobs)) {
-        DEBUGF(JOB, ("Job queue is not full. Restarting a stopped job.\n"));
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout,
+                       "Job queue is not full. Restarting a stopped job.\n");
+            (void) fflush(stdout);
+        }
         JobRestart((Job *)Lst_DeQueue(stoppedJobs));
     }