* ReadMakefile --
* Open and parse the given makefile.
*
* Results:
* 0 if ok. -1 if couldn't open file.
*
* Side Effects:
* lots
*/
static int
ReadMakefile(const void *p, const void *q MAKE_ATTR_UNUSED)
{
const char *fname = p; /* makefile to read */
int fd;
size_t len = MAXPATHLEN;
char *name, *path = bmake_malloc(len);
if (!strcmp(fname, "-")) {
Parse_File(NULL /*stdin*/, -1);
Var_Set("MAKEFILE", "", VAR_INTERNAL, 0);
} else {
/* if we've chdir'd, rebuild the path name */
if (strcmp(curdir, objdir) && *fname != '/') {
size_t plen = strlen(curdir) + strlen(fname) + 2;
if (len < plen)
path = bmake_realloc(path, len = 2 * plen);
(void)snprintf(path, len, "%s/%s", curdir, fname);
fd = open(path, O_RDONLY);
if (fd != -1) {
fname = path;
Boolean
meta_oodate(GNode *gn, Boolean oodate)
{
static char *tmpdir = NULL;
static char cwd[MAXPATHLEN];
char ldir_vname[64];
char latestdir[MAXPATHLEN];
char fname[MAXPATHLEN];
char fname1[MAXPATHLEN];
char fname2[MAXPATHLEN];
char *p;
char *cp;
static size_t cwdlen = 0;
static size_t tmplen = 0;
FILE *fp;
Boolean ignoreOODATE = FALSE;
Lst missingFiles;
if (oodate)
return oodate; /* we're done */
missingFiles = Lst_Init(FALSE);
/*
* We need to check if the target is out-of-date. This includes
* checking if the expanded command has changed. This in turn
* requires that all variables are set in the same way that they
* would be if the target needs to be re-built.
*/
Make_DoAllVar(gn);
meta_name(gn, fname, sizeof(fname), NULL, NULL);
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "meta_oodate: %s\n", fname);
#endif
if ((fp = fopen(fname, "r")) != NULL) {
static char *buf = NULL;
static size_t bufsz;
int lineno = 0;
int lastpid = 0;
int pid;
int f = 0;
int x;
LstNode ln;
struct stat fs;
if (!buf) {
bufsz = 8 * BUFSIZ;
buf = bmake_malloc(bufsz);
}
if (!cwdlen) {
if (getcwd(cwd, sizeof(cwd)) == NULL)
err(1, "Could not get current working directory");
cwdlen = strlen(cwd);
}
if (!tmpdir) {
tmpdir = getTmpdir();
tmplen = strlen(tmpdir);
}
/* we want to track all the .meta we read */
Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
ln = Lst_First(gn->commands);
while (!oodate && (x = fgetLine(&buf, &bufsz, 0, fp)) > 0) {
lineno++;
if (buf[x - 1] == '\n')
buf[x - 1] = '\0';
else
warnx("%s: %d: line truncated at %u", fname, lineno, x);
/* Find the start of the build monitor section. */
if (!f) {
if (strncmp(buf, "-- filemon", 10) == 0) {
f = 1;
continue;
}
if (strncmp(buf, "# buildmon", 10) == 0) {
f = 1;
continue;
}
}
/* Delimit the record type. */
p = buf;
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: %s\n", fname, lineno, buf);
#endif
strsep(&p, " ");
if (f) {
/*
* We are in the 'filemon' output section.
* Each record from filemon follows the general form:
*
* <key> <pid> <data>
*
* Where:
* <key> is a single letter, denoting the syscall.
* <pid> is the process that made the syscall.
* <data> is the arguments (of interest).
*/
switch(buf[0]) {
case '#': /* comment */
case 'V': /* version */
break;
default:
/*
* We need to track pathnames per-process.
*
* Each process run by make, starts off in the 'CWD'
* recorded in the .meta file, if it chdirs ('C')
* elsewhere we need to track that - but only for
* that process. If it forks ('F'), we initialize
* the child to have the same cwd as its parent.
*
* We also need to track the 'latestdir' of
* interest. This is usually the same as cwd, but
* not if a process is reading directories.
*
* Each time we spot a different process ('pid')
* we save the current value of 'latestdir' in a
* variable qualified by 'lastpid', and
* re-initialize 'latestdir' to any pre-saved
* value for the current 'pid' and 'CWD' if none.
*/
pid = atoi(p);
if (pid > 0 && pid != lastpid) {
char *ldir;
char *tp;
if (lastpid > 0) {
/* We need to remember this. */
Var_Set(ldir_vname, latestdir, VAR_GLOBAL, 0);
}
snprintf(ldir_vname, sizeof(ldir_vname), LDIR_VNAME_FMT, pid);
lastpid = pid;
ldir = Var_Value(ldir_vname, VAR_GLOBAL, &tp);
if (ldir) {
strlcpy(latestdir, ldir, sizeof(latestdir));
if (tp)
free(tp);
} else
strlcpy(latestdir, cwd, sizeof(latestdir));
}
/* Skip past the pid. */
if (strsep(&p, " ") == NULL)
continue;
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: cwd=%s ldir=%s\n", fname, lineno, cwd, latestdir);
#endif
break;
}
/* Process according to record type. */
switch (buf[0]) {
case 'X': /* eXit */
Var_Delete(ldir_vname, VAR_GLOBAL);
lastpid = 0; /* no need to save ldir_vname */
break;
case 'F': /* [v]Fork */
{
char cldir[64];
int child;
child = atoi(p);
if (child > 0) {
snprintf(cldir, sizeof(cldir), LDIR_VNAME_FMT, child);
Var_Set(cldir, latestdir, VAR_GLOBAL, 0);
}
}
break;
case 'C': /* Chdir */
/* Update the latest directory. */
strlcpy(latestdir, p, sizeof(latestdir));
break;
case 'M': /* renaMe */
if (Lst_IsEmpty(missingFiles))
break;
/* 'L' and 'M' put single quotes around the args */
if (*p == '\'') {
char *ep;
p++;
if ((ep = strchr(p, '\'')))
*ep = '\0';
}
/* FALLTHROUGH */
case 'D': /* unlink */
if (*p == '/' && !Lst_IsEmpty(missingFiles)) {
/* remove p from the missingFiles list if present */
if ((ln = Lst_Find(missingFiles, p, string_match)) != NULL) {
char *tp = Lst_Datum(ln);
Lst_Remove(missingFiles, ln);
free(tp);
}
}
break;
case 'L': /* Link */
/* we want the target */
if (strsep(&p, " ") == NULL)
continue;
/* 'L' and 'M' put single quotes around the args */
if (*p == '\'') {
char *ep;
p++;
if ((ep = strchr(p, '\'')))
*ep = '\0';
}
/* FALLTHROUGH */
case 'W': /* Write */
/*
* If a file we generated within our bailiwick
* but outside of .OBJDIR is missing,
* we need to do it again.
*/
/* ignore non-absolute paths */
if (*p != '/')
break;
if (Lst_IsEmpty(metaBailiwick))
break;
/* ignore cwd - normal dependencies handle those */
if (strncmp(p, cwd, cwdlen) == 0)
break;
if (!Lst_ForEach(metaBailiwick, prefix_match, p))
break;
/* tmpdir might be within */
if (tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0)
break;
/* ignore anything containing the string "tmp" */
if ((strstr("tmp", p)))
break;
if (stat(p, &fs) < 0) {
Lst_AtEnd(missingFiles, bmake_strdup(p));
}
break;
case 'R': /* Read */
case 'E': /* Exec */
/*
* Check for runtime files that can't
* be part of the dependencies because
* they are _expected_ to change.
*/
if (strncmp(p, "/tmp/", 5) == 0 ||
(tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0))
break;
if (strncmp(p, "/var/", 5) == 0)
break;
/* Ignore device files. */
if (strncmp(p, "/dev/", 5) == 0)
break;
/* Ignore /etc/ files. */
if (strncmp(p, "/etc/", 5) == 0)
break;
/*
* The rest of the record is the file name.
* Check if it's not an absolute path.
*/
{
char *sdirs[4];
char **sdp;
int sdx = 0;
int found = 0;
if (*p == '/') {
sdirs[sdx++] = p; /* done */
} else {
if (strcmp(".", p) == 0)
continue; /* no point */
/* Check vs latestdir */
snprintf(fname1, sizeof(fname1), "%s/%s", latestdir, p);
sdirs[sdx++] = fname1;
if (strcmp(latestdir, cwd) != 0) {
/* Check vs cwd */
snprintf(fname2, sizeof(fname2), "%s/%s", cwd, p);
sdirs[sdx++] = fname2;
}
}
sdirs[sdx++] = NULL;
for (sdp = sdirs; *sdp && !found; sdp++) {
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: looking for: %s\n", fname, lineno, *sdp);
#endif
if (stat(*sdp, &fs) == 0) {
found = 1;
p = *sdp;
}
}
if (found) {
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: found: %s\n", fname, lineno, p);
#endif
if (!S_ISDIR(fs.st_mode) &&
fs.st_mtime > gn->mtime) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: file '%s' is newer than the target...\n", fname, lineno, p);
oodate = TRUE;
} else if (S_ISDIR(fs.st_mode)) {
/* Update the latest directory. */
realpath(p, latestdir);
}
} else if (errno == ENOENT && *p == '/' &&
strncmp(p, cwd, cwdlen) != 0) {
/*
* A referenced file outside of CWD is missing.
* We cannot catch every eventuality here...
*/
if (DEBUG(META))
fprintf(debug_file, "%s: %d: file '%s' may have moved?...\n", fname, lineno, p);
oodate = TRUE;
}
}
break;
default:
break;
}
} else if (strcmp(buf, "CMD") == 0) {
/*
* Compare the current command with the one in the
* meta data file.
*/
if (ln == NULL) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: there were more build commands in the meta data file than there are now...\n", fname, lineno);
oodate = TRUE;
} else {
char *cmd = (char *)Lst_Datum(ln);
if (!ignoreOODATE) {
if (strstr(cmd, "$?"))
ignoreOODATE = TRUE;
else if ((cp = strstr(cmd, ".OODATE"))) {
/* check for $[{(].OODATE[)}] */
if (cp > cmd + 2 && cp[-2] == '$')
ignoreOODATE = TRUE;
}
if (ignoreOODATE && DEBUG(META))
fprintf(debug_file, "%s: %d: cannot compare commands using .OODATE\n", fname, lineno);
}
cmd = Var_Subst(NULL, cmd, gn, TRUE);
if ((cp = strchr(cmd, '\n'))) {
int n;
/*
* This command contains newlines, we need to
* fetch more from the .meta file before we
* attempt a comparison.
*/
/* first put the newline back at buf[x - 1] */
buf[x - 1] = '\n';
do {
/* now fetch the next line */
if ((n = fgetLine(&buf, &bufsz, x, fp)) <= 0)
break;
x = n;
lineno++;
if (buf[x - 1] != '\n') {
warnx("%s: %d: line truncated at %u", fname, lineno, x);
break;
}
cp = strchr(++cp, '\n');
} while (cp);
if (buf[x - 1] == '\n')
buf[x - 1] = '\0';
}
if (!ignoreOODATE &&
!(gn->type & OP_NOMETA_CMP) &&
strcmp(p, cmd) != 0) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: a build command has changed\n%s\nvs\n%s\n", fname, lineno, p, cmd);
if (!metaIgnoreCMDs)
oodate = TRUE;
}
free(cmd);
ln = Lst_Succ(ln);
}
} else if (strcmp(buf, "CWD") == 0) {
/*
* Check if there are extra commands now
* that weren't in the meta data file.
*/
if (!oodate && ln != NULL) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: there are extra build commands now that weren't in the meta data file\n", fname, lineno);
oodate = TRUE;
}
if (strcmp(p, cwd) != 0) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: the current working directory has changed from '%s' to '%s'\n", fname, lineno, p, curdir);
oodate = TRUE;
}
}
}
fclose(fp);
if (!Lst_IsEmpty(missingFiles)) {
if (DEBUG(META))
fprintf(debug_file, "%s: missing files: %s...\n",
fname, (char *)Lst_Datum(Lst_First(missingFiles)));
oodate = TRUE;
Lst_Destroy(missingFiles, (FreeProc *)free);
}
}
if (oodate && ignoreOODATE) {
/*
* Target uses .OODATE, so we need to re-compute it.
* We need to clean up what Make_DoAllVar() did.
*/
Var_Delete(ALLSRC, gn);
Var_Delete(OODATE, gn);
gn->flags &= ~DONE_ALLSRC;
}
return oodate;
}
Boolean
meta_oodate(GNode *gn, Boolean oodate)
{
static char *tmpdir = NULL;
static char cwd[MAXPATHLEN];
char lcwd_vname[64];
char ldir_vname[64];
char lcwd[MAXPATHLEN];
char latestdir[MAXPATHLEN];
char fname[MAXPATHLEN];
char fname1[MAXPATHLEN];
char fname2[MAXPATHLEN];
char fname3[MAXPATHLEN];
const char *dname;
const char *tname;
char *p;
char *cp;
char *link_src;
char *move_target;
static size_t cwdlen = 0;
static size_t tmplen = 0;
FILE *fp;
Boolean needOODATE = FALSE;
Lst missingFiles;
char *pa[4]; /* >= possible uses */
int i;
int have_filemon = FALSE;
if (oodate)
return oodate; /* we're done */
i = 0;
dname = Var_Value(".OBJDIR", gn, &pa[i++]);
tname = Var_Value(TARGET, gn, &pa[i++]);
/* if this succeeds fname3 is realpath of dname */
if (!meta_needed(gn, dname, tname, fname3, FALSE))
goto oodate_out;
dname = fname3;
missingFiles = Lst_Init(FALSE);
/*
* We need to check if the target is out-of-date. This includes
* checking if the expanded command has changed. This in turn
* requires that all variables are set in the same way that they
* would be if the target needs to be re-built.
*/
Make_DoAllVar(gn);
meta_name(gn, fname, sizeof(fname), dname, tname, dname);
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "meta_oodate: %s\n", fname);
#endif
if ((fp = fopen(fname, "r")) != NULL) {
static char *buf = NULL;
static size_t bufsz;
int lineno = 0;
int lastpid = 0;
int pid;
int x;
LstNode ln;
struct stat fs;
if (!buf) {
bufsz = 8 * BUFSIZ;
buf = bmake_malloc(bufsz);
}
if (!cwdlen) {
if (getcwd(cwd, sizeof(cwd)) == NULL)
err(1, "Could not get current working directory");
cwdlen = strlen(cwd);
}
strlcpy(lcwd, cwd, sizeof(lcwd));
strlcpy(latestdir, cwd, sizeof(latestdir));
if (!tmpdir) {
tmpdir = getTmpdir();
tmplen = strlen(tmpdir);
}
/* we want to track all the .meta we read */
Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
ln = Lst_First(gn->commands);
while (!oodate && (x = fgetLine(&buf, &bufsz, 0, fp)) > 0) {
lineno++;
if (buf[x - 1] == '\n')
buf[x - 1] = '\0';
else {
warnx("%s: %d: line truncated at %u", fname, lineno, x);
oodate = TRUE;
break;
}
link_src = NULL;
move_target = NULL;
/* Find the start of the build monitor section. */
if (!have_filemon) {
if (strncmp(buf, "-- filemon", 10) == 0) {
have_filemon = TRUE;
continue;
}
if (strncmp(buf, "# buildmon", 10) == 0) {
have_filemon = TRUE;
continue;
}
}
/* Delimit the record type. */
p = buf;
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: %s\n", fname, lineno, buf);
#endif
strsep(&p, " ");
if (have_filemon) {
/*
* We are in the 'filemon' output section.
* Each record from filemon follows the general form:
*
* <key> <pid> <data>
*
* Where:
* <key> is a single letter, denoting the syscall.
* <pid> is the process that made the syscall.
* <data> is the arguments (of interest).
*/
switch(buf[0]) {
case '#': /* comment */
case 'V': /* version */
break;
default:
/*
* We need to track pathnames per-process.
*
* Each process run by make, starts off in the 'CWD'
* recorded in the .meta file, if it chdirs ('C')
* elsewhere we need to track that - but only for
* that process. If it forks ('F'), we initialize
* the child to have the same cwd as its parent.
*
* We also need to track the 'latestdir' of
* interest. This is usually the same as cwd, but
* not if a process is reading directories.
*
* Each time we spot a different process ('pid')
* we save the current value of 'latestdir' in a
* variable qualified by 'lastpid', and
* re-initialize 'latestdir' to any pre-saved
* value for the current 'pid' and 'CWD' if none.
*/
CHECK_VALID_META(p);
pid = atoi(p);
if (pid > 0 && pid != lastpid) {
char *ldir;
char *tp;
if (lastpid > 0) {
/* We need to remember these. */
Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0);
Var_Set(ldir_vname, latestdir, VAR_GLOBAL, 0);
}
snprintf(lcwd_vname, sizeof(lcwd_vname), LCWD_VNAME_FMT, pid);
snprintf(ldir_vname, sizeof(ldir_vname), LDIR_VNAME_FMT, pid);
lastpid = pid;
ldir = Var_Value(ldir_vname, VAR_GLOBAL, &tp);
if (ldir) {
strlcpy(latestdir, ldir, sizeof(latestdir));
free(tp);
}
ldir = Var_Value(lcwd_vname, VAR_GLOBAL, &tp);
if (ldir) {
strlcpy(lcwd, ldir, sizeof(lcwd));
free(tp);
}
}
/* Skip past the pid. */
if (strsep(&p, " ") == NULL)
continue;
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: %d: %c: cwd=%s lcwd=%s ldir=%s\n",
fname, lineno,
pid, buf[0], cwd, lcwd, latestdir);
#endif
break;
}
CHECK_VALID_META(p);
/* Process according to record type. */
switch (buf[0]) {
case 'X': /* eXit */
Var_Delete(lcwd_vname, VAR_GLOBAL);
Var_Delete(ldir_vname, VAR_GLOBAL);
lastpid = 0; /* no need to save ldir_vname */
break;
case 'F': /* [v]Fork */
{
char cldir[64];
int child;
child = atoi(p);
if (child > 0) {
snprintf(cldir, sizeof(cldir), LCWD_VNAME_FMT, child);
Var_Set(cldir, lcwd, VAR_GLOBAL, 0);
snprintf(cldir, sizeof(cldir), LDIR_VNAME_FMT, child);
Var_Set(cldir, latestdir, VAR_GLOBAL, 0);
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: %d: cwd=%s lcwd=%s ldir=%s\n",
fname, lineno,
child, cwd, lcwd, latestdir);
#endif
}
}
break;
case 'C': /* Chdir */
/* Update lcwd and latest directory. */
strlcpy(latestdir, p, sizeof(latestdir));
strlcpy(lcwd, p, sizeof(lcwd));
Var_Set(lcwd_vname, lcwd, VAR_GLOBAL, 0);
Var_Set(ldir_vname, lcwd, VAR_GLOBAL, 0);
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: cwd=%s ldir=%s\n", fname, lineno, cwd, lcwd);
#endif
break;
case 'M': /* renaMe */
/*
* For 'M'oves we want to check
* the src as for 'R'ead
* and the target as for 'W'rite.
*/
cp = p; /* save this for a second */
/* now get target */
if (strsep(&p, " ") == NULL)
continue;
CHECK_VALID_META(p);
move_target = p;
p = cp;
/* 'L' and 'M' put single quotes around the args */
DEQUOTE(p);
DEQUOTE(move_target);
/* FALLTHROUGH */
case 'D': /* unlink */
if (*p == '/' && !Lst_IsEmpty(missingFiles)) {
/* remove any missingFiles entries that match p */
if ((ln = Lst_Find(missingFiles, p,
path_match)) != NULL) {
LstNode nln;
char *tp;
do {
nln = Lst_FindFrom(missingFiles, Lst_Succ(ln),
p, path_match);
tp = Lst_Datum(ln);
Lst_Remove(missingFiles, ln);
free(tp);
} while ((ln = nln) != NULL);
}
}
if (buf[0] == 'M') {
/* the target of the mv is a file 'W'ritten */
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "meta_oodate: M %s -> %s\n",
p, move_target);
#endif
p = move_target;
goto check_write;
}
break;
case 'L': /* Link */
/*
* For 'L'inks check
* the src as for 'R'ead
* and the target as for 'W'rite.
*/
link_src = p;
/* now get target */
if (strsep(&p, " ") == NULL)
continue;
CHECK_VALID_META(p);
/* 'L' and 'M' put single quotes around the args */
DEQUOTE(p);
DEQUOTE(link_src);
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "meta_oodate: L %s -> %s\n",
link_src, p);
#endif
/* FALLTHROUGH */
case 'W': /* Write */
check_write:
/*
* If a file we generated within our bailiwick
* but outside of .OBJDIR is missing,
* we need to do it again.
*/
/* ignore non-absolute paths */
if (*p != '/')
break;
if (Lst_IsEmpty(metaBailiwick))
break;
/* ignore cwd - normal dependencies handle those */
if (strncmp(p, cwd, cwdlen) == 0)
break;
if (!Lst_ForEach(metaBailiwick, prefix_match, p))
break;
/* tmpdir might be within */
if (tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0)
break;
/* ignore anything containing the string "tmp" */
if ((strstr("tmp", p)))
break;
if ((link_src != NULL && cached_lstat(p, &fs) < 0) ||
(link_src == NULL && cached_stat(p, &fs) < 0)) {
if (!meta_ignore(gn, p)) {
if (Lst_Find(missingFiles, p, string_match) == NULL)
Lst_AtEnd(missingFiles, bmake_strdup(p));
}
}
break;
check_link_src:
p = link_src;
link_src = NULL;
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "meta_oodate: L src %s\n", p);
#endif
/* FALLTHROUGH */
case 'R': /* Read */
case 'E': /* Exec */
/*
* Check for runtime files that can't
* be part of the dependencies because
* they are _expected_ to change.
*/
if (meta_ignore(gn, p))
break;
/*
* The rest of the record is the file name.
* Check if it's not an absolute path.
*/
{
char *sdirs[4];
char **sdp;
int sdx = 0;
int found = 0;
if (*p == '/') {
sdirs[sdx++] = p; /* done */
} else {
if (strcmp(".", p) == 0)
continue; /* no point */
/* Check vs latestdir */
snprintf(fname1, sizeof(fname1), "%s/%s", latestdir, p);
sdirs[sdx++] = fname1;
if (strcmp(latestdir, lcwd) != 0) {
/* Check vs lcwd */
snprintf(fname2, sizeof(fname2), "%s/%s", lcwd, p);
sdirs[sdx++] = fname2;
}
if (strcmp(lcwd, cwd) != 0) {
/* Check vs cwd */
snprintf(fname3, sizeof(fname3), "%s/%s", cwd, p);
sdirs[sdx++] = fname3;
}
}
sdirs[sdx++] = NULL;
for (sdp = sdirs; *sdp && !found; sdp++) {
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: looking for: %s\n", fname, lineno, *sdp);
#endif
if (cached_stat(*sdp, &fs) == 0) {
found = 1;
p = *sdp;
}
}
if (found) {
#ifdef DEBUG_META_MODE
if (DEBUG(META))
fprintf(debug_file, "%s: %d: found: %s\n", fname, lineno, p);
#endif
if (!S_ISDIR(fs.st_mode) &&
fs.st_mtime > gn->mtime) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: file '%s' is newer than the target...\n", fname, lineno, p);
oodate = TRUE;
} else if (S_ISDIR(fs.st_mode)) {
/* Update the latest directory. */
cached_realpath(p, latestdir);
}
} else if (errno == ENOENT && *p == '/' &&
strncmp(p, cwd, cwdlen) != 0) {
/*
* A referenced file outside of CWD is missing.
* We cannot catch every eventuality here...
*/
if (Lst_Find(missingFiles, p, string_match) == NULL)
Lst_AtEnd(missingFiles, bmake_strdup(p));
}
}
if (buf[0] == 'E') {
/* previous latestdir is no longer relevant */
strlcpy(latestdir, lcwd, sizeof(latestdir));
}
break;
default:
break;
}
if (!oodate && buf[0] == 'L' && link_src != NULL)
goto check_link_src;
} else if (strcmp(buf, "CMD") == 0) {
/*
* Compare the current command with the one in the
* meta data file.
*/
if (ln == NULL) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: there were more build commands in the meta data file than there are now...\n", fname, lineno);
oodate = TRUE;
} else {
char *cmd = (char *)Lst_Datum(ln);
Boolean hasOODATE = FALSE;
if (strstr(cmd, "$?"))
hasOODATE = TRUE;
else if ((cp = strstr(cmd, ".OODATE"))) {
/* check for $[{(].OODATE[:)}] */
if (cp > cmd + 2 && cp[-2] == '$')
hasOODATE = TRUE;
}
if (hasOODATE) {
needOODATE = TRUE;
if (DEBUG(META))
fprintf(debug_file, "%s: %d: cannot compare command using .OODATE\n", fname, lineno);
}
cmd = Var_Subst(NULL, cmd, gn, VARF_WANTRES|VARF_UNDEFERR);
if ((cp = strchr(cmd, '\n'))) {
int n;
/*
* This command contains newlines, we need to
* fetch more from the .meta file before we
* attempt a comparison.
*/
/* first put the newline back at buf[x - 1] */
buf[x - 1] = '\n';
do {
/* now fetch the next line */
if ((n = fgetLine(&buf, &bufsz, x, fp)) <= 0)
break;
x = n;
lineno++;
if (buf[x - 1] != '\n') {
warnx("%s: %d: line truncated at %u", fname, lineno, x);
break;
}
cp = strchr(++cp, '\n');
} while (cp);
if (buf[x - 1] == '\n')
buf[x - 1] = '\0';
}
if (!hasOODATE &&
!(gn->type & OP_NOMETA_CMP) &&
strcmp(p, cmd) != 0) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: a build command has changed\n%s\nvs\n%s\n", fname, lineno, p, cmd);
if (!metaIgnoreCMDs)
oodate = TRUE;
}
free(cmd);
ln = Lst_Succ(ln);
}
} else if (strcmp(buf, "CWD") == 0) {
/*
* Check if there are extra commands now
* that weren't in the meta data file.
*/
if (!oodate && ln != NULL) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: there are extra build commands now that weren't in the meta data file\n", fname, lineno);
oodate = TRUE;
}
if (strcmp(p, cwd) != 0) {
if (DEBUG(META))
fprintf(debug_file, "%s: %d: the current working directory has changed from '%s' to '%s'\n", fname, lineno, p, curdir);
oodate = TRUE;
}
}
}
fclose(fp);
if (!Lst_IsEmpty(missingFiles)) {
if (DEBUG(META))
fprintf(debug_file, "%s: missing files: %s...\n",
fname, (char *)Lst_Datum(Lst_First(missingFiles)));
oodate = TRUE;
}
if (!oodate && !have_filemon && filemonMissing) {
if (DEBUG(META))
fprintf(debug_file, "%s: missing filemon data\n", fname);
oodate = TRUE;
}
} else {
if (writeMeta && metaMissing) {
cp = NULL;
/* if target is in .CURDIR we do not need a meta file */
if (gn->path && (cp = strrchr(gn->path, '/')) && cp > gn->path) {
if (strncmp(curdir, gn->path, (cp - gn->path)) != 0) {
cp = NULL; /* not in .CURDIR */
}
}
if (!cp) {
if (DEBUG(META))
fprintf(debug_file, "%s: required but missing\n", fname);
oodate = TRUE;
needOODATE = TRUE; /* assume the worst */
}
}
}
Lst_Destroy(missingFiles, (FreeProc *)free);
if (oodate && needOODATE) {
/*
* Target uses .OODATE which is empty; or we wouldn't be here.
* We have decided it is oodate, so .OODATE needs to be set.
* All we can sanely do is set it to .ALLSRC.
*/
Var_Delete(OODATE, gn);
Var_Set(OODATE, Var_Value(ALLSRC, gn, &cp), gn, 0);
free(cp);
}
oodate_out:
for (i--; i >= 0; i--) {
free(pa[i]);
}
return oodate;
}
/*-
*-----------------------------------------------------------------------
* ArchSVR4Entry --
* Parse an SVR4 style entry that begins with a slash.
* If it is "//", then load the table of filenames
* If it is "/<offset>", then try to substitute the long file name
* from offset of a table previously read.
*
* Results:
* -1: Bad data in archive
* 0: A table was loaded from the file
* 1: Name was successfully substituted from table
* 2: Name was not successfully substituted from table
*
* Side Effects:
* If a table is read, the file pointer is moved to the next archive
* member
*
*-----------------------------------------------------------------------
*/
static int
ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
{
#define ARLONGNAMES1 "//"
#define ARLONGNAMES2 "/ARFILENAMES"
size_t entry;
char *ptr, *eptr;
if (strncmp(name, ARLONGNAMES1, sizeof(ARLONGNAMES1) - 1) == 0 ||
strncmp(name, ARLONGNAMES2, sizeof(ARLONGNAMES2) - 1) == 0) {
if (ar->fnametab != NULL) {
if (DEBUG(ARCH)) {
fprintf(debug_file, "Attempted to redefine an SVR4 name table\n");
}
return -1;
}
/*
* This is a table of archive names, so we build one for
* ourselves
*/
ar->fnametab = bmake_malloc(size);
ar->fnamesize = size;
if (fread(ar->fnametab, size, 1, arch) != 1) {
if (DEBUG(ARCH)) {
fprintf(debug_file, "Reading an SVR4 name table failed\n");
}
return -1;
}
eptr = ar->fnametab + size;
for (entry = 0, ptr = ar->fnametab; ptr < eptr; ptr++)
switch (*ptr) {
case '/':
entry++;
*ptr = '\0';
break;
case '\n':
break;
default:
break;
}
if (DEBUG(ARCH)) {
fprintf(debug_file, "Found svr4 archive name table with %lu entries\n",
(u_long)entry);
}
return 0;
}
if (name[1] == ' ' || name[1] == '\0')
return 2;
entry = (size_t)strtol(&name[1], &eptr, 0);
if ((*eptr != ' ' && *eptr != '\0') || eptr == &name[1]) {
if (DEBUG(ARCH)) {
fprintf(debug_file, "Could not parse SVR4 name %s\n", name);
}
return 2;
}
if (entry >= ar->fnamesize) {
if (DEBUG(ARCH)) {
fprintf(debug_file, "SVR4 entry offset %s is greater than %lu\n",
name, (u_long)ar->fnamesize);
}
return 2;
}
if (DEBUG(ARCH)) {
fprintf(debug_file, "Replaced %s with %s\n", name, &ar->fnametab[entry]);
}
(void)strncpy(name, &ar->fnametab[entry], MAXPATHLEN);
name[MAXPATHLEN] = '\0';
return 1;
}
/*-
*-----------------------------------------------------------------------
* ArchStatMember --
* Locate a member of an archive, given the path of the archive and
* the path of the desired member.
*
* Input:
* archive Path to the archive
* member Name of member. If it is a path, only the last
* component is used.
* hash TRUE if archive should be hashed if not already so.
*
* Results:
* A pointer to the current struct ar_hdr structure for the member. Note
* That no position is returned, so this is not useful for touching
* archive members. This is mostly because we have no assurances that
* The archive will remain constant after we read all the headers, so
* there's not much point in remembering the position...
*
* Side Effects:
*
*-----------------------------------------------------------------------
*/
static struct ar_hdr *
ArchStatMember(char *archive, char *member, Boolean hash)
{
#define AR_MAX_NAME_LEN (sizeof(arh.ar_name)-1)
FILE * arch; /* Stream to archive */
int size; /* Size of archive member */
char *cp; /* Useful character pointer */
char magic[SARMAG];
LstNode ln; /* Lst member containing archive descriptor */
Arch *ar; /* Archive descriptor */
Hash_Entry *he; /* Entry containing member's description */
struct ar_hdr arh; /* archive-member header for reading archive */
char memName[MAXPATHLEN+1];
/* Current member name while hashing. */
/*
* Because of space constraints and similar things, files are archived
* using their final path components, not the entire thing, so we need
* to point 'member' to the final component, if there is one, to make
* the comparisons easier...
*/
cp = strrchr(member, '/');
if (cp != NULL) {
member = cp + 1;
}
ln = Lst_Find(archives, archive, ArchFindArchive);
if (ln != NULL) {
ar = (Arch *)Lst_Datum(ln);
he = Hash_FindEntry(&ar->members, member);
if (he != NULL) {
return ((struct ar_hdr *)Hash_GetValue(he));
} else {
/* Try truncated name */
char copy[AR_MAX_NAME_LEN+1];
size_t len = strlen(member);
if (len > AR_MAX_NAME_LEN) {
len = AR_MAX_NAME_LEN;
strncpy(copy, member, AR_MAX_NAME_LEN);
copy[AR_MAX_NAME_LEN] = '\0';
}
if ((he = Hash_FindEntry(&ar->members, copy)) != NULL)
return ((struct ar_hdr *)Hash_GetValue(he));
return NULL;
}
}
if (!hash) {
/*
* Caller doesn't want the thing hashed, just use ArchFindMember
* to read the header for the member out and close down the stream
* again. Since the archive is not to be hashed, we assume there's
* no need to allocate extra room for the header we're returning,
* so just declare it static.
*/
static struct ar_hdr sarh;
arch = ArchFindMember(archive, member, &sarh, "r");
if (arch == NULL) {
return NULL;
} else {
fclose(arch);
return (&sarh);
}
}
/*
* We don't have this archive on the list yet, so we want to find out
* everything that's in it and cache it so we can get at it quickly.
*/
arch = fopen(archive, "r");
if (arch == NULL) {
return NULL;
}
/*
* We use the ARMAG string to make sure this is an archive we
* can handle...
*/
if ((fread(magic, SARMAG, 1, arch) != 1) ||
(strncmp(magic, ARMAG, SARMAG) != 0)) {
fclose(arch);
return NULL;
}
ar = bmake_malloc(sizeof(Arch));
ar->name = bmake_strdup(archive);
ar->fnametab = NULL;
ar->fnamesize = 0;
Hash_InitTable(&ar->members, -1);
memName[AR_MAX_NAME_LEN] = '\0';
while (fread((char *)&arh, sizeof(struct ar_hdr), 1, arch) == 1) {
if (strncmp( arh.ar_fmag, ARFMAG, sizeof(arh.ar_fmag)) != 0) {
/*
* The header is bogus, so the archive is bad
* and there's no way we can recover...
*/
goto badarch;
} else {
/*
* We need to advance the stream's pointer to the start of the
* next header. Files are padded with newlines to an even-byte
* boundary, so we need to extract the size of the file from the
* 'size' field of the header and round it up during the seek.
*/
arh.ar_size[sizeof(arh.ar_size)-1] = '\0';
size = (int)strtol(arh.ar_size, NULL, 10);
(void)strncpy(memName, arh.ar_name, sizeof(arh.ar_name));
for (cp = &memName[AR_MAX_NAME_LEN]; *cp == ' '; cp--) {
continue;
}
cp[1] = '\0';
#ifdef SVR4ARCHIVES
/*
* svr4 names are slash terminated. Also svr4 extended AR format.
*/
if (memName[0] == '/') {
/*
* svr4 magic mode; handle it
*/
switch (ArchSVR4Entry(ar, memName, size, arch)) {
case -1: /* Invalid data */
goto badarch;
case 0: /* List of files entry */
continue;
default: /* Got the entry */
break;
}
}
else {
if (cp[0] == '/')
cp[0] = '\0';
}
#endif
#ifdef AR_EFMT1
/*
* BSD 4.4 extended AR format: #1/<namelen>, with name as the
* first <namelen> bytes of the file
*/
if (strncmp(memName, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0 &&
isdigit((unsigned char)memName[sizeof(AR_EFMT1) - 1])) {
unsigned int elen = atoi(&memName[sizeof(AR_EFMT1)-1]);
if (elen > MAXPATHLEN)
goto badarch;
if (fread(memName, elen, 1, arch) != 1)
goto badarch;
memName[elen] = '\0';
fseek(arch, -elen, SEEK_CUR);
if (DEBUG(ARCH) || DEBUG(MAKE)) {
fprintf(debug_file, "ArchStat: Extended format entry for %s\n", memName);
}
}
#endif
he = Hash_CreateEntry(&ar->members, memName, NULL);
Hash_SetValue(he, bmake_malloc(sizeof(struct ar_hdr)));
memcpy(Hash_GetValue(he), &arh, sizeof(struct ar_hdr));
}
fseek(arch, (size + 1) & ~1, SEEK_CUR);
}
fclose(arch);
(void)Lst_AtEnd(archives, ar);
/*
* Now that the archive has been read and cached, we can look into
* the hash table to find the desired member's header.
*/
he = Hash_FindEntry(&ar->members, member);
if (he != NULL) {
return ((struct ar_hdr *)Hash_GetValue(he));
} else {
return NULL;
}
badarch:
fclose(arch);
Hash_DeleteTable(&ar->members);
if (ar->fnametab)
free(ar->fnametab);
free(ar);
return NULL;
}
/*-
*-----------------------------------------------------------------------
* Arch_ParseArchive --
* Parse the archive specification in the given line and find/create
* the nodes for the specified archive members, placing their nodes
* on the given list.
*
* Input:
* linePtr Pointer to start of specification
* nodeLst Lst on which to place the nodes
* ctxt Context in which to expand variables
*
* Results:
* SUCCESS if it was a valid specification. The linePtr is updated
* to point to the first non-space after the archive spec. The
* nodes for the members are placed on the given list.
*
* Side Effects:
* Some nodes may be created. The given list is extended.
*
*-----------------------------------------------------------------------
*/
ReturnStatus
Arch_ParseArchive(char **linePtr, Lst nodeLst, GNode *ctxt)
{
char *cp; /* Pointer into line */
GNode *gn; /* New node */
char *libName; /* Library-part of specification */
char *memName; /* Member-part of specification */
char *nameBuf; /* temporary place for node name */
char saveChar; /* Ending delimiter of member-name */
Boolean subLibName; /* TRUE if libName should have/had
* variable substitution performed on it */
libName = *linePtr;
subLibName = FALSE;
for (cp = libName; *cp != '(' && *cp != '\0'; cp++) {
if (*cp == '$') {
/*
* Variable spec, so call the Var module to parse the puppy
* so we can safely advance beyond it...
*/
int length;
void *freeIt;
char *result;
result = Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
if (freeIt)
free(freeIt);
if (result == var_Error) {
return(FAILURE);
} else {
subLibName = TRUE;
}
cp += length-1;
}
}
*cp++ = '\0';
if (subLibName) {
libName = Var_Subst(NULL, libName, ctxt, TRUE);
}
for (;;) {
/*
* First skip to the start of the member's name, mark that
* place and skip to the end of it (either white-space or
* a close paren).
*/
Boolean doSubst = FALSE; /* TRUE if need to substitute in memName */
while (*cp != '\0' && *cp != ')' && isspace ((unsigned char)*cp)) {
cp++;
}
memName = cp;
while (*cp != '\0' && *cp != ')' && !isspace ((unsigned char)*cp)) {
if (*cp == '$') {
/*
* Variable spec, so call the Var module to parse the puppy
* so we can safely advance beyond it...
*/
int length;
void *freeIt;
char *result;
result = Var_Parse(cp, ctxt, TRUE, &length, &freeIt);
if (freeIt)
free(freeIt);
if (result == var_Error) {
return(FAILURE);
} else {
doSubst = TRUE;
}
cp += length;
} else {
cp++;
}
}
/*
* If the specification ends without a closing parenthesis,
* chances are there's something wrong (like a missing backslash),
* so it's better to return failure than allow such things to happen
*/
if (*cp == '\0') {
printf("No closing parenthesis in archive specification\n");
return (FAILURE);
}
/*
* If we didn't move anywhere, we must be done
*/
if (cp == memName) {
break;
}
saveChar = *cp;
*cp = '\0';
/*
* XXX: This should be taken care of intelligently by
* SuffExpandChildren, both for the archive and the member portions.
*/
/*
* If member contains variables, try and substitute for them.
* This will slow down archive specs with dynamic sources, of course,
* since we'll be (non-)substituting them three times, but them's
* the breaks -- we need to do this since SuffExpandChildren calls
* us, otherwise we could assume the thing would be taken care of
* later.
*/
if (doSubst) {
char *buf;
char *sacrifice;
char *oldMemName = memName;
size_t sz;
memName = Var_Subst(NULL, memName, ctxt, TRUE);
/*
* Now form an archive spec and recurse to deal with nested
* variables and multi-word variable values.... The results
* are just placed at the end of the nodeLst we're returning.
*/
sz = strlen(memName)+strlen(libName)+3;
buf = sacrifice = bmake_malloc(sz);
snprintf(buf, sz, "%s(%s)", libName, memName);
if (strchr(memName, '$') && strcmp(memName, oldMemName) == 0) {
/*
* Must contain dynamic sources, so we can't deal with it now.
* Just create an ARCHV node for the thing and let
* SuffExpandChildren handle it...
*/
gn = Targ_FindNode(buf, TARG_CREATE);
if (gn == NULL) {
free(buf);
return(FAILURE);
} else {
gn->type |= OP_ARCHV;
(void)Lst_AtEnd(nodeLst, gn);
}
} else if (Arch_ParseArchive(&sacrifice, nodeLst, ctxt)!=SUCCESS) {
/*
* Error in nested call -- free buffer and return FAILURE
* ourselves.
*/
free(buf);
return(FAILURE);
}
/*
* Free buffer and continue with our work.
*/
free(buf);
} else if (Dir_HasWildcards(memName)) {
Lst members = Lst_Init(FALSE);
char *member;
size_t sz = MAXPATHLEN, nsz;
nameBuf = bmake_malloc(sz);
Dir_Expand(memName, dirSearchPath, members);
while (!Lst_IsEmpty(members)) {
member = (char *)Lst_DeQueue(members);
nsz = strlen(libName) + strlen(member) + 3;
if (sz > nsz)
nameBuf = bmake_realloc(nameBuf, sz = nsz * 2);
snprintf(nameBuf, sz, "%s(%s)", libName, member);
free(member);
gn = Targ_FindNode(nameBuf, TARG_CREATE);
if (gn == NULL) {
free(nameBuf);
return (FAILURE);
} else {
/*
* We've found the node, but have to make sure the rest of
* the world knows it's an archive member, without having
* to constantly check for parentheses, so we type the
* thing with the OP_ARCHV bit before we place it on the
* end of the provided list.
*/
gn->type |= OP_ARCHV;
(void)Lst_AtEnd(nodeLst, gn);
}
}
Lst_Destroy(members, NULL);
free(nameBuf);
} else {
size_t sz = strlen(libName) + strlen(memName) + 3;
nameBuf = bmake_malloc(sz);
snprintf(nameBuf, sz, "%s(%s)", libName, memName);
gn = Targ_FindNode(nameBuf, TARG_CREATE);
free(nameBuf);
if (gn == NULL) {
return (FAILURE);
} else {
/*
* We've found the node, but have to make sure the rest of the
* world knows it's an archive member, without having to
* constantly check for parentheses, so we type the thing with
* the OP_ARCHV bit before we place it on the end of the
* provided list.
*/
gn->type |= OP_ARCHV;
(void)Lst_AtEnd(nodeLst, gn);
}
}
if (doSubst) {
free(memName);
}
*cp = saveChar;
}
/*
* If substituted libName, free it now, since we need it no longer.
*/
if (subLibName) {
free(libName);
}
/*
* We promised the pointer would be set up at the next non-space, so
* we must advance cp there before setting *linePtr... (note that on
* entrance to the loop, cp is guaranteed to point at a ')')
*/
do {
cp++;
} while (*cp != '\0' && isspace ((unsigned char)*cp));
*linePtr = cp;
return (SUCCESS);
}
