diff options
Diffstat (limited to 'usr.bin/make/suff.c')
| -rw-r--r-- | usr.bin/make/suff.c | 2205 |
1 files changed, 2205 insertions, 0 deletions
diff --git a/usr.bin/make/suff.c b/usr.bin/make/suff.c new file mode 100644 index 0000000..bed6c7a --- /dev/null +++ b/usr.bin/make/suff.c @@ -0,0 +1,2205 @@ +/*- + * 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. + * + * @(#)suff.c 8.4 (Berkeley) 3/21/94 + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +/*- + * suff.c -- + * Functions to maintain suffix lists and find implicit dependents + * using suffix transformation rules + * + * Interface: + * Suff_Init Initialize all things to do with suffixes. + * + * Suff_DoPaths This function is used to make life easier + * when searching for a file according to its + * suffix. It takes the global search path, + * as defined using the .PATH: target, and appends + * its directories to the path of each of the + * defined suffixes, as specified using + * .PATH<suffix>: targets. In addition, all + * directories given for suffixes labeled as + * include files or libraries, using the .INCLUDES + * or .LIBS targets, are played with using + * Dir_MakeFlags to create the .INCLUDES and + * .LIBS global variables. + * + * Suff_ClearSuffixes Clear out all the suffixes and defined + * transformations. + * + * Suff_IsTransform Return TRUE if the passed string is the lhs + * of a transformation rule. + * + * Suff_AddSuffix Add the passed string as another known suffix. + * + * Suff_GetPath Return the search path for the given suffix. + * + * Suff_AddInclude Mark the given suffix as denoting an include + * file. + * + * Suff_AddLib Mark the given suffix as denoting a library. + * + * Suff_AddTransform Add another transformation to the suffix + * graph. Returns GNode suitable for framing, I + * mean, tacking commands, attributes, etc. on. + * + * Suff_SetNull Define the suffix to consider the suffix of + * any file that doesn't have a known one. + * + * Suff_FindDeps Find implicit sources for and the location of + * a target based on its suffix. Returns the + * bottom-most node added to the graph or NULL + * if the target had no implicit sources. + */ + +#include <sys/queue.h> +#include <assert.h> +#include <string.h> +#include <stdlib.h> + +#include "arch.h" +#include "buf.h" +#include "config.h" +#include "dir.h" +#include "globals.h" +#include "GNode.h" +#include "lst.h" +#include "make.h" +#include "parse.h" +#include "str.h" +#include "suff.h" +#include "targ.h" +#include "util.h" +#include "var.h" + +/* Lst of suffixes */ +static Lst sufflist = Lst_Initializer(sufflist); + +/* Lst of suffixes to be cleaned */ +static Lst suffClean = Lst_Initializer(suffClean); + +/* Lst of sources */ +static Lst srclist = Lst_Initializer(srclist); + +/* Lst of transformation rules */ +static Lst transforms = Lst_Initializer(transforms); + +/* Counter for assigning suffix numbers */ +static int sNum = 0; + +/* + * Structure describing an individual suffix. + */ +typedef struct Suff { + char *name; /* The suffix itself */ + int nameLen; /* Length of the suffix */ + short flags; /* Type of suffix */ +#define SUFF_INCLUDE 0x01 /* One which is #include'd */ +#define SUFF_LIBRARY 0x02 /* One which contains a library */ +#define SUFF_NULL 0x04 /* The empty suffix */ + struct Path searchPath; /* Path for files with this suffix */ + int sNum; /* The suffix number */ + int refCount; /* Reference count of list membership */ + Lst parents; /* Suffixes we have a transformation to */ + Lst children; /* Suffixes we have a transformation from */ + Lst ref; /* List of lists this suffix is referenced */ +} Suff; + +/* + * Structure used in the search for implied sources. + */ +typedef struct Src { + char *file; /* The file to look for */ + char *pref; /* Prefix from which file was formed */ + Suff *suff; /* The suffix on the file */ + struct Src *parent; /* The Src for which this is a source */ + GNode *node; /* The node describing the file */ + int children; /* Count of existing children (so we don't free + * this thing too early or never nuke it) */ +#ifdef DEBUG_SRC + Lst cp; /* Debug; children list */ +#endif +} Src; + +/* The NULL suffix for this run */ +static Suff *suffNull; + +/* The empty suffix required for POSIX single-suffix transformation rules */ +static Suff *emptySuff; + +static void SuffFindDeps(GNode *, Lst *); + + +/*- + *----------------------------------------------------------------------- + * SuffSuffIsSuffix -- + * See if suff is a suffix of str. + * + * Results: + * NULL if it ain't, pointer to character in str before suffix if + * it is. + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +static char * +SuffSuffIsSuffix(const Suff *s, char *str) +{ + const char *p1; /* Pointer into suffix name */ + char *p2; /* Pointer into string being examined */ + size_t len; + + len = strlen(str); + p1 = s->name + s->nameLen; + p2 = str + len; + + while (p1 >= s->name && len > 0 && *p1 == *p2) { + p1--; + p2--; + len--; + } + + return (p1 == s->name - 1 ? p2 : NULL); +} + +/*- + *----------------------------------------------------------------------- + * SuffSuffFind -- + * Find a suffix given its name. + * + * Results: + * The suffix or NULL. + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +static Suff * +SuffSuffFind(const char *s) +{ + LstNode *ln; + + LST_FOREACH(ln, &sufflist) { + if (strcmp(s, ((const Suff *)Lst_Datum(ln))->name) == 0) + return (Lst_Datum(ln)); + } + return (NULL); +} + +/*- + *----------------------------------------------------------------------- + * SuffTransFind + * Find a transform. + * + * Results: + * transform or NULL. + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +static GNode * +SuffTransFind(const char *name) +{ + LstNode *ln; + + LST_FOREACH(ln, &transforms) { + if (strcmp(name, ((const GNode *)Lst_Datum(ln))->name) == 0) + return (Lst_Datum(ln)); + } + return (NULL); +} + + /*********** Maintenance Functions ************/ + +#if 0 +/* + * Keep this function for now until it is clear why a .SUFFIXES: doesn't + * actually delete the suffixes but just puts them on the suffClean list. + */ +/*- + *----------------------------------------------------------------------- + * SuffFree -- + * Free up all memory associated with the given suffix structure. + * + * Results: + * none + * + * Side Effects: + * the suffix entry is detroyed + *----------------------------------------------------------------------- + */ +static void +SuffFree(void *sp) +{ + Suff *s = sp; + + if (s == suffNull) + suffNull = NULL; + + if (s == emptySuff) + emptySuff = NULL; + + Lst_Destroy(&s->ref, NOFREE); + Lst_Destroy(&s->children, NOFREE); + Lst_Destroy(&s->parents, NOFREE); + Lst_Destroy(&s->searchPath, Dir_Destroy); + + free(s->name); + free(s); +} +#endif + +/*- + *----------------------------------------------------------------------- + * SuffRemove -- + * Remove the suffix into the list + * + * Results: + * None + * + * Side Effects: + * The reference count for the suffix is decremented + *----------------------------------------------------------------------- + */ +static void +SuffRemove(Lst *l, Suff *s) +{ + LstNode *ln = Lst_Member(l, s); + + if (ln != NULL) { + Lst_Remove(l, ln); + s->refCount--; + } +} + +/*- + *----------------------------------------------------------------------- + * SuffInsert -- + * Insert the suffix into the list keeping the list ordered by suffix + * numbers. + * + * Results: + * None + * + * Side Effects: + * The reference count of the suffix is incremented + *----------------------------------------------------------------------- + */ +static void +SuffInsert(Lst *l, Suff *s) +{ + LstNode *ln; /* current element in l we're examining */ + Suff *s2; /* the suffix descriptor in this element */ + + s2 = NULL; + for (ln = Lst_First(l); ln != NULL; ln = Lst_Succ(ln)) { + s2 = Lst_Datum(ln); + if (s2->sNum >= s->sNum) + break; + } + if (s2 == NULL) { + DEBUGF(SUFF, ("inserting an empty list?...")); + } + + DEBUGF(SUFF, ("inserting %s(%d)...", s->name, s->sNum)); + if (ln == NULL) { + DEBUGF(SUFF, ("at end of list\n")); + Lst_AtEnd(l, s); + s->refCount++; + Lst_AtEnd(&s->ref, l); + } else if (s2->sNum != s->sNum) { + DEBUGF(SUFF, ("before %s(%d)\n", s2->name, s2->sNum)); + Lst_Insert(l, ln, s); + s->refCount++; + Lst_AtEnd(&s->ref, l); + } else { + DEBUGF(SUFF, ("already there\n")); + } +} + +/*- + *----------------------------------------------------------------------- + * Suff_ClearSuffixes -- + * This is gross. Nuke the list of suffixes but keep all transformation + * rules around. The transformation graph is destroyed in this process, + * but we leave the list of rules so when a new graph is formed the rules + * will remain. + * This function is called from the parse module when a + * .SUFFIXES:\n line is encountered. + * + * Results: + * none + * + * Side Effects: + * the sufflist and its graph nodes are destroyed + *----------------------------------------------------------------------- + */ +void +Suff_ClearSuffixes(void) +{ + + Lst_Concat(&suffClean, &sufflist, LST_CONCLINK); + + sNum = 1; + suffNull = emptySuff; + /* + * Clear suffNull's children list (the other suffixes are built new, but + * suffNull is used as is). + * NOFREE is used because all suffixes are are on the suffClean list. + * suffNull should not have parents. + */ + Lst_Destroy(&suffNull->children, NOFREE); +} + +/*- + *----------------------------------------------------------------------- + * SuffParseTransform -- + * Parse a transformation string to find its two component suffixes. + * + * Results: + * TRUE if the string is a valid transformation and FALSE otherwise. + * + * Side Effects: + * The passed pointers are overwritten. + * + *----------------------------------------------------------------------- + */ +static Boolean +SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr) +{ + LstNode *srcLn; /* element in suffix list of trans source*/ + Suff *src; /* Source of transformation */ + char *str2; /* Extra pointer (maybe target suffix) */ + LstNode *singleLn; /* element in suffix list of any suffix + * that exactly matches str */ + Suff *single = NULL; /* Source of possible transformation to + * null suffix */ + + singleLn = NULL; + + /* + * Loop looking first for a suffix that matches the start of the + * string and then for one that exactly matches the rest of it. If + * we can find two that meet these criteria, we've successfully + * parsed the string. + */ + srcLn = Lst_First(&sufflist); + for (;;) { + /* advance to next possible suffix */ + while (srcLn != NULL) { + src = Lst_Datum(srcLn); + if (strncmp(str, src->name, strlen(src->name)) == 0) + break; + srcLn = LST_NEXT(srcLn); + } + + if (srcLn == NULL) { + /* + * Ran out of source suffixes -- no such rule + */ + if (singleLn != NULL) { + /* + * Not so fast Mr. Smith! There was a suffix + * that encompassed the entire string, so we + * assume it was a transformation to the null + * suffix (thank you POSIX). We still prefer to + * find a double rule over a singleton, hence we + * leave this check until the end. + * + * XXX: Use emptySuff over suffNull? + */ + *srcPtr = single; + *targPtr = suffNull; + return (TRUE); + } + return (FALSE); + } + str2 = str + src->nameLen; + if (*str2 == '\0') { + single = src; + singleLn = srcLn; + } else { + + *targPtr = SuffSuffFind(str2); + if (*targPtr != NULL) { + *srcPtr = src; + return (TRUE); + } + } + /* next one */ + srcLn = LST_NEXT(srcLn); + } +} + +/*- + *----------------------------------------------------------------------- + * Suff_IsTransform -- + * Return TRUE if the given string is a transformation rule + * + * + * Results: + * TRUE if the string is a concatenation of two known suffixes. + * FALSE otherwise + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +Boolean +Suff_IsTransform(char *str) +{ + Suff *src, *targ; + + return (SuffParseTransform(str, &src, &targ)); +} + +/*- + *----------------------------------------------------------------------- + * Suff_AddTransform -- + * Add the transformation rule described by the line to the + * list of rules and place the transformation itself in the graph + * + * Results: + * The node created for the transformation in the transforms list + * + * Side Effects: + * The node is placed on the end of the transforms Lst and links are + * made between the two suffixes mentioned in the target name + *----------------------------------------------------------------------- + */ +GNode * +Suff_AddTransform(char *line) +{ + GNode *gn; /* GNode of transformation rule */ + Suff *s; /* source suffix */ + Suff *t; /* target suffix */ + + s = t = NULL; /* silence gcc */ + gn = SuffTransFind(line); + if (gn == NULL) { + /* + * Make a new graph node for the transformation. + * It will be filled in by the Parse module. + */ + gn = Targ_NewGN(line); + Lst_AtEnd(&transforms, gn); + } else { + /* + * New specification for transformation rule. Just nuke the + * old list of commands so they can be filled in again... + * We don't actually free the commands themselves, because a + * given command can be attached to several different + * transformations. + */ + Lst_Destroy(&gn->commands, NOFREE); + Lst_Destroy(&gn->children, NOFREE); + } + + gn->type = OP_TRANSFORM; + + SuffParseTransform(line, &s, &t); + + /* + * link the two together in the proper relationship and order + */ + DEBUGF(SUFF, ("defining transformation from `%s' to `%s'\n", + s->name, t->name)); + SuffInsert(&t->children, s); + SuffInsert(&s->parents, t); + + return (gn); +} + +/*- + *----------------------------------------------------------------------- + * Suff_EndTransform -- + * Handle the finish of a transformation definition, removing the + * transformation from the graph if it has neither commands nor + * sources. This is called from the Parse module at the end of + * a dependency block. + * + * Side Effects: + * If the node has no commands or children, the children and parents + * lists of the affected suffices are altered. + * + *----------------------------------------------------------------------- + */ +void +Suff_EndTransform(const GNode *gn) +{ + Suff *s, *t; + + if (!Lst_IsEmpty(&gn->commands) || !Lst_IsEmpty(&gn->children)) { + DEBUGF(SUFF, ("transformation %s complete\n", gn->name)); + return; + } + + /* + * SuffParseTransform() may fail for special rules which are not + * actual transformation rules (e.g., .DEFAULT). + */ + if (!SuffParseTransform(gn->name, &s, &t)) + return; + + DEBUGF(SUFF, ("deleting transformation from `%s' to `%s'\n", + s->name, t->name)); + + /* + * Remove the source from the target's children list. We check + * for a NULL return to handle a beanhead saying something like + * .c.o .c.o: + * + * We'll be called twice when the next target is seen, but .c + * and .o are only linked once... + */ + SuffRemove(&t->children, s); + + /* + * Remove the target from the source's parents list + */ + SuffRemove(&s->parents, t); +} + +/*- + *----------------------------------------------------------------------- + * SuffRebuildGraph -- + * Called from Suff_AddSuffix via LST_FOREACH to search through the + * list of existing transformation rules and rebuild the transformation + * graph when it has been destroyed by Suff_ClearSuffixes. If the + * given rule is a transformation involving this suffix and another, + * existing suffix, the proper relationship is established between + * the two. + * + * Side Effects: + * The appropriate links will be made between this suffix and + * others if transformation rules exist for it. + * + *----------------------------------------------------------------------- + */ +static void +SuffRebuildGraph(const GNode *transform, Suff *s) +{ + char *cp; + Suff *s2 = NULL; + + /* + * First see if it is a transformation from this suffix. + */ + if (strncmp(transform->name, s->name, strlen(s->name)) == 0) { + cp = transform->name + strlen(s->name); + + if (cp[0] == '\0') /* null rule */ + s2 = suffNull; + else + s2 = SuffSuffFind(cp); + if (s2 != NULL) { + /* + * Found target. Link in and return, since it can't be + * anything else. + */ + SuffInsert(&s2->children, s); + SuffInsert(&s->parents, s2); + return; + } + } + + /* + * Not from, maybe to? + */ + cp = SuffSuffIsSuffix(s, transform->name); + if (cp != NULL) { + /* + * Null-terminate the source suffix in order to find it. + */ + cp[1] = '\0'; + s2 = SuffSuffFind(transform->name); + + /* + * Replace the start of the target suffix + */ + cp[1] = s->name[0]; + if (s2 != NULL) { + /* + * Found it -- establish the proper relationship + */ + SuffInsert(&s->children, s2); + SuffInsert(&s2->parents, s); + } + } +} + +/*- + *----------------------------------------------------------------------- + * Suff_AddSuffix -- + * Add the suffix in string to the end of the list of known suffixes. + * Should we restructure the suffix graph? Make doesn't... + * + * Results: + * None + * + * Side Effects: + * A GNode is created for the suffix and a Suff structure is created and + * added to the suffixes list unless the suffix was already known. + *----------------------------------------------------------------------- + */ +void +Suff_AddSuffix(char *str) +{ + Suff *s; /* new suffix descriptor */ + LstNode *ln; + + if (SuffSuffFind(str) != NULL) + /* + * Already known + */ + return; + + s = emalloc(sizeof(Suff)); + + s->name = estrdup(str); + s->nameLen = strlen(s->name); + TAILQ_INIT(&s->searchPath); + Lst_Init(&s->children); + Lst_Init(&s->parents); + Lst_Init(&s->ref); + s->sNum = sNum++; + s->flags = 0; + s->refCount = 0; + + Lst_AtEnd(&sufflist, s); + + /* + * Look for any existing transformations from or to this suffix. + * XXX: Only do this after a Suff_ClearSuffixes? + */ + LST_FOREACH(ln, &transforms) + SuffRebuildGraph(Lst_Datum(ln), s); +} + +/*- + *----------------------------------------------------------------------- + * Suff_GetPath -- + * Return the search path for the given suffix, if it's defined. + * + * Results: + * The searchPath for the desired suffix or NULL if the suffix isn't + * defined. + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +struct Path * +Suff_GetPath(char *sname) +{ + Suff *s; + + s = SuffSuffFind(sname); + if (s == NULL) + return (NULL); + return (&s->searchPath); +} + +/*- + *----------------------------------------------------------------------- + * Suff_DoPaths -- + * Extend the search paths for all suffixes to include the default + * search path. + * + * Results: + * None. + * + * Side Effects: + * The searchPath field of all the suffixes is extended by the + * directories in dirSearchPath. If paths were specified for the + * ".h" suffix, the directories are stuffed into a global variable + * called ".INCLUDES" with each directory preceded by a -I. The same + * is done for the ".a" suffix, except the variable is called + * ".LIBS" and the flag is -L. + *----------------------------------------------------------------------- + */ +void +Suff_DoPaths(void) +{ + Suff *s; + LstNode *ln; + char *ptr; + struct Path inIncludes; /* Cumulative .INCLUDES path */ + struct Path inLibs; /* Cumulative .LIBS path */ + + TAILQ_INIT(&inIncludes); + TAILQ_INIT(&inLibs); + + for (ln = Lst_First(&sufflist); ln != NULL; ln = Lst_Succ(ln)) { + s = Lst_Datum(ln); +#ifdef INCLUDES + if (s->flags & SUFF_INCLUDE) { + Path_Concat(&inIncludes, &s->searchPath); + } +#endif /* INCLUDES */ +#ifdef LIBRARIES + if (s->flags & SUFF_LIBRARY) { + Path_Concat(&inLibs, &s->searchPath); + } +#endif /* LIBRARIES */ + Path_Concat(&s->searchPath, &dirSearchPath); + } + + ptr = Path_MakeFlags("-I", &inIncludes); + Var_SetGlobal(".INCLUDES", ptr); + free(ptr); + + ptr = Path_MakeFlags("-L", &inLibs); + Var_SetGlobal(".LIBS", ptr); + free(ptr); + + Path_Clear(&inIncludes); + Path_Clear(&inLibs); +} + +/*- + *----------------------------------------------------------------------- + * Suff_AddInclude -- + * Add the given suffix as a type of file which gets included. + * Called from the parse module when a .INCLUDES line is parsed. + * The suffix must have already been defined. + * + * Results: + * None. + * + * Side Effects: + * The SUFF_INCLUDE bit is set in the suffix's flags field + * + *----------------------------------------------------------------------- + */ +void +Suff_AddInclude(char *sname) +{ + Suff *s; + + if ((s = SuffSuffFind(sname)) != NULL) + s->flags |= SUFF_INCLUDE; +} + +/*- + *----------------------------------------------------------------------- + * Suff_AddLib -- + * Add the given suffix as a type of file which is a library. + * Called from the parse module when parsing a .LIBS line. The + * suffix must have been defined via .SUFFIXES before this is + * called. + * + * Results: + * None. + * + * Side Effects: + * The SUFF_LIBRARY bit is set in the suffix's flags field + * + *----------------------------------------------------------------------- + */ +void +Suff_AddLib(char *sname) +{ + Suff *s; + + if ((s = SuffSuffFind(sname)) != NULL) + s->flags |= SUFF_LIBRARY; +} + +/* + * Create a new Src structure + */ +static Src * +SuffSrcCreate(char *file, char *prefix, Suff *suff, Src *parent, GNode *node) +{ + Src *s; + + s = emalloc(sizeof(*s)); + s->file = file; + s->pref = prefix; + s->suff = suff; + s->parent = parent; + s->node = node; + s->children = 0; + +#ifdef DEBUG_SRC + Lst_Init(&s->cp); +#endif + + return (s); +} + + /********** Implicit Source Search Functions *********/ + +/*- + *----------------------------------------------------------------------- + * SuffAddLevel -- + * Add all the children of targ as Src structures to the given list: + * Add a suffix as a Src structure to the given list with its parent + * being the given Src structure. If the suffix is the null suffix, + * the prefix is used unaltered as the file name in the Src structure. + * + * Results: + * None + * + * Side Effects: + * Lots of structures are created and added to the list + *----------------------------------------------------------------------- + */ +static void +SuffAddLevel(Lst *l, Src *targ) +{ + LstNode *ln; + Suff *suff; + Src *s2; +#ifdef DEBUG_SRC + const LstNode *ln1; +#endif + + LST_FOREACH(ln, &targ->suff->children) { + suff = Lst_Datum(ln); + + if ((suff->flags & SUFF_NULL) && *suff->name != '\0') { + /* + * If the suffix has been marked as the NULL suffix, + * also create a Src structure for a file with no suffix + * attached. Two birds, and all that... + */ + s2 = SuffSrcCreate(estrdup(targ->pref), targ->pref, + suff, targ, NULL); + suff->refCount++; + targ->children += 1; + Lst_AtEnd(l, s2); +#ifdef DEBUG_SRC + Lst_AtEnd(&targ->cp, s2); + printf("1 add %p %p to %p:", targ, s2, l); + LST_FOREACH(ln1, l) + printf("%p ", (const void *)Lst_Datum(ln1)); + printf("\n"); +#endif + } + s2 = SuffSrcCreate(str_concat(targ->pref, suff->name, 0), + targ->pref, suff, targ, NULL); + suff->refCount++; + targ->children += 1; + Lst_AtEnd(l, s2); +#ifdef DEBUG_SRC + Lst_AtEnd(&targ->cp, s2); + printf("2 add %p %p to %p:", targ, s2, l); + LST_FOREACH(ln1, l) + printf("%p ", (const void *)Lst_Datum(ln1)); + printf("\n"); +#endif + } +} + +/*- + *---------------------------------------------------------------------- + * SuffRemoveSrc -- + * Free all src structures in list that don't have a reference count + * XXX this actually frees only the first of these. + * + * Results: + * True if a src was removed + * + * Side Effects: + * The memory is free'd. + *---------------------------------------------------------------------- + */ +static int +SuffRemoveSrc(Lst *l) +{ + LstNode *ln, *ln1; + Src *s; + int t = 0; + +#ifdef DEBUG_SRC + printf("cleaning %lx: ", (unsigned long) l); + LST_FOREACH(ln, l) + printf("%p ", (const void *)Lst_Datum(ln)); + printf("\n"); +#endif + + for (ln = Lst_First(l); ln != NULL; ln = ln1) { + ln1 = Lst_Succ(ln); + + s = (Src *)Lst_Datum(ln); + if (s->children == 0) { + free(s->file); + if (!s->parent) + free(s->pref); + else { +#ifdef DEBUG_SRC + LstNode *ln = Lst_Member(&s->parent->cp, s); + if (ln != NULL) + Lst_Remove(&s->parent->cp, ln); +#endif + --s->parent->children; + } +#ifdef DEBUG_SRC + printf("free: [l=%p] p=%p %d\n", l, s, s->children); + Lst_Destroy(&s->cp, NOFREE); +#endif + Lst_Remove(l, ln); + free(s); + t |= 1; + return (TRUE); + } +#ifdef DEBUG_SRC + else { + const LstNode *tln; + + printf("keep: [l=%p] p=%p %d: ", l, s, s->children); + LST_FOREACH(tln, &s->cp) + printf("%p ", (const void *)Lst_Datum(tln)); + printf("\n"); + } +#endif + } + + return (t); +} + +/*- + *----------------------------------------------------------------------- + * SuffFindThem -- + * Find the first existing file/target in the list srcs + * + * Results: + * The lowest structure in the chain of transformations + * + * Side Effects: + * None + *----------------------------------------------------------------------- + */ +static Src * +SuffFindThem(Lst *srcs, Lst *slst) +{ + Src *s; /* current Src */ + Src *rs; /* returned Src */ + char *ptr; + + rs = NULL; + + while (!Lst_IsEmpty (srcs)) { + s = Lst_DeQueue(srcs); + + DEBUGF(SUFF, ("\ttrying %s...", s->file)); + + /* + * A file is considered to exist if either a node exists in the + * graph for it or the file actually exists. + */ + if (Targ_FindNode(s->file, TARG_NOCREATE) != NULL) { +#ifdef DEBUG_SRC + printf("remove %p from %p\n", s, srcs); +#endif + rs = s; + break; + } + + if ((ptr = Path_FindFile(s->file, + &s->suff->searchPath)) != NULL) { + rs = s; +#ifdef DEBUG_SRC + printf("remove %p from %p\n", s, srcs); +#endif + free(ptr); + break; + } + + DEBUGF(SUFF, ("not there\n")); + + SuffAddLevel(srcs, s); + Lst_AtEnd(slst, s); + } + + if (rs) { + DEBUGF(SUFF, ("got it\n")); + } + return (rs); +} + +/*- + *----------------------------------------------------------------------- + * SuffFindCmds -- + * See if any of the children of the target in the Src structure is + * one from which the target can be transformed. If there is one, + * a Src structure is put together for it and returned. + * + * Results: + * The Src structure of the "winning" child, or NULL if no such beast. + * + * Side Effects: + * A Src structure may be allocated. + * + *----------------------------------------------------------------------- + */ +static Src * +SuffFindCmds(Src *targ, Lst *slst) +{ + LstNode *ln; /* General-purpose list node */ + GNode *t; /* Target GNode */ + GNode *s; /* Source GNode */ + int prefLen;/* The length of the defined prefix */ + Suff *suff; /* Suffix on matching beastie */ + Src *ret; /* Return value */ + char *cp; + + t = targ->node; + prefLen = strlen(targ->pref); + + for (ln = Lst_First(&t->children); ln != NULL; ln = Lst_Succ(ln)) { + s = Lst_Datum(ln); + + cp = strrchr(s->name, '/'); + if (cp == NULL) { + cp = s->name; + } else { + cp++; + } + if (strncmp(cp, targ->pref, prefLen) == 0) { + /* + * The node matches the prefix ok, see if it has + * a known suffix. + */ + suff = SuffSuffFind(&cp[prefLen]); + if (suff != NULL) { + /* + * It even has a known suffix, see if there's + * a transformation defined between the node's + * suffix and the target's suffix. + * + * XXX: Handle multi-stage transformations + * here, too. + */ + if (Lst_Member(&suff->parents, + targ->suff) != NULL) { + /* + * Hot Damn! Create a new Src structure + * to describe this transformation + * (making sure to duplicate the + * source node's name so Suff_FindDeps + * can free it again (ick)), and return + * the new structure. + */ + ret = SuffSrcCreate(estrdup(s->name), + targ->pref, suff, targ, s); + suff->refCount++; + targ->children += 1; +#ifdef DEBUG_SRC + printf("3 add %p %p\n", &targ, ret); + Lst_AtEnd(&targ->cp, ret); +#endif + Lst_AtEnd(slst, ret); + DEBUGF(SUFF, ("\tusing existing source " + "%s\n", s->name)); + return (ret); + } + } + } + } + return (NULL); +} + +/*- + * The child node contains variable references. Expand them and return + * a list of expansions. + */ +static void +SuffExpandVariables(GNode *parent, GNode *child, Lst *members) +{ + Buffer *buf; + char *cp; + char *start; + + Lst_Init(members); + + DEBUGF(SUFF, ("Expanding \"%s\"...", child->name)); + buf = Var_Subst(child->name, parent, TRUE); + cp = Buf_Data(buf); + + if (child->type & OP_ARCHV) { + /* + * Node was an archive(member) target, so we + * want to call on the Arch module to find the + * nodes for us, expanding variables in the + * parent's context. + */ + Arch_ParseArchive(&cp, members, parent); + Buf_Destroy(buf, TRUE); + return; + } + /* + * Break the result into a vector of strings whose nodes we can find, + * then add those nodes to the members list. Unfortunately, we can't use + * brk_string b/c it doesn't understand about variable specifications + * with spaces in them... XXX + */ + for (start = cp; *start == ' ' || *start == '\t'; start++) + ; + + for (cp = start; *cp != '\0'; cp++) { + if (*cp == ' ' || *cp == '\t') { + /* + * White-space -- terminate element, find the node, + * add it, skip any further spaces. + */ + *cp++ = '\0'; + Lst_AtEnd(members, Targ_FindNode(start, TARG_CREATE)); + + while (*cp == ' ' || *cp == '\t') { + cp++; + } + /* + * Adjust cp for increment at + * start of loop, but set start + * to first non-space. + */ + start = cp--; + + } else if (*cp == '$') { + /* + * Start of a variable spec -- contact variable module + * to find the end so we can skip over it. + */ + char *junk; + size_t len = 0; + Boolean doFree; + + junk = Var_Parse(cp, parent, TRUE, &len, &doFree); + if (junk != var_Error) { + cp += len - 1; + } + if (doFree) { + free(junk); + } + + } else if (*cp == '\\' && *cp != '\0') { + /* + * Escaped something -- skip over it + */ + cp++; + } + } + + if (cp != start) { + /* + * Stuff left over -- add it to the + * list too + */ + Lst_AtEnd(members, Targ_FindNode(start, TARG_CREATE)); + } + + Buf_Destroy(buf, TRUE); +} + +/*- + * The child node contains wildcards. Expand them and return a list of + * expansions. + */ +static void +SuffExpandWildcards(GNode *child, Lst *members) +{ + char *cp; + Lst exp; /* List of expansions */ + LstNode *ln; + struct Path *path; /* Search path along which to expand */ + + Lst_Init(members); + + /* + * Find a path along which to expand the word. + * + * If the word has a known suffix, use that path. + * If it has no known suffix and we're allowed to use the null + * suffix, use its path. + * Else use the default system search path. + */ + LST_FOREACH(ln, &sufflist) { + if (SuffSuffIsSuffix(Lst_Datum(ln), child->name) != NULL) + break; + } + + DEBUGF(SUFF, ("Wildcard expanding \"%s\"...", child->name)); + + if (ln != NULL) { + Suff *s = Lst_Datum(ln); + + DEBUGF(SUFF, ("suffix is \"%s\"...", s->name)); + path = &s->searchPath; + } else { + /* + * Use default search path + */ + path = &dirSearchPath; + } + + /* + * Expand the word along the chosen path + */ + Lst_Init(&exp); + Path_Expand(child->name, path, &exp); + + while (!Lst_IsEmpty(&exp)) { + /* + * Fetch next expansion off the list and find its GNode + */ + cp = Lst_DeQueue(&exp); + + DEBUGF(SUFF, ("%s...", cp)); + Lst_AtEnd(members, Targ_FindNode(cp, TARG_CREATE)); + } +} + +/*- + *----------------------------------------------------------------------- + * SuffExpandChildren -- + * Expand the names of any children of a given node that contain + * variable invocations or file wildcards into actual targets. + * + * Results: + * == 0 (continue) + * + * Side Effects: + * The expanded node is removed from the parent's list of children, + * and the parent's unmade counter is decremented, but other nodes + * may be added. + * + *----------------------------------------------------------------------- + */ +static void +SuffExpandChildren(GNode *parent, LstNode *current) +{ + GNode *cchild; /* current child */ + GNode *gn; + LstNode *prev; /* node after which to append new source */ + Lst members; /* expanded nodes */ + + if (current == NULL) { + /* start from begin of parent's children list */ + current = Lst_First(&parent->children); + } + + while (current != NULL) { + cchild = Lst_Datum(current); + + /* + * First do variable expansion -- this takes precedence over + * wildcard expansion. If the result contains wildcards, they'll + * be gotten to later since the resulting words are tacked + * instead of the current child onto the children list. + * + * XXXHB what if cchild contains lib.a(t1.o t2.o t3.o) but + * no $? + */ + if (strchr(cchild->name, '$') != NULL) { + SuffExpandVariables(parent, cchild, &members); + + } else if (Dir_HasWildcards(cchild->name)) { + SuffExpandWildcards(cchild, &members); + + } else { + /* nothing special just advance to next child */ + current = LST_NEXT(current); + continue; + } + + /* + * New nodes effectively take the place of the child, + * so place them after the child + */ + prev = current; + + /* + * Add all new elements to the parent node if they aren't + * already children of it. + */ + while(!Lst_IsEmpty(&members)) { + gn = Lst_DeQueue(&members); + + DEBUGF(SUFF, ("%s...", gn->name)); + if (Lst_Member(&parent->children, gn) == NULL) { + Lst_Append(&parent->children, prev, gn); + prev = Lst_Succ(prev); + Lst_AtEnd(&gn->parents, parent); + parent->unmade++; + } + } + + /* + * Now the source is expanded, remove it from the list + * of children to keep it from being processed. + * Advance to the next child. + */ + prev = current; + current = LST_NEXT(current); + + parent->unmade--; + Lst_Remove(&parent->children, prev); + DEBUGF(SUFF, ("\n")); + } +} + +/*- + *----------------------------------------------------------------------- + * SuffApplyTransform -- + * Apply a transformation rule, given the source and target nodes + * and suffixes. + * + * Results: + * TRUE if successful, FALSE if not. + * + * Side Effects: + * The source and target are linked and the commands from the + * transformation are added to the target node's commands list. + * All attributes but OP_DEPMASK and OP_TRANSFORM are applied + * to the target. The target also inherits all the sources for + * the transformation rule. + * + *----------------------------------------------------------------------- + */ +static Boolean +SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s) +{ + LstNode *ln; /* General node */ + char *tname; /* Name of transformation rule */ + GNode *gn; /* Node for same */ + + if (Lst_Member(&tGn->children, sGn) == NULL) { + /* + * Not already linked, so form the proper links between the + * target and source. + */ + Lst_AtEnd(&tGn->children, sGn); + Lst_AtEnd(&sGn->parents, tGn); + tGn->unmade += 1; + } + + if ((sGn->type & OP_OPMASK) == OP_DOUBLEDEP) { + /* + * When a :: node is used as the implied source of a node, + * we have to link all its cohorts in as sources as well. Only + * the initial sGn gets the target in its iParents list, however + * as that will be sufficient to get the .IMPSRC variable set + * for tGn + */ + for (ln = Lst_First(&sGn->cohorts); ln != NULL; + ln = Lst_Succ(ln)) { + gn = Lst_Datum(ln); + + if (Lst_Member(&tGn->children, gn) == NULL) { + /* + * Not already linked, so form the proper + * links between the target and source. + */ + Lst_AtEnd(&tGn->children, gn); + Lst_AtEnd(&gn->parents, tGn); + tGn->unmade += 1; + } + } + } + /* + * Locate the transformation rule itself + */ + tname = str_concat(s->name, t->name, 0); + gn = SuffTransFind(tname); + free(tname); + + if (gn == NULL) { + /* + * Not really such a transformation rule (can happen when we're + * called to link an OP_MEMBER and OP_ARCHV node), so return + * FALSE. + */ + return (FALSE); + } + + DEBUGF(SUFF, ("\tapplying %s -> %s to \"%s\"\n", + s->name, t->name, tGn->name)); + + /* + * Record last child for expansion purposes + */ + ln = Lst_Last(&tGn->children); + + /* + * Pass the buck to Make_HandleUse to apply the rule + */ + Make_HandleUse(gn, tGn); + + /* + * Deal with wildcards and variables in any acquired sources + */ + ln = Lst_Succ(ln); + if (ln != NULL) { + SuffExpandChildren(tGn, ln); + } + + /* + * Keep track of another parent to which this beast is transformed so + * the .IMPSRC variable can be set correctly for the parent. + */ + Lst_AtEnd(&sGn->iParents, tGn); + + return (TRUE); +} + + +/*- + *----------------------------------------------------------------------- + * SuffFindArchiveDeps -- + * Locate dependencies for an OP_ARCHV node. + * + * Results: + * None + * + * Side Effects: + * Same as Suff_FindDeps + * + *----------------------------------------------------------------------- + */ +static void +SuffFindArchiveDeps(GNode *gn, Lst *slst) +{ + char *eoarch; /* End of archive portion */ + char *eoname; /* End of member portion */ + char *name; /* Start of member's name */ + GNode *mem; /* Node for member */ + Suff *ms; /* Suffix descriptor for member */ + + static const char *copy[] = { + TARGET, /* Must be first */ + PREFIX, /* Must be second */ + }; + + /* + * The node is an archive(member) pair. so we must find a + * suffix for both of them. + */ + eoarch = strchr(gn->name, '('); + eoname = strchr(eoarch, ')'); + + *eoname = '\0'; /* Nuke parentheses during suffix search */ + *eoarch = '\0'; /* So a suffix can be found */ + + name = eoarch + 1; + + /* + * To simplify things, call Suff_FindDeps recursively on the member now, + * so we can simply compare the member's .PREFIX and .TARGET variables + * to locate its suffix. This allows us to figure out the suffix to + * use for the archive without having to do a quadratic search over the + * suffix list, backtracking for each one... + */ + mem = Targ_FindNode(name, TARG_CREATE); + SuffFindDeps(mem, slst); + + /* + * Create the link between the two nodes right off + */ + if (Lst_Member(&gn->children, mem) == NULL) { + Lst_AtEnd(&gn->children, mem); + Lst_AtEnd(&mem->parents, gn); + gn->unmade += 1; + } + + /* + * Copy in the variables from the member node to this one. + */ + Var_Set(copy[1], Var_Value(copy[1], mem), gn); + Var_Set(copy[0], Var_Value(copy[0], mem), gn); + + ms = mem->suffix; + if (ms == NULL) { + /* + * Didn't know what it was -- use .NULL suffix if not in + * make mode + */ + DEBUGF(SUFF, ("using null suffix\n")); + ms = suffNull; + } + + /* + * Set the other two local variables required for this target. + */ + Var_Set(MEMBER, name, gn); + Var_Set(ARCHIVE, gn->name, gn); + + if (ms != NULL) { + /* + * Member has a known suffix, so look for a transformation rule + * from it to a possible suffix of the archive. Rather than + * searching through the entire list, we just look at suffixes + * to which the member's suffix may be transformed... + */ + LstNode *ln; + + /* + * Use first matching suffix... + */ + LST_FOREACH(ln, &ms->parents) { + if (SuffSuffIsSuffix(Lst_Datum(ln), gn->name) != NULL) + break; + } + + if (ln != NULL) { + /* + * Got one -- apply it + */ + if (!SuffApplyTransform(gn, mem, Lst_Datum(ln), ms)) { + DEBUGF(SUFF, ("\tNo transformation from " + "%s -> %s\n", ms->name, + ((Suff *)Lst_Datum(ln))->name)); + } + } + } + + /* + * Replace the opening and closing parens now we've no need + * of the separate pieces. + */ + *eoarch = '('; + *eoname = ')'; + + /* + * Pretend gn appeared to the left of a dependency operator so + * the user needn't provide a transformation from the member to the + * archive. + */ + if (OP_NOP(gn->type)) { + gn->type |= OP_DEPENDS; + } + + /* + * Flag the member as such so we remember to look in the archive for + * its modification time. + */ + mem->type |= OP_MEMBER; +} + +/*- + *----------------------------------------------------------------------- + * SuffFindNormalDeps -- + * Locate implicit dependencies for regular targets. + * + * Results: + * None. + * + * Side Effects: + * Same as Suff_FindDeps... + * + *----------------------------------------------------------------------- + */ +static void +SuffFindNormalDeps(GNode *gn, Lst *slst) +{ + char *eoname; /* End of name */ + char *sopref; /* Start of prefix */ + LstNode *ln; /* Next suffix node to check */ + Lst srcs; /* List of sources at which to look */ + Lst targs; /* List of targets to which things can be + * transformed. They all have the same file, + * but different suff and pref fields */ + Src *bottom; /* Start of found transformation path */ + Src *src; /* General Src pointer */ + char *pref; /* Prefix to use */ + Src *targ; /* General Src target pointer */ + + eoname = gn->name + strlen(gn->name); + sopref = gn->name; + + /* + * Begin at the beginning... + */ + ln = Lst_First(&sufflist); + Lst_Init(&srcs); + Lst_Init(&targs); + + /* + * We're caught in a catch-22 here. On the one hand, we want to use any + * transformation implied by the target's sources, but we can't examine + * the sources until we've expanded any variables/wildcards they may + * hold, and we can't do that until we've set up the target's local + * variables and we can't do that until we know what the proper suffix + * for the target is (in case there are two suffixes one of which is a + * suffix of the other) and we can't know that until we've found its + * implied source, which we may not want to use if there's an existing + * source that implies a different transformation. + * + * In an attempt to get around this, which may not work all the time, + * but should work most of the time, we look for implied sources first, + * checking transformations to all possible suffixes of the target, + * use what we find to set the target's local variables, expand the + * children, then look for any overriding transformations they imply. + * Should we find one, we discard the one we found before. + */ + + while (ln != NULL) { + /* + * Look for next possible suffix... + */ + while (ln != NULL) { + if (SuffSuffIsSuffix(Lst_Datum(ln), gn->name) != NULL) + break; + ln = LST_NEXT(ln); + } + + if (ln != NULL) { + int prefLen; /* Length of the prefix */ + Src *target; + + /* + * Allocate a Src structure to which things can be + * transformed + */ + target = SuffSrcCreate(estrdup(gn->name), NULL, + Lst_Datum(ln), NULL, gn); + target->suff->refCount++; + + /* + * Allocate room for the prefix, whose end is found + * by subtracting the length of the suffix from + * the end of the name. + */ + prefLen = (eoname - target->suff->nameLen) - sopref; + assert(prefLen >= 0); + target->pref = emalloc(prefLen + 1); + memcpy(target->pref, sopref, prefLen); + target->pref[prefLen] = '\0'; + + /* + * Add nodes from which the target can be made + */ + SuffAddLevel(&srcs, target); + + /* + * Record the target so we can nuke it + */ + Lst_AtEnd(&targs, target); + + /* + * Search from this suffix's successor... + */ + ln = Lst_Succ(ln); + } + } + + /* + * Handle target of unknown suffix... + */ + if (Lst_IsEmpty(&targs) && suffNull != NULL) { + DEBUGF(SUFF, ("\tNo known suffix on %s. Using .NULL suffix\n", + gn->name)); + + targ = SuffSrcCreate(estrdup(gn->name), estrdup(sopref), + suffNull, NULL, gn); + targ->suff->refCount++; + + /* + * Only use the default suffix rules if we don't have commands + * or dependencies defined for this gnode + */ + if (Lst_IsEmpty(&gn->commands) && Lst_IsEmpty(&gn->children)) + SuffAddLevel(&srcs, targ); + else { + DEBUGF(SUFF, ("not ")); + } + + DEBUGF(SUFF, ("adding suffix rules\n")); + + Lst_AtEnd(&targs, targ); + } + + /* + * Using the list of possible sources built up from the target + * suffix(es), try and find an existing file/target that matches. + */ + bottom = SuffFindThem(&srcs, slst); + + if (bottom == NULL) { + /* + * No known transformations -- use the first suffix found for + * setting the local variables. + */ + if (!Lst_IsEmpty(&targs)) { + targ = Lst_Datum(Lst_First(&targs)); + } else { + targ = NULL; + } + } else { + /* + * Work up the transformation path to find the suffix of the + * target to which the transformation was made. + */ + for (targ = bottom; targ->parent != NULL; targ = targ->parent) + continue; + } + + /* + * The .TARGET variable we always set to be the name at this point, + * since it's only set to the path if the thing is only a source and + * if it's only a source, it doesn't matter what we put here as far + * as expanding sources is concerned, since it has none... + */ + Var_Set(TARGET, gn->name, gn); + + pref = (targ != NULL) ? targ->pref : gn->name; + Var_Set(PREFIX, pref, gn); + + /* + * Now we've got the important local variables set, expand any sources + * that still contain variables or wildcards in their names. + */ + SuffExpandChildren(gn, NULL); + + if (targ == NULL) { + DEBUGF(SUFF, ("\tNo valid suffix on %s\n", gn->name)); + + sfnd_abort: + /* + * Deal with finding the thing on the default search path if the + * node is only a source (not on the lhs of a dependency + * operator or [XXX] it has neither children or commands). + */ + if (OP_NOP(gn->type) || (Lst_IsEmpty(&gn->children) && + Lst_IsEmpty(&gn->commands))) { + gn->path = Path_FindFile(gn->name, + (targ == NULL ? &dirSearchPath : + &targ->suff->searchPath)); + if (gn->path != NULL) { + char *ptr; + Var_Set(TARGET, gn->path, gn); + + if (targ != NULL) { + /* + * Suffix known for the thing -- trim + * the suffix off the path to form the + * proper .PREFIX variable. + */ + int savep = strlen(gn->path) - + targ->suff->nameLen; + char savec; + + if (gn->suffix) + gn->suffix->refCount--; + gn->suffix = targ->suff; + gn->suffix->refCount++; + + savec = gn->path[savep]; + gn->path[savep] = '\0'; + + if ((ptr = strrchr(gn->path, '/')) != NULL) + ptr++; + else + ptr = gn->path; + + Var_Set(PREFIX, ptr, gn); + + gn->path[savep] = savec; + } else { + /* + * The .PREFIX gets the full path if + * the target has no known suffix. + */ + if (gn->suffix) + gn->suffix->refCount--; + gn->suffix = NULL; + + if ((ptr = strrchr(gn->path, '/')) != NULL) + ptr++; + else + ptr = gn->path; + + Var_Set(PREFIX, ptr, gn); + } + } + } else { + /* + * Not appropriate to search for the thing -- set the + * path to be the name so Dir_MTime won't go + * grovelling for it. + */ + if (gn->suffix) + gn->suffix->refCount--; + gn->suffix = (targ == NULL) ? NULL : targ->suff; + if (gn->suffix) + gn->suffix->refCount++; + free(gn->path); + gn->path = estrdup(gn->name); + } + + goto sfnd_return; + } + + /* + * If the suffix indicates that the target is a library, mark that in + * the node's type field. + */ + if (targ->suff->flags & SUFF_LIBRARY) { + gn->type |= OP_LIB; + } + + /* + * Check for overriding transformation rule implied by sources + */ + if (!Lst_IsEmpty(&gn->children)) { + src = SuffFindCmds(targ, slst); + + if (src != NULL) { + /* + * Free up all the Src structures in the + * transformation path up to, but not including, + * the parent node. + */ + while (bottom && bottom->parent != NULL) { + if (Lst_Member(slst, bottom) == NULL) { + Lst_AtEnd(slst, bottom); + } + bottom = bottom->parent; + } + bottom = src; + } + } + + if (bottom == NULL) { + /* + * No idea from where it can come -- return now. + */ + goto sfnd_abort; + } + + /* + * We now have a list of Src structures headed by 'bottom' and linked + * via their 'parent' pointers. What we do next is create links between + * source and target nodes (which may or may not have been created) + * and set the necessary local variables in each target. The + * commands for each target are set from the commands of the + * transformation rule used to get from the src suffix to the targ + * suffix. Note that this causes the commands list of the original + * node, gn, to be replaced by the commands of the final + * transformation rule. Also, the unmade field of gn is incremented. + * Etc. + */ + if (bottom->node == NULL) { + bottom->node = Targ_FindNode(bottom->file, TARG_CREATE); + } + + for (src = bottom; src->parent != NULL; src = src->parent) { + targ = src->parent; + + if (src->node->suffix) + src->node->suffix->refCount--; + src->node->suffix = src->suff; + src->node->suffix->refCount++; + + if (targ->node == NULL) { + targ->node = Targ_FindNode(targ->file, TARG_CREATE); + } + + SuffApplyTransform(targ->node, src->node, + targ->suff, src->suff); + + if (targ->node != gn) { + /* + * Finish off the dependency-search process for any + * nodes between bottom and gn (no point in questing + * around the filesystem for their implicit source + * when it's already known). Note that the node can't + * have any sources that need expanding, since + * SuffFindThem will stop on an existing + * node, so all we need to do is set the standard and + * System V variables. + */ + targ->node->type |= OP_DEPS_FOUND; + + Var_Set(PREFIX, targ->pref, targ->node); + Var_Set(TARGET, targ->node->name, targ->node); + } + } + + if (gn->suffix) + gn->suffix->refCount--; + gn->suffix = src->suff; + gn->suffix->refCount++; + + /* + * So Dir_MTime doesn't go questing for it... + */ + free(gn->path); + gn->path = estrdup(gn->name); + + /* + * Nuke the transformation path and the Src structures left over in the + * two lists. + */ + sfnd_return: + if (bottom) + if (Lst_Member(slst, bottom) == NULL) + Lst_AtEnd(slst, bottom); + + while (SuffRemoveSrc(&srcs) || SuffRemoveSrc(&targs)) + continue; + + Lst_Concat(slst, &srcs, LST_CONCLINK); + Lst_Concat(slst, &targs, LST_CONCLINK); +} + +/*- + *----------------------------------------------------------------------- + * Suff_FindDeps -- + * Find implicit sources for the target described by the graph node + * gn + * + * Results: + * Nothing. + * + * Side Effects: + * Nodes are added to the graph below the passed-in node. The nodes + * are marked to have their IMPSRC variable filled in. The + * PREFIX variable is set for the given node and all its + * implied children. + * + * Notes: + * The path found by this target is the shortest path in the + * transformation graph, which may pass through non-existent targets, + * to an existing target. The search continues on all paths from the + * root suffix until a file is found. I.e. if there's a path + * .o -> .c -> .l -> .l,v from the root and the .l,v file exists but + * the .c and .l files don't, the search will branch out in + * all directions from .o and again from all the nodes on the + * next level until the .l,v node is encountered. + * + *----------------------------------------------------------------------- + */ +void +Suff_FindDeps(GNode *gn) +{ + + SuffFindDeps(gn, &srclist); + while (SuffRemoveSrc(&srclist)) + continue; +} + + +static void +SuffFindDeps(GNode *gn, Lst *slst) +{ + + if (gn->type & OP_DEPS_FOUND) { + /* + * If dependencies already found, no need to do it again... + */ + return; + } else { + gn->type |= OP_DEPS_FOUND; + } + + DEBUGF(SUFF, ("SuffFindDeps (%s)\n", gn->name)); + + if (gn->type & OP_ARCHV) { + SuffFindArchiveDeps(gn, slst); + + } else if (gn->type & OP_LIB) { + /* + * If the node is a library, it is the arch module's job to find + * it and set the TARGET variable accordingly. We merely provide + * the search path, assuming all libraries end in ".a" (if the + * suffix hasn't been defined, there's nothing we can do for it, + * so we just set the TARGET variable to the node's name in order + * to give it a value). + */ + Suff *s; + + s = SuffSuffFind(LIBSUFF); + if (gn->suffix) + gn->suffix->refCount--; + if (s != NULL) { + gn->suffix = s; + gn->suffix->refCount++; + Arch_FindLib(gn, &s->searchPath); + } else { + gn->suffix = NULL; + Var_Set(TARGET, gn->name, gn); + } + + /* + * Because a library (-lfoo) target doesn't follow the standard + * filesystem conventions, we don't set the regular variables for + * the thing. .PREFIX is simply made empty... + */ + Var_Set(PREFIX, "", gn); + + } else { + SuffFindNormalDeps(gn, slst); + } +} + +/*- + *----------------------------------------------------------------------- + * Suff_SetNull -- + * Define which suffix is the null suffix. + * + * Results: + * None. + * + * Side Effects: + * 'suffNull' is altered. + * + * Notes: + * Need to handle the changing of the null suffix gracefully so the + * old transformation rules don't just go away. + * + *----------------------------------------------------------------------- + */ +void +Suff_SetNull(char *name) +{ + Suff *s; + + if ((s = SuffSuffFind(name)) == NULL) { + Parse_Error(PARSE_WARNING, "Desired null suffix %s " + "not defined.", name); + return; + } + + if (suffNull != NULL) { + suffNull->flags &= ~SUFF_NULL; + } + s->flags |= SUFF_NULL; + + /* + * XXX: Here's where the transformation mangling + * would take place + */ + suffNull = s; +} + +/*- + *----------------------------------------------------------------------- + * Suff_Init -- + * Initialize suffixes module + * + * Results: + * None + * + * Side Effects: + * Many + *----------------------------------------------------------------------- + */ +void +Suff_Init(void) +{ + + sNum = 0; + /* + * Create null suffix for single-suffix rules (POSIX). The thing doesn't + * actually go on the suffix list or everyone will think that's its + * suffix. + */ + emptySuff = suffNull = emalloc(sizeof(Suff)); + + suffNull->name = estrdup(""); + suffNull->nameLen = 0; + TAILQ_INIT(&suffNull->searchPath); + Path_Concat(&suffNull->searchPath, &dirSearchPath); + Lst_Init(&suffNull->children); + Lst_Init(&suffNull->parents); + Lst_Init(&suffNull->ref); + suffNull->sNum = sNum++; + suffNull->flags = SUFF_NULL; + suffNull->refCount = 1; +} + +/********************* DEBUGGING FUNCTIONS **********************/ + +void +Suff_PrintAll(void) +{ + const LstNode *ln; + const LstNode *tln; + const GNode *gn; + const Suff *s; + + static const struct flag2str suff_flags[] = { + { SUFF_INCLUDE, "INCLUDE" }, + { SUFF_LIBRARY, "LIBRARY" }, + { SUFF_NULL, "NULL" }, + { 0, NULL } + }; + + printf("#*** Suffixes:\n"); + LST_FOREACH(ln, &sufflist) { + s = Lst_Datum(ln); + printf("# `%s' [%d] ", s->name, s->refCount); + + if (s->flags != 0) { + printf(" "); + print_flags(stdout, suff_flags, s->flags, 1); + } + + printf("\n#\tTo: "); + LST_FOREACH(tln, &s->parents) + printf("`%s' ", ((const Suff *)Lst_Datum(tln))->name); + + printf("\n#\tFrom: "); + LST_FOREACH(tln, &s->children) + printf("`%s' ", ((const Suff *)Lst_Datum(tln))->name); + + printf("\n#\tSearch Path: "); + Path_Print(&s->searchPath); + + printf("\n"); + } + + printf("#*** Transformations:\n"); + LST_FOREACH(ln, &transforms) { + gn = Lst_Datum(ln); + printf("%-16s: ", gn->name); + Targ_PrintType(gn->type); + printf("\n"); + LST_FOREACH(tln, &gn->commands) + printf("\t%s\n", (const char *)Lst_Datum(tln)); + printf("\n"); + } +} |
