Changeset 24 for branches/FREEBSD/src/kmk/dir.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/dir.c (modified) (51 diffs)

branches/FREEBSD/src/kmk/dir.c

@@ -1 +1 @@
 /*
- * Copyright (c) 1988, 1989, 1990, 1993
- *      The Regents of the University of California.  All rights reserved.
+ * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * Copyright (c) 1988, 1989 by Adam de Boor
  * Copyright (c) 1989 by Berkeley Softworks
@@ -36 +35 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- *
- * @(#)dir.c    8.2 (Berkeley) 1/2/94
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/usr.bin/make/dir.c,v 1.30 2002/10/09 03:42:10 jmallett Exp $");
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)dir.c       8.2 (Berkeley) 1/2/94";
+#else
+static const char rcsid[] =
+  "$FreeBSD: src/usr.bin/make/dir.c,v 1.10.2.1 2001/02/13 03:13:57 will Exp $";
+#endif
+#endif /* not lint */
 
 /*-
@@ -88 +91 @@
 #include <stdio.h>
 #include <sys/types.h>
+#include <dirent.h>
 #include <sys/stat.h>
-#include <dirent.h>
-#include <err.h>
 #include "make.h"
 #include "hash.h"
@@ -190 +192 @@
 
 
-static int DirFindName(void *, void *);
-static int DirMatchFiles(char *, Path *, Lst);
-static void DirExpandCurly(char *, char *, Lst, Lst);
-static void DirExpandInt(char *, Lst, Lst);
-static int DirPrintWord(void *, void *);
-static int DirPrintDir(void *, void *);
+static int DirFindName __P((ClientData, ClientData));
+static int DirMatchFiles __P((char *, Path *, Lst));
+static void DirExpandCurly __P((char *, char *, Lst, Lst));
+static void DirExpandInt __P((char *, Lst, Lst));
+static int DirPrintWord __P((ClientData, ClientData));
+static int DirPrintDir __P((ClientData, ClientData));
 
 /*-
@@ -210 +212 @@
  */
 void
-Dir_Init (void)
+Dir_Init ()
 {
     dirSearchPath = Lst_Init (FALSE);
@@ -247 +249 @@
  */
 void
-Dir_End(void)
+Dir_End()
 {
     dot->refCount -= 1;
-    Dir_Destroy((void *) dot);
+    Dir_Destroy((ClientData) dot);
     Dir_ClearPath(dirSearchPath);
     Lst_Destroy(dirSearchPath, NOFREE);
@@ -273 +275 @@
  */
 static int
-DirFindName (void *p, void *dname)
+DirFindName (p, dname)
+    ClientData    p;          /* Current name */
+    ClientData    dname;      /* Desired name */
 {
     return (strcmp (((Path *)p)->name, (char *) dname));
@@ -281 +285 @@
  *-----------------------------------------------------------------------
  * Dir_HasWildcards  --
- *      See if the given name has any wildcard characters in it.
+ *      see if the given name has any wildcard characters in it
  *
  * Results:
@@ -291 +295 @@
  */
 Boolean
-Dir_HasWildcards (char *name)
-{
-    char *cp;
-    int wild = 0, brace = 0, bracket = 0;
+Dir_HasWildcards (name)
+    char          *name;        /* name to check */
+{
+    register char *cp;
 
     for (cp = name; *cp; cp++) {
         switch(*cp) {
         case '{':
-                brace++;
-                wild = 1;
-                break;
-        case '}':
-                brace--;
-                break;
         case '[':
-                bracket++;
-                wild = 1;
-                break;
-        case ']':
-                bracket--;
-                break;
         case '?':
         case '*':
-                wild = 1;
-                break;
-        default:
-                break;
-        }
-    }
-    return wild && bracket == 0 && brace == 0;
+            return (TRUE);
+        }
+    }
+    return (FALSE);
 }
 
@@ -341 +330 @@
  */
 static int
-DirMatchFiles (char *pattern, Path *p, Lst expansions)
+DirMatchFiles (pattern, p, expansions)
+    char          *pattern;     /* Pattern to look for */
+    Path          *p;           /* Directory to search */
+    Lst           expansions;   /* Place to store the results */
 {
     Hash_Search   search;       /* Index into the directory's table */
@@ -378 +370 @@
  *      Note the special case: if after the piece of the curly brace is
  *      done there are no wildcard characters in the result, the result is
- *      placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.  The
- *      given arguments are the entire word to expand, the first curly
- *      brace in the word, the search path, and the list to store the
- *      expansions in.
+ *      placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
  *
  * Results:
@@ -392 +381 @@
  */
 static void
-DirExpandCurly(char *word, char *brace, Lst path, Lst expansions)
+DirExpandCurly(word, brace, path, expansions)
+    char          *word;        /* Entire word to expand */
+    char          *brace;       /* First curly brace in it */
+    Lst           path;         /* Search path to use */
+    Lst           expansions;   /* Place to store the expansions */
 {
     char          *end;         /* Character after the closing brace */
@@ -466 +459 @@
                 Dir_Expand(file, path, expansions);
                 goto next;
-            default:
-                break;
             }
         }
@@ -490 +481 @@
  *      Internal expand routine. Passes through the directories in the
  *      path one by one, calling DirMatchFiles for each. NOTE: This still
- *      doesn't handle patterns in directories...  Works given a word to
- *      expand, a path to look in, and a list to store expansions in.
+ *      doesn't handle patterns in directories...
  *
  * Results:
@@ -502 +492 @@
  */
 static void
-DirExpandInt(char *word, Lst path, Lst expansions)
+DirExpandInt(word, path, expansions)
+    char          *word;        /* Word to expand */
+    Lst           path;         /* Path on which to look */
+    Lst           expansions;   /* Place to store the result */
 {
     LstNode       ln;           /* Current node */
@@ -508 +501 @@
 
     if (Lst_Open(path) == SUCCESS) {
-        while ((ln = Lst_Next(path)) != NULL) {
+        while ((ln = Lst_Next(path)) != NILLNODE) {
             p = (Path *)Lst_Datum(ln);
             DirMatchFiles(word, p, expansions);
@@ -531 +524 @@
  */
 static int
-DirPrintWord(void *word, void *dummy __unused)
-{
-    DEBUGF(DIR, ("%s ", (char *) word));
-
-    return (0);
+DirPrintWord(word, dummy)
+    ClientData  word;
+    ClientData  dummy;
+{
+    printf("%s ", (char *) word);
+
+    return(dummy ? 0 : 0);
 }
 
@@ -546 +541 @@
  * Results:
  *      A list of words consisting of the files which exist along the search
- *      path matching the given pattern is placed in expansions.
+ *      path matching the given pattern.
  *
  * Side Effects:
@@ -553 +548 @@
  */
 void
-Dir_Expand (char *word, Lst path, Lst expansions)
+Dir_Expand (word, path, expansions)
+    char    *word;      /* the word to expand */
+    Lst     path;       /* the list of directories in which to find
+                         * the resulting files */
+    Lst     expansions; /* the list on which to place the results */
 {
     char          *cp;
 
-    DEBUGF(DIR, ("expanding \"%s\"...", word));
+    if (DEBUG(DIR)) {
+        printf("expanding \"%s\"...", word);
+    }
 
     cp = strchr(word, '{');
@@ -640 +641 @@
     }
     if (DEBUG(DIR)) {
-        Lst_ForEach(expansions, DirPrintWord, (void *) 0);
-        DEBUGF(DIR, ("\n"));
+        Lst_ForEach(expansions, DirPrintWord, (ClientData) 0);
+        fputc('\n', stdout);
     }
 }
@@ -664 +665 @@
  */
 char *
-Dir_FindFile (char *name, Lst path)
-{
-    char          *p1;      /* pointer into p->name */
-    char          *p2;      /* pointer into name */
+Dir_FindFile (name, path)
+    char          *name;    /* the file to find */
+    Lst           path;     /* the Lst of directories to search */
+{
+    register char *p1;      /* pointer into p->name */
+    register char *p2;      /* pointer into name */
     LstNode       ln;       /* a list element */
-    char          *file;    /* the current filename to check */
-    Path          *p;       /* current path member */
-    char          *cp;      /* index of first slash, if any */
+    register char *file;    /* the current filename to check */
+    register Path *p;       /* current path member */
+    register char *cp;      /* index of first slash, if any */
     Boolean       hasSlash; /* true if 'name' contains a / */
     struct stat   stb;      /* Buffer for stat, if necessary */
@@ -689 +692 @@
     }
 
-    DEBUGF(DIR, ("Searching for %s...", name));
+    if (DEBUG(DIR)) {
+        printf("Searching for %s...", name);
+    }
     /*
      * No matter what, we always look for the file in the current directory
@@ -698 +703 @@
     if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
         (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
-            DEBUGF(DIR, ("in '.'\n"));
+            if (DEBUG(DIR)) {
+                printf("in '.'\n");
+            }
             hits += 1;
             dot->hits += 1;
@@ -705 +712 @@
 
     if (Lst_Open (path) == FAILURE) {
-        DEBUGF(DIR, ("couldn't open path, file not found\n"));
+        if (DEBUG(DIR)) {
+            printf("couldn't open path, file not found\n");
+        }
         misses += 1;
         return ((char *) NULL);
@@ -718 +727 @@
      * we go on to phase two...
      */
-    while ((ln = Lst_Next (path)) != NULL) {
+    while ((ln = Lst_Next (path)) != NILLNODE) {
         p = (Path *) Lst_Datum (ln);
-        DEBUGF(DIR, ("%s...", p->name));
+        if (DEBUG(DIR)) {
+            printf("%s...", p->name);
+        }
         if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
-            DEBUGF(DIR, ("here..."));
+            if (DEBUG(DIR)) {
+                printf("here...");
+            }
             if (hasSlash) {
                 /*
@@ -738 +751 @@
                 }
                 if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
-                    DEBUGF(DIR, ("component mismatch -- continuing..."));
+                    if (DEBUG(DIR)) {
+                        printf("component mismatch -- continuing...");
+                    }
                     continue;
                 }
             }
             file = str_concat (p->name, cp, STR_ADDSLASH);
-            DEBUGF(DIR, ("returning %s\n", file));
+            if (DEBUG(DIR)) {
+                printf("returning %s\n", file);
+            }
             Lst_Close (path);
             p->hits += 1;
@@ -758 +775 @@
             }
             if (*p1 == '\0' && p2 == cp - 1) {
-                DEBUGF(DIR, ("must be here but isn't -- returing NULL\n"));
+                if (DEBUG(DIR)) {
+                    printf("must be here but isn't -- returing NULL\n");
+                }
                 Lst_Close (path);
                 return ((char *) NULL);
@@ -778 +797 @@
      */
     if (!hasSlash) {
-        DEBUGF(DIR, ("failed.\n"));
+        if (DEBUG(DIR)) {
+            printf("failed.\n");
+        }
         misses += 1;
         return ((char *) NULL);
@@ -786 +807 @@
         Boolean checkedDot = FALSE;
 
-        DEBUGF(DIR, ("failed. Trying subdirectories..."));
+        if (DEBUG(DIR)) {
+            printf("failed. Trying subdirectories...");
+        }
         (void) Lst_Open (path);
-        while ((ln = Lst_Next (path)) != NULL) {
+        while ((ln = Lst_Next (path)) != NILLNODE) {
             p = (Path *) Lst_Datum (ln);
             if (p != dot) {
@@ -799 +822 @@
                 checkedDot = TRUE;
             }
-            DEBUGF(DIR, ("checking %s...", file));
+            if (DEBUG(DIR)) {
+                printf("checking %s...", file);
+            }
+
 
             if (stat (file, &stb) == 0) {
-                DEBUGF(DIR, ("got it.\n"));
+                if (DEBUG(DIR)) {
+                    printf("got it.\n");
+                }
 
                 Lst_Close (path);
@@ -825 +853 @@
                  * to fetch it again.
                  */
-                DEBUGF(DIR, ("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), file));
+                if (DEBUG(DIR)) {
+                    printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
+                            file);
+                }
                 entry = Hash_CreateEntry(&mtimes, (char *) file,
                                          (Boolean *)NULL);
@@ -836 +867 @@
         }
 
-        DEBUGF(DIR, ("failed. "));
+        if (DEBUG(DIR)) {
+            printf("failed. ");
+        }
         Lst_Close (path);
 
@@ -844 +877 @@
              * so no point in proceeding...
              */
-            DEBUGF(DIR, ("Checked . already, returning NULL\n"));
+            if (DEBUG(DIR)) {
+                printf("Checked . already, returning NULL\n");
+            }
             return(NULL);
         }
@@ -873 +908 @@
     bigmisses += 1;
     ln = Lst_Last (path);
-    if (ln == NULL) {
+    if (ln == NILLNODE) {
         return ((char *) NULL);
     } else {
@@ -885 +920 @@
     }
 #else /* !notdef */
-    DEBUGF(DIR, ("Looking for \"%s\"...", name));
+    if (DEBUG(DIR)) {
+        printf("Looking for \"%s\"...", name);
+    }
 
     bigmisses += 1;
     entry = Hash_FindEntry(&mtimes, name);
     if (entry != (Hash_Entry *)NULL) {
-        DEBUGF(DIR, ("got it (in mtime cache)\n"));
-        return (estrdup(name));
+        if (DEBUG(DIR)) {
+            printf("got it (in mtime cache)\n");
+        }
+        return(estrdup(name));
     } else if (stat (name, &stb) == 0) {
         entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
-        DEBUGF(DIR, ("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), name));
+        if (DEBUG(DIR)) {
+            printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
+                    name);
+        }
         Hash_SetValue(entry, (long)stb.st_mtime);
         return (estrdup (name));
     } else {
-        DEBUGF(DIR, ("failed. Returning NULL\n"));
+        if (DEBUG(DIR)) {
+            printf("failed. Returning NULL\n");
+        }
         return ((char *)NULL);
     }
@@ -920 +964 @@
  */
 int
-Dir_MTime (GNode *gn)
+Dir_MTime (gn)
+    GNode         *gn;        /* the file whose modification time is
+                               * desired */
 {
     char          *fullName;  /* the full pathname of name */
@@ -943 +989 @@
          * Only do this once -- the second time folks are checking to
          * see if the file was actually updated, so we need to actually go
-         * to the filesystem.
+         * to the file system.
          */
-        DEBUGF(DIR, ("Using cached time %s for %s\n",
-               Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName));
+        if (DEBUG(DIR)) {
+            printf("Using cached time %s for %s\n",
+                    Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
+        }
         stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
         Hash_DeleteEntry(&mtimes, entry);
@@ -982 +1030 @@
  */
 void
-Dir_AddDir (Lst path, char *name)
+Dir_AddDir (path, name)
+    Lst           path;       /* the path to which the directory should be
+                               * added */
+    char          *name;      /* the name of the directory to add */
 {
     LstNode       ln;         /* node in case Path structure is found */
-    Path          *p;         /* pointer to new Path structure */
+    register 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);
-    if (ln != NULL) {
+    register struct dirent *dp; /* entry in directory */
+
+    ln = Lst_Find (openDirectories, (ClientData)name, DirFindName);
+    if (ln != NILLNODE) {
         p = (Path *)Lst_Datum (ln);
-        if (Lst_Member(path, (void *)p) == NULL) {
+        if (Lst_Member(path, (ClientData)p) == NILLNODE) {
             p->refCount += 1;
-            (void)Lst_AtEnd (path, (void *)p);
+            (void)Lst_AtEnd (path, (ClientData)p);
         }
     } else {
-        DEBUGF(DIR, ("Caching %s...", name));
+        if (DEBUG(DIR)) {
+            printf("Caching %s...", name);
+            fflush(stdout);
+        }
 
         if ((d = opendir (name)) != (DIR *) NULL) {
@@ -1007 +1061 @@
 
             while ((dp = readdir (d)) != (struct dirent *) NULL) {
-#if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define for d_fileno */
+#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
@@ -1022 +1076 @@
                  * that order when first going through a directory.  This is
                  * needed for XFS over NFS filesystems since SGI does not
-                 * guarantee that these are the first two entries returned
+                 * guarantee that these are * the first two entries returned
                  * from readdir().
                  */
@@ -1031 +1085 @@
             }
             (void) closedir (d);
-            (void)Lst_AtEnd (openDirectories, (void *)p);
-            (void)Lst_AtEnd (path, (void *)p);
-        }
-        DEBUGF(DIR, ("done\n"));
+            (void)Lst_AtEnd (openDirectories, (ClientData)p);
+            (void)Lst_AtEnd (path, (ClientData)p);
+        }
+        if (DEBUG(DIR)) {
+            printf("done\n");
+        }
     }
 }
@@ -1052 +1108 @@
  *-----------------------------------------------------------------------
  */
-void *
-Dir_CopyDir(void *p)
+ClientData
+Dir_CopyDir(p)
+    ClientData p;
 {
     ((Path *) p)->refCount += 1;
 
-    return ((void *)p);
+    return ((ClientData)p);
 }
 
@@ -1078 +1135 @@
  */
 char *
-Dir_MakeFlags (char *flag, Lst path)
+Dir_MakeFlags (flag, path)
+    char          *flag;  /* flag which should precede each directory */
+    Lst           path;   /* list of directories */
 {
     char          *str;   /* the string which will be returned */
@@ -1088 +1147 @@
 
     if (Lst_Open (path) == SUCCESS) {
-        while ((ln = Lst_Next (path)) != NULL) {
+        while ((ln = Lst_Next (path)) != NILLNODE) {
             p = (Path *) Lst_Datum (ln);
             tstr = str_concat (flag, p->name, 0);
@@ -1115 +1174 @@
  */
 void
-Dir_Destroy (void *pp)
+Dir_Destroy (pp)
+    ClientData    pp;       /* The directory descriptor to nuke */
 {
     Path          *p = (Path *) pp;
@@ -1123 +1183 @@
         LstNode ln;
 
-        ln = Lst_Member (openDirectories, (void *)p);
+        ln = Lst_Member (openDirectories, (ClientData)p);
         (void) Lst_Remove (openDirectories, ln);
 
         Hash_DeleteTable (&p->files);
-        free(p->name);
-        free(p);
+        free((Address)p->name);
+        free((Address)p);
     }
 }
@@ -1147 +1207 @@
  */
 void
-Dir_ClearPath(Lst path)
+Dir_ClearPath(path)
+    Lst     path;       /* Path to clear */
 {
     Path    *p;
     while (!Lst_IsEmpty(path)) {
         p = (Path *)Lst_DeQueue(path);
-        Dir_Destroy((void *) p);
+        Dir_Destroy((ClientData) p);
     }
 }
@@ -1172 +1233 @@
  */
 void
-Dir_Concat(Lst path1, Lst path2)
+Dir_Concat(path1, path2)
+    Lst     path1;      /* Dest */
+    Lst     path2;      /* Source */
 {
     LstNode ln;
     Path    *p;
 
-    for (ln = Lst_First(path2); ln != NULL; ln = Lst_Succ(ln)) {
+    for (ln = Lst_First(path2); ln != NILLNODE; ln = Lst_Succ(ln)) {
         p = (Path *)Lst_Datum(ln);
-        if (Lst_Member(path1, (void *)p) == NULL) {
+        if (Lst_Member(path1, (ClientData)p) == NILLNODE) {
             p->refCount += 1;
-            (void)Lst_AtEnd(path1, (void *)p);
+            (void)Lst_AtEnd(path1, (ClientData)p);
         }
     }
@@ -1188 +1251 @@
 /********** DEBUG INFO **********/
 void
-Dir_PrintDirectories(void)
+Dir_PrintDirectories()
 {
     LstNode     ln;
@@ -1200 +1263 @@
     printf ("# %-20s referenced\thits\n", "directory");
     if (Lst_Open (openDirectories) == SUCCESS) {
-        while ((ln = Lst_Next (openDirectories)) != NULL) {
+        while ((ln = Lst_Next (openDirectories)) != NILLNODE) {
             p = (Path *) Lst_Datum (ln);
             printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
@@ -1208 +1271 @@
 }
 
-static int
-DirPrintDir (void *p, void *dummy __unused)
+static int DirPrintDir (p, dummy)
+    ClientData  p;
+    ClientData  dummy;
 {
     printf ("%s ", ((Path *) p)->name);
-
-    return (0);
+    return (dummy ? 0 : 0);
 }
 
 void
-Dir_PrintPath (Lst path)
-{
-    Lst_ForEach (path, DirPrintDir, (void *)0);
-}
+Dir_PrintPath (path)
+    Lst path;
+{
+    Lst_ForEach (path, DirPrintDir, (ClientData)0);
+}