Deleted Added
sdiff udiff text old ( 103503 ) new ( 103508 )
full compact
dir.c (103503) dir.c (103508)
1/*
2 * Copyright (c) 1988, 1989, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1988, 1989 by Adam de Boor
5 * Copyright (c) 1989 by Berkeley Softworks
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by

--- 26 unchanged lines hidden (view full) ---

35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * @(#)dir.c 8.2 (Berkeley) 1/2/94
40 */
41
42#include <sys/cdefs.h>
1/*
2 * Copyright (c) 1988, 1989, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1988, 1989 by Adam de Boor
5 * Copyright (c) 1989 by Berkeley Softworks
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by

--- 26 unchanged lines hidden (view full) ---

35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * @(#)dir.c 8.2 (Berkeley) 1/2/94
40 */
41
42#include <sys/cdefs.h>
43__FBSDID("$FreeBSD: head/usr.bin/make/dir.c 103503 2002-09-17 21:29:06Z jmallett $");
43__FBSDID("$FreeBSD: head/usr.bin/make/dir.c 103508 2002-09-17 22:31:26Z jmallett $");
44
45/*-
46 * dir.c --
47 * Directory searching using wildcards and/or normal names...
48 * Used both for source wildcarding in the Makefile and for finding
49 * implicit sources.
50 *
51 * The interface for this module is:

--- 484 unchanged lines hidden (view full) ---

536 *
537 *-----------------------------------------------------------------------
538 */
539static int
540DirPrintWord(word, dummy)
541 void * word;
542 void * dummy;
543{
44
45/*-
46 * dir.c --
47 * Directory searching using wildcards and/or normal names...
48 * Used both for source wildcarding in the Makefile and for finding
49 * implicit sources.
50 *
51 * The interface for this module is:

--- 484 unchanged lines hidden (view full) ---

536 *
537 *-----------------------------------------------------------------------
538 */
539static int
540DirPrintWord(word, dummy)
541 void * word;
542 void * dummy;
543{
544 printf("%s ", (char *) word);
544 DEBUGF(DIR, "%s ", (char *) word);
545
546 return(dummy ? 0 : 0);
547}
548
549/*-
550 *-----------------------------------------------------------------------
551 * Dir_Expand --
552 * Expand the given word into a list of words by globbing it looking

--- 11 unchanged lines hidden (view full) ---

564Dir_Expand (word, path, expansions)
565 char *word; /* the word to expand */
566 Lst path; /* the list of directories in which to find
567 * the resulting files */
568 Lst expansions; /* the list on which to place the results */
569{
570 char *cp;
571
545
546 return(dummy ? 0 : 0);
547}
548
549/*-
550 *-----------------------------------------------------------------------
551 * Dir_Expand --
552 * Expand the given word into a list of words by globbing it looking

--- 11 unchanged lines hidden (view full) ---

564Dir_Expand (word, path, expansions)
565 char *word; /* the word to expand */
566 Lst path; /* the list of directories in which to find
567 * the resulting files */
568 Lst expansions; /* the list on which to place the results */
569{
570 char *cp;
571
572 if (DEBUG(DIR)) {
573 printf("expanding \"%s\"...", word);
574 }
572 DEBUGF(DIR, "expanding \"%s\"...", word);
575
576 cp = strchr(word, '{');
577 if (cp) {
578 DirExpandCurly(word, cp, path, expansions);
579 } else {
580 cp = strchr(word, '/');
581 if (cp) {
582 /*

--- 67 unchanged lines hidden (view full) ---

650 /*
651 * Then the files in every other directory on the path.
652 */
653 DirExpandInt(word, path, expansions);
654 }
655 }
656 if (DEBUG(DIR)) {
657 Lst_ForEach(expansions, DirPrintWord, (void *) 0);
573
574 cp = strchr(word, '{');
575 if (cp) {
576 DirExpandCurly(word, cp, path, expansions);
577 } else {
578 cp = strchr(word, '/');
579 if (cp) {
580 /*

--- 67 unchanged lines hidden (view full) ---

648 /*
649 * Then the files in every other directory on the path.
650 */
651 DirExpandInt(word, path, expansions);
652 }
653 }
654 if (DEBUG(DIR)) {
655 Lst_ForEach(expansions, DirPrintWord, (void *) 0);
658 fputc('\n', stdout);
656 DEBUGF(DIR, "\n");
659 }
660}
661
662/*-
663 *-----------------------------------------------------------------------
664 * Dir_FindFile --
665 * Find the file with the given name along the given search path.
666 *

--- 33 unchanged lines hidden (view full) ---

700 if (cp) {
701 hasSlash = TRUE;
702 cp += 1;
703 } else {
704 hasSlash = FALSE;
705 cp = name;
706 }
707
657 }
658}
659
660/*-
661 *-----------------------------------------------------------------------
662 * Dir_FindFile --
663 * Find the file with the given name along the given search path.
664 *

--- 33 unchanged lines hidden (view full) ---

698 if (cp) {
699 hasSlash = TRUE;
700 cp += 1;
701 } else {
702 hasSlash = FALSE;
703 cp = name;
704 }
705
708 if (DEBUG(DIR)) {
709 printf("Searching for %s...", name);
710 }
706 DEBUGF(DIR, "Searching for %s...", name);
711 /*
712 * No matter what, we always look for the file in the current directory
713 * before anywhere else and we *do not* add the ./ to it if it exists.
714 * This is so there are no conflicts between what the user specifies
715 * (fish.c) and what pmake finds (./fish.c).
716 */
717 if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
718 (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
707 /*
708 * No matter what, we always look for the file in the current directory
709 * before anywhere else and we *do not* add the ./ to it if it exists.
710 * This is so there are no conflicts between what the user specifies
711 * (fish.c) and what pmake finds (./fish.c).
712 */
713 if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
714 (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
719 if (DEBUG(DIR)) {
720 printf("in '.'\n");
721 }
715 DEBUGF(DIR, "in '.'\n");
722 hits += 1;
723 dot->hits += 1;
724 return (estrdup (name));
725 }
726
727 if (Lst_Open (path) == FAILURE) {
716 hits += 1;
717 dot->hits += 1;
718 return (estrdup (name));
719 }
720
721 if (Lst_Open (path) == FAILURE) {
728 if (DEBUG(DIR)) {
729 printf("couldn't open path, file not found\n");
730 }
722 DEBUGF(DIR, "couldn't open path, file not found\n");
731 misses += 1;
732 return ((char *) NULL);
733 }
734
735 /*
736 * We look through all the directories on the path seeking one which
737 * contains the final component of the given name and whose final
738 * component(s) match the name's initial component(s). If such a beast
739 * is found, we concatenate the directory name and the final component
740 * and return the resulting string. If we don't find any such thing,
741 * we go on to phase two...
742 */
743 while ((ln = Lst_Next (path)) != NULL) {
744 p = (Path *) Lst_Datum (ln);
723 misses += 1;
724 return ((char *) NULL);
725 }
726
727 /*
728 * We look through all the directories on the path seeking one which
729 * contains the final component of the given name and whose final
730 * component(s) match the name's initial component(s). If such a beast
731 * is found, we concatenate the directory name and the final component
732 * and return the resulting string. If we don't find any such thing,
733 * we go on to phase two...
734 */
735 while ((ln = Lst_Next (path)) != NULL) {
736 p = (Path *) Lst_Datum (ln);
745 if (DEBUG(DIR)) {
746 printf("%s...", p->name);
747 }
737 DEBUGF(DIR, "%s...", p->name);
748 if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
738 if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
749 if (DEBUG(DIR)) {
750 printf("here...");
751 }
739 DEBUGF(DIR, "here...");
752 if (hasSlash) {
753 /*
754 * If the name had a slash, its initial components and p's
755 * final components must match. This is false if a mismatch
756 * is encountered before all of the initial components
757 * have been checked (p2 > name at the end of the loop), or
758 * we matched only part of one of the components of p
759 * along with all the rest of them (*p1 != '/').
760 */
761 p1 = p->name + strlen (p->name) - 1;
762 p2 = cp - 2;
763 while (p2 >= name && p1 >= p->name && *p1 == *p2) {
764 p1 -= 1; p2 -= 1;
765 }
766 if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
740 if (hasSlash) {
741 /*
742 * If the name had a slash, its initial components and p's
743 * final components must match. This is false if a mismatch
744 * is encountered before all of the initial components
745 * have been checked (p2 > name at the end of the loop), or
746 * we matched only part of one of the components of p
747 * along with all the rest of them (*p1 != '/').
748 */
749 p1 = p->name + strlen (p->name) - 1;
750 p2 = cp - 2;
751 while (p2 >= name && p1 >= p->name && *p1 == *p2) {
752 p1 -= 1; p2 -= 1;
753 }
754 if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
767 if (DEBUG(DIR)) {
768 printf("component mismatch -- continuing...");
769 }
755 DEBUGF(DIR, "component mismatch -- continuing...");
770 continue;
771 }
772 }
773 file = str_concat (p->name, cp, STR_ADDSLASH);
756 continue;
757 }
758 }
759 file = str_concat (p->name, cp, STR_ADDSLASH);
774 if (DEBUG(DIR)) {
775 printf("returning %s\n", file);
776 }
760 DEBUGF(DIR, "returning %s\n", file);
777 Lst_Close (path);
778 p->hits += 1;
779 hits += 1;
780 return (file);
781 } else if (hasSlash) {
782 /*
783 * If the file has a leading path component and that component
784 * exactly matches the entire name of the current search
785 * directory, we assume the file doesn't exist and return NULL.
786 */
787 for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
788 continue;
789 }
790 if (*p1 == '\0' && p2 == cp - 1) {
761 Lst_Close (path);
762 p->hits += 1;
763 hits += 1;
764 return (file);
765 } else if (hasSlash) {
766 /*
767 * If the file has a leading path component and that component
768 * exactly matches the entire name of the current search
769 * directory, we assume the file doesn't exist and return NULL.
770 */
771 for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
772 continue;
773 }
774 if (*p1 == '\0' && p2 == cp - 1) {
791 if (DEBUG(DIR)) {
792 printf("must be here but isn't -- returing NULL\n");
793 }
775 DEBUGF(DIR, "must be here but isn't -- returing NULL\n");
794 Lst_Close (path);
795 return ((char *) NULL);
796 }
797 }
798 }
799
800 /*
801 * We didn't find the file on any existing members of the directory.
802 * If the name doesn't contain a slash, that means it doesn't exist.
803 * If it *does* contain a slash, however, there is still hope: it
804 * could be in a subdirectory of one of the members of the search
805 * path. (eg. /usr/include and sys/types.h. The above search would
806 * fail to turn up types.h in /usr/include, but it *is* in
807 * /usr/include/sys/types.h) If we find such a beast, we assume there
808 * will be more (what else can we assume?) and add all but the last
809 * component of the resulting name onto the search path (at the
810 * end). This phase is only performed if the file is *not* absolute.
811 */
812 if (!hasSlash) {
776 Lst_Close (path);
777 return ((char *) NULL);
778 }
779 }
780 }
781
782 /*
783 * We didn't find the file on any existing members of the directory.
784 * If the name doesn't contain a slash, that means it doesn't exist.
785 * If it *does* contain a slash, however, there is still hope: it
786 * could be in a subdirectory of one of the members of the search
787 * path. (eg. /usr/include and sys/types.h. The above search would
788 * fail to turn up types.h in /usr/include, but it *is* in
789 * /usr/include/sys/types.h) If we find such a beast, we assume there
790 * will be more (what else can we assume?) and add all but the last
791 * component of the resulting name onto the search path (at the
792 * end). This phase is only performed if the file is *not* absolute.
793 */
794 if (!hasSlash) {
813 if (DEBUG(DIR)) {
814 printf("failed.\n");
815 }
795 DEBUGF(DIR, "failed.\n");
816 misses += 1;
817 return ((char *) NULL);
818 }
819
820 if (*name != '/') {
821 Boolean checkedDot = FALSE;
822
796 misses += 1;
797 return ((char *) NULL);
798 }
799
800 if (*name != '/') {
801 Boolean checkedDot = FALSE;
802
823 if (DEBUG(DIR)) {
824 printf("failed. Trying subdirectories...");
825 }
803 DEBUGF(DIR, "failed. Trying subdirectories...");
826 (void) Lst_Open (path);
827 while ((ln = Lst_Next (path)) != NULL) {
828 p = (Path *) Lst_Datum (ln);
829 if (p != dot) {
830 file = str_concat (p->name, name, STR_ADDSLASH);
831 } else {
832 /*
833 * Checking in dot -- DON'T put a leading ./ on the thing.
834 */
835 file = estrdup(name);
836 checkedDot = TRUE;
837 }
804 (void) Lst_Open (path);
805 while ((ln = Lst_Next (path)) != NULL) {
806 p = (Path *) Lst_Datum (ln);
807 if (p != dot) {
808 file = str_concat (p->name, name, STR_ADDSLASH);
809 } else {
810 /*
811 * Checking in dot -- DON'T put a leading ./ on the thing.
812 */
813 file = estrdup(name);
814 checkedDot = TRUE;
815 }
838 if (DEBUG(DIR)) {
839 printf("checking %s...", file);
840 }
816 DEBUGF(DIR, "checking %s...", file);
841
817
842
843 if (stat (file, &stb) == 0) {
818 if (stat (file, &stb) == 0) {
844 if (DEBUG(DIR)) {
845 printf("got it.\n");
846 }
819 DEBUGF(DIR, "got it.\n");
847
848 Lst_Close (path);
849
850 /*
851 * We've found another directory to search. We know there's
852 * a slash in 'file' because we put one there. We nuke it after
853 * finding it and call Dir_AddDir to add this new directory
854 * onto the existing search path. Once that's done, we restore

--- 6 unchanged lines hidden (view full) ---

861 *cp = '\0';
862 Dir_AddDir (path, file);
863 *cp = '/';
864
865 /*
866 * Save the modification time so if it's needed, we don't have
867 * to fetch it again.
868 */
820
821 Lst_Close (path);
822
823 /*
824 * We've found another directory to search. We know there's
825 * a slash in 'file' because we put one there. We nuke it after
826 * finding it and call Dir_AddDir to add this new directory
827 * onto the existing search path. Once that's done, we restore

--- 6 unchanged lines hidden (view full) ---

834 *cp = '\0';
835 Dir_AddDir (path, file);
836 *cp = '/';
837
838 /*
839 * Save the modification time so if it's needed, we don't have
840 * to fetch it again.
841 */
869 if (DEBUG(DIR)) {
870 printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
871 file);
872 }
842 DEBUGF(DIR, "Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), file);
873 entry = Hash_CreateEntry(&mtimes, (char *) file,
874 (Boolean *)NULL);
875 Hash_SetValue(entry, (long)stb.st_mtime);
876 nearmisses += 1;
877 return (file);
878 } else {
879 free (file);
880 }
881 }
882
843 entry = Hash_CreateEntry(&mtimes, (char *) file,
844 (Boolean *)NULL);
845 Hash_SetValue(entry, (long)stb.st_mtime);
846 nearmisses += 1;
847 return (file);
848 } else {
849 free (file);
850 }
851 }
852
883 if (DEBUG(DIR)) {
884 printf("failed. ");
885 }
853 DEBUGF(DIR, "failed. ");
886 Lst_Close (path);
887
888 if (checkedDot) {
889 /*
890 * Already checked by the given name, since . was in the path,
891 * so no point in proceeding...
892 */
854 Lst_Close (path);
855
856 if (checkedDot) {
857 /*
858 * Already checked by the given name, since . was in the path,
859 * so no point in proceeding...
860 */
893 if (DEBUG(DIR)) {
894 printf("Checked . already, returning NULL\n");
895 }
861 DEBUGF(DIR, "Checked . already, returning NULL\n");
896 return(NULL);
897 }
898 }
899
900 /*
901 * Didn't find it that way, either. Sigh. Phase 3. Add its directory
902 * onto the search path in any case, just in case, then look for the
903 * thing in the hash table. If we find it, grand. We return a new

--- 24 unchanged lines hidden (view full) ---

928 }
929
930 if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
931 return (estrdup (name));
932 } else {
933 return ((char *) NULL);
934 }
935#else /* !notdef */
862 return(NULL);
863 }
864 }
865
866 /*
867 * Didn't find it that way, either. Sigh. Phase 3. Add its directory
868 * onto the search path in any case, just in case, then look for the
869 * thing in the hash table. If we find it, grand. We return a new

--- 24 unchanged lines hidden (view full) ---

894 }
895
896 if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
897 return (estrdup (name));
898 } else {
899 return ((char *) NULL);
900 }
901#else /* !notdef */
936 if (DEBUG(DIR)) {
937 printf("Looking for \"%s\"...", name);
938 }
902 DEBUGF(DIR, "Looking for \"%s\"...", name);
939
940 bigmisses += 1;
941 entry = Hash_FindEntry(&mtimes, name);
942 if (entry != (Hash_Entry *)NULL) {
903
904 bigmisses += 1;
905 entry = Hash_FindEntry(&mtimes, name);
906 if (entry != (Hash_Entry *)NULL) {
943 if (DEBUG(DIR)) {
944 printf("got it (in mtime cache)\n");
945 }
946 return(estrdup(name));
907 DEBUGF(DIR, "got it (in mtime cache)\n");
908 return (estrdup(name));
947 } else if (stat (name, &stb) == 0) {
948 entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
909 } else if (stat (name, &stb) == 0) {
910 entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
949 if (DEBUG(DIR)) {
950 printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
951 name);
952 }
911 DEBUGF(DIR, "Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), name);
953 Hash_SetValue(entry, (long)stb.st_mtime);
954 return (estrdup (name));
955 } else {
912 Hash_SetValue(entry, (long)stb.st_mtime);
913 return (estrdup (name));
914 } else {
956 if (DEBUG(DIR)) {
957 printf("failed. Returning NULL\n");
958 }
915 DEBUGF(DIR, "failed. Returning NULL\n");
959 return ((char *)NULL);
960 }
961#endif /* notdef */
962}
963
964/*-
965 *-----------------------------------------------------------------------
966 * Dir_MTime --

--- 32 unchanged lines hidden (view full) ---

999
1000 entry = Hash_FindEntry(&mtimes, fullName);
1001 if (entry != (Hash_Entry *)NULL) {
1002 /*
1003 * Only do this once -- the second time folks are checking to
1004 * see if the file was actually updated, so we need to actually go
1005 * to the filesystem.
1006 */
916 return ((char *)NULL);
917 }
918#endif /* notdef */
919}
920
921/*-
922 *-----------------------------------------------------------------------
923 * Dir_MTime --

--- 32 unchanged lines hidden (view full) ---

956
957 entry = Hash_FindEntry(&mtimes, fullName);
958 if (entry != (Hash_Entry *)NULL) {
959 /*
960 * Only do this once -- the second time folks are checking to
961 * see if the file was actually updated, so we need to actually go
962 * to the filesystem.
963 */
1007 if (DEBUG(DIR)) {
1008 printf("Using cached time %s for %s\n",
1009 Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
1010 }
964 DEBUGF(DIR, "Using cached time %s for %s\n",
965 Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
1011 stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
1012 Hash_DeleteEntry(&mtimes, entry);
1013 } else if (stat (fullName, &stb) < 0) {
1014 if (gn->type & OP_MEMBER) {
1015 if (fullName != gn->path)
1016 free(fullName);
1017 return Arch_MemMTime (gn);
1018 } else {

--- 37 unchanged lines hidden (view full) ---

1056 ln = Lst_Find (openDirectories, (void *)name, DirFindName);
1057 if (ln != NULL) {
1058 p = (Path *)Lst_Datum (ln);
1059 if (Lst_Member(path, (void *)p) == NULL) {
1060 p->refCount += 1;
1061 (void)Lst_AtEnd (path, (void *)p);
1062 }
1063 } else {
966 stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
967 Hash_DeleteEntry(&mtimes, entry);
968 } else if (stat (fullName, &stb) < 0) {
969 if (gn->type & OP_MEMBER) {
970 if (fullName != gn->path)
971 free(fullName);
972 return Arch_MemMTime (gn);
973 } else {

--- 37 unchanged lines hidden (view full) ---

1011 ln = Lst_Find (openDirectories, (void *)name, DirFindName);
1012 if (ln != NULL) {
1013 p = (Path *)Lst_Datum (ln);
1014 if (Lst_Member(path, (void *)p) == NULL) {
1015 p->refCount += 1;
1016 (void)Lst_AtEnd (path, (void *)p);
1017 }
1018 } else {
1064 if (DEBUG(DIR)) {
1065 printf("Caching %s...", name);
1066 fflush(stdout);
1067 }
1019 DEBUGF(DIR, "Caching %s...", name);
1068
1069 if ((d = opendir (name)) != (DIR *) NULL) {
1070 p = (Path *) emalloc (sizeof (Path));
1071 p->name = estrdup (name);
1072 p->hits = 0;
1073 p->refCount = 1;
1074 Hash_InitTable (&p->files, -1);
1075

--- 20 unchanged lines hidden (view full) ---

1096 continue;
1097
1098 (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
1099 }
1100 (void) closedir (d);
1101 (void)Lst_AtEnd (openDirectories, (void *)p);
1102 (void)Lst_AtEnd (path, (void *)p);
1103 }
1020
1021 if ((d = opendir (name)) != (DIR *) NULL) {
1022 p = (Path *) emalloc (sizeof (Path));
1023 p->name = estrdup (name);
1024 p->hits = 0;
1025 p->refCount = 1;
1026 Hash_InitTable (&p->files, -1);
1027

--- 20 unchanged lines hidden (view full) ---

1048 continue;
1049
1050 (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
1051 }
1052 (void) closedir (d);
1053 (void)Lst_AtEnd (openDirectories, (void *)p);
1054 (void)Lst_AtEnd (path, (void *)p);
1055 }
1104 if (DEBUG(DIR)) {
1105 printf("done\n");
1106 }
1056 DEBUGF(DIR, "done\n");
1107 }
1108}
1109
1110/*-
1111 *-----------------------------------------------------------------------
1112 * Dir_CopyDir --
1113 * Callback function for duplicating a search path via Lst_Duplicate.
1114 * Ups the reference count for the directory.

--- 186 unchanged lines hidden --- 		1057 }
1058}
1059
1060/*-
1061 *-----------------------------------------------------------------------
1062 * Dir_CopyDir --
1063 * Callback function for duplicating a search path via Lst_Duplicate.
1064 * Ups the reference count for the directory.

--- 186 unchanged lines hidden ---