make/ar.c
Roland McGrath 9e443adaf6 Tue Mar 19 20:21:34 1996 Roland McGrath <roland@charlie-brown.gnu.ai.mit.edu>
Merged VMS port from Klaus Kaempf <kkaempf@didymus.rmi.de>.
	* make.h (PARAMS): New macro.
	* config.h-vms: New file.
	* makefile.com: New file.
	* makefile.vms: New file.
	* readme.vms: New file.
	* vmsdir.h: New file.
	* vmsfunctions.c: New file.
	* vmsify.c: New file.
	* file.h: Renamed to filedef.h to avoid conflict with VMS system hdr.
	* ar.c: Added prototypes and changes for VMS.
	* commands.c: Likewise.
	* commands.h: Likewise.
	* default.c: Likewise.
	* dep.h: Likewise.
	* dir.c: Likewise.
	* expand.c: Likewise.
	* file.c: Likewise.
	* function.c: Likewise.
	* implicit.c: Likewise.
	* job.c: Likewise.
	* job.h: Likewise.
	* main.c: Likewise.
	* make.h: Likewise.
	* misc.c: Likewise.
	* read.c: Likewise.
	* remake.c: Likewise.
	* remote-stub.c: Likewise.
	* rule.c: Likewise.
	* rule.h: Likewise.
	* variable.c: Likewise.
	* variable.h: Likewise.
	* vpath.c: Likewise.
	* compatMakefile (srcs): Rename file.h to filedef.h.
1996-03-20 14:57:41 +00:00

434 lines
10 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Interface to `ar' archives for GNU Make.
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#ifndef NO_ARCHIVES
#include "filedef.h"
#include "dep.h"
#include <fnmatch.h>
/* Defined in arscan.c. */
extern long int ar_scan PARAMS ((char *archive, long int (*function) (), long int arg));
extern int ar_member_touch PARAMS ((char *arname, char *memname));
extern int ar_name_equal PARAMS ((char *name, char *mem, int truncated));
/* Return nonzero if NAME is an archive-member reference, zero if not.
An archive-member reference is a name like `lib(member)'.
If a name like `lib((entry))' is used, a fatal error is signaled at
the attempt to use this unsupported feature. */
int
ar_name (name)
char *name;
{
char *p = index (name, '('), *end = name + strlen (name) - 1;
if (p == 0 || p == name || *end != ')')
return 0;
if (p[1] == '(' && end[-1] == ')')
fatal ("attempt to use unsupported feature: `%s'", name);
return 1;
}
/* Parse the archive-member reference NAME into the archive and member names.
Put the malloc'd archive name in *ARNAME_P if ARNAME_P is non-nil;
put the malloc'd member name in *MEMNAME_P if MEMNAME_P is non-nil. */
void
ar_parse_name (name, arname_p, memname_p)
char *name, **arname_p, **memname_p;
{
char *p = index (name, '('), *end = name + strlen (name) - 1;
if (arname_p != 0)
*arname_p = savestring (name, p - name);
if (memname_p != 0)
*memname_p = savestring (p + 1, end - (p + 1));
}
#ifdef VMS
#include <lbrdef.h>
#include <mhddef.h>
#include <credef.h>
#include <descrip.h>
#include <ctype.h>
#if __DECC
#include <lbr$routines.h>
#endif
#define uppercasify(str) {char *str1; for (str1 = str; *str1; str1++) *str1 = _toupper(*str1);}
#define LBR$_KEYNOTFND 2527330 /* This isn't in any .h file anywhere so I got it from a MACRO library */
time_t
ar_member_date (name)
char *name;
{
static char *arname;
static char *memname;
char *p,*q;
long int val;
static struct {
struct mhddef mhd;
struct credef cre;
char garbage[256];
} buf;
int func=LBR$C_READ,
type=LBR$C_TYP_OBJ,
rfa[2],
lidx,
status;
$DESCRIPTOR(bufdesc,(char *)&buf);
$DESCRIPTOR(libdesc,arname);
$DESCRIPTOR(moddesc,memname);
/* This "file" is an archive member. */
p = index (name, '(');
arname = savestring (name, p - name);
val = strlen (p) - 2;
/*
if (val > 15)
val = 15;
*/
memname = savestring (p + 1, val);
#ifdef OLDWAY
p = rindex (memname, ')');
if (p != 0) {
q = rindex(p,'.');
if (q)
*q = '\0'; /* to get rid of extension */
}
#endif
q = rindex(memname,'.');
if (q)
*q = '\0'; /* to get rid of extension */
uppercasify(memname);
/* Make sure we know the modtime of the archive itself because
we are likely to be called just before commands to remake a
member are run, and they will change the archive itself. */
(void) f_mtime (enter_file (arname));
libdesc.dsc$a_pointer = arname;
libdesc.dsc$w_length = strlen(arname);
moddesc.dsc$a_pointer = memname;
moddesc.dsc$w_length = strlen(memname);
if (!((status = lbr$ini_control(&lidx,&func,&type,0)) & 1)) {
printf("Error in lbr$ini_control, %d\n",status);
return(-1);
}
if (!((status = lbr$open(&lidx,&libdesc,0,0,0,0,0)) & 1)) {
printf("Error opening library %s to lookup member %s, %d\n",arname, memname ,status);
return(-1);
}
if (!((status = lbr$lookup_key(&lidx,&moddesc,rfa)) & 1)) {
if (status != LBR$_KEYNOTFND)
printf("Error looking up module %s in library %s, %d\n",memname, arname ,status);
lbr$close(&lidx);
return(-1);
}
if (!((status = lbr$set_module(&lidx,rfa,&bufdesc,&bufdesc,0)) & 1)) {
printf("Error getting module info, %d\n",status);
lbr$close(&lidx);
return(-1);
}
lbr$close(&lidx);
val = SHELL$FIX_TIME(&buf.mhd.mhd$l_datim);
free (arname);
free (memname);
return (val <= 0 ? (time_t) -1 : (time_t) val);
}
#else
static long int ar_member_date_1 PARAMS ((int desc, char *mem, int truncated, long int hdrpos,
long int datapos, long int size, long int date, int uid, int gid, int mode, char *name));
/* Return the modtime of NAME. */
time_t
ar_member_date (name)
char *name;
{
char *arname;
int arname_used = 0;
char *memname;
long int val;
ar_parse_name (name, &arname, &memname);
/* Make sure we know the modtime of the archive itself because we are
likely to be called just before commands to remake a member are run,
and they will change the archive itself.
But we must be careful not to enter_file the archive itself if it does
not exist, because pattern_search assumes that files found in the data
base exist or can be made. */
{
struct file *arfile;
arfile = lookup_file (arname);
if (arfile == 0 && file_exists_p (arname))
{
arfile = enter_file (arname);
arname_used = 1;
}
if (arfile != 0)
(void) f_mtime (arfile, 0);
}
val = ar_scan (arname, ar_member_date_1, (long int) memname);
if (!arname_used)
free (arname);
free (memname);
return (val <= 0 ? (time_t) -1 : (time_t) val);
}
/* This function is called by `ar_scan' to find which member to look at. */
/* ARGSUSED */
static long int
ar_member_date_1 (desc, mem, truncated,
hdrpos, datapos, size, date, uid, gid, mode, name)
int desc;
char *mem;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
char *name;
{
return ar_name_equal (name, mem, truncated) ? date : 0;
}
#endif /* !VMS */
/* Set the archive-member NAME's modtime to now. */
#ifdef VMS
int
ar_touch (name)
char *name;
{
error ("touch archive member is not available on VMS");
return -1;
}
#else
int
ar_touch (name)
char *name;
{
char *arname, *memname;
int arname_used = 0;
register int val;
ar_parse_name (name, &arname, &memname);
/* Make sure we know the modtime of the archive itself before we
touch the member, since this will change the archive itself. */
{
struct file *arfile;
arfile = lookup_file (arname);
if (arfile == 0)
{
arfile = enter_file (arname);
arname_used = 1;
}
(void) f_mtime (arfile, 0);
}
val = 1;
switch (ar_member_touch (arname, memname))
{
case -1:
error ("touch: Archive `%s' does not exist", arname);
break;
case -2:
error ("touch: `%s' is not a valid archive", arname);
break;
case -3:
perror_with_name ("touch: ", arname);
break;
case 1:
error ("touch: Member `%s' does not exist in `%s'", memname, arname);
break;
case 0:
val = 0;
break;
default:
error ("touch: Bad return code from ar_member_touch on `%s'", name);
}
if (!arname_used)
free (arname);
free (memname);
return val;
}
#endif /* !VMS */
/* State of an `ar_glob' run, passed to `ar_glob_match'. */
struct ar_glob_state
{
char *arname;
char *pattern;
unsigned int size;
struct nameseq *chain;
unsigned int n;
};
/* This function is called by `ar_scan' to match one archive
element against the pattern in STATE. */
static long int
ar_glob_match (desc, mem, truncated,
hdrpos, datapos, size, date, uid, gid, mode,
state)
int desc;
char *mem;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
struct ar_glob_state *state;
{
if (fnmatch (state->pattern, mem, FNM_PATHNAME|FNM_PERIOD) == 0)
{
/* We have a match. Add it to the chain. */
struct nameseq *new = (struct nameseq *) xmalloc (state->size);
new->name = concat (state->arname, mem, ")");
new->next = state->chain;
state->chain = new;
++state->n;
}
return 0L;
}
/* Alphabetic sorting function for `qsort'. */
static int
ar_glob_alphacompare (a, b)
char **a, **b;
{
return strcmp (*a, *b);
}
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
static int
glob_pattern_p (pattern, quote)
const char *pattern;
const int quote;
{
register const char *p;
int open = 0;
for (p = pattern; *p != '\0'; ++p)
switch (*p)
{
case '?':
case '*':
return 1;
case '\\':
if (quote)
++p;
break;
case '[':
open = 1;
break;
case ']':
if (open)
return 1;
break;
}
return 0;
}
/* Glob for MEMBER_PATTERN in archive ARNAME.
Return a malloc'd chain of matching elements (or nil if none). */
struct nameseq *
ar_glob (arname, member_pattern, size)
char *arname, *member_pattern;
unsigned int size;
{
struct ar_glob_state state;
char **names;
struct nameseq *n;
unsigned int i;
if (! glob_pattern_p (member_pattern, 1))
return 0;
/* Scan the archive for matches.
ar_glob_match will accumulate them in STATE.chain. */
i = strlen (arname);
state.arname = (char *) alloca (i + 2);
bcopy (arname, state.arname, i);
state.arname[i] = '(';
state.arname[i + 1] = '\0';
state.pattern = member_pattern;
state.size = size;
state.chain = 0;
state.n = 0;
(void) ar_scan (arname, ar_glob_match, (long int) &state);
if (state.chain == 0)
return 0;
/* Now put the names into a vector for sorting. */
names = (char **) alloca (state.n * sizeof (char *));
i = 0;
for (n = state.chain; n != 0; n = n->next)
names[i++] = n->name;
/* Sort them alphabetically. */
qsort ((char *) names, i, sizeof (*names), ar_glob_alphacompare);
/* Put them back into the chain in the sorted order. */
i = 0;
for (n = state.chain; n != 0; n = n->next)
n->name = names[i++];
return state.chain;
}
#endif /* Not NO_ARCHIVES. */