Stylification: missing spaces, extra space after function names,
authorMax Okumoto <okumoto@dragonflybsd.org>
Fri, 10 Dec 2004 19:22:25 +0000 (19:22 +0000)
committerMax Okumoto <okumoto@dragonflybsd.org>
Fri, 10 Dec 2004 19:22:25 +0000 (19:22 +0000)
casts and the sizeof operator, missing empty lines, void casts,
extra empty lines.

Checked by: diff on make *.o lst.lib/*.o

Author: harti, okumoto

34 files changed:
usr.bin/make/arch.c
usr.bin/make/buf.c
usr.bin/make/buf.h
usr.bin/make/compat.c
usr.bin/make/cond.c
usr.bin/make/dir.c
usr.bin/make/dir.h
usr.bin/make/for.c
usr.bin/make/hash.c
usr.bin/make/hash.h
usr.bin/make/job.c
usr.bin/make/job.h
usr.bin/make/lst.lib/lstAppend.c
usr.bin/make/lst.lib/lstConcat.c
usr.bin/make/lst.lib/lstDeQueue.c
usr.bin/make/lst.lib/lstDestroy.c
usr.bin/make/lst.lib/lstDupl.c
usr.bin/make/lst.lib/lstFindFrom.c
usr.bin/make/lst.lib/lstForEachFrom.c
usr.bin/make/lst.lib/lstInsert.c
usr.bin/make/lst.lib/lstIsAtEnd.c
usr.bin/make/lst.lib/lstNext.c
usr.bin/make/lst.lib/lstOpen.c
usr.bin/make/lst.lib/lstRemove.c
usr.bin/make/main.c
usr.bin/make/make.c
usr.bin/make/parse.c
usr.bin/make/str.c
usr.bin/make/suff.c
usr.bin/make/targ.c
usr.bin/make/util.c
usr.bin/make/var.c
usr.bin/make/var.h
usr.bin/make/var_modify.c

index 3a3eea6..888be79 100644 (file)
@@ -37,7 +37,7 @@
  *
  * @(#)arch.c  8.2 (Berkeley) 1/2/94
  * $FreeBSD: src/usr.bin/make/arch.c,v 1.15.2.1 2001/02/13 03:13:57 will Exp $
- * $DragonFly: src/usr.bin/make/arch.c,v 1.13 2004/11/18 02:01:39 dillon Exp $
+ * $DragonFly: src/usr.bin/make/arch.c,v 1.14 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -137,7 +137,7 @@ static int ArchSVR4Entry(Arch *, char *, size_t, FILE *);
 static void
 ArchFree(void *ap)
 {
-    Arch *a = (Arch *) ap;
+    Arch *a = (Arch *)ap;
     Hash_Search          search;
     Hash_Entry   *entry;
 
@@ -153,8 +153,6 @@ ArchFree(void *ap)
     free(a);
 }
 
-
-
 /*-
  *-----------------------------------------------------------------------
  * Arch_ParseArchive --
@@ -175,7 +173,7 @@ ArchFree(void *ap)
  *-----------------------------------------------------------------------
  */
 ReturnStatus
-Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
+Arch_ParseArchive(char **linePtr, Lst nodeLst, GNode *ctxt)
 {
     char            *cp;           /* Pointer into line */
     GNode          *gn;            /* New node */
@@ -200,9 +198,9 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
            Boolean     freeIt;
            char        *result;
 
-           result=Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
+           result = Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
            if (result == var_Error) {
-               return(FAILURE);
+               return (FAILURE);
            } else {
                subLibName = TRUE;
            }
@@ -210,7 +208,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
            if (freeIt) {
                free(result);
            }
-           cp += length-1;
+           cp += length - 1;
        }
     }
 
@@ -228,11 +226,11 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
         */
        Boolean doSubst = FALSE; /* TRUE if need to substitute in memName */
 
-       while (*cp != '\0' && *cp != ')' && isspace ((unsigned char) *cp)) {
+       while (*cp != '\0' && *cp != ')' && isspace((unsigned char)*cp)) {
            cp++;
        }
        memName = cp;
-       while (*cp != '\0' && *cp != ')' && !isspace ((unsigned char) *cp)) {
+       while (*cp != '\0' && *cp != ')' && !isspace((unsigned char)*cp)) {
            if (*cp == '$') {
                /*
                 * Variable spec, so call the Var module to parse the puppy
@@ -244,7 +242,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
 
                result=Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
                if (result == var_Error) {
-                   return(FAILURE);
+                   return (FAILURE);
                } else {
                    doSubst = TRUE;
                }
@@ -317,18 +315,18 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
 
                if (gn == NULL) {
                    free(buf);
-                   return(FAILURE);
+                   return (FAILURE);
                } else {
                    gn->type |= OP_ARCHV;
-                   (void)Lst_AtEnd(nodeLst, (void *)gn);
+                   Lst_AtEnd(nodeLst, (void *)gn);
                }
-           } else if (Arch_ParseArchive(&sacrifice, nodeLst, ctxt)!=SUCCESS) {
+           } else if (Arch_ParseArchive(&sacrifice, nodeLst, ctxt) != SUCCESS) {
                /*
                 * Error in nested call -- free buffer and return FAILURE
                 * ourselves.
                 */
                free(buf);
-               return(FAILURE);
+               return (FAILURE);
            }
            /*
             * Free buffer and continue with our work.
@@ -352,7 +350,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
                }
                snprintf(nameBuf, sz, "%s(%s)", libName, member);
                free(member);
-               gn = Targ_FindNode (nameBuf, TARG_CREATE);
+               gn = Targ_FindNode(nameBuf, TARG_CREATE);
                if (gn == NULL) {
                    free(nameBuf);
                    return (FAILURE);
@@ -365,7 +363,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
                     * end of the provided list.
                     */
                    gn->type |= OP_ARCHV;
-                   (void) Lst_AtEnd (nodeLst, (void *)gn);
+                   Lst_AtEnd(nodeLst, (void *)gn);
                }
            }
            Lst_Destroy(members, NOFREE);
@@ -374,7 +372,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
            size_t sz = strlen(libName) + strlen(memName) + 3;
            nameBuf = emalloc(sz);
            snprintf(nameBuf, sz, "%s(%s)", libName, memName);
-           gn = Targ_FindNode (nameBuf, TARG_CREATE);
+           gn = Targ_FindNode(nameBuf, TARG_CREATE);
            free(nameBuf);
            if (gn == NULL) {
                return (FAILURE);
@@ -387,7 +385,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
                 * provided list.
                 */
                gn->type |= OP_ARCHV;
-               (void) Lst_AtEnd (nodeLst, (void *)gn);
+               Lst_AtEnd(nodeLst, (void *)gn);
            }
        }
        if (doSubst) {
@@ -411,7 +409,7 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
      */
     do {
        cp++;
-    } while (*cp != '\0' && isspace ((unsigned char) *cp));
+    } while (*cp != '\0' && isspace((unsigned char)*cp));
 
     *linePtr = cp;
     return (SUCCESS);
@@ -433,9 +431,9 @@ Arch_ParseArchive (char **linePtr, Lst nodeLst, GNode *ctxt)
  *-----------------------------------------------------------------------
  */
 static int
-ArchFindArchive (void *ar, void *archName)
+ArchFindArchive(void *ar, void *archName)
 {
-    return (strcmp ((char *) archName, ((Arch *) ar)->name));
+    return (strcmp((char *)archName, ((Arch *)ar)->name));
 }
 
 /*-
@@ -457,9 +455,9 @@ ArchFindArchive (void *ar, void *archName)
  *-----------------------------------------------------------------------
  */
 static struct ar_hdr *
-ArchStatMember (char *archive, char *member, Boolean hash)
+ArchStatMember(char *archive, char *member, Boolean hash)
 {
-#define        AR_MAX_NAME_LEN     (sizeof(arh.ar_name)-1)
+#define        AR_MAX_NAME_LEN     (sizeof(arh.ar_name) - 1)
     FILE *       arch;       /* Stream to archive */
     int                  size;       /* Size of archive member */
     char         *cp;        /* Useful character pointer */
@@ -477,30 +475,30 @@ ArchStatMember (char *archive, char *member, Boolean hash)
      * to point 'member' to the final component, if there is one, to make
      * the comparisons easier...
      */
-    cp = strrchr (member, '/');
+    cp = strrchr(member, '/');
     if ((cp != NULL) && (strcmp(member, RANLIBMAG) != 0))
        member = cp + 1;
 
-    ln = Lst_Find (archives, (void *) archive, ArchFindArchive);
+    ln = Lst_Find(archives, (void *)archive, ArchFindArchive);
     if (ln != NULL) {
-       ar = (Arch *) Lst_Datum (ln);
+       ar = (Arch *)Lst_Datum(ln);
 
-       he = Hash_FindEntry (&ar->members, member);
+       he = Hash_FindEntry(&ar->members, member);
 
        if (he != NULL) {
-           return ((struct ar_hdr *) Hash_GetValue (he));
+           return ((struct ar_hdr *)Hash_GetValue (he));
        } else {
            /* Try truncated name */
-           char copy[AR_MAX_NAME_LEN+1];
-           size_t len = strlen (member);
+           char copy[AR_MAX_NAME_LEN + 1];
+           size_t len = strlen(member);
 
            if (len > AR_MAX_NAME_LEN) {
                len = AR_MAX_NAME_LEN;
                strncpy(copy, member, AR_MAX_NAME_LEN);
                copy[AR_MAX_NAME_LEN] = '\0';
            }
-           if ((he = Hash_FindEntry (&ar->members, copy)) != NULL)
-               return ((struct ar_hdr *) Hash_GetValue (he));
+           if ((he = Hash_FindEntry(&ar->members, copy)) != NULL)
+               return ((struct ar_hdr *)Hash_GetValue(he));
            return (NULL);
        }
     }
@@ -529,7 +527,7 @@ ArchStatMember (char *archive, char *member, Boolean hash)
      * We don't have this archive on the list yet, so we want to find out
      * everything that's in it and cache it so we can get at it quickly.
      */
-    arch = fopen (archive, "r");
+    arch = fopen(archive, "r");
     if (arch == NULL) {
        return (NULL);
     }
@@ -538,21 +536,21 @@ ArchStatMember (char *archive, char *member, Boolean hash)
      * We use the ARMAG string to make sure this is an archive we
      * can handle...
      */
-    if ((fread (magic, SARMAG, 1, arch) != 1) ||
-       (strncmp (magic, ARMAG, SARMAG) != 0)) {
-           fclose (arch);
+    if ((fread(magic, SARMAG, 1, arch) != 1) ||
+       (strncmp(magic, ARMAG, SARMAG) != 0)) {
+           fclose(arch);
            return (NULL);
     }
 
-    ar = (Arch *)emalloc (sizeof (Arch));
-    ar->name = estrdup (archive);
+    ar = (Arch *)emalloc(sizeof(Arch));
+    ar->name = estrdup(archive);
     ar->fnametab = NULL;
     ar->fnamesize = 0;
-    Hash_InitTable (&ar->members, -1);
+    Hash_InitTable(&ar->members, -1);
     memName[AR_MAX_NAME_LEN] = '\0';
 
-    while (fread ((char *)&arh, sizeof (struct ar_hdr), 1, arch) == 1) {
-       if (strncmp ( arh.ar_fmag, ARFMAG, sizeof (arh.ar_fmag)) != 0) {
+    while (fread((char *)&arh, sizeof(struct ar_hdr), 1, arch) == 1) {
+       if (strncmp(arh.ar_fmag, ARFMAG, sizeof(arh.ar_fmag)) != 0) {
            /*
             * The header is bogus, so the archive is bad
             * and there's no way we can recover...
@@ -565,10 +563,10 @@ ArchStatMember (char *archive, char *member, Boolean hash)
             * boundary, so we need to extract the size of the file from the
             * 'size' field of the header and round it up during the seek.
             */
-           arh.ar_size[sizeof(arh.ar_size)-1] = '\0';
-           size = (int) strtol(arh.ar_size, NULL, 10);
+           arh.ar_size[sizeof(arh.ar_size) - 1] = '\0';
+           size = (int)strtol(arh.ar_size, NULL, 10);
 
-           (void) strncpy (memName, arh.ar_name, sizeof(arh.ar_name));
+           strncpy(memName, arh.ar_name, sizeof(arh.ar_name));
            for (cp = &memName[AR_MAX_NAME_LEN]; *cp == ' '; cp--) {
                continue;
            }
@@ -609,10 +607,10 @@ ArchStatMember (char *archive, char *member, Boolean hash)
 
                if (elen > MAXPATHLEN)
                        goto badarch;
-               if (fread (memName, elen, 1, arch) != 1)
+               if (fread(memName, elen, 1, arch) != 1)
                        goto badarch;
                memName[elen] = '\0';
-               fseek (arch, -elen, SEEK_CUR);
+               fseek(arch, -elen, SEEK_CUR);
                /* XXX Multiple levels may be asked for, make this conditional
                 * on one, and use DEBUGF.
                 */
@@ -622,35 +620,35 @@ ArchStatMember (char *archive, char *member, Boolean hash)
            }
 #endif
 
-           he = Hash_CreateEntry (&ar->members, memName, NULL);
-           Hash_SetValue (he, (void *)emalloc (sizeof (struct ar_hdr)));
-           memcpy (Hash_GetValue (he), &arh,
-               sizeof (struct ar_hdr));
+           he = Hash_CreateEntry(&ar->members, memName, NULL);
+           Hash_SetValue(he, (void *)emalloc (sizeof(struct ar_hdr)));
+           memcpy(Hash_GetValue(he), &arh,
+               sizeof(struct ar_hdr));
        }
-       fseek (arch, (size + 1) & ~1, SEEK_CUR);
+       fseek(arch, (size + 1) & ~1, SEEK_CUR);
     }
 
-    fclose (arch);
+    fclose(arch);
 
-    (void) Lst_AtEnd (archives, (void *) ar);
+    Lst_AtEnd(archives, (void *)ar);
 
     /*
      * Now that the archive has been read and cached, we can look into
      * the hash table to find the desired member's header.
      */
-    he = Hash_FindEntry (&ar->members, member);
+    he = Hash_FindEntry(&ar->members, member);
 
     if (he != NULL) {
-       return ((struct ar_hdr *) Hash_GetValue (he));
+       return ((struct ar_hdr *)Hash_GetValue (he));
     } else {
        return (NULL);
     }
 
 badarch:
-    fclose (arch);
-    Hash_DeleteTable (&ar->members);
+    fclose(arch);
+    Hash_DeleteTable(&ar->members);
     free(ar->fnametab);
-    free (ar);
+    free(ar);
     return (NULL);
 }
 
@@ -688,7 +686,7 @@ ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
 
        if (ar->fnametab != NULL) {
            DEBUGF(ARCH, ("Attempted to redefine an SVR4 name table\n"));
-           return -1;
+           return (-1);
        }
 
        /*
@@ -700,7 +698,7 @@ ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
 
        if (fread(ar->fnametab, size, 1, arch) != 1) {
            DEBUGF(ARCH, ("Reading an SVR4 name table failed\n"));
-           return -1;
+           return (-1);
        }
        eptr = ar->fnametab + size;
        for (entry = 0, ptr = ar->fnametab; ptr < eptr; ptr++)
@@ -717,28 +715,28 @@ ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
                break;
            }
        DEBUGF(ARCH, ("Found svr4 archive name table with %zu entries\n", entry));
-       return 0;
+       return (0);
     }
 
     if (name[1] == ' ' || name[1] == '\0')
-       return 2;
+       return (2);
 
-    entry = (size_t) strtol(&name[1], &eptr, 0);
+    entry = (size_t)strtol(&name[1], &eptr, 0);
     if ((*eptr != ' ' && *eptr != '\0') || eptr == &name[1]) {
        DEBUGF(ARCH, ("Could not parse SVR4 name %s\n", name));
-       return 2;
+       return (2);
     }
     if (entry >= ar->fnamesize) {
        DEBUGF(ARCH, ("SVR4 entry offset %s is greater than %zu\n",
                name, ar->fnamesize));
-       return 2;
+       return (2);
     }
 
     DEBUGF(ARCH, ("Replaced %s with %s\n", name, &ar->fnametab[entry]));
 
-    (void) strncpy(name, &ar->fnametab[entry], MAXPATHLEN);
+    strncpy(name, &ar->fnametab[entry], MAXPATHLEN);
     name[MAXPATHLEN - 1] = '\0';
-    return 1;
+    return (1);
 }
 #endif
 
@@ -762,7 +760,7 @@ ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
  *-----------------------------------------------------------------------
  */
 static FILE *
-ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
+ArchFindMember(char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
 {
     FILE *       arch;       /* Stream to archive */
     int                  size;       /* Size of archive member */
@@ -770,7 +768,7 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
     char         magic[SARMAG];
     size_t       len, tlen;
 
-    arch = fopen (archive, mode);
+    arch = fopen(archive, mode);
     if (arch == NULL) {
        return (NULL);
     }
@@ -779,9 +777,9 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
      * We use the ARMAG string to make sure this is an archive we
      * can handle...
      */
-    if ((fread (magic, SARMAG, 1, arch) != 1) ||
-       (strncmp (magic, ARMAG, SARMAG) != 0)) {
-           fclose (arch);
+    if ((fread(magic, SARMAG, 1, arch) != 1) ||
+       (strncmp(magic, ARMAG, SARMAG) != 0)) {
+           fclose(arch);
            return (NULL);
     }
 
@@ -791,24 +789,24 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
      * to point 'member' to the final component, if there is one, to make
      * the comparisons easier...
      */
-    cp = strrchr (member, '/');
+    cp = strrchr(member, '/');
     if ((cp != NULL) && (strcmp(member, RANLIBMAG) != 0)) {
        member = cp + 1;
     }
-    len = tlen = strlen (member);
-    if (len > sizeof (arhPtr->ar_name)) {
-       tlen = sizeof (arhPtr->ar_name);
+    len = tlen = strlen(member);
+    if (len > sizeof(arhPtr->ar_name)) {
+       tlen = sizeof(arhPtr->ar_name);
     }
 
-    while (fread ((char *)arhPtr, sizeof (struct ar_hdr), 1, arch) == 1) {
-       if (strncmp(arhPtr->ar_fmag, ARFMAG, sizeof (arhPtr->ar_fmag) ) != 0) {
+    while (fread((char *)arhPtr, sizeof(struct ar_hdr), 1, arch) == 1) {
+       if (strncmp(arhPtr->ar_fmag, ARFMAG, sizeof(arhPtr->ar_fmag) ) != 0) {
             /*
              * The header is bogus, so the archive is bad
              * and there's no way we can recover...
              */
-            fclose (arch);
+            fclose(arch);
             return (NULL);
-       } else if (strncmp (member, arhPtr->ar_name, tlen) == 0) {
+       } else if (strncmp(member, arhPtr->ar_name, tlen) == 0) {
            /*
             * If the member's name doesn't take up the entire 'name' field,
             * we have to be careful of matching prefixes. Names are space-
@@ -826,7 +824,7 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
                 * the file at the actual member, rather than its header, but
                 * not here...
                 */
-               fseek (arch, -sizeof(struct ar_hdr), SEEK_CUR);
+               fseek(arch, -sizeof(struct ar_hdr), SEEK_CUR);
                return (arch);
            }
        } else
@@ -843,11 +841,11 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
                char ename[MAXPATHLEN];
 
                if (elen > MAXPATHLEN) {
-                       fclose (arch);
+                       fclose(arch);
                        return NULL;
                }
-               if (fread (ename, elen, 1, arch) != 1) {
-                       fclose (arch);
+               if (fread(ename, elen, 1, arch) != 1) {
+                       fclose(arch);
                        return NULL;
                }
                ename[elen] = '\0';
@@ -859,10 +857,10 @@ ArchFindMember (char *archive, char *member, struct ar_hdr *arhPtr, char *mode)
                }
                if (strncmp(ename, member, len) == 0) {
                        /* Found as extended name */
-                       fseek (arch, -sizeof(struct ar_hdr) - elen, SEEK_CUR);
+                       fseek(arch, -sizeof(struct ar_hdr) - elen, SEEK_CUR);
                        return (arch);
                }
-               fseek (arch, -elen, SEEK_CUR);
+               fseek(arch, -elen, SEEK_CUR);
                goto skip;
        } else
 #endif
@@ -875,9 +873,9 @@ skip:
             * extract the size of the file from the 'size' field of the
             * header and round it up during the seek.
             */
-           arhPtr->ar_size[sizeof(arhPtr->ar_size)-1] = '\0';
-           size = (int) strtol(arhPtr->ar_size, NULL, 10);
-           fseek (arch, (size + 1) & ~1, SEEK_CUR);
+           arhPtr->ar_size[sizeof(arhPtr->ar_size) - 1] = '\0';
+           size = (int)strtol(arhPtr->ar_size, NULL, 10);
+           fseek(arch, (size + 1) & ~1, SEEK_CUR);
        }
     }
 
@@ -885,7 +883,7 @@ skip:
      * We've looked everywhere, but the member is not to be found. Close the
      * archive and return NULL -- an error.
      */
-    fclose (arch);
+    fclose(arch);
     return (NULL);
 }
 
@@ -905,22 +903,22 @@ skip:
  *-----------------------------------------------------------------------
  */
 void
-Arch_Touch (GNode *gn)
+Arch_Touch(GNode *gn)
 {
     FILE *       arch;   /* Stream open to archive, positioned properly */
     struct ar_hdr arh;   /* Current header describing member */
     char *p1, *p2;
 
-    arch = ArchFindMember(Var_Value (ARCHIVE, gn, &p1),
-                         Var_Value (TARGET, gn, &p2),
+    arch = ArchFindMember(Var_Value(ARCHIVE, gn, &p1),
+                         Var_Value(TARGET, gn, &p2),
                          &arh, "r+");
     free(p1);
     free(p2);
-    snprintf(arh.ar_date, sizeof(arh.ar_date), "%-12ld", (long) now);
+    snprintf(arh.ar_date, sizeof(arh.ar_date), "%-12ld", (long)now);
 
     if (arch != NULL) {
-       (void)fwrite ((char *)&arh, sizeof (struct ar_hdr), 1, arch);
-       fclose (arch);
+       fwrite((char *)&arh, sizeof(struct ar_hdr), 1, arch);
+       fclose(arch);
     }
 }
 
@@ -940,19 +938,19 @@ Arch_Touch (GNode *gn)
  *-----------------------------------------------------------------------
  */
 void
-Arch_TouchLib (GNode *gn)
+Arch_TouchLib(GNode *gn)
 {
 #ifdef RANLIBMAG
     FILE *         arch;       /* Stream open to archive */
     struct ar_hdr   arh;       /* Header describing table of contents */
     struct utimbuf  times;     /* Times for utime() call */
 
-    arch = ArchFindMember (gn->path, RANLIBMAG, &arh, "r+");
+    arch = ArchFindMember(gn->path, RANLIBMAG, &arh, "r+");
     snprintf(arh.ar_date, sizeof(arh.ar_date), "%-12ld", (long) now);
 
     if (arch != NULL) {
-       (void)fwrite ((char *)&arh, sizeof (struct ar_hdr), 1, arch);
-       fclose (arch);
+       fwrite((char *)&arh, sizeof(struct ar_hdr), 1, arch);
+       fclose(arch);
 
        times.actime = times.modtime = now;
        utime(gn->path, &times);
@@ -967,7 +965,7 @@ Arch_TouchLib (GNode *gn)
  *     name.
  *
  * Results:
- *     The modification time (seconds).
+ *     The modification time(seconds).
  *
  * Side Effects:
  *     The mtime field of the given node is filled in with the value
@@ -982,14 +980,14 @@ Arch_MTime(GNode *gn)
     int                  modTime;    /* Modification time as an integer */
     char *p1, *p2;
 
-    arhPtr = ArchStatMember (Var_Value (ARCHIVE, gn, &p1),
-                            Var_Value (TARGET, gn, &p2),
+    arhPtr = ArchStatMember(Var_Value(ARCHIVE, gn, &p1),
+                            Var_Value(TARGET, gn, &p2),
                             TRUE);
     free(p1);
     free(p2);
 
     if (arhPtr != NULL) {
-       modTime = (int) strtol(arhPtr->ar_date, NULL, 10);
+       modTime = (int)strtol(arhPtr->ar_date, NULL, 10);
     } else {
        modTime = 0;
     }
@@ -1013,19 +1011,19 @@ Arch_MTime(GNode *gn)
  *-----------------------------------------------------------------------
  */
 int
-Arch_MemMTime (GNode *gn)
+Arch_MemMTime(GNode *gn)
 {
     LstNode      ln;
     GNode        *pgn;
     char         *nameStart,
                  *nameEnd;
 
-    if (Lst_Open (gn->parents) != SUCCESS) {
+    if (Lst_Open(gn->parents) != SUCCESS) {
        gn->mtime = 0;
        return (0);
     }
-    while ((ln = Lst_Next (gn->parents)) != NULL) {
-       pgn = (GNode *) Lst_Datum (ln);
+    while ((ln = Lst_Next(gn->parents)) != NULL) {
+       pgn = (GNode *)Lst_Datum(ln);
 
        if (pgn->type & OP_ARCHV) {
            /*
@@ -1035,8 +1033,8 @@ Arch_MemMTime (GNode *gn)
             * child. We keep searching its parents in case some other
             * parent requires this child to exist...
             */
-           nameStart = strchr (pgn->name, '(') + 1;
-           nameEnd = strchr (nameStart, ')');
+           nameStart = strchr(pgn->name, '(') + 1;
+           nameEnd = strchr(nameStart, ')');
 
            if (pgn->make &&
                strncmp(nameStart, gn->name, nameEnd - nameStart) == 0) {
@@ -1052,7 +1050,7 @@ Arch_MemMTime (GNode *gn)
        }
     }
 
-    Lst_Close (gn->parents);
+    Lst_Close(gn->parents);
 
     return (gn->mtime);
 }
@@ -1078,7 +1076,7 @@ Arch_MemMTime (GNode *gn)
  *-----------------------------------------------------------------------
  */
 void
-Arch_FindLib (GNode *gn, Lst path)
+Arch_FindLib(GNode *gn, Lst path)
 {
     char           *libName;   /* file name for archive */
     size_t         sz;
@@ -1087,14 +1085,14 @@ Arch_FindLib (GNode *gn, Lst path)
     libName = (char *)emalloc(sz);
     snprintf(libName, sz, "lib%s.a", &gn->name[2]);
 
-    gn->path = Dir_FindFile (libName, path);
+    gn->path = Dir_FindFile(libName, path);
 
-    free (libName);
+    free(libName);
 
 #ifdef LIBRARIES
-    Var_Set (TARGET, gn->name, gn);
+    Var_Set(TARGET, gn->name, gn);
 #else
-    Var_Set (TARGET, gn->path == NULL ? gn->name : gn->path, gn);
+    Var_Set(TARGET, gn->path == NULL ? gn->name : gn->path, gn);
 #endif /* LIBRARIES */
 }
 
@@ -1136,7 +1134,7 @@ Arch_FindLib (GNode *gn, Lst path)
  *-----------------------------------------------------------------------
  */
 Boolean
-Arch_LibOODate (GNode *gn)
+Arch_LibOODate(GNode *gn)
 {
     Boolean      oodate;
 
@@ -1149,10 +1147,10 @@ Arch_LibOODate (GNode *gn)
        struct ar_hdr   *arhPtr;    /* Header for __.SYMDEF */
        int             modTimeTOC; /* The table-of-contents's mod time */
 
-       arhPtr = ArchStatMember (gn->path, RANLIBMAG, FALSE);
+       arhPtr = ArchStatMember(gn->path, RANLIBMAG, FALSE);
 
        if (arhPtr != NULL) {
-           modTimeTOC = (int) strtol(arhPtr->ar_date, NULL, 10);
+           modTimeTOC = (int)strtol(arhPtr->ar_date, NULL, 10);
 
            /* XXX choose one. */
            if (DEBUG(ARCH) || DEBUG(MAKE)) {
@@ -1189,13 +1187,11 @@ Arch_LibOODate (GNode *gn)
  *-----------------------------------------------------------------------
  */
 void
-Arch_Init (void)
+Arch_Init(void)
 {
-    archives = Lst_Init (FALSE);
+    archives = Lst_Init(FALSE);
 }
 
-
-
 /*-
  *-----------------------------------------------------------------------
  * Arch_End --
@@ -1210,7 +1206,7 @@ Arch_Init (void)
  *-----------------------------------------------------------------------
  */
 void
-Arch_End (void)
+Arch_End(void)
 {
     Lst_Destroy(archives, ArchFree);
 }
index 0bb38ce..b4c214e 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)buf.c   8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/buf.c,v 1.11 1999/09/11 13:08:01 hoek Exp $
- * $DragonFly: src/usr.bin/make/buf.c,v 1.6 2004/11/18 02:01:39 dillon Exp $
+ * $DragonFly: src/usr.bin/make/buf.c,v 1.7 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -63,8 +63,8 @@
  */
 #define        BufExpand(bp,nb) \
        if (bp->left < (nb)+1) {\
-           int newSize = (bp)->size + max((nb)+1,BUF_ADD_INC); \
-           Byte  *newBuf = (Byte *) erealloc((bp)->buffer, newSize); \
+           int newSize = (bp)->size + max((nb) + 1, BUF_ADD_INC); \
+           Byte  *newBuf = (Byte *)erealloc((bp)->buffer, newSize); \
            \
            (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer); \
            (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer);\
  *-----------------------------------------------------------------------
  */
 void
-Buf_OvAddByte (Buffer bp, int byte)
+Buf_OvAddByte(Buffer bp, int byte)
 {
     bp->left = 0;
-    BufExpand (bp, 1);
+    BufExpand(bp, 1);
 
     *bp->inPtr++ = byte;
     bp->left--;
@@ -104,7 +104,7 @@ Buf_OvAddByte (Buffer bp, int byte)
      */
     *bp->inPtr = 0;
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_AddBytes --
@@ -119,12 +119,12 @@ Buf_OvAddByte (Buffer bp, int byte)
  *-----------------------------------------------------------------------
  */
 void
-Buf_AddBytes (Buffer bp, int numBytes, const Byte *bytesPtr)
+Buf_AddBytes(Buffer bp, int numBytes, const Byte *bytesPtr)
 {
 
-    BufExpand (bp, numBytes);
+    BufExpand(bp, numBytes);
 
-    memcpy (bp->inPtr, bytesPtr, numBytes);
+    memcpy(bp->inPtr, bytesPtr, numBytes);
     bp->inPtr += numBytes;
     bp->left -= numBytes;
 
@@ -133,7 +133,7 @@ Buf_AddBytes (Buffer bp, int numBytes, const Byte *bytesPtr)
      */
     *bp->inPtr = 0;
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_UngetByte --
@@ -148,7 +148,7 @@ Buf_AddBytes (Buffer bp, int numBytes, const Byte *bytesPtr)
  *-----------------------------------------------------------------------
  */
 void
-Buf_UngetByte (Buffer bp, int byte)
+Buf_UngetByte(Buffer bp, int byte)
 {
 
     if (bp->outPtr != bp->buffer) {
@@ -170,10 +170,11 @@ Buf_UngetByte (Buffer bp, int byte)
        Byte      *newBuf;
 
        newBuf = (Byte *)emalloc(bp->size + BUF_UNGET_INC);
-       memcpy ((char *)(newBuf+BUF_UNGET_INC), (char *)bp->outPtr, numBytes+1);
+       memcpy((char *)(newBuf+BUF_UNGET_INC), (char *)bp->outPtr,
+           numBytes + 1);
        bp->outPtr = newBuf + BUF_UNGET_INC;
        bp->inPtr = bp->outPtr + numBytes;
-       free ((char *)bp->buffer);
+       free((char *)bp->buffer);
        bp->buffer = newBuf;
        bp->size += BUF_UNGET_INC;
        bp->left = bp->size - (bp->inPtr - bp->buffer);
@@ -181,7 +182,7 @@ Buf_UngetByte (Buffer bp, int byte)
        *bp->outPtr = byte;
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_UngetBytes --
@@ -196,32 +197,32 @@ Buf_UngetByte (Buffer bp, int byte)
  *-----------------------------------------------------------------------
  */
 void
-Buf_UngetBytes (Buffer bp, int numBytes, Byte *bytesPtr)
+Buf_UngetBytes(Buffer bp, int numBytes, Byte *bytesPtr)
 {
 
     if (bp->outPtr - bp->buffer >= numBytes) {
        bp->outPtr -= numBytes;
-       memcpy (bp->outPtr, bytesPtr, numBytes);
+       memcpy(bp->outPtr, bytesPtr, numBytes);
     } else if (bp->outPtr == bp->inPtr) {
-       Buf_AddBytes (bp, numBytes, bytesPtr);
+       Buf_AddBytes(bp, numBytes, bytesPtr);
     } else {
        int       curNumBytes = bp->inPtr - bp->outPtr;
        Byte      *newBuf;
        int       newBytes = max(numBytes,BUF_UNGET_INC);
 
        newBuf = (Byte *)emalloc (bp->size + newBytes);
-       memcpy((char *)(newBuf+newBytes), (char *)bp->outPtr, curNumBytes+1);
+       memcpy((char *)(newBuf+newBytes), (char *)bp->outPtr, curNumBytes + 1);
        bp->outPtr = newBuf + newBytes;
        bp->inPtr = bp->outPtr + curNumBytes;
-       free ((char *)bp->buffer);
+       free((char *)bp->buffer);
        bp->buffer = newBuf;
        bp->size += newBytes;
        bp->left = bp->size - (bp->inPtr - bp->buffer);
        bp->outPtr -= numBytes;
-       memcpy ((char *)bp->outPtr, (char *)bytesPtr, numBytes);
+       memcpy((char *)bp->outPtr, (char *)bytesPtr, numBytes);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_GetByte --
@@ -238,14 +239,14 @@ Buf_UngetBytes (Buffer bp, int numBytes, Byte *bytesPtr)
  *-----------------------------------------------------------------------
  */
 int
-Buf_GetByte (Buffer bp)
+Buf_GetByte(Buffer bp)
 {
     int            res;
 
     if (bp->inPtr == bp->outPtr) {
        return (BUF_ERROR);
     } else {
-       res = (int) *bp->outPtr;
+       res = (int)*bp->outPtr;
        bp->outPtr += 1;
        if (bp->outPtr == bp->inPtr) {
            bp->outPtr = bp->inPtr = bp->buffer;
@@ -255,7 +256,7 @@ Buf_GetByte (Buffer bp)
        return (res);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_GetBytes --
@@ -270,13 +271,13 @@ Buf_GetByte (Buffer bp)
  *-----------------------------------------------------------------------
  */
 int
-Buf_GetBytes (Buffer bp, int numBytes, Byte *bytesPtr)
+Buf_GetBytes(Buffer bp, int numBytes, Byte *bytesPtr)
 {
 
     if (bp->inPtr - bp->outPtr < numBytes) {
        numBytes = bp->inPtr - bp->outPtr;
     }
-    memcpy (bytesPtr, bp->outPtr, numBytes);
+    memcpy(bytesPtr, bp->outPtr, numBytes);
     bp->outPtr += numBytes;
 
     if (bp->outPtr == bp->inPtr) {
@@ -286,7 +287,7 @@ Buf_GetBytes (Buffer bp, int numBytes, Byte *bytesPtr)
     }
     return (numBytes);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_GetAll --
@@ -301,7 +302,7 @@ Buf_GetBytes (Buffer bp, int numBytes, Byte *bytesPtr)
  *-----------------------------------------------------------------------
  */
 Byte *
-Buf_GetAll (Buffer bp, int *numBytesPtr)
+Buf_GetAll(Buffer bp, int *numBytesPtr)
 {
 
     if (numBytesPtr != (int *)NULL) {
@@ -310,7 +311,7 @@ Buf_GetAll (Buffer bp, int *numBytesPtr)
 
     return (bp->outPtr);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_Discard --
@@ -325,7 +326,7 @@ Buf_GetAll (Buffer bp, int *numBytesPtr)
  *-----------------------------------------------------------------------
  */
 void
-Buf_Discard (Buffer bp, int numBytes)
+Buf_Discard(Buffer bp, int numBytes)
 {
 
     if (bp->inPtr - bp->outPtr <= numBytes) {
@@ -336,7 +337,7 @@ Buf_Discard (Buffer bp, int numBytes)
        bp->outPtr += numBytes;
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_Size --
@@ -352,11 +353,11 @@ Buf_Discard (Buffer bp, int numBytes)
  *-----------------------------------------------------------------------
  */
 int
-Buf_Size (Buffer buf)
+Buf_Size(Buffer buf)
 {
     return (buf->inPtr - buf->outPtr);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_Init --
@@ -373,7 +374,7 @@ Buf_Size (Buffer buf)
  *-----------------------------------------------------------------------
  */
 Buffer
-Buf_Init (int size)
+Buf_Init(int size)
 {
     Buffer bp;         /* New Buffer */
 
@@ -389,7 +390,7 @@ Buf_Init (int size)
 
     return (bp);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_Destroy --
@@ -404,15 +405,15 @@ Buf_Init (int size)
  *-----------------------------------------------------------------------
  */
 void
-Buf_Destroy (Buffer buf, Boolean freeData)
+Buf_Destroy(Buffer buf, Boolean freeData)
 {
 
     if (freeData) {
-       free ((char *)buf->buffer);
+       free((char *)buf->buffer);
     }
-    free ((char *)buf);
+    free((char *)buf);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Buf_ReplaceLastByte --
@@ -428,7 +429,7 @@ Buf_Destroy (Buffer buf, Boolean freeData)
  *-----------------------------------------------------------------------
  */
 void
-Buf_ReplaceLastByte (Buffer buf, int byte)
+Buf_ReplaceLastByte(Buffer buf, int byte)
 {
     if (buf->inPtr == buf->outPtr)
         Buf_AddByte(buf, byte);
index 36abf51..2d2ded6 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     from: @(#)buf.h 8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/buf.h,v 1.9 1999/08/28 01:03:26 peter Exp $
- * $DragonFly: src/usr.bin/make/buf.h,v 1.5 2004/11/12 22:42:36 dillon Exp $
+ * $DragonFly: src/usr.bin/make/buf.h,v 1.6 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -63,7 +63,7 @@ typedef struct Buffer {
 
 /* Buf_AddByte adds a single byte to a buffer. */
 #define        Buf_AddByte(bp, byte) \
-       (void) (--(bp)->left <= 0 ? Buf_OvAddByte(bp, byte), 1 : \
+       (void)(--(bp)->left <= 0 ? Buf_OvAddByte(bp, byte), 1 : \
                (*(bp)->inPtr++ = (byte), *(bp)->inPtr = 0), 1)
 
 #define        BUF_ERROR 256
index 76b20f1..28354aa 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)compat.c        8.2 (Berkeley) 3/19/94
  * $FreeBSD: src/usr.bin/make/compat.c,v 1.16.2.2 2000/07/01 12:24:21 ps Exp $
- * $DragonFly: src/usr.bin/make/Attic/compat.c,v 1.15 2004/12/10 01:03:46 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/Attic/compat.c,v 1.16 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -84,8 +84,8 @@ static void CompatInterrupt(int);
 static int CompatMake(void *, void *);
 static int shellneed(char *);
 
-static char *sh_builtin[] = { 
-       "alias", "cd", "eval", "exec", "exit", "read", "set", "ulimit", 
+static char *sh_builtin[] = {
+       "alias", "cd", "eval", "exec", "exit", "read", "set", "ulimit",
        "unalias", "umask", "unset", "wait", ":", 0};
 
 static void
@@ -94,7 +94,7 @@ CompatInit(void)
     char         *cp;      /* Pointer to string of shell meta-characters */
 
     for (cp = "#=|^(){};&<>*?[]:$`\\\n"; *cp != '\0'; cp++) {
-       meta[(unsigned char) *cp] = 1;
+       meta[(unsigned char)*cp] = 1;
     }
     /*
      * The null character serves as a sentinel in the string.
@@ -143,12 +143,12 @@ CompatInterrupt (int signo)
     /* prevent recursion in evaluation of .INTERRUPT */
     interrupted = 0;
 
-    if ((curTarg != NULL) && !Targ_Precious (curTarg)) {
+    if ((curTarg != NULL) && !Targ_Precious(curTarg)) {
        char      *p1;
-       char      *file = Var_Value (TARGET, curTarg, &p1);
+       char      *file = Var_Value(TARGET, curTarg, &p1);
 
        if (!noExecute && eunlink(file) != -1) {
-           printf ("*** %s removed\n", file);
+           printf("*** %s removed\n", file);
        }
        free(p1);
     }
@@ -167,21 +167,21 @@ CompatInterrupt (int signo)
 
     if (signo == SIGQUIT)
        exit(signo);
-    (void) signal(signo, SIG_DFL);
-    (void) kill(getpid(), signo);
+    signal(signo, SIG_DFL);
+    kill(getpid(), signo);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * shellneed --
- *     
+ *
  * Results:
  *     Returns 1 if a specified line must be executed by the shell,
  *     0 if it can be run via execve, and -1 if the command is a no-op.
  *
  * Side Effects:
  *     None.
- *     
+ *
  *-----------------------------------------------------------------------
  */
 static int
@@ -196,7 +196,7 @@ shellneed (char *cmd)
                        return (1);
        return (0);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Compat_RunCommand --
@@ -213,7 +213,7 @@ shellneed (char *cmd)
  *-----------------------------------------------------------------------
  */
 int
-Compat_RunCommand (void *cmdp, void *gnp)
+Compat_RunCommand(void *cmdp, void *gnp)
 {
     char         *cmdStart;    /* Start of expanded command */
     char         *cp;
@@ -229,8 +229,8 @@ Compat_RunCommand (void *cmdp, void *gnp)
     int                  argc;         /* Number of arguments in av or 0 if not
                                 * dynamically allocated */
     int                  internal;     /* Various values.. */
-    char         *cmd = (char *) cmdp;
-    GNode        *gn = (GNode *) gnp;
+    char         *cmd = (char *)cmdp;
+    GNode        *gn = (GNode *)gnp;
 
     /*
      * Avoid clobbered variable warnings by forcing the compiler
@@ -244,8 +244,8 @@ Compat_RunCommand (void *cmdp, void *gnp)
     errCheck = !(gn->type & OP_IGNORE);
     doit = FALSE;
 
-    cmdNode = Lst_Member (gn->commands, (void *)cmd);
-    cmdStart = Var_Subst (NULL, cmd, gn, FALSE);
+    cmdNode = Lst_Member(gn->commands, (void *)cmd);
+    cmdStart = Var_Subst(NULL, cmd, gn, FALSE);
 
     /*
      * brk_string will return an argv with a NULL in av[0], thus causing
@@ -257,18 +257,18 @@ Compat_RunCommand (void *cmdp, void *gnp)
     if (*cmdStart == '\0') {
        free(cmdStart);
        Error("%s expands to empty string", cmd);
-       return(0);
+       return (0);
     } else {
        cmd = cmdStart;
     }
     Lst_Replace (cmdNode, (void *)cmdStart);
 
     if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
-       (void)Lst_AtEnd(ENDNode->commands, (void *)cmdStart);
-       return(0);
+       Lst_AtEnd(ENDNode->commands, (void *)cmdStart);
+       return (0);
     } else if (strcmp(cmdStart, "...") == 0) {
        gn->type |= OP_SAVE_CMDS;
-       return(0);
+       return (0);
     }
 
     while ((*cmd == '@') || (*cmd == '-') || (*cmd == '+')) {
@@ -308,7 +308,7 @@ Compat_RunCommand (void *cmdp, void *gnp)
      * this one. We also print the command if -n given, but not if '+'.
      */
     if (!silent || (noExecute && !doit)) {
-       printf ("%s\n", cmd);
+       printf("%s\n", cmd);
        fflush(stdout);
     }
 
@@ -373,22 +373,22 @@ Compat_RunCommand (void *cmdp, void *gnp)
     }
     if (cpid == 0) {
        execvp(av[0], av);
-       (void) write (STDERR_FILENO, av[0], strlen (av[0]));
-       (void) write (STDERR_FILENO, ":", 1);
-       (void) write (STDERR_FILENO, strerror(errno), strlen(strerror(errno)));
-       (void) write (STDERR_FILENO, "\n", 1);
+       write(STDERR_FILENO, av[0], strlen (av[0]));
+       write(STDERR_FILENO, ":", 1);
+       write(STDERR_FILENO, strerror(errno), strlen(strerror(errno)));
+       write(STDERR_FILENO, "\n", 1);
        exit(1);
     }
 
-    /* 
+    /*
      * we need to print out the command associated with this Gnode in
      * Targ_PrintCmd from Targ_PrintGraph when debugging at level g2,
      * in main(), Fatal() and DieHorribly(), therefore do not free it
-     * when debugging. 
+     * when debugging.
      */
     if (!DEBUG(GRAPH2)) {
        free(cmdStart);
-       Lst_Replace (cmdNode, cmdp);
+       Lst_Replace(cmdNode, cmdp);
     }
 
     /*
@@ -410,11 +410,11 @@ Compat_RunCommand (void *cmdp, void *gnp)
            } else if (WIFEXITED(reason)) {
                status = WEXITSTATUS(reason);           /* exited */
                if (status != 0) {
-                   printf ("*** Error code %d", status);
+                   printf("*** Error code %d", status);
                }
            } else {
                status = WTERMSIG(reason);              /* signaled */
-               printf ("*** Signal %d", status);
+               printf("*** Signal %d", status);
            }
 
 
@@ -426,27 +426,27 @@ Compat_RunCommand (void *cmdp, void *gnp)
                         * Abort the current target, but let others
                         * continue.
                         */
-                       printf (" (continuing)\n");
+                       printf(" (continuing)\n");
                    }
                } else {
                    /*
                     * Continue executing commands for this target.
                     * If we return 0, this will happen...
                     */
-                   printf (" (ignored)\n");
+                   printf(" (ignored)\n");
                    status = 0;
                }
            }
            break;
        } else {
-           Fatal ("error in wait: %d", rstat);
+           Fatal("error in wait: %d", rstat);
            /*NOTREACHED*/
        }
     }
 
     return (status);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CompatMake --
@@ -461,10 +461,11 @@ Compat_RunCommand (void *cmdp, void *gnp)
  *-----------------------------------------------------------------------
  */
 static int
-CompatMake (void *gnp, void *pgnp)
+CompatMake(void *gnp, void *pgnp)
 {
-    GNode *gn = (GNode *) gnp;
-    GNode *pgn = (GNode *) pgnp;
+    GNode *gn = (GNode *)gnp;
+    GNode *pgn = (GNode *)pgnp;
+
     if (gn->type & OP_USE) {
        Make_HandleUse(gn, pgn);
     } else if (gn->made == UNMADE) {
@@ -478,17 +479,17 @@ CompatMake (void *gnp, void *pgnp)
         */
        gn->make = TRUE;
        gn->made = BEINGMADE;
-       Suff_FindDeps (gn);
-       Lst_ForEach (gn->children, CompatMake, (void *)gn);
+       Suff_FindDeps(gn);
+       Lst_ForEach(gn->children, CompatMake, (void *)gn);
        if (!gn->make) {
            gn->made = ABORTED;
            pgn->make = FALSE;
            return (0);
        }
 
-       if (Lst_Member (gn->iParents, pgn) != NULL) {
+       if (Lst_Member(gn->iParents, pgn) != NULL) {
            char *p1;
-           Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
+           Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
            free(p1);
        }
 
@@ -499,7 +500,7 @@ CompatMake (void *gnp, void *pgnp)
         * Make_OODate function.
         */
        DEBUGF(MAKE, ("Examining %s...", gn->name));
-       if (! Make_OODate(gn)) {
+       if (!Make_OODate(gn)) {
            gn->made = UPTODATE;
            DEBUGF(MAKE, ("up-to-date.\n"));
            return (0);
@@ -512,7 +513,7 @@ CompatMake (void *gnp, void *pgnp)
         * to tell him/her "yes".
         */
        if (queryFlag) {
-           exit (1);
+           exit(1);
        }
 
        /*
@@ -526,24 +527,24 @@ CompatMake (void *gnp, void *pgnp)
         * Alter our type to tell if errors should be ignored or things
         * should not be printed so Compat_RunCommand knows what to do.
         */
-       if (Targ_Ignore (gn)) {
+       if (Targ_Ignore(gn)) {
            gn->type |= OP_IGNORE;
        }
-       if (Targ_Silent (gn)) {
+       if (Targ_Silent(gn)) {
            gn->type |= OP_SILENT;
        }
 
-       if (Job_CheckCommands (gn, Fatal)) {
+       if (Job_CheckCommands(gn, Fatal)) {
            /*
             * Our commands are ok, but we still have to worry about the -t
             * flag...
             */
            if (!touchFlag) {
                curTarg = gn;
-               Lst_ForEach (gn->commands, Compat_RunCommand, (void *)gn);
+               Lst_ForEach(gn->commands, Compat_RunCommand, (void *)gn);
                curTarg = NULL;
            } else {
-               Job_Touch (gn, gn->type & OP_SILENT);
+               Job_Touch(gn, gn->type & OP_SILENT);
            }
        } else {
            gn->made = ERROR;
@@ -622,9 +623,9 @@ CompatMake (void *gnp, void *pgnp)
        } else {
            char *p1;
 
-           printf ("\n\nStop in %s.\n", Var_Value(".CURDIR", gn, &p1));
+           printf("\n\nStop in %s.\n", Var_Value(".CURDIR", gn, &p1));
            free(p1);
-           exit (1);
+           exit(1);
        }
     } else if (gn->made == ERROR) {
        /*
@@ -633,9 +634,9 @@ CompatMake (void *gnp, void *pgnp)
         */
        pgn->make = FALSE;
     } else {
-       if (Lst_Member (gn->iParents, pgn) != NULL) {
+       if (Lst_Member(gn->iParents, pgn) != NULL) {
            char *p1;
-           Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
+           Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
            free(p1);
        }
        switch(gn->made) {
@@ -662,7 +663,7 @@ CompatMake (void *gnp, void *pgnp)
 
     return (0);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Compat_Run --
@@ -725,14 +726,14 @@ Compat_Run(Lst targs)
      *                     could not be made due to errors.
      */
     errors = 0;
-    while (!Lst_IsEmpty (targs)) {
-       gn = (GNode *) Lst_DeQueue (targs);
-       CompatMake (gn, gn);
+    while (!Lst_IsEmpty(targs)) {
+       gn = (GNode *)Lst_DeQueue(targs);
+       CompatMake(gn, gn);
 
        if (gn->made == UPTODATE) {
-           printf ("`%s' is up to date.\n", gn->name);
+           printf("`%s' is up to date.\n", gn->name);
        } else if (gn->made == ABORTED) {
-           printf ("`%s' not remade because of errors.\n", gn->name);
+           printf("`%s' not remade because of errors.\n", gn->name);
            errors += 1;
        }
     }
index 53610d8..55588d1 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)cond.c  8.2 (Berkeley) 1/2/94
  * $FreeBSD: src/usr.bin/make/cond.c,v 1.12.2.1 2003/07/22 08:03:13 ru Exp $
- * $DragonFly: src/usr.bin/make/cond.c,v 1.12 2004/12/01 15:17:28 joerg Exp $
+ * $DragonFly: src/usr.bin/make/cond.c,v 1.13 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -154,11 +154,11 @@ static Boolean      skipLine = FALSE;     /* Whether the parse module is skipping
  *-----------------------------------------------------------------------
  */
 static void
-CondPushBack (Token t)
+CondPushBack(Token t)
 {
     condPushBack = t;
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondGetArg --
@@ -175,7 +175,7 @@ CondPushBack (Token t)
  *-----------------------------------------------------------------------
  */
 static int
-CondGetArg (char **linePtr, char **argPtr, char *func, Boolean parens)
+CondGetArg(char **linePtr, char **argPtr, char *func, Boolean parens)
 {
     char         *cp;
     int                  argLen;
@@ -245,7 +245,7 @@ CondGetArg (char **linePtr, char **argPtr, char *func, Boolean parens)
        cp++;
     }
     if (parens && *cp != ')') {
-       Parse_Error (PARSE_WARNING, "Missing closing parenthesis for %s()",
+       Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()",
                     func);
        return (0);
     } else if (parens) {
@@ -258,7 +258,7 @@ CondGetArg (char **linePtr, char **argPtr, char *func, Boolean parens)
     *linePtr = cp;
     return (argLen);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondDoDefined --
@@ -273,14 +273,14 @@ CondGetArg (char **linePtr, char **argPtr, char *func, Boolean parens)
  *-----------------------------------------------------------------------
  */
 static Boolean
-CondDoDefined (int argLen, char *arg)
+CondDoDefined(int argLen, char *arg)
 {
     char    savec = arg[argLen];
     char    *p1;
     Boolean result;
 
     arg[argLen] = '\0';
-    if (Var_Value (arg, VAR_CMD, &p1) != (char *)NULL) {
+    if (Var_Value(arg, VAR_CMD, &p1) != (char *)NULL) {
        result = TRUE;
     } else {
        result = FALSE;
@@ -289,7 +289,7 @@ CondDoDefined (int argLen, char *arg)
     arg[argLen] = savec;
     return (result);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondStrMatch --
@@ -307,9 +307,9 @@ CondDoDefined (int argLen, char *arg)
 static int
 CondStrMatch(void *string, void *pattern)
 {
-    return(!Str_Match((char *) string,(char *) pattern));
+    return (!Str_Match((char *)string, (char *)pattern));
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondDoMake --
@@ -324,13 +324,13 @@ CondStrMatch(void *string, void *pattern)
  *-----------------------------------------------------------------------
  */
 static Boolean
-CondDoMake (int argLen, char *arg)
+CondDoMake(int argLen, char *arg)
 {
     char    savec = arg[argLen];
     Boolean result;
 
     arg[argLen] = '\0';
-    if (Lst_Find (create, (void *)arg, CondStrMatch) == NULL) {
+    if (Lst_Find(create, (void *)arg, CondStrMatch) == NULL) {
        result = FALSE;
     } else {
        result = TRUE;
@@ -338,7 +338,7 @@ CondDoMake (int argLen, char *arg)
     arg[argLen] = savec;
     return (result);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondDoExists --
@@ -353,7 +353,7 @@ CondDoMake (int argLen, char *arg)
  *-----------------------------------------------------------------------
  */
 static Boolean
-CondDoExists (int argLen, char *arg)
+CondDoExists(int argLen, char *arg)
 {
     char    savec = arg[argLen];
     Boolean result;
@@ -370,7 +370,7 @@ CondDoExists (int argLen, char *arg)
     arg[argLen] = savec;
     return (result);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondDoTarget --
@@ -385,7 +385,7 @@ CondDoExists (int argLen, char *arg)
  *-----------------------------------------------------------------------
  */
 static Boolean
-CondDoTarget (int argLen, char *arg)
+CondDoTarget(int argLen, char *arg)
 {
     char    savec = arg[argLen];
     Boolean result;
@@ -402,7 +402,6 @@ CondDoTarget (int argLen, char *arg)
     return (result);
 }
 
-\f
 /*-
  *-----------------------------------------------------------------------
  * CondCvtArg --
@@ -430,12 +429,12 @@ CondCvtArg(char *str, double *value)
 
        for (str += 2, i = 0; ; str++) {
            int x;
-           if (isdigit((unsigned char) *str))
+           if (isdigit((unsigned char)*str))
                x  = *str - '0';
-           else if (isxdigit((unsigned char) *str))
-               x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a';
+           else if (isxdigit((unsigned char)*str))
+               x = 10 + *str - isupper((unsigned char)*str) ? 'A' : 'a';
            else {
-               *value = (double) i;
+               *value = (double)i;
                return str;
            }
            i = (i << 4) + x;
@@ -444,10 +443,10 @@ CondCvtArg(char *str, double *value)
     else {
        char *eptr;
        *value = strtod(str, &eptr);
-       return eptr;
+       return (eptr);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondToken --
@@ -513,17 +512,18 @@ CondToken(Boolean doEval)
                 * value in lhs.
                 */
                t = Err;
-               lhs = Var_Parse(condExpr, VAR_CMD, doEval,&varSpecLen,&doFree);
+               lhs = Var_Parse(condExpr, VAR_CMD, doEval,
+                   &varSpecLen, &doFree);
                if (lhs == var_Error) {
                    /*
                     * Even if !doEval, we still report syntax errors, which
                     * is what getting var_Error back with !doEval means.
                     */
-                   return(Err);
+                   return (Err);
                }
                condExpr += varSpecLen;
 
-               if (!isspace((unsigned char) *condExpr) &&
+               if (!isspace((unsigned char)*condExpr) &&
                    strchr("!=><", *condExpr) == NULL) {
                    Buffer buf;
                    char *cp;
@@ -550,7 +550,7 @@ CondToken(Boolean doEval)
                /*
                 * Skip whitespace to get to the operator
                 */
-               while (isspace((unsigned char) *condExpr))
+               while (isspace((unsigned char)*condExpr))
                    condExpr++;
 
                /*
@@ -576,7 +576,7 @@ CondToken(Boolean doEval)
 
                        goto do_compare;
                }
-               while (isspace((unsigned char) *condExpr)) {
+               while (isspace((unsigned char)*condExpr)) {
                    condExpr++;
                }
                if (*condExpr == '\0') {
@@ -621,7 +621,7 @@ do_string_compare:
                            int len;
                            Boolean freeIt;
 
-                           cp2 = Var_Parse(cp, VAR_CMD, doEval,&len, &freeIt);
+                           cp2 = Var_Parse(cp, VAR_CMD, doEval, &len, &freeIt);
                            if (cp2 != var_Error) {
                                Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
                                if (freeIt) {
@@ -673,7 +673,7 @@ do_string_compare:
                        int     len;
                        Boolean freeIt;
 
-                       string = Var_Parse(rhs, VAR_CMD, doEval,&len,&freeIt);
+                       string = Var_Parse(rhs, VAR_CMD, doEval, &len, &freeIt);
                        if (string == var_Error) {
                            right = 0.0;
                        } else {
@@ -701,7 +701,7 @@ do_string_compare:
 
                    DEBUGF(COND, ("left = %f, right = %f, op = %.2s\n", left,
                           right, op));
-                   switch(op[0]) {
+                   switch (op[0]) {
                    case '!':
                        if (op[1] != '=') {
                            Parse_Error(PARSE_WARNING,
@@ -747,7 +747,7 @@ error:
                char    *arg;
                int     arglen;
 
-               if (strncmp (condExpr, "defined", 7) == 0) {
+               if (strncmp(condExpr, "defined", 7) == 0) {
                    /*
                     * Use CondDoDefined to evaluate the argument and
                     * CondGetArg to extract the argument from the 'function
@@ -755,12 +755,12 @@ error:
                     */
                    evalProc = CondDoDefined;
                    condExpr += 7;
-                   arglen = CondGetArg (&condExpr, &arg, "defined", TRUE);
+                   arglen = CondGetArg(&condExpr, &arg, "defined", TRUE);
                    if (arglen == 0) {
                        condExpr -= 7;
                        goto use_default;
                    }
-               } else if (strncmp (condExpr, "make", 4) == 0) {
+               } else if (strncmp(condExpr, "make", 4) == 0) {
                    /*
                     * Use CondDoMake to evaluate the argument and
                     * CondGetArg to extract the argument from the 'function
@@ -768,12 +768,12 @@ error:
                     */
                    evalProc = CondDoMake;
                    condExpr += 4;
-                   arglen = CondGetArg (&condExpr, &arg, "make", TRUE);
+                   arglen = CondGetArg(&condExpr, &arg, "make", TRUE);
                    if (arglen == 0) {
                        condExpr -= 4;
                        goto use_default;
                    }
-               } else if (strncmp (condExpr, "exists", 6) == 0) {
+               } else if (strncmp(condExpr, "exists", 6) == 0) {
                    /*
                     * Use CondDoExists to evaluate the argument and
                     * CondGetArg to extract the argument from the
@@ -831,7 +831,7 @@ error:
                        goto use_default;
                    }
                    break;
-               } else if (strncmp (condExpr, "target", 6) == 0) {
+               } else if (strncmp(condExpr, "target", 6) == 0) {
                    /*
                     * Use CondDoTarget to evaluate the argument and
                     * CondGetArg to extract the argument from the
@@ -875,7 +875,7 @@ error:
     }
     return (t);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondT --
@@ -926,7 +926,7 @@ CondT(Boolean doEval)
     }
     return (t);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondF --
@@ -961,18 +961,18 @@ CondF(Boolean doEval)
            if (l == True) {
                l = CondF(doEval);
            } else {
-               (void) CondF(FALSE);
+                CondF(FALSE);
            }
        } else {
            /*
             * F -> T
             */
-           CondPushBack (o);
+           CondPushBack(o);
        }
     }
     return (l);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * CondE --
@@ -1008,18 +1008,18 @@ CondE(Boolean doEval)
            if (l == False) {
                l = CondE(doEval);
            } else {
-               (void) CondE(FALSE);
+                CondE(FALSE);
            }
        } else {
            /*
             * E -> F
             */
-           CondPushBack (o);
+           CondPushBack(o);
        }
     }
     return (l);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Cond_Eval --
@@ -1042,7 +1042,7 @@ CondE(Boolean doEval)
  *-----------------------------------------------------------------------
  */
 int
-Cond_Eval (char *line)
+Cond_Eval(char *line)
 {
     struct If      *ifp;
     Boolean        isElse;
@@ -1064,7 +1064,7 @@ Cond_Eval (char *line)
     if (line[0] == 'e' && line[1] == 'l') {
        line += 2;
        isElse = TRUE;
-    } else if (strncmp (line, "endif", 5) == 0) {
+    } else if (strncmp(line, "endif", 5) == 0) {
        /*
         * End of a conditional section. If skipIfLevel is non-zero, that
         * conditional was skipped, so lines following it should also be
@@ -1078,7 +1078,7 @@ Cond_Eval (char *line)
            return (COND_SKIP);
        } else {
            if (condTop == MAXIF) {
-               Parse_Error (level, "if-less endif");
+               Parse_Error(level, "if-less endif");
                return (COND_INVALID);
            } else {
                skipLine = FALSE;
@@ -1095,12 +1095,12 @@ Cond_Eval (char *line)
      * function is, etc. -- by looking in the table of valid "ifs"
      */
     for (ifp = ifs; ifp->form != (char *)0; ifp++) {
-       if (strncmp (ifp->form, line, ifp->formlen) == 0) {
+       if (strncmp(ifp->form, line, ifp->formlen) == 0) {
            break;
        }
     }
 
-    if (ifp->form == (char *) 0) {
+    if (ifp->form == (char *)0) {
        /*
         * Nothing fit. If the first word on the line is actually
         * "else", it's a valid conditional whose value is the inverse
@@ -1108,7 +1108,7 @@ Cond_Eval (char *line)
         */
        if (isElse && (line[0] == 's') && (line[1] == 'e')) {
            if (condTop == MAXIF) {
-               Parse_Error (level, "if-less else");
+               Parse_Error(level, "if-less else");
                return (COND_INVALID);
            } else if (skipIfLevel == 0) {
                value = !condStack[condTop];
@@ -1125,7 +1125,7 @@ Cond_Eval (char *line)
     } else {
        if (isElse) {
            if (condTop == MAXIF) {
-               Parse_Error (level, "if-less elif");
+               Parse_Error(level, "if-less elif");
                return (COND_INVALID);
            } else if (skipIfLevel != 0) {
                /*
@@ -1135,7 +1135,7 @@ Cond_Eval (char *line)
                 * we're skipping...
                 */
                skipIfLineno[skipIfLevel - 1] = lineno;
-               return(COND_SKIP);
+               return (COND_SKIP);
            }
        } else if (skipLine) {
            /*
@@ -1144,7 +1144,7 @@ Cond_Eval (char *line)
             */
            skipIfLineno[skipIfLevel] = lineno;
            skipIfLevel += 1;
-           return(COND_SKIP);
+           return (COND_SKIP);
        }
 
        /*
@@ -1178,7 +1178,7 @@ Cond_Eval (char *line)
                /*FALLTHRU*/
            case Err:
            err:
-               Parse_Error (level, "Malformed conditional (%s)",
+               Parse_Error(level, "Malformed conditional (%s)",
                             line);
                return (COND_INVALID);
            default:
@@ -1204,7 +1204,7 @@ Cond_Eval (char *line)
         * This is the one case where we can definitely proclaim a fatal
         * error. If we don't, we're hosed.
         */
-       Parse_Error (PARSE_FATAL, "Too many nested if's. %d max.", MAXIF);
+       Parse_Error(PARSE_FATAL, "Too many nested if's. %d max.", MAXIF);
        return (COND_INVALID);
     } else {
        condStack[condTop] = value;
@@ -1213,7 +1213,7 @@ Cond_Eval (char *line)
        return (value ? COND_PARSE : COND_SKIP);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Cond_End --
index 95c8d88..f182297 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)dir.c   8.2 (Berkeley) 1/2/94
  * $$FreeBSD: src/usr.bin/make/dir.c,v 1.10.2.2 2003/10/08 08:14:22 ru Exp $
- * $DragonFly: src/usr.bin/make/dir.c,v 1.16 2004/12/09 19:16:03 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/dir.c,v 1.17 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -208,10 +208,11 @@ static int DirPrintDir(void *, void *);
  *-----------------------------------------------------------------------
  */
 void
-Dir_Init (void)
+Dir_Init(void)
 {
-    dirSearchPath = Lst_Init (FALSE);
-    openDirectories = Lst_Init (FALSE);
+
+    dirSearchPath = Lst_Init(FALSE);
+    openDirectories = Lst_Init(FALSE);
     Hash_InitTable(&mtimes, 0);
 }
 
@@ -228,11 +229,11 @@ Dir_Init (void)
  *-----------------------------------------------------------------------
  */
 void
-Dir_InitDot (void)
+Dir_InitDot(void)
 {
     LstNode ln;
 
-    Dir_AddDir (openDirectories, ".");
+    Dir_AddDir(openDirectories, ".");
     if ((ln = Lst_Last(openDirectories)) == NULL)
        err(1, "cannot open current directory");
     dot = Lst_Datum(ln);
@@ -259,6 +260,7 @@ Dir_InitDot (void)
 void
 Dir_End(void)
 {
+
     dot->refCount -= 1;
     Dir_Destroy((void *) dot);
     Dir_ClearPath(dirSearchPath);
@@ -283,9 +285,9 @@ Dir_End(void)
  *-----------------------------------------------------------------------
  */
 static int
-DirFindName (void *p, void *dname)
+DirFindName(void *p, void *dname)
 {
-    return (strcmp (((Path *)p)->name, (char *) dname));
+    return (strcmp(((Path *)p)->name, (char *)dname));
 }
 
 /*-
@@ -301,13 +303,13 @@ DirFindName (void *p, void *dname)
  *-----------------------------------------------------------------------
  */
 Boolean
-Dir_HasWildcards (char *name)
+Dir_HasWildcards(char *name)
 {
     char *cp;
     int wild = 0, brace = 0, bracket = 0;
 
     for (cp = name; *cp; cp++) {
-       switch(*cp) {
+       switch (*cp) {
        case '{':
                brace++;
                wild = 1;
@@ -330,7 +332,7 @@ Dir_HasWildcards (char *name)
                break;
        }
     }
-    return wild && bracket == 0 && brace == 0;
+    return (wild && bracket == 0 && brace == 0);
 }
 
 /*-
@@ -351,7 +353,7 @@ Dir_HasWildcards (char *name)
  *-----------------------------------------------------------------------
  */
 static int
-DirMatchFiles (char *pattern, Path *p, Lst expansions)
+DirMatchFiles(char *pattern, Path *p, Lst expansions)
 {
     Hash_Search          search;       /* Index into the directory's table */
     Hash_Entry   *entry;       /* Current entry in the table */
@@ -373,7 +375,7 @@ DirMatchFiles (char *pattern, Path *p, Lst expansions)
            ((entry->name[0] != '.') ||
             (pattern[0] == '.')))
        {
-           (void)Lst_AtEnd(expansions,
+           Lst_AtEnd(expansions,
                            (isDot ? estrdup(entry->name) :
                             str_concat(p->name, entry->name,
                                        STR_ADDSLASH)));
@@ -417,7 +419,7 @@ DirExpandCurly(char *word, char *brace, Lst path, Lst expansions)
     char         *cp2;         /* Pointer for checking for wildcards in
                                 * expansion before calling Dir_Expand */
 
-    start = brace+1;
+    start = brace + 1;
 
     /*
      * Find the end of the brace clause first, being wary of nested brace
@@ -456,12 +458,12 @@ DirExpandCurly(char *word, char *brace, Lst path, Lst expansions)
         */
        file = emalloc(otherLen + cp - start + 1);
        if (brace != word) {
-           strncpy(file, word, brace-word);
+           strncpy(file, word, brace - word);
        }
        if (cp != start) {
-           strncpy(&file[brace-word], start, cp-start);
+           strncpy(&file[brace - word], start, cp - start);
        }
-       strcpy(&file[(brace-word)+(cp-start)], end);
+       strcpy(&file[(brace - word) + (cp - start)], end);
 
        /*
         * See if the result has any wildcards in it. If we find one, call
@@ -485,7 +487,7 @@ DirExpandCurly(char *word, char *brace, Lst path, Lst expansions)
             * Hit the end w/o finding any wildcards, so stick the expansion
             * on the end of the list.
             */
-           (void)Lst_AtEnd(expansions, file);
+           Lst_AtEnd(expansions, file);
        } else {
        next:
            free(file);
@@ -543,7 +545,8 @@ DirExpandInt(char *word, Lst path, Lst expansions)
 static int
 DirPrintWord(void *word, void *dummy __unused)
 {
-    DEBUGF(DIR, ("%s ", (char *) word));
+
+    DEBUGF(DIR, ("%s ", (char *)word));
 
     return (0);
 }
@@ -563,7 +566,7 @@ DirPrintWord(void *word, void *dummy __unused)
  *-----------------------------------------------------------------------
  */
 void
-Dir_Expand (char *word, Lst path, Lst expansions)
+Dir_Expand(char *word, Lst path, Lst expansions)
 {
     char         *cp;
 
@@ -674,7 +677,7 @@ Dir_Expand (char *word, Lst path, Lst expansions)
  *-----------------------------------------------------------------------
  */
 char *
-Dir_FindFile (char *name, Lst path)
+Dir_FindFile(char *name, Lst path)
 {
     char          *p1;     /* pointer into p->name */
     char          *p2;     /* pointer into name */
@@ -690,7 +693,7 @@ Dir_FindFile (char *name, Lst path)
      * Find the final component of the name and note whether it has a
      * slash in it (the name, I mean)
      */
-    cp = strrchr (name, '/');
+    cp = strrchr(name, '/');
     if (cp) {
        hasSlash = TRUE;
        cp += 1;
@@ -707,17 +710,17 @@ Dir_FindFile (char *name, Lst path)
      * (fish.c) and what pmake finds (./fish.c).
      */
     if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
-       (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
+       (Hash_FindEntry(&dot->files, cp) != (Hash_Entry *)NULL)) {
            DEBUGF(DIR, ("in '.'\n"));
            hits += 1;
            dot->hits += 1;
-           return (estrdup (name));
+           return (estrdup(name));
     }
 
-    if (Lst_Open (path) == FAILURE) {
+    if (Lst_Open(path) == FAILURE) {
        DEBUGF(DIR, ("couldn't open path, file not found\n"));
        misses += 1;
-       return ((char *) NULL);
+       return ((char *)NULL);
     }
 
     /*
@@ -728,10 +731,10 @@ Dir_FindFile (char *name, Lst path)
      * and return the resulting string. If we don't find any such thing,
      * we go on to phase two...
      */
-    while ((ln = Lst_Next (path)) != NULL) {
-       p = (Path *) Lst_Datum (ln);
+    while ((ln = Lst_Next(path)) != NULL) {
+       p = (Path *)Lst_Datum (ln);
        DEBUGF(DIR, ("%s...", p->name));
-       if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
+       if (Hash_FindEntry(&p->files, cp) != (Hash_Entry *)NULL) {
            DEBUGF(DIR, ("here..."));
            if (hasSlash) {
                /*
@@ -742,7 +745,7 @@ Dir_FindFile (char *name, Lst path)
                 * we matched only part of one of the components of p
                 * along with all the rest of them (*p1 != '/').
                 */
-               p1 = p->name + strlen (p->name) - 1;
+               p1 = p->name + strlen(p->name) - 1;
                p2 = cp - 2;
                while (p2 >= name && p1 >= p->name && *p1 == *p2) {
                    p1 -= 1; p2 -= 1;
@@ -752,9 +755,9 @@ Dir_FindFile (char *name, Lst path)
                    continue;
                }
            }
-           file = str_concat (p->name, cp, STR_ADDSLASH);
+           file = str_concat(p->name, cp, STR_ADDSLASH);
            DEBUGF(DIR, ("returning %s\n", file));
-           Lst_Close (path);
+           Lst_Close(path);
            p->hits += 1;
            hits += 1;
            return (file);
@@ -768,13 +771,13 @@ Dir_FindFile (char *name, Lst path)
                continue;
            }
            if (*p1 == '\0' && p2 == cp - 1) {
-               Lst_Close (path);
+               Lst_Close(path);
                if (*cp == '\0' || ISDOT(cp) || ISDOTDOT(cp)) {
                    DEBUGF(DIR, ("returning %s\n", name));
                    return (estrdup(name));
                } else {
                    DEBUGF(DIR, ("must be here but isn't -- returning NULL\n"));
-                   return ((char *) NULL);
+                   return ((char *)NULL);
                }
            }
        }
@@ -795,18 +798,18 @@ Dir_FindFile (char *name, Lst path)
     if (!hasSlash) {
        DEBUGF(DIR, ("failed.\n"));
        misses += 1;
-       return ((char *) NULL);
+       return ((char *)NULL);
     }
 
     if (*name != '/') {
        Boolean checkedDot = FALSE;
 
        DEBUGF(DIR, ("failed. Trying subdirectories..."));
-       (void) Lst_Open (path);
-       while ((ln = Lst_Next (path)) != NULL) {
-           p = (Path *) Lst_Datum (ln);
+        Lst_Open(path);
+       while ((ln = Lst_Next(path)) != NULL) {
+           p = (Path *)Lst_Datum(ln);
            if (p != dot) {
-               file = str_concat (p->name, name, STR_ADDSLASH);
+               file = str_concat(p->name, name, STR_ADDSLASH);
            } else {
                /*
                 * Checking in dot -- DON'T put a leading ./ on the thing.
@@ -816,10 +819,10 @@ Dir_FindFile (char *name, Lst path)
            }
            DEBUGF(DIR, ("checking %s...", file));
 
-           if (stat (file, &stb) == 0) {
+           if (stat(file, &stb) == 0) {
                DEBUGF(DIR, ("got it.\n"));
 
-               Lst_Close (path);
+               Lst_Close(path);
 
                /*
                 * We've found another directory to search. We know there's
@@ -831,9 +834,9 @@ Dir_FindFile (char *name, Lst path)
                 * again in such a manner, we will find it without having to do
                 * numerous numbers of access calls. Hurrah!
                 */
-               cp = strrchr (file, '/');
+               cp = strrchr(file, '/');
                *cp = '\0';
-               Dir_AddDir (path, file);
+               Dir_AddDir(path, file);
                *cp = '/';
 
                /*
@@ -841,18 +844,18 @@ Dir_FindFile (char *name, Lst path)
                 * to fetch it again.
                 */
                DEBUGF(DIR, ("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), file));
-               entry = Hash_CreateEntry(&mtimes, (char *) file,
+               entry = Hash_CreateEntry(&mtimes, (char *)file,
                                         (Boolean *)NULL);
                Hash_SetValue(entry, (long)stb.st_mtime);
                nearmisses += 1;
                return (file);
            } else {
-               free (file);
+               free(file);
            }
        }
 
        DEBUGF(DIR, ("failed. "));
-       Lst_Close (path);
+       Lst_Close(path);
 
        if (checkedDot) {
            /*
@@ -860,7 +863,7 @@ Dir_FindFile (char *name, Lst path)
             * so no point in proceeding...
             */
            DEBUGF(DIR, ("Checked . already, returning NULL\n"));
-           return(NULL);
+           return (NULL);
        }
     }
 
@@ -883,21 +886,21 @@ Dir_FindFile (char *name, Lst path)
      */
 #ifdef notdef
     cp[-1] = '\0';
-    Dir_AddDir (path, name);
+    Dir_AddDir(path, name);
     cp[-1] = '/';
 
     bigmisses += 1;
-    ln = Lst_Last (path);
+    ln = Lst_Last(path);
     if (ln == NULL) {
-       return ((char *) NULL);
+       return ((char *)NULL);
     } else {
-       p = (Path *) Lst_Datum (ln);
+       p = (Path *)Lst_Datum (ln);
     }
 
-    if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
-       return (estrdup (name));
+    if (Hash_FindEntry(&p->files, cp) != (Hash_Entry *)NULL) {
+       return (estrdup(name));
     } else {
-       return ((char *) NULL);
+       return ((char *)NULL);
     }
 #else /* !notdef */
     DEBUGF(DIR, ("Looking for \"%s\"...", name));
@@ -911,7 +914,7 @@ Dir_FindFile (char *name, Lst path)
        entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
        DEBUGF(DIR, ("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), name));
        Hash_SetValue(entry, (long)stb.st_mtime);
-       return (estrdup (name));
+       return (estrdup(name));
     } else {
        DEBUGF(DIR, ("failed. Returning NULL\n"));
        return ((char *)NULL);
@@ -935,16 +938,16 @@ Dir_FindFile (char *name, Lst path)
  *-----------------------------------------------------------------------
  */
 int
-Dir_MTime (GNode *gn)
+Dir_MTime(GNode *gn)
 {
     char          *fullName;  /* the full pathname of name */
     struct stat          stb;        /* buffer for finding the mod time */
     Hash_Entry   *entry;
 
     if (gn->type & OP_ARCHV) {
-       return Arch_MTime (gn);
+       return (Arch_MTime(gn));
     } else if (gn->path == (char *)NULL) {
-       fullName = Dir_FindFile (gn->name, dirSearchPath);
+       fullName = Dir_FindFile(gn->name, dirSearchPath);
     } else {
        fullName = gn->path;
     }
@@ -964,11 +967,11 @@ Dir_MTime (GNode *gn)
               Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName));
        stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
        Hash_DeleteEntry(&mtimes, entry);
-    } else if (stat (fullName, &stb) < 0) {
+    } else if (stat(fullName, &stb) < 0) {
        if (gn->type & OP_MEMBER) {
            if (fullName != gn->path)
                free(fullName);
-           return Arch_MemMTime (gn);
+           return (Arch_MemMTime(gn));
        } else {
            stb.st_mtime = 0;
        }
@@ -997,31 +1000,31 @@ Dir_MTime (GNode *gn)
  *-----------------------------------------------------------------------
  */
 void
-Dir_AddDir (Lst path, char *name)
+Dir_AddDir(Lst path, char *name)
 {
     LstNode       ln;        /* node in case Path structure is found */
     Path          *p;        /* pointer to new Path structure */
     DIR          *d;         /* for reading directory */
     struct dirent *dp;       /* entry in directory */
 
-    ln = Lst_Find (openDirectories, (void *)name, DirFindName);
+    ln = Lst_Find(openDirectories, (void *)name, DirFindName);
     if (ln != NULL) {
-       p = (Path *)Lst_Datum (ln);
+       p = (Path *)Lst_Datum(ln);
        if (Lst_Member(path, (void *)p) == NULL) {
            p->refCount += 1;
-           (void)Lst_AtEnd (path, (void *)p);
+           Lst_AtEnd(path, (void *)p);
        }
     } else {
        DEBUGF(DIR, ("Caching %s...", name));
 
-       if ((d = opendir (name)) != (DIR *) NULL) {
-           p = (Path *) emalloc (sizeof (Path));
-           p->name = estrdup (name);
+       if ((d = opendir(name)) != (DIR *)NULL) {
+           p = (Path *) emalloc(sizeof(Path));
+           p->name = estrdup(name);
            p->hits = 0;
            p->refCount = 1;
-           Hash_InitTable (&p->files, -1);
+           Hash_InitTable(&p->files, -1);
 
-           while ((dp = readdir (d)) != (struct dirent *) NULL) {
+           while ((dp = readdir(d)) != (struct dirent *)NULL) {
 #if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define        for d_fileno */
                /*
                 * The sun directory library doesn't check for a 0 inode
@@ -1043,12 +1046,12 @@ Dir_AddDir (Lst path, char *name)
                if (ISDOT(dp->d_name) || ISDOTDOT(dp->d_name))
                        continue;
 
-               (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
+               Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
            }
-           (void) closedir (d);
-           (void)Lst_AtEnd (openDirectories, (void *)p);
+           closedir(d);
+           Lst_AtEnd(openDirectories, (void *)p);
            if (path != openDirectories)
-               (void)Lst_AtEnd (path, (void *)p);
+               Lst_AtEnd(path, (void *)p);
        }
        DEBUGF(DIR, ("done\n"));
     }
@@ -1071,7 +1074,8 @@ Dir_AddDir (Lst path, char *name)
 void *
 Dir_CopyDir(void *p)
 {
-    ((Path *) p)->refCount += 1;
+
+    ((Path *)p)->refCount += 1;
 
     return ((void *)p);
 }
@@ -1094,7 +1098,7 @@ Dir_CopyDir(void *p)
  *-----------------------------------------------------------------------
  */
 char *
-Dir_MakeFlags (char *flag, Lst path)
+Dir_MakeFlags(char *flag, Lst path)
 {
     char         *str;   /* the string which will be returned */
     char         *tstr;  /* the current directory preceded by 'flag' */
@@ -1102,18 +1106,18 @@ Dir_MakeFlags (char *flag, Lst path)
     LstNode      ln;     /* the node of the current directory */
     Path         *p;     /* the structure describing the current directory */
 
-    str = estrdup ("");
+    str = estrdup("");
 
-    if (Lst_Open (path) == SUCCESS) {
-       while ((ln = Lst_Next (path)) != NULL) {
-           p = (Path *) Lst_Datum (ln);
-           tstr = str_concat (flag, p->name, 0);
-           nstr = str_concat (str, tstr, STR_ADDSPACE);
+    if (Lst_Open(path) == SUCCESS) {
+       while ((ln = Lst_Next(path)) != NULL) {
+           p = (Path *)Lst_Datum(ln);
+           tstr = str_concat(flag, p->name, 0);
+           nstr = str_concat(str, tstr, STR_ADDSPACE);
            free(str);
            free(tstr);
            str = nstr;
        }
-       Lst_Close (path);
+       Lst_Close(path);
     }
 
     return (str);
@@ -1135,18 +1139,18 @@ Dir_MakeFlags (char *flag, Lst path)
  *-----------------------------------------------------------------------
  */
 void
-Dir_Destroy (void *pp)
+Dir_Destroy(void *pp)
 {
-    Path         *p = (Path *) pp;
+    Path         *p = (Path *)pp;
     p->refCount -= 1;
 
     if (p->refCount == 0) {
        LstNode ln;
 
-       ln = Lst_Member (openDirectories, (void *)p);
-       (void) Lst_Remove (openDirectories, ln);
+       ln = Lst_Member(openDirectories, (void *)p);
+       Lst_Remove(openDirectories, ln);
 
-       Hash_DeleteTable (&p->files);
+       Hash_DeleteTable(&p->files);
        free(p->name);
        free(p);
     }
@@ -1170,6 +1174,7 @@ void
 Dir_ClearPath(Lst path)
 {
     Path    *p;
+
     while (!Lst_IsEmpty(path)) {
        p = (Path *)Lst_DeQueue(path);
        Dir_Destroy((void *) p);
@@ -1201,7 +1206,7 @@ Dir_Concat(Lst path1, Lst path2)
        p = (Path *)Lst_Datum(ln);
        if (Lst_Member(path1, (void *)p) == NULL) {
            p->refCount += 1;
-           (void)Lst_AtEnd(path1, (void *)p);
+           Lst_AtEnd(path1, (void *)p);
        }
     }
 }
@@ -1213,31 +1218,33 @@ Dir_PrintDirectories(void)
     LstNode    ln;
     Path       *p;
 
-    printf ("#*** Directory Cache:\n");
-    printf ("# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
+    printf("#*** Directory Cache:\n");
+    printf("# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
              hits, misses, nearmisses, bigmisses,
-             (hits+bigmisses+nearmisses ?
+             (hits + bigmisses + nearmisses ?
               hits * 100 / (hits + bigmisses + nearmisses) : 0));
-    printf ("# %-20s referenced\thits\n", "directory");
-    if (Lst_Open (openDirectories) == SUCCESS) {
-       while ((ln = Lst_Next (openDirectories)) != NULL) {
-           p = (Path *) Lst_Datum (ln);
-           printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
+    printf("# %-20s referenced\thits\n", "directory");
+    if (Lst_Open(openDirectories) == SUCCESS) {
+       while ((ln = Lst_Next(openDirectories)) != NULL) {
+           p = (Path *)Lst_Datum(ln);
+           printf("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
        }
-       Lst_Close (openDirectories);
+       Lst_Close(openDirectories);
     }
 }
 
 static int
-DirPrintDir (void *p, void *dummy __unused)
+DirPrintDir(void *p, void *dummy __unused)
 {
-    printf ("%s ", ((Path *) p)->name);
+
+    printf("%s ", ((Path *)p)->name);
 
     return (0);
 }
 
 void
-Dir_PrintPath (Lst path)
+Dir_PrintPath(Lst path)
 {
-    Lst_ForEach (path, DirPrintDir, (void *)0);
+
+    Lst_ForEach(path, DirPrintDir, (void *)0);
 }
index 4ec3ab6..0ff188c 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     from: @(#)dir.h 8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/dir.h,v 1.7 1999/08/28 01:03:29 peter Exp $
- * $DragonFly: src/usr.bin/make/dir.h,v 1.6 2004/11/30 15:22:46 joerg Exp $
+ * $DragonFly: src/usr.bin/make/dir.h,v 1.7 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /* dir.h --
@@ -69,6 +69,6 @@ void Dir_Concat(Lst, Lst);
 void Dir_PrintDirectories(void);
 void Dir_PrintPath(Lst);
 void Dir_Destroy(void *);
-void * Dir_CopyDir(void *);
+void *Dir_CopyDir(void *);
 
 #endif /* _DIR */
index a9ef9a7..0417d95 100644 (file)
@@ -35,7 +35,7 @@
  *
  * @(#)for.c   8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/for.c,v 1.10 1999/09/11 13:08:01 hoek Exp $
- * $DragonFly: src/usr.bin/make/for.c,v 1.10 2004/12/09 19:08:35 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/for.c,v 1.11 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -85,9 +85,6 @@ typedef struct _For {
 
 static int ForExec(void *, void *);
 
-
-
-\f
 /*-
  *-----------------------------------------------------------------------
  * For_Eval --
@@ -106,7 +103,7 @@ static int ForExec(void *, void *);
  *-----------------------------------------------------------------------
  */
 int
-For_Eval (char *line)
+For_Eval(char *line)
 {
     char           *ptr = line, *sub, *wrd;
     int                    level;      /* Level at which to report errors. */
@@ -118,53 +115,53 @@ For_Eval (char *line)
        Buffer      buf;
        int         varlen;
 
-       for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
+       for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
            continue;
        /*
         * If we are not in a for loop quickly determine if the statement is
         * a for.
         */
        if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
-           !isspace((unsigned char) ptr[3]))
-           return FALSE;
+           !isspace((unsigned char)ptr[3]))
+           return (FALSE);
        ptr += 3;
 
        /*
         * we found a for loop, and now we are going to parse it.
         */
-       while (*ptr && isspace((unsigned char) *ptr))
+       while (*ptr && isspace((unsigned char)*ptr))
            ptr++;
 
        /*
         * Grab the variable
         */
        buf = Buf_Init(0);
-       for (wrd = ptr; *ptr && !isspace((unsigned char) *ptr); ptr++)
+       for (wrd = ptr; *ptr && !isspace((unsigned char)*ptr); ptr++)
            continue;
-       Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd);
+       Buf_AddBytes(buf, ptr - wrd, (Byte *)wrd);
 
-       forVar = (char *) Buf_GetAll(buf, &varlen);
+       forVar = (char *)Buf_GetAll(buf, &varlen);
        if (varlen == 0) {
-           Parse_Error (level, "missing variable in for");
-           return 0;
+           Parse_Error(level, "missing variable in for");
+           return (0);
        }
        Buf_Destroy(buf, FALSE);
 
-       while (*ptr && isspace((unsigned char) *ptr))
+       while (*ptr && isspace((unsigned char)*ptr))
            ptr++;
 
        /*
         * Grab the `in'
         */
        if (ptr[0] != 'i' || ptr[1] != 'n' ||
-           !isspace((unsigned char) ptr[2])) {
-           Parse_Error (level, "missing `in' in for");
+           !isspace((unsigned char)ptr[2])) {
+           Parse_Error(level, "missing `in' in for");
            printf("%s\n", ptr);
-           return 0;
+           return (0);
        }
        ptr += 3;
 
-       while (*ptr && isspace((unsigned char) *ptr))
+       while (*ptr && isspace((unsigned char)*ptr))
            ptr++;
 
        /*
@@ -175,19 +172,19 @@ For_Eval (char *line)
        sub = Var_Subst(NULL, ptr, VAR_CMD, FALSE);
 
 #define        ADDWORD() \
-       Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd), \
-       Buf_AddByte(buf, (Byte) '\0'), \
-       Lst_AtFront(forLst, (void *) Buf_GetAll(buf, &varlen)), \
+       Buf_AddBytes(buf, ptr - wrd, (Byte *)wrd), \
+       Buf_AddByte(buf, (Byte)'\0'), \
+       Lst_AtFront(forLst, (void *)Buf_GetAll(buf, &varlen)), \
        Buf_Destroy(buf, FALSE)
 
-       for (ptr = sub; *ptr && isspace((unsigned char) *ptr); ptr++)
+       for (ptr = sub; *ptr && isspace((unsigned char)*ptr); ptr++)
            continue;
 
        for (wrd = ptr; *ptr; ptr++)
-           if (isspace((unsigned char) *ptr)) {
+           if (isspace((unsigned char)*ptr)) {
                ADDWORD();
                buf = Buf_Init(0);
-               while (*ptr && isspace((unsigned char) *ptr))
+               while (*ptr && isspace((unsigned char)*ptr))
                    ptr++;
                wrd = ptr--;
            }
@@ -200,35 +197,35 @@ For_Eval (char *line)
 
        forBuf = Buf_Init(0);
        forLevel++;
-       return 1;
+       return (1);
     }
     else if (*ptr == '.') {
 
-       for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
+       for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
            continue;
 
        if (strncmp(ptr, "endfor", 6) == 0 &&
-           (isspace((unsigned char) ptr[6]) || !ptr[6])) {
+           (isspace((unsigned char)ptr[6]) || !ptr[6])) {
            DEBUGF(FOR, ("For: end for %d\n", forLevel));
            if (--forLevel < 0) {
-               Parse_Error (level, "for-less endfor");
-               return 0;
+               Parse_Error(level, "for-less endfor");
+               return (0);
            }
        }
        else if (strncmp(ptr, "for", 3) == 0 &&
-                isspace((unsigned char) ptr[3])) {
+                isspace((unsigned char)ptr[3])) {
            forLevel++;
            DEBUGF(FOR, ("For: new loop %d\n", forLevel));
        }
     }
 
     if (forLevel != 0) {
-       Buf_AddBytes(forBuf, strlen(line), (Byte *) line);
-       Buf_AddByte(forBuf, (Byte) '\n');
-       return 1;
+       Buf_AddBytes(forBuf, strlen(line), (Byte *)line);
+       Buf_AddByte(forBuf, (Byte)'\n');
+       return (1);
     }
     else {
-       return 0;
+       return (0);
     }
 }
 
@@ -253,14 +250,13 @@ ForExec(void *namep, void *argp)
     int len;
     Var_Set(arg->var, name, VAR_GLOBAL);
     DEBUGF(FOR, ("--- %s = %s\n", arg->var, name));
-    Parse_FromString(Var_Subst(arg->var, (char *) Buf_GetAll(arg->buf, &len),
+    Parse_FromString(Var_Subst(arg->var, (char *)Buf_GetAll(arg->buf, &len),
                               VAR_GLOBAL, FALSE), arg->lineno);
     Var_Delete(arg->var, VAR_GLOBAL);
 
-    return 0;
+    return (0);
 }
 
-\f
 /*-
  *-----------------------------------------------------------------------
  * For_Run --
@@ -289,7 +285,7 @@ For_Run(int lineno)
     forBuf = NULL;
     forLst = NULL;
 
-    Lst_ForEach(arg.lst, ForExec, (void *) &arg);
+    Lst_ForEach(arg.lst, ForExec, (void *)&arg);
 
     free(arg.var);
     Lst_Destroy(arg.lst, free);
index a710212..2dfaae9 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)hash.c  8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/hash.c,v 1.9 1999/09/11 13:08:01 hoek Exp $
- * $DragonFly: src/usr.bin/make/hash.c,v 1.8 2004/11/14 20:05:25 dillon Exp $
+ * $DragonFly: src/usr.bin/make/hash.c,v 1.9 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /* hash.c --
@@ -71,7 +71,7 @@ static void RebuildTable(Hash_Table *);
  *---------------------------------------------------------
  *
  * Hash_InitTable --
- * 
+ *
  *     Set up the hash table t with a given number of buckets, or a
  *     reasonable default if the number requested is less than or
  *     equal to zero.  Hash tables will grow in size as needed.
@@ -233,13 +233,13 @@ Hash_CreateEntry(Hash_Table *t, char *key, Boolean *newPtr)
         */
        if (t->numEntries >= rebuildLimit * t->size)
                RebuildTable(t);
-       e = (Hash_Entry *) emalloc(sizeof(*e) + keylen);
+       e = (Hash_Entry *)emalloc(sizeof(*e) + keylen);
        hp = &t->bucketPtr[h & t->mask];
        e->next = *hp;
        *hp = e;
        e->clientData = NULL;
        e->namehash = h;
-       (void) strcpy(e->name, p);
+       strcpy(e->name, p);
        t->numEntries++;
 
        if (newPtr != NULL)
@@ -280,7 +280,7 @@ Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e)
                        return;
                }
        }
-       (void) write(STDERR_FILENO, "bad call to Hash_DeleteEntry\n", 29);
+       write(STDERR_FILENO, "bad call to Hash_DeleteEntry\n", 29);
        abort();
 }
 
@@ -306,10 +306,11 @@ Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e)
 Hash_Entry *
 Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr)
 {
+
        searchPtr->tablePtr = t;
        searchPtr->nextIndex = 0;
        searchPtr->hashEntryPtr = NULL;
-       return Hash_EnumNext(searchPtr);
+       return (Hash_EnumNext(searchPtr));
 }
 
 /*
@@ -387,7 +388,7 @@ RebuildTable(Hash_Table *t)
        i <<= 1;
        t->size = i;
        t->mask = mask = i - 1;
-       t->bucketPtr = hp = (struct Hash_Entry **) emalloc(sizeof(*hp) * i);
+       t->bucketPtr = hp = (struct Hash_Entry **)emalloc(sizeof(*hp) * i);
        while (--i >= 0)
                *hp++ = NULL;
        for (hp = oldhp, i = oldsize; --i >= 0;) {
index 9b197c9..22d8939 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     from: @(#)hash.h        8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/hash.h,v 1.8 1999/08/28 01:03:30 peter Exp $
- * $DragonFly: src/usr.bin/make/hash.h,v 1.6 2004/11/12 22:42:36 dillon Exp $
+ * $DragonFly: src/usr.bin/make/hash.h,v 1.7 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /* hash.h --
@@ -100,13 +100,13 @@ typedef struct Hash_Search {
  *     char *val;
  */
 
-#define        Hash_SetValue(h, val) ((h)->clientData = (void *) (val))
+#define        Hash_SetValue(h, val) ((h)->clientData = (void *)(val))
 
 /*
  * Hash_Size(n) returns the number of words in an object of n bytes
  */
 
-#define        Hash_Size(n)    (((n) + sizeof (int) - 1) / sizeof (int))
+#define        Hash_Size(n)    (((n) + sizeof(int) - 1) / sizeof(int))
 
 void Hash_InitTable(Hash_Table *, int);
 void Hash_DeleteTable(Hash_Table *);
index a85894e..7b6507d 100644 (file)
@@ -38,7 +38,7 @@
  *
  * @(#)job.c   8.2 (Berkeley) 3/19/94
  * $FreeBSD: src/usr.bin/make/job.c,v 1.17.2.2 2001/02/13 03:13:57 will Exp $
- * $DragonFly: src/usr.bin/make/job.c,v 1.25 2004/12/10 01:16:25 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/job.c,v 1.26 2004/12/10 19:22:24 okumoto Exp $
  */
 
 #ifndef OLD_JOKE
@@ -138,7 +138,7 @@ static int          aborting = 0;       /* why is the make aborting? */
  * XXX: Avoid SunOS bug... FILENO() is fp->_file, and file
  * is a char! So when we go above 127 we turn negative!
  */
-#define        FILENO(a) ((unsigned) fileno(a))
+#define        FILENO(a) ((unsigned)fileno(a))
 
 /*
  * post-make command processing. The node postCommands is really just the
@@ -161,7 +161,7 @@ static int            numCommands;      /* The number of commands actually printed
 
 /*
  * tfile is used to build temp file names to store shell commands to
- * execute. 
+ * execute.
  */
 static char     tfile[sizeof(TMPPAT)];
 
@@ -232,7 +232,7 @@ STATIC char         *targFmt;       /* Format string to use to head output from a
 
 #define        TARG_FMT  "--- %s ---\n" /* Default format */
 #define        MESSAGE(fp, gn) \
-       (void) fprintf(fp, targFmt, gn->name);
+        fprintf(fp, targFmt, gn->name);
 
 /*
  * When JobStart attempts to run a job but isn't allowed to
@@ -269,7 +269,7 @@ static sig_atomic_t interrupted;
  */
 #define        W_SETMASKED(st, val, fun)                               \
        {                                                       \
-               int sh = (int) ~0;                              \
+               int sh = (int)~0;                               \
                int mask = fun(sh);                             \
                                                                \
                for (sh = 0; ((mask >> sh) & 1) == 0; sh++)     \
@@ -327,13 +327,13 @@ JobCatchSig(int signo)
 static int
 JobCondPassSig(void *jobp, void *signop)
 {
-    Job        *job = (Job *) jobp;
-    int        signo = *(int *) signop;
+    Job        *job = (Job *)jobp;
+    int        signo = *(int *)signop;
 
     DEBUGF(JOB, ("JobCondPassSig passing signal %d to child %d.\n",
        signo, job->pid));
     KILL(job->pid, signo);
-    return 0;
+    return (0);
 }
 
 /*-
@@ -361,7 +361,7 @@ JobPassSig(int signo)
     sigprocmask(SIG_SETMASK, &nmask, &omask);
 
     DEBUGF(JOB, ("JobPassSig(%d) called.\n", signo));
-    Lst_ForEach(jobs, JobCondPassSig, (void *) &signo);
+    Lst_ForEach(jobs, JobCondPassSig, (void *)&signo);
 
     /*
      * Deal with proper cleanup based on the signal received. We only run
@@ -393,15 +393,16 @@ JobPassSig(int signo)
     act.sa_flags = 0;
     sigaction(signo, &act, NULL);
 
-    DEBUGF(JOB, ("JobPassSig passing signal to self, mask = %x.\n", ~0 & ~(1 << (signo-1))));
-    (void) signal(signo, SIG_DFL);
+    DEBUGF(JOB, ("JobPassSig passing signal to self, mask = %x.\n",
+       ~0 & ~(1 << (signo - 1))));
+    signal(signo, SIG_DFL);
 
-    (void) KILL(getpid(), signo);
+    KILL(getpid(), signo);
 
     signo = SIGCONT;
-    Lst_ForEach(jobs, JobCondPassSig, (void *) &signo);
+    Lst_ForEach(jobs, JobCondPassSig, (void *)&signo);
 
-    (void) sigprocmask(SIG_SETMASK, &omask, NULL);
+    sigprocmask(SIG_SETMASK, &omask, NULL);
     sigprocmask(SIG_SETMASK, &omask, NULL);
     act.sa_handler = JobPassSig;
     sigaction(signo, &act, NULL);
@@ -424,7 +425,7 @@ JobPassSig(int signo)
 static int
 JobCmpPid(void *job, void *pid)
 {
-    return *(int *) pid - ((Job *) job)->pid;
+    return (*(int *)pid - ((Job *)job)->pid);
 }
 
 /*-
@@ -469,8 +470,8 @@ JobPrintCommand(void *cmdp, void *jobp)
                                     * command */
     char         *cmdStart;        /* Start of expanded command */
     LstNode      cmdNode;          /* Node for replacing the command */
-    char         *cmd = (char *) cmdp;
-    Job           *job = (Job *) jobp;
+    char         *cmd = (char *)cmdp;
+    Job           *job = (Job *)jobp;
 
     noSpecials = (noExecute && !(job->node->type & OP_MAKE));
 
@@ -479,15 +480,15 @@ JobPrintCommand(void *cmdp, void *jobp)
        if ((job->flags & JOB_IGNDOTS) == 0) {
            job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
                                                (void *)cmd));
-           return 1;
+           return (1);
        }
-       return 0;
+       return (0);
     }
 
 #define        DBPRINTF(fmt, arg)                      \
    DEBUGF(JOB, (fmt, arg));                    \
-   (void) fprintf(job->cmdFILE, fmt, arg);     \
-   (void) fflush(job->cmdFILE);
+    fprintf(job->cmdFILE, fmt, arg);   \
+    fflush(job->cmdFILE);
 
     numCommands += 1;
 
@@ -530,7 +531,7 @@ JobPrintCommand(void *cmdp, void *jobp)
        cmd++;
     }
 
-    while (isspace((unsigned char) *cmd))
+    while (isspace((unsigned char)*cmd))
        cmd++;
 
     if (shutUp) {
@@ -611,7 +612,7 @@ JobPrintCommand(void *cmdp, void *jobp)
     if (shutUp) {
        DBPRINTF("%s\n", commandShell->echoOn);
     }
-    return 0;
+    return (0);
 }
 
 /*-
@@ -631,9 +632,10 @@ JobPrintCommand(void *cmdp, void *jobp)
 static int
 JobSaveCommand(void *cmd, void *gn)
 {
-    cmd = (void *) Var_Subst(NULL, (char *) cmd, (GNode *) gn, FALSE);
-    (void) Lst_AtEnd(postCommands->commands, cmd);
-    return(0);
+
+    cmd = (void *)Var_Subst(NULL, (char *)cmd, (GNode *)gn, FALSE);
+    Lst_AtEnd(postCommands->commands, cmd);
+    return (0);
 }
 
 
@@ -653,17 +655,18 @@ JobSaveCommand(void *cmd, void *gn)
 static void
 JobClose(Job *job)
 {
+
     if (usePipes) {
 #if !defined(USE_KQUEUE)
        FD_CLR(job->inPipe, &outputs);
 #endif
        if (job->outPipe != job->inPipe) {
-          (void) close(job->outPipe);
+          close(job->outPipe);
        }
        JobDoOutput(job, TRUE);
-       (void) close(job->inPipe);
+       close(job->inPipe);
     } else {
-       (void) close(job->outFd);
+       close(job->outFd);
        JobDoOutput(job, TRUE);
     }
 }
@@ -711,7 +714,7 @@ JobFinish(Job *job, int *status)
         */
        JobClose(job);
        if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
-          (void) fclose(job->cmdFILE);
+           fclose(job->cmdFILE);
        }
        done = TRUE;
     } else if (WIFEXITED(*status)) {
@@ -764,7 +767,7 @@ JobFinish(Job *job, int *status)
                    MESSAGE(out, job->node);
                    lastNode = job->node;
                }
-               (void) fprintf(out, "*** Error code %d%s\n",
+                fprintf(out, "*** Error code %d%s\n",
                               WEXITSTATUS(*status),
                               (job->flags & JOB_IGNERR) ? "(ignored)" : "");
 
@@ -776,7 +779,7 @@ JobFinish(Job *job, int *status)
                    MESSAGE(out, job->node);
                    lastNode = job->node;
                }
-               (void) fprintf(out, "*** Completed successfully\n");
+               fprintf(out, "*** Completed successfully\n");
            }
        } else if (WIFSTOPPED(*status)) {
            DEBUGF(JOB, ("Process %d stopped.\n", job->pid));
@@ -784,11 +787,11 @@ JobFinish(Job *job, int *status)
                MESSAGE(out, job->node);
                lastNode = job->node;
            }
-           (void) fprintf(out, "*** Stopped -- signal %d\n",
+           fprintf(out, "*** Stopped -- signal %d\n",
                WSTOPSIG(*status));
            job->flags |= JOB_RESUME;
-           (void)Lst_AtEnd(stoppedJobs, (void *)job);
-           (void) fflush(out);
+           Lst_AtEnd(stoppedJobs, (void *)job);
+           fflush(out);
            return;
        } else if (WTERMSIG(*status) == SIGCONT) {
            /*
@@ -801,7 +804,7 @@ JobFinish(Job *job, int *status)
                    MESSAGE(out, job->node);
                    lastNode = job->node;
                }
-               (void) fprintf(out, "*** Continued\n");
+                fprintf(out, "*** Continued\n");
            }
            if (!(job->flags & JOB_CONTINUING)) {
                DEBUGF(JOB, ("Warning: process %d was not continuing.\n", job->pid));
@@ -823,17 +826,17 @@ JobFinish(Job *job, int *status)
                jobFull = TRUE;
                DEBUGF(JOB, ("Job queue is full.\n"));
            }
-           (void) fflush(out);
+           fflush(out);
            return;
        } else {
            if (usePipes && job->node != lastNode) {
                MESSAGE(out, job->node);
                lastNode = job->node;
            }
-           (void) fprintf(out, "*** Signal %d\n", WTERMSIG(*status));
+           fprintf(out, "*** Signal %d\n", WTERMSIG(*status));
        }
 
-       (void) fflush(out);
+       fflush(out);
     }
 
     /*
@@ -943,8 +946,8 @@ Job_Touch(GNode *gn, Boolean silent)
     }
 
     if (!silent) {
-       (void) fprintf(stdout, "touch %s\n", gn->name);
-       (void) fflush(stdout);
+        fprintf(stdout, "touch %s\n", gn->name);
+        fflush(stdout);
     }
 
     if (noExecute) {
@@ -970,15 +973,15 @@ Job_Touch(GNode *gn, Boolean silent)
                 * modification time, then close the file.
                 */
                if (read(streamID, &c, 1) == 1) {
-                   (void) lseek(streamID, (off_t)0, SEEK_SET);
-                   (void) write(streamID, &c, 1);
+                    lseek(streamID, (off_t)0, SEEK_SET);
+                   write(streamID, &c, 1);
                }
 
-               (void) close(streamID);
+               close(streamID);
            } else {
-               (void) fprintf(stdout, "*** couldn't touch %s: %s",
+                fprintf(stdout, "*** couldn't touch %s: %s",
                               file, strerror(errno));
-               (void) fflush(stdout);
+                fflush(stdout);
            }
        }
     }
@@ -1000,6 +1003,7 @@ Job_Touch(GNode *gn, Boolean silent)
 Boolean
 Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
 {
+
     if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) &&
        (gn->type & OP_LIB) == 0) {
        /*
@@ -1031,12 +1035,12 @@ Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
            static const char msg[] = "make: don't know how to make";
 
            if (gn->type & OP_OPTIONAL) {
-               (void) fprintf(stdout, "%s %s(ignored)\n", msg, gn->name);
-               (void) fflush(stdout);
+                fprintf(stdout, "%s %s(ignored)\n", msg, gn->name);
+                fflush(stdout);
            } else if (keepgoing) {
-               (void) fprintf(stdout, "%s %s(continuing)\n", msg, gn->name);
-               (void) fflush(stdout);
-               return FALSE;
+                fprintf(stdout, "%s %s(continuing)\n", msg, gn->name);
+                fflush(stdout);
+                return (FALSE);
            } else {
 #if OLD_JOKE
                if (strcmp(gn->name,"love") == 0)
@@ -1044,11 +1048,11 @@ Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
                else
 #endif
                    (*abortProc)("%s %s. Stop", msg, gn->name);
-               return FALSE;
+               return (FALSE);
            }
        }
     }
-    return TRUE;
+    return (TRUE);
 }
 
 /*-
@@ -1107,8 +1111,8 @@ JobExec(Job *job, char **argv)
         */
        if (dup2(FILENO(job->cmdFILE), 0) == -1)
            Punt("Cannot dup2: %s", strerror(errno));
-       (void) fcntl(0, F_SETFD, 0);
-       (void) lseek(0, (off_t)0, SEEK_SET);
+       fcntl(0, F_SETFD, 0);
+       lseek(0, (off_t)0, SEEK_SET);
 
        if (usePipes) {
            /*
@@ -1132,7 +1136,7 @@ JobExec(Job *job, char **argv)
         * it before routing the shell's error output to the same place as
         * its standard output.
         */
-       (void) fcntl(1, F_SETFD, 0);
+       fcntl(1, F_SETFD, 0);
        if (dup2(1, 2) == -1)
            Punt("Cannot dup2: %s", strerror(errno));
 
@@ -1143,15 +1147,15 @@ JobExec(Job *job, char **argv)
         * by killing its process family, but not commit suicide.
         */
 # if defined(SYSV)
-       (void) setsid();
+       setsid();
 # else
-       (void) setpgid(0, getpid());
+       setpgid(0, getpid());
 # endif
 #endif /* USE_PGRP */
 
-       (void) execv(shellPath, argv);
+       execv(shellPath, argv);
 
-       (void) write(STDERR_FILENO, "Could not execute shell\n",
+       write(STDERR_FILENO, "Could not execute shell\n",
                     sizeof("Could not execute shell"));
        _exit(1);
     } else {
@@ -1183,7 +1187,7 @@ JobExec(Job *job, char **argv)
        }
 
        if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
-           (void) fclose(job->cmdFILE);
+           fclose(job->cmdFILE);
            job->cmdFILE = NULL;
        }
     }
@@ -1192,7 +1196,7 @@ JobExec(Job *job, char **argv)
      * Now the job is actually running, add it to the table.
      */
     nJobs += 1;
-    (void) Lst_AtEnd(jobs, (void *)job);
+    Lst_AtEnd(jobs, (void *)job);
     if (nJobs == maxJobs) {
        jobFull = TRUE;
     }
@@ -1228,7 +1232,7 @@ JobMakeArgv(Job *job, char **argv)
         * Bourne shell thinks its second argument is a file to source.
         * Grrrr. Note the ten-character limitation on the combined arguments.
         */
-       (void)sprintf(args, "-%s%s",
+       sprintf(args, "-%s%s",
                      ((job->flags & JOB_IGNERR) ? "" :
                       (commandShell->exit ? commandShell->exit : "")),
                      ((job->flags & JOB_SILENT) ? "" :
@@ -1288,7 +1292,7 @@ JobRestart(Job *job)
             * back on the hold queue and mark the table full
             */
            DEBUGF(JOB, ("holding\n"));
-           (void)Lst_AtFront(stoppedJobs, (void *)job);
+           Lst_AtFront(stoppedJobs, (void *)job);
            jobFull = TRUE;
            DEBUGF(JOB, ("Job queue is full.\n"));
            return;
@@ -1343,7 +1347,7 @@ JobRestart(Job *job)
             * place the job back on the list of stopped jobs.
             */
            DEBUGF(JOB, ("table full\n"));
-           (void) Lst_AtFront(stoppedJobs, (void *)job);
+           Lst_AtFront(stoppedJobs, (void *)job);
            jobFull = TRUE;
            DEBUGF(JOB, ("Job queue is full.\n"));
        }
@@ -1383,7 +1387,7 @@ JobStart(GNode *gn, int flags, Job *previous)
        previous->flags &= ~(JOB_FIRST|JOB_IGNERR|JOB_SILENT);
        job = previous;
     } else {
-       job = (Job *) emalloc(sizeof(Job));
+       job = (Job *)emalloc(sizeof(Job));
        flags |= JOB_FIRST;
     }
 
@@ -1429,7 +1433,7 @@ JobStart(GNode *gn, int flags, Job *previous)
            DieHorribly();
        }
 
-       (void) strcpy(tfile, TMPPAT);
+       strcpy(tfile, TMPPAT);
        if ((tfd = mkstemp(tfile)) == -1)
            Punt("Cannot create temp file: %s", strerror(errno));
        job->cmdFILE = fdopen(tfd, "w+");
@@ -1438,7 +1442,7 @@ JobStart(GNode *gn, int flags, Job *previous)
            close(tfd);
            Punt("Could not open %s", tfile);
        }
-       (void) fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
+       fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
        /*
         * Send the commands to the command file, flush all its buffers then
         * rewind and remove the thing.
@@ -1464,8 +1468,8 @@ JobStart(GNode *gn, int flags, Job *previous)
                LstNode ln = Lst_Next(gn->commands);
 
                if ((ln == NULL) ||
-                   JobPrintCommand((void *) Lst_Datum(ln),
-                                   (void *) job))
+                   JobPrintCommand((void *)Lst_Datum(ln),
+                                   (void *)job))
                {
                    noExec = TRUE;
                    Lst_Close(gn->commands);
@@ -1543,9 +1547,9 @@ JobStart(GNode *gn, int flags, Job *previous)
         */
        if (job->cmdFILE != stdout) {
            if (job->cmdFILE != NULL)
-               (void) fclose(job->cmdFILE);
+                fclose(job->cmdFILE);
        } else {
-            (void) fflush(stdout);
+             fflush(stdout);
        }
 
        /*
@@ -1569,7 +1573,7 @@ JobStart(GNode *gn, int flags, Job *previous)
            return(JOB_ERROR);
        }
     } else {
-       (void) fflush(job->cmdFILE);
+        fflush(job->cmdFILE);
     }
 
     /*
@@ -1586,19 +1590,20 @@ JobStart(GNode *gn, int flags, Job *previous)
     if (!compatMake || (job->flags & JOB_FIRST)) {
        if (usePipes) {
            int fd[2];
+
            if (pipe(fd) == -1)
                Punt("Cannot create pipe: %s", strerror(errno));
            job->inPipe = fd[0];
            job->outPipe = fd[1];
-           (void) fcntl(job->inPipe, F_SETFD, 1);
-           (void) fcntl(job->outPipe, F_SETFD, 1);
+           fcntl(job->inPipe, F_SETFD, 1);
+           fcntl(job->outPipe, F_SETFD, 1);
        } else {
-           (void) fprintf(stdout, "Remaking `%s'\n", gn->name);
-           (void) fflush(stdout);
-           (void) strcpy(job->outFile, TMPPAT);
+           fprintf(stdout, "Remaking `%s'\n", gn->name);
+           fflush(stdout);
+           strcpy(job->outFile, TMPPAT);
            if ((job->outFd = mkstemp(job->outFile)) == -1)
                Punt("cannot create temp file: %s", strerror(errno));
-           (void) fcntl(job->outFd, F_SETFD, 1);
+           fcntl(job->outFd, F_SETFD, 1);
        }
     }
 
@@ -1613,7 +1618,7 @@ JobStart(GNode *gn, int flags, Job *previous)
 
        DEBUGF(JOB, ("Can only run job locally.\n"));
        job->flags |= JOB_RESTART;
-       (void) Lst_AtEnd(stoppedJobs, (void *)job);
+       Lst_AtEnd(stoppedJobs, (void *)job);
     } else {
        if (nJobs >= maxJobs) {
            /*
@@ -1625,7 +1630,7 @@ JobStart(GNode *gn, int flags, Job *previous)
        }
        JobExec(job, argv);
     }
-    return(JOB_RUNNING);
+    return (JOB_RUNNING);
 }
 
 static char *
@@ -1648,8 +1653,8 @@ JobOutput(Job *job, char *cp, char *endp, int msg)
                 * however, since the non-printable comes after it,
                 * there must be a newline, so we don't print one.
                 */
-               (void) fprintf(stdout, "%s", cp);
-               (void) fflush(stdout);
+                fprintf(stdout, "%s", cp);
+                fflush(stdout);
            }
            cp = ecp + commandShell->noPLen;
            if (cp != endp) {
@@ -1664,11 +1669,11 @@ JobOutput(Job *job, char *cp, char *endp, int msg)
                }
                ecp = strstr(cp, commandShell->noPrint);
            } else {
-               return cp;
+               return (cp);
            }
        }
     }
-    return cp;
+    return (cp);
 }
 
 /*-
@@ -1807,13 +1812,13 @@ end_loop:
                        MESSAGE(stdout, job->node);
                        lastNode = job->node;
                    }
-                   (void) fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
-                   (void) fflush(stdout);
+                    fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
+                    fflush(stdout);
                }
            }
            if (i < max - 1) {
                /* shift the remaining characters down */
-               (void) memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
+                memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
                job->curPos = max - (i + 1);
 
            } else {
@@ -1848,8 +1853,8 @@ end_loop:
         */
        oFILE = fopen(job->outFile, "r");
        if (oFILE != NULL) {
-           (void) fprintf(stdout, "Results of making %s:\n", job->node->name);
-           (void) fflush(stdout);
+            fprintf(stdout, "Results of making %s:\n", job->node->name);
+            fflush(stdout);
            while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
                char    *cp, *endp, *oendp;
 
@@ -1865,15 +1870,15 @@ end_loop:
                 * we know there's no newline at the end, so we add one of
                 * our own free will.
                 */
-               (void) fprintf(stdout, "%s", cp);
-               (void) fflush(stdout);
+               fprintf(stdout, "%s", cp);
+               fflush(stdout);
                if (endp != oendp) {
-                   (void) fprintf(stdout, "\n");
-                   (void) fflush(stdout);
+                    fprintf(stdout, "\n");
+                    fflush(stdout);
                }
            }
-           (void) fclose(oFILE);
-           (void) eunlink(job->outFile);
+            fclose(oFILE);
+            eunlink(job->outFile);
        }
     }
 }
@@ -1913,7 +1918,7 @@ Job_CatchChildren(Boolean block)
     }
 
     for (;;) {
-       pid = waitpid((pid_t) -1, &status, (block?0:WNOHANG)|WUNTRACED);
+       pid = waitpid((pid_t)-1, &status, (block ? 0 : WNOHANG) | WUNTRACED);
        if (pid <= 0)
            break;
        DEBUGF(JOB, ("Process %d exited or stopped.\n", pid));
@@ -1922,20 +1927,20 @@ Job_CatchChildren(Boolean block)
 
        if (jnode == NULL) {
            if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGCONT)) {
-               jnode = Lst_Find(stoppedJobs, (void *) &pid, JobCmpPid);
+               jnode = Lst_Find(stoppedJobs, (void *)&pid, JobCmpPid);
                if (jnode == NULL) {
                    Error("Resumed child (%d) not in table", pid);
                    continue;
                }
                job = (Job *)Lst_Datum(jnode);
-               (void) Lst_Remove(stoppedJobs, jnode);
+               Lst_Remove(stoppedJobs, jnode);
            } else {
                Error("Child (%d) not in table?", pid);
                continue;
            }
        } else {
-           job = (Job *) Lst_Datum(jnode);
-           (void) Lst_Remove(jobs, jnode);
+           job = (Job *)Lst_Datum(jnode);
+           Lst_Remove(jobs, jnode);
            nJobs -= 1;
            if (fifoFd >= 0 && maxJobs > 1) {
                write(fifoFd, "+", 1);
@@ -1961,7 +1966,7 @@ Job_CatchChildren(Boolean block)
  * Job_CatchOutput --
  *     Catch the output from our children, if we're using
  *     pipes do so. Otherwise just block time until we get a
- *     signal (most likely a SIGCHLD) since there's no point in
+ *     signal(most likely a SIGCHLD) since there's no point in
  *     just spinning when there's nothing to do and the reaping
  *     of a child can wait for a while.
  *
@@ -1987,7 +1992,7 @@ Job_CatchOutput(int flag)
     Job                          *job;
 #endif
 
-    (void) fflush(stdout);
+     fflush(stdout);
 
     if (usePipes) {
 #ifdef USE_KQUEUE
@@ -2023,7 +2028,7 @@ Job_CatchOutput(int flag)
        nfds = select(FD_SETSIZE, &readfds, (fd_set *) 0,
                           (fd_set *) 0, &timeout);
        if (nfds <= 0) {
-           if (interrupted) 
+           if (interrupted)
                JobPassSig(interrupted);
            return;
        }
@@ -2035,7 +2040,7 @@ Job_CatchOutput(int flag)
            Punt("Cannot open job table");
        }
        while (nfds && (ln = Lst_Next(jobs)) != NULL) {
-           job = (Job *) Lst_Datum(ln);
+           job = (Job *)Lst_Datum(ln);
            if (FD_ISSET(job->inPipe, &readfds)) {
                JobDoOutput(job, FALSE);
                nfds -= 1;
@@ -2063,7 +2068,8 @@ Job_CatchOutput(int flag)
 void
 Job_Make(GNode *gn)
 {
-    (void) JobStart(gn, 0, NULL);
+
+     JobStart(gn, 0, NULL);
 }
 
 /*
@@ -2182,8 +2188,8 @@ Job_Init(int maxproc)
     const char   *env;
     struct sigaction sa;
 
-    fifoFd =     -1;
-    jobs =       Lst_Init(FALSE);
+    fifoFd = -1;
+    jobs = Lst_Init(FALSE);
     stoppedJobs = Lst_Init(FALSE);
     env = getenv("MAKE_JOBS_FIFO");
 
@@ -2233,12 +2239,12 @@ Job_Init(int maxproc)
         jobFull = FALSE;
     } else {
     }
-    nJobs =      0;
+    nJobs = 0;
 
-    aborting =           0;
-    errors =     0;
+    aborting = 0;
+    errors = 0;
 
-    lastNode =   NULL;
+    lastNode = NULL;
 
     if ((maxJobs == 1 && fifoFd < 0) || beVerbose == 0) {
        /*
@@ -2262,16 +2268,16 @@ Job_Init(int maxproc)
     sa.sa_flags = 0;
 
     if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGINT, &sa, NULL);
+       sigaction(SIGINT, &sa, NULL);
     }
     if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGHUP, &sa, NULL);
+       sigaction(SIGHUP, &sa, NULL);
     }
     if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGQUIT, &sa, NULL);
+       sigaction(SIGQUIT, &sa, NULL);
     }
     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGTERM, &sa, NULL);
+       sigaction(SIGTERM, &sa, NULL);
     }
     /*
      * There are additional signals that need to be caught and passed if
@@ -2281,16 +2287,16 @@ Job_Init(int maxproc)
      */
 #if defined(USE_PGRP)
     if (signal(SIGTSTP, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGTSTP, &sa, NULL);
+       sigaction(SIGTSTP, &sa, NULL);
     }
     if (signal(SIGTTOU, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGTTOU, &sa, NULL);
+       sigaction(SIGTTOU, &sa, NULL);
     }
     if (signal(SIGTTIN, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGTTIN, &sa, NULL);
+       sigaction(SIGTTIN, &sa, NULL);
     }
     if (signal(SIGWINCH, SIG_IGN) != SIG_IGN) {
-       (void) sigaction(SIGWINCH, &sa, NULL);
+       sigaction(SIGWINCH, &sa, NULL);
     }
 #endif
 
@@ -2333,7 +2339,7 @@ Job_Full(void)
     int i;
 
     if (aborting)
-       return(aborting);
+       return (aborting);
     if (fifoFd >= 0 && jobFull) {
        i = read(fifoFd, &c, 1);
        if (i > 0) {
@@ -2341,7 +2347,7 @@ Job_Full(void)
            jobFull = FALSE;
        }
     }
-    return(jobFull);
+    return (jobFull);
 }
 
 /*-
@@ -2371,12 +2377,12 @@ Job_Empty(void)
             */
            jobFull = FALSE;
            JobRestartJobs();
-           return(FALSE);
+           return (FALSE);
        } else {
-           return(TRUE);
+           return (TRUE);
        }
     } else {
-       return(FALSE);
+       return (FALSE);
     }
 }
 
@@ -2497,7 +2503,7 @@ Job_ParseShell(char *line)
     Shell        *sh;
     Boolean      fullSpec = FALSE;
 
-    while (isspace((unsigned char) *line)) {
+    while (isspace((unsigned char)*line)) {
        line++;
     }
     words = brk_string(line, &wordCount, TRUE);
@@ -2537,7 +2543,7 @@ Job_ParseShell(char *line)
                 } else {
                     Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",
                                  *argv);
-                    return(FAILURE);
+                    return (FAILURE);
                 }
                 fullSpec = TRUE;
             }
@@ -2634,14 +2640,14 @@ JobInterrupt(int runINTERRUPT, int signo)
 
     aborting = ABORT_INTERRUPT;
 
-    (void) Lst_Open(jobs);
+    Lst_Open(jobs);
     while ((ln = Lst_Next(jobs)) != NULL) {
-       job = (Job *) Lst_Datum(ln);
+       job = (Job *)Lst_Datum(ln);
 
        if (!Targ_Precious(job->node)) {
-           char        *file = (job->node->path == NULL ?
-                                job->node->name :
-                                job->node->path);
+           char *file = (job->node->path == NULL ?
+                               job->node->name :
+                               job->node->path);
            if (!noExecute && eunlink(file) != -1) {
                Error("*** %s removed", file);
            }
@@ -2684,6 +2690,7 @@ JobInterrupt(int runINTERRUPT, int signo)
 int
 Job_Finish(void)
 {
+
     if (postCommands != NULL && !Lst_IsEmpty(postCommands->commands)) {
        if (errors) {
            Error("Errors reported so .END ignored");
@@ -2702,7 +2709,7 @@ Job_Finish(void)
        if (fifoMaster)
            unlink(fifoName);
     }
-    return(errors);
+    return (errors);
 }
 
 /*-
@@ -2722,6 +2729,7 @@ Job_Finish(void)
 void
 Job_Wait(void)
 {
+
     aborting = ABORT_WAIT;
     while (nJobs != 0) {
        Job_CatchOutput(0);
@@ -2755,9 +2763,9 @@ Job_AbortAll(void)
 
     if (nJobs) {
 
-       (void) Lst_Open(jobs);
+       Lst_Open(jobs);
        while ((ln = Lst_Next(jobs)) != NULL) {
-           job = (Job *) Lst_Datum(ln);
+           job = (Job *)Lst_Datum(ln);
 
            /*
             * kill the child process with increasingly drastic signals to make
@@ -2771,7 +2779,7 @@ Job_AbortAll(void)
     /*
      * Catch as many children as want to report in at first, then give up
      */
-    while (waitpid((pid_t) -1, &foo, WNOHANG) > 0)
+    while (waitpid((pid_t)-1, &foo, WNOHANG) > 0)
        continue;
 }
 
index 6557deb..16ba5f9 100644 (file)
@@ -38,7 +38,7 @@
  *
  *     from: @(#)job.h 8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/job.h,v 1.11 2000/01/17 06:43:41 kris Exp $
- * $DragonFly: src/usr.bin/make/job.h,v 1.14 2004/12/10 01:16:25 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/job.h,v 1.15 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -61,7 +61,6 @@
 #define        SEL_USEC        0
 #endif /* !USE_KQUEUE */
 
-\f
 /*-
  * Job Table definitions.
  *
@@ -149,7 +148,6 @@ typedef struct Job {
 #define        outFile         output.o_file.of_outFile
 #define        outFd           output.o_file.of_outFd
 
-\f
 /*-
  * Shell Specifications:
  * Each shell type has associated with it the following information:
index 3285af0..b91e213 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstAppend.c,v 1.6 1999/08/28 01:03:45 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstAppend.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstAppend.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstAppend.c     8.1 (Berkeley) 6/6/93
  */
@@ -73,11 +73,11 @@ Lst_Append(Lst list, LstNode ln, void *d)
 {
     LstNode    nLNode;
 
-    if (Lst_Valid (list) && (ln == NULL && Lst_IsEmpty (list))) {
+    if (Lst_Valid(list) && (ln == NULL && Lst_IsEmpty(list))) {
        goto ok;
     }
 
-    if (!Lst_Valid (list) || Lst_IsEmpty (list)  || ! Lst_NodeValid(ln, list)) {
+    if (!Lst_Valid(list) || Lst_IsEmpty(list)  || ! Lst_NodeValid(ln, list)) {
        return (FAILURE);
     }
     ok:
index c8eed4f..e341591 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstConcat.c,v 1.7 1999/08/28 01:03:47 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstConcat.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstConcat.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstConcat.c     8.1 (Berkeley) 6/6/93
  */
@@ -77,7 +77,8 @@ Lst_Concat(Lst list1, Lst list2, int flags)
     LstNode    nln;    /* new LstNode */
     LstNode    last;   /* the last element in the list. Keeps
                         * bookkeeping until the end */
-    if (!Lst_Valid (list1) || !Lst_Valid (list2)) {
+
+    if (!Lst_Valid(list1) || !Lst_Valid(list2)) {
        return (FAILURE);
     }
 
@@ -117,7 +118,7 @@ Lst_Concat(Lst list1, Lst list2, int flags)
            list1->firstPtr->prevPtr = list1->lastPtr;
            list1->lastPtr->nextPtr = list1->firstPtr;
        }
-       free (list2);
+       free(list2);
     } else if (list2->firstPtr != NULL) {
        /*
         * We set the nextPtr of the last element of list 2 to be NULL to make
index f8eb478..29c15d3 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstDeQueue.c,v 1.6 1999/08/28 01:03:48 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDeQueue.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDeQueue.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstDeQueue.c    8.1 (Berkeley) 6/6/93
  */
@@ -67,13 +67,13 @@ Lst_DeQueue(Lst l)
     void *     rd;
     LstNode    tln;
 
-    tln = Lst_First (l);
+    tln = Lst_First(l);
     if (tln == NULL) {
        return (NULL);
     }
 
     rd = tln->datum;
-    if (Lst_Remove (l, tln) == FAILURE) {
+    if (Lst_Remove(l, tln) == FAILURE) {
        return (NULL);
     } else {
        return (rd);
index 63aee80..b1dafd9 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstDestroy.c,v 1.7 1999/08/28 01:03:49 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDestroy.c,v 1.7 2004/12/09 19:08:36 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDestroy.c,v 1.8 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstDestroy.c    8.1 (Berkeley) 6/6/93
  */
@@ -80,22 +80,22 @@ Lst_Destroy(Lst list, FreeProc *freeProc)
     if (list->lastPtr != NULL)
        list->lastPtr->nextPtr = NULL;
     else {
-       free (list);
+       free(list);
        return;
     }
 
     if (freeProc) {
        for (ln = list->firstPtr; ln != NULL; ln = tln) {
             tln = ln->nextPtr;
-            (*freeProc) (ln->datum);
-            free (ln);
+            (*freeProc)(ln->datum);
+            free(ln);
        }
     } else {
        for (ln = list->firstPtr; ln != NULL; ln = tln) {
             tln = ln->nextPtr;
-            free (ln);
+            free(ln);
        }
     }
 
-    free (list);
+    free(list);
 }
index 837858e..8bd2480 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstDupl.c,v 1.7 1999/08/28 01:03:49 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDupl.c,v 1.7 2004/12/09 19:08:36 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstDupl.c,v 1.8 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstDupl.c       8.1 (Berkeley) 6/6/93
  */
@@ -71,11 +71,11 @@ Lst_Duplicate(Lst list, DuplicateProc *copyProc)
     Lst        nl;
     LstNode    ln;
 
-    if (!Lst_Valid (list)) {
+    if (!Lst_Valid(list)) {
        return (NULL);
     }
 
-    nl = Lst_Init (list->isCirc);
+    nl = Lst_Init(list->isCirc);
     if (nl == NULL) {
        return (NULL);
     }
@@ -83,7 +83,7 @@ Lst_Duplicate(Lst list, DuplicateProc *copyProc)
     ln = list->firstPtr;
     while (ln != NULL) {
        if (copyProc != NOCOPY) {
-           if (Lst_AtEnd (nl, (*copyProc) (ln->datum)) == FAILURE) {
+           if (Lst_AtEnd(nl, (*copyProc)(ln->datum)) == FAILURE) {
                return (NULL);
            }
        } else if (Lst_AtEnd (nl, ln->datum) == FAILURE) {
index 6d9bedb..9aca477 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstFindFrom.c,v 1.7 1999/08/28 01:03:50 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstFindFrom.c,v 1.7 2004/12/09 19:08:36 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstFindFrom.c,v 1.8 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstFindFrom.c   8.1 (Berkeley) 6/6/93
  */
@@ -68,14 +68,14 @@ Lst_FindFrom(Lst l, LstNode ln, void *d, CompareProc *cProc)
     LstNode    tln;
     Boolean    found = FALSE;
 
-    if (!Lst_Valid (l) || Lst_IsEmpty (l) || !Lst_NodeValid (ln, l)) {
+    if (!Lst_Valid(l) || Lst_IsEmpty(l) || !Lst_NodeValid(ln, l)) {
        return (NULL);
     }
 
     tln = ln;
 
     do {
-       if ((*cProc) (tln->datum, d) == 0) {
+       if ((*cProc)(tln->datum, d) == 0) {
            found = TRUE;
            break;
        } else {
index fdd53b5..6215f46 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstForEachFrom.c,v 1.7 1999/08/28 01:03:52 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstForEachFrom.c,v 1.7 2004/12/09 19:08:36 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstForEachFrom.c,v 1.8 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstForEachFrom.c        8.1 (Berkeley) 6/6/93
  */
@@ -70,7 +70,7 @@ Lst_ForEachFrom(Lst list, LstNode ln, DoProc *proc, void *d)
     Boolean    done;
     int        result;
 
-    if (!Lst_Valid (list) || Lst_IsEmpty (list)) {
+    if (!Lst_Valid(list) || Lst_IsEmpty(list)) {
        return;
     }
 
@@ -82,9 +82,9 @@ Lst_ForEachFrom(Lst list, LstNode ln, DoProc *proc, void *d)
 
        next = ln->nextPtr;
 
-       (void) ln->useCount++;
-       result = (*proc) (ln->datum, d);
-       (void) ln->useCount--;
+       ln->useCount++;
+       result = (*proc)(ln->datum, d);
+       ln->useCount--;
 
        /*
         * We're done with the traversal if
index fd36bf8..bac3849 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstInsert.c,v 1.6 1999/08/28 01:03:52 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstInsert.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstInsert.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstInsert.c     8.1 (Berkeley) 6/6/93
  */
@@ -74,10 +74,10 @@ Lst_Insert(Lst list, LstNode ln, void *d)
     /*
      * check validity of arguments
      */
-    if (Lst_Valid (list) && (Lst_IsEmpty (list) && ln == NULL))
+    if (Lst_Valid(list) && (Lst_IsEmpty(list) && ln == NULL))
        goto ok;
 
-    if (!Lst_Valid (list) || Lst_IsEmpty (list) || !Lst_NodeValid (ln, list)) {
+    if (!Lst_Valid(list) || Lst_IsEmpty(list) || !Lst_NodeValid(ln, list)) {
        return (FAILURE);
     }
 
index fd271bd..f3f1472 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstIsAtEnd.c,v 1.5 1999/08/28 01:03:53 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstIsAtEnd.c,v 1.4 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstIsAtEnd.c,v 1.5 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstIsAtEnd.c    8.1 (Berkeley) 6/6/93
  */
@@ -75,6 +75,6 @@ Boolean
 Lst_IsAtEnd(Lst list)
 {
 
-    return (!Lst_Valid (list) || !list->isOpen ||
+    return (!Lst_Valid(list) || !list->isOpen ||
            (list->atEnd == LstHead) || (list->atEnd == LstTail));
 }
index 5fd9c1e..bce1e42 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstNext.c,v 1.6 1999/08/28 01:03:55 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstNext.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstNext.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstNext.c       8.1 (Berkeley) 6/6/93
  */
@@ -72,7 +72,7 @@ Lst_Next(Lst list)
 {
     LstNode    tln;
 
-    if ((Lst_Valid (list) == FALSE) || (list->isOpen == FALSE)) {
+    if ((Lst_Valid(list) == FALSE) || (list->isOpen == FALSE)) {
            return (NULL);
     }
 
index 9fa6bc4..ed3a2ef 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstOpen.c,v 1.5 1999/08/28 01:03:56 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstOpen.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstOpen.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstOpen.c       8.1 (Berkeley) 6/6/93
  */
@@ -71,11 +71,11 @@ ReturnStatus
 Lst_Open(Lst l)
 {
 
-       if (Lst_Valid (l) == FALSE) {
+       if (Lst_Valid(l) == FALSE) {
                return (FAILURE);
        }
        l->isOpen = TRUE;
-       l->atEnd = Lst_IsEmpty (l) ? LstHead : LstUnknown;
+       l->atEnd = Lst_IsEmpty(l) ? LstHead : LstUnknown;
        l->curPtr = NULL;
 
        return (SUCCESS);
index fe46ed9..aecc34e 100644 (file)
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/usr.bin/make/lst.lib/lstRemove.c,v 1.6 1999/08/28 01:03:56 peter Exp $
- * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstRemove.c,v 1.5 2004/12/08 11:26:39 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/lst.lib/Attic/lstRemove.c,v 1.6 2004/12/10 19:22:25 okumoto Exp $
  *
  * @(#)lstRemove.c     8.1 (Berkeley) 6/6/93
  */
@@ -66,7 +66,7 @@ ReturnStatus
 Lst_Remove(Lst list, LstNode ln)
 {
 
-    if (!Lst_Valid (list) || !Lst_NodeValid (ln, list)) {
+    if (!Lst_Valid(list) || !Lst_NodeValid(ln, list)) {
            return (FAILURE);
     }
 
index 20588e5..487945f 100644 (file)
@@ -38,7 +38,7 @@
  * @(#) Copyright (c) 1988, 1989, 1990, 1993 The Regents of the University of California.  All rights reserved.
  * @(#)main.c  8.3 (Berkeley) 3/19/94
  * $FreeBSD: src/usr.bin/make/main.c,v 1.35.2.10 2003/12/16 08:34:11 des Exp $
- * $DragonFly: src/usr.bin/make/main.c,v 1.30 2004/12/10 01:16:25 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/main.c,v 1.31 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -127,6 +127,7 @@ static char *objdir;                        /* where we chdir'ed to */
 static void
 MFLAGS_append(char *flag, char *arg)
 {
+
        Var_Append(MAKEFLAGS, flag, VAR_GLOBAL);
        if (arg != NULL)
                Var_Append(MAKEFLAGS, arg, VAR_GLOBAL);
@@ -249,8 +250,8 @@ rearg:      while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
                }
                case 'E':
                        p = emalloc(strlen(optarg) + 1);
-                       (void)strcpy(p, optarg);
-                       (void)Lst_AtEnd(envFirstVars, (void *)p);
+                       strcpy(p, optarg);
+                       Lst_AtEnd(envFirstVars, (void *)p);
                        MFLAGS_append("-E", optarg);
                        break;
                case 'e':
@@ -258,7 +259,7 @@ rearg:      while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
                        MFLAGS_append("-e", NULL);
                        break;
                case 'f':
-                       (void)Lst_AtEnd(makefiles, (void *)optarg);
+                       Lst_AtEnd(makefiles, (void *)optarg);
                        break;
                case 'i':
                        ignoreErrors = TRUE;
@@ -341,7 +342,7 @@ rearg:      while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
                                        optind = 1;     /* - */
                                goto rearg;
                        }
-                       (void)Lst_AtEnd(create, (void *)estrdup(*argv));
+                       Lst_AtEnd(create, (void *)estrdup(*argv));
                }
 }
 
@@ -385,12 +386,12 @@ chdir_verify_path(char *path, char *obpath)
        if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
                if (chdir(path) == -1 || getcwd(obpath, MAXPATHLEN) == NULL) {
                        warn("warning: %s", path);
-                       return 0;
+                       return (0);
                }
-               return obpath;
+               return (obpath);
        }
 
-       return 0;
+       return (0);
 }
 
 static void
@@ -492,7 +493,7 @@ main(int argc, char **argv)
                if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
                    rl.rlim_cur != rl.rlim_max) {
                        rl.rlim_cur = rl.rlim_max;
-                       (void) setrlimit(RLIMIT_NOFILE, &rl);
+                       setrlimit(RLIMIT_NOFILE, &rl);
                }
        }
 #endif
@@ -652,11 +653,11 @@ main(int argc, char **argv)
                if (!(path = getenv("MAKEOBJDIR"))) {
                        path = _PATH_OBJDIR;
                        pathp = _PATH_OBJDIRPREFIX;
-                       (void) snprintf(mdpath, MAXPATHLEN, "%s.%s",
+                       snprintf(mdpath, MAXPATHLEN, "%s.%s",
                                        path, machine);
                        if (!(objdir = chdir_verify_path(mdpath, obpath)))
                                if (!(objdir=chdir_verify_path(path, obpath))) {
-                                       (void) snprintf(mdpath, MAXPATHLEN,
+                                       snprintf(mdpath, MAXPATHLEN,
                                                        "%s%s", pathp, curdir);
                                        if (!(objdir=chdir_verify_path(mdpath,
                                                                       obpath)))
@@ -667,7 +668,7 @@ main(int argc, char **argv)
                        objdir = curdir;
        }
        else {
-               (void) snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
+               snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
                if (!(objdir = chdir_verify_path(mdpath, obpath)))
                        objdir = curdir;
        }
@@ -696,7 +697,7 @@ main(int argc, char **argv)
        Suff_Init();
 
        DEFAULT = NULL;
-       (void)time(&now);
+       time(&now);
 
        /*
         * Set up the .TARGETS variable to contain the list of targets to be
@@ -742,8 +743,8 @@ main(int argc, char **argv)
        if (!noBuiltins) {
                LstNode ln;
 
-               sysMkPath = Lst_Init (FALSE);
-               Dir_Expand (_PATH_DEFSYSMK, sysIncPath, sysMkPath);
+               sysMkPath = Lst_Init(FALSE);
+               Dir_Expand(_PATH_DEFSYSMK, sysIncPath, sysMkPath);
                if (Lst_IsEmpty(sysMkPath))
                        Fatal("make: no system rules (%s).", _PATH_DEFSYSMK);
                ln = Lst_Find(sysMkPath, (void *)NULL, ReadMakefile);
@@ -759,9 +760,9 @@ main(int argc, char **argv)
                        Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
        } else if (!ReadMakefile("BSDmakefile", NULL))
            if (!ReadMakefile("makefile", NULL))
-               (void)ReadMakefile("Makefile", NULL);
+               ReadMakefile("Makefile", NULL);
 
-       (void)ReadMakefile(".depend", NULL);
+       ReadMakefile(".depend", NULL);
 
        /* Install all the flags into the MAKE envariable. */
        if (((p = Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1)) != NULL) && *p)
@@ -797,7 +798,7 @@ main(int argc, char **argv)
                        *cp = savec;
                        path = cp + 1;
                } while (savec == ':');
-               (void)free(vpath);
+               free(vpath);
        }
 
        /*
@@ -820,7 +821,7 @@ main(int argc, char **argv)
                        if (expandVars) {
                                p1 = emalloc(strlen((char *)Lst_Datum(ln)) + 1 + 3);
                                /* This sprintf is safe, because of the malloc above */
-                               (void)sprintf(p1, "${%s}", (char *)Lst_Datum(ln));
+                               sprintf(p1, "${%s}", (char *)Lst_Datum(ln));
                                value = Var_Subst(NULL, p1, VAR_GLOBAL, FALSE);
                        } else {
                                value = Var_Value((char *)Lst_Datum(ln),
@@ -884,9 +885,9 @@ main(int argc, char **argv)
        Dir_End();
 
        if (queryFlag && outOfDate)
-               return(1);
+               return (1);
        else
-               return(0);
+               return (0);
 }
 
 /*-
@@ -918,7 +919,7 @@ ReadMakefile(void *p, void *q __unused)
 
                /* if we've chdir'd, rebuild the path name */
                if (curdir != objdir && *fname != '/') {
-                       (void)snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname);
+                       snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname);
                        /*
                         * XXX The realpath stuff breaks relative includes
                         * XXX in some cases.   The problem likely is in
@@ -964,7 +965,7 @@ ReadMakefile(void *p, void *q __unused)
                if (!name)
                        name = Dir_FindFile(fname, sysIncPath);
                if (!name || !(stream = fopen(name, "r")))
-                       return(FALSE);
+                       return (FALSE);
                MAKEFILE = fname = name;
                /*
                 * set the MAKEFILE variable desired by System V fans -- the
@@ -975,9 +976,9 @@ found:
                if (setMAKEFILE)
                        Var_Set("MAKEFILE", MAKEFILE, VAR_GLOBAL);
                Parse_File(fname, stream);
-               (void)fclose(stream);
+               fclose(stream);
        }
-       return(TRUE);
+       return (TRUE);
 }
 
 /*-
@@ -1033,17 +1034,17 @@ Cmd_Exec(char *cmd, char **error)
        /*
         * Close input side of pipe
         */
-       (void) close(fds[0]);
+       close(fds[0]);
 
        /*
         * Duplicate the output stream to the shell's output, then
         * shut the extra thing down. Note we don't fetch the error
         * stream...why not? Why?
         */
-       (void) dup2(fds[1], 1);
-       (void) close(fds[1]);
+       dup2(fds[1], 1);
+       close(fds[1]);
 
-       (void) execv(shellPath, args);
+       execv(shellPath, args);
        _exit(1);
        /*NOTREACHED*/
 
@@ -1055,34 +1056,34 @@ Cmd_Exec(char *cmd, char **error)
        /*
         * No need for the writing half
         */
-       (void) close(fds[1]);
+       close(fds[1]);
 
-       buf = Buf_Init (MAKE_BSIZE);
+       buf = Buf_Init(MAKE_BSIZE);
 
        do {
            char   result[BUFSIZ];
            cc = read(fds[0], result, sizeof(result));
            if (cc > 0)
-               Buf_AddBytes(buf, cc, (Byte *) result);
+               Buf_AddBytes(buf, cc, (Byte *)result);
        }
        while (cc > 0 || (cc == -1 && errno == EINTR));
 
        /*
         * Close the input side of the pipe.
         */
-       (void) close(fds[0]);
+       close(fds[0]);
 
        /*
         * Wait for the process to exit.
         */
-       while(((pid = wait(&status)) != cpid) && (pid >= 0))
+       while (((pid = wait(&status)) != cpid) && (pid >= 0))
            continue;
 
        if (cc == -1)
            *error = "Error reading shell's output for \"%s\"";
 
-       res = (char *)Buf_GetAll (buf, &cc);
-       Buf_Destroy (buf, FALSE);
+       res = (char *)Buf_GetAll(buf, &cc);
+       Buf_Destroy(buf, FALSE);
 
        if (status)
            *error = "\"%s\" returned non-zero status";
@@ -1108,11 +1109,11 @@ Cmd_Exec(char *cmd, char **error)
        }
        break;
     }
-    return res;
+    return (res);
 bad:
     res = emalloc(1);
     *res = '\0';
-    return res;
+    return (res);
 }
  
 /*
@@ -1122,7 +1123,7 @@ bad:
 static void
 usage(void)
 {
-       (void)fprintf(stderr, "%s\n%s\n%s\n",
+       fprintf(stderr, "%s\n%s\n%s\n",
 "usage: make [-BPSXeiknqrstv] [-C directory] [-D variable] [-d flags]",
 "            [-E variable] [-f makefile] [-I directory] [-j max_jobs]",
 "            [-m directory] [-V variable] [variable=value] [target ...]");
index 11ee5ee..1b9375a 100644 (file)
@@ -37,7 +37,7 @@
  *
  * @(#)make.c  8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/make.c,v 1.11 1999/09/11 13:08:01 hoek Exp $
- * $DragonFly: src/usr.bin/make/make.c,v 1.11 2004/12/10 01:16:25 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/make.c,v 1.12 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -92,6 +92,7 @@ static int MakeTimeStamp(void *, void *);
 static int MakeHandleUse(void *, void *);
 static Boolean MakeStartJobs(void);
 static int MakePrintStatus(void *, void *);
+
 /*-
  *-----------------------------------------------------------------------
  * Make_TimeStamp --
@@ -107,8 +108,9 @@ static int MakePrintStatus(void *, void *);
  *-----------------------------------------------------------------------
  */
 int
-Make_TimeStamp (GNode *pgn, GNode *cgn)
+Make_TimeStamp(GNode *pgn, GNode *cgn)
 {
+
     if (cgn->mtime > pgn->cmtime) {
        pgn->cmtime = cgn->mtime;
     }
@@ -116,11 +118,12 @@ Make_TimeStamp (GNode *pgn, GNode *cgn)
 }
 
 static int
-MakeTimeStamp (void *pgn, void *cgn)
+MakeTimeStamp(void *pgn, void *cgn)
 {
-    return Make_TimeStamp((GNode *) pgn, (GNode *) cgn);
+
+    return (Make_TimeStamp((GNode *)pgn, (GNode *)cgn));
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Make_OODate --
@@ -140,7 +143,7 @@ MakeTimeStamp (void *pgn, void *cgn)
  *-----------------------------------------------------------------------
  */
 Boolean
-Make_OODate (GNode *gn)
+Make_OODate(GNode *gn)
 {
     Boolean         oodate;
 
@@ -148,8 +151,8 @@ Make_OODate (GNode *gn)
      * Certain types of targets needn't even be sought as their datedness
      * doesn't depend on their modification time...
      */
-    if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC)) == 0) {
-       (void) Dir_MTime (gn);
+    if ((gn->type & (OP_JOIN | OP_USE | OP_EXEC)) == 0) {
+        Dir_MTime(gn);
        if (gn->mtime != 0) {
            DEBUGF(MAKE, ("modified %s...", Targ_FmtTime(gn->mtime)));
        } else {
@@ -185,7 +188,7 @@ Make_OODate (GNode *gn)
         * always out of date if no children and :: target
         */
 
-       oodate = Arch_LibOODate (gn) ||
+       oodate = Arch_LibOODate(gn) ||
            ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP));
     } else if (gn->type & OP_JOIN) {
        /*
@@ -237,12 +240,12 @@ Make_OODate (GNode *gn)
      * thinking they're out-of-date.
      */
     if (!oodate) {
-       Lst_ForEach (gn->parents, MakeTimeStamp, (void *)gn);
+       Lst_ForEach(gn->parents, MakeTimeStamp, (void *)gn);
     }
 
     return (oodate);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * MakeAddChild  --
@@ -257,17 +260,17 @@ Make_OODate (GNode *gn)
  *-----------------------------------------------------------------------
  */
 static int
-MakeAddChild (void *gnp, void *lp)
+MakeAddChild(void *gnp, void *lp)
 {
-    GNode          *gn = (GNode *) gnp;
-    Lst            l = (Lst) lp;
+    GNode          *gn = (GNode *)gnp;
+    Lst            l = (Lst)lp;
 
     if (!gn->make && !(gn->type & OP_USE)) {
-       (void)Lst_EnQueue (l, (void *)gn);
+       Lst_EnQueue(l, (void *)gn);
     }
     return (0);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Make_HandleUse --
@@ -292,7 +295,7 @@ MakeAddChild (void *gnp, void *lp)
  *-----------------------------------------------------------------------
  */
 int
-Make_HandleUse (GNode *cgn, GNode *pgn)
+Make_HandleUse(GNode *cgn, GNode *pgn)
 {
     GNode      *gn;            /* A child of the .USE node */
     LstNode    ln;             /* An element in the children list */
@@ -303,23 +306,23 @@ Make_HandleUse (GNode *cgn, GNode *pgn)
             * .USE or transformation and target has no commands -- append
             * the child's commands to the parent.
             */
-           (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW);
+            Lst_Concat(pgn->commands, cgn->commands, LST_CONCNEW);
        }
 
-       if (Lst_Open (cgn->children) == SUCCESS) {
-           while ((ln = Lst_Next (cgn->children)) != NULL) {
-               gn = (GNode *)Lst_Datum (ln);
+       if (Lst_Open(cgn->children) == SUCCESS) {
+           while ((ln = Lst_Next(cgn->children)) != NULL) {
+               gn = (GNode *)Lst_Datum(ln);
 
-               if (Lst_Member (pgn->children, gn) == NULL) {
-                   (void) Lst_AtEnd (pgn->children, gn);
-                   (void) Lst_AtEnd (gn->parents, pgn);
+               if (Lst_Member(pgn->children, gn) == NULL) {
+                   Lst_AtEnd(pgn->children, gn);
+                   Lst_AtEnd(gn->parents, pgn);
                    pgn->unmade += 1;
                }
            }
-           Lst_Close (cgn->children);
+           Lst_Close(cgn->children);
        }
 
-       pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM);
+       pgn->type |= cgn->type & ~(OP_OPMASK | OP_USE | OP_TRANSFORM);
 
        /*
         * This child node is now "made", so we decrement the count of
@@ -334,12 +337,14 @@ Make_HandleUse (GNode *cgn, GNode *pgn)
     }
     return (0);
 }
+
 static int
-MakeHandleUse (void *pgn, void *cgn)
+MakeHandleUse(void *pgn, void *cgn)
 {
-    return Make_HandleUse((GNode *) pgn, (GNode *) cgn);
+
+    return (Make_HandleUse((GNode *)pgn, (GNode *)cgn));
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Make_Update  --
@@ -366,14 +371,14 @@ MakeHandleUse (void *pgn, void *cgn)
  *-----------------------------------------------------------------------
  */
 void
-Make_Update (GNode *cgn)
+Make_Update(GNode *cgn)
 {
     GNode      *pgn;           /* the parent node */
     char       *cname;         /* the child's name */
     LstNode    ln;             /* Element in parents and iParents lists */
     char       *p1;
 
-    cname = Var_Value (TARGET, cgn, &p1);
+    cname = Var_Value(TARGET, cgn, &p1);
     free(p1);
 
     /*
@@ -441,20 +446,20 @@ Make_Update (GNode *cgn)
 #endif
     }
 
-    if (Lst_Open (cgn->parents) == SUCCESS) {
-       while ((ln = Lst_Next (cgn->parents)) != NULL) {
-           pgn = (GNode *)Lst_Datum (ln);
+    if (Lst_Open(cgn->parents) == SUCCESS) {
+       while ((ln = Lst_Next(cgn->parents)) != NULL) {
+           pgn = (GNode *)Lst_Datum(ln);
            if (pgn->make) {
                pgn->unmade -= 1;
 
-               if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
+               if (!(cgn->type & (OP_EXEC | OP_USE))) {
                    if (cgn->made == MADE) {
                        pgn->childMade = TRUE;
                        if (pgn->cmtime < cgn->mtime) {
                            pgn->cmtime = cgn->mtime;
                        }
                    } else {
-                       (void)Make_TimeStamp (pgn, cgn);
+                       Make_TimeStamp(pgn, cgn);
                    }
                }
                if (pgn->unmade == 0) {
@@ -462,13 +467,13 @@ Make_Update (GNode *cgn)
                     * Queue the node up -- any unmade predecessors will
                     * be dealt with in MakeStartJobs.
                     */
-                   (void)Lst_EnQueue (toBeMade, (void *)pgn);
+                   Lst_EnQueue(toBeMade, (void *)pgn);
                } else if (pgn->unmade < 0) {
-                   Error ("Graph cycles through %s", pgn->name);
+                   Error("Graph cycles through %s", pgn->name);
                }
            }
        }
-       Lst_Close (cgn->parents);
+       Lst_Close(cgn->parents);
     }
     /*
      * Deal with successor nodes. If any is marked for making and has an unmade
@@ -482,7 +487,7 @@ Make_Update (GNode *cgn)
        if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
            Lst_Member(toBeMade, (void *)succ) == NULL)
        {
-           (void)Lst_EnQueue(toBeMade, (void *)succ);
+           Lst_EnQueue(toBeMade, (void *)succ);
        }
     }
 
@@ -490,22 +495,22 @@ Make_Update (GNode *cgn)
      * Set the .PREFIX and .IMPSRC variables for all the implied parents
      * of this node.
      */
-    if (Lst_Open (cgn->iParents) == SUCCESS) {
+    if (Lst_Open(cgn->iParents) == SUCCESS) {
        char    *ptr;
        char    *cpref = Var_Value(PREFIX, cgn, &ptr);
 
-       while ((ln = Lst_Next (cgn->iParents)) != NULL) {
+       while ((ln = Lst_Next(cgn->iParents)) != NULL) {
            pgn = (GNode *)Lst_Datum (ln);
            if (pgn->make) {
-               Var_Set (IMPSRC, cname, pgn);
-               Var_Set (PREFIX, cpref, pgn);
+               Var_Set(IMPSRC, cname, pgn);
+               Var_Set(PREFIX, cpref, pgn);
            }
        }
        free(ptr);
-       Lst_Close (cgn->iParents);
+       Lst_Close(cgn->iParents);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * MakeAddAllSrc --
@@ -527,11 +532,12 @@ Make_Update (GNode *cgn)
  *-----------------------------------------------------------------------
  */
 static int
-MakeAddAllSrc (void *cgnp, void *pgnp)
+MakeAddAllSrc(void *cgnp, void *pgnp)
 {
     GNode      *cgn = (GNode *) cgnp;
     GNode      *pgn = (GNode *) pgnp;
-    if ((cgn->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) == 0) {
+
+    if ((cgn->type & (OP_EXEC | OP_USE | OP_INVISIBLE)) == 0) {
        char *child;
        char *p1 = NULL;
 
@@ -543,7 +549,7 @@ MakeAddAllSrc (void *cgnp, void *pgnp)
        }
        else
            child = Var_Value(TARGET, cgn, &p1);
-       Var_Append (ALLSRC, child, pgn);
+       Var_Append(ALLSRC, child, pgn);
        if (pgn->type & OP_JOIN) {
            if (cgn->made == MADE) {
                Var_Append(OODATE, child, pgn);
@@ -573,7 +579,7 @@ MakeAddAllSrc (void *cgnp, void *pgnp)
     }
     return (0);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Make_DoAllVar --
@@ -597,24 +603,26 @@ MakeAddAllSrc (void *cgnp, void *pgnp)
  *-----------------------------------------------------------------------
  */
 void
-Make_DoAllVar (GNode *gn)
+Make_DoAllVar(GNode *gn)
 {
-    Lst_ForEach (gn->children, MakeAddAllSrc, (void *) gn);
+
+    Lst_ForEach(gn->children, MakeAddAllSrc, (void *)gn);
 
     if (!Var_Exists (OODATE, gn)) {
-       Var_Set (OODATE, "", gn);
+       Var_Set(OODATE, "", gn);
     }
     if (!Var_Exists (ALLSRC, gn)) {
-       Var_Set (ALLSRC, "", gn);
+       Var_Set(ALLSRC, "", gn);
     }
 
     if (gn->type & OP_JOIN) {
        char *p1;
-       Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn);
+
+       Var_Set(TARGET, Var_Value(ALLSRC, gn, &p1), gn);
        free(p1);
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * MakeStartJobs --
@@ -632,12 +640,12 @@ Make_DoAllVar (GNode *gn)
  *-----------------------------------------------------------------------
  */
 static Boolean
-MakeStartJobs (void)
+MakeStartJobs(void)
 {
     GNode      *gn;
 
     while (!Lst_IsEmpty (toBeMade) && !Job_Full()) {
-       gn = (GNode *) Lst_DeQueue (toBeMade);
+       gn = (GNode *)Lst_DeQueue(toBeMade);
        DEBUGF(MAKE, ("Examining %s...", gn->name));
        /*
         * Make sure any and all predecessors that are going to be made,
@@ -666,13 +674,13 @@ MakeStartJobs (void)
        }
 
        numNodes--;
-       if (Make_OODate (gn)) {
+       if (Make_OODate(gn)) {
            DEBUGF(MAKE, ("out-of-date\n"));
            if (queryFlag) {
                return (TRUE);
            }
-           Make_DoAllVar (gn);
-           Job_Make (gn);
+           Make_DoAllVar(gn);
+           Job_Make(gn);
        } else {
            DEBUGF(MAKE, ("up-to-date\n"));
            gn->made = UPTODATE;
@@ -683,15 +691,15 @@ MakeStartJobs (void)
                 * value for .TARGET when building up the context variables
                 * of its parent(s)...
                 */
-               Make_DoAllVar (gn);
+               Make_DoAllVar(gn);
            }
 
-           Make_Update (gn);
+           Make_Update(gn);
        }
     }
     return (FALSE);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * MakePrintStatus --
@@ -712,10 +720,11 @@ MakeStartJobs (void)
 static int
 MakePrintStatus(void *gnp, void *cyclep)
 {
-    GNode      *gn = (GNode *) gnp;
-    Boolean    cycle = *(Boolean *) cyclep;
+    GNode      *gn = (GNode *)gnp;
+    Boolean    cycle = *(Boolean *)cyclep;
+
     if (gn->made == UPTODATE) {
-       printf ("`%s' is up to date.\n", gn->name);
+       printf("`%s' is up to date.\n", gn->name);
     } else if (gn->unmade != 0) {
        if (cycle) {
            Boolean t = TRUE;
@@ -732,19 +741,19 @@ MakePrintStatus(void *gnp, void *cyclep)
            if (gn->made == CYCLE) {
                Error("Graph cycles through `%s'", gn->name);
                gn->made = ENDCYCLE;
-               Lst_ForEach(gn->children, MakePrintStatus, (void *) &t);
+               Lst_ForEach(gn->children, MakePrintStatus, (void *)&t);
                gn->made = UNMADE;
            } else if (gn->made != ENDCYCLE) {
                gn->made = CYCLE;
-               Lst_ForEach(gn->children, MakePrintStatus, (void *) &t);
+               Lst_ForEach(gn->children, MakePrintStatus, (void *)&t);
            }
        } else {
-           printf ("`%s' not remade because of errors.\n", gn->name);
+           printf("`%s' not remade because of errors.\n", gn->name);
        }
     }
     return (0);
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * Make_Run --
@@ -767,13 +776,13 @@ MakePrintStatus(void *gnp, void *cyclep)
  *-----------------------------------------------------------------------
  */
 Boolean
-Make_Run (Lst targs)
+Make_Run(Lst targs)
 {
     GNode          *gn;        /* a temporary pointer */
     Lst                    examine;    /* List of targets to examine */
     int                    errors;     /* Number of errors the Job module reports */
 
-    toBeMade = Lst_Init (FALSE);
+    toBeMade = Lst_Init(FALSE);
 
     examine = Lst_Duplicate(targs, NOCOPY);
     numNodes = 0;
@@ -786,8 +795,8 @@ Make_Run (Lst targs)
      * be looked at in a minute, otherwise we add its children to our queue
      * and go on about our business.
      */
-    while (!Lst_IsEmpty (examine)) {
-       gn = (GNode *) Lst_DeQueue (examine);
+    while (!Lst_IsEmpty(examine)) {
+       gn = (GNode *)Lst_DeQueue(examine);
 
        if (!gn->make) {
            gn->make = TRUE;
@@ -797,18 +806,18 @@ Make_Run (Lst targs)
             * Apply any .USE rules before looking for implicit dependencies
             * to make sure everything has commands that should...
             */
-           Lst_ForEach (gn->children, MakeHandleUse, (void *)gn);
-           Suff_FindDeps (gn);
+           Lst_ForEach(gn->children, MakeHandleUse, (void *)gn);
+           Suff_FindDeps(gn);
 
            if (gn->unmade != 0) {
-               Lst_ForEach (gn->children, MakeAddChild, (void *)examine);
+               Lst_ForEach(gn->children, MakeAddChild, (void *)examine);
            } else {
-               (void)Lst_EnQueue (toBeMade, (void *)gn);
+               Lst_EnQueue(toBeMade, (void *)gn);
            }
        }
     }
 
-    Lst_Destroy (examine, NOFREE);
+    Lst_Destroy(examine, NOFREE);
 
     if (queryFlag) {
        /*
@@ -825,7 +834,7 @@ Make_Run (Lst targs)
         * the finishing of a job. So we fill the Job table as much as we can
         * before going into our loop.
         */
-       (void) MakeStartJobs();
+        MakeStartJobs();
     }
 
     /*
@@ -839,9 +848,9 @@ Make_Run (Lst targs)
      * keepgoing flag was given.
      */
     while (!Job_Empty ()) {
-       Job_CatchOutput (!Lst_IsEmpty (toBeMade));
-       Job_CatchChildren (!usePipes);
-       (void)MakeStartJobs();
+       Job_CatchOutput(!Lst_IsEmpty (toBeMade));
+       Job_CatchChildren(!usePipes);
+       MakeStartJobs();
     }
 
     errors = Job_Finish();
@@ -851,7 +860,7 @@ Make_Run (Lst targs)
      * because some inferior reported an error.
      */
     errors = ((errors == 0) && (numNodes != 0));
-    Lst_ForEach(targs, MakePrintStatus, (void *) &errors);
+    Lst_ForEach(targs, MakePrintStatus, (void *)&errors);
 
     return (TRUE);
 }
index f0bb2a6..1809ae2 100644 (file)
@@ -37,7 +37,7 @@
  *
  * @(#)parse.c 8.3 (Berkeley) 3/19/94
  * $FreeBSD: src/usr.bin/make/parse.c,v 1.22.2.2 2004/07/10 08:14:42 eik Exp $
- * $DragonFly: src/usr.bin/make/parse.c,v 1.20 2004/12/09 19:08:35 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/parse.c,v 1.21 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -244,7 +244,7 @@ static void ParseFinishLine(void);
  *----------------------------------------------------------------------
  */
 static int
-ParseFindKeyword (char *str)
+ParseFindKeyword(char *str)
 {
     int                    start,
                    end,
@@ -252,11 +252,11 @@ ParseFindKeyword (char *str)
     int                    diff;
 
     start = 0;
-    end = (sizeof(parseKeywords)/sizeof(parseKeywords[0])) - 1;
+    end = (sizeof(parseKeywords) / sizeof(parseKeywords[0])) - 1;
 
     do {
        cur = start + ((end - start) / 2);
-       diff = strcmp (str, parseKeywords[cur].name);
+       diff = strcmp(str, parseKeywords[cur].name);
 
        if (diff == 0) {
            return (cur);
@@ -288,14 +288,14 @@ Parse_Error(int type, const char *fmt, ...)
        va_list ap;
        va_start(ap, fmt);
 
-       (void)fprintf(stderr, "\"%s\", line %d: ",
+       fprintf(stderr, "\"%s\", line %d: ",
            curFile.fname, curFile.lineno);
        if (type == PARSE_WARNING)
-               (void)fprintf(stderr, "warning: ");
-       (void)vfprintf(stderr, fmt, ap);
+               fprintf(stderr, "warning: ");
+       vfprintf(stderr, fmt, ap);
        va_end(ap);
-       (void)fprintf(stderr, "\n");
-       (void)fflush(stderr);
+       fprintf(stderr, "\n");
+       fflush(stderr);
        if (type == PARSE_FATAL)
                fatals += 1;
 }
@@ -317,14 +317,15 @@ Parse_Error(int type, const char *fmt, ...)
  *---------------------------------------------------------------------
  */
 static int
-ParseLinkSrc (void *pgnp, void *cgnp)
+ParseLinkSrc(void *pgnp, void *cgnp)
 {
-    GNode          *pgn = (GNode *) pgnp;
-    GNode          *cgn = (GNode *) cgnp;
-    if (Lst_Member (pgn->children, (void *)cgn) == NULL) {
-       (void)Lst_AtEnd (pgn->children, (void *)cgn);
+    GNode          *pgn = (GNode *)pgnp;
+    GNode          *cgn = (GNode *)cgnp;
+
+    if (Lst_Member(pgn->children, (void *)cgn) == NULL) {
+       Lst_AtEnd (pgn->children, (void *)cgn);
        if (specType == Not) {
-           (void)Lst_AtEnd (cgn->parents, (void *)pgn);
+           Lst_AtEnd (cgn->parents, (void *)pgn);
        }
        pgn->unmade += 1;
     }
@@ -348,10 +349,11 @@ ParseLinkSrc (void *pgnp, void *cgnp)
  *---------------------------------------------------------------------
  */
 static int
-ParseDoOp (void *gnp, void *opp)
+ParseDoOp(void *gnp, void *opp)
 {
-    GNode          *gn = (GNode *) gnp;
-    int             op = *(int *) opp;
+    GNode          *gn = (GNode *)gnp;
+    int             op = *(int *)opp;
+
     /*
      * If the dependency mask of the operator and the node don't match and
      * the node has actually had an operator applied to it before, and
@@ -360,7 +362,7 @@ ParseDoOp (void *gnp, void *opp)
     if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
        !OP_NOP(gn->type) && !OP_NOP(op))
     {
-       Parse_Error (PARSE_FATAL, "Inconsistent operator for %s", gn->name);
+       Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
        return (1);
     }
 
@@ -388,7 +390,7 @@ ParseDoOp (void *gnp, void *opp)
         */
        Lst_ForEach(gn->parents, ParseLinkSrc, (void *)cohort);
        cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
-       (void)Lst_AtEnd(gn->cohorts, (void *)cohort);
+       Lst_AtEnd(gn->cohorts, (void *)cohort);
 
        /*
         * Replace the node in the targets list with the new copy
@@ -425,8 +427,8 @@ ParseDoOp (void *gnp, void *opp)
 static int
 ParseAddDep(void *pp, void *sp)
 {
-    GNode *p = (GNode *) pp;
-    GNode *s = (GNode *) sp;
+    GNode *p = (GNode *)pp;
+    GNode *s = (GNode *)sp;
 
     if (p->order < s->order) {
        /*
@@ -434,12 +436,12 @@ ParseAddDep(void *pp, void *sp)
         * but checking is tedious, and the debugging output can show the
         * problem
         */
-       (void)Lst_AtEnd(p->successors, (void *)s);
-       (void)Lst_AtEnd(s->preds, (void *)p);
-       return 0;
+       Lst_AtEnd(p->successors, (void *)s);
+       Lst_AtEnd(s->preds, (void *)p);
+       return (0);
     }
     else
-       return 1;
+       return (1);
 }
 
 
@@ -461,7 +463,7 @@ ParseAddDep(void *pp, void *sp)
  *---------------------------------------------------------------------
  */
 static void
-ParseDoSrc (int tOp, char *src, Lst allsrc)
+ParseDoSrc(int tOp, char *src, Lst allsrc)
 {
     GNode      *gn = NULL;
 
@@ -490,7 +492,7 @@ ParseDoSrc (int tOp, char *src, Lst allsrc)
         * invoked if the user didn't specify a target on the command
         * line. This is to allow #ifmake's to succeed, or something...
         */
-       (void) Lst_AtEnd (create, (void *)estrdup(src));
+       Lst_AtEnd (create, (void *)estrdup(src));
        /*
         * Add the name to the .TARGETS variable as well, so the user cna
         * employ that, if desired.
@@ -505,8 +507,8 @@ ParseDoSrc (int tOp, char *src, Lst allsrc)
         */
        gn = Targ_FindNode(src, TARG_CREATE);
        if (predecessor != NULL) {
-           (void)Lst_AtEnd(predecessor->successors, (void *)gn);
-           (void)Lst_AtEnd(gn->preds, (void *)predecessor);
+           Lst_AtEnd(predecessor->successors, (void *)gn);
+           Lst_AtEnd(gn->preds, (void *)predecessor);
        }
        /*
         * The current source now becomes the predecessor for the next one.
@@ -526,7 +528,7 @@ ParseDoSrc (int tOp, char *src, Lst allsrc)
         * the 'cohorts' list of the node) or all the cohorts are linked
         * to all the targets.
         */
-       gn = Targ_FindNode (src, TARG_CREATE);
+       gn = Targ_FindNode(src, TARG_CREATE);
        if (tOp) {
            gn->type |= tOp;
        } else {
@@ -549,7 +551,7 @@ ParseDoSrc (int tOp, char *src, Lst allsrc)
     }
 
     gn->order = waiting;
-    (void)Lst_AtEnd(allsrc, (void *)gn);
+    Lst_AtEnd(allsrc, (void *)gn);
     if (waiting) {
        Lst_ForEach(allsrc, ParseAddDep, (void *)gn);
     }
@@ -574,7 +576,7 @@ static int
 ParseFindMain(void *gnp, void *dummy __unused)
 {
     GNode        *gn = (GNode *) gnp;
-    if ((gn->type & (OP_NOTMAIN|OP_USE|OP_EXEC|OP_TRANSFORM)) == 0) {
+    if ((gn->type & (OP_NOTMAIN | OP_USE | OP_EXEC | OP_TRANSFORM)) == 0) {
        mainNode = gn;
        Targ_SetMain(gn);
        return (1);
@@ -599,7 +601,8 @@ ParseFindMain(void *gnp, void *dummy __unused)
 static int
 ParseAddDir(void *path, void *name)
 {
-    Dir_AddDir((Lst) path, (char *) name);
+
+    Dir_AddDir((Lst)path, (char *)name);
     return(0);
 }
 
@@ -619,7 +622,8 @@ ParseAddDir(void *path, void *name)
 static int
 ParseClearPath(void *path, void *dummy __unused)
 {
-    Dir_ClearPath((Lst) path);
+
+    Dir_ClearPath((Lst)path);
     return (0);
 }
 
@@ -684,7 +688,7 @@ ParseDoDependency (char *line)
 
     do {
        for (cp = line;
-            *cp && !isspace ((unsigned char) *cp) && *cp != '(';
+            *cp && !isspace ((unsigned char)*cp) && *cp != '(';
             cp++)
        {
            if (*cp == '$') {
@@ -699,12 +703,12 @@ ParseDoDependency (char *line)
                Boolean freeIt;
                char    *result;
 
-               result=Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
+               result = Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
 
                if (freeIt) {
                    free(result);
                }
-               cp += length-1;
+               cp += length - 1;
            } else if (*cp == '!' || *cp == ':') {
                /*
                 * We don't want to end a word on ':' or '!' if there is a
@@ -746,8 +750,8 @@ ParseDoDependency (char *line)
             * went well and FAILURE if there was an error in the
             * specification. On error, line should remain untouched.
             */
-           if (Arch_ParseArchive (&line, targets, VAR_CMD) != SUCCESS) {
-               Parse_Error (PARSE_FATAL,
+           if (Arch_ParseArchive(&line, targets, VAR_CMD) != SUCCESS) {
+               Parse_Error(PARSE_FATAL,
                             "Error in archive specification: \"%s\"", line);
                return;
            } else {
@@ -765,10 +769,10 @@ ParseDoDependency (char *line)
            if ((strncmp(line, "<<<<<<", 6) == 0) ||
                (strncmp(line, "======", 6) == 0) ||
                (strncmp(line, ">>>>>>", 6) == 0))
-               Parse_Error (PARSE_FATAL,
+               Parse_Error(PARSE_FATAL,
                    "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
            else
-               Parse_Error (PARSE_FATAL, "Need an operator");
+               Parse_Error(PARSE_FATAL, "Need an operator");
            return;
        }
        *cp = '\0';
@@ -776,7 +780,7 @@ ParseDoDependency (char *line)
         * Have a word in line. See if it's a special target and set
         * specType to match it.
         */
-       if (*line == '.' && isupper ((unsigned char) line[1])) {
+       if (*line == '.' && isupper ((unsigned char)line[1])) {
            /*
             * See if the target is a special target that must have it
             * or its sources handled specially.
@@ -824,7 +828,7 @@ ParseDoDependency (char *line)
                        if (paths == NULL) {
                            paths = Lst_Init(FALSE);
                        }
-                       (void)Lst_AtEnd(paths, (void *)dirSearchPath);
+                       Lst_AtEnd(paths, (void *)dirSearchPath);
                        break;
                    case Main:
                        if (!Lst_IsEmpty(create)) {
@@ -836,12 +840,12 @@ ParseDoDependency (char *line)
                    case Interrupt:
                        gn = Targ_FindNode(line, TARG_CREATE);
                        gn->type |= OP_NOTMAIN;
-                       (void)Lst_AtEnd(targets, (void *)gn);
+                       Lst_AtEnd(targets, (void *)gn);
                        break;
                    case Default:
                        gn = Targ_NewGN(".DEFAULT");
                        gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
-                       (void)Lst_AtEnd(targets, (void *)gn);
+                       Lst_AtEnd(targets, (void *)gn);
                        DEFAULT = gn;
                        break;
                    case NotParallel:
@@ -858,7 +862,7 @@ ParseDoDependency (char *line)
                    default:
                        break;
                }
-           } else if (strncmp (line, ".PATH", 5) == 0) {
+           } else if (strncmp(line, ".PATH", 5) == 0) {
                /*
                 * .PATH<suffix> has to be handled specially.
                 * Call on the suffix module to give us a path to
@@ -867,9 +871,9 @@ ParseDoDependency (char *line)
                Lst     path;
 
                specType = ExPath;
-               path = Suff_GetPath (&line[5]);
+               path = Suff_GetPath(&line[5]);
                if (path == NULL) {
-                   Parse_Error (PARSE_FATAL,
+                   Parse_Error(PARSE_FATAL,
                                 "Suffix '%s' not defined (yet)",
                                 &line[5]);
                    return;
@@ -877,7 +881,7 @@ ParseDoDependency (char *line)
                    if (paths == (Lst)NULL) {
                        paths = Lst_Init(FALSE);
                    }
-                   (void)Lst_AtEnd(paths, (void *)path);
+                   Lst_AtEnd(paths, (void *)path);
                }
            }
        }
@@ -904,19 +908,19 @@ ParseDoDependency (char *line)
                 * No wildcards, but we want to avoid code duplication,
                 * so create a list with the word on it.
                 */
-               (void)Lst_AtEnd(curTargs, (void *)line);
+               Lst_AtEnd(curTargs, (void *)line);
            }
 
            while(!Lst_IsEmpty(curTargs)) {
                char    *targName = (char *)Lst_DeQueue(curTargs);
 
                if (!Suff_IsTransform (targName)) {
-                   gn = Targ_FindNode (targName, TARG_CREATE);
+                   gn = Targ_FindNode(targName, TARG_CREATE);
                } else {
-                   gn = Suff_AddTransform (targName);
+                   gn = Suff_AddTransform(targName);
                }
 
-               (void)Lst_AtEnd (targets, (void *)gn);
+               Lst_AtEnd(targets, (void *)gn);
            }
        } else if (specType == ExPath && *line != '.' && *line != '\0') {
            Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
@@ -987,18 +991,18 @@ ParseDoDependency (char *line)
            op = OP_DEPENDS;
        }
     } else {
-       Parse_Error (PARSE_FATAL, "Missing dependency operator");
+       Parse_Error(PARSE_FATAL, "Missing dependency operator");
        return;
     }
 
     cp++;                      /* Advance beyond operator */
 
-    Lst_ForEach (targets, ParseDoOp, (void *)&op);
+    Lst_ForEach(targets, ParseDoOp, (void *)&op);
 
     /*
      * Get to the first source
      */
-    while (*cp && isspace ((unsigned char) *cp)) {
+    while (*cp && isspace ((unsigned char)*cp)) {
        cp++;
     }
     line = cp;
@@ -1015,7 +1019,7 @@ ParseDoDependency (char *line)
     if (!*line) {
        switch (specType) {
            case Suffixes:
-               Suff_ClearSuffixes ();
+               Suff_ClearSuffixes();
                break;
            case Precious:
                allPrecious = TRUE;
@@ -1041,11 +1045,11 @@ ParseDoDependency (char *line)
         * set the initial character to a null-character so the loop to
         * get sources won't get anything
         */
-       Main_ParseArgLine (line);
+       Main_ParseArgLine(line);
        *line = '\0';
     } else if (specType == ExShell) {
-       if (Job_ParseShell (line) != SUCCESS) {
-           Parse_Error (PARSE_FATAL, "improper shell specification");
+       if (Job_ParseShell(line) != SUCCESS) {
+           Parse_Error(PARSE_FATAL, "improper shell specification");
            return;
        }
        *line = '\0';
@@ -1086,26 +1090,26 @@ ParseDoDependency (char *line)
             * has no valid suffix.
             */
            char  savech;
-           while (*cp && !isspace ((unsigned char) *cp)) {
+           while (*cp && !isspace ((unsigned char)*cp)) {
                cp++;
            }
            savech = *cp;
            *cp = '\0';
            switch (specType) {
                case Suffixes:
-                   Suff_AddSuffix (line);
+                   Suff_AddSuffix(line);
                    break;
                case ExPath:
                    Lst_ForEach(paths, ParseAddDir, (void *)line);
                    break;
                case Includes:
-                   Suff_AddInclude (line);
+                   Suff_AddInclude(line);
                    break;
                case Libs:
-                   Suff_AddLib (line);
+                   Suff_AddLib(line);
                    break;
                case Null:
-                   Suff_SetNull (line);
+                   Suff_SetNull(line);
                    break;
                default:
                    break;
@@ -1114,7 +1118,7 @@ ParseDoDependency (char *line)
            if (savech != '\0') {
                cp++;
            }
-           while (*cp && isspace ((unsigned char) *cp)) {
+           while (*cp && isspace ((unsigned char)*cp)) {
                cp++;
            }
            line = cp;
@@ -1129,7 +1133,7 @@ ParseDoDependency (char *line)
             * specifications (i.e. things with left parentheses in them)
             * and handle them accordingly.
             */
-           while (*cp && !isspace ((unsigned char) *cp)) {
+           while (*cp && !isspace ((unsigned char)*cp)) {
                if ((*cp == '(') && (cp > line) && (cp[-1] != '$')) {
                    /*
                     * Only stop for a left parenthesis if it isn't at the
@@ -1146,18 +1150,18 @@ ParseDoDependency (char *line)
            if (*cp == '(') {
                GNode     *gnp;
 
-               sources = Lst_Init (FALSE);
-               if (Arch_ParseArchive (&line, sources, VAR_CMD) != SUCCESS) {
-                   Parse_Error (PARSE_FATAL,
+               sources = Lst_Init(FALSE);
+               if (Arch_ParseArchive(&line, sources, VAR_CMD) != SUCCESS) {
+                   Parse_Error(PARSE_FATAL,
                                 "Error in source archive spec \"%s\"", line);
                    return;
                }
 
                while (!Lst_IsEmpty (sources)) {
-                   gnp = (GNode *) Lst_DeQueue (sources);
-                   ParseDoSrc (tOp, gnp->name, curSrcs);
+                   gnp = (GNode *)Lst_DeQueue(sources);
+                   ParseDoSrc(tOp, gnp->name, curSrcs);
                }
-               Lst_Destroy (sources, NOFREE);
+               Lst_Destroy(sources, NOFREE);
                cp = line;
            } else {
                if (*cp) {
@@ -1165,9 +1169,9 @@ ParseDoDependency (char *line)
                    cp += 1;
                }
 
-               ParseDoSrc (tOp, line, curSrcs);
+               ParseDoSrc(tOp, line, curSrcs);
            }
-           while (*cp && isspace ((unsigned char) *cp)) {
+           while (*cp && isspace ((unsigned char)*cp)) {
                cp++;
            }
            line = cp;
@@ -1181,7 +1185,7 @@ ParseDoDependency (char *line)
         * the first dependency line that is actually a real target
         * (i.e. isn't a .USE or .EXEC rule) to be made.
         */
-       Lst_ForEach (targets, ParseFindMain, (void *)0);
+       Lst_ForEach(targets, ParseFindMain, (void *)0);
     }
 
     /*
@@ -1207,10 +1211,11 @@ ParseDoDependency (char *line)
  *---------------------------------------------------------------------
  */
 Boolean
-Parse_IsVar (char *line)
+Parse_IsVar(char *line)
 {
     Boolean wasSpace = FALSE;  /* set TRUE if found a space */
     Boolean haveName = FALSE;  /* Set TRUE if have a variable name */
+
     int level = 0;
 #define        ISEQOPERATOR(c) \
        (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
@@ -1218,7 +1223,7 @@ Parse_IsVar (char *line)
     /*
      * Skip to variable name
      */
-    for (;(*line == ' ') || (*line == '\t'); line++)
+    for (; (*line == ' ') || (*line == '\t'); line++)
        continue;
 
     for (; *line != '=' || level != 0; line++)
@@ -1227,7 +1232,7 @@ Parse_IsVar (char *line)
            /*
             * end-of-line -- can't be a variable assignment.
             */
-           return FALSE;
+           return (FALSE);
 
        case ' ':
        case '\t':
@@ -1255,7 +1260,7 @@ Parse_IsVar (char *line)
                         * We must have a finished word
                         */
                        if (level != 0)
-                           return FALSE;
+                           return (FALSE);
 
                        /*
                         * When an = operator [+?!:] is found, the next
@@ -1263,19 +1268,19 @@ Parse_IsVar (char *line)
                         * assignment.
                         */
                        if (line[1] == '=')
-                           return haveName;
+                           return (haveName);
 #ifdef SUNSHCMD
                        /*
                         * This is a shell command
                         */
                        if (strncmp(line, ":sh", 3) == 0)
-                           return haveName;
+                           return (haveName);
 #endif
                    }
                    /*
                     * This is the start of another word, so not assignment.
                     */
-                   return FALSE;
+                   return (FALSE);
            }
            else {
                haveName = TRUE;
@@ -1284,7 +1289,7 @@ Parse_IsVar (char *line)
            break;
        }
 
-    return haveName;
+    return (haveName);
 }
 
 /*-
@@ -1308,7 +1313,7 @@ Parse_IsVar (char *line)
  *---------------------------------------------------------------------
  */
 void
-Parse_DoVar (char *line, GNode *ctxt)
+Parse_DoVar(char *line, GNode *ctxt)
 {
     char          *cp; /* pointer into line */
     enum {
@@ -1321,8 +1326,8 @@ Parse_DoVar (char *line, GNode *ctxt)
      * to ``unregister'' variables
      */
 #if __GNUC__
-    (void) &cp;
-    (void) &line;
+    (void)&cp;
+    (void)&line;
 #endif
 
     /*
@@ -1336,11 +1341,11 @@ Parse_DoVar (char *line, GNode *ctxt)
      * Skip to operator character, nulling out whitespace as we go
      */
     for (cp = line + 1; *cp != '='; cp++) {
-       if (isspace ((unsigned char) *cp)) {
+       if (isspace ((unsigned char)*cp)) {
            *cp = '\0';
        }
     }
-    opc = cp-1;                /* operator is the previous character */
+    opc = cp - 1;      /* operator is the previous character */
     *cp++ = '\0';      /* nuke the = */
 
     /*
@@ -1392,12 +1397,12 @@ Parse_DoVar (char *line, GNode *ctxt)
            break;
     }
 
-    while (isspace ((unsigned char) *cp)) {
+    while (isspace ((unsigned char)*cp)) {
        cp++;
     }
 
     if (type == VAR_APPEND) {
-       Var_Append (line, cp, ctxt);
+       Var_Append(line, cp, ctxt);
     } else if (type == VAR_SUBST) {
        /*
         * Allow variables in the old value to be undefined, but leave their
@@ -1473,14 +1478,15 @@ static int
 ParseAddCmd(void *gnp, void *cmd)
 {
     GNode *gn = (GNode *) gnp;
+
     /* if target already supplied, ignore commands */
     if (!(gn->type & OP_HAS_COMMANDS))
-       (void)Lst_AtEnd(gn->commands, cmd);
+       Lst_AtEnd(gn->commands, cmd);
     else
        Parse_Error(PARSE_WARNING,
                    "duplicate script for target \"%s\" ignored",
                    gn->name);
-    return(0);
+    return (0);
 }
 
 /*-
@@ -1502,7 +1508,9 @@ ParseAddCmd(void *gnp, void *cmd)
 static void
 ParseHasCommands(void *gnp)
 {
+
     GNode *gn = (GNode *) gnp;
+
     if (!Lst_IsEmpty(gn->commands)) {
        gn->type |= OP_HAS_COMMANDS;
     }
@@ -1523,9 +1531,10 @@ ParseHasCommands(void *gnp)
  *-----------------------------------------------------------------------
  */
 void
-Parse_AddIncludeDir (char *dir)
+Parse_AddIncludeDir(char *dir)
 {
-    Dir_AddDir (parseIncPath, dir);
+
+    Dir_AddDir(parseIncPath, dir);
 }
 
 /*---------------------------------------------------------------------
@@ -1541,14 +1550,15 @@ Parse_AddIncludeDir (char *dir)
 static void
 ParseDoError(char *errmsg)
 {
-       if (!isspace((unsigned char) *errmsg)) {
+
+       if (!isspace((unsigned char)*errmsg)) {
                Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg);
                return;
        }
-       
-       while (isspace((unsigned char) *errmsg))
+
+       while (isspace((unsigned char)*errmsg))
                errmsg++;
-       
+
        errmsg = Var_Subst(NULL, errmsg, VAR_GLOBAL, FALSE);
 
        Parse_Error(PARSE_FATAL, "%s", errmsg);
@@ -1569,15 +1579,16 @@ ParseDoError(char *errmsg)
 static void
 ParseDoWarning(char *warnmsg)
 {
-       if (!isspace((unsigned char) *warnmsg)) {
+
+       if (!isspace((unsigned char)*warnmsg)) {
                Parse_Error(PARSE_WARNING, "invalid syntax: .warning%s",
                    warnmsg);
                return;
        }
-       
-       while (isspace((unsigned char) *warnmsg))
+
+       while (isspace((unsigned char)*warnmsg))
                warnmsg++;
-       
+
        warnmsg = Var_Subst(NULL, warnmsg, VAR_GLOBAL, FALSE);
 
        Parse_Error(PARSE_WARNING, "%s", warnmsg);
@@ -1618,7 +1629,7 @@ ParseDoInclude (char *file)
     }
 
     if ((*file != '"') && (*file != '<')) {
-       Parse_Error (PARSE_FATAL,
+       Parse_Error(PARSE_FATAL,
            ".include filename must be delimited by '\"' or '<'");
        return;
     }
@@ -1644,7 +1655,7 @@ ParseDoInclude (char *file)
     }
 
     if (*cp != endc) {
-       Parse_Error (PARSE_FATAL,
+       Parse_Error(PARSE_FATAL,
                     "Unclosed %cinclude filename. '%c' expected",
                     '.', endc);
        return;
@@ -1655,7 +1666,7 @@ ParseDoInclude (char *file)
      * Substitute for any variables in the file name before trying to
      * find the thing.
      */
-    file = Var_Subst (NULL, file, VAR_CMD, FALSE);
+    file = Var_Subst(NULL, file, VAR_CMD, FALSE);
 
     /*
      * Now we know the file's name and its search path, we attempt to
@@ -1675,7 +1686,7 @@ ParseDoInclude (char *file)
        /* Make a temporary copy of this, to be safe. */
        Fname = estrdup(curFile.fname);
 
-       prefEnd = strrchr (Fname, '/');
+       prefEnd = strrchr(Fname, '/');
        if (prefEnd != (char *)NULL) {
            char        *newName;
 
@@ -1683,17 +1694,17 @@ ParseDoInclude (char *file)
            if (file[0] == '/')
                newName = estrdup(file);
            else
-               newName = str_concat (Fname, file, STR_ADDSLASH);
-           fullname = Dir_FindFile (newName, parseIncPath);
+               newName = str_concat(Fname, file, STR_ADDSLASH);
+           fullname = Dir_FindFile(newName, parseIncPath);
            if (fullname == (char *)NULL) {
                fullname = Dir_FindFile(newName, dirSearchPath);
            }
-           free (newName);
+           free(newName);
            *prefEnd = '/';
        } else {
            fullname = (char *)NULL;
        }
-       free (Fname);
+       free(Fname);
     } else {
        fullname = (char *)NULL;
     }
@@ -1705,7 +1716,7 @@ ParseDoInclude (char *file)
         * then on the .PATH search path, if not found in a -I directory.
         * XXX: Suffix specific?
         */
-       fullname = Dir_FindFile (file, parseIncPath);
+       fullname = Dir_FindFile(file, parseIncPath);
        if (fullname == (char *)NULL) {
            fullname = Dir_FindFile(file, dirSearchPath);
        }
@@ -1721,7 +1732,7 @@ ParseDoInclude (char *file)
 
     if (fullname == (char *) NULL) {
        *cp = endc;
-       Parse_Error (PARSE_FATAL, "Could not find %s", file);
+       Parse_Error(PARSE_FATAL, "Could not find %s", file);
        return;
     }
 
@@ -1734,10 +1745,10 @@ ParseDoInclude (char *file)
      * is placed on a list with other IFile structures. The list makes
      * a very nice stack to track how we got here...
      */
-    oldFile = (IFile *) emalloc (sizeof (IFile));
+    oldFile = (IFile *) emalloc(sizeof (IFile));
     memcpy(oldFile, &curFile, sizeof (IFile));
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    Lst_AtFront(includes, (void *)oldFile);
 
     /*
      * Once the previous state has been saved, we can get down to reading
@@ -1748,21 +1759,19 @@ ParseDoInclude (char *file)
     curFile.fname = fullname;
     curFile.lineno = 0;
 
-    curFile.F = fopen (fullname, "r");
+    curFile.F = fopen(fullname, "r");
     curFile.p = NULL;
     if (curFile.F == (FILE * ) NULL) {
-       Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
+       Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
        /*
         * Pop to previous file
         */
-       (void) ParseEOF(0);
+       ParseEOF(0);
     } else {
        Var_Append(".MAKEFILE_LIST", fullname, VAR_GLOBAL);
     }
 }
 
-
-
 /*-
  *---------------------------------------------------------------------
  * Parse_FromString  --
@@ -1783,19 +1792,18 @@ Parse_FromString(char *str, int lineno)
 
     DEBUGF(FOR, ("%s\n---- at line %d\n", str, lineno));
 
-    oldFile = (IFile *) emalloc (sizeof (IFile));
-    memcpy(oldFile, &curFile, sizeof (IFile));
+    oldFile = (IFile *)emalloc(sizeof(IFile));
+    memcpy(oldFile, &curFile, sizeof(IFile));
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    Lst_AtFront (includes, (void *)oldFile);
 
     curFile.F = NULL;
-    curFile.p = (PTR *) emalloc (sizeof (PTR));
+    curFile.p = (PTR *)emalloc(sizeof (PTR));
     curFile.p->str = curFile.p->ptr = str;
     curFile.lineno = lineno;
     curFile.fname = estrdup(curFile.fname);
 }
 
-
 #ifdef SYSVINCLUDE
 /*-
  *---------------------------------------------------------------------
@@ -1828,7 +1836,7 @@ ParseTraditionalInclude (char *file)
     }
 
     if (*file == '\0') {
-       Parse_Error (PARSE_FATAL,
+       Parse_Error(PARSE_FATAL,
                     "Filename missing from \"include\"");
        return;
     }
@@ -1846,14 +1854,14 @@ ParseTraditionalInclude (char *file)
      * Substitute for any variables in the file name before trying to
      * find the thing.
      */
-    file = Var_Subst (NULL, file, VAR_CMD, FALSE);
+    file = Var_Subst(NULL, file, VAR_CMD, FALSE);
 
     /*
      * Now we know the file's name, we attempt to find the durn thing.
      * Search for it first on the -I search path, then on the .PATH
      * search path, if not found in a -I directory.
      */
-    fullname = Dir_FindFile (file, parseIncPath);
+    fullname = Dir_FindFile(file, parseIncPath);
     if (fullname == (char *)NULL) {
         fullname = Dir_FindFile(file, dirSearchPath);
     }
@@ -1867,7 +1875,7 @@ ParseTraditionalInclude (char *file)
     }
 
     if (fullname == (char *) NULL) {
-       Parse_Error (PARSE_FATAL, "Could not find %s", file);
+       Parse_Error(PARSE_FATAL, "Could not find %s", file);
        return;
     }
 
@@ -1878,10 +1886,10 @@ ParseTraditionalInclude (char *file)
      * is placed on a list with other IFile structures. The list makes
      * a very nice stack to track how we got here...
      */
-    oldFile = (IFile *) emalloc (sizeof (IFile));
-    memcpy(oldFile, &curFile, sizeof (IFile));
+    oldFile = (IFile *)emalloc(sizeof(IFile));
+    memcpy(oldFile, &curFile, sizeof(IFile));
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    Lst_AtFront(includes, (void *)oldFile);
 
     /*
      * Once the previous state has been saved, we can get down to reading
@@ -1892,14 +1900,14 @@ ParseTraditionalInclude (char *file)
     curFile.fname = fullname;
     curFile.lineno = 0;
 
-    curFile.F = fopen (fullname, "r");
+    curFile.F = fopen(fullname, "r");
     curFile.p = NULL;
-    if (curFile.F == (FILE * ) NULL) {
-       Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
+    if (curFile.F == (FILE * )NULL) {
+       Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
        /*
         * Pop to previous file
         */
-       (void) ParseEOF(1);
+       ParseEOF(1);
     } else {
        Var_Append(".MAKEFILE_LIST", fullname, VAR_GLOBAL);
     }
@@ -1923,7 +1931,7 @@ ParseTraditionalInclude (char *file)
  *---------------------------------------------------------------------
  */
 static int
-ParseEOF (int opened)
+ParseEOF(int opened)
 {
     IFile     *ifile;  /* the state on the top of the includes stack */
 
@@ -1932,18 +1940,18 @@ ParseEOF (int opened)
        return (DONE);
     }
 
-    ifile = (IFile *) Lst_DeQueue (includes);
-    free (curFile.fname);
+    ifile = (IFile *)Lst_DeQueue(includes);
+    free(curFile.fname);
     if (opened && curFile.F) {
-       (void) fclose (curFile.F);
+       fclose(curFile.F);
        Var_Append(".MAKEFILE_LIST", "..", VAR_GLOBAL);
     }
     if (curFile.p) {
        free(curFile.p->str);
        free(curFile.p);
     }
-    memcpy(&curFile, ifile, sizeof (IFile));
-    free (ifile);
+    memcpy(&curFile, ifile, sizeof(IFile));
+    free(ifile);
     return (CONTINUE);
 }
 
@@ -1961,12 +1969,13 @@ ParseEOF (int opened)
 static int
 ParseReadc(void)
 {
+
     if (curFile.F)
-       return fgetc(curFile.F);
+       return (fgetc(curFile.F));
 
     if (curFile.p && *curFile.p->ptr)
-       return *curFile.p->ptr++;
-    return EOF;
+       return (*curFile.p->ptr++);
+    return (EOF);
 }
 
 
@@ -1984,6 +1993,7 @@ ParseReadc(void)
 static void
 ParseUnreadc(int c)
 {
+
     if (curFile.F) {
        ungetc(c, curFile.F);
        return;
@@ -2042,7 +2052,7 @@ ParseSkipLine(int skip, int keep_newline)
         if (c == EOF) {
             Parse_Error(PARSE_FATAL, "Unclosed conditional/for loop");
             Buf_Destroy(buf, TRUE);
-            return((char *)NULL);
+            return ((char *)NULL);
         }
 
         curFile.lineno++;
@@ -2051,7 +2061,7 @@ ParseSkipLine(int skip, int keep_newline)
     } while (skip == 1 && line[0] != '.');
 
     Buf_Destroy(buf, FALSE);
-    return line;
+    return (line);
 }
 
 
@@ -2073,7 +2083,7 @@ ParseSkipLine(int skip, int keep_newline)
  *---------------------------------------------------------------------
  */
 static char *
-ParseReadLine (void)
+ParseReadLine(void)
 {
     Buffer       buf;          /* Buffer for current line */
     int                  c;            /* the current character */
@@ -2122,11 +2132,11 @@ ParseReadLine (void)
        lastc = c;
        buf = Buf_Init(MAKE_BSIZE);
 
-       while (((c = ParseReadc ()) != '\n' || (lastc == '\\')) &&
+       while (((c = ParseReadc()) != '\n' || (lastc == '\\')) &&
               (c != EOF))
        {
 test_char:
-           switch(c) {
+           switch (c) {
            case '\n':
                /*
                 * Escaped newline: read characters until a non-space or an
@@ -2138,7 +2148,7 @@ test_char:
                 */
                curFile.lineno++;
                lastc = ' ';
-               while ((c = ParseReadc ()) == ' ' || c == '\t') {
+               while ((c = ParseReadc()) == ' ' || c == '\t') {
                    continue;
                }
                if (c == EOF || c == '\n') {
@@ -2190,7 +2200,8 @@ test_char:
                     * XXX: Note that a line like "foo : a:=b" will blow up,
                     * but who'd write a line like that anyway?
                     */
-                   ignDepOp = TRUE; semiNL = FALSE;
+                   ignDepOp = TRUE;
+                   semiNL = FALSE;
                }
                break;
            case '#':
@@ -2232,7 +2243,7 @@ test_char:
            /*
             * Copy in the previous character and save this one in lastc.
             */
-           Buf_AddByte (buf, (Byte)lastc);
+           Buf_AddByte(buf, (Byte)lastc);
            lastc = c;
 
        }
@@ -2240,11 +2251,11 @@ test_char:
        curFile.lineno++;
 
        if (lastc != '\0') {
-           Buf_AddByte (buf, (Byte)lastc);
+           Buf_AddByte(buf, (Byte)lastc);
        }
-       Buf_AddByte (buf, (Byte)'\0');
-       line = (char *)Buf_GetAll (buf, &lineLength);
-       Buf_Destroy (buf, FALSE);
+       Buf_AddByte(buf, (Byte)'\0');
+       line = (char *)Buf_GetAll(buf, &lineLength);
+       Buf_Destroy(buf, FALSE);
 
        /*
         * Strip trailing blanks and tabs from the line.
@@ -2266,20 +2277,20 @@ test_char:
             * The line might be a conditional. Ask the conditional module
             * about it and act accordingly
             */
-           switch (Cond_Eval (line)) {
+           switch (Cond_Eval(line)) {
            case COND_SKIP:
                /*
                 * Skip to next conditional that evaluates to COND_PARSE.
                 */
                do {
-                   free (line);
+                   free(line);
                    line = ParseSkipLine(1, 0);
                } while (line && Cond_Eval(line) != COND_PARSE);
                if (line == NULL)
                    break;
                /*FALLTHRU*/
            case COND_PARSE:
-               free (line);
+               free(line);
                line = ParseReadLine();
                break;
            case COND_INVALID:
@@ -2293,7 +2304,7 @@ test_char:
                         */
                        line = ParseSkipLine(0, 1);
                        if (line == NULL) {
-                           Parse_Error (PARSE_FATAL,
+                           Parse_Error(PARSE_FATAL,
                                     "Unexpected end of file in for loop.\n");
                            break;
                        }
@@ -2316,7 +2327,7 @@ test_char:
        /*
         * Hit end-of-file, so return a NULL line to indicate this.
         */
-       return((char *)NULL);
+       return ((char *)NULL);
     }
 }
 
@@ -2336,9 +2347,10 @@ test_char:
 static void
 ParseFinishLine(void)
 {
+
     if (inLine) {
        Lst_ForEach(targets, Suff_EndTransform, (void *)NULL);
-       Lst_Destroy (targets, ParseHasCommands);
+       Lst_Destroy(targets, ParseHasCommands);
        targets = NULL;
        inLine = FALSE;
     }
@@ -2389,22 +2401,22 @@ Parse_File(char *name, FILE *stream)
     Var_Append(".MAKEFILE_LIST", name, VAR_GLOBAL);
 
     do {
-       while ((line = ParseReadLine ()) != NULL) {
+       while ((line = ParseReadLine()) != NULL) {
            if (*line == '.') {
                /*
                 * Lines that begin with the special character are either
                 * include or undef directives.
                 */
-               for (cp = line + 1; isspace ((unsigned char) *cp); cp++) {
+               for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
                    continue;
                }
-               if (strncmp (cp, "include", 7) == 0) {
+               if (strncmp(cp, "include", 7) == 0) {
                    ParseDoInclude (cp + 7);
                    goto nextLine;
-               } else if (strncmp (cp, "error", 5) == 0) {
+               } else if (strncmp(cp, "error", 5) == 0) {
                    ParseDoError(cp + 5);
                    goto nextLine;          
-               } else if (strncmp (cp, "warning", 7) == 0) {
+               } else if (strncmp(cp, "warning", 7) == 0) {
                    ParseDoWarning(cp + 7);
                    goto nextLine;          
                } else if (strncmp(cp, "undef", 5) == 0) {
@@ -2428,7 +2440,7 @@ Parse_File(char *name, FILE *stream)
                 * If a line starts with a tab, it can only hope to be
                 * a creation command.
                 */
-               for (cp = line + 1; isspace ((unsigned char) *cp); cp++) {
+               for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
                    continue;
                }
                if (*cp) {
@@ -2438,28 +2450,28 @@ Parse_File(char *name, FILE *stream)
                         * in a dependency spec, add the command to the list of
                         * commands of all targets in the dependency spec
                         */
-                       Lst_ForEach (targets, ParseAddCmd, cp);
-                       Lst_AtEnd(targCmds, (void *) line);
+                       Lst_ForEach(targets, ParseAddCmd, cp);
+                       Lst_AtEnd(targCmds, (void *)line);
                        continue;
                    } else {
-                       Parse_Error (PARSE_FATAL,
+                       Parse_Error(PARSE_FATAL,
                                     "Unassociated shell command \"%s\"",
                                     cp);
                    }
                }
 #ifdef SYSVINCLUDE
-           } else if (strncmp (line, "include", 7) == 0 &&
-                      isspace((unsigned char) line[7]) &&
+           } else if (strncmp(line, "include", 7) == 0 &&
+                      isspace((unsigned char)line[7]) &&
                       strchr(line, ':') == NULL) {
                /*
                 * It's an S3/S5-style "include".
                 */
-               ParseTraditionalInclude (line + 7);
+               ParseTraditionalInclude(line + 7);
                goto nextLine;
 #endif
-           } else if (Parse_IsVar (line)) {
+           } else if (Parse_IsVar(line)) {
                ParseFinishLine();
-               Parse_DoVar (line, VAR_GLOBAL);
+               Parse_DoVar(line, VAR_GLOBAL);
            } else {
                /*
                 * We now know it's a dependency line so it needs to have all
@@ -2472,8 +2484,8 @@ Parse_File(char *name, FILE *stream)
                 * and add it to the current list of targets.
                 */
                cp = line;
-               if (isspace((unsigned char) line[0])) {
-                   while ((*cp != '\0') && isspace((unsigned char) *cp)) {
+               if (isspace((unsigned char)line[0])) {
+                   while ((*cp != '\0') && isspace((unsigned char)*cp)) {
                        cp++;
                    }
                    if (*cp == '\0') {
@@ -2483,8 +2495,8 @@ Parse_File(char *name, FILE *stream)
 
                ParseFinishLine();
 
-               cp = Var_Subst (NULL, line, VAR_CMD, TRUE);
-               free (line);
+               cp = Var_Subst(NULL, line, VAR_CMD, TRUE);
+               free(line);
                line = cp;
 
                /*
@@ -2493,7 +2505,7 @@ Parse_File(char *name, FILE *stream)
                if (targets)
                    Lst_Destroy(targets, NOFREE);
 
-               targets = Lst_Init (FALSE);
+               targets = Lst_Init(FALSE);
                inLine = TRUE;
 
                ParseDoDependency (line);
@@ -2501,7 +2513,7 @@ Parse_File(char *name, FILE *stream)
 
            nextLine:
 
-           free (line);
+           free(line);
        }
        /*
         * Reached EOF, but it may be just EOF of an include file...
@@ -2530,18 +2542,20 @@ Parse_File(char *name, FILE *stream)
  *---------------------------------------------------------------------
  */
 void
-Parse_Init (void)
+Parse_Init(void)
 {
+
     mainNode = NULL;
-    parseIncPath = Lst_Init (FALSE);
-    sysIncPath = Lst_Init (FALSE);
-    includes = Lst_Init (FALSE);
-    targCmds = Lst_Init (FALSE);
+    parseIncPath = Lst_Init(FALSE);
+    sysIncPath = Lst_Init(FALSE);
+    includes = Lst_Init(FALSE);
+    targCmds = Lst_Init(FALSE);
 }
 
 void
-Parse_End (void)
+Parse_End(void)
 {
+
     Lst_Destroy(targCmds, free);
     if (targets)
        Lst_Destroy(targets, NOFREE);
@@ -2570,16 +2584,16 @@ Parse_MainName(void)
 {
     Lst           listmain;    /* result list */
 
-    listmain = Lst_Init (FALSE);
+    listmain = Lst_Init(FALSE);
 
     if (mainNode == NULL) {
-       Punt ("no target to make.");
+       Punt("no target to make.");
        /*NOTREACHED*/
     } else if (mainNode->type & OP_DOUBLEDEP) {
-       (void) Lst_AtEnd (listmain, (void *)mainNode);
+       Lst_AtEnd(listmain, (void *)mainNode);
        Lst_Concat(listmain, mainNode->cohorts, LST_CONCNEW);
     }
     else
-       (void) Lst_AtEnd (listmain, (void *)mainNode);
+       Lst_AtEnd(listmain, (void *)mainNode);
     return (listmain);
 }
index 49a4776..54503fd 100644 (file)
@@ -37,7 +37,7 @@
  *
  * @(#)str.c   5.8 (Berkeley) 6/1/90
  * $FreeBSD: src/usr.bin/make/str.c,v 1.12.2.2 2004/02/23 12:10:57 ru Exp $
- * $DragonFly: src/usr.bin/make/str.c,v 1.9 2004/12/10 00:38:21 okumoto Exp $
+ * $DragonFly: src/usr.bin/make/str.c,v 1.10 2004/12/10 19:22:24 okumoto Exp $
  */
 
 #include "make.h"
@@ -54,6 +54,7 @@ void
 str_init(void)
 {
     char *p1;
+
     argv = (char **)emalloc(((argmax = 50) + 1) * sizeof(char *));
     argv[0] = Var_Value(".MAKE", VAR_GLOBAL, &p1);
 }
@@ -111,7 +112,7 @@ str_concat(const char *s1, const char *s2, int flags)
 
        /* copy second string plus EOS into place */
        memcpy(result + len1, s2, len2 + 1);
-       return(result);
+       return (result);
 }
 
 /*-
@@ -231,11 +232,11 @@ brk_string(char *str, int *store_argc, Boolean expand)
                }
                if (!start)
                        start = t;
-               *t++ = (char) ch;
+               *t++ = (char)ch;
        }
 done:  argv[argc] = (char *)NULL;
        *store_argc = argc;
-       return(argv);
+       return (argv);
 }
 
 /*
@@ -261,9 +262,9 @@ Str_Match(const char *string, const char *pattern)
                 * pattern but not at the end of the string, we failed.
                 */
                if (*pattern == 0)
-                       return(!*string);
+                       return (!*string);
                if (*string == 0 && *pattern != '*')
-                       return(0);
+                       return (0);
                /*
                 * Check for a "*" as the next pattern character.  It matches
                 * any substring.  We handle this by calling ourselves
@@ -273,13 +274,13 @@ Str_Match(const char *string, const char *pattern)
                if (*pattern == '*') {
                        pattern += 1;
                        if (*pattern == 0)
-                               return(1);
+                               return (1);
                        while (*string != 0) {
                                if (Str_Match(string, pattern))
-                                       return(1);
+                                       return (1);
                                ++string;
                        }
-                       return(0);
+                       return (0);
                }
                /*
                 * Check for a "?" as the next pattern character.  It matches
@@ -296,13 +297,13 @@ Str_Match(const char *string, const char *pattern)
                        ++pattern;
                        for (;;) {
                                if ((*pattern == ']') || (*pattern == 0))
-                                       return(0);
+                                       return (0);
                                if (*pattern == *string)
                                        break;
                                if (pattern[1] == '-') {
                                        c2 = pattern[2];
                                        if (c2 == 0)
-                                               return(0);
+                                               return (0);
                                        if ((*pattern <= *string) &&
                                            (c2 >= *string))
                                                break;
@@ -324,14 +325,14 @@ Str_Match(const char *string, const char *pattern)
                if (*pattern == '\\') {
                        ++pattern;
                        if (*pattern == 0)
-                               return(0);
+                               return (0);
                }
                /*
                 * There's no special character.  Just make sure that the
                 * next characters of each string match.
                 */
                if (*pattern != *string)
-                       return(0);
+                       return (0);
 thisCharOK:    ++pattern;
                ++string;
        }
@@ -362,13 +363,13 @@ Str_SYSVMatch(const char *word, const char *pattern, int *len)
     if (*w == '\0') {
        /* Zero-length word cannot be matched against */
        *len = 0;
-       return NULL;
+       return (NULL);
     }
 
     if (*p == '\0') {
        /* Null pattern is the whole string */
        *len = strlen(w);
-       return w;
+       return (w);
     }
 
     if ((m = strchr(p, '%')) != NULL) {
@@ -377,12 +378,12 @@ Str_SYSVMatch(const char *word, const char *pattern, int *len)
             continue;
 
        if (p != m)
-           return NULL;        /* No match */
+           return (NULL);      /* No match */
 
        if (*++p == '\0') {
            /* No more pattern, return the rest of the string */
            *len = strlen(w);
-           return w;
+           return (w);
        }
     }
 
@@ -392,11 +393,11 @@ Str_SYSVMatch(const char *word, const char *pattern, int *len)
     do
        if (strcmp(p, w) == 0) {
            *len = w - m;
-           return m;
+           return (m);
        }
     while (*w++ != '\0');
 
-    return NULL;
+    return (NULL);
 }
 
 
@@ -422,14 +423,14 @@ Str_SYSVSubst(Buffer buf, const char *pat, const char *src, int len)
 
     if ((m = strchr(pat, '%')) != NULL) {
        /* Copy the prefix */
-       Buf_AddBytes(buf, m - pat, (Byte *) pat);
+       Buf_AddBytes(buf, m - pat, (Byte *)pat);
        /* skip the % */
        pat = m + 1;
     }
 
     /* Copy the pattern */
-    Buf_AddBytes(buf, len, (Byte *) src);
+    Buf_AddBytes(buf, len, (Byte *)src);
 
     /* append the rest */
-    Buf_AddBytes(buf, strlen(pat), (Byte *) pat);
+    Buf_AddBytes(buf, strlen(pat), (Byte *)pat);
 }
index f045321..9f9e67e 100644 (file)
@@ -37,7 +37,7 @@
  *
  * @(#)suff.c  8.4 (Berkeley) 3/21/94
  * $FreeBSD: src/usr.bin/make/suff.c,v 1.12.2.2 2004/06/10 13:07:53 ru Exp $
- * $DragonFly: src/usr.bin/make/suff.c,v 1.13 2004/11/24 07:20:50 dillon Exp $
+ * $DragonFly: src/usr.bin/make/suff.c,v 1.14 2004/12/10 19:22:24 okumoto Exp $
  */
 
 /*-
@@ -191,8 +191,9 @@ static int SuffPrintTrans(void *, void *);
  *-----------------------------------------------------------------------
  */
 static char    *
-SuffStrIsPrefix (char *pref, char *str)
+SuffStrIsPrefix(char *pref, char *str)
 {
+
     while (*str && *pref == *str) {
        pref++;
        str++;
@@ -216,7 +217,7 @@ SuffStrIsPrefix (char *pref, char *str)
  *-----------------------------------------------------------------------
  */
 static char *
-SuffSuffIsSuffix (Suff *s, char *str)
+SuffSuffIsSuffix(Suff *s, char *str)
 {
     char          *p1;         /* Pointer into suffix name */
     char          *p2;         /* Pointer into string being examined */
@@ -249,7 +250,8 @@ SuffSuffIsSuffix (Suff *s, char *str)
 static int
 SuffSuffIsSuffixP(void *s, void *str)
 {
-    return(!SuffSuffIsSuffix((Suff *) s, (char *) str));
+
+    return (!SuffSuffIsSuffix((Suff *)s, (char *)str));
 }
 
 /*-
@@ -266,9 +268,10 @@ SuffSuffIsSuffixP(void *s, void *str)
  *-----------------------------------------------------------------------
  */
 static int
-SuffSuffHasNameP (void *s, void *sname)
+SuffSuffHasNameP(void *s, void *sname)
 {
-    return (strcmp ((char *) sname, ((Suff *) s)->name));
+
+    return (strcmp((char *)sname, ((Suff *)s)->name));
 }
 
 /*-
@@ -287,9 +290,10 @@ SuffSuffHasNameP (void *s, void *sname)
  *-----------------------------------------------------------------------
  */
 static int
-SuffSuffIsPrefix (void *s, void *str)
+SuffSuffIsPrefix(void *s, void *str)
 {
-    return (SuffStrIsPrefix (((Suff *) s)->name, (char *) str) == NULL ? 1 : 0);
+
+    return (SuffStrIsPrefix(((Suff *)s)->name, (char *)str) == NULL ? 1 : 0);
 }
 
 /*-
@@ -305,9 +309,10 @@ SuffSuffIsPrefix (void *s, void *str)
  *-----------------------------------------------------------------------
  */
 static int
-SuffGNHasNameP (void *gn, void *name)
+SuffGNHasNameP(void *gn, void *name)
 {
-    return (strcmp ((char *) name, ((GNode *) gn)->name));
+
+    return (strcmp((char *)name, ((GNode *)gn)->name));
 }
 
            /*********** Maintenance Functions ************/
@@ -325,7 +330,7 @@ SuffGNHasNameP (void *gn, void *name)
  *-----------------------------------------------------------------------
  */
 static void
-SuffFree (void *sp)
+SuffFree(void *sp)
 {
     Suff           *s = (Suff *) sp;
 
@@ -335,13 +340,13 @@ SuffFree (void *sp)
     if (s == emptySuff)
        emptySuff = NULL;
 
-    Lst_Destroy (s->ref, NOFREE);
-    Lst_Destroy (s->children, NOFREE);
-    Lst_Destroy (s->parents, NOFREE);
-    Lst_Destroy (s->searchPath, Dir_Destroy);
+    Lst_Destroy(s->ref, NOFREE);
+    Lst_Destroy(s->children, NOFREE);
+    Lst_Destroy(s->parents, NOFREE);
+    Lst_Destroy(s->searchPath, Dir_Destroy);
 
-    free (s->name);
-    free (s);
+    free(s->name);
+    free(s);
 }
 
 /*-
@@ -365,7 +370,7 @@ SuffRemove(Lst l, Suff *s)
        s->refCount--;
     }
 }
-\f
+
 /*-
  *-----------------------------------------------------------------------
  * SuffInsert  --
@@ -380,16 +385,16 @@ SuffRemove(Lst l, Suff *s)
  *-----------------------------------------------------------------------
  */
 static void
-SuffInsert (Lst l, Suff *s)
+SuffInsert(Lst l, Suff *s)
 {
     LstNode      ln;           /* current element in l we're examining */
     Suff          *s2 = NULL;  /* the suffix descriptor in this element */
 
-    if (Lst_Open (l) == FAILURE) {
+    if (Lst_Open(l) == FAILURE) {
        return;
     }
-    while ((ln = Lst_Next (l)) != NULL) {
-       s2 = (Suff *) Lst_Datum (ln);
+    while ((ln = Lst_Next(l)) != NULL) {
+       s2 = (Suff *)Lst_Datum(ln);
        if (s2->sNum >= s->sNum) {
            break;
        }
@@ -398,18 +403,18 @@ SuffInsert (Lst l, Suff *s)
            DEBUGF(SUFF, ("inserting an empty list?..."));
     }
 
-    Lst_Close (l);
+    Lst_Close(l);
     DEBUGF(SUFF, ("inserting %s(%d)...", s->name, s->sNum));
     if (ln == NULL) {
        DEBUGF(SUFF, ("at end of list\n"));
-       (void)Lst_AtEnd (l, (void *)s);
+       Lst_AtEnd (l, (void *)s);
        s->refCount++;
-       (void)Lst_AtEnd(s->ref, (void *) l);
+       Lst_AtEnd(s->ref, (void *)l);
     } else if (s2->sNum != s->sNum) {
        DEBUGF(SUFF, ("before %s(%d)\n", s2->name, s2->sNum));
-       (void)Lst_Insert (l, ln, (void *)s);
+       Lst_Insert(l, ln, (void *)s);
        s->refCount++;
-       (void)Lst_AtEnd(s->ref, (void *) l);
+       Lst_AtEnd(s->ref, (void *)l);
     } else {
        DEBUGF(SUFF, ("already there\n"));
     }
@@ -433,9 +438,10 @@ SuffInsert (Lst l, Suff *s)
  *-----------------------------------------------------------------------
  */
 void
-Suff_ClearSuffixes (void)
+Suff_ClearSuffixes(void)
 {
-    Lst_Concat (suffClean, sufflist, LST_CONCLINK);
+
+    Lst_Concat(suffClean, sufflist, LST_CONCLINK);
     sufflist = Lst_Init(FALSE);
     sNum = 1;
     suffNull = emptySuff;
@@ -487,7 +493,7 @@ SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
        if (srcLn == NULL) {
            srcLn = Lst_Find(sufflist, (void *)str, SuffSuffIsPrefix);
        } else {
-           srcLn = Lst_FindFrom (sufflist, Lst_Succ(srcLn), (void *)str,
+           srcLn = Lst_FindFrom(sufflist, Lst_Succ(srcLn), (void *)str,
                                  SuffSuffIsPrefix);
        }
        if (srcLn == NULL) {
@@ -506,7 +512,7 @@ SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
                 */
                *srcPtr = single;
                *targPtr = suffNull;
-               return(TRUE);
+               return (TRUE);
            }
            return (FALSE);
        }
@@ -541,7 +547,7 @@ SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
  *-----------------------------------------------------------------------
  */
 Boolean
-Suff_IsTransform (char *str)
+Suff_IsTransform(char *str)
 {
     Suff         *src, *targ;
 
@@ -563,21 +569,21 @@ Suff_IsTransform (char *str)
  *-----------------------------------------------------------------------
  */
 GNode *
-Suff_AddTransform (char *line)
+Suff_AddTransform(char *line)
 {
     GNode         *gn;         /* GNode of transformation rule */
     Suff          *s,          /* source suffix */
                   *t;          /* target suffix */
     LstNode      ln;           /* Node for existing transformation */
 
-    ln = Lst_Find (transforms, (void *)line, SuffGNHasNameP);
+    ln = Lst_Find(transforms, (void *)line, SuffGNHasNameP);
     if (ln == NULL) {
        /*
         * Make a new graph node for the transformation. It will be filled in
         * by the Parse module.
         */
-       gn = Targ_NewGN (line);
-       (void)Lst_AtEnd (transforms, (void *)gn);
+       gn = Targ_NewGN(line);
+       Lst_AtEnd (transforms, (void *)gn);
     } else {
        /*
         * New specification for transformation rule. Just nuke the old list
@@ -585,24 +591,24 @@ Suff_AddTransform (char *line)
         * free the commands themselves, because a given command can be
         * attached to several different transformations.
         */
-       gn = (GNode *) Lst_Datum (ln);
-       Lst_Destroy (gn->commands, NOFREE);
-       Lst_Destroy (gn->children, NOFREE);
-       gn->commands = Lst_Init (FALSE);
-       gn->children = Lst_Init (FALSE);
+       gn = (GNode *)Lst_Datum(ln);
+       Lst_Destroy(gn->commands, NOFREE);
+       Lst_Destroy(gn->children, NOFREE);
+       gn->commands = Lst_Init(FALSE);
+       gn->children = Lst_Init(FALSE);
     }
 
     gn->type = OP_TRANSFORM;
 
-    (void)SuffParseTransform(line, &s, &t);
+    SuffParseTransform(line, &s, &t);
 
     /*
      * link the two together in the proper relationship and order
      */
     DEBUGF(SUFF, ("defining transformation from `%s' to `%s'\n",
           s->name, t->name));
-    SuffInsert (t->children, s);
-    SuffInsert (s->parents, t);
+    SuffInsert(t->children, s);
+    SuffInsert(s->parents, t);
 
     return (gn);
 }
@@ -627,7 +633,7 @@ Suff_AddTransform (char *line)
 int
 Suff_EndTransform(void *gnp, void *dummy __unused)
 {
-    GNode *gn = (GNode *) gnp;
+    GNode *gn = (GNode *)gnp;
 
     if ((gn->type & OP_TRANSFORM) && Lst_IsEmpty(gn->commands) &&
        Lst_IsEmpty(gn->children))
@@ -687,8 +693,8 @@ Suff_EndTransform(void *gnp, void *dummy __unused)
 static int
 SuffRebuildGraph(void *transformp, void *sp)
 {
-    GNode      *transform = (GNode *) transformp;
-    Suff       *s = (Suff *) sp;
+    GNode      *transform = (GNode *)transformp;
+    Suff       *s = (Suff *)sp;
     char       *cp;
     LstNode    ln;
     Suff       *s2 = NULL;
@@ -712,7 +718,7 @@ SuffRebuildGraph(void *transformp, void *sp)
             */
            SuffInsert(s2->children, s);
            SuffInsert(s->parents, s2);
-           return(0);
+           return (0);
        }
     }
 
@@ -739,7 +745,7 @@ SuffRebuildGraph(void *transformp, void *sp)
            SuffInsert(s2->parents, s);
        }
     }
-    return(0);
+    return (0);
 }
 
 /*-
@@ -757,31 +763,31 @@ SuffRebuildGraph(void *transformp, void *sp)
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddSuffix (char *str)
+Suff_AddSuffix(char *str)
 {
     Suff          *s;      /* new suffix descriptor */
     LstNode      ln;
 
-    ln = Lst_Find (sufflist, (void *)str, SuffSuffHasNameP);
+    ln = Lst_Find(sufflist, (void *)str, SuffSuffHasNameP);
     if (ln == NULL) {
-       s = (Suff *) emalloc (sizeof (Suff));
-
-       s->name =       estrdup (str);
-       s->nameLen =    strlen (s->name);
-       s->searchPath = Lst_Init (FALSE);
-       s->children =   Lst_Init (FALSE);
-       s->parents =    Lst_Init (FALSE);
-       s->ref =        Lst_Init (FALSE);
-       s->sNum =       sNum++;
-       s->flags =      0;
-       s->refCount =   0;
-
-       (void)Lst_AtEnd (sufflist, (void *)s);
+       s = (Suff *)emalloc(sizeof(Suff));
+
+       s->name = estrdup(str);
+       s->nameLen = strlen (s->name);
+       s->searchPath = Lst_Init(FALSE);
+       s->children = Lst_Init(FALSE);
+       s->parents = Lst_Init(FALSE);
+       s->ref = Lst_Init(FALSE);
+       s->sNum = sNum++;
+       s->flags = 0;
+       s->refCount = 0;
+
+       Lst_AtEnd(sufflist, (void *)s);
        /*
         * Look for any existing transformations from or to this suffix.
         * XXX: Only do this after a Suff_ClearSuffixes?
         */
-       Lst_ForEach (transforms, SuffRebuildGraph, (void *)s);
+       Lst_ForEach(transforms, SuffRebuildGraph, (void *)s);
     }
 }
 
@@ -799,16 +805,16 @@ Suff_AddSuffix (char *str)
  *-----------------------------------------------------------------------
  */
 Lst
-Suff_GetPath (char *sname)
+Suff_GetPath(char *sname)
 {
     LstNode      ln;
     Suff         *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
+    ln = Lst_Find(sufflist, (void *)sname, SuffSuffHasNameP);
     if (ln == NULL) {
        return (NULL);
     } else {
-       s = (Suff *) Lst_Datum (ln);
+       s = (Suff *)Lst_Datum(ln);
        return (s->searchPath);
     }
 }
@@ -840,16 +846,16 @@ Suff_DoPaths(void)
     Lst                        inIncludes; /* Cumulative .INCLUDES path */
     Lst                        inLibs;     /* Cumulative .LIBS path */
 
-    if (Lst_Open (sufflist) == FAILURE) {
+    if (Lst_Open(sufflist) == FAILURE) {
        return;
     }
 
     inIncludes = Lst_Init(FALSE);
     inLibs = Lst_Init(FALSE);
 
-    while ((ln = Lst_Next (sufflist)) != NULL) {
-       s = (Suff *) Lst_Datum (ln);
-       if (!Lst_IsEmpty (s->searchPath)) {
+    while ((ln = Lst_Next(sufflist)) != NULL) {
+       s = (Suff *)Lst_Datum(ln);
+       if (!Lst_IsEmpty(s->searchPath)) {
 #ifdef INCLUDES
            if (s->flags & SUFF_INCLUDE) {
                Dir_Concat(inIncludes, s->searchPath);
@@ -862,7 +868,7 @@ Suff_DoPaths(void)
 #endif /* LIBRARIES */
            Dir_Concat(s->searchPath, dirSearchPath);
        } else {
-           Lst_Destroy (s->searchPath, Dir_Destroy);
+           Lst_Destroy(s->searchPath, Dir_Destroy);
            s->searchPath = Lst_Duplicate(dirSearchPath, Dir_CopyDir);
        }
     }
@@ -875,7 +881,7 @@ Suff_DoPaths(void)
     Lst_Destroy(inIncludes, Dir_Destroy);
     Lst_Destroy(inLibs, Dir_Destroy);
 
-    Lst_Close (sufflist);
+    Lst_Close(sufflist);
 }
 
 /*-
@@ -894,14 +900,14 @@ Suff_DoPaths(void)
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddInclude (char *sname)
+Suff_AddInclude(char *sname)
 {
     LstNode      ln;
     Suff         *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
+    ln = Lst_Find(sufflist, (void *)sname, SuffSuffHasNameP);
     if (ln != NULL) {
-       s = (Suff *) Lst_Datum (ln);
+       s = (Suff *)Lst_Datum(ln);
        s->flags |= SUFF_INCLUDE;
     }
 }
@@ -923,14 +929,14 @@ Suff_AddInclude (char *sname)
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddLib (char *sname)
+Suff_AddLib(char *sname)
 {
     LstNode      ln;
     Suff         *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
+    ln = Lst_Find(sufflist, (void *)sname, SuffSuffHasNameP);
     if (ln != NULL) {
-       s = (Suff *) Lst_Datum (ln);
+       s = (Suff *)Lst_Datum(ln);
        s->flags |= SUFF_LIBRARY;
     }
 }
@@ -952,7 +958,7 @@ Suff_AddLib (char *sname)
  *-----------------------------------------------------------------------
  */
 static int
-SuffAddSrc (void *sp, void *lsp)
+SuffAddSrc(void *sp, void *lsp)
 {
     Suff       *s = (Suff *) sp;
     LstSrc      *ls = (LstSrc *) lsp;
@@ -967,16 +973,16 @@ SuffAddSrc (void *sp, void *lsp)
         * structure for a file with no suffix attached. Two birds, and all
         * that...
         */
-       s2 = (Src *) emalloc (sizeof (Src));
-       s2->file =      estrdup(targ->pref);
-       s2->pref =      targ->pref;
-       s2->parent =    targ;
-       s2->node =      NULL;
-       s2->suff =      s;
+       s2 = (Src *)emalloc(sizeof(Src));
+       s2->file = estrdup(targ->pref);
+       s2->pref = targ->pref;
+       s2->parent = targ;
+       s2->node = NULL;
+       s2->suff = s;
        s->refCount++;
        s2->children =  0;
        targ->children += 1;
-       (void)Lst_AtEnd (ls->l, (void *)s2);
+       Lst_AtEnd(ls->l, (void *)s2);
 #ifdef DEBUG_SRC
        s2->cp = Lst_Init(FALSE);
        Lst_AtEnd(targ->cp, (void *) s2);
@@ -985,16 +991,16 @@ SuffAddSrc (void *sp, void *lsp)
        printf("\n");
 #endif
     }
-    s2 = (Src *) emalloc (sizeof (Src));
-    s2->file =             str_concat (targ->pref, s->name, 0);
-    s2->pref =     targ->pref;
-    s2->parent =    targ;
-    s2->node =             NULL;
-    s2->suff =             s;
+    s2 = (Src *)emalloc(sizeof(Src));
+    s2->file = str_concat(targ->pref, s->name, 0);
+    s2->pref = targ->pref;
+    s2->parent = targ;
+    s2->node = NULL;
+    s2->suff = s;
     s->refCount++;
     s2->children =  0;
     targ->children += 1;
-    (void)Lst_AtEnd (ls->l, (void *)s2);
+    Lst_AtEnd(ls->l, (void *)s2);
 #ifdef DEBUG_SRC
     s2->cp = Lst_Init(FALSE);
     Lst_AtEnd(targ->cp, (void *) s2);
@@ -1003,7 +1009,7 @@ SuffAddSrc (void *sp, void *lsp)
     printf("\n");
 #endif
 
-    return(0);
+    return (0);
 }
 
 /*-
@@ -1019,14 +1025,14 @@ SuffAddSrc (void *sp, void *lsp)
  *-----------------------------------------------------------------------
  */
 static void
-SuffAddLevel (Lst l, Src *targ)
+SuffAddLevel(Lst l, Src *targ)
 {
     LstSrc         ls;
 
     ls.s = targ;
     ls.l = l;
 
-    Lst_ForEach (targ->suff->children, SuffAddSrc, (void *)&ls);
+    Lst_ForEach(targ->suff->children, SuffAddSrc, (void *)&ls);
 }
 
 /*-
@@ -1042,14 +1048,14 @@ SuffAddLevel (Lst l, Src *targ)
  *----------------------------------------------------------------------
  */
 static int
-SuffRemoveSrc (Lst l)
+SuffRemoveSrc(Lst l)
 {
     LstNode ln;
     Src *s;
     int t = 0;
 
-    if (Lst_Open (l) == FAILURE) {
-       return 0;
+    if (Lst_Open(l) == FAILURE) {
+       return (0);
     }
 #ifdef DEBUG_SRC
     printf("cleaning %lx: ", (unsigned long) l);
@@ -1058,10 +1064,10 @@ SuffRemoveSrc (Lst l)
 #endif
 
 
-    while ((ln = Lst_Next (l)) != NULL) {
-       s = (Src *) Lst_Datum (ln);
+    while ((ln = Lst_Next(l)) != NULL) {
+       s = (Src *)Lst_Datum(ln);
        if (s->children == 0) {
-           free (s->file);
+           free(s->file);
            if (!s->parent)
                free(s->pref);
            else {
@@ -1077,7 +1083,7 @@ SuffRemoveSrc (Lst l)
            Lst_Destroy(s->cp, NOFREE);
 #endif
            Lst_Remove(l, ln);
-           free (s);
+           free(s);
            t |= 1;
            Lst_Close(l);
            return TRUE;
@@ -1085,7 +1091,7 @@ SuffRemoveSrc (Lst l)
 #ifdef DEBUG_SRC
        else {
            printf("keep: [l=%x] p=%x %d: ", l, s, s->children);
-           Lst_ForEach(s->cp, PrintAddr, (void *) 0);
+           Lst_ForEach(s->cp, PrintAddr, (void *)0);
            printf("\n");
        }
 #endif
@@ -1093,7 +1099,7 @@ SuffRemoveSrc (Lst l)
 
     Lst_Close(l);
 
-    return t;
+    return (t);
 }
 
 /*-
@@ -1115,10 +1121,10 @@ SuffFindThem (Lst srcs, Lst slst)
     Src                   *rs;         /* returned Src */
     char          *ptr;
 
-    rs = (Src *) NULL;
+    rs = (Src *)NULL;
 
     while (!Lst_IsEmpty (srcs)) {
-       s = (Src *) Lst_DeQueue (srcs);
+       s = (Src *)Lst_DeQueue(srcs);
 
        DEBUGF(SUFF, ("\ttrying %s...", s->file));
 
@@ -1134,7 +1140,7 @@ SuffFindThem (Lst srcs, Lst slst)
            break;
        }
 
-       if ((ptr = Dir_FindFile (s->file, s->suff->searchPath)) != NULL) {
+       if ((ptr = Dir_FindFile(s->file, s->suff->searchPath)) != NULL) {
            rs = s;
 #ifdef DEBUG_SRC
            printf("remove %x from %x\n", s, srcs);
@@ -1145,8 +1151,8 @@ SuffFindThem (Lst srcs, Lst slst)
 
        DEBUGF(SUFF, ("not there\n"));
 
-       SuffAddLevel (srcs, s);
-       Lst_AtEnd(slst, (void *) s);
+       SuffAddLevel(srcs, s);
+       Lst_AtEnd(slst, (void *)s);
     }
 
     if (rs) {
@@ -1182,25 +1188,24 @@ SuffFindCmds (Src *targ, Lst slst)
     char               *cp;
 
     t = targ->node;
-    (void) Lst_Open (t->children);
-    prefLen = strlen (targ->pref);
+    Lst_Open(t->children);
+    prefLen = strlen(targ->pref);
 
-    while ((ln = Lst_Next (t->children)) != NULL) {
-       s = (GNode *)Lst_Datum (ln);
+    while ((ln = Lst_Next(t->children)) != NULL) {
+       s = (GNode *)Lst_Datum(ln);
 
-       cp = strrchr (s->name, '/');
+       cp = strrchr(s->name, '/');
        if (cp == (char *)NULL) {
            cp = s->name;
        } else {
            cp++;
        }
-       if (strncmp (cp, targ->pref, prefLen) == 0) {
+       if (strncmp(cp, targ->pref, prefLen) == 0) {
            /*
             * The node matches the prefix ok, see if it has a known
             * suffix.
             */
-           ln = Lst_Find (sufflist, (void *)&cp[prefLen],
-                          SuffSuffHasNameP);
+           ln = Lst_Find(sufflist, (void *)&cp[prefLen], SuffSuffHasNameP);
            if (ln != NULL) {
                /*
                 * It even has a known suffix, see if there's a transformation
@@ -1208,10 +1213,9 @@ SuffFindCmds (Src *targ, Lst slst)
                 *
                 * XXX: Handle multi-stage transformations here, too.
                 */
-               suff = (Suff *)Lst_Datum (ln);
+               suff = (Suff *)Lst_Datum(ln);
 
-               if (Lst_Member (suff->parents,
-                               (void *)targ->suff) != NULL)
+               if (Lst_Member(suff->parents, (void *)targ->suff) != NULL)
                {
                    /*
                     * Hot Damn! Create a new Src structure to describe
@@ -1219,7 +1223,7 @@ SuffFindCmds (Src *targ, Lst slst)
                     * source node's name so Suff_FindDeps can free it
                     * again (ick)), and return the new structure.
                     */
-                   ret = (Src *)emalloc (sizeof (Src));
+                   ret = (Src *)emalloc (sizeof(Src));
                    ret->file = estrdup(s->name);
                    ret->pref = targ->pref;
                    ret->suff = suff;
@@ -1231,16 +1235,16 @@ SuffFindCmds (Src *targ, Lst slst)
 #ifdef DEBUG_SRC
                    ret->cp = Lst_Init(FALSE);
                    printf("3 add %x %x\n", targ, ret);
-                   Lst_AtEnd(targ->cp, (void *) ret);
+                   Lst_AtEnd(targ->cp, (void *)ret);
 #endif
-                   Lst_AtEnd(slst, (void *) ret);
+                   Lst_AtEnd(slst, (void *)ret);
                    DEBUGF(SUFF, ("\tusing existing source %s\n", s->name));
                    return (ret);
                }
            }
        }
     }
-    Lst_Close (t->children);
+    Lst_Close(t->children);
     return ((Src *)NULL);
 }
 
@@ -1263,8 +1267,8 @@ SuffFindCmds (Src *targ, Lst slst)
 static int
 SuffExpandChildren(void *cgnp, void *pgnp)
 {
-    GNode      *cgn = (GNode *) cgnp;
-    GNode      *pgn = (GNode *) pgnp;
+    GNode      *cgn = (GNode *)cgnp;
+    GNode      *pgn = (GNode *)pgnp;
     GNode      *gn;        /* New source 8) */
     LstNode    prevLN;    /* Node after which new source should be put */
     LstNode    ln;         /* List element for old source */
@@ -1297,7 +1301,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
                 */
                char    *sacrifice = cp;
 
-               (void)Arch_ParseArchive(&sacrifice, members, pgn);
+               Arch_ParseArchive(&sacrifice, members, pgn);
            } else {
                /*
                 * Break the result into a vector of strings whose nodes
@@ -1319,7 +1323,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
                         */
                        *cp++ = '\0';
                        gn = Targ_FindNode(start, TARG_CREATE);
-                       (void)Lst_AtEnd(members, (void *)gn);
+                       Lst_AtEnd(members, (void *)gn);
                        while (*cp == ' ' || *cp == '\t') {
                            cp++;
                        }
@@ -1358,7 +1362,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
                     * Stuff left over -- add it to the list too
                     */
                    gn = Targ_FindNode(start, TARG_CREATE);
-                   (void)Lst_AtEnd(members, (void *)gn);
+                   Lst_AtEnd(members, (void *)gn);
                }
                /*
                 * Point cp back at the beginning again so the variable value
@@ -1374,9 +1378,9 @@ SuffExpandChildren(void *cgnp, void *pgnp)
 
                DEBUGF(SUFF, ("%s...", gn->name));
                if (Lst_Member(pgn->children, (void *)gn) == NULL) {
-                   (void)Lst_Append(pgn->children, prevLN, (void *)gn);
+                   Lst_Append(pgn->children, prevLN, (void *)gn);
                    prevLN = Lst_Succ(prevLN);
-                   (void)Lst_AtEnd(gn->parents, (void *)pgn);
+                   Lst_AtEnd(gn->parents, (void *)pgn);
                    pgn->unmade++;
                }
            }
@@ -1443,9 +1447,9 @@ SuffExpandChildren(void *cgnp, void *pgnp)
             * up the parent's count of unmade children.
             */
            if (Lst_Member(pgn->children, (void *)gn) == NULL) {
-               (void)Lst_Append(pgn->children, prevLN, (void *)gn);
+               Lst_Append(pgn->children, prevLN, (void *)gn);
                prevLN = Lst_Succ(prevLN);
-               (void)Lst_AtEnd(gn->parents, (void *)pgn);
+               Lst_AtEnd(gn->parents, (void *)pgn);
                pgn->unmade++;
            }
        }
@@ -1465,7 +1469,7 @@ SuffExpandChildren(void *cgnp, void *pgnp)
        DEBUGF(SUFF, ("\n"));
     }
 
-    return(0);
+    return (0);
 }
 
 /*-
@@ -1498,8 +1502,8 @@ SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
         * Not already linked, so form the proper links between the
         * target and source.
         */
-       (void)Lst_AtEnd(tGn->children, (void *)sGn);
-       (void)Lst_AtEnd(sGn->parents, (void *)tGn);
+       Lst_AtEnd(tGn->children, (void *)sGn);
+       Lst_AtEnd(sGn->parents, (void *)tGn);
        tGn->unmade += 1;
     }
 
@@ -1518,8 +1522,8 @@ SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
                 * Not already linked, so form the proper links between the
                 * target and source.
                 */
-               (void)Lst_AtEnd(tGn->children, (void *)gn);
-               (void)Lst_AtEnd(gn->parents, (void *)tGn);
+               Lst_AtEnd(tGn->children, (void *)gn);
+               Lst_AtEnd(gn->parents, (void *)tGn);
                tGn->unmade += 1;
            }
        }
@@ -1537,7 +1541,7 @@ SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
         * called to link an OP_MEMBER and OP_ARCHV node), so return
         * FALSE.
         */
-       return(FALSE);
+       return (FALSE);
     }
 
     gn = (GNode *)Lst_Datum(ln);
@@ -1552,24 +1556,23 @@ SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
     /*
      * Pass the buck to Make_HandleUse to apply the rule
      */
-    (void)Make_HandleUse(gn, tGn);
+    Make_HandleUse(gn, tGn);
 
     /*
      * Deal with wildcards and variables in any acquired sources
      */
     ln = Lst_Succ(ln);
     if (ln != NULL) {
-       Lst_ForEachFrom(tGn->children, ln,
-                       SuffExpandChildren, (void *)tGn);
+       Lst_ForEachFrom(tGn->children, ln, SuffExpandChildren, (void *)tGn);
     }
 
     /*
      * Keep track of another parent to which this beast is transformed so
      * the .IMPSRC variable can be set correctly for the parent.
      */
-    (void)Lst_AtEnd(sGn->iParents, (void *)tGn);
+    Lst_AtEnd(sGn->iParents, (void *)tGn);
 
-    return(TRUE);
+    return (TRUE);
 }
 
 
@@ -1604,8 +1607,8 @@ SuffFindArchiveDeps(GNode *gn, Lst slst)
      * The node is an archive(member) pair. so we must find a
      * suffix for both of them.
      */
-    eoarch = strchr (gn->name, '(');
-    eoname = strchr (eoarch, ')');
+    eoarch = strchr(gn->name, '(');
+    eoname = strchr(eoarch, ')');
 
     *eoname = '\0';      /* Nuke parentheses during suffix search */
     *eoarch = '\0';      /* So a suffix can be found */
@@ -1626,15 +1629,15 @@ SuffFindArchiveDeps(GNode *gn, Lst slst)
      * Create the link between the two nodes right off
      */
     if (Lst_Member(gn->children, (void *)mem) == NULL) {
-       (void)Lst_AtEnd(gn->children, (void *)mem);
-       (void)Lst_AtEnd(mem->parents, (void *)gn);
+       Lst_AtEnd(gn->children, (void *)mem);
+       Lst_AtEnd(mem->parents, (void *)gn);
        gn->unmade += 1;
     }
 
     /*
      * Copy in the variables from the member node to this one.
      */
-    for (i = (sizeof(copy)/sizeof(copy[0]))-1; i >= 0; i--) {
+    for (i = (sizeof(copy) / sizeof(copy[0]))-1; i >= 0; i--) {
        char *p1;
        Var_Set(copy[i], Var_Value(copy[i], mem, &p1), gn);
        free(p1);
@@ -1654,8 +1657,8 @@ SuffFindArchiveDeps(GNode *gn, Lst slst)
     /*
      * Set the other two local variables required for this target.
      */
-    Var_Set (MEMBER, name, gn);
-    Var_Set (ARCHIVE, gn->name, gn);
+    Var_Set(MEMBER, name, gn);
+    Var_Set(ARCHIVE, gn->name, gn);
 
     if (ms != NULL) {
        /*
@@ -1776,7 +1779,7 @@ SuffFindNormalDeps(GNode *gn, Lst slst)
            /*
             * Allocate a Src structure to which things can be transformed
             */
-           target = (Src *)emalloc(sizeof (Src));
+           target = (Src *)emalloc(sizeof(Src));
            target->file = estrdup(gn->name);
            target->suff = (Suff *)Lst_Datum(ln);
            target->suff->refCount++;
@@ -1804,7 +1807,7 @@ SuffFindNormalDeps(GNode *gn, Lst slst)
            /*
             * Record the target so we can nuke it
             */
-           (void)Lst_AtEnd(targs, (void *)target);
+           Lst_AtEnd(targs, (void *)target);
 
            /*
             * Search from this suffix's successor...
@@ -1819,7 +1822,7 @@ SuffFindNormalDeps(GNode *gn, Lst slst)
     if (Lst_IsEmpty(targs) && suffNull != NULL) {
        DEBUGF(SUFF, ("\tNo known suffix on %s. Using .NULL suffix\n", gn->name));
 
-       targ = (Src *)emalloc(sizeof (Src));
+       targ = (Src *)emalloc(sizeof(Src));
        targ->file = estrdup(gn->name);
        targ->suff = suffNull;
        targ->suff->refCount++;
@@ -1843,7 +1846,7 @@ SuffFindNormalDeps(GNode *gn, Lst slst)
 
        DEBUGF(SUFF, ("adding suffix rules\n"));
 
-       (void)Lst_AtEnd(targs, (void *)targ);
+       Lst_AtEnd(targs, (void *)targ);
     }
 
     /*
@@ -1986,8 +1989,8 @@ sfnd_abort:
             * up to, but not including, the parent node.
             */
            while (bottom && bottom->parent != NULL) {
-               if (Lst_Member(slst, (void *) bottom) == NULL) {
-                   Lst_AtEnd(slst, (void *) bottom);
+               if (Lst_Member(slst, (void *)bottom) == NULL) {
+                   Lst_AtEnd(slst, (void *)bottom);
                }
                bottom = bottom->parent;
            }
@@ -2068,8 +2071,8 @@ sfnd_abort:
      */
 sfnd_return:
     if (bottom)
-       if (Lst_Member(slst, (void *) bottom) == NULL)
-           Lst_AtEnd(slst, (void *) bottom);
+       if (Lst_Member(slst, (void *)bottom) == NULL)
+           Lst_AtEnd(slst, (void *)bottom);
 
     while (SuffRemoveSrc(srcs) || SuffRemoveSrc(targs))
        continue;
@@ -2078,7 +2081,6 @@ sfnd_return:
     Lst_Concat(slst, targs, LST_CONCLINK);
 }
 
-
 /*-
  *-----------------------------------------------------------------------
  * Suff_FindDeps  --
@@ -2106,7 +2108,6 @@ sfnd_return:
  *
  *-----------------------------------------------------------------------
  */
-
 void
 Suff_FindDeps(GNode *gn)
 {
@@ -2118,8 +2119,9 @@ Suff_FindDeps(GNode *gn)
 
 
 static void
-SuffFindDeps (GNode *gn, Lst slst)
+SuffFindDeps(GNode *gn, Lst slst)
 {
+
     if (gn->type & OP_DEPS_FOUND) {
        /*
         * If dependencies already found, no need to do it again...
@@ -2145,16 +2147,16 @@ SuffFindDeps (GNode *gn, Lst slst)
        LstNode ln;
        Suff    *s;
 
-       ln = Lst_Find (sufflist, (void *)LIBSUFF, SuffSuffHasNameP);
+       ln = Lst_Find(sufflist, (void *)LIBSUFF, SuffSuffHasNameP);
        if (gn->suffix)
            gn->suffix->refCount--;
        if (ln != NULL) {
-           gn->suffix = s = (Suff *) Lst_Datum (ln);
+           gn->suffix = s = (Suff *)Lst_Datum (ln);
            gn->suffix->refCount++;
-           Arch_FindLib (gn, s->searchPath);
+           Arch_FindLib(gn, s->searchPath);
        } else {
            gn->suffix = NULL;
-           Var_Set (TARGET, gn->name, gn);
+           Var_Set(TARGET, gn->name, gn);
        }
        /*
         * Because a library (-lfoo) target doesn't follow the standard
@@ -2202,7 +2204,7 @@ Suff_SetNull(char *name)
         */
        suffNull = s;
     } else {
-       Parse_Error (PARSE_WARNING, "Desired null suffix %s not defined.",
+       Parse_Error(PARSE_WARNING, "Desired null suffix %s not defined.",
                     name);
     }
 }
@@ -2220,12 +2222,13 @@ Suff_SetNull(char *name)
  *-----------------------------------------------------------------------
  */
 void
-Suff_Init (void)
+Suff_Init(void)
 {
-    sufflist = Lst_Init (FALSE);
+
+    sufflist = Lst_Init(FALSE);
     suffClean = Lst_Init(FALSE);
-    srclist = Lst_Init (FALSE);
-    transforms = Lst_Init (FALSE);
+    srclist = Lst_Init(FALSE);
+    transforms = Lst_Init(FALSE);
 
     sNum = 0;
     /*
@@ -2233,22 +2236,20 @@ Suff_Init (void)
      * actually go on the suffix list or everyone will think that's its
      * suffix.
      */
-    emptySuff = suffNull = (Suff *) emalloc (sizeof (Suff));
+    emptySuff = suffNull = (Suff *)emalloc(sizeof(Suff));
 
-    suffNull->name =               estrdup ("");
-    suffNull->nameLen =     0;
-    suffNull->searchPath =  Lst_Init (FALSE);
+    suffNull->name = estrdup("");
+    suffNull->nameLen = 0;
+    suffNull->searchPath = Lst_Init(FALSE);
     Dir_Concat(suffNull->searchPath, dirSearchPath);
-    suffNull->children =    Lst_Init (FALSE);
-    suffNull->parents =            Lst_Init (FALSE);
-    suffNull->ref =        Lst_Init (FALSE);
-    suffNull->sNum =               sNum++;
-    suffNull->flags =              SUFF_NULL;
-    suffNull->refCount =    1;
-
+    suffNull->children = Lst_Init(FALSE);
+    suffNull->parents = Lst_Init(FALSE);
+    suffNull->ref = Lst_Init(FALSE);
+    suffNull->sNum = sNum++;
+    suffNull->flags = SUFF_NULL;
+    suffNull->refCount = 1;
 }
 
-
 /*-
  *----------------------------------------------------------------------
  * Suff_End --
@@ -2265,6 +2266,7 @@ Suff_Init (void)
 void
 Suff_End(void)
 {
+
     Lst_Destroy(sufflist, SuffFree);
     Lst_Destroy(suffClean, SuffFree);
     if (suffNull)