d466dc0ec0
documentation already adequatedly existed in the description in most cases. Where it did not, it was added. If no documentation existed beforehand, then none was added. Some unused dummies for use in the traversal functions were marked as __unused during the conversion. Occasionally, local style fixes were applied to lines already being modified or influenced. Now make(1) should always build with WARNS=3.
627 lines
16 KiB
C
627 lines
16 KiB
C
/*
|
|
* Copyright (c) 1988, 1989, 1990, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
* Copyright (c) 1989 by Berkeley Softworks
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Adam de Boor.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)targ.c 8.2 (Berkeley) 3/19/94
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*-
|
|
* targ.c --
|
|
* Functions for maintaining the Lst allTargets. Target nodes are
|
|
* kept in two structures: a Lst, maintained by the list library, and a
|
|
* hash table, maintained by the hash library.
|
|
*
|
|
* Interface:
|
|
* Targ_Init Initialization procedure.
|
|
*
|
|
* Targ_End Cleanup the module
|
|
*
|
|
* Targ_NewGN Create a new GNode for the passed target
|
|
* (string). The node is *not* placed in the
|
|
* hash table, though all its fields are
|
|
* initialized.
|
|
*
|
|
* Targ_FindNode Find the node for a given target, creating
|
|
* and storing it if it doesn't exist and the
|
|
* flags are right (TARG_CREATE)
|
|
*
|
|
* Targ_FindList Given a list of names, find nodes for all
|
|
* of them. If a name doesn't exist and the
|
|
* TARG_NOCREATE flag was given, an error message
|
|
* is printed. Else, if a name doesn't exist,
|
|
* its node is created.
|
|
*
|
|
* Targ_Ignore Return TRUE if errors should be ignored when
|
|
* creating the given target.
|
|
*
|
|
* Targ_Silent Return TRUE if we should be silent when
|
|
* creating the given target.
|
|
*
|
|
* Targ_Precious Return TRUE if the target is precious and
|
|
* should not be removed if we are interrupted.
|
|
*
|
|
* Debugging:
|
|
* Targ_PrintGraph Print out the entire graphm all variables
|
|
* and statistics for the directory cache. Should
|
|
* print something for suffixes, too, but...
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include "make.h"
|
|
#include "hash.h"
|
|
#include "dir.h"
|
|
|
|
static Lst allTargets; /* the list of all targets found so far */
|
|
static Lst allGNs; /* List of all the GNodes */
|
|
static Hash_Table targets; /* a hash table of same */
|
|
|
|
#define HTSIZE 191 /* initial size of hash table */
|
|
|
|
static int TargPrintOnlySrc(void *, void *);
|
|
static int TargPrintName(void *, void *);
|
|
static int TargPrintNode(void *, void *);
|
|
static void TargFreeGN(void *);
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_Init --
|
|
* Initialize this module
|
|
*
|
|
* Results:
|
|
* None
|
|
*
|
|
* Side Effects:
|
|
* The allTargets list and the targets hash table are initialized
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
void
|
|
Targ_Init (void)
|
|
{
|
|
allTargets = Lst_Init (FALSE);
|
|
Hash_InitTable (&targets, HTSIZE);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_End --
|
|
* Finalize this module
|
|
*
|
|
* Results:
|
|
* None
|
|
*
|
|
* Side Effects:
|
|
* All lists and gnodes are cleared
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
void
|
|
Targ_End (void)
|
|
{
|
|
Lst_Destroy(allTargets, NOFREE);
|
|
if (allGNs)
|
|
Lst_Destroy(allGNs, TargFreeGN);
|
|
Hash_DeleteTable(&targets);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_NewGN --
|
|
* Create and initialize a new graph node
|
|
*
|
|
* Results:
|
|
* An initialized graph node with the name field filled with a copy
|
|
* of the passed name
|
|
*
|
|
* Side Effects:
|
|
* The gnode is added to the list of all gnodes.
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
GNode *
|
|
Targ_NewGN (char *name)
|
|
{
|
|
GNode *gn;
|
|
|
|
gn = (GNode *) emalloc (sizeof (GNode));
|
|
gn->name = estrdup (name);
|
|
gn->path = (char *) 0;
|
|
if (name[0] == '-' && name[1] == 'l') {
|
|
gn->type = OP_LIB;
|
|
} else {
|
|
gn->type = 0;
|
|
}
|
|
gn->unmade = 0;
|
|
gn->make = FALSE;
|
|
gn->made = UNMADE;
|
|
gn->childMade = FALSE;
|
|
gn->order = 0;
|
|
gn->mtime = gn->cmtime = 0;
|
|
gn->iParents = Lst_Init (FALSE);
|
|
gn->cohorts = Lst_Init (FALSE);
|
|
gn->parents = Lst_Init (FALSE);
|
|
gn->children = Lst_Init (FALSE);
|
|
gn->successors = Lst_Init (FALSE);
|
|
gn->preds = Lst_Init (FALSE);
|
|
gn->context = Lst_Init (FALSE);
|
|
gn->commands = Lst_Init (FALSE);
|
|
gn->suffix = NULL;
|
|
|
|
if (allGNs == NULL)
|
|
allGNs = Lst_Init(FALSE);
|
|
Lst_AtEnd(allGNs, (void *) gn);
|
|
|
|
return (gn);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* TargFreeGN --
|
|
* Destroy a GNode
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
static void
|
|
TargFreeGN (void *gnp)
|
|
{
|
|
GNode *gn = (GNode *) gnp;
|
|
|
|
|
|
free(gn->name);
|
|
efree(gn->path);
|
|
|
|
Lst_Destroy(gn->iParents, NOFREE);
|
|
Lst_Destroy(gn->cohorts, NOFREE);
|
|
Lst_Destroy(gn->parents, NOFREE);
|
|
Lst_Destroy(gn->children, NOFREE);
|
|
Lst_Destroy(gn->successors, NOFREE);
|
|
Lst_Destroy(gn->preds, NOFREE);
|
|
Lst_Destroy(gn->context, NOFREE);
|
|
Lst_Destroy(gn->commands, NOFREE);
|
|
free(gn);
|
|
}
|
|
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_FindNode --
|
|
* Find a node in the list using the given name for matching
|
|
*
|
|
* Results:
|
|
* The node in the list if it was. If it wasn't, return NULL of
|
|
* flags was TARG_NOCREATE or the newly created and initialized node
|
|
* if it was TARG_CREATE
|
|
*
|
|
* Side Effects:
|
|
* Sometimes a node is created and added to the list
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
GNode *
|
|
Targ_FindNode (char *name, int flags)
|
|
{
|
|
GNode *gn; /* node in that element */
|
|
Hash_Entry *he; /* New or used hash entry for node */
|
|
Boolean isNew; /* Set TRUE if Hash_CreateEntry had to create */
|
|
/* an entry for the node */
|
|
|
|
|
|
if (flags & TARG_CREATE) {
|
|
he = Hash_CreateEntry (&targets, name, &isNew);
|
|
if (isNew) {
|
|
gn = Targ_NewGN (name);
|
|
Hash_SetValue (he, gn);
|
|
(void) Lst_AtEnd (allTargets, (void *)gn);
|
|
}
|
|
} else {
|
|
he = Hash_FindEntry (&targets, name);
|
|
}
|
|
|
|
if (he == (Hash_Entry *) NULL) {
|
|
return (NULL);
|
|
} else {
|
|
return ((GNode *) Hash_GetValue (he));
|
|
}
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_FindList --
|
|
* Make a complete list of GNodes from the given list of names
|
|
*
|
|
* Results:
|
|
* A complete list of graph nodes corresponding to all instances of all
|
|
* the names in names.
|
|
*
|
|
* Side Effects:
|
|
* If flags is TARG_CREATE, nodes will be created for all names in
|
|
* names which do not yet have graph nodes. If flags is TARG_NOCREATE,
|
|
* an error message will be printed for each name which can't be found.
|
|
* -----------------------------------------------------------------------
|
|
*/
|
|
Lst
|
|
Targ_FindList (Lst names, int flags)
|
|
{
|
|
Lst nodes; /* result list */
|
|
LstNode ln; /* name list element */
|
|
GNode *gn; /* node in tLn */
|
|
char *name;
|
|
|
|
nodes = Lst_Init (FALSE);
|
|
|
|
if (Lst_Open (names) == FAILURE) {
|
|
return (nodes);
|
|
}
|
|
while ((ln = Lst_Next (names)) != NULL) {
|
|
name = (char *)Lst_Datum(ln);
|
|
gn = Targ_FindNode (name, flags);
|
|
if (gn != NULL) {
|
|
/*
|
|
* Note: Lst_AtEnd must come before the Lst_Concat so the nodes
|
|
* are added to the list in the order in which they were
|
|
* encountered in the makefile.
|
|
*/
|
|
(void) Lst_AtEnd (nodes, (void *)gn);
|
|
if (gn->type & OP_DOUBLEDEP) {
|
|
(void)Lst_Concat (nodes, gn->cohorts, LST_CONCNEW);
|
|
}
|
|
} else if (flags == TARG_NOCREATE) {
|
|
Error ("\"%s\" -- target unknown.", name);
|
|
}
|
|
}
|
|
Lst_Close (names);
|
|
return (nodes);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_Ignore --
|
|
* Return true if should ignore errors when creating gn
|
|
*
|
|
* Results:
|
|
* TRUE if should ignore errors
|
|
*
|
|
* Side Effects:
|
|
* None
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
Boolean
|
|
Targ_Ignore (GNode *gn)
|
|
{
|
|
if (ignoreErrors || gn->type & OP_IGNORE) {
|
|
return (TRUE);
|
|
} else {
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_Silent --
|
|
* Return true if be silent when creating gn
|
|
*
|
|
* Results:
|
|
* TRUE if should be silent
|
|
*
|
|
* Side Effects:
|
|
* None
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
Boolean
|
|
Targ_Silent (GNode *gn)
|
|
{
|
|
if (beSilent || gn->type & OP_SILENT) {
|
|
return (TRUE);
|
|
} else {
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_Precious --
|
|
* See if the given target is precious
|
|
*
|
|
* Results:
|
|
* TRUE if it is precious. FALSE otherwise
|
|
*
|
|
* Side Effects:
|
|
* None
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
Boolean
|
|
Targ_Precious (GNode *gn)
|
|
{
|
|
if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
|
|
return (TRUE);
|
|
} else {
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
/******************* DEBUG INFO PRINTING ****************/
|
|
|
|
static GNode *mainTarg; /* the main target, as set by Targ_SetMain */
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_SetMain --
|
|
* Set our idea of the main target we'll be creating. Used for
|
|
* debugging output.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* "mainTarg" is set to the main target's node.
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
void
|
|
Targ_SetMain (GNode *gn)
|
|
{
|
|
mainTarg = gn;
|
|
}
|
|
|
|
static int
|
|
TargPrintName (void *gnp, void *ppath)
|
|
{
|
|
GNode *gn = (GNode *) gnp;
|
|
printf ("%s ", gn->name);
|
|
#ifdef notdef
|
|
if (ppath) {
|
|
if (gn->path) {
|
|
printf ("[%s] ", gn->path);
|
|
}
|
|
if (gn == mainTarg) {
|
|
printf ("(MAIN NAME) ");
|
|
}
|
|
}
|
|
#endif /* notdef */
|
|
return (ppath ? 0 : 0);
|
|
}
|
|
|
|
|
|
int
|
|
Targ_PrintCmd (void *cmd, void *dummy __unused)
|
|
{
|
|
printf ("\t%s\n", (char *) cmd);
|
|
return (0);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_FmtTime --
|
|
* Format a modification time in some reasonable way and return it.
|
|
*
|
|
* Results:
|
|
* The time reformatted.
|
|
*
|
|
* Side Effects:
|
|
* The time is placed in a static area, so it is overwritten
|
|
* with each call.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
char *
|
|
Targ_FmtTime (time_t modtime)
|
|
{
|
|
struct tm *parts;
|
|
static char buf[128];
|
|
|
|
parts = localtime(&modtime);
|
|
|
|
strftime(buf, sizeof buf, "%H:%M:%S %b %d, %Y", parts);
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
return(buf);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_PrintType --
|
|
* Print out a type field giving only those attributes the user can
|
|
* set.
|
|
*
|
|
* Results:
|
|
*
|
|
* Side Effects:
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
void
|
|
Targ_PrintType (int type)
|
|
{
|
|
int tbit;
|
|
|
|
#define PRINTBIT(attr) case CONCAT(OP_,attr): printf("." #attr " "); break
|
|
#define PRINTDBIT(attr) case CONCAT(OP_,attr): DEBUGF(TARG, ("." #attr " ")); break
|
|
|
|
type &= ~OP_OPMASK;
|
|
|
|
while (type) {
|
|
tbit = 1 << (ffs(type) - 1);
|
|
type &= ~tbit;
|
|
|
|
switch(tbit) {
|
|
PRINTBIT(OPTIONAL);
|
|
PRINTBIT(USE);
|
|
PRINTBIT(EXEC);
|
|
PRINTBIT(IGNORE);
|
|
PRINTBIT(PRECIOUS);
|
|
PRINTBIT(SILENT);
|
|
PRINTBIT(MAKE);
|
|
PRINTBIT(JOIN);
|
|
PRINTBIT(INVISIBLE);
|
|
PRINTBIT(NOTMAIN);
|
|
PRINTDBIT(LIB);
|
|
/*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
|
|
case OP_MEMBER: DEBUGF(TARG, (".MEMBER ")); break;
|
|
PRINTDBIT(ARCHV);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* TargPrintNode --
|
|
* print the contents of a node
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
static int
|
|
TargPrintNode (void *gnp, void *passp)
|
|
{
|
|
GNode *gn = (GNode *) gnp;
|
|
int pass = *(int *) passp;
|
|
if (!OP_NOP(gn->type)) {
|
|
printf("#\n");
|
|
if (gn == mainTarg) {
|
|
printf("# *** MAIN TARGET ***\n");
|
|
}
|
|
if (pass == 2) {
|
|
if (gn->unmade) {
|
|
printf("# %d unmade children\n", gn->unmade);
|
|
} else {
|
|
printf("# No unmade children\n");
|
|
}
|
|
if (! (gn->type & (OP_JOIN|OP_USE|OP_EXEC))) {
|
|
if (gn->mtime != 0) {
|
|
printf("# last modified %s: %s\n",
|
|
Targ_FmtTime(gn->mtime),
|
|
(gn->made == UNMADE ? "unmade" :
|
|
(gn->made == MADE ? "made" :
|
|
(gn->made == UPTODATE ? "up-to-date" :
|
|
"error when made"))));
|
|
} else if (gn->made != UNMADE) {
|
|
printf("# non-existent (maybe): %s\n",
|
|
(gn->made == MADE ? "made" :
|
|
(gn->made == UPTODATE ? "up-to-date" :
|
|
(gn->made == ERROR ? "error when made" :
|
|
"aborted"))));
|
|
} else {
|
|
printf("# unmade\n");
|
|
}
|
|
}
|
|
if (!Lst_IsEmpty (gn->iParents)) {
|
|
printf("# implicit parents: ");
|
|
Lst_ForEach (gn->iParents, TargPrintName, (void *)0);
|
|
fputc ('\n', stdout);
|
|
}
|
|
}
|
|
if (!Lst_IsEmpty (gn->parents)) {
|
|
printf("# parents: ");
|
|
Lst_ForEach (gn->parents, TargPrintName, (void *)0);
|
|
fputc ('\n', stdout);
|
|
}
|
|
|
|
printf("%-16s", gn->name);
|
|
switch (gn->type & OP_OPMASK) {
|
|
case OP_DEPENDS:
|
|
printf(": "); break;
|
|
case OP_FORCE:
|
|
printf("! "); break;
|
|
case OP_DOUBLEDEP:
|
|
printf(":: "); break;
|
|
default:
|
|
break;
|
|
}
|
|
Targ_PrintType (gn->type);
|
|
Lst_ForEach (gn->children, TargPrintName, (void *)0);
|
|
fputc ('\n', stdout);
|
|
Lst_ForEach (gn->commands, Targ_PrintCmd, (void *)0);
|
|
printf("\n\n");
|
|
if (gn->type & OP_DOUBLEDEP) {
|
|
Lst_ForEach (gn->cohorts, TargPrintNode, (void *)&pass);
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* TargPrintOnlySrc --
|
|
* Print only those targets that are just a source.
|
|
*
|
|
* Results:
|
|
* 0.
|
|
*
|
|
* Side Effects:
|
|
* The name of each file is printed preceded by #\t
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
static int
|
|
TargPrintOnlySrc(void *gnp, void *dummy __unused)
|
|
{
|
|
GNode *gn = (GNode *) gnp;
|
|
if (OP_NOP(gn->type))
|
|
printf("#\t%s [%s]\n", gn->name, gn->path ? gn->path : gn->name);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* Targ_PrintGraph --
|
|
* Print the entire graph.
|
|
*
|
|
* Results:
|
|
* none
|
|
*
|
|
* Side Effects:
|
|
* lots o' output
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
void
|
|
Targ_PrintGraph (int pass)
|
|
{
|
|
printf("#*** Input graph:\n");
|
|
Lst_ForEach (allTargets, TargPrintNode, (void *)&pass);
|
|
printf("\n\n");
|
|
printf("#\n# Files that are only sources:\n");
|
|
Lst_ForEach (allTargets, TargPrintOnlySrc, (void *) 0);
|
|
printf("#*** Global Variables:\n");
|
|
Var_Dump (VAR_GLOBAL);
|
|
printf("#*** Command-line Variables:\n");
|
|
Var_Dump (VAR_CMD);
|
|
printf("\n");
|
|
Dir_PrintDirectories();
|
|
printf("\n");
|
|
Suff_PrintAll();
|
|
}
|