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

Timestamp:

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

Author:

bird

Message:

Import of RELENG_4_7_0_RELEASE

File:

• branches/FREEBSD/src/kmk/suff.c (modified) (105 diffs)

branches/FREEBSD/src/kmk/suff.c

@@ -35 +35 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- *
- * @(#)suff.c   8.4 (Berkeley) 3/21/94
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/usr.bin/make/suff.c,v 1.26 2002/10/09 03:42:10 jmallett Exp $");
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)suff.c      8.4 (Berkeley) 3/21/94";
+#else
+static const char rcsid[] =
+  "$FreeBSD: src/usr.bin/make/suff.c,v 1.12.2.1 2001/03/09 01:13:24 tmm Exp $";
+#endif
+#endif /* not lint */
 
 /*-
@@ -89 +93 @@
  *      Suff_FindDeps           Find implicit sources for and the location of
  *                              a target based on its suffix. Returns the
- *                              bottom-most node added to the graph or NULL
+ *                              bottom-most node added to the graph or NILGNODE
  *                              if the target had no implicit sources.
  */
@@ -112 +116 @@
     int          nameLen;       /* Length of the suffix */
     short        flags;         /* Type of suffix */
-#define SUFF_INCLUDE      0x01      /* One which is #include'd */
-#define SUFF_LIBRARY      0x02      /* One which contains a library */
-#define SUFF_NULL         0x04      /* The empty suffix */
+#define SUFF_INCLUDE      0x01      /* One which is #include'd */
+#define SUFF_LIBRARY      0x02      /* One which contains a library */
+#define SUFF_NULL         0x04      /* The empty suffix */
     Lst          searchPath;    /* The path along which files of this suffix
                                  * may be found */
@@ -154 +158 @@
 
 
-static char *SuffStrIsPrefix(char *, char *);
-static char *SuffSuffIsSuffix(Suff *, char *);
-static int SuffSuffIsSuffixP(void *, void *);
-static int SuffSuffHasNameP(void *, void *);
-static int SuffSuffIsPrefix(void *, void *);
-static int SuffGNHasNameP(void *, void *);
-static void SuffFree(void *);
-static void SuffInsert(Lst, Suff *);
-static void SuffRemove(Lst, Suff *);
-static Boolean SuffParseTransform(char *, Suff **, Suff **);
-static int SuffRebuildGraph(void *, void *);
-static int SuffAddSrc(void *, void *);
-static int SuffRemoveSrc(Lst);
-static void SuffAddLevel(Lst, Src *);
-static Src *SuffFindThem(Lst, Lst);
-static Src *SuffFindCmds(Src *, Lst);
-static int SuffExpandChildren(void *, void *);
-static Boolean SuffApplyTransform(GNode *, GNode *, Suff *, Suff *);
-static void SuffFindDeps(GNode *, Lst);
-static void SuffFindArchiveDeps(GNode *, Lst);
-static void SuffFindNormalDeps(GNode *, Lst);
-static int SuffPrintName(void *, void *);
-static int SuffPrintSuff(void *, void *);
-static int SuffPrintTrans(void *, void *);
+static char *SuffStrIsPrefix __P((char *, char *));
+static char *SuffSuffIsSuffix __P((Suff *, char *));
+static int SuffSuffIsSuffixP __P((ClientData, ClientData));
+static int SuffSuffHasNameP __P((ClientData, ClientData));
+static int SuffSuffIsPrefix __P((ClientData, ClientData));
+static int SuffGNHasNameP __P((ClientData, ClientData));
+static void SuffFree __P((ClientData));
+static void SuffInsert __P((Lst, Suff *));
+static void SuffRemove __P((Lst, Suff *));
+static Boolean SuffParseTransform __P((char *, Suff **, Suff **));
+static int SuffRebuildGraph __P((ClientData, ClientData));
+static int SuffAddSrc __P((ClientData, ClientData));
+static int SuffRemoveSrc __P((Lst));
+static void SuffAddLevel __P((Lst, Src *));
+static Src *SuffFindThem __P((Lst, Lst));
+static Src *SuffFindCmds __P((Src *, Lst));
+static int SuffExpandChildren __P((ClientData, ClientData));
+static Boolean SuffApplyTransform __P((GNode *, GNode *, Suff *, Suff *));
+static void SuffFindDeps __P((GNode *, Lst));
+static void SuffFindArchiveDeps __P((GNode *, Lst));
+static void SuffFindNormalDeps __P((GNode *, Lst));
+static int SuffPrintName __P((ClientData, ClientData));
+static int SuffPrintSuff __P((ClientData, ClientData));
+static int SuffPrintTrans __P((ClientData, ClientData));
 
         /*************** Lst Predicates ****************/
@@ -193 +197 @@
  */
 static char    *
-SuffStrIsPrefix (char *pref, char *str)
+SuffStrIsPrefix (pref, str)
+    register char  *pref;       /* possible prefix */
+    register char  *str;        /* string to check */
 {
     while (*str && *pref == *str) {
@@ -218 +224 @@
  */
 static char *
-SuffSuffIsSuffix (Suff *s, char *str)
-{
-    char           *p1;         /* Pointer into suffix name */
-    char           *p2;         /* Pointer into string being examined */
+SuffSuffIsSuffix (s, str)
+    register Suff  *s;          /* possible suffix */
+    char           *str;        /* string to examine */
+{
+    register char  *p1;         /* Pointer into suffix name */
+    register char  *p2;         /* Pointer into string being examined */
 
     p1 = s->name + s->nameLen;
@@ -249 +257 @@
  */
 static int
-SuffSuffIsSuffixP(void *s, void *str)
+SuffSuffIsSuffixP(s, str)
+    ClientData   s;
+    ClientData   str;
 {
     return(!SuffSuffIsSuffix((Suff *) s, (char *) str));
@@ -268 +278 @@
  */
 static int
-SuffSuffHasNameP (void *s, void *sname)
+SuffSuffHasNameP (s, sname)
+    ClientData    s;                /* Suffix to check */
+    ClientData    sname;            /* Desired name */
 {
     return (strcmp ((char *) sname, ((Suff *) s)->name));
@@ -289 +301 @@
  */
 static int
-SuffSuffIsPrefix (void *s, void *str)
+SuffSuffIsPrefix (s, str)
+    ClientData   s;             /* suffix to compare */
+    ClientData   str;   /* string to examine */
 {
     return (SuffStrIsPrefix (((Suff *) s)->name, (char *) str) == NULL ? 1 : 0);
@@ -307 +321 @@
  */
 static int
-SuffGNHasNameP (void *gn, void *name)
+SuffGNHasNameP (gn, name)
+    ClientData      gn;         /* current node we're looking at */
+    ClientData      name;       /* name we're looking for */
 {
     return (strcmp ((char *) name, ((GNode *) gn)->name));
@@ -327 +343 @@
  */
 static void
-SuffFree (void *sp)
+SuffFree (sp)
+    ClientData sp;
 {
     Suff           *s = (Suff *) sp;
@@ -342 +359 @@
     Lst_Destroy (s->searchPath, Dir_Destroy);
 
-    free (s->name);
-    free (s);
+    free ((Address)s->name);
+    free ((Address)s);
 }
 
@@ -359 +376 @@
  */
 static void
-SuffRemove(Lst l, Suff *s)
-{
-    LstNode ln = Lst_Member(l, (void *)s);
-    if (ln != NULL) {
+SuffRemove(l, s)
+    Lst l;
+    Suff *s;
+{
+    LstNode ln = Lst_Member(l, (ClientData)s);
+    if (ln != NILLNODE) {
         Lst_Remove(l, ln);
         s->refCount--;
@@ -383 +402 @@
  */
 static void
-SuffInsert (Lst l, Suff *s)
+SuffInsert (l, s)
+    Lst           l;            /* the list where in s should be inserted */
+    Suff          *s;           /* the suffix to insert */
 {
     LstNode       ln;           /* current element in l we're examining */
@@ -391 +412 @@
         return;
     }
-    while ((ln = Lst_Next (l)) != NULL) {
+    while ((ln = Lst_Next (l)) != NILLNODE) {
         s2 = (Suff *) Lst_Datum (ln);
         if (s2->sNum >= s->sNum) {
@@ -397 +418 @@
         }
     }
-    if (s2 == NULL) {
-            DEBUGF(SUFF, ("inserting an empty list?..."));
-    }
 
     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);
+    if (DEBUG(SUFF)) {
+        printf("inserting %s(%d)...", s->name, s->sNum);
+    }
+    if (ln == NILLNODE) {
+        if (DEBUG(SUFF)) {
+            printf("at end of list\n");
+        }
+        (void)Lst_AtEnd (l, (ClientData)s);
         s->refCount++;
-        (void)Lst_AtEnd(s->ref, (void *) l);
+        (void)Lst_AtEnd(s->ref, (ClientData) l);
     } else if (s2->sNum != s->sNum) {
-        DEBUGF(SUFF, ("before %s(%d)\n", s2->name, s2->sNum));
-        (void)Lst_Insert (l, ln, (void *)s);
+        if (DEBUG(SUFF)) {
+            printf("before %s(%d)\n", s2->name, s2->sNum);
+        }
+        (void)Lst_Insert (l, ln, (ClientData)s);
         s->refCount++;
-        (void)Lst_AtEnd(s->ref, (void *) l);
-    } else {
-        DEBUGF(SUFF, ("already there\n"));
+        (void)Lst_AtEnd(s->ref, (ClientData) l);
+    } else if (DEBUG(SUFF)) {
+        printf("already there\n");
     }
 }
@@ -436 +460 @@
  */
 void
-Suff_ClearSuffixes (void)
+Suff_ClearSuffixes ()
 {
     Lst_Concat (suffClean, sufflist, LST_CONCLINK);
@@ -448 +472 @@
      * suffNull should not have parents.
      */
-    Lst_Destroy(suffNull->children, NOFREE); 
+    Lst_Destroy(suffNull->children, NOFREE);
     suffNull->children = Lst_Init(FALSE);
 }
@@ -466 +490 @@
  */
 static Boolean
-SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
-{
-    LstNode             srcLn;      /* element in suffix list of trans source*/
-    Suff                *src;       /* Source of transformation */
-    LstNode             targLn;     /* element in suffix list of trans target*/
-    char                *str2;      /* Extra pointer (maybe target suffix) */
+SuffParseTransform(str, srcPtr, targPtr)
+    char                *str;           /* String being parsed */
+    Suff                **srcPtr;       /* Place to store source of trans. */
+    Suff                **targPtr;      /* Place to store target of trans. */
+{
+    register LstNode    srcLn;      /* element in suffix list of trans source*/
+    register Suff       *src;       /* Source of transformation */
+    register LstNode    targLn;     /* element in suffix list of trans target*/
+    register char       *str2;      /* Extra pointer (maybe target suffix) */
     LstNode             singleLn;   /* element in suffix list of any suffix
                                      * that exactly matches str */
@@ -477 +504 @@
                                      * null suffix */
 
-    srcLn = NULL;
-    singleLn = NULL;
+    srcLn = NILLNODE;
+    singleLn = NILLNODE;
 
     /*
@@ -487 +514 @@
      */
     for (;;) {
-        if (srcLn == NULL) {
-            srcLn = Lst_Find(sufflist, (void *)str, SuffSuffIsPrefix);
+        if (srcLn == NILLNODE) {
+            srcLn = Lst_Find(sufflist, (ClientData)str, SuffSuffIsPrefix);
         } else {
-            srcLn = Lst_FindFrom (sufflist, Lst_Succ(srcLn), (void *)str,
+            srcLn = Lst_FindFrom (sufflist, Lst_Succ(srcLn), (ClientData)str,
                                   SuffSuffIsPrefix);
         }
-        if (srcLn == NULL) {
+        if (srcLn == NILLNODE) {
             /*
              * Ran out of source suffixes -- no such rule
              */
-            if (singleLn != NULL) {
+            if (singleLn != NILLNODE) {
                 /*
                  * Not so fast Mr. Smith! There was a suffix that encompassed
@@ -519 +546 @@
             singleLn = srcLn;
         } else {
-            targLn = Lst_Find(sufflist, (void *)str2, SuffSuffHasNameP);
-            if (targLn != NULL) {
+            targLn = Lst_Find(sufflist, (ClientData)str2, SuffSuffHasNameP);
+            if (targLn != NILLNODE) {
                 *srcPtr = src;
                 *targPtr = (Suff *)Lst_Datum(targLn);
@@ -544 +571 @@
  */
 Boolean
-Suff_IsTransform (char *str)
+Suff_IsTransform (str)
+    char          *str;         /* string to check */
 {
     Suff          *src, *targ;
@@ -566 +594 @@
  */
 GNode *
-Suff_AddTransform (char *line)
+Suff_AddTransform (line)
+    char          *line;        /* name of transformation to add */
 {
     GNode         *gn;          /* GNode of transformation rule */
@@ -573 +602 @@
     LstNode       ln;           /* Node for existing transformation */
 
-    ln = Lst_Find (transforms, (void *)line, SuffGNHasNameP);
-    if (ln == NULL) {
+    ln = Lst_Find (transforms, (ClientData)line, SuffGNHasNameP);
+    if (ln == NILLNODE) {
         /*
          * Make a new graph node for the transformation. It will be filled in
@@ -580 +609 @@
          */
         gn = Targ_NewGN (line);
-        (void)Lst_AtEnd (transforms, (void *)gn);
+        (void)Lst_AtEnd (transforms, (ClientData)gn);
     } else {
         /*
@@ -602 +631 @@
      * link the two together in the proper relationship and order
      */
-    DEBUGF(SUFF, ("defining transformation from `%s' to `%s'\n",
-           s->name, t->name));
+    if (DEBUG(SUFF)) {
+        printf("defining transformation from `%s' to `%s'\n",
+                s->name, t->name);
+    }
     SuffInsert (t->children, s);
     SuffInsert (s->parents, t);
@@ -628 +659 @@
  */
 int
-Suff_EndTransform(void *gnp, void *dummy __unused)
+Suff_EndTransform(gnp, dummy)
+    ClientData   gnp;           /* Node for transformation */
+    ClientData   dummy;         /* Node for transformation */
 {
     GNode *gn = (GNode *) gnp;
@@ -639 +672 @@
         (void)SuffParseTransform(gn->name, &s, &t);
 
-        DEBUGF(SUFF, ("deleting transformation from `%s' to `%s'\n",
-               s->name, t->name));
+        if (DEBUG(SUFF)) {
+            printf("deleting transformation from `%s' to `%s'\n",
+                    s->name, t->name);
+        }
 
         /*
          * Remove the source from the target's children list. We check for a
-         * NULL return to handle a beanhead saying something like
+         * nil return to handle a beanhead saying something like
          *  .c.o .c.o:
          *
@@ -656 +691 @@
          */
         SuffRemove(s->parents, t);
-    } else if (gn->type & OP_TRANSFORM) {
-        DEBUGF(SUFF, ("transformation %s complete\n", gn->name));
-    }
-
-    return (0);
+    } else if ((gn->type & OP_TRANSFORM) && DEBUG(SUFF)) {
+        printf("transformation %s complete\n", gn->name);
+    }
+
+    return(dummy ? 0 : 0);
 }
 
@@ -683 +718 @@
  */
 static int
-SuffRebuildGraph(void *transformp, void *sp)
+SuffRebuildGraph(transformp, sp)
+    ClientData  transformp; /* Transformation to test */
+    ClientData  sp;         /* Suffix to rebuild */
 {
     GNode       *transform = (GNode *) transformp;
@@ -696 +733 @@
     cp = SuffStrIsPrefix(s->name, transform->name);
     if (cp != (char *)NULL) {
-        if (cp[0] == '\0')  /* null rule */
+        if (cp[0] == '\0')  /* null rule */
             s2 = suffNull;
         else {
-            ln = Lst_Find(sufflist, (void *)cp, SuffSuffHasNameP);
-            if (ln != NULL) 
-                s2 = (Suff *)Lst_Datum(ln);
+            ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffHasNameP);
+            if (ln != NILLNODE)
+                s2 = (Suff *)Lst_Datum(ln);
         }
         if (s2 != NULL) {
@@ -723 +760 @@
          */
         cp[1] = '\0';
-        ln = Lst_Find(sufflist, (void *)transform->name, SuffSuffHasNameP);
+        ln = Lst_Find(sufflist, (ClientData)transform->name, SuffSuffHasNameP);
         /*
          * Replace the start of the target suffix
          */
         cp[1] = s->name[0];
-        if (ln != NULL) {
+        if (ln != NILLNODE) {
             /*
              * Found it -- establish the proper relationship
@@ -755 +792 @@
  */
 void
-Suff_AddSuffix (char *str)
+Suff_AddSuffix (str)
+    char          *str;     /* the name of the suffix to add */
 {
     Suff          *s;       /* new suffix descriptor */
     LstNode       ln;
 
-    ln = Lst_Find (sufflist, (void *)str, SuffSuffHasNameP);
-    if (ln == NULL) {
+    ln = Lst_Find (sufflist, (ClientData)str, SuffSuffHasNameP);
+    if (ln == NILLNODE) {
         s = (Suff *) emalloc (sizeof (Suff));
 
@@ -774 +812 @@
         s->refCount =   0;
 
-        (void)Lst_AtEnd (sufflist, (void *)s);
+        (void)Lst_AtEnd (sufflist, (ClientData)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, (ClientData)s);
     }
 }
@@ -789 +827 @@
  *
  * Results:
- *      The searchPath for the desired suffix or NULL if the suffix isn't
+ *      The searchPath for the desired suffix or NILLST if the suffix isn't
  *      defined.
  *
@@ -797 +835 @@
  */
 Lst
-Suff_GetPath (char *sname)
+Suff_GetPath (sname)
+    char          *sname;
 {
     LstNode       ln;
     Suff          *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
-    if (ln == NULL) {
-        return (NULL);
+    ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
+    if (ln == NILLNODE) {
+        return (NILLST);
     } else {
         s = (Suff *) Lst_Datum (ln);
@@ -824 +863 @@
  *      directories in dirSearchPath. If paths were specified for the
  *      ".h" suffix, the directories are stuffed into a global variable
- *      called ".INCLUDES" with each directory preceded by a -I. The same
+ *      called ".INCLUDES" with each directory preceeded by a -I. The same
  *      is done for the ".a" suffix, except the variable is called
  *      ".LIBS" and the flag is -L.
@@ -830 +869 @@
  */
 void
-Suff_DoPaths(void)
-{
-    Suff                *s;
-    LstNode             ln;
+Suff_DoPaths()
+{
+    register Suff       *s;
+    register LstNode    ln;
     char                *ptr;
     Lst                 inIncludes; /* Cumulative .INCLUDES path */
@@ -845 +884 @@
     inLibs = Lst_Init(FALSE);
 
-    while ((ln = Lst_Next (sufflist)) != NULL) {
+    while ((ln = Lst_Next (sufflist)) != NILLNODE) {
         s = (Suff *) Lst_Datum (ln);
         if (!Lst_IsEmpty (s->searchPath)) {
@@ -892 +931 @@
  */
 void
-Suff_AddInclude (char *sname)
+Suff_AddInclude (sname)
+    char          *sname;     /* Name of suffix to mark */
 {
     LstNode       ln;
     Suff          *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
-    if (ln != NULL) {
+    ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
+    if (ln != NILLNODE) {
         s = (Suff *) Lst_Datum (ln);
         s->flags |= SUFF_INCLUDE;
@@ -921 +961 @@
  */
 void
-Suff_AddLib (char *sname)
+Suff_AddLib (sname)
+    char          *sname;     /* Name of suffix to mark */
 {
     LstNode       ln;
     Suff          *s;
 
-    ln = Lst_Find (sufflist, (void *)sname, SuffSuffHasNameP);
-    if (ln != NULL) {
+    ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
+    if (ln != NILLNODE) {
         s = (Suff *) Lst_Datum (ln);
         s->flags |= SUFF_LIBRARY;
@@ -950 +991 @@
  */
 static int
-SuffAddSrc (void *sp, void *lsp)
+SuffAddSrc (sp, lsp)
+    ClientData  sp;         /* suffix for which to create a Src structure */
+    ClientData  lsp;        /* list and parent for the new Src */
 {
     Suff        *s = (Suff *) sp;
@@ -969 +1012 @@
         s2->pref =      targ->pref;
         s2->parent =    targ;
-        s2->node =      NULL;
+        s2->node =      NILGNODE;
         s2->suff =      s;
         s->refCount++;
         s2->children =  0;
         targ->children += 1;
-        (void)Lst_AtEnd (ls->l, (void *)s2);
+        (void)Lst_AtEnd (ls->l, (ClientData)s2);
 #ifdef DEBUG_SRC
         s2->cp = Lst_Init(FALSE);
-        Lst_AtEnd(targ->cp, (void *) s2);
+        Lst_AtEnd(targ->cp, (ClientData) s2);
         printf("1 add %x %x to %x:", targ, s2, ls->l);
-        Lst_ForEach(ls->l, PrintAddr, (void *) 0);
+        Lst_ForEach(ls->l, PrintAddr, (ClientData) 0);
         printf("\n");
 #endif
@@ -987 +1030 @@
     s2->pref =      targ->pref;
     s2->parent =    targ;
-    s2->node =      NULL;
+    s2->node =      NILGNODE;
     s2->suff =      s;
     s->refCount++;
     s2->children =  0;
     targ->children += 1;
-    (void)Lst_AtEnd (ls->l, (void *)s2);
+    (void)Lst_AtEnd (ls->l, (ClientData)s2);
 #ifdef DEBUG_SRC
     s2->cp = Lst_Init(FALSE);
-    Lst_AtEnd(targ->cp, (void *) s2);
+    Lst_AtEnd(targ->cp, (ClientData) s2);
     printf("2 add %x %x to %x:", targ, s2, ls->l);
-    Lst_ForEach(ls->l, PrintAddr, (void *) 0);
+    Lst_ForEach(ls->l, PrintAddr, (ClientData) 0);
     printf("\n");
 #endif
@@ -1017 +1060 @@
  */
 static void
-SuffAddLevel (Lst l, Src *targ)
+SuffAddLevel (l, targ)
+    Lst            l;           /* list to which to add the new level */
+    Src            *targ;       /* Src structure to use as the parent */
 {
     LstSrc         ls;
@@ -1024 +1069 @@
     ls.l = l;
 
-    Lst_ForEach (targ->suff->children, SuffAddSrc, (void *)&ls);
+    Lst_ForEach (targ->suff->children, SuffAddSrc, (ClientData)&ls);
 }
 
@@ -1040 +1085 @@
  */
 static int
-SuffRemoveSrc (Lst l)
+SuffRemoveSrc (l)
+    Lst l;
 {
     LstNode ln;
@@ -1051 +1097 @@
 #ifdef DEBUG_SRC
     printf("cleaning %lx: ", (unsigned long) l);
-    Lst_ForEach(l, PrintAddr, (void *) 0);
+    Lst_ForEach(l, PrintAddr, (ClientData) 0);
     printf("\n");
 #endif
 
 
-    while ((ln = Lst_Next (l)) != NULL) {
+    while ((ln = Lst_Next (l)) != NILLNODE) {
         s = (Src *) Lst_Datum (ln);
         if (s->children == 0) {
-            free (s->file);
+            free ((Address)s->file);
             if (!s->parent)
-                free(s->pref);
+                free((Address)s->pref);
             else {
 #ifdef DEBUG_SRC
-                LstNode ln = Lst_Member(s->parent->cp, (void *)s);
-                if (ln != NULL)
+                LstNode ln = Lst_Member(s->parent->cp, (ClientData)s);
+                if (ln != NILLNODE)
                     Lst_Remove(s->parent->cp, ln);
 #endif
@@ -1075 +1121 @@
 #endif
             Lst_Remove(l, ln);
-            free (s);
+            free ((Address)s);
             t |= 1;
             Lst_Close(l);
@@ -1083 +1129 @@
         else {
             printf("keep: [l=%x] p=%x %d: ", l, s, s->children);
-            Lst_ForEach(s->cp, PrintAddr, (void *) 0);
+            Lst_ForEach(s->cp, PrintAddr, (ClientData) 0);
             printf("\n");
         }
@@ -1107 +1153 @@
  */
 static Src *
-SuffFindThem (Lst srcs, Lst slst)
+SuffFindThem (srcs, slst)
+    Lst            srcs;        /* list of Src structures to search through */
+    Lst            slst;
 {
     Src            *s;          /* current Src */
@@ -1118 +1166 @@
         s = (Src *) Lst_DeQueue (srcs);
 
-        DEBUGF(SUFF, ("\ttrying %s...", s->file));
+        if (DEBUG(SUFF)) {
+            printf ("\ttrying %s...", s->file);
+        }
 
         /*
@@ -1124 +1174 @@
          * graph for it or the file actually exists.
          */
-        if (Targ_FindNode(s->file, TARG_NOCREATE) != NULL) {
+        if (Targ_FindNode(s->file, TARG_NOCREATE) != NILGNODE) {
 #ifdef DEBUG_SRC
             printf("remove %x from %x\n", s, srcs);
@@ -1141 +1191 @@
         }
 
-        DEBUGF(SUFF, ("not there\n"));
+        if (DEBUG(SUFF)) {
+            printf ("not there\n");
+        }
 
         SuffAddLevel (srcs, s);
-        Lst_AtEnd(slst, (void *) s);
-    }
-
-    if (rs) {
-        DEBUGF(SUFF, ("got it\n"));
+        Lst_AtEnd(slst, (ClientData) s);
+    }
+
+    if (DEBUG(SUFF) && rs) {
+        printf ("got it\n");
     }
     return (rs);
@@ -1161 +1213 @@
  *
  * Results:
- *      The Src structure of the "winning" child, or NULL if no such beast.
+ *      The Src structure of the "winning" child, or NIL if no such beast.
  *
  * Side Effects:
@@ -1169 +1221 @@
  */
 static Src *
-SuffFindCmds (Src *targ, Lst slst)
+SuffFindCmds (targ, slst)
+    Src         *targ;  /* Src structure to play with */
+    Lst         slst;
 {
     LstNode             ln;     /* General-purpose list node */
-    GNode               *t,     /* Target GNode */
+    register GNode      *t,     /* Target GNode */
                         *s;     /* Source GNode */
     int                 prefLen;/* The length of the defined prefix */
@@ -1183 +1237 @@
     prefLen = strlen (targ->pref);
 
-    while ((ln = Lst_Next (t->children)) != NULL) {
+    while ((ln = Lst_Next (t->children)) != NILLNODE) {
         s = (GNode *)Lst_Datum (ln);
 
@@ -1197 +1251 @@
              * suffix.
              */
-            ln = Lst_Find (sufflist, (void *)&cp[prefLen],
+            ln = Lst_Find (sufflist, (ClientData)&cp[prefLen],
                            SuffSuffHasNameP);
-            if (ln != NULL) {
+            if (ln != NILLNODE) {
                 /*
                  * It even has a known suffix, see if there's a transformation
@@ -1209 +1263 @@
 
                 if (Lst_Member (suff->parents,
-                                (void *)targ->suff) != NULL)
+                                (ClientData)targ->suff) != NILLNODE)
                 {
                     /*
@@ -1229 +1283 @@
                     ret->cp = Lst_Init(FALSE);
                     printf("3 add %x %x\n", targ, ret);
-                    Lst_AtEnd(targ->cp, (void *) ret);
+                    Lst_AtEnd(targ->cp, (ClientData) ret);
 #endif
-                    Lst_AtEnd(slst, (void *) ret);
-                    DEBUGF(SUFF, ("\tusing existing source %s\n", s->name));
+                    Lst_AtEnd(slst, (ClientData) ret);
+                    if (DEBUG(SUFF)) {
+                        printf ("\tusing existing source %s\n", s->name);
+                    }
                     return (ret);
                 }
@@ -1259 +1315 @@
  */
 static int
-SuffExpandChildren(void *cgnp, void *pgnp)
+SuffExpandChildren(cgnp, pgnp)
+    ClientData  cgnp;       /* Child to examine */
+    ClientData  pgnp;       /* Parent node being processed */
 {
     GNode       *cgn = (GNode *) cgnp;
@@ -1272 +1330 @@
      * after the child
      */
-    prevLN = Lst_Member(pgn->children, (void *)cgn);
+    prevLN = Lst_Member(pgn->children, (ClientData)cgn);
 
     /*
@@ -1281 +1339 @@
      */
     if (strchr(cgn->name, '$') != (char *)NULL) {
-        DEBUGF(SUFF, ("Expanding \"%s\"...", cgn->name));
+        if (DEBUG(SUFF)) {
+            printf("Expanding \"%s\"...", cgn->name);
+        }
         cp = Var_Subst(NULL, cgn->name, pgn, TRUE);
 
@@ -1317 +1377 @@
                         *cp++ = '\0';
                         gn = Targ_FindNode(start, TARG_CREATE);
-                        (void)Lst_AtEnd(members, (void *)gn);
+                        (void)Lst_AtEnd(members, (ClientData)gn);
                         while (*cp == ' ' || *cp == '\t') {
                             cp++;
@@ -1356 +1416 @@
                      */
                     gn = Targ_FindNode(start, TARG_CREATE);
-                    (void)Lst_AtEnd(members, (void *)gn);
+                    (void)Lst_AtEnd(members, (ClientData)gn);
                 }
                 /*
@@ -1370 +1430 @@
                 gn = (GNode *)Lst_DeQueue(members);
 
-                DEBUGF(SUFF, ("%s...", gn->name));
-                if (Lst_Member(pgn->children, (void *)gn) == NULL) {
-                    (void)Lst_Append(pgn->children, prevLN, (void *)gn);
+                if (DEBUG(SUFF)) {
+                    printf("%s...", gn->name);
+                }
+                if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
+                    (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
                     prevLN = Lst_Succ(prevLN);
-                    (void)Lst_AtEnd(gn->parents, (void *)pgn);
+                    (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
                     pgn->unmade++;
                 }
@@ -1388 +1450 @@
          * keep it from being processed.
          */
-        ln = Lst_Member(pgn->children, (void *)cgn);
+        ln = Lst_Member(pgn->children, (ClientData)cgn);
         pgn->unmade--;
         Lst_Remove(pgn->children, ln);
-        DEBUGF(SUFF, ("\n"));
+        if (DEBUG(SUFF)) {
+            printf("\n");
+        }
     } else if (Dir_HasWildcards(cgn->name)) {
         Lst     exp;        /* List of expansions */
@@ -1405 +1469 @@
          */
         cp = cgn->name + strlen(cgn->name);
-        ln = Lst_Find(sufflist, (void *)cp, SuffSuffIsSuffixP);
-
-        DEBUGF(SUFF, ("Wildcard expanding \"%s\"...", cgn->name));
-
-        if (ln != NULL) {
+        ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffIsSuffixP);
+
+        if (DEBUG(SUFF)) {
+            printf("Wildcard expanding \"%s\"...", cgn->name);
+        }
+
+        if (ln != NILLNODE) {
             Suff    *s = (Suff *)Lst_Datum(ln);
 
-            DEBUGF(SUFF, ("suffix is \"%s\"...", s->name));
+            if (DEBUG(SUFF)) {
+                printf("suffix is \"%s\"...", s->name);
+            }
             path = s->searchPath;
         } else {
@@ -1433 +1501 @@
             cp = (char *)Lst_DeQueue(exp);
 
-            DEBUGF(SUFF, ("%s...", cp));
+            if (DEBUG(SUFF)) {
+                printf("%s...", cp);
+            }
             gn = Targ_FindNode(cp, TARG_CREATE);
 
@@ -1440 +1510 @@
              * up the parent's count of unmade children.
              */
-            if (Lst_Member(pgn->children, (void *)gn) == NULL) {
-                (void)Lst_Append(pgn->children, prevLN, (void *)gn);
+            if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
+                (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
                 prevLN = Lst_Succ(prevLN);
-                (void)Lst_AtEnd(gn->parents, (void *)pgn);
+                (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
                 pgn->unmade++;
             }
@@ -1457 +1527 @@
          * keep it from being processed.
          */
-        ln = Lst_Member(pgn->children, (void *)cgn);
+        ln = Lst_Member(pgn->children, (ClientData)cgn);
         pgn->unmade--;
         Lst_Remove(pgn->children, ln);
-        DEBUGF(SUFF, ("\n"));
+        if (DEBUG(SUFF)) {
+            printf("\n");
+        }
     }
 
@@ -1485 +1557 @@
  */
 static Boolean
-SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
+SuffApplyTransform(tGn, sGn, t, s)
+    GNode       *tGn;       /* Target node */
+    GNode       *sGn;       /* Source node */
+    Suff        *t;         /* Target suffix */
+    Suff        *s;         /* Source suffix */
 {
     LstNode     ln;         /* General node */
@@ -1491 +1567 @@
     GNode       *gn;        /* Node for same */
 
-    if (Lst_Member(tGn->children, (void *)sGn) == NULL) {
+    if (Lst_Member(tGn->children, (ClientData)sGn) == NILLNODE) {
         /*
          * 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);
+        (void)Lst_AtEnd(tGn->children, (ClientData)sGn);
+        (void)Lst_AtEnd(sGn->parents, (ClientData)tGn);
         tGn->unmade += 1;
     }
@@ -1508 +1584 @@
          * will be sufficient to get the .IMPSRC variable set for tGn
          */
-        for (ln=Lst_First(sGn->cohorts); ln != NULL; ln=Lst_Succ(ln)) {
+        for (ln=Lst_First(sGn->cohorts); ln != NILLNODE; ln=Lst_Succ(ln)) {
             gn = (GNode *)Lst_Datum(ln);
 
-            if (Lst_Member(tGn->children, (void *)gn) == NULL) {
+            if (Lst_Member(tGn->children, (ClientData)gn) == NILLNODE) {
                 /*
                  * 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);
+                (void)Lst_AtEnd(tGn->children, (ClientData)gn);
+                (void)Lst_AtEnd(gn->parents, (ClientData)tGn);
                 tGn->unmade += 1;
             }
@@ -1526 +1602 @@
      */
     tname = str_concat(s->name, t->name, 0);
-    ln = Lst_Find(transforms, (void *)tname, SuffGNHasNameP);
+    ln = Lst_Find(transforms, (ClientData)tname, SuffGNHasNameP);
     free(tname);
 
-    if (ln == NULL) {
+    if (ln == NILLNODE) {
         /*
          * Not really such a transformation rule (can happen when we're
@@ -1540 +1616 @@
     gn = (GNode *)Lst_Datum(ln);
 
-    DEBUGF(SUFF, ("\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name));
+    if (DEBUG(SUFF)) {
+        printf("\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name);
+    }
 
     /*
@@ -1556 +1634 @@
      */
     ln = Lst_Succ(ln);
-    if (ln != NULL) {
+    if (ln != NILLNODE) {
         Lst_ForEachFrom(tGn->children, ln,
-                        SuffExpandChildren, (void *)tGn);
+                        SuffExpandChildren, (ClientData)tGn);
     }
 
@@ -1565 +1643 @@
      * the .IMPSRC variable can be set correctly for the parent.
      */
-    (void)Lst_AtEnd(sGn->iParents, (void *)tGn);
+    (void)Lst_AtEnd(sGn->iParents, (ClientData)tGn);
 
     return(TRUE);
@@ -1585 +1663 @@
  */
 static void
-SuffFindArchiveDeps(GNode *gn, Lst slst)
+SuffFindArchiveDeps(gn, slst)
+    GNode       *gn;        /* Node for which to locate dependencies */
+    Lst         slst;
 {
     char        *eoarch;    /* End of archive portion */
@@ -1623 +1703 @@
      * 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);
+    if (Lst_Member(gn->children, (ClientData)mem) == NILLNODE) {
+        (void)Lst_AtEnd(gn->children, (ClientData)mem);
+        (void)Lst_AtEnd(mem->parents, (ClientData)gn);
         gn->unmade += 1;
     }
@@ -1644 +1724 @@
          * Didn't know what it was -- use .NULL suffix if not in make mode
          */
-        DEBUGF(SUFF, ("using null suffix\n"));
+        if (DEBUG(SUFF)) {
+            printf("using null suffix\n");
+        }
         ms = suffNull;
     }
@@ -1669 +1751 @@
         ln = Lst_Find(ms->parents, eoarch, SuffSuffIsSuffixP);
 
-        if (ln != NULL) {
+        if (ln != NILLNODE) {
             /*
              * Got one -- apply it
              */
-            if (!SuffApplyTransform(gn, mem, (Suff *)Lst_Datum(ln), ms)) {
-                DEBUGF(SUFF, ("\tNo transformation from %s -> %s\n",
-                       ms->name, ((Suff *)Lst_Datum(ln))->name));
+            if (!SuffApplyTransform(gn, mem, (Suff *)Lst_Datum(ln), ms) &&
+                DEBUG(SUFF))
+            {
+                printf("\tNo transformation from %s -> %s\n",
+                       ms->name, ((Suff *)Lst_Datum(ln))->name);
             }
         }
@@ -1716 +1800 @@
  */
 static void
-SuffFindNormalDeps(GNode *gn, Lst slst)
+SuffFindNormalDeps(gn, slst)
+    GNode       *gn;        /* Node for which to find sources */
+    Lst         slst;
 {
     char        *eoname;    /* End of name */
@@ -1761 +1847 @@
      */
 
-    while (ln != NULL) {
+    while (ln != NILLNODE) {
         /*
          * Look for next possible suffix...
@@ -1767 +1853 @@
         ln = Lst_FindFrom(sufflist, ln, eoname, SuffSuffIsSuffixP);
 
-        if (ln != NULL) {
+        if (ln != NILLNODE) {
             int     prefLen;        /* Length of the prefix */
-            Src     *target;
+            Src     *targ;
 
             /*
              * Allocate a Src structure to which things can be transformed
              */
-            target = (Src *)emalloc(sizeof (Src));
-            target->file = estrdup(gn->name);
-            target->suff = (Suff *)Lst_Datum(ln);
-            target->suff->refCount++;
-            target->node = gn;
-            target->parent = (Src *)NULL;
-            target->children = 0;
+            targ = (Src *)emalloc(sizeof (Src));
+            targ->file = estrdup(gn->name);
+            targ->suff = (Suff *)Lst_Datum(ln);
+            targ->suff->refCount++;
+            targ->node = gn;
+            targ->parent = (Src *)NULL;
+            targ->children = 0;
 #ifdef DEBUG_SRC
-            target->cp = Lst_Init(FALSE);
+            targ->cp = Lst_Init(FALSE);
 #endif
 
@@ -1789 +1875 @@
              * the length of the suffix from the end of the name.
              */
-            prefLen = (eoname - target->suff->nameLen) - sopref;
-            target->pref = emalloc(prefLen + 1);
-            memcpy(target->pref, sopref, prefLen);
-            target->pref[prefLen] = '\0';
+            prefLen = (eoname - targ->suff->nameLen) - sopref;
+            targ->pref = emalloc(prefLen + 1);
+            memcpy(targ->pref, sopref, prefLen);
+            targ->pref[prefLen] = '\0';
 
             /*
              * Add nodes from which the target can be made
              */
-            SuffAddLevel(srcs, target);
+            SuffAddLevel(srcs, targ);
 
             /*
              * Record the target so we can nuke it
              */
-            (void)Lst_AtEnd(targs, (void *)target);
+            (void)Lst_AtEnd(targs, (ClientData)targ);
 
             /*
@@ -1815 +1901 @@
      */
     if (Lst_IsEmpty(targs) && suffNull != NULL) {
-        DEBUGF(SUFF, ("\tNo known suffix on %s. Using .NULL suffix\n", gn->name));
+        if (DEBUG(SUFF)) {
+            printf("\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
+        }
 
         targ = (Src *)emalloc(sizeof (Src));
@@ -1836 +1924 @@
             SuffAddLevel(srcs, targ);
         else {
-            DEBUGF(SUFF, ("not "));
-        }
-
-        DEBUGF(SUFF, ("adding suffix rules\n"));
-
-        (void)Lst_AtEnd(targs, (void *)targ);
+            if (DEBUG(SUFF))
+                printf("not ");
+        }
+
+        if (DEBUG(SUFF))
+            printf("adding suffix rules\n");
+
+        (void)Lst_AtEnd(targs, (ClientData)targ);
     }
 
@@ -1884 +1974 @@
      * that still contain variables or wildcards in their names.
      */
-    Lst_ForEach(gn->children, SuffExpandChildren, (void *)gn);
+    Lst_ForEach(gn->children, SuffExpandChildren, (ClientData)gn);
 
     if (targ == NULL) {
-        DEBUGF(SUFF, ("\tNo valid suffix on %s\n", gn->name));
+        if (DEBUG(SUFF)) {
+            printf("\tNo valid suffix on %s\n", gn->name);
+        }
 
 sfnd_abort:
@@ -1984 +2076 @@
              */
             while (bottom && bottom->parent != NULL) {
-                if (Lst_Member(slst, (void *) bottom) == NULL) {
-                    Lst_AtEnd(slst, (void *) bottom);
+                if (Lst_Member(slst, (ClientData) bottom) == NILLNODE) {
+                    Lst_AtEnd(slst, (ClientData) bottom);
                 }
                 bottom = bottom->parent;
@@ -2012 +2104 @@
      * Etc.
      */
-    if (bottom->node == NULL) {
+    if (bottom->node == NILGNODE) {
         bottom->node = Targ_FindNode(bottom->file, TARG_CREATE);
     }
@@ -2024 +2116 @@
         src->node->suffix->refCount++;
 
-        if (targ->node == NULL) {
+        if (targ->node == NILGNODE) {
             targ->node = Targ_FindNode(targ->file, TARG_CREATE);
         }
@@ -2066 +2158 @@
 sfnd_return:
     if (bottom)
-        if (Lst_Member(slst, (void *) bottom) == NULL)
-            Lst_AtEnd(slst, (void *) bottom);
+        if (Lst_Member(slst, (ClientData) bottom) == NILLNODE)
+            Lst_AtEnd(slst, (ClientData) bottom);
 
     while (SuffRemoveSrc(srcs) || SuffRemoveSrc(targs))
@@ -2106 +2198 @@
 
 void
-Suff_FindDeps(GNode *gn)
+Suff_FindDeps(gn)
+    GNode *gn;
 {
 
@@ -2116 +2209 @@
 
 static void
-SuffFindDeps (GNode *gn, Lst slst)
+SuffFindDeps (gn, slst)
+    GNode         *gn;          /* node we're dealing with */
+    Lst           slst;
 {
     if (gn->type & OP_DEPS_FOUND) {
@@ -2127 +2222 @@
     }
 
-    DEBUGF(SUFF, ("SuffFindDeps (%s)\n", gn->name));
+    if (DEBUG(SUFF)) {
+        printf ("SuffFindDeps (%s)\n", gn->name);
+    }
 
     if (gn->type & OP_ARCHV) {
@@ -2143 +2240 @@
         Suff    *s;
 
-        ln = Lst_Find (sufflist, (void *)LIBSUFF, SuffSuffHasNameP);
+        ln = Lst_Find (sufflist, (ClientData)LIBSUFF, SuffSuffHasNameP);
         if (gn->suffix)
             gn->suffix->refCount--;
-        if (ln != NULL) {
+        if (ln != NILLNODE) {
             gn->suffix = s = (Suff *) Lst_Datum (ln);
             gn->suffix->refCount++;
@@ -2183 +2280 @@
  */
 void
-Suff_SetNull(char *name)
+Suff_SetNull(name)
+    char    *name;          /* Name of null suffix */
 {
     Suff    *s;
     LstNode ln;
 
-    ln = Lst_Find(sufflist, (void *)name, SuffSuffHasNameP);
-    if (ln != NULL) {
+    ln = Lst_Find(sufflist, (ClientData)name, SuffSuffHasNameP);
+    if (ln != NILLNODE) {
         s = (Suff *)Lst_Datum(ln);
         if (suffNull != (Suff *)NULL) {
@@ -2218 +2316 @@
  */
 void
-Suff_Init (void)
+Suff_Init ()
 {
     sufflist = Lst_Init (FALSE);
@@ -2261 +2359 @@
 
 void
-Suff_End(void)
+Suff_End()
 {
     Lst_Destroy(sufflist, SuffFree);
@@ -2274 +2372 @@
 /********************* DEBUGGING FUNCTIONS **********************/
 
+static int SuffPrintName(s, dummy)
+    ClientData s;
+    ClientData dummy;
+{
+    printf ("`%s' ", ((Suff *) s)->name);
+    return (dummy ? 0 : 0);
+}
+
 static int
-SuffPrintName(void *s, void *dummy __unused)
-{
-    printf ("`%s' ", ((Suff *) s)->name);
-    return (0);
-}
-
-static int
-SuffPrintSuff (void *sp, void *dummy __unused)
+SuffPrintSuff (sp, dummy)
+    ClientData sp;
+    ClientData dummy;
 {
     Suff    *s = (Suff *) sp;
@@ -2306 +2407 @@
                     printf ("LIBRARY");
                     break;
-                default:
-                    break;
             }
             fputc(flags ? '|' : ')', stdout);
@@ -2314 +2413 @@
     fputc ('\n', stdout);
     printf ("#\tTo: ");
-    Lst_ForEach (s->parents, SuffPrintName, (void *)0);
+    Lst_ForEach (s->parents, SuffPrintName, (ClientData)0);
     fputc ('\n', stdout);
     printf ("#\tFrom: ");
-    Lst_ForEach (s->children, SuffPrintName, (void *)0);
+    Lst_ForEach (s->children, SuffPrintName, (ClientData)0);
     fputc ('\n', stdout);
     printf ("#\tSearch Path: ");
     Dir_PrintPath (s->searchPath);
     fputc ('\n', stdout);
-    return (0);
+    return (dummy ? 0 : 0);
 }
 
 static int
-SuffPrintTrans (void *tp, void *dummy __unused)
+SuffPrintTrans (tp, dummy)
+    ClientData tp;
+    ClientData dummy;
 {
     GNode   *t = (GNode *) tp;
@@ -2333 +2434 @@
     Targ_PrintType (t->type);
     fputc ('\n', stdout);
-    Lst_ForEach (t->commands, Targ_PrintCmd, (void *)0);
+    Lst_ForEach (t->commands, Targ_PrintCmd, (ClientData)0);
     fputc ('\n', stdout);
-    return (0);
+    return(dummy ? 0 : 0);
 }
 
 void
-Suff_PrintAll(void)
+Suff_PrintAll()
 {
     printf ("#*** Suffixes:\n");
-    Lst_ForEach (sufflist, SuffPrintSuff, (void *)0);
+    Lst_ForEach (sufflist, SuffPrintSuff, (ClientData)0);
 
     printf ("#*** Transformations:\n");
-    Lst_ForEach (transforms, SuffPrintTrans, (void *)0);
-}
+    Lst_ForEach (transforms, SuffPrintTrans, (ClientData)0);
+}