home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / GNUSRC.Z / vpath.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-01  |  13.8 KB  |  496 lines
  1. /* Implementation of pattern-matching file search paths for GNU Make.
  2. Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
  3. This file is part of GNU Make.
  4.  
  5. GNU Make is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. GNU Make is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with GNU Make; see the file COPYING.  If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include "make.h"
  20. #include "file.h"
  21. #include "variable.h"
  22.  
  23.  
  24. /* Structure used to represent a selective VPATH searchpath.  */
  25.  
  26. struct vpath
  27.   {
  28.     struct vpath *next;    /* Pointer to next struct in the linked list.  */
  29.     char *pattern;    /* The pattern to match.  */
  30.     char *percent;    /* Pointer into `pattern' where the `%' is.  */
  31.     unsigned int patlen;/* Length of the pattern.  */
  32.     char **searchpath;    /* Null-terminated list of directories.  */
  33.     unsigned int maxlen;/* Maximum length of any entry in the list.  */
  34.   };
  35.  
  36. /* Linked-list of all selective VPATHs.  */
  37.  
  38. static struct vpath *vpaths;
  39.  
  40. /* Structure for the general VPATH given in the variable.  */
  41.  
  42. static struct vpath *general_vpath;
  43.  
  44. static int selective_vpath_search ();
  45.  
  46. /* Reverse the chain of selective VPATH lists so they
  47.    will be searched in the order given in the makefiles
  48.    and construct the list from the VPATH variable.  */
  49.  
  50. void
  51. build_vpath_lists ()
  52. {
  53.   register struct vpath *new = 0;
  54.   register struct vpath *old, *nexto;
  55.   register char *p;
  56.  
  57.   /* Reverse the chain.  */
  58.   for (old = vpaths; old != 0; old = nexto)
  59.     {
  60.       nexto = old->next;
  61.       old->next = new;
  62.       new = old;
  63.     }
  64.  
  65.   vpaths = new;
  66.  
  67.   /* If there is a VPATH variable with a nonnull value, construct the
  68.      general VPATH list from it.  We use variable_expand rather than just
  69.      calling lookup_variable so that it will be recursively expanded.  */
  70.  
  71.   {
  72.     /* Turn off --warn-undefined-variables while we expand SHELL and IFS.  */
  73.     int save = warn_undefined_variables_flag;
  74.     warn_undefined_variables_flag = 0;
  75.  
  76.     p = variable_expand ("$(strip $(VPATH))");
  77.  
  78.     warn_undefined_variables_flag = save;
  79.   }
  80.  
  81.   if (*p != '\0')
  82.     {
  83.       /* Save the list of vpaths.  */
  84.       struct vpath *save_vpaths = vpaths;
  85.  
  86.       /* Empty `vpaths' so the new one will have no next, and `vpaths'
  87.      will still be nil if P contains no existing directories.  */
  88.       vpaths = 0;
  89.  
  90.       /* Parse P.  */
  91.       construct_vpath_list ("%", p);
  92.  
  93.       /* Store the created path as the general path,
  94.      and restore the old list of vpaths.  */
  95.       general_vpath = vpaths;
  96.       vpaths = save_vpaths;
  97.     }
  98. }
  99.  
  100. /* Construct the VPATH listing for the pattern and searchpath given.
  101.  
  102.    This function is called to generate selective VPATH lists and also for
  103.    the general VPATH list (which is in fact just a selective VPATH that
  104.    is applied to everything).  The returned pointer is either put in the
  105.    linked list of all selective VPATH lists or in the GENERAL_VPATH
  106.    variable.
  107.  
  108.    If SEARCHPATH is nil, remove all previous listings with the same
  109.    pattern.  If PATTERN is nil, remove all VPATH listings.
  110.    Existing and readable directories that are not "." given in the
  111.    searchpath separated by colons are loaded into the directory hash
  112.    table if they are not there already and put in the VPATH searchpath
  113.    for the given pattern with trailing slashes stripped off if present
  114.    (and if the directory is not the root, "/").
  115.    The length of the longest entry in the list is put in the structure as well.
  116.    The new entry will be at the head of the VPATHS chain.  */
  117.  
  118. void
  119. construct_vpath_list (pattern, dirpath)
  120.      char *pattern, *dirpath;
  121. {
  122.   register unsigned int elem;
  123.   register char *p;
  124.   register char **vpath;
  125.   register unsigned int maxvpath;
  126.   unsigned int maxelem;
  127.   char *percent;
  128.  
  129.   if (pattern != 0)
  130.     {
  131.       pattern = savestring (pattern, strlen (pattern));
  132.       percent = find_percent (pattern);
  133.     }
  134.  
  135.   if (dirpath == 0)
  136.     {
  137.       /* Remove matching listings.  */
  138.       register struct vpath *path, *lastpath;
  139.  
  140.       lastpath = 0;
  141.       path = vpaths;
  142.       while (path != 0)
  143.     {
  144.       struct vpath *next = path->next;
  145.  
  146.       if (pattern == 0
  147.           || (((percent == 0 && path->percent == 0)
  148.            || (percent - pattern == path->percent - path->pattern))
  149.           && streq (pattern, path->pattern)))
  150.         {
  151.           /* Remove it from the linked list.  */
  152.           if (lastpath == 0)
  153.         vpaths = path->next;
  154.           else
  155.         lastpath->next = next;
  156.  
  157.           /* Free its unused storage.  */
  158.           free (path->pattern);
  159.           free ((char *) path->searchpath);
  160.           free ((char *) path);
  161.         }
  162.       else
  163.         lastpath = path;
  164.  
  165.       path = next;
  166.     }
  167.  
  168.       if (pattern != 0)
  169.     free (pattern);
  170.       return;
  171.     }
  172.  
  173.   /* Figure out the maximum number of VPATH entries and
  174.      put it in MAXELEM.  We start with 2, one before the
  175.      first colon and one nil, the list terminator and
  176.      increment our estimated number for each colon or blank we find.  */
  177.   maxelem = 2;
  178.   p = dirpath;
  179.   while (*p != '\0')
  180.     if (*p++ == PATH_SEPARATOR_CHAR || isblank (*p))
  181.       ++maxelem;
  182.  
  183.   vpath = (char **) xmalloc (maxelem * sizeof (char *));
  184.   maxvpath = 0;
  185.  
  186.   /* Skip over any initial colons and blanks.  */
  187.   p = dirpath;
  188.   while (*p == PATH_SEPARATOR_CHAR || isblank (*p))
  189.     ++p;
  190.  
  191.   elem = 0;
  192.   while (*p != '\0')
  193.     {
  194.       char *v;
  195.       unsigned int len;
  196.  
  197.       /* Find the end of this entry.  */
  198.       v = p;
  199. #if defined (__MSDOS__) || defined (WIN32)
  200.       /* treat x:\ as a drive, not a single-character path */
  201.       while (*p != '\0'
  202.         && (*p != PATH_SEPARATOR_CHAR 
  203.           || ((*(p+1) == '/' || *(p+1) == '\\') && p-v == 1))
  204.         && !isblank (*p))
  205. #else
  206.       while (*p != '\0' && *p != PATH_SEPARATOR_CHAR && !isblank (*p))
  207. #endif
  208.     ++p;
  209.  
  210.       len = p - v;
  211.       /* Make sure there's no trailing slash,
  212.      but still allow "/" as a directory.  */
  213.       if (len > 1 && p[-1] == '/')
  214.     --len;
  215.  
  216.       if (len > 1 || *v != '.')
  217.     {
  218.       v = savestring (v, len);
  219.  
  220.       /* Verify that the directory actually exists.  */
  221.  
  222.       if (dir_file_exists_p (v, ""))
  223.         {
  224.           /* It does.  Put it in the list.  */
  225.           vpath[elem++] = dir_name (v);
  226.           free (v);
  227.           if (len > maxvpath)
  228.         maxvpath = len;
  229.         }
  230.       else
  231.         /* The directory does not exist.  Omit from the list.  */
  232.         free (v);
  233.     }
  234.  
  235.       /* Skip over colons and blanks between entries.  */
  236.       while (*p == PATH_SEPARATOR_CHAR || isblank (*p))
  237.     ++p;
  238.     }
  239.  
  240.   if (elem > 0)
  241.     {
  242.       struct vpath *path;
  243.       /* ELEM is now incremented one element past the last
  244.      entry, to where the nil-pointer terminator goes.
  245.      Usually this is maxelem - 1.  If not, shrink down.  */
  246.       if (elem < (maxelem - 1))
  247.     vpath = (char **) xrealloc ((char *) vpath,
  248.                     (elem + 1) * sizeof (char *));
  249.  
  250.       /* Put the nil-pointer terminator on the end of the VPATH list.  */
  251.       vpath[elem] = 0;
  252.  
  253.       /* Construct the vpath structure and put it into the linked list.  */
  254.       path = (struct vpath *) xmalloc (sizeof (struct vpath));
  255.       path->searchpath = vpath;
  256.       path->maxlen = maxvpath;
  257.       path->next = vpaths;
  258.       vpaths = path;
  259.  
  260.       /* Set up the members.  */
  261.       path->pattern = pattern;
  262.       path->percent = percent;
  263.       path->patlen = strlen (pattern);
  264.     }
  265.   else
  266.     {
  267.       /* There were no entries, so free whatever space we allocated.  */
  268.       free ((char *) vpath);
  269.       if (pattern != 0)
  270.     free (pattern);
  271.     }
  272. }
  273.  
  274. /* Search the VPATH list whose pattern matches *FILE for a directory
  275.    where the name pointed to by FILE exists.  If it is found, we set *FILE to
  276.    the newly malloc'd name of the existing file, *MTIME_PTR (if MTIME_PTR is
  277.    not NULL) to its modtime (or zero if no stat call was done), and return 1.
  278.    Otherwise we return 0.  */
  279.  
  280. int
  281. vpath_search (file, mtime_ptr)
  282.      char **file;
  283.      time_t *mtime_ptr;
  284. {
  285.   register struct vpath *v;
  286.  
  287.   /* If there are no VPATH entries or FILENAME starts at the root,
  288.      there is nothing we can do.  */
  289.  
  290.   if (**file == '/' || (vpaths == 0 && general_vpath == 0))
  291.     return 0;
  292.  
  293.   for (v = vpaths; v != 0; v = v->next)
  294.     if (pattern_matches (v->pattern, v->percent, *file))
  295.       if (selective_vpath_search (v, file, mtime_ptr))
  296.     return 1;
  297.  
  298.   if (general_vpath != 0
  299.       && selective_vpath_search (general_vpath, file, mtime_ptr))
  300.     return 1;
  301.  
  302.   return 0;
  303. }
  304.  
  305.  
  306. /* Search the given VPATH list for a directory where the name pointed
  307.    to by FILE exists.  If it is found, we set *FILE to the newly malloc'd
  308.    name of the existing file, *MTIME_PTR (if MTIME_PTR is not NULL) to
  309.    its modtime (or zero if no stat call was done), and we return 1.
  310.    Otherwise we return 0.  */
  311.  
  312. static int
  313. selective_vpath_search (path, file, mtime_ptr)
  314.      struct vpath *path;
  315.      char **file;
  316.      time_t *mtime_ptr;
  317. {
  318.   int not_target;
  319.   char *name, *n;
  320.   char *filename;
  321.   register char **vpath = path->searchpath;
  322.   unsigned int maxvpath = path->maxlen;
  323.   register unsigned int i;
  324.   unsigned int flen, vlen, name_dplen;
  325.   int exists = 0;
  326.  
  327.   /* Find out if *FILE is a target.
  328.      If and only if it is NOT a target, we will accept prospective
  329.      files that don't exist but are mentioned in a makefile.  */
  330.   {
  331.     struct file *f = lookup_file (*file);
  332.     not_target = f == 0 || !f->is_target;
  333.   }
  334.  
  335.   flen = strlen (*file);
  336.  
  337.   /* Split *FILE into a directory prefix and a name-within-directory.
  338.      NAME_DPLEN gets the length of the prefix; FILENAME gets the
  339.      pointer to the name-within-directory and FLEN is its length.  */
  340.  
  341.   n = rindex (*file, '/');
  342.   name_dplen = n != 0 ? n - *file : 0;
  343.   filename = name_dplen > 0 ? n + 1 : *file;
  344.   if (name_dplen > 0)
  345.     flen -= name_dplen + 1;
  346.  
  347.   /* Allocate enough space for the biggest VPATH entry,
  348.      a slash, the directory prefix that came with *FILE,
  349.      another slash (although this one may not always be
  350.      necessary), the filename, and a null terminator.  */
  351.   name = (char *) alloca (maxvpath + 1 + name_dplen + 1 + flen + 1);
  352.  
  353.   /* Try each VPATH entry.  */
  354.   for (i = 0; vpath[i] != 0; ++i)
  355.     {
  356.       int exists_in_cache = 0;
  357.  
  358.       n = name;
  359.  
  360.       /* Put the next VPATH entry into NAME at N and increment N past it.  */
  361.       vlen = strlen (vpath[i]);
  362.       bcopy (vpath[i], n, vlen);
  363.       n += vlen;
  364.  
  365.       /* Add the directory prefix already in *FILE.  */
  366.       if (name_dplen > 0)
  367.     {
  368.       *n++ = '/';
  369.       bcopy (*file, n, name_dplen);
  370.       n += name_dplen;
  371.     }
  372.  
  373.       /* Now add the name-within-directory at the end of NAME.  */
  374.       if (n != name && n[-1] != '/')
  375.     {
  376.       *n = '/';
  377.       bcopy (filename, n + 1, flen + 1);
  378.     }
  379.       else
  380.     bcopy (filename, n, flen + 1);
  381.  
  382.       /* Check if the file is mentioned in a makefile.  If *FILE is not
  383.      a target, that is enough for us to decide this file exists.
  384.      If *FILE is a target, then the file must be mentioned in the
  385.      makefile also as a target to be chosen.
  386.  
  387.      The restriction that *FILE must not be a target for a
  388.      makefile-mentioned file to be chosen was added by an
  389.      inadequately commented change in July 1990; I am not sure off
  390.      hand what problem it fixes.
  391.  
  392.      In December 1993 I loosened of this restriction to allow a file
  393.      to be chosen if it is mentioned as a target in a makefile.  This
  394.      seem logical.  */
  395.       {
  396.     struct file *f = lookup_file (name);
  397.     if (f != 0)
  398.       exists = not_target || f->is_target;
  399.       }
  400.  
  401.       if (!exists)
  402.     {
  403.       /* That file wasn't mentioned in the makefile.
  404.          See if it actually exists.  */
  405.  
  406.       /* Clobber a null into the name at the last slash.
  407.          Now NAME is the name of the directory to look in.  */
  408.       *n = '\0';
  409.  
  410.       /* We know the directory is in the hash table now because either
  411.          construct_vpath_list or the code just above put it there.
  412.          Does the file we seek exist in it?  */
  413.       exists_in_cache = exists = dir_file_exists_p (name, filename);
  414.     }
  415.  
  416.       if (exists)
  417.     {
  418.       /* The file is in the directory cache.
  419.          Now check that it actually exists in the filesystem.
  420.          The cache may be out of date.  When vpath thinks a file
  421.          exists, but stat fails for it, confusion results in the
  422.          higher levels.  */
  423.  
  424.       struct stat st;
  425.  
  426.       /* Put the slash back in NAME.  */
  427.       *n = '/';
  428.  
  429.       if (!exists_in_cache    /* Makefile-mentioned file need not exist.  */
  430.           || safe_stat (name, &st) == 0) /* Does it really exist?  */
  431.         {
  432.           /* We have found a file.
  433.          Store the name we found into *FILE for the caller.  */
  434.  
  435.           *file = savestring (name, (n + 1 - name) + flen);
  436.  
  437.           if (mtime_ptr != 0)
  438.         /* Store the modtime into *MTIME_PTR for the caller.
  439.            If we have had no need to stat the file here,
  440.            we record a zero modtime to indicate this.  */
  441.         *mtime_ptr = exists_in_cache ? st.st_mtime : (time_t) 0;
  442.  
  443.           return 1;
  444.         }
  445.       else
  446.         exists = 0;
  447.     }
  448.     }
  449.  
  450.   return 0;
  451. }
  452.  
  453. /* Print the data base of VPATH search paths.  */
  454.  
  455. void
  456. print_vpath_data_base ()
  457. {
  458.   register unsigned int nvpaths;
  459.   register struct vpath *v;
  460.  
  461.   puts ("\n# VPATH Search Paths\n");
  462.  
  463.   nvpaths = 0;
  464.   for (v = vpaths; v != 0; v = v->next)
  465.     {
  466.       register unsigned int i;
  467.  
  468.       ++nvpaths;
  469.  
  470.       printf ("vpath %s ", v->pattern);
  471.  
  472.       for (i = 0; v->searchpath[i] != 0; ++i)
  473.     printf ("%s%c", v->searchpath[i],
  474.         v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
  475.     }
  476.  
  477.   if (vpaths == 0)
  478.     puts ("# No `vpath' search paths.");
  479.   else
  480.     printf ("\n# %u `vpath' search paths.\n", nvpaths);
  481.  
  482.   if (general_vpath == 0)
  483.     puts ("\n# No general (`VPATH' variable) search path.");
  484.   else
  485.     {
  486.       register char **path = general_vpath->searchpath;
  487.       register unsigned int i;
  488.  
  489.       fputs ("\n# General (`VPATH' variable) search path:\n# ", stdout);
  490.  
  491.       for (i = 0; path[i] != 0; ++i)
  492.     printf ("%s%c", path[i],
  493.         path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
  494.     }
  495. }
  496.