ar.c

   1 /* Interface to `ar' archives for GNU Make.
   2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
   4 Foundation, Inc.
   5 This file is part of GNU Make.
   6
   7 GNU Make is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 3 of the License, or (at your option) any later
  10 version.
  11
  12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  14 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License along with
  17 this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "make.h"
  20
  21 #ifndef NO_ARCHIVES
  22
  23 #include "filedef.h"
  24 #include "dep.h"
  25 #include <fnmatch.h>
  26
  27 /* Return nonzero if NAME is an archive-member reference, zero if not.
  28    An archive-member reference is a name like `lib(member)'.
  29    If a name like `lib((entry))' is used, a fatal error is signaled at
  30    the attempt to use this unsupported feature.  */
  31
  32 int
  33 ar_name (const char *name)
  34 {
  35   const char *p = strchr (name, '(');
  36   const char *end;
  37
  38   if (p == 0 || p == name)
  39     return 0;
  40
  41   end = p + strlen (p) - 1;
  42   if (*end != ')')
  43     return 0;
  44
  45   if (p[1] == '(' && end[-1] == ')')
  46     fatal (NILF, _("attempt to use unsupported feature: `%s'"), name);
  47
  48   return 1;
  49 }
  50
  51
  52 /* Parse the archive-member reference NAME into the archive and member names.
  53    Creates one allocated string containing both names, pointed to by ARNAME_P.
  54    MEMNAME_P points to the member.  */
  55
  56 void
  57 ar_parse_name (const char *name, char **arname_p, char **memname_p)
  58 {
  59   char *p;
  60
  61   *arname_p = xstrdup (name);
  62   p = strchr (*arname_p, '(');
  63   *(p++) = '\0';
  64   p[strlen(p) - 1] = '\0';
  65   *memname_p = p;
  66 }
  67 \f
  68
  69 /* This function is called by `ar_scan' to find which member to look at.  */
  70
  71 /* ARGSUSED */
  72 static long int
  73 ar_member_date_1 (int desc UNUSED, const char *mem, int truncated,
  74                   long int hdrpos UNUSED, long int datapos UNUSED,
  75                   long int size UNUSED, long int date,
  76                   int uid UNUSED, int gid UNUSED, int mode UNUSED,
  77                   const void *name)
  78 {
  79   return ar_name_equal (name, mem, truncated) ? date : 0;
  80 }
  81
  82 /* Return the modtime of NAME.  */
  83
  84 time_t
  85 ar_member_date (const char *name)
  86 {
  87   char *arname;
  88   char *memname;
  89   long int val;
  90
  91   ar_parse_name (name, &arname, &memname);
  92
  93   /* Make sure we know the modtime of the archive itself because we are
  94      likely to be called just before commands to remake a member are run,
  95      and they will change the archive itself.
  96
  97      But we must be careful not to enter_file the archive itself if it does
  98      not exist, because pattern_search assumes that files found in the data
  99      base exist or can be made.  */
 100   {
 101     struct file *arfile;
 102     arfile = lookup_file (arname);
 103     if (arfile == 0 && file_exists_p (arname))
 104       arfile = enter_file (strcache_add (arname));
 105
 106     if (arfile != 0)
 107       (void) f_mtime (arfile, 0);
 108   }
 109
 110   val = ar_scan (arname, ar_member_date_1, memname);
 111
 112   free (arname);
 113
 114   return (val <= 0 ? (time_t) -1 : (time_t) val);
 115 }
 116 \f
 117 /* Set the archive-member NAME's modtime to now.  */
 118
 119 #ifdef VMS
 120 int
 121 ar_touch (const char *name)
 122 {
 123   error (NILF, _("touch archive member is not available on VMS"));
 124   return -1;
 125 }
 126 #else
 127 int
 128 ar_touch (const char *name)
 129 {
 130   char *arname, *memname;
 131   int val;
 132
 133   ar_parse_name (name, &arname, &memname);
 134
 135   /* Make sure we know the modtime of the archive itself before we
 136      touch the member, since this will change the archive modtime.  */
 137   {
 138     struct file *arfile;
 139     arfile = enter_file (strcache_add (arname));
 140     f_mtime (arfile, 0);
 141   }
 142
 143   val = 1;
 144   switch (ar_member_touch (arname, memname))
 145     {
 146     case -1:
 147       error (NILF, _("touch: Archive `%s' does not exist"), arname);
 148       break;
 149     case -2:
 150       error (NILF, _("touch: `%s' is not a valid archive"), arname);
 151       break;
 152     case -3:
 153       perror_with_name ("touch: ", arname);
 154       break;
 155     case 1:
 156       error (NILF,
 157              _("touch: Member `%s' does not exist in `%s'"), memname, arname);
 158       break;
 159     case 0:
 160       val = 0;
 161       break;
 162     default:
 163       error (NILF,
 164              _("touch: Bad return code from ar_member_touch on `%s'"), name);
 165     }
 166
 167   free (arname);
 168
 169   return val;
 170 }
 171 #endif /* !VMS */
 172 \f
 173 /* State of an `ar_glob' run, passed to `ar_glob_match'.  */
 174
 175 struct ar_glob_state
 176   {
 177     const char *arname;
 178     const char *pattern;
 179     unsigned int size;
 180     struct nameseq *chain;
 181     unsigned int n;
 182   };
 183
 184 /* This function is called by `ar_scan' to match one archive
 185    element against the pattern in STATE.  */
 186
 187 static long int
 188 ar_glob_match (int desc UNUSED, const char *mem, int truncated UNUSED,
 189                long int hdrpos UNUSED, long int datapos UNUSED,
 190                long int size UNUSED, long int date UNUSED, int uid UNUSED,
 191                int gid UNUSED, int mode UNUSED, const void *arg)
 192 {
 193   struct ar_glob_state *state = (struct ar_glob_state *)arg;
 194
 195   if (fnmatch (state->pattern, mem, FNM_PATHNAME|FNM_PERIOD) == 0)
 196     {
 197       /* We have a match.  Add it to the chain.  */
 198       struct nameseq *new = xmalloc (state->size);
 199       memset (new, '\0', state->size);
 200       new->name = strcache_add (concat (state->arname, mem, ")"));
 201       new->next = state->chain;
 202       state->chain = new;
 203       ++state->n;
 204     }
 205
 206   return 0L;
 207 }
 208
 209 /* Return nonzero if PATTERN contains any metacharacters.
 210    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
 211 static int
 212 glob_pattern_p (const char *pattern, int quote)
 213 {
 214   const char *p;
 215   int open = 0;
 216
 217   for (p = pattern; *p != '\0'; ++p)
 218     switch (*p)
 219       {
 220       case '?':
 221       case '*':
 222         return 1;
 223
 224       case '\\':
 225         if (quote)
 226           ++p;
 227         break;
 228
 229       case '[':
 230         open = 1;
 231         break;
 232
 233       case ']':
 234         if (open)
 235           return 1;
 236         break;
 237       }
 238
 239   return 0;
 240 }
 241
 242 /* Glob for MEMBER_PATTERN in archive ARNAME.
 243    Return a malloc'd chain of matching elements (or nil if none).  */
 244
 245 struct nameseq *
 246 ar_glob (const char *arname, const char *member_pattern, unsigned int size)
 247 {
 248   struct ar_glob_state state;
 249   struct nameseq *n;
 250   const char **names;
 251   char *name;
 252   unsigned int i;
 253
 254   if (! glob_pattern_p (member_pattern, 1))
 255     return 0;
 256
 257   /* Scan the archive for matches.
 258      ar_glob_match will accumulate them in STATE.chain.  */
 259   i = strlen (arname);
 260   name = alloca (i + 2);
 261   memcpy (name, arname, i);
 262   name[i] = '(';
 263   name[i + 1] = '\0';
 264   state.arname = name;
 265   state.pattern = member_pattern;
 266   state.size = size;
 267   state.chain = 0;
 268   state.n = 0;
 269   ar_scan (arname, ar_glob_match, &state);
 270
 271   if (state.chain == 0)
 272     return 0;
 273
 274   /* Now put the names into a vector for sorting.  */
 275   names = alloca (state.n * sizeof (const char *));
 276   i = 0;
 277   for (n = state.chain; n != 0; n = n->next)
 278     names[i++] = n->name;
 279
 280   /* Sort them alphabetically.  */
 281   qsort (names, i, sizeof (*names), alpha_compare);
 282
 283   /* Put them back into the chain in the sorted order.  */
 284   i = 0;
 285   for (n = state.chain; n != 0; n = n->next)
 286     n->name = names[i++];
 287
 288   return state.chain;
 289 }
 290
 291 #endif  /* Not NO_ARCHIVES.  */