suff.c revision 1.164 1 1.164 rillig /* $NetBSD: suff.c,v 1.164 2020/09/25 17:14:32 rillig Exp $ */
2 1.8 christos
3 1.1 cgd /*
4 1.13 christos * Copyright (c) 1988, 1989, 1990, 1993
5 1.13 christos * The Regents of the University of California. All rights reserved.
6 1.42 agc *
7 1.42 agc * This code is derived from software contributed to Berkeley by
8 1.42 agc * Adam de Boor.
9 1.42 agc *
10 1.42 agc * Redistribution and use in source and binary forms, with or without
11 1.42 agc * modification, are permitted provided that the following conditions
12 1.42 agc * are met:
13 1.42 agc * 1. Redistributions of source code must retain the above copyright
14 1.42 agc * notice, this list of conditions and the following disclaimer.
15 1.42 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.42 agc * notice, this list of conditions and the following disclaimer in the
17 1.42 agc * documentation and/or other materials provided with the distribution.
18 1.42 agc * 3. Neither the name of the University nor the names of its contributors
19 1.42 agc * may be used to endorse or promote products derived from this software
20 1.42 agc * without specific prior written permission.
21 1.42 agc *
22 1.42 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.42 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.42 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.42 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.42 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.42 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.42 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.42 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.42 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.42 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.42 agc * SUCH DAMAGE.
33 1.42 agc */
34 1.42 agc
35 1.42 agc /*
36 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
37 1.1 cgd * All rights reserved.
38 1.1 cgd *
39 1.1 cgd * This code is derived from software contributed to Berkeley by
40 1.1 cgd * Adam de Boor.
41 1.1 cgd *
42 1.1 cgd * Redistribution and use in source and binary forms, with or without
43 1.1 cgd * modification, are permitted provided that the following conditions
44 1.1 cgd * are met:
45 1.1 cgd * 1. Redistributions of source code must retain the above copyright
46 1.1 cgd * notice, this list of conditions and the following disclaimer.
47 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
48 1.1 cgd * notice, this list of conditions and the following disclaimer in the
49 1.1 cgd * documentation and/or other materials provided with the distribution.
50 1.1 cgd * 3. All advertising materials mentioning features or use of this software
51 1.1 cgd * must display the following acknowledgement:
52 1.1 cgd * This product includes software developed by the University of
53 1.1 cgd * California, Berkeley and its contributors.
54 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
55 1.1 cgd * may be used to endorse or promote products derived from this software
56 1.1 cgd * without specific prior written permission.
57 1.1 cgd *
58 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 1.1 cgd * SUCH DAMAGE.
69 1.1 cgd */
70 1.1 cgd
71 1.1 cgd /*-
72 1.1 cgd * suff.c --
73 1.1 cgd * Functions to maintain suffix lists and find implicit dependents
74 1.1 cgd * using suffix transformation rules
75 1.1 cgd *
76 1.1 cgd * Interface:
77 1.1 cgd * Suff_Init Initialize all things to do with suffixes.
78 1.1 cgd *
79 1.73 joerg * Suff_End Cleanup the module
80 1.6 jtc *
81 1.1 cgd * Suff_DoPaths This function is used to make life easier
82 1.1 cgd * when searching for a file according to its
83 1.1 cgd * suffix. It takes the global search path,
84 1.1 cgd * as defined using the .PATH: target, and appends
85 1.1 cgd * its directories to the path of each of the
86 1.1 cgd * defined suffixes, as specified using
87 1.1 cgd * .PATH<suffix>: targets. In addition, all
88 1.1 cgd * directories given for suffixes labeled as
89 1.1 cgd * include files or libraries, using the .INCLUDES
90 1.1 cgd * or .LIBS targets, are played with using
91 1.1 cgd * Dir_MakeFlags to create the .INCLUDES and
92 1.1 cgd * .LIBS global variables.
93 1.1 cgd *
94 1.1 cgd * Suff_ClearSuffixes Clear out all the suffixes and defined
95 1.1 cgd * transformations.
96 1.1 cgd *
97 1.1 cgd * Suff_IsTransform Return TRUE if the passed string is the lhs
98 1.1 cgd * of a transformation rule.
99 1.1 cgd *
100 1.1 cgd * Suff_AddSuffix Add the passed string as another known suffix.
101 1.1 cgd *
102 1.1 cgd * Suff_GetPath Return the search path for the given suffix.
103 1.1 cgd *
104 1.1 cgd * Suff_AddInclude Mark the given suffix as denoting an include
105 1.1 cgd * file.
106 1.1 cgd *
107 1.1 cgd * Suff_AddLib Mark the given suffix as denoting a library.
108 1.1 cgd *
109 1.1 cgd * Suff_AddTransform Add another transformation to the suffix
110 1.1 cgd * graph. Returns GNode suitable for framing, I
111 1.1 cgd * mean, tacking commands, attributes, etc. on.
112 1.1 cgd *
113 1.73 joerg * Suff_SetNull Define the suffix to consider the suffix of
114 1.73 joerg * any file that doesn't have a known one.
115 1.73 joerg *
116 1.1 cgd * Suff_FindDeps Find implicit sources for and the location of
117 1.1 cgd * a target based on its suffix. Returns the
118 1.65 dsl * bottom-most node added to the graph or NULL
119 1.1 cgd * if the target had no implicit sources.
120 1.47 christos *
121 1.47 christos * Suff_FindPath Return the appropriate path to search in
122 1.47 christos * order to find the node.
123 1.1 cgd */
124 1.1 cgd
125 1.1 cgd #include "make.h"
126 1.4 cgd #include "dir.h"
127 1.1 cgd
128 1.155 rillig /* "@(#)suff.c 8.4 (Berkeley) 3/21/94" */
129 1.164 rillig MAKE_RCSID("$NetBSD: suff.c,v 1.164 2020/09/25 17:14:32 rillig Exp $");
130 1.155 rillig
131 1.140 rillig #define SUFF_DEBUG0(fmt) \
132 1.140 rillig if (!DEBUG(SUFF)) (void) 0; else fprintf(debug_file, fmt)
133 1.140 rillig
134 1.140 rillig #define SUFF_DEBUG1(fmt, arg1) \
135 1.140 rillig if (!DEBUG(SUFF)) (void) 0; else fprintf(debug_file, fmt, arg1)
136 1.140 rillig
137 1.140 rillig #define SUFF_DEBUG2(fmt, arg1, arg2) \
138 1.140 rillig if (!DEBUG(SUFF)) (void) 0; else fprintf(debug_file, fmt, arg1, arg2)
139 1.140 rillig
140 1.140 rillig #define SUFF_DEBUG3(fmt, arg1, arg2, arg3) \
141 1.140 rillig if (!DEBUG(SUFF)) (void) 0; else fprintf(debug_file, fmt, arg1, arg2, arg3)
142 1.140 rillig
143 1.157 rillig typedef List SuffList;
144 1.157 rillig typedef ListNode SuffListNode;
145 1.157 rillig
146 1.157 rillig typedef List SrcList;
147 1.157 rillig typedef ListNode SrcListNode;
148 1.157 rillig
149 1.157 rillig static SuffList *sufflist; /* List of suffixes */
150 1.73 joerg #ifdef CLEANUP
151 1.157 rillig static SuffList *suffClean; /* List of suffixes to be cleaned */
152 1.73 joerg #endif
153 1.157 rillig static SrcList *srclist; /* List of sources */
154 1.157 rillig static GNodeList *transforms; /* List of transformation rules */
155 1.1 cgd
156 1.73 joerg static int sNum = 0; /* Counter for assigning suffix numbers */
157 1.1 cgd
158 1.96 rillig typedef enum {
159 1.96 rillig SUFF_INCLUDE = 0x01, /* One which is #include'd */
160 1.96 rillig SUFF_LIBRARY = 0x02, /* One which contains a library */
161 1.96 rillig SUFF_NULL = 0x04 /* The empty suffix */
162 1.122 rillig /* XXX: Why is SUFF_NULL needed? Wouldn't nameLen == 0 mean the same? */
163 1.96 rillig } SuffFlags;
164 1.96 rillig
165 1.122 rillig ENUM_FLAGS_RTTI_3(SuffFlags,
166 1.122 rillig SUFF_INCLUDE, SUFF_LIBRARY, SUFF_NULL);
167 1.122 rillig
168 1.157 rillig typedef List SuffListList;
169 1.157 rillig
170 1.1 cgd /*
171 1.1 cgd * Structure describing an individual suffix.
172 1.1 cgd */
173 1.96 rillig typedef struct Suff {
174 1.122 rillig char *name; /* The suffix itself, such as ".c" */
175 1.164 rillig size_t nameLen; /* Length of the name, to avoid strlen calls */
176 1.96 rillig SuffFlags flags; /* Type of suffix */
177 1.157 rillig SearchPath *searchPath; /* The path along which files of this suffix
178 1.1 cgd * may be found */
179 1.73 joerg int sNum; /* The suffix number */
180 1.73 joerg int refCount; /* Reference count of list membership */
181 1.157 rillig SuffList *parents; /* Suffixes we have a transformation to */
182 1.157 rillig SuffList *children; /* Suffixes we have a transformation from */
183 1.157 rillig SuffListList *ref; /* Lists in which this suffix is referenced */
184 1.1 cgd } Suff;
185 1.1 cgd
186 1.1 cgd /*
187 1.1 cgd * Structure used in the search for implied sources.
188 1.1 cgd */
189 1.163 rillig typedef struct Src {
190 1.1 cgd char *file; /* The file to look for */
191 1.73 joerg char *pref; /* Prefix from which file was formed */
192 1.1 cgd Suff *suff; /* The suffix on the file */
193 1.163 rillig struct Src *parent; /* The Src for which this is a source */
194 1.1 cgd GNode *node; /* The node describing the file */
195 1.73 joerg int children; /* Count of existing children (so we don't free
196 1.73 joerg * this thing too early or never nuke it) */
197 1.73 joerg #ifdef DEBUG_SRC
198 1.157 rillig SrcList *cp; /* Debug; children list */
199 1.73 joerg #endif
200 1.1 cgd } Src;
201 1.1 cgd
202 1.73 joerg /*
203 1.73 joerg * A structure for passing more than one argument to the Lst-library-invoked
204 1.73 joerg * function...
205 1.73 joerg */
206 1.161 rillig typedef struct LstSrc {
207 1.157 rillig SrcList *l;
208 1.157 rillig Src *s;
209 1.71 christos } LstSrc;
210 1.71 christos
211 1.161 rillig /* XXX: Name doesn't match content */
212 1.161 rillig typedef struct GNodeSuff {
213 1.147 rillig GNode **gnp;
214 1.73 joerg Suff *s;
215 1.73 joerg Boolean r;
216 1.73 joerg } GNodeSuff;
217 1.73 joerg
218 1.73 joerg static Suff *suffNull; /* The NULL suffix for this run */
219 1.73 joerg static Suff *emptySuff; /* The empty suffix required for POSIX
220 1.73 joerg * single-suffix transformation rules */
221 1.1 cgd
222 1.4 cgd
223 1.160 rillig static void SuffFindDeps(GNode *, SrcList *);
224 1.157 rillig static void SuffExpandWildcards(GNodeListNode *, GNode *);
225 1.4 cgd
226 1.73 joerg /*************** Lst Predicates ****************/
227 1.1 cgd /*-
228 1.1 cgd *-----------------------------------------------------------------------
229 1.1 cgd * SuffStrIsPrefix --
230 1.1 cgd * See if pref is a prefix of str.
231 1.1 cgd *
232 1.39 wiz * Input:
233 1.39 wiz * pref possible prefix
234 1.39 wiz * str string to check
235 1.39 wiz *
236 1.1 cgd * Results:
237 1.1 cgd * NULL if it ain't, pointer to character in str after prefix if so
238 1.1 cgd *
239 1.1 cgd * Side Effects:
240 1.1 cgd * None
241 1.1 cgd *-----------------------------------------------------------------------
242 1.1 cgd */
243 1.67 dsl static const char *
244 1.67 dsl SuffStrIsPrefix(const char *pref, const char *str)
245 1.1 cgd {
246 1.1 cgd while (*str && *pref == *str) {
247 1.1 cgd pref++;
248 1.1 cgd str++;
249 1.1 cgd }
250 1.1 cgd
251 1.88 rillig return *pref ? NULL : str;
252 1.1 cgd }
253 1.1 cgd
254 1.161 rillig struct SuffSuffGetSuffixArgs {
255 1.164 rillig size_t name_len;
256 1.164 rillig char *name_end;
257 1.161 rillig };
258 1.128 rillig
259 1.129 rillig /* See if suff is a suffix of str. str->ename should point to THE END
260 1.129 rillig * of the string to check. (THE END == the null byte)
261 1.1 cgd *
262 1.39 wiz * Input:
263 1.39 wiz * s possible suffix
264 1.129 rillig * str string to examine
265 1.39 wiz *
266 1.1 cgd * Results:
267 1.1 cgd * NULL if it ain't, pointer to character in str before suffix if
268 1.1 cgd * it is.
269 1.1 cgd */
270 1.1 cgd static char *
271 1.161 rillig SuffSuffGetSuffix(const Suff *s, const struct SuffSuffGetSuffixArgs *str)
272 1.1 cgd {
273 1.39 wiz char *p1; /* Pointer into suffix name */
274 1.39 wiz char *p2; /* Pointer into string being examined */
275 1.1 cgd
276 1.164 rillig if (str->name_len < s->nameLen)
277 1.22 itohy return NULL; /* this string is shorter than the suffix */
278 1.22 itohy
279 1.1 cgd p1 = s->name + s->nameLen;
280 1.164 rillig p2 = str->name_end;
281 1.1 cgd
282 1.1 cgd while (p1 >= s->name && *p1 == *p2) {
283 1.1 cgd p1--;
284 1.1 cgd p2--;
285 1.1 cgd }
286 1.1 cgd
287 1.88 rillig return p1 == s->name - 1 ? p2 : NULL;
288 1.1 cgd }
289 1.1 cgd
290 1.130 rillig /* Predicate form of SuffSuffGetSuffix, for Lst_Find. */
291 1.129 rillig static Boolean
292 1.129 rillig SuffSuffIsSuffix(const void *s, const void *sd)
293 1.1 cgd {
294 1.129 rillig return SuffSuffGetSuffix(s, sd) != NULL;
295 1.1 cgd }
296 1.1 cgd
297 1.162 rillig static SuffListNode *
298 1.162 rillig FindSuffByName(const char *name)
299 1.1 cgd {
300 1.162 rillig SuffListNode *ln;
301 1.162 rillig
302 1.162 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next) {
303 1.162 rillig const Suff *suff = ln->datum;
304 1.162 rillig if (strcmp(suff->name, name) == 0)
305 1.162 rillig return ln;
306 1.162 rillig }
307 1.162 rillig return NULL;
308 1.1 cgd }
309 1.1 cgd
310 1.129 rillig /* See if the suffix name is a prefix of the string. Care must be taken when
311 1.129 rillig * using this to search for transformations and what-not, since there could
312 1.129 rillig * well be two suffixes, one of which is a prefix of the other... */
313 1.129 rillig static Boolean
314 1.73 joerg SuffSuffIsPrefix(const void *s, const void *str)
315 1.1 cgd {
316 1.129 rillig return SuffStrIsPrefix(((const Suff *)s)->name, str) != NULL;
317 1.1 cgd }
318 1.1 cgd
319 1.129 rillig /* See if the graph node has the desired name. */
320 1.129 rillig static Boolean
321 1.129 rillig SuffGNHasName(const void *gn, const void *desiredName)
322 1.1 cgd {
323 1.129 rillig return strcmp(((const GNode *)gn)->name, desiredName) == 0;
324 1.1 cgd }
325 1.1 cgd
326 1.93 rillig /*********** Maintenance Functions ************/
327 1.73 joerg
328 1.73 joerg static void
329 1.73 joerg SuffUnRef(void *lp, void *sp)
330 1.73 joerg {
331 1.157 rillig SuffList *l = lp;
332 1.73 joerg
333 1.157 rillig SuffListNode *ln = Lst_FindDatum(l, sp);
334 1.73 joerg if (ln != NULL) {
335 1.125 rillig Lst_Remove(l, ln);
336 1.73 joerg ((Suff *)sp)->refCount--;
337 1.73 joerg }
338 1.73 joerg }
339 1.73 joerg
340 1.134 rillig /* Free up all memory associated with the given suffix structure. */
341 1.73 joerg static void
342 1.73 joerg SuffFree(void *sp)
343 1.71 christos {
344 1.134 rillig Suff *s = (Suff *)sp;
345 1.6 jtc
346 1.73 joerg if (s == suffNull)
347 1.73 joerg suffNull = NULL;
348 1.6 jtc
349 1.73 joerg if (s == emptySuff)
350 1.73 joerg emptySuff = NULL;
351 1.6 jtc
352 1.73 joerg #ifdef notdef
353 1.73 joerg /* We don't delete suffixes in order, so we cannot use this */
354 1.73 joerg if (s->refCount)
355 1.73 joerg Punt("Internal error deleting suffix `%s' with refcount = %d", s->name,
356 1.73 joerg s->refCount);
357 1.73 joerg #endif
358 1.6 jtc
359 1.125 rillig Lst_Free(s->ref);
360 1.125 rillig Lst_Free(s->children);
361 1.125 rillig Lst_Free(s->parents);
362 1.125 rillig Lst_Destroy(s->searchPath, Dir_Destroy);
363 1.19 christos
364 1.73 joerg free(s->name);
365 1.73 joerg free(s);
366 1.1 cgd }
367 1.1 cgd
368 1.134 rillig /* Remove the suffix from the list, and free if it is otherwise unused. */
369 1.6 jtc static void
370 1.157 rillig SuffRemove(SuffList *l, Suff *s)
371 1.6 jtc {
372 1.73 joerg SuffUnRef(l, s);
373 1.73 joerg if (s->refCount == 0) {
374 1.73 joerg SuffUnRef(sufflist, s);
375 1.73 joerg SuffFree(s);
376 1.73 joerg }
377 1.6 jtc }
378 1.101 rillig
379 1.134 rillig /* Insert the suffix into the list keeping the list ordered by suffix numbers.
380 1.1 cgd *
381 1.39 wiz * Input:
382 1.73 joerg * l the list where in s should be inserted
383 1.73 joerg * s the suffix to insert
384 1.1 cgd */
385 1.73 joerg static void
386 1.157 rillig SuffInsert(SuffList *l, Suff *s)
387 1.1 cgd {
388 1.157 rillig SuffListNode *ln; /* current element in l we're examining */
389 1.73 joerg Suff *s2 = NULL; /* the suffix descriptor in this element */
390 1.71 christos
391 1.125 rillig Lst_Open(l);
392 1.125 rillig while ((ln = Lst_Next(l)) != NULL) {
393 1.138 rillig s2 = LstNode_Datum(ln);
394 1.73 joerg if (s2->sNum >= s->sNum) {
395 1.73 joerg break;
396 1.73 joerg }
397 1.73 joerg }
398 1.125 rillig Lst_Close(l);
399 1.71 christos
400 1.140 rillig SUFF_DEBUG2("inserting %s(%d)...", s->name, s->sNum);
401 1.140 rillig
402 1.73 joerg if (ln == NULL) {
403 1.140 rillig SUFF_DEBUG0("at end of list\n");
404 1.125 rillig Lst_Append(l, s);
405 1.73 joerg s->refCount++;
406 1.125 rillig Lst_Append(s->ref, l);
407 1.73 joerg } else if (s2->sNum != s->sNum) {
408 1.140 rillig SUFF_DEBUG2("before %s(%d)\n", s2->name, s2->sNum);
409 1.125 rillig Lst_InsertBefore(l, ln, s);
410 1.73 joerg s->refCount++;
411 1.125 rillig Lst_Append(s->ref, l);
412 1.140 rillig } else {
413 1.140 rillig SUFF_DEBUG0("already there\n");
414 1.73 joerg }
415 1.71 christos }
416 1.1 cgd
417 1.117 rillig static Suff *
418 1.117 rillig SuffNew(const char *name)
419 1.117 rillig {
420 1.117 rillig Suff *s = bmake_malloc(sizeof(Suff));
421 1.117 rillig
422 1.117 rillig s->name = bmake_strdup(name);
423 1.117 rillig s->nameLen = strlen(s->name);
424 1.117 rillig s->searchPath = Lst_Init();
425 1.117 rillig s->children = Lst_Init();
426 1.117 rillig s->parents = Lst_Init();
427 1.117 rillig s->ref = Lst_Init();
428 1.117 rillig s->sNum = sNum++;
429 1.117 rillig s->flags = 0;
430 1.117 rillig s->refCount = 1;
431 1.117 rillig
432 1.117 rillig return s;
433 1.117 rillig }
434 1.117 rillig
435 1.134 rillig /* This is gross. Nuke the list of suffixes but keep all transformation
436 1.134 rillig * rules around. The transformation graph is destroyed in this process, but
437 1.134 rillig * we leave the list of rules so when a new graph is formed the rules will
438 1.134 rillig * remain. This function is called from the parse module when a .SUFFIXES:\n
439 1.134 rillig * line is encountered. */
440 1.73 joerg void
441 1.73 joerg Suff_ClearSuffixes(void)
442 1.71 christos {
443 1.73 joerg #ifdef CLEANUP
444 1.125 rillig Lst_MoveAll(suffClean, sufflist);
445 1.73 joerg #endif
446 1.97 rillig sufflist = Lst_Init();
447 1.73 joerg sNum = 0;
448 1.75 sjg if (suffNull)
449 1.75 sjg SuffFree(suffNull);
450 1.117 rillig emptySuff = suffNull = SuffNew("");
451 1.75 sjg
452 1.75 sjg Dir_Concat(suffNull->searchPath, dirSearchPath);
453 1.75 sjg suffNull->flags = SUFF_NULL;
454 1.1 cgd }
455 1.1 cgd
456 1.134 rillig /* Parse a transformation string to find its two component suffixes.
457 1.1 cgd *
458 1.39 wiz * Input:
459 1.73 joerg * str String being parsed
460 1.134 rillig * out_src Place to store source of trans.
461 1.134 rillig * out_targ Place to store target of trans.
462 1.73 joerg *
463 1.73 joerg * Results:
464 1.134 rillig * TRUE if the string is a valid transformation, FALSE otherwise.
465 1.1 cgd */
466 1.73 joerg static Boolean
467 1.134 rillig SuffParseTransform(char *str, Suff **out_src, Suff **out_targ)
468 1.39 wiz {
469 1.157 rillig SuffListNode *srcLn; /* element in suffix list of trans source*/
470 1.157 rillig Suff *src; /* Source of transformation */
471 1.157 rillig SuffListNode *targLn; /* element in suffix list of trans target*/
472 1.157 rillig char *str2; /* Extra pointer (maybe target suffix) */
473 1.157 rillig SuffListNode *singleLn; /* element in suffix list of any suffix
474 1.157 rillig * that exactly matches str */
475 1.157 rillig Suff *single = NULL; /* Source of possible transformation to
476 1.157 rillig * null suffix */
477 1.73 joerg
478 1.73 joerg srcLn = NULL;
479 1.73 joerg singleLn = NULL;
480 1.73 joerg
481 1.73 joerg /*
482 1.73 joerg * Loop looking first for a suffix that matches the start of the
483 1.73 joerg * string and then for one that exactly matches the rest of it. If
484 1.73 joerg * we can find two that meet these criteria, we've successfully
485 1.73 joerg * parsed the string.
486 1.73 joerg */
487 1.73 joerg for (;;) {
488 1.73 joerg if (srcLn == NULL) {
489 1.130 rillig srcLn = Lst_Find(sufflist, SuffSuffIsPrefix, str);
490 1.73 joerg } else {
491 1.131 rillig srcLn = Lst_FindFrom(sufflist, LstNode_Next(srcLn),
492 1.129 rillig SuffSuffIsPrefix, str);
493 1.73 joerg }
494 1.73 joerg if (srcLn == NULL) {
495 1.73 joerg /*
496 1.73 joerg * Ran out of source suffixes -- no such rule
497 1.73 joerg */
498 1.73 joerg if (singleLn != NULL) {
499 1.73 joerg /*
500 1.73 joerg * Not so fast Mr. Smith! There was a suffix that encompassed
501 1.73 joerg * the entire string, so we assume it was a transformation
502 1.73 joerg * to the null suffix (thank you POSIX). We still prefer to
503 1.73 joerg * find a double rule over a singleton, hence we leave this
504 1.73 joerg * check until the end.
505 1.73 joerg *
506 1.73 joerg * XXX: Use emptySuff over suffNull?
507 1.73 joerg */
508 1.134 rillig *out_src = single;
509 1.134 rillig *out_targ = suffNull;
510 1.88 rillig return TRUE;
511 1.73 joerg }
512 1.88 rillig return FALSE;
513 1.73 joerg }
514 1.138 rillig src = LstNode_Datum(srcLn);
515 1.73 joerg str2 = str + src->nameLen;
516 1.73 joerg if (*str2 == '\0') {
517 1.73 joerg single = src;
518 1.73 joerg singleLn = srcLn;
519 1.73 joerg } else {
520 1.162 rillig targLn = FindSuffByName(str2);
521 1.73 joerg if (targLn != NULL) {
522 1.134 rillig *out_src = src;
523 1.138 rillig *out_targ = LstNode_Datum(targLn);
524 1.88 rillig return TRUE;
525 1.73 joerg }
526 1.73 joerg }
527 1.73 joerg }
528 1.1 cgd }
529 1.1 cgd
530 1.134 rillig /* Return TRUE if the given string is a transformation rule, that is, a
531 1.134 rillig * concatenation of two known suffixes. */
532 1.73 joerg Boolean
533 1.73 joerg Suff_IsTransform(char *str)
534 1.1 cgd {
535 1.73 joerg Suff *src, *targ;
536 1.1 cgd
537 1.88 rillig return SuffParseTransform(str, &src, &targ);
538 1.1 cgd }
539 1.1 cgd
540 1.134 rillig /* Add the transformation rule described by the line to the list of rules
541 1.134 rillig * and place the transformation itself in the graph.
542 1.1 cgd *
543 1.134 rillig * The node is placed on the end of the transforms Lst and links are made
544 1.134 rillig * between the two suffixes mentioned in the target name.
545 1.134 rillig
546 1.73 joerg * Input:
547 1.73 joerg * line name of transformation to add
548 1.39 wiz *
549 1.73 joerg * Results:
550 1.73 joerg * The node created for the transformation in the transforms list
551 1.1 cgd */
552 1.73 joerg GNode *
553 1.73 joerg Suff_AddTransform(char *line)
554 1.1 cgd {
555 1.73 joerg GNode *gn; /* GNode of transformation rule */
556 1.73 joerg Suff *s, /* source suffix */
557 1.93 rillig *t; /* target suffix */
558 1.157 rillig GNodeListNode *ln; /* Node for existing transformation */
559 1.142 rillig Boolean ok;
560 1.1 cgd
561 1.130 rillig ln = Lst_Find(transforms, SuffGNHasName, line);
562 1.73 joerg if (ln == NULL) {
563 1.73 joerg /*
564 1.73 joerg * Make a new graph node for the transformation. It will be filled in
565 1.73 joerg * by the Parse module.
566 1.73 joerg */
567 1.73 joerg gn = Targ_NewGN(line);
568 1.125 rillig Lst_Append(transforms, gn);
569 1.73 joerg } else {
570 1.73 joerg /*
571 1.73 joerg * New specification for transformation rule. Just nuke the old list
572 1.73 joerg * of commands so they can be filled in again... We don't actually
573 1.73 joerg * free the commands themselves, because a given command can be
574 1.73 joerg * attached to several different transformations.
575 1.73 joerg */
576 1.138 rillig gn = LstNode_Datum(ln);
577 1.125 rillig Lst_Free(gn->commands);
578 1.125 rillig Lst_Free(gn->children);
579 1.97 rillig gn->commands = Lst_Init();
580 1.97 rillig gn->children = Lst_Init();
581 1.73 joerg }
582 1.1 cgd
583 1.73 joerg gn->type = OP_TRANSFORM;
584 1.1 cgd
585 1.142 rillig ok = SuffParseTransform(line, &s, &t);
586 1.142 rillig assert(ok);
587 1.142 rillig (void)ok;
588 1.1 cgd
589 1.73 joerg /*
590 1.73 joerg * link the two together in the proper relationship and order
591 1.73 joerg */
592 1.140 rillig SUFF_DEBUG2("defining transformation from `%s' to `%s'\n",
593 1.73 joerg s->name, t->name);
594 1.73 joerg SuffInsert(t->children, s);
595 1.73 joerg SuffInsert(s->parents, t);
596 1.1 cgd
597 1.88 rillig return gn;
598 1.1 cgd }
599 1.1 cgd
600 1.134 rillig /* Handle the finish of a transformation definition, removing the
601 1.134 rillig * transformation from the graph if it has neither commands nor sources.
602 1.159 rillig * This is a callback procedure for the Parse module via Lst_ForEachUntil.
603 1.134 rillig *
604 1.134 rillig * If the node has no commands or children, the children and parents lists
605 1.134 rillig * of the affected suffixes are altered.
606 1.71 christos *
607 1.73 joerg * Input:
608 1.150 rillig * gn Node for transformation
609 1.1 cgd */
610 1.150 rillig void
611 1.150 rillig Suff_EndTransform(GNode *gn)
612 1.1 cgd {
613 1.125 rillig if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(gn->cohorts))
614 1.138 rillig gn = LstNode_Datum(Lst_Last(gn->cohorts));
615 1.125 rillig if ((gn->type & OP_TRANSFORM) && Lst_IsEmpty(gn->commands) &&
616 1.125 rillig Lst_IsEmpty(gn->children))
617 1.73 joerg {
618 1.73 joerg Suff *s, *t;
619 1.73 joerg
620 1.73 joerg /*
621 1.73 joerg * SuffParseTransform() may fail for special rules which are not
622 1.73 joerg * actual transformation rules. (e.g. .DEFAULT)
623 1.73 joerg */
624 1.73 joerg if (SuffParseTransform(gn->name, &s, &t)) {
625 1.157 rillig SuffList *p;
626 1.73 joerg
627 1.140 rillig SUFF_DEBUG2("deleting transformation from `%s' to `%s'\n",
628 1.140 rillig s->name, t->name);
629 1.73 joerg
630 1.73 joerg /*
631 1.73 joerg * Store s->parents because s could be deleted in SuffRemove
632 1.73 joerg */
633 1.73 joerg p = s->parents;
634 1.20 christos
635 1.73 joerg /*
636 1.73 joerg * Remove the source from the target's children list. We check for a
637 1.73 joerg * nil return to handle a beanhead saying something like
638 1.73 joerg * .c.o .c.o:
639 1.73 joerg *
640 1.73 joerg * We'll be called twice when the next target is seen, but .c and .o
641 1.73 joerg * are only linked once...
642 1.73 joerg */
643 1.73 joerg SuffRemove(t->children, s);
644 1.1 cgd
645 1.73 joerg /*
646 1.73 joerg * Remove the target from the source's parents list
647 1.73 joerg */
648 1.73 joerg SuffRemove(p, t);
649 1.73 joerg }
650 1.140 rillig } else if (gn->type & OP_TRANSFORM) {
651 1.148 rillig SUFF_DEBUG1("transformation %s complete\n", gn->name);
652 1.1 cgd }
653 1.1 cgd }
654 1.1 cgd
655 1.159 rillig /* Called from Suff_AddSuffix via Lst_ForEachUntil to search through the list of
656 1.134 rillig * existing transformation rules and rebuild the transformation graph when
657 1.134 rillig * it has been destroyed by Suff_ClearSuffixes. If the given rule is a
658 1.134 rillig * transformation involving this suffix and another, existing suffix, the
659 1.134 rillig * proper relationship is established between the two.
660 1.134 rillig *
661 1.134 rillig * The appropriate links will be made between this suffix and others if
662 1.134 rillig * transformation rules exist for it.
663 1.1 cgd *
664 1.39 wiz * Input:
665 1.73 joerg * transformp Transformation to test
666 1.73 joerg * sp Suffix to rebuild
667 1.73 joerg *
668 1.73 joerg * Results:
669 1.159 rillig * 0, so that Lst_ForEachUntil continues
670 1.1 cgd */
671 1.73 joerg static int
672 1.73 joerg SuffRebuildGraph(void *transformp, void *sp)
673 1.6 jtc {
674 1.73 joerg GNode *transform = (GNode *)transformp;
675 1.73 joerg Suff *s = (Suff *)sp;
676 1.73 joerg char *cp;
677 1.73 joerg Suff *s2;
678 1.161 rillig struct SuffSuffGetSuffixArgs sd;
679 1.73 joerg
680 1.73 joerg /*
681 1.73 joerg * First see if it is a transformation from this suffix.
682 1.73 joerg */
683 1.73 joerg cp = UNCONST(SuffStrIsPrefix(s->name, transform->name));
684 1.73 joerg if (cp != NULL) {
685 1.162 rillig SuffListNode *ln = FindSuffByName(cp);
686 1.73 joerg if (ln != NULL) {
687 1.73 joerg /*
688 1.73 joerg * Found target. Link in and return, since it can't be anything
689 1.73 joerg * else.
690 1.73 joerg */
691 1.138 rillig s2 = LstNode_Datum(ln);
692 1.73 joerg SuffInsert(s2->children, s);
693 1.73 joerg SuffInsert(s->parents, s2);
694 1.88 rillig return 0;
695 1.73 joerg }
696 1.73 joerg }
697 1.1 cgd
698 1.73 joerg /*
699 1.73 joerg * Not from, maybe to?
700 1.73 joerg */
701 1.164 rillig sd.name_len = strlen(transform->name);
702 1.164 rillig sd.name_end = transform->name + sd.name_len;
703 1.129 rillig cp = SuffSuffGetSuffix(s, &sd);
704 1.73 joerg if (cp != NULL) {
705 1.157 rillig SuffListNode *ln;
706 1.157 rillig
707 1.73 joerg /*
708 1.73 joerg * Null-terminate the source suffix in order to find it.
709 1.73 joerg */
710 1.73 joerg cp[1] = '\0';
711 1.162 rillig ln = FindSuffByName(transform->name);
712 1.73 joerg /*
713 1.73 joerg * Replace the start of the target suffix
714 1.73 joerg */
715 1.73 joerg cp[1] = s->name[0];
716 1.73 joerg if (ln != NULL) {
717 1.73 joerg /*
718 1.73 joerg * Found it -- establish the proper relationship
719 1.73 joerg */
720 1.138 rillig s2 = LstNode_Datum(ln);
721 1.73 joerg SuffInsert(s->children, s2);
722 1.73 joerg SuffInsert(s2->parents, s);
723 1.73 joerg }
724 1.1 cgd }
725 1.88 rillig return 0;
726 1.71 christos }
727 1.71 christos
728 1.159 rillig /* Called from Suff_AddSuffix via Lst_ForEachUntil to search through the list of
729 1.134 rillig * existing targets and find if any of the existing targets can be turned
730 1.134 rillig * into a transformation rule.
731 1.134 rillig *
732 1.134 rillig * If such a target is found and the target is the current main target, the
733 1.134 rillig * main target is set to NULL and the next target examined (if that exists)
734 1.134 rillig * becomes the main target.
735 1.71 christos *
736 1.73 joerg * Results:
737 1.73 joerg * 1 if a new main target has been selected, 0 otherwise.
738 1.71 christos */
739 1.71 christos static int
740 1.73 joerg SuffScanTargets(void *targetp, void *gsp)
741 1.71 christos {
742 1.73 joerg GNode *target = (GNode *)targetp;
743 1.73 joerg GNodeSuff *gs = (GNodeSuff *)gsp;
744 1.73 joerg Suff *s, *t;
745 1.73 joerg char *ptr;
746 1.73 joerg
747 1.147 rillig if (*gs->gnp == NULL && gs->r && (target->type & OP_NOTARGET) == 0) {
748 1.147 rillig *gs->gnp = target;
749 1.73 joerg Targ_SetMain(target);
750 1.73 joerg return 1;
751 1.73 joerg }
752 1.73 joerg
753 1.108 rillig if (target->type == OP_TRANSFORM)
754 1.73 joerg return 0;
755 1.73 joerg
756 1.73 joerg if ((ptr = strstr(target->name, gs->s->name)) == NULL ||
757 1.73 joerg ptr == target->name)
758 1.73 joerg return 0;
759 1.73 joerg
760 1.73 joerg if (SuffParseTransform(target->name, &s, &t)) {
761 1.147 rillig if (*gs->gnp == target) {
762 1.73 joerg gs->r = TRUE;
763 1.147 rillig *gs->gnp = NULL;
764 1.73 joerg Targ_SetMain(NULL);
765 1.71 christos }
766 1.125 rillig Lst_Free(target->children);
767 1.97 rillig target->children = Lst_Init();
768 1.73 joerg target->type = OP_TRANSFORM;
769 1.73 joerg /*
770 1.73 joerg * link the two together in the proper relationship and order
771 1.73 joerg */
772 1.140 rillig SUFF_DEBUG2("defining transformation from `%s' to `%s'\n",
773 1.140 rillig s->name, t->name);
774 1.73 joerg SuffInsert(t->children, s);
775 1.73 joerg SuffInsert(s->parents, t);
776 1.71 christos }
777 1.14 christos return 0;
778 1.14 christos }
779 1.14 christos
780 1.134 rillig /* Add the suffix to the end of the list of known suffixes.
781 1.134 rillig * Should we restructure the suffix graph? Make doesn't...
782 1.134 rillig *
783 1.134 rillig * A GNode is created for the suffix and a Suff structure is created and
784 1.134 rillig * added to the suffixes list unless the suffix was already known.
785 1.134 rillig * The mainNode passed can be modified if a target mutated into a
786 1.134 rillig * transform and that target happened to be the main target.
787 1.1 cgd *
788 1.39 wiz * Input:
789 1.134 rillig * name the name of the suffix to add
790 1.1 cgd */
791 1.1 cgd void
792 1.147 rillig Suff_AddSuffix(const char *name, GNode **gnp)
793 1.1 cgd {
794 1.73 joerg Suff *s; /* new suffix descriptor */
795 1.157 rillig SuffListNode *ln;
796 1.73 joerg GNodeSuff gs;
797 1.73 joerg
798 1.162 rillig ln = FindSuffByName(name);
799 1.73 joerg if (ln == NULL) {
800 1.148 rillig s = SuffNew(name);
801 1.71 christos
802 1.125 rillig Lst_Append(sufflist, s);
803 1.73 joerg /*
804 1.73 joerg * We also look at our existing targets list to see if adding
805 1.73 joerg * this suffix will make one of our current targets mutate into
806 1.73 joerg * a suffix rule. This is ugly, but other makes treat all targets
807 1.73 joerg * that start with a . as suffix rules.
808 1.73 joerg */
809 1.147 rillig gs.gnp = gnp;
810 1.73 joerg gs.s = s;
811 1.73 joerg gs.r = FALSE;
812 1.159 rillig Lst_ForEachUntil(Targ_List(), SuffScanTargets, &gs);
813 1.73 joerg /*
814 1.73 joerg * Look for any existing transformations from or to this suffix.
815 1.73 joerg * XXX: Only do this after a Suff_ClearSuffixes?
816 1.73 joerg */
817 1.159 rillig Lst_ForEachUntil(transforms, SuffRebuildGraph, s);
818 1.13 christos }
819 1.1 cgd }
820 1.1 cgd
821 1.134 rillig /* Return the search path for the given suffix, or NULL. */
822 1.157 rillig SearchPath *
823 1.39 wiz Suff_GetPath(char *sname)
824 1.1 cgd {
825 1.157 rillig SuffListNode *ln;
826 1.157 rillig Suff *s;
827 1.1 cgd
828 1.162 rillig ln = FindSuffByName(sname);
829 1.73 joerg if (ln == NULL) {
830 1.73 joerg return NULL;
831 1.73 joerg } else {
832 1.138 rillig s = LstNode_Datum(ln);
833 1.88 rillig return s->searchPath;
834 1.73 joerg }
835 1.1 cgd }
836 1.1 cgd
837 1.134 rillig /* Extend the search paths for all suffixes to include the default search
838 1.134 rillig * path.
839 1.1 cgd *
840 1.134 rillig * The searchPath field of all the suffixes is extended by the directories
841 1.134 rillig * in dirSearchPath. If paths were specified for the ".h" suffix, the
842 1.134 rillig * directories are stuffed into a global variable called ".INCLUDES" with
843 1.134 rillig * each directory preceded by a -I. The same is done for the ".a" suffix,
844 1.134 rillig * except the variable is called ".LIBS" and the flag is -L.
845 1.1 cgd */
846 1.1 cgd void
847 1.39 wiz Suff_DoPaths(void)
848 1.1 cgd {
849 1.157 rillig Suff *s;
850 1.157 rillig SuffListNode *ln;
851 1.157 rillig char *ptr;
852 1.157 rillig SearchPath *inIncludes; /* Cumulative .INCLUDES path */
853 1.157 rillig SearchPath *inLibs; /* Cumulative .LIBS path */
854 1.1 cgd
855 1.1 cgd
856 1.97 rillig inIncludes = Lst_Init();
857 1.97 rillig inLibs = Lst_Init();
858 1.1 cgd
859 1.125 rillig Lst_Open(sufflist);
860 1.125 rillig while ((ln = Lst_Next(sufflist)) != NULL) {
861 1.138 rillig s = LstNode_Datum(ln);
862 1.125 rillig if (!Lst_IsEmpty(s->searchPath)) {
863 1.1 cgd #ifdef INCLUDES
864 1.1 cgd if (s->flags & SUFF_INCLUDE) {
865 1.1 cgd Dir_Concat(inIncludes, s->searchPath);
866 1.1 cgd }
867 1.154 rillig #endif
868 1.1 cgd #ifdef LIBRARIES
869 1.1 cgd if (s->flags & SUFF_LIBRARY) {
870 1.1 cgd Dir_Concat(inLibs, s->searchPath);
871 1.1 cgd }
872 1.154 rillig #endif
873 1.1 cgd Dir_Concat(s->searchPath, dirSearchPath);
874 1.1 cgd } else {
875 1.125 rillig Lst_Destroy(s->searchPath, Dir_Destroy);
876 1.125 rillig s->searchPath = Lst_Copy(dirSearchPath, Dir_CopyDir);
877 1.1 cgd }
878 1.1 cgd }
879 1.125 rillig Lst_Close(sufflist);
880 1.1 cgd
881 1.87 rillig Var_Set(".INCLUDES", ptr = Dir_MakeFlags("-I", inIncludes), VAR_GLOBAL);
882 1.6 jtc free(ptr);
883 1.87 rillig Var_Set(".LIBS", ptr = Dir_MakeFlags("-L", inLibs), VAR_GLOBAL);
884 1.6 jtc free(ptr);
885 1.1 cgd
886 1.125 rillig Lst_Destroy(inIncludes, Dir_Destroy);
887 1.125 rillig Lst_Destroy(inLibs, Dir_Destroy);
888 1.1 cgd }
889 1.1 cgd
890 1.134 rillig /* Add the given suffix as a type of file which gets included.
891 1.134 rillig * Called from the parse module when a .INCLUDES line is parsed.
892 1.134 rillig * The suffix must have already been defined.
893 1.134 rillig * The SUFF_INCLUDE bit is set in the suffix's flags field.
894 1.1 cgd *
895 1.39 wiz * Input:
896 1.39 wiz * sname Name of the suffix to mark
897 1.1 cgd */
898 1.1 cgd void
899 1.39 wiz Suff_AddInclude(char *sname)
900 1.1 cgd {
901 1.162 rillig SuffListNode *ln = FindSuffByName(sname);
902 1.65 dsl if (ln != NULL) {
903 1.157 rillig Suff *s = LstNode_Datum(ln);
904 1.1 cgd s->flags |= SUFF_INCLUDE;
905 1.1 cgd }
906 1.1 cgd }
907 1.1 cgd
908 1.134 rillig /* Add the given suffix as a type of file which is a library.
909 1.134 rillig * Called from the parse module when parsing a .LIBS line.
910 1.134 rillig * The suffix must have been defined via .SUFFIXES before this is called.
911 1.134 rillig * The SUFF_LIBRARY bit is set in the suffix's flags field.
912 1.1 cgd *
913 1.39 wiz * Input:
914 1.39 wiz * sname Name of the suffix to mark
915 1.1 cgd */
916 1.1 cgd void
917 1.134 rillig Suff_AddLib(const char *sname)
918 1.1 cgd {
919 1.162 rillig SuffListNode *ln = FindSuffByName(sname);
920 1.65 dsl if (ln != NULL) {
921 1.157 rillig Suff *s = LstNode_Datum(ln);
922 1.1 cgd s->flags |= SUFF_LIBRARY;
923 1.1 cgd }
924 1.1 cgd }
925 1.1 cgd
926 1.93 rillig /********** Implicit Source Search Functions *********/
927 1.1 cgd
928 1.149 rillig #ifdef DEBUG_SRC
929 1.149 rillig static int
930 1.149 rillig PrintAddr(void *a, void *b MAKE_ATTR_UNUSED)
931 1.149 rillig {
932 1.149 rillig printf("%lx ", (unsigned long) a);
933 1.149 rillig return 0;
934 1.149 rillig }
935 1.149 rillig #endif
936 1.149 rillig
937 1.134 rillig /* Add a suffix as a Src structure to the given list with its parent
938 1.134 rillig * being the given Src structure. If the suffix is the null suffix,
939 1.134 rillig * the prefix is used unaltered as the file name in the Src structure.
940 1.1 cgd *
941 1.39 wiz * Input:
942 1.73 joerg * sp suffix for which to create a Src structure
943 1.73 joerg * lsp list and parent for the new Src
944 1.39 wiz *
945 1.1 cgd * Results:
946 1.159 rillig * 0, so that Lst_ForEachUntil continues
947 1.1 cgd */
948 1.1 cgd static int
949 1.73 joerg SuffAddSrc(void *sp, void *lsp)
950 1.1 cgd {
951 1.73 joerg Suff *s = (Suff *)sp;
952 1.73 joerg LstSrc *ls = (LstSrc *)lsp;
953 1.73 joerg Src *s2; /* new Src structure */
954 1.73 joerg Src *targ; /* Target structure */
955 1.1 cgd
956 1.73 joerg targ = ls->s;
957 1.13 christos
958 1.146 rillig if ((s->flags & SUFF_NULL) && s->name[0] != '\0') {
959 1.73 joerg /*
960 1.73 joerg * If the suffix has been marked as the NULL suffix, also create a Src
961 1.73 joerg * structure for a file with no suffix attached. Two birds, and all
962 1.73 joerg * that...
963 1.73 joerg */
964 1.73 joerg s2 = bmake_malloc(sizeof(Src));
965 1.73 joerg s2->file = bmake_strdup(targ->pref);
966 1.73 joerg s2->pref = targ->pref;
967 1.73 joerg s2->parent = targ;
968 1.73 joerg s2->node = NULL;
969 1.73 joerg s2->suff = s;
970 1.73 joerg s->refCount++;
971 1.73 joerg s2->children = 0;
972 1.73 joerg targ->children += 1;
973 1.125 rillig Lst_Append(ls->l, s2);
974 1.73 joerg #ifdef DEBUG_SRC
975 1.97 rillig s2->cp = Lst_Init();
976 1.125 rillig Lst_Append(targ->cp, s2);
977 1.84 dholland fprintf(debug_file, "1 add %p %p to %p:", targ, s2, ls->l);
978 1.159 rillig Lst_ForEachUntil(ls->l, PrintAddr, NULL);
979 1.73 joerg fprintf(debug_file, "\n");
980 1.73 joerg #endif
981 1.1 cgd }
982 1.73 joerg s2 = bmake_malloc(sizeof(Src));
983 1.95 rillig s2->file = str_concat2(targ->pref, s->name);
984 1.73 joerg s2->pref = targ->pref;
985 1.73 joerg s2->parent = targ;
986 1.73 joerg s2->node = NULL;
987 1.73 joerg s2->suff = s;
988 1.73 joerg s->refCount++;
989 1.73 joerg s2->children = 0;
990 1.73 joerg targ->children += 1;
991 1.125 rillig Lst_Append(ls->l, s2);
992 1.6 jtc #ifdef DEBUG_SRC
993 1.97 rillig s2->cp = Lst_Init();
994 1.125 rillig Lst_Append(targ->cp, s2);
995 1.84 dholland fprintf(debug_file, "2 add %p %p to %p:", targ, s2, ls->l);
996 1.159 rillig Lst_ForEachUntil(ls->l, PrintAddr, NULL);
997 1.55 dsl fprintf(debug_file, "\n");
998 1.6 jtc #endif
999 1.1 cgd
1000 1.88 rillig return 0;
1001 1.1 cgd }
1002 1.1 cgd
1003 1.134 rillig /* Add all the children of targ as Src structures to the given list.
1004 1.1 cgd *
1005 1.73 joerg * Input:
1006 1.73 joerg * l list to which to add the new level
1007 1.73 joerg * targ Src structure to use as the parent
1008 1.1 cgd */
1009 1.1 cgd static void
1010 1.157 rillig SuffAddLevel(SrcList *l, Src *targ)
1011 1.1 cgd {
1012 1.73 joerg LstSrc ls;
1013 1.73 joerg
1014 1.73 joerg ls.s = targ;
1015 1.73 joerg ls.l = l;
1016 1.1 cgd
1017 1.159 rillig Lst_ForEachUntil(targ->suff->children, SuffAddSrc, &ls);
1018 1.1 cgd }
1019 1.1 cgd
1020 1.134 rillig /* Free the first Src in the list that doesn't have a reference count.
1021 1.134 rillig * Return whether a Src was removed. */
1022 1.134 rillig static Boolean
1023 1.157 rillig SuffRemoveSrc(SrcList *l)
1024 1.73 joerg {
1025 1.157 rillig SrcListNode *ln;
1026 1.73 joerg Src *s;
1027 1.73 joerg
1028 1.125 rillig Lst_Open(l);
1029 1.100 rillig
1030 1.73 joerg #ifdef DEBUG_SRC
1031 1.73 joerg fprintf(debug_file, "cleaning %lx: ", (unsigned long) l);
1032 1.159 rillig Lst_ForEachUntil(l, PrintAddr, NULL);
1033 1.73 joerg fprintf(debug_file, "\n");
1034 1.73 joerg #endif
1035 1.73 joerg
1036 1.125 rillig while ((ln = Lst_Next(l)) != NULL) {
1037 1.138 rillig s = LstNode_Datum(ln);
1038 1.73 joerg if (s->children == 0) {
1039 1.73 joerg free(s->file);
1040 1.73 joerg if (!s->parent)
1041 1.73 joerg free(s->pref);
1042 1.73 joerg else {
1043 1.73 joerg #ifdef DEBUG_SRC
1044 1.157 rillig SrcListNode *ln2 = Lst_FindDatum(s->parent->cp, s);
1045 1.84 dholland if (ln2 != NULL)
1046 1.125 rillig Lst_Remove(s->parent->cp, ln2);
1047 1.73 joerg #endif
1048 1.73 joerg --s->parent->children;
1049 1.73 joerg }
1050 1.73 joerg #ifdef DEBUG_SRC
1051 1.84 dholland fprintf(debug_file, "free: [l=%p] p=%p %d\n", l, s, s->children);
1052 1.125 rillig Lst_Free(s->cp);
1053 1.73 joerg #endif
1054 1.125 rillig Lst_Remove(l, ln);
1055 1.73 joerg free(s);
1056 1.125 rillig Lst_Close(l);
1057 1.73 joerg return TRUE;
1058 1.73 joerg }
1059 1.73 joerg #ifdef DEBUG_SRC
1060 1.73 joerg else {
1061 1.84 dholland fprintf(debug_file, "keep: [l=%p] p=%p %d: ", l, s, s->children);
1062 1.159 rillig Lst_ForEachUntil(s->cp, PrintAddr, NULL);
1063 1.73 joerg fprintf(debug_file, "\n");
1064 1.73 joerg }
1065 1.73 joerg #endif
1066 1.73 joerg }
1067 1.6 jtc
1068 1.125 rillig Lst_Close(l);
1069 1.6 jtc
1070 1.134 rillig return FALSE;
1071 1.1 cgd }
1072 1.1 cgd
1073 1.134 rillig /* Find the first existing file/target in the list srcs.
1074 1.1 cgd *
1075 1.39 wiz * Input:
1076 1.73 joerg * srcs list of Src structures to search through
1077 1.39 wiz *
1078 1.1 cgd * Results:
1079 1.134 rillig * The lowest structure in the chain of transformations, or NULL.
1080 1.1 cgd */
1081 1.1 cgd static Src *
1082 1.157 rillig SuffFindThem(SrcList *srcs, SrcList *slst)
1083 1.1 cgd {
1084 1.73 joerg Src *s; /* current Src */
1085 1.73 joerg Src *rs; /* returned Src */
1086 1.73 joerg char *ptr;
1087 1.73 joerg
1088 1.73 joerg rs = NULL;
1089 1.1 cgd
1090 1.125 rillig while (!Lst_IsEmpty(srcs)) {
1091 1.125 rillig s = Lst_Dequeue(srcs);
1092 1.1 cgd
1093 1.140 rillig SUFF_DEBUG1("\ttrying %s...", s->file);
1094 1.6 jtc
1095 1.1 cgd /*
1096 1.73 joerg * A file is considered to exist if either a node exists in the
1097 1.73 joerg * graph for it or the file actually exists.
1098 1.1 cgd */
1099 1.73 joerg if (Targ_FindNode(s->file, TARG_NOCREATE) != NULL) {
1100 1.6 jtc #ifdef DEBUG_SRC
1101 1.84 dholland fprintf(debug_file, "remove %p from %p\n", s, srcs);
1102 1.6 jtc #endif
1103 1.73 joerg rs = s;
1104 1.73 joerg break;
1105 1.73 joerg }
1106 1.73 joerg
1107 1.73 joerg if ((ptr = Dir_FindFile(s->file, s->suff->searchPath)) != NULL) {
1108 1.73 joerg rs = s;
1109 1.6 jtc #ifdef DEBUG_SRC
1110 1.84 dholland fprintf(debug_file, "remove %p from %p\n", s, srcs);
1111 1.6 jtc #endif
1112 1.73 joerg free(ptr);
1113 1.1 cgd break;
1114 1.1 cgd }
1115 1.6 jtc
1116 1.140 rillig SUFF_DEBUG0("not there\n");
1117 1.6 jtc
1118 1.73 joerg SuffAddLevel(srcs, s);
1119 1.125 rillig Lst_Append(slst, s);
1120 1.6 jtc }
1121 1.6 jtc
1122 1.140 rillig if (rs) {
1123 1.140 rillig SUFF_DEBUG0("got it\n");
1124 1.73 joerg }
1125 1.88 rillig return rs;
1126 1.1 cgd }
1127 1.1 cgd
1128 1.134 rillig /* See if any of the children of the target in the Src structure is one from
1129 1.134 rillig * which the target can be transformed. If there is one, a Src structure is
1130 1.134 rillig * put together for it and returned.
1131 1.1 cgd *
1132 1.39 wiz * Input:
1133 1.134 rillig * targ Src to play with
1134 1.73 joerg *
1135 1.73 joerg * Results:
1136 1.134 rillig * The Src of the "winning" child, or NULL.
1137 1.1 cgd */
1138 1.73 joerg static Src *
1139 1.157 rillig SuffFindCmds(Src *targ, SrcList *slst)
1140 1.1 cgd {
1141 1.157 rillig GNodeListNode *gln;
1142 1.157 rillig SuffListNode *suffln;
1143 1.157 rillig
1144 1.73 joerg GNode *t, /* Target GNode */
1145 1.93 rillig *s; /* Source GNode */
1146 1.164 rillig size_t prefLen;/* The length of the defined prefix */
1147 1.73 joerg Suff *suff; /* Suffix on matching beastie */
1148 1.73 joerg Src *ret; /* Return value */
1149 1.73 joerg char *cp;
1150 1.73 joerg
1151 1.73 joerg t = targ->node;
1152 1.125 rillig Lst_Open(t->children);
1153 1.73 joerg prefLen = strlen(targ->pref);
1154 1.73 joerg
1155 1.73 joerg for (;;) {
1156 1.157 rillig gln = Lst_Next(t->children);
1157 1.157 rillig if (gln == NULL) {
1158 1.125 rillig Lst_Close(t->children);
1159 1.73 joerg return NULL;
1160 1.73 joerg }
1161 1.157 rillig s = LstNode_Datum(gln);
1162 1.73 joerg
1163 1.125 rillig if (s->type & OP_OPTIONAL && Lst_IsEmpty(t->commands)) {
1164 1.73 joerg /*
1165 1.73 joerg * We haven't looked to see if .OPTIONAL files exist yet, so
1166 1.73 joerg * don't use one as the implicit source.
1167 1.73 joerg * This allows us to use .OPTIONAL in .depend files so make won't
1168 1.73 joerg * complain "don't know how to make xxx.h' when a dependent file
1169 1.73 joerg * has been moved/deleted.
1170 1.73 joerg */
1171 1.73 joerg continue;
1172 1.73 joerg }
1173 1.73 joerg
1174 1.73 joerg cp = strrchr(s->name, '/');
1175 1.73 joerg if (cp == NULL) {
1176 1.73 joerg cp = s->name;
1177 1.73 joerg } else {
1178 1.73 joerg cp++;
1179 1.73 joerg }
1180 1.73 joerg if (strncmp(cp, targ->pref, prefLen) != 0)
1181 1.73 joerg continue;
1182 1.73 joerg /*
1183 1.73 joerg * The node matches the prefix ok, see if it has a known
1184 1.73 joerg * suffix.
1185 1.73 joerg */
1186 1.162 rillig suffln = FindSuffByName(cp + prefLen);
1187 1.157 rillig if (suffln == NULL)
1188 1.73 joerg continue;
1189 1.73 joerg /*
1190 1.73 joerg * It even has a known suffix, see if there's a transformation
1191 1.73 joerg * defined between the node's suffix and the target's suffix.
1192 1.73 joerg *
1193 1.73 joerg * XXX: Handle multi-stage transformations here, too.
1194 1.73 joerg */
1195 1.157 rillig suff = LstNode_Datum(suffln);
1196 1.73 joerg
1197 1.107 rillig /* XXX: Can targ->suff be NULL here? */
1198 1.107 rillig if (targ->suff != NULL &&
1199 1.137 rillig Lst_FindDatum(suff->parents, targ->suff) != NULL)
1200 1.73 joerg break;
1201 1.73 joerg }
1202 1.1 cgd
1203 1.43 dsl /*
1204 1.73 joerg * Hot Damn! Create a new Src structure to describe
1205 1.73 joerg * this transformation (making sure to duplicate the
1206 1.73 joerg * source node's name so Suff_FindDeps can free it
1207 1.73 joerg * again (ick)), and return the new structure.
1208 1.73 joerg */
1209 1.73 joerg ret = bmake_malloc(sizeof(Src));
1210 1.73 joerg ret->file = bmake_strdup(s->name);
1211 1.73 joerg ret->pref = targ->pref;
1212 1.73 joerg ret->suff = suff;
1213 1.73 joerg suff->refCount++;
1214 1.73 joerg ret->parent = targ;
1215 1.73 joerg ret->node = s;
1216 1.73 joerg ret->children = 0;
1217 1.73 joerg targ->children += 1;
1218 1.73 joerg #ifdef DEBUG_SRC
1219 1.97 rillig ret->cp = Lst_Init();
1220 1.84 dholland fprintf(debug_file, "3 add %p %p\n", targ, ret);
1221 1.125 rillig Lst_Append(targ->cp, ret);
1222 1.73 joerg #endif
1223 1.125 rillig Lst_Append(slst, ret);
1224 1.140 rillig SUFF_DEBUG1("\tusing existing source %s\n", s->name);
1225 1.141 rillig Lst_Close(t->children);
1226 1.88 rillig return ret;
1227 1.1 cgd }
1228 1.1 cgd
1229 1.134 rillig /* Expand the names of any children of a given node that contain variable
1230 1.153 rillig * expressions or file wildcards into actual targets.
1231 1.134 rillig *
1232 1.134 rillig * The expanded node is removed from the parent's list of children, and the
1233 1.134 rillig * parent's unmade counter is decremented, but other nodes may be added.
1234 1.1 cgd *
1235 1.39 wiz * Input:
1236 1.73 joerg * cln Child to examine
1237 1.73 joerg * pgn Parent node being processed
1238 1.1 cgd */
1239 1.56 dsl static void
1240 1.157 rillig SuffExpandChildren(GNodeListNode *cln, GNode *pgn)
1241 1.1 cgd {
1242 1.138 rillig GNode *cgn = LstNode_Datum(cln);
1243 1.73 joerg GNode *gn; /* New source 8) */
1244 1.73 joerg char *cp; /* Expanded value */
1245 1.1 cgd
1246 1.125 rillig if (!Lst_IsEmpty(cgn->order_pred) || !Lst_IsEmpty(cgn->order_succ))
1247 1.61 dsl /* It is all too hard to process the result of .ORDER */
1248 1.61 dsl return;
1249 1.61 dsl
1250 1.61 dsl if (cgn->type & OP_WAIT)
1251 1.61 dsl /* Ignore these (& OP_PHONY ?) */
1252 1.61 dsl return;
1253 1.61 dsl
1254 1.1 cgd /*
1255 1.1 cgd * First do variable expansion -- this takes precedence over
1256 1.1 cgd * wildcard expansion. If the result contains wildcards, they'll be gotten
1257 1.1 cgd * to later since the resulting words are tacked on to the end of
1258 1.1 cgd * the children list.
1259 1.1 cgd */
1260 1.56 dsl if (strchr(cgn->name, '$') == NULL) {
1261 1.56 dsl SuffExpandWildcards(cln, pgn);
1262 1.56 dsl return;
1263 1.56 dsl }
1264 1.56 dsl
1265 1.140 rillig SUFF_DEBUG1("Expanding \"%s\"...", cgn->name);
1266 1.158 rillig (void)Var_Subst(cgn->name, pgn, VARE_UNDEFERR|VARE_WANTRES, &cp);
1267 1.158 rillig /* TODO: handle errors */
1268 1.1 cgd
1269 1.135 rillig {
1270 1.157 rillig GNodeList *members = Lst_Init();
1271 1.13 christos
1272 1.56 dsl if (cgn->type & OP_ARCHV) {
1273 1.56 dsl /*
1274 1.56 dsl * Node was an archive(member) target, so we want to call
1275 1.56 dsl * on the Arch module to find the nodes for us, expanding
1276 1.56 dsl * variables in the parent's context.
1277 1.56 dsl */
1278 1.56 dsl char *sacrifice = cp;
1279 1.1 cgd
1280 1.56 dsl (void)Arch_ParseArchive(&sacrifice, members, pgn);
1281 1.56 dsl } else {
1282 1.56 dsl /*
1283 1.56 dsl * Break the result into a vector of strings whose nodes
1284 1.56 dsl * we can find, then add those nodes to the members list.
1285 1.56 dsl * Unfortunately, we can't use brk_string b/c it
1286 1.56 dsl * doesn't understand about variable specifications with
1287 1.56 dsl * spaces in them...
1288 1.56 dsl */
1289 1.56 dsl char *start;
1290 1.73 joerg char *initcp = cp; /* For freeing... */
1291 1.1 cgd
1292 1.56 dsl for (start = cp; *start == ' ' || *start == '\t'; start++)
1293 1.56 dsl continue;
1294 1.145 rillig cp = start;
1295 1.145 rillig while (*cp != '\0') {
1296 1.56 dsl if (*cp == ' ' || *cp == '\t') {
1297 1.56 dsl /*
1298 1.56 dsl * White-space -- terminate element, find the node,
1299 1.56 dsl * add it, skip any further spaces.
1300 1.56 dsl */
1301 1.56 dsl *cp++ = '\0';
1302 1.56 dsl gn = Targ_FindNode(start, TARG_CREATE);
1303 1.125 rillig Lst_Append(members, gn);
1304 1.56 dsl while (*cp == ' ' || *cp == '\t') {
1305 1.1 cgd cp++;
1306 1.1 cgd }
1307 1.145 rillig start = cp; /* Continue at the next non-space. */
1308 1.56 dsl } else if (*cp == '$') {
1309 1.56 dsl /*
1310 1.56 dsl * Start of a variable spec -- contact variable module
1311 1.56 dsl * to find the end so we can skip over it.
1312 1.56 dsl */
1313 1.144 rillig const char *nested_p = cp;
1314 1.90 rillig const char *junk;
1315 1.56 dsl void *freeIt;
1316 1.56 dsl
1317 1.145 rillig /* XXX: Why VARE_WANTRES when the result is not used? */
1318 1.156 rillig (void)Var_Parse(&nested_p, pgn,
1319 1.156 rillig VARE_UNDEFERR|VARE_WANTRES,
1320 1.156 rillig &junk, &freeIt);
1321 1.156 rillig /* TODO: handle errors */
1322 1.145 rillig if (junk == var_Error) {
1323 1.145 rillig Parse_Error(PARSE_FATAL,
1324 1.145 rillig "Malformed variable expression at \"%s\"",
1325 1.145 rillig cp);
1326 1.148 rillig cp++;
1327 1.145 rillig } else {
1328 1.144 rillig cp += nested_p - cp;
1329 1.56 dsl }
1330 1.1 cgd
1331 1.77 christos free(freeIt);
1332 1.82 dholland } else if (*cp == '\\' && cp[1] != '\0') {
1333 1.1 cgd /*
1334 1.56 dsl * Escaped something -- skip over it
1335 1.1 cgd */
1336 1.145 rillig /* XXX: In other places, escaping at this syntactical
1337 1.145 rillig * position is done by a '$', not a '\'. The '\' is only
1338 1.145 rillig * used in variable modifiers. */
1339 1.145 rillig cp += 2;
1340 1.145 rillig } else {
1341 1.56 dsl cp++;
1342 1.1 cgd }
1343 1.56 dsl }
1344 1.56 dsl
1345 1.56 dsl if (cp != start) {
1346 1.1 cgd /*
1347 1.56 dsl * Stuff left over -- add it to the list too
1348 1.1 cgd */
1349 1.56 dsl gn = Targ_FindNode(start, TARG_CREATE);
1350 1.125 rillig Lst_Append(members, gn);
1351 1.1 cgd }
1352 1.73 joerg /*
1353 1.73 joerg * Point cp back at the beginning again so the variable value
1354 1.73 joerg * can be freed.
1355 1.73 joerg */
1356 1.73 joerg cp = initcp;
1357 1.56 dsl }
1358 1.1 cgd
1359 1.1 cgd /*
1360 1.56 dsl * Add all elements of the members list to the parent node.
1361 1.1 cgd */
1362 1.125 rillig while(!Lst_IsEmpty(members)) {
1363 1.125 rillig gn = Lst_Dequeue(members);
1364 1.56 dsl
1365 1.140 rillig SUFF_DEBUG1("%s...", gn->name);
1366 1.56 dsl /* Add gn to the parents child list before the original child */
1367 1.125 rillig Lst_InsertBefore(pgn->children, cln, gn);
1368 1.125 rillig Lst_Append(gn->parents, pgn);
1369 1.56 dsl pgn->unmade++;
1370 1.56 dsl /* Expand wildcards on new node */
1371 1.131 rillig SuffExpandWildcards(LstNode_Prev(cln), pgn);
1372 1.1 cgd }
1373 1.125 rillig Lst_Free(members);
1374 1.1 cgd
1375 1.73 joerg /*
1376 1.73 joerg * Free the result
1377 1.73 joerg */
1378 1.73 joerg free(cp);
1379 1.73 joerg }
1380 1.135 rillig
1381 1.140 rillig SUFF_DEBUG0("\n");
1382 1.1 cgd
1383 1.56 dsl /*
1384 1.56 dsl * Now the source is expanded, remove it from the list of children to
1385 1.56 dsl * keep it from being processed.
1386 1.56 dsl */
1387 1.56 dsl pgn->unmade--;
1388 1.125 rillig Lst_Remove(pgn->children, cln);
1389 1.137 rillig Lst_Remove(cgn->parents, Lst_FindDatum(cgn->parents, pgn));
1390 1.56 dsl }
1391 1.56 dsl
1392 1.56 dsl static void
1393 1.157 rillig SuffExpandWildcards(GNodeListNode *cln, GNode *pgn)
1394 1.56 dsl {
1395 1.138 rillig GNode *cgn = LstNode_Datum(cln);
1396 1.157 rillig StringList *explist;
1397 1.1 cgd
1398 1.56 dsl if (!Dir_HasWildcards(cgn->name))
1399 1.56 dsl return;
1400 1.1 cgd
1401 1.56 dsl /*
1402 1.56 dsl * Expand the word along the chosen path
1403 1.56 dsl */
1404 1.97 rillig explist = Lst_Init();
1405 1.56 dsl Dir_Expand(cgn->name, Suff_FindPath(cgn), explist);
1406 1.1 cgd
1407 1.125 rillig while (!Lst_IsEmpty(explist)) {
1408 1.157 rillig GNode *gn;
1409 1.1 cgd /*
1410 1.56 dsl * Fetch next expansion off the list and find its GNode
1411 1.1 cgd */
1412 1.157 rillig char *cp = Lst_Dequeue(explist);
1413 1.13 christos
1414 1.140 rillig SUFF_DEBUG1("%s...", cp);
1415 1.56 dsl gn = Targ_FindNode(cp, TARG_CREATE);
1416 1.56 dsl
1417 1.56 dsl /* Add gn to the parents child list before the original child */
1418 1.125 rillig Lst_InsertBefore(pgn->children, cln, gn);
1419 1.125 rillig Lst_Append(gn->parents, pgn);
1420 1.56 dsl pgn->unmade++;
1421 1.1 cgd }
1422 1.1 cgd
1423 1.125 rillig Lst_Free(explist);
1424 1.56 dsl
1425 1.140 rillig SUFF_DEBUG0("\n");
1426 1.73 joerg
1427 1.56 dsl /*
1428 1.56 dsl * Now the source is expanded, remove it from the list of children to
1429 1.56 dsl * keep it from being processed.
1430 1.56 dsl */
1431 1.56 dsl pgn->unmade--;
1432 1.125 rillig Lst_Remove(pgn->children, cln);
1433 1.137 rillig Lst_Remove(cgn->parents, Lst_FindDatum(cgn->parents, pgn));
1434 1.1 cgd }
1435 1.1 cgd
1436 1.134 rillig /* Find a path along which to expand the node.
1437 1.47 christos *
1438 1.134 rillig * If the word has a known suffix, use that path.
1439 1.134 rillig * If it has no known suffix, use the default system search path.
1440 1.47 christos *
1441 1.47 christos * Input:
1442 1.47 christos * gn Node being examined
1443 1.47 christos *
1444 1.47 christos * Results:
1445 1.47 christos * The appropriate path to search for the GNode.
1446 1.46 christos */
1447 1.157 rillig SearchPath *
1448 1.46 christos Suff_FindPath(GNode* gn)
1449 1.46 christos {
1450 1.46 christos Suff *suff = gn->suffix;
1451 1.46 christos
1452 1.46 christos if (suff == NULL) {
1453 1.161 rillig struct SuffSuffGetSuffixArgs sd; /* Search string data */
1454 1.157 rillig SuffListNode *ln;
1455 1.164 rillig sd.name_len = strlen(gn->name);
1456 1.164 rillig sd.name_end = gn->name + sd.name_len;
1457 1.130 rillig ln = Lst_Find(sufflist, SuffSuffIsSuffix, &sd);
1458 1.46 christos
1459 1.140 rillig SUFF_DEBUG1("Wildcard expanding \"%s\"...", gn->name);
1460 1.65 dsl if (ln != NULL)
1461 1.138 rillig suff = LstNode_Datum(ln);
1462 1.46 christos /* XXX: Here we can save the suffix so we don't have to do this again */
1463 1.46 christos }
1464 1.46 christos
1465 1.73 joerg if (suff != NULL) {
1466 1.140 rillig SUFF_DEBUG1("suffix is \"%s\"...", suff->name);
1467 1.46 christos return suff->searchPath;
1468 1.73 joerg } else {
1469 1.73 joerg /*
1470 1.73 joerg * Use default search path
1471 1.73 joerg */
1472 1.46 christos return dirSearchPath;
1473 1.46 christos }
1474 1.46 christos }
1475 1.46 christos
1476 1.134 rillig /* Apply a transformation rule, given the source and target nodes and
1477 1.134 rillig * suffixes.
1478 1.1 cgd *
1479 1.39 wiz * Input:
1480 1.73 joerg * tGn Target node
1481 1.73 joerg * sGn Source node
1482 1.73 joerg * t Target suffix
1483 1.73 joerg * s Source suffix
1484 1.39 wiz *
1485 1.1 cgd * Results:
1486 1.1 cgd * TRUE if successful, FALSE if not.
1487 1.1 cgd *
1488 1.1 cgd * Side Effects:
1489 1.1 cgd * The source and target are linked and the commands from the
1490 1.1 cgd * transformation are added to the target node's commands list.
1491 1.1 cgd * All attributes but OP_DEPMASK and OP_TRANSFORM are applied
1492 1.1 cgd * to the target. The target also inherits all the sources for
1493 1.1 cgd * the transformation rule.
1494 1.1 cgd */
1495 1.1 cgd static Boolean
1496 1.73 joerg SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
1497 1.1 cgd {
1498 1.157 rillig GNodeListNode *ln, *nln; /* General node */
1499 1.1 cgd char *tname; /* Name of transformation rule */
1500 1.1 cgd GNode *gn; /* Node for same */
1501 1.1 cgd
1502 1.31 mycroft /*
1503 1.31 mycroft * Form the proper links between the target and source.
1504 1.31 mycroft */
1505 1.125 rillig Lst_Append(tGn->children, sGn);
1506 1.125 rillig Lst_Append(sGn->parents, tGn);
1507 1.31 mycroft tGn->unmade += 1;
1508 1.1 cgd
1509 1.1 cgd /*
1510 1.1 cgd * Locate the transformation rule itself
1511 1.1 cgd */
1512 1.95 rillig tname = str_concat2(s->name, t->name);
1513 1.130 rillig ln = Lst_Find(transforms, SuffGNHasName, tname);
1514 1.1 cgd free(tname);
1515 1.1 cgd
1516 1.73 joerg if (ln == NULL) {
1517 1.73 joerg /*
1518 1.73 joerg * Not really such a transformation rule (can happen when we're
1519 1.73 joerg * called to link an OP_MEMBER and OP_ARCHV node), so return
1520 1.73 joerg * FALSE.
1521 1.73 joerg */
1522 1.88 rillig return FALSE;
1523 1.73 joerg }
1524 1.73 joerg
1525 1.138 rillig gn = LstNode_Datum(ln);
1526 1.13 christos
1527 1.140 rillig SUFF_DEBUG3("\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name);
1528 1.1 cgd
1529 1.73 joerg /*
1530 1.73 joerg * Record last child for expansion purposes
1531 1.73 joerg */
1532 1.125 rillig ln = Lst_Last(tGn->children);
1533 1.13 christos
1534 1.1 cgd /*
1535 1.1 cgd * Pass the buck to Make_HandleUse to apply the rule
1536 1.1 cgd */
1537 1.1 cgd (void)Make_HandleUse(gn, tGn);
1538 1.1 cgd
1539 1.1 cgd /*
1540 1.71 christos * Deal with wildcards and variables in any acquired sources
1541 1.71 christos */
1542 1.131 rillig for (ln = ln != NULL ? LstNode_Next(ln) : NULL; ln != NULL; ln = nln) {
1543 1.131 rillig nln = LstNode_Next(ln);
1544 1.73 joerg SuffExpandChildren(ln, tGn);
1545 1.73 joerg }
1546 1.1 cgd
1547 1.73 joerg /*
1548 1.73 joerg * Keep track of another parent to which this beast is transformed so
1549 1.73 joerg * the .IMPSRC variable can be set correctly for the parent.
1550 1.73 joerg */
1551 1.139 rillig Lst_Append(sGn->implicitParents, tGn);
1552 1.1 cgd
1553 1.88 rillig return TRUE;
1554 1.1 cgd }
1555 1.1 cgd
1556 1.1 cgd
1557 1.134 rillig /* Locate dependencies for an OP_ARCHV node.
1558 1.1 cgd *
1559 1.39 wiz * Input:
1560 1.73 joerg * gn Node for which to locate dependencies
1561 1.39 wiz *
1562 1.1 cgd * Side Effects:
1563 1.73 joerg * Same as Suff_FindDeps
1564 1.1 cgd */
1565 1.1 cgd static void
1566 1.157 rillig SuffFindArchiveDeps(GNode *gn, SrcList *slst)
1567 1.1 cgd {
1568 1.157 rillig char *eoarch; /* End of archive portion */
1569 1.157 rillig char *eoname; /* End of member portion */
1570 1.157 rillig GNode *mem; /* Node for member */
1571 1.157 rillig SuffListNode *ln, *nln; /* Next suffix node to check */
1572 1.157 rillig Suff *ms; /* Suffix descriptor for member */
1573 1.157 rillig char *name; /* Start of member's name */
1574 1.71 christos
1575 1.73 joerg /*
1576 1.73 joerg * The node is an archive(member) pair. so we must find a
1577 1.73 joerg * suffix for both of them.
1578 1.73 joerg */
1579 1.73 joerg eoarch = strchr(gn->name, '(');
1580 1.73 joerg eoname = strchr(eoarch, ')');
1581 1.13 christos
1582 1.86 riastrad /*
1583 1.86 riastrad * Caller guarantees the format `libname(member)', via
1584 1.86 riastrad * Arch_ParseArchive.
1585 1.86 riastrad */
1586 1.86 riastrad assert(eoarch != NULL);
1587 1.86 riastrad assert(eoname != NULL);
1588 1.86 riastrad
1589 1.73 joerg *eoname = '\0'; /* Nuke parentheses during suffix search */
1590 1.73 joerg *eoarch = '\0'; /* So a suffix can be found */
1591 1.1 cgd
1592 1.73 joerg name = eoarch + 1;
1593 1.1 cgd
1594 1.73 joerg /*
1595 1.73 joerg * To simplify things, call Suff_FindDeps recursively on the member now,
1596 1.73 joerg * so we can simply compare the member's .PREFIX and .TARGET variables
1597 1.73 joerg * to locate its suffix. This allows us to figure out the suffix to
1598 1.73 joerg * use for the archive without having to do a quadratic search over the
1599 1.73 joerg * suffix list, backtracking for each one...
1600 1.73 joerg */
1601 1.73 joerg mem = Targ_FindNode(name, TARG_CREATE);
1602 1.73 joerg SuffFindDeps(mem, slst);
1603 1.13 christos
1604 1.1 cgd /*
1605 1.73 joerg * Create the link between the two nodes right off
1606 1.1 cgd */
1607 1.125 rillig Lst_Append(gn->children, mem);
1608 1.125 rillig Lst_Append(mem->parents, gn);
1609 1.73 joerg gn->unmade += 1;
1610 1.13 christos
1611 1.1 cgd /*
1612 1.73 joerg * Copy in the variables from the member node to this one.
1613 1.1 cgd */
1614 1.113 rillig {
1615 1.113 rillig char *freeIt;
1616 1.113 rillig Var_Set(PREFIX, Var_Value(PREFIX, mem, &freeIt), gn);
1617 1.113 rillig bmake_free(freeIt);
1618 1.113 rillig Var_Set(TARGET, Var_Value(TARGET, mem, &freeIt), gn);
1619 1.113 rillig bmake_free(freeIt);
1620 1.73 joerg }
1621 1.1 cgd
1622 1.73 joerg ms = mem->suffix;
1623 1.73 joerg if (ms == NULL) {
1624 1.73 joerg /*
1625 1.73 joerg * Didn't know what it was -- use .NULL suffix if not in make mode
1626 1.73 joerg */
1627 1.140 rillig SUFF_DEBUG0("using null suffix\n");
1628 1.73 joerg ms = suffNull;
1629 1.1 cgd }
1630 1.1 cgd
1631 1.73 joerg
1632 1.1 cgd /*
1633 1.73 joerg * Set the other two local variables required for this target.
1634 1.1 cgd */
1635 1.87 rillig Var_Set(MEMBER, name, gn);
1636 1.87 rillig Var_Set(ARCHIVE, gn->name, gn);
1637 1.73 joerg
1638 1.79 matthias /*
1639 1.79 matthias * Set $@ for compatibility with other makes
1640 1.79 matthias */
1641 1.87 rillig Var_Set(TARGET, gn->name, gn);
1642 1.80 matthias
1643 1.80 matthias /*
1644 1.80 matthias * Now we've got the important local variables set, expand any sources
1645 1.80 matthias * that still contain variables or wildcards in their names.
1646 1.80 matthias */
1647 1.125 rillig for (ln = Lst_First(gn->children); ln != NULL; ln = nln) {
1648 1.131 rillig nln = LstNode_Next(ln);
1649 1.80 matthias SuffExpandChildren(ln, gn);
1650 1.80 matthias }
1651 1.80 matthias
1652 1.73 joerg if (ms != NULL) {
1653 1.73 joerg /*
1654 1.73 joerg * Member has a known suffix, so look for a transformation rule from
1655 1.73 joerg * it to a possible suffix of the archive. Rather than searching
1656 1.73 joerg * through the entire list, we just look at suffixes to which the
1657 1.73 joerg * member's suffix may be transformed...
1658 1.73 joerg */
1659 1.161 rillig struct SuffSuffGetSuffixArgs sd; /* Search string data */
1660 1.73 joerg
1661 1.73 joerg /*
1662 1.73 joerg * Use first matching suffix...
1663 1.73 joerg */
1664 1.164 rillig sd.name_len = eoarch - gn->name;
1665 1.164 rillig sd.name_end = eoarch;
1666 1.130 rillig ln = Lst_Find(ms->parents, SuffSuffIsSuffix, &sd);
1667 1.73 joerg
1668 1.73 joerg if (ln != NULL) {
1669 1.73 joerg /*
1670 1.73 joerg * Got one -- apply it
1671 1.73 joerg */
1672 1.140 rillig Suff *suff = LstNode_Datum(ln);
1673 1.140 rillig if (!SuffApplyTransform(gn, mem, suff, ms)) {
1674 1.140 rillig SUFF_DEBUG2("\tNo transformation from %s -> %s\n",
1675 1.140 rillig ms->name, suff->name);
1676 1.1 cgd }
1677 1.1 cgd }
1678 1.1 cgd }
1679 1.1 cgd
1680 1.73 joerg /*
1681 1.73 joerg * Replace the opening and closing parens now we've no need of the separate
1682 1.73 joerg * pieces.
1683 1.73 joerg */
1684 1.73 joerg *eoarch = '('; *eoname = ')';
1685 1.71 christos
1686 1.1 cgd /*
1687 1.73 joerg * Pretend gn appeared to the left of a dependency operator so
1688 1.73 joerg * the user needn't provide a transformation from the member to the
1689 1.73 joerg * archive.
1690 1.1 cgd */
1691 1.73 joerg if (OP_NOP(gn->type)) {
1692 1.73 joerg gn->type |= OP_DEPENDS;
1693 1.73 joerg }
1694 1.71 christos
1695 1.73 joerg /*
1696 1.73 joerg * Flag the member as such so we remember to look in the archive for
1697 1.81 matthias * its modification time. The OP_JOIN | OP_MADE is needed because this
1698 1.81 matthias * target should never get made.
1699 1.73 joerg */
1700 1.81 matthias mem->type |= OP_MEMBER | OP_JOIN | OP_MADE;
1701 1.1 cgd }
1702 1.1 cgd
1703 1.134 rillig /* Locate implicit dependencies for regular targets.
1704 1.1 cgd *
1705 1.39 wiz * Input:
1706 1.73 joerg * gn Node for which to find sources
1707 1.39 wiz *
1708 1.1 cgd * Side Effects:
1709 1.134 rillig * Same as Suff_FindDeps
1710 1.1 cgd */
1711 1.1 cgd static void
1712 1.157 rillig SuffFindNormalDeps(GNode *gn, SrcList *slst)
1713 1.1 cgd {
1714 1.73 joerg char *eoname; /* End of name */
1715 1.73 joerg char *sopref; /* Start of prefix */
1716 1.157 rillig SuffListNode *ln, *nln;
1717 1.157 rillig SrcList *srcs; /* List of sources at which to look */
1718 1.157 rillig SrcList *targs; /* List of targets to which things can be
1719 1.73 joerg * transformed. They all have the same file,
1720 1.73 joerg * but different suff and pref fields */
1721 1.73 joerg Src *bottom; /* Start of found transformation path */
1722 1.73 joerg Src *src; /* General Src pointer */
1723 1.73 joerg char *pref; /* Prefix to use */
1724 1.73 joerg Src *targ; /* General Src target pointer */
1725 1.161 rillig struct SuffSuffGetSuffixArgs sd; /* Search string data */
1726 1.73 joerg
1727 1.73 joerg
1728 1.164 rillig sd.name_len = strlen(gn->name);
1729 1.164 rillig sd.name_end = eoname = gn->name + sd.name_len;
1730 1.73 joerg
1731 1.73 joerg sopref = gn->name;
1732 1.73 joerg
1733 1.73 joerg /*
1734 1.73 joerg * Begin at the beginning...
1735 1.73 joerg */
1736 1.125 rillig ln = Lst_First(sufflist);
1737 1.97 rillig srcs = Lst_Init();
1738 1.97 rillig targs = Lst_Init();
1739 1.73 joerg
1740 1.73 joerg /*
1741 1.73 joerg * We're caught in a catch-22 here. On the one hand, we want to use any
1742 1.73 joerg * transformation implied by the target's sources, but we can't examine
1743 1.73 joerg * the sources until we've expanded any variables/wildcards they may hold,
1744 1.73 joerg * and we can't do that until we've set up the target's local variables
1745 1.73 joerg * and we can't do that until we know what the proper suffix for the
1746 1.73 joerg * target is (in case there are two suffixes one of which is a suffix of
1747 1.73 joerg * the other) and we can't know that until we've found its implied
1748 1.73 joerg * source, which we may not want to use if there's an existing source
1749 1.73 joerg * that implies a different transformation.
1750 1.73 joerg *
1751 1.73 joerg * In an attempt to get around this, which may not work all the time,
1752 1.73 joerg * but should work most of the time, we look for implied sources first,
1753 1.73 joerg * checking transformations to all possible suffixes of the target,
1754 1.73 joerg * use what we find to set the target's local variables, expand the
1755 1.73 joerg * children, then look for any overriding transformations they imply.
1756 1.73 joerg * Should we find one, we discard the one we found before.
1757 1.73 joerg */
1758 1.73 joerg bottom = NULL;
1759 1.73 joerg targ = NULL;
1760 1.71 christos
1761 1.73 joerg if (!(gn->type & OP_PHONY)) {
1762 1.73 joerg
1763 1.73 joerg while (ln != NULL) {
1764 1.73 joerg /*
1765 1.73 joerg * Look for next possible suffix...
1766 1.73 joerg */
1767 1.130 rillig ln = Lst_FindFrom(sufflist, ln, SuffSuffIsSuffix, &sd);
1768 1.73 joerg
1769 1.73 joerg if (ln != NULL) {
1770 1.148 rillig const char *eopref;
1771 1.73 joerg
1772 1.73 joerg /*
1773 1.73 joerg * Allocate a Src structure to which things can be transformed
1774 1.73 joerg */
1775 1.73 joerg targ = bmake_malloc(sizeof(Src));
1776 1.73 joerg targ->file = bmake_strdup(gn->name);
1777 1.138 rillig targ->suff = LstNode_Datum(ln);
1778 1.73 joerg targ->suff->refCount++;
1779 1.73 joerg targ->node = gn;
1780 1.73 joerg targ->parent = NULL;
1781 1.73 joerg targ->children = 0;
1782 1.73 joerg #ifdef DEBUG_SRC
1783 1.97 rillig targ->cp = Lst_Init();
1784 1.73 joerg #endif
1785 1.73 joerg
1786 1.132 rillig eopref = eoname - targ->suff->nameLen;
1787 1.133 rillig targ->pref = bmake_strsedup(sopref, eopref);
1788 1.73 joerg
1789 1.73 joerg /*
1790 1.73 joerg * Add nodes from which the target can be made
1791 1.73 joerg */
1792 1.73 joerg SuffAddLevel(srcs, targ);
1793 1.73 joerg
1794 1.73 joerg /*
1795 1.73 joerg * Record the target so we can nuke it
1796 1.73 joerg */
1797 1.125 rillig Lst_Append(targs, targ);
1798 1.73 joerg
1799 1.73 joerg /*
1800 1.73 joerg * Search from this suffix's successor...
1801 1.73 joerg */
1802 1.131 rillig ln = LstNode_Next(ln);
1803 1.73 joerg }
1804 1.73 joerg }
1805 1.73 joerg
1806 1.73 joerg /*
1807 1.73 joerg * Handle target of unknown suffix...
1808 1.73 joerg */
1809 1.125 rillig if (Lst_IsEmpty(targs) && suffNull != NULL) {
1810 1.140 rillig SUFF_DEBUG1("\tNo known suffix on %s. Using .NULL suffix\n",
1811 1.140 rillig gn->name);
1812 1.73 joerg
1813 1.73 joerg targ = bmake_malloc(sizeof(Src));
1814 1.73 joerg targ->file = bmake_strdup(gn->name);
1815 1.73 joerg targ->suff = suffNull;
1816 1.73 joerg targ->suff->refCount++;
1817 1.73 joerg targ->node = gn;
1818 1.73 joerg targ->parent = NULL;
1819 1.73 joerg targ->children = 0;
1820 1.73 joerg targ->pref = bmake_strdup(sopref);
1821 1.73 joerg #ifdef DEBUG_SRC
1822 1.97 rillig targ->cp = Lst_Init();
1823 1.73 joerg #endif
1824 1.73 joerg
1825 1.73 joerg /*
1826 1.73 joerg * Only use the default suffix rules if we don't have commands
1827 1.73 joerg * defined for this gnode; traditional make programs used to
1828 1.73 joerg * not define suffix rules if the gnode had children but we
1829 1.73 joerg * don't do this anymore.
1830 1.73 joerg */
1831 1.125 rillig if (Lst_IsEmpty(gn->commands))
1832 1.73 joerg SuffAddLevel(srcs, targ);
1833 1.73 joerg else {
1834 1.140 rillig SUFF_DEBUG0("not ");
1835 1.73 joerg }
1836 1.73 joerg
1837 1.140 rillig SUFF_DEBUG0("adding suffix rules\n");
1838 1.73 joerg
1839 1.125 rillig Lst_Append(targs, targ);
1840 1.73 joerg }
1841 1.73 joerg
1842 1.73 joerg /*
1843 1.73 joerg * Using the list of possible sources built up from the target
1844 1.73 joerg * suffix(es), try and find an existing file/target that matches.
1845 1.73 joerg */
1846 1.73 joerg bottom = SuffFindThem(srcs, slst);
1847 1.73 joerg
1848 1.73 joerg if (bottom == NULL) {
1849 1.73 joerg /*
1850 1.73 joerg * No known transformations -- use the first suffix found
1851 1.73 joerg * for setting the local variables.
1852 1.73 joerg */
1853 1.125 rillig if (!Lst_IsEmpty(targs)) {
1854 1.138 rillig targ = LstNode_Datum(Lst_First(targs));
1855 1.73 joerg } else {
1856 1.73 joerg targ = NULL;
1857 1.73 joerg }
1858 1.73 joerg } else {
1859 1.73 joerg /*
1860 1.73 joerg * Work up the transformation path to find the suffix of the
1861 1.73 joerg * target to which the transformation was made.
1862 1.73 joerg */
1863 1.73 joerg for (targ = bottom; targ->parent != NULL; targ = targ->parent)
1864 1.73 joerg continue;
1865 1.73 joerg }
1866 1.73 joerg }
1867 1.73 joerg
1868 1.87 rillig Var_Set(TARGET, gn->path ? gn->path : gn->name, gn);
1869 1.73 joerg
1870 1.73 joerg pref = (targ != NULL) ? targ->pref : gn->name;
1871 1.87 rillig Var_Set(PREFIX, pref, gn);
1872 1.1 cgd
1873 1.1 cgd /*
1874 1.73 joerg * Now we've got the important local variables set, expand any sources
1875 1.73 joerg * that still contain variables or wildcards in their names.
1876 1.1 cgd */
1877 1.125 rillig for (ln = Lst_First(gn->children); ln != NULL; ln = nln) {
1878 1.131 rillig nln = LstNode_Next(ln);
1879 1.73 joerg SuffExpandChildren(ln, gn);
1880 1.73 joerg }
1881 1.73 joerg
1882 1.73 joerg if (targ == NULL) {
1883 1.140 rillig SUFF_DEBUG1("\tNo valid suffix on %s\n", gn->name);
1884 1.73 joerg
1885 1.73 joerg sfnd_abort:
1886 1.73 joerg /*
1887 1.73 joerg * Deal with finding the thing on the default search path. We
1888 1.73 joerg * always do that, not only if the node is only a source (not
1889 1.73 joerg * on the lhs of a dependency operator or [XXX] it has neither
1890 1.73 joerg * children or commands) as the old pmake did.
1891 1.73 joerg */
1892 1.73 joerg if ((gn->type & (OP_PHONY|OP_NOPATH)) == 0) {
1893 1.73 joerg free(gn->path);
1894 1.73 joerg gn->path = Dir_FindFile(gn->name,
1895 1.73 joerg (targ == NULL ? dirSearchPath :
1896 1.73 joerg targ->suff->searchPath));
1897 1.73 joerg if (gn->path != NULL) {
1898 1.73 joerg char *ptr;
1899 1.87 rillig Var_Set(TARGET, gn->path, gn);
1900 1.73 joerg
1901 1.73 joerg if (targ != NULL) {
1902 1.73 joerg /*
1903 1.73 joerg * Suffix known for the thing -- trim the suffix off
1904 1.73 joerg * the path to form the proper .PREFIX variable.
1905 1.73 joerg */
1906 1.164 rillig size_t savep = strlen(gn->path) - targ->suff->nameLen;
1907 1.73 joerg char savec;
1908 1.73 joerg
1909 1.73 joerg if (gn->suffix)
1910 1.73 joerg gn->suffix->refCount--;
1911 1.73 joerg gn->suffix = targ->suff;
1912 1.73 joerg gn->suffix->refCount++;
1913 1.73 joerg
1914 1.73 joerg savec = gn->path[savep];
1915 1.73 joerg gn->path[savep] = '\0';
1916 1.73 joerg
1917 1.73 joerg if ((ptr = strrchr(gn->path, '/')) != NULL)
1918 1.73 joerg ptr++;
1919 1.73 joerg else
1920 1.73 joerg ptr = gn->path;
1921 1.73 joerg
1922 1.87 rillig Var_Set(PREFIX, ptr, gn);
1923 1.73 joerg
1924 1.73 joerg gn->path[savep] = savec;
1925 1.73 joerg } else {
1926 1.73 joerg /*
1927 1.73 joerg * The .PREFIX gets the full path if the target has
1928 1.73 joerg * no known suffix.
1929 1.73 joerg */
1930 1.73 joerg if (gn->suffix)
1931 1.73 joerg gn->suffix->refCount--;
1932 1.73 joerg gn->suffix = NULL;
1933 1.73 joerg
1934 1.73 joerg if ((ptr = strrchr(gn->path, '/')) != NULL)
1935 1.73 joerg ptr++;
1936 1.73 joerg else
1937 1.73 joerg ptr = gn->path;
1938 1.73 joerg
1939 1.87 rillig Var_Set(PREFIX, ptr, gn);
1940 1.73 joerg }
1941 1.73 joerg }
1942 1.73 joerg }
1943 1.73 joerg
1944 1.73 joerg goto sfnd_return;
1945 1.1 cgd }
1946 1.1 cgd
1947 1.1 cgd /*
1948 1.73 joerg * If the suffix indicates that the target is a library, mark that in
1949 1.73 joerg * the node's type field.
1950 1.1 cgd */
1951 1.73 joerg if (targ->suff->flags & SUFF_LIBRARY) {
1952 1.73 joerg gn->type |= OP_LIB;
1953 1.73 joerg }
1954 1.1 cgd
1955 1.73 joerg /*
1956 1.73 joerg * Check for overriding transformation rule implied by sources
1957 1.73 joerg */
1958 1.125 rillig if (!Lst_IsEmpty(gn->children)) {
1959 1.73 joerg src = SuffFindCmds(targ, slst);
1960 1.1 cgd
1961 1.73 joerg if (src != NULL) {
1962 1.73 joerg /*
1963 1.73 joerg * Free up all the Src structures in the transformation path
1964 1.73 joerg * up to, but not including, the parent node.
1965 1.73 joerg */
1966 1.73 joerg while (bottom && bottom->parent != NULL) {
1967 1.137 rillig if (Lst_FindDatum(slst, bottom) == NULL) {
1968 1.125 rillig Lst_Append(slst, bottom);
1969 1.73 joerg }
1970 1.73 joerg bottom = bottom->parent;
1971 1.1 cgd }
1972 1.73 joerg bottom = src;
1973 1.1 cgd }
1974 1.73 joerg }
1975 1.1 cgd
1976 1.73 joerg if (bottom == NULL) {
1977 1.73 joerg /*
1978 1.73 joerg * No idea from where it can come -- return now.
1979 1.73 joerg */
1980 1.73 joerg goto sfnd_abort;
1981 1.73 joerg }
1982 1.73 joerg
1983 1.73 joerg /*
1984 1.73 joerg * We now have a list of Src structures headed by 'bottom' and linked via
1985 1.73 joerg * their 'parent' pointers. What we do next is create links between
1986 1.73 joerg * source and target nodes (which may or may not have been created)
1987 1.73 joerg * and set the necessary local variables in each target. The
1988 1.73 joerg * commands for each target are set from the commands of the
1989 1.73 joerg * transformation rule used to get from the src suffix to the targ
1990 1.73 joerg * suffix. Note that this causes the commands list of the original
1991 1.73 joerg * node, gn, to be replaced by the commands of the final
1992 1.73 joerg * transformation rule. Also, the unmade field of gn is incremented.
1993 1.73 joerg * Etc.
1994 1.73 joerg */
1995 1.73 joerg if (bottom->node == NULL) {
1996 1.73 joerg bottom->node = Targ_FindNode(bottom->file, TARG_CREATE);
1997 1.1 cgd }
1998 1.1 cgd
1999 1.73 joerg for (src = bottom; src->parent != NULL; src = src->parent) {
2000 1.73 joerg targ = src->parent;
2001 1.73 joerg
2002 1.73 joerg if (src->node->suffix)
2003 1.73 joerg src->node->suffix->refCount--;
2004 1.73 joerg src->node->suffix = src->suff;
2005 1.73 joerg src->node->suffix->refCount++;
2006 1.73 joerg
2007 1.73 joerg if (targ->node == NULL) {
2008 1.73 joerg targ->node = Targ_FindNode(targ->file, TARG_CREATE);
2009 1.73 joerg }
2010 1.73 joerg
2011 1.73 joerg SuffApplyTransform(targ->node, src->node,
2012 1.73 joerg targ->suff, src->suff);
2013 1.73 joerg
2014 1.73 joerg if (targ->node != gn) {
2015 1.73 joerg /*
2016 1.73 joerg * Finish off the dependency-search process for any nodes
2017 1.73 joerg * between bottom and gn (no point in questing around the
2018 1.73 joerg * filesystem for their implicit source when it's already
2019 1.73 joerg * known). Note that the node can't have any sources that
2020 1.73 joerg * need expanding, since SuffFindThem will stop on an existing
2021 1.73 joerg * node, so all we need to do is set the standard and System V
2022 1.73 joerg * variables.
2023 1.73 joerg */
2024 1.73 joerg targ->node->type |= OP_DEPS_FOUND;
2025 1.73 joerg
2026 1.87 rillig Var_Set(PREFIX, targ->pref, targ->node);
2027 1.1 cgd
2028 1.87 rillig Var_Set(TARGET, targ->node->name, targ->node);
2029 1.1 cgd }
2030 1.1 cgd }
2031 1.1 cgd
2032 1.73 joerg if (gn->suffix)
2033 1.73 joerg gn->suffix->refCount--;
2034 1.73 joerg gn->suffix = src->suff;
2035 1.73 joerg gn->suffix->refCount++;
2036 1.73 joerg
2037 1.73 joerg /*
2038 1.73 joerg * Nuke the transformation path and the Src structures left over in the
2039 1.73 joerg * two lists.
2040 1.73 joerg */
2041 1.73 joerg sfnd_return:
2042 1.73 joerg if (bottom)
2043 1.137 rillig if (Lst_FindDatum(slst, bottom) == NULL)
2044 1.125 rillig Lst_Append(slst, bottom);
2045 1.1 cgd
2046 1.73 joerg while (SuffRemoveSrc(srcs) || SuffRemoveSrc(targs))
2047 1.73 joerg continue;
2048 1.1 cgd
2049 1.125 rillig Lst_MoveAll(slst, srcs);
2050 1.125 rillig Lst_MoveAll(slst, targs);
2051 1.1 cgd }
2052 1.13 christos
2053 1.13 christos
2054 1.134 rillig /* Find implicit sources for the target described by the graph node.
2055 1.1 cgd *
2056 1.134 rillig * Nodes are added to the graph below the passed-in node. The nodes are
2057 1.134 rillig * marked to have their IMPSRC variable filled in. The PREFIX variable is set
2058 1.134 rillig * for the given node and all its implied children.
2059 1.134 rillig *
2060 1.134 rillig * The path found by this target is the shortest path in the transformation
2061 1.134 rillig * graph, which may pass through non-existent targets, to an existing target.
2062 1.134 rillig * The search continues on all paths from the root suffix until a file is
2063 1.134 rillig * found. I.e. if there's a path .o -> .c -> .l -> .l,v from the root and the
2064 1.134 rillig * .l,v file exists but the .c and .l files don't, the search will branch out
2065 1.134 rillig * in all directions from .o and again from all the nodes on the next level
2066 1.134 rillig * until the .l,v node is encountered.
2067 1.1 cgd */
2068 1.1 cgd void
2069 1.73 joerg Suff_FindDeps(GNode *gn)
2070 1.6 jtc {
2071 1.13 christos
2072 1.73 joerg SuffFindDeps(gn, srclist);
2073 1.73 joerg while (SuffRemoveSrc(srclist))
2074 1.73 joerg continue;
2075 1.73 joerg }
2076 1.73 joerg
2077 1.73 joerg static void
2078 1.157 rillig SuffFindDeps(GNode *gn, SrcList *slst)
2079 1.73 joerg {
2080 1.127 rillig if (gn->type & OP_DEPS_FOUND)
2081 1.1 cgd return;
2082 1.127 rillig gn->type |= OP_DEPS_FOUND;
2083 1.127 rillig
2084 1.69 sjg /*
2085 1.69 sjg * Make sure we have these set, may get revised below.
2086 1.69 sjg */
2087 1.87 rillig Var_Set(TARGET, gn->path ? gn->path : gn->name, gn);
2088 1.87 rillig Var_Set(PREFIX, gn->name, gn);
2089 1.70 sjg
2090 1.140 rillig SUFF_DEBUG1("SuffFindDeps (%s)\n", gn->name);
2091 1.13 christos
2092 1.73 joerg if (gn->type & OP_ARCHV) {
2093 1.73 joerg SuffFindArchiveDeps(gn, slst);
2094 1.73 joerg } else if (gn->type & OP_LIB) {
2095 1.1 cgd /*
2096 1.1 cgd * If the node is a library, it is the arch module's job to find it
2097 1.1 cgd * and set the TARGET variable accordingly. We merely provide the
2098 1.1 cgd * search path, assuming all libraries end in ".a" (if the suffix
2099 1.1 cgd * hasn't been defined, there's nothing we can do for it, so we just
2100 1.1 cgd * set the TARGET variable to the node's name in order to give it a
2101 1.1 cgd * value).
2102 1.1 cgd */
2103 1.157 rillig SuffListNode *ln;
2104 1.1 cgd Suff *s;
2105 1.13 christos
2106 1.162 rillig ln = FindSuffByName(LIBSUFF);
2107 1.73 joerg if (gn->suffix)
2108 1.73 joerg gn->suffix->refCount--;
2109 1.73 joerg if (ln != NULL) {
2110 1.138 rillig gn->suffix = s = LstNode_Datum(ln);
2111 1.73 joerg gn->suffix->refCount++;
2112 1.73 joerg Arch_FindLib(gn, s->searchPath);
2113 1.73 joerg } else {
2114 1.73 joerg gn->suffix = NULL;
2115 1.87 rillig Var_Set(TARGET, gn->name, gn);
2116 1.73 joerg }
2117 1.1 cgd /*
2118 1.1 cgd * Because a library (-lfoo) target doesn't follow the standard
2119 1.1 cgd * filesystem conventions, we don't set the regular variables for
2120 1.1 cgd * the thing. .PREFIX is simply made empty...
2121 1.1 cgd */
2122 1.87 rillig Var_Set(PREFIX, "", gn);
2123 1.73 joerg } else {
2124 1.73 joerg SuffFindNormalDeps(gn, slst);
2125 1.73 joerg }
2126 1.73 joerg }
2127 1.71 christos
2128 1.134 rillig /* Define which suffix is the null suffix.
2129 1.134 rillig *
2130 1.134 rillig * Need to handle the changing of the null suffix gracefully so the old
2131 1.134 rillig * transformation rules don't just go away.
2132 1.1 cgd *
2133 1.39 wiz * Input:
2134 1.73 joerg * name Name of null suffix
2135 1.1 cgd */
2136 1.1 cgd void
2137 1.39 wiz Suff_SetNull(char *name)
2138 1.1 cgd {
2139 1.73 joerg Suff *s;
2140 1.157 rillig SuffListNode *ln;
2141 1.1 cgd
2142 1.162 rillig ln = FindSuffByName(name);
2143 1.73 joerg if (ln != NULL) {
2144 1.138 rillig s = LstNode_Datum(ln);
2145 1.73 joerg if (suffNull != NULL) {
2146 1.73 joerg suffNull->flags &= ~SUFF_NULL;
2147 1.73 joerg }
2148 1.73 joerg s->flags |= SUFF_NULL;
2149 1.73 joerg /*
2150 1.73 joerg * XXX: Here's where the transformation mangling would take place
2151 1.73 joerg */
2152 1.73 joerg suffNull = s;
2153 1.73 joerg } else {
2154 1.73 joerg Parse_Error(PARSE_WARNING, "Desired null suffix %s not defined.",
2155 1.73 joerg name);
2156 1.73 joerg }
2157 1.1 cgd }
2158 1.1 cgd
2159 1.127 rillig /* Initialize the suffixes module. */
2160 1.1 cgd void
2161 1.39 wiz Suff_Init(void)
2162 1.1 cgd {
2163 1.73 joerg #ifdef CLEANUP
2164 1.97 rillig suffClean = Lst_Init();
2165 1.115 rillig sufflist = Lst_Init();
2166 1.73 joerg #endif
2167 1.97 rillig srclist = Lst_Init();
2168 1.97 rillig transforms = Lst_Init();
2169 1.1 cgd
2170 1.73 joerg /*
2171 1.73 joerg * Create null suffix for single-suffix rules (POSIX). The thing doesn't
2172 1.73 joerg * actually go on the suffix list or everyone will think that's its
2173 1.73 joerg * suffix.
2174 1.73 joerg */
2175 1.75 sjg Suff_ClearSuffixes();
2176 1.1 cgd }
2177 1.5 jtc
2178 1.5 jtc
2179 1.127 rillig /* Clean up the suffixes module. */
2180 1.6 jtc void
2181 1.39 wiz Suff_End(void)
2182 1.5 jtc {
2183 1.25 mycroft #ifdef CLEANUP
2184 1.125 rillig Lst_Destroy(sufflist, SuffFree);
2185 1.125 rillig Lst_Destroy(suffClean, SuffFree);
2186 1.73 joerg if (suffNull)
2187 1.73 joerg SuffFree(suffNull);
2188 1.125 rillig Lst_Free(srclist);
2189 1.125 rillig Lst_Free(transforms);
2190 1.25 mycroft #endif
2191 1.5 jtc }
2192 1.5 jtc
2193 1.1 cgd
2194 1.73 joerg /********************* DEBUGGING FUNCTIONS **********************/
2195 1.1 cgd
2196 1.85 riastrad static int SuffPrintName(void *s, void *dummy MAKE_ATTR_UNUSED)
2197 1.6 jtc {
2198 1.83 dholland
2199 1.73 joerg fprintf(debug_file, "%s ", ((Suff *)s)->name);
2200 1.83 dholland return 0;
2201 1.6 jtc }
2202 1.1 cgd
2203 1.1 cgd static int
2204 1.85 riastrad SuffPrintSuff(void *sp, void *dummy MAKE_ATTR_UNUSED)
2205 1.1 cgd {
2206 1.51 christos Suff *s = (Suff *)sp;
2207 1.1 cgd
2208 1.63 christos fprintf(debug_file, "# `%s' [%d] ", s->name, s->refCount);
2209 1.13 christos
2210 1.122 rillig if (s->flags != 0) {
2211 1.122 rillig char flags_buf[SuffFlags_ToStringSize];
2212 1.122 rillig
2213 1.122 rillig fprintf(debug_file, " (%s)",
2214 1.122 rillig Enum_FlagsToString(flags_buf, sizeof flags_buf,
2215 1.122 rillig s->flags, SuffFlags_ToStringSpecs));
2216 1.1 cgd }
2217 1.63 christos fputc('\n', debug_file);
2218 1.63 christos fprintf(debug_file, "#\tTo: ");
2219 1.159 rillig Lst_ForEachUntil(s->parents, SuffPrintName, NULL);
2220 1.63 christos fputc('\n', debug_file);
2221 1.63 christos fprintf(debug_file, "#\tFrom: ");
2222 1.159 rillig Lst_ForEachUntil(s->children, SuffPrintName, NULL);
2223 1.63 christos fputc('\n', debug_file);
2224 1.63 christos fprintf(debug_file, "#\tSearch Path: ");
2225 1.48 christos Dir_PrintPath(s->searchPath);
2226 1.63 christos fputc('\n', debug_file);
2227 1.83 dholland return 0;
2228 1.1 cgd }
2229 1.1 cgd
2230 1.1 cgd static int
2231 1.85 riastrad SuffPrintTrans(void *tp, void *dummy MAKE_ATTR_UNUSED)
2232 1.1 cgd {
2233 1.51 christos GNode *t = (GNode *)tp;
2234 1.1 cgd
2235 1.143 rillig fprintf(debug_file, "%-16s:", t->name);
2236 1.48 christos Targ_PrintType(t->type);
2237 1.63 christos fputc('\n', debug_file);
2238 1.151 rillig Targ_PrintCmds(t);
2239 1.63 christos fputc('\n', debug_file);
2240 1.83 dholland return 0;
2241 1.1 cgd }
2242 1.1 cgd
2243 1.4 cgd void
2244 1.39 wiz Suff_PrintAll(void)
2245 1.1 cgd {
2246 1.63 christos fprintf(debug_file, "#*** Suffixes:\n");
2247 1.159 rillig Lst_ForEachUntil(sufflist, SuffPrintSuff, NULL);
2248 1.1 cgd
2249 1.63 christos fprintf(debug_file, "#*** Transformations:\n");
2250 1.159 rillig Lst_ForEachUntil(transforms, SuffPrintTrans, NULL);
2251 1.1 cgd }
2252