suff.c revision 1.296 1 1.296 rillig /* $NetBSD: suff.c,v 1.296 2020/11/22 12:00:27 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.238 rillig /*
72 1.238 rillig * Maintain suffix lists and find implicit dependents using suffix
73 1.238 rillig * transformation rules such as ".c.o".
74 1.1 cgd *
75 1.1 cgd * Interface:
76 1.238 rillig * Suff_Init Initialize the module.
77 1.1 cgd *
78 1.238 rillig * Suff_End Clean up the module.
79 1.6 jtc *
80 1.238 rillig * Suff_DoPaths Extend the search path of each suffix to include the
81 1.238 rillig * default search path.
82 1.170 rillig *
83 1.170 rillig * Suff_ClearSuffixes
84 1.238 rillig * Clear out all the suffixes and transformations.
85 1.170 rillig *
86 1.170 rillig * Suff_IsTransform
87 1.238 rillig * See if the passed string is a transformation rule.
88 1.170 rillig *
89 1.170 rillig * Suff_AddSuffix Add the passed string as another known suffix.
90 1.170 rillig *
91 1.170 rillig * Suff_GetPath Return the search path for the given suffix.
92 1.170 rillig *
93 1.170 rillig * Suff_AddInclude
94 1.170 rillig * Mark the given suffix as denoting an include file.
95 1.170 rillig *
96 1.170 rillig * Suff_AddLib Mark the given suffix as denoting a library.
97 1.170 rillig *
98 1.170 rillig * Suff_AddTransform
99 1.238 rillig * Add another transformation to the suffix graph.
100 1.170 rillig *
101 1.170 rillig * Suff_SetNull Define the suffix to consider the suffix of
102 1.170 rillig * any file that doesn't have a known one.
103 1.170 rillig *
104 1.170 rillig * Suff_FindDeps Find implicit sources for and the location of
105 1.170 rillig * a target based on its suffix. Returns the
106 1.170 rillig * bottom-most node added to the graph or NULL
107 1.170 rillig * if the target had no implicit sources.
108 1.1 cgd *
109 1.170 rillig * Suff_FindPath Return the appropriate path to search in order to
110 1.170 rillig * find the node.
111 1.1 cgd */
112 1.1 cgd
113 1.176 rillig #include "make.h"
114 1.176 rillig #include "dir.h"
115 1.1 cgd
116 1.155 rillig /* "@(#)suff.c 8.4 (Berkeley) 3/21/94" */
117 1.296 rillig MAKE_RCSID("$NetBSD: suff.c,v 1.296 2020/11/22 12:00:27 rillig Exp $");
118 1.155 rillig
119 1.171 rillig #define SUFF_DEBUG0(text) DEBUG0(SUFF, text)
120 1.171 rillig #define SUFF_DEBUG1(fmt, arg1) DEBUG1(SUFF, fmt, arg1)
121 1.171 rillig #define SUFF_DEBUG2(fmt, arg1, arg2) DEBUG2(SUFF, fmt, arg1, arg2)
122 1.140 rillig
123 1.269 rillig typedef List SuffixList;
124 1.269 rillig typedef ListNode SuffixListNode;
125 1.157 rillig
126 1.283 rillig typedef List CandidateList;
127 1.283 rillig typedef ListNode CandidateListNode;
128 1.157 rillig
129 1.269 rillig static SuffixList *sufflist; /* List of suffixes */
130 1.73 joerg #ifdef CLEANUP
131 1.269 rillig static SuffixList *suffClean; /* List of suffixes to be cleaned */
132 1.73 joerg #endif
133 1.250 rillig
134 1.238 rillig /* List of transformation rules, such as ".c.o" */
135 1.238 rillig static GNodeList *transforms;
136 1.238 rillig
137 1.238 rillig static int sNum = 0; /* Counter for assigning suffix numbers */
138 1.1 cgd
139 1.270 rillig typedef enum SuffixFlags {
140 1.96 rillig SUFF_INCLUDE = 0x01, /* One which is #include'd */
141 1.96 rillig SUFF_LIBRARY = 0x02, /* One which contains a library */
142 1.96 rillig SUFF_NULL = 0x04 /* The empty suffix */
143 1.122 rillig /* XXX: Why is SUFF_NULL needed? Wouldn't nameLen == 0 mean the same? */
144 1.270 rillig } SuffixFlags;
145 1.96 rillig
146 1.270 rillig ENUM_FLAGS_RTTI_3(SuffixFlags,
147 1.122 rillig SUFF_INCLUDE, SUFF_LIBRARY, SUFF_NULL);
148 1.122 rillig
149 1.269 rillig typedef List SuffixListList;
150 1.157 rillig
151 1.273 rillig /*
152 1.273 rillig * A suffix such as ".c" or ".o" that is used in suffix transformation rules
153 1.273 rillig * such as ".c.o:".
154 1.273 rillig */
155 1.268 rillig typedef struct Suffix {
156 1.238 rillig /* The suffix itself, such as ".c" */
157 1.238 rillig char *name;
158 1.238 rillig /* Length of the name, to avoid strlen calls */
159 1.238 rillig size_t nameLen;
160 1.238 rillig /* Type of suffix */
161 1.270 rillig SuffixFlags flags;
162 1.238 rillig /* The path along which files of this suffix may be found */
163 1.238 rillig SearchPath *searchPath;
164 1.238 rillig /* The suffix number; TODO: document the purpose of this number */
165 1.238 rillig int sNum;
166 1.238 rillig /* Reference count of list membership and several other places */
167 1.238 rillig int refCount;
168 1.238 rillig /* Suffixes we have a transformation to */
169 1.269 rillig SuffixList *parents;
170 1.238 rillig /* Suffixes we have a transformation from */
171 1.269 rillig SuffixList *children;
172 1.237 rillig
173 1.237 rillig /* Lists in which this suffix is referenced.
174 1.237 rillig * XXX: These lists are used nowhere, they are just appended to, for no
175 1.237 rillig * apparent reason. They do have the side effect of increasing refCount
176 1.237 rillig * though. */
177 1.269 rillig SuffixListList *ref;
178 1.268 rillig } Suffix;
179 1.1 cgd
180 1.1 cgd /*
181 1.273 rillig * A candidate when searching for implied sources.
182 1.273 rillig *
183 1.273 rillig * For example, when "src.o" is to be made, a typical candidate is "src.c"
184 1.273 rillig * via the transformation rule ".c.o". If that doesn't exist, maybe there is
185 1.273 rillig * another transformation rule ".pas.c" that would make "src.pas" an indirect
186 1.273 rillig * candidate as well. The first such chain that leads to an existing file or
187 1.282 rillig * node is finally chosen to be made.
188 1.1 cgd */
189 1.282 rillig typedef struct Candidate {
190 1.296 rillig /* The file or node to look for. */
191 1.296 rillig char *file;
192 1.296 rillig /* The prefix from which file was formed.
193 1.296 rillig * Its memory is shared among all candidates. */
194 1.296 rillig /* XXX: rename to prefix */
195 1.296 rillig char *pref;
196 1.296 rillig /* The suffix on the file. */
197 1.296 rillig Suffix *suff;
198 1.296 rillig
199 1.296 rillig /* The candidate that can be made from this,
200 1.296 rillig * or NULL for the top-level candidate. */
201 1.296 rillig struct Candidate *parent;
202 1.296 rillig /* The node describing the file. */
203 1.296 rillig GNode *node;
204 1.296 rillig
205 1.296 rillig /* Count of existing children, only used for memory management, so we
206 1.296 rillig * don't free this candidate too early or too late. */
207 1.296 rillig int numChildren;
208 1.73 joerg #ifdef DEBUG_SRC
209 1.283 rillig CandidateList *childrenList;
210 1.73 joerg #endif
211 1.282 rillig } Candidate;
212 1.1 cgd
213 1.273 rillig
214 1.267 rillig /* TODO: Document the difference between nullSuff and emptySuff. */
215 1.238 rillig /* The NULL suffix for this run */
216 1.268 rillig static Suffix *nullSuff;
217 1.238 rillig /* The empty suffix required for POSIX single-suffix transformation rules */
218 1.268 rillig static Suffix *emptySuff;
219 1.1 cgd
220 1.4 cgd
221 1.268 rillig static Suffix *
222 1.271 rillig Suffix_Ref(Suffix *suff)
223 1.260 rillig {
224 1.260 rillig suff->refCount++;
225 1.260 rillig return suff;
226 1.260 rillig }
227 1.260 rillig
228 1.268 rillig /* Change the value of a Suffix variable, adjusting the reference counts. */
229 1.259 rillig static void
230 1.271 rillig Suffix_Reassign(Suffix **var, Suffix *suff)
231 1.259 rillig {
232 1.259 rillig if (*var != NULL)
233 1.259 rillig (*var)->refCount--;
234 1.259 rillig *var = suff;
235 1.259 rillig suff->refCount++;
236 1.259 rillig }
237 1.259 rillig
238 1.268 rillig /* Set a Suffix variable to NULL, adjusting the reference count. */
239 1.259 rillig static void
240 1.271 rillig Suffix_Unassign(Suffix **var)
241 1.259 rillig {
242 1.259 rillig if (*var != NULL)
243 1.259 rillig (*var)->refCount--;
244 1.259 rillig *var = NULL;
245 1.259 rillig }
246 1.259 rillig
247 1.238 rillig /*
248 1.238 rillig * See if pref is a prefix of str.
249 1.238 rillig * Return NULL if it ain't, pointer to character in str after prefix if so.
250 1.1 cgd */
251 1.67 dsl static const char *
252 1.292 rillig StrTrimPrefix(const char *pref, const char *str)
253 1.1 cgd {
254 1.1 cgd while (*str && *pref == *str) {
255 1.1 cgd pref++;
256 1.1 cgd str++;
257 1.1 cgd }
258 1.1 cgd
259 1.239 rillig return *pref != '\0' ? NULL : str;
260 1.1 cgd }
261 1.1 cgd
262 1.238 rillig /*
263 1.293 rillig * See if suff is a suffix of str, and if so, return the pointer to the suffix
264 1.293 rillig * in str, which at the same time marks the end of the prefix.
265 1.1 cgd */
266 1.221 rillig static const char *
267 1.293 rillig StrTrimSuffix(const char *str, size_t strLen, const char *suff, size_t suffLen)
268 1.1 cgd {
269 1.293 rillig const char *suffInStr;
270 1.291 rillig size_t i;
271 1.1 cgd
272 1.293 rillig if (strLen < suffLen)
273 1.279 rillig return NULL;
274 1.1 cgd
275 1.293 rillig suffInStr = str + strLen - suffLen;
276 1.293 rillig for (i = 0; i < suffLen; i++)
277 1.293 rillig if (suff[i] != suffInStr[i])
278 1.279 rillig return NULL;
279 1.293 rillig
280 1.293 rillig return suffInStr;
281 1.293 rillig }
282 1.293 rillig
283 1.293 rillig /*
284 1.293 rillig * See if suff is a suffix of name, and if so, return the end of the prefix
285 1.293 rillig * in name.
286 1.293 rillig */
287 1.293 rillig static const char *
288 1.293 rillig Suffix_TrimSuffix(const Suffix *suff, size_t nameLen, const char *nameEnd)
289 1.293 rillig {
290 1.293 rillig return StrTrimSuffix(nameEnd - nameLen, nameLen, suff->name, suff->nameLen);
291 1.1 cgd }
292 1.1 cgd
293 1.129 rillig static Boolean
294 1.271 rillig Suffix_IsSuffix(const Suffix *suff, size_t nameLen, const char *nameEnd)
295 1.1 cgd {
296 1.293 rillig return Suffix_TrimSuffix(suff, nameLen, nameEnd) != NULL;
297 1.1 cgd }
298 1.1 cgd
299 1.268 rillig static Suffix *
300 1.271 rillig FindSuffixByNameLen(const char *name, size_t nameLen)
301 1.1 cgd {
302 1.269 rillig SuffixListNode *ln;
303 1.162 rillig
304 1.162 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next) {
305 1.268 rillig Suffix *suff = ln->datum;
306 1.221 rillig if (suff->nameLen == nameLen && memcmp(suff->name, name, nameLen) == 0)
307 1.178 rillig return suff;
308 1.162 rillig }
309 1.162 rillig return NULL;
310 1.1 cgd }
311 1.1 cgd
312 1.268 rillig static Suffix *
313 1.271 rillig FindSuffixByName(const char *name)
314 1.221 rillig {
315 1.271 rillig return FindSuffixByNameLen(name, strlen(name));
316 1.221 rillig }
317 1.221 rillig
318 1.210 rillig static GNode *
319 1.210 rillig FindTransformByName(const char *name)
320 1.1 cgd {
321 1.210 rillig GNodeListNode *ln;
322 1.210 rillig for (ln = transforms->first; ln != NULL; ln = ln->next) {
323 1.228 rillig GNode *gn = ln->datum;
324 1.228 rillig if (strcmp(gn->name, name) == 0)
325 1.228 rillig return gn;
326 1.210 rillig }
327 1.210 rillig return NULL;
328 1.1 cgd }
329 1.1 cgd
330 1.73 joerg static void
331 1.269 rillig SuffixList_Unref(SuffixList *list, Suffix *suff)
332 1.73 joerg {
333 1.269 rillig SuffixListNode *ln = Lst_FindDatum(list, suff);
334 1.73 joerg if (ln != NULL) {
335 1.198 rillig Lst_Remove(list, ln);
336 1.198 rillig suff->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.271 rillig Suffix_Free(Suffix *suff)
343 1.71 christos {
344 1.6 jtc
345 1.267 rillig if (suff == nullSuff)
346 1.267 rillig nullSuff = NULL;
347 1.6 jtc
348 1.233 rillig if (suff == emptySuff)
349 1.73 joerg emptySuff = NULL;
350 1.6 jtc
351 1.198 rillig #if 0
352 1.73 joerg /* We don't delete suffixes in order, so we cannot use this */
353 1.239 rillig if (suff->refCount != 0)
354 1.233 rillig Punt("Internal error deleting suffix `%s' with refcount = %d",
355 1.233 rillig suff->name, suff->refCount);
356 1.73 joerg #endif
357 1.6 jtc
358 1.233 rillig Lst_Free(suff->ref);
359 1.233 rillig Lst_Free(suff->children);
360 1.233 rillig Lst_Free(suff->parents);
361 1.233 rillig Lst_Destroy(suff->searchPath, Dir_Destroy);
362 1.19 christos
363 1.233 rillig free(suff->name);
364 1.233 rillig free(suff);
365 1.1 cgd }
366 1.1 cgd
367 1.271 rillig static void
368 1.271 rillig SuffFree(void *p)
369 1.271 rillig {
370 1.271 rillig Suffix_Free(p);
371 1.271 rillig }
372 1.271 rillig
373 1.134 rillig /* Remove the suffix from the list, and free if it is otherwise unused. */
374 1.6 jtc static void
375 1.269 rillig SuffixList_Remove(SuffixList *list, Suffix *suff)
376 1.6 jtc {
377 1.269 rillig SuffixList_Unref(list, suff);
378 1.198 rillig if (suff->refCount == 0) {
379 1.238 rillig /* XXX: can lead to suff->refCount == -1 */
380 1.269 rillig SuffixList_Unref(sufflist, suff);
381 1.257 rillig DEBUG1(SUFF, "Removing suffix \"%s\"\n", suff->name);
382 1.198 rillig SuffFree(suff);
383 1.73 joerg }
384 1.6 jtc }
385 1.101 rillig
386 1.198 rillig /* Insert the suffix into the list, keeping the list ordered by suffix
387 1.238 rillig * number. */
388 1.73 joerg static void
389 1.269 rillig SuffixList_Insert(SuffixList *list, Suffix *suff)
390 1.1 cgd {
391 1.269 rillig SuffixListNode *ln;
392 1.268 rillig Suffix *listSuff = NULL;
393 1.71 christos
394 1.198 rillig for (ln = list->first; ln != NULL; ln = ln->next) {
395 1.198 rillig listSuff = ln->datum;
396 1.198 rillig if (listSuff->sNum >= suff->sNum)
397 1.73 joerg break;
398 1.73 joerg }
399 1.71 christos
400 1.73 joerg if (ln == NULL) {
401 1.198 rillig SUFF_DEBUG2("inserting \"%s\" (%d) at end of list\n",
402 1.198 rillig suff->name, suff->sNum);
403 1.271 rillig Lst_Append(list, Suffix_Ref(suff));
404 1.198 rillig Lst_Append(suff->ref, list);
405 1.198 rillig } else if (listSuff->sNum != suff->sNum) {
406 1.278 rillig DEBUG4(SUFF, "inserting \"%s\" (%d) before \"%s\" (%d)\n",
407 1.278 rillig suff->name, suff->sNum, listSuff->name, listSuff->sNum);
408 1.271 rillig Lst_InsertBefore(list, ln, Suffix_Ref(suff));
409 1.198 rillig Lst_Append(suff->ref, list);
410 1.140 rillig } else {
411 1.198 rillig SUFF_DEBUG2("\"%s\" (%d) is already there\n", suff->name, suff->sNum);
412 1.73 joerg }
413 1.71 christos }
414 1.1 cgd
415 1.246 rillig static void
416 1.281 rillig Relate(Suffix *srcSuff, Suffix *targSuff)
417 1.246 rillig {
418 1.269 rillig SuffixList_Insert(targSuff->children, srcSuff);
419 1.269 rillig SuffixList_Insert(srcSuff->parents, targSuff);
420 1.246 rillig }
421 1.246 rillig
422 1.268 rillig static Suffix *
423 1.271 rillig Suffix_New(const char *name)
424 1.117 rillig {
425 1.268 rillig Suffix *suff = bmake_malloc(sizeof *suff);
426 1.117 rillig
427 1.233 rillig suff->name = bmake_strdup(name);
428 1.233 rillig suff->nameLen = strlen(suff->name);
429 1.233 rillig suff->searchPath = Lst_New();
430 1.233 rillig suff->children = Lst_New();
431 1.233 rillig suff->parents = Lst_New();
432 1.233 rillig suff->ref = Lst_New();
433 1.233 rillig suff->sNum = sNum++;
434 1.233 rillig suff->flags = 0;
435 1.238 rillig suff->refCount = 1; /* XXX: why 1? It's not assigned anywhere yet. */
436 1.117 rillig
437 1.233 rillig return suff;
438 1.117 rillig }
439 1.117 rillig
440 1.238 rillig /*
441 1.238 rillig * Nuke the list of suffixes but keep all transformation rules around. The
442 1.238 rillig * transformation graph is destroyed in this process, but we leave the list
443 1.238 rillig * of rules so when a new graph is formed, the rules will remain. This
444 1.238 rillig * function is called when a line '.SUFFIXES:' with an empty suffixes list is
445 1.238 rillig * encountered in a makefile.
446 1.238 rillig */
447 1.73 joerg void
448 1.73 joerg Suff_ClearSuffixes(void)
449 1.71 christos {
450 1.73 joerg #ifdef CLEANUP
451 1.125 rillig Lst_MoveAll(suffClean, sufflist);
452 1.73 joerg #endif
453 1.257 rillig DEBUG0(SUFF, "Clearing all suffixes\n");
454 1.180 rillig sufflist = Lst_New();
455 1.73 joerg sNum = 0;
456 1.267 rillig if (nullSuff != NULL)
457 1.267 rillig SuffFree(nullSuff);
458 1.271 rillig emptySuff = nullSuff = Suffix_New("");
459 1.75 sjg
460 1.267 rillig Dir_Concat(nullSuff->searchPath, dirSearchPath);
461 1.267 rillig nullSuff->flags = SUFF_NULL;
462 1.1 cgd }
463 1.1 cgd
464 1.196 rillig /* Parse a transformation string such as ".c.o" to find its two component
465 1.196 rillig * suffixes (the source ".c" and the target ".o"). If there are no such
466 1.196 rillig * suffixes, try a single-suffix transformation as well.
467 1.1 cgd *
468 1.196 rillig * Return TRUE if the string is a valid transformation.
469 1.1 cgd */
470 1.73 joerg static Boolean
471 1.281 rillig ParseTransform(const char *str, Suffix **out_src, Suffix **out_targ)
472 1.39 wiz {
473 1.269 rillig SuffixListNode *ln;
474 1.288 rillig Suffix *single = NULL;
475 1.73 joerg
476 1.73 joerg /*
477 1.73 joerg * Loop looking first for a suffix that matches the start of the
478 1.73 joerg * string and then for one that exactly matches the rest of it. If
479 1.73 joerg * we can find two that meet these criteria, we've successfully
480 1.73 joerg * parsed the string.
481 1.73 joerg */
482 1.196 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next) {
483 1.268 rillig Suffix *src = ln->datum;
484 1.197 rillig
485 1.292 rillig if (StrTrimPrefix(src->name, str) == NULL)
486 1.196 rillig continue;
487 1.196 rillig
488 1.196 rillig if (str[src->nameLen] == '\0') {
489 1.288 rillig single = src;
490 1.73 joerg } else {
491 1.271 rillig Suffix *targ = FindSuffixByName(str + src->nameLen);
492 1.166 rillig if (targ != NULL) {
493 1.134 rillig *out_src = src;
494 1.166 rillig *out_targ = targ;
495 1.88 rillig return TRUE;
496 1.73 joerg }
497 1.73 joerg }
498 1.73 joerg }
499 1.196 rillig
500 1.288 rillig if (single != NULL) {
501 1.196 rillig /*
502 1.287 rillig * There was a suffix that encompassed the entire string, so we
503 1.287 rillig * assume it was a transformation to the null suffix (thank you
504 1.287 rillig * POSIX; search for "single suffix" or "single-suffix").
505 1.287 rillig *
506 1.287 rillig * We still prefer to find a double rule over a singleton,
507 1.287 rillig * hence we leave this check until the end.
508 1.196 rillig *
509 1.267 rillig * XXX: Use emptySuff over nullSuff?
510 1.196 rillig */
511 1.288 rillig *out_src = single;
512 1.267 rillig *out_targ = nullSuff;
513 1.196 rillig return TRUE;
514 1.196 rillig }
515 1.196 rillig return FALSE;
516 1.1 cgd }
517 1.1 cgd
518 1.134 rillig /* Return TRUE if the given string is a transformation rule, that is, a
519 1.238 rillig * concatenation of two known suffixes such as ".c.o" or a single suffix
520 1.238 rillig * such as ".o". */
521 1.73 joerg Boolean
522 1.167 rillig Suff_IsTransform(const char *str)
523 1.1 cgd {
524 1.268 rillig Suffix *src, *targ;
525 1.1 cgd
526 1.281 rillig return ParseTransform(str, &src, &targ);
527 1.1 cgd }
528 1.1 cgd
529 1.210 rillig /* Add the transformation rule to the list of rules and place the
530 1.210 rillig * transformation itself in the graph.
531 1.210 rillig *
532 1.210 rillig * The transformation is linked to the two suffixes mentioned in the name.
533 1.1 cgd *
534 1.73 joerg * Input:
535 1.210 rillig * name must have the form ".from.to" or just ".from"
536 1.39 wiz *
537 1.73 joerg * Results:
538 1.210 rillig * The created or existing transformation node in the transforms list
539 1.1 cgd */
540 1.73 joerg GNode *
541 1.210 rillig Suff_AddTransform(const char *name)
542 1.1 cgd {
543 1.268 rillig Suffix *srcSuff;
544 1.268 rillig Suffix *targSuff;
545 1.1 cgd
546 1.233 rillig GNode *gn = FindTransformByName(name);
547 1.210 rillig if (gn == NULL) {
548 1.73 joerg /*
549 1.73 joerg * Make a new graph node for the transformation. It will be filled in
550 1.73 joerg * by the Parse module.
551 1.73 joerg */
552 1.244 rillig gn = GNode_New(name);
553 1.125 rillig Lst_Append(transforms, gn);
554 1.73 joerg } else {
555 1.73 joerg /*
556 1.73 joerg * New specification for transformation rule. Just nuke the old list
557 1.73 joerg * of commands so they can be filled in again... We don't actually
558 1.73 joerg * free the commands themselves, because a given command can be
559 1.73 joerg * attached to several different transformations.
560 1.73 joerg */
561 1.125 rillig Lst_Free(gn->commands);
562 1.125 rillig Lst_Free(gn->children);
563 1.180 rillig gn->commands = Lst_New();
564 1.180 rillig gn->children = Lst_New();
565 1.73 joerg }
566 1.1 cgd
567 1.73 joerg gn->type = OP_TRANSFORM;
568 1.1 cgd
569 1.233 rillig {
570 1.281 rillig Boolean ok = ParseTransform(name, &srcSuff, &targSuff);
571 1.233 rillig assert(ok);
572 1.233 rillig (void)ok;
573 1.233 rillig }
574 1.1 cgd
575 1.73 joerg /*
576 1.73 joerg * link the two together in the proper relationship and order
577 1.73 joerg */
578 1.140 rillig SUFF_DEBUG2("defining transformation from `%s' to `%s'\n",
579 1.233 rillig srcSuff->name, targSuff->name);
580 1.281 rillig Relate(srcSuff, targSuff);
581 1.1 cgd
582 1.88 rillig return gn;
583 1.1 cgd }
584 1.1 cgd
585 1.134 rillig /* Handle the finish of a transformation definition, removing the
586 1.134 rillig * transformation from the graph if it has neither commands nor sources.
587 1.134 rillig *
588 1.134 rillig * If the node has no commands or children, the children and parents lists
589 1.134 rillig * of the affected suffixes are altered.
590 1.71 christos *
591 1.73 joerg * Input:
592 1.150 rillig * gn Node for transformation
593 1.1 cgd */
594 1.150 rillig void
595 1.150 rillig Suff_EndTransform(GNode *gn)
596 1.1 cgd {
597 1.268 rillig Suffix *srcSuff, *targSuff;
598 1.269 rillig SuffixList *srcSuffParents;
599 1.253 rillig
600 1.125 rillig if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(gn->cohorts))
601 1.195 rillig gn = gn->cohorts->last->datum;
602 1.238 rillig
603 1.253 rillig if (!(gn->type & OP_TRANSFORM))
604 1.253 rillig return;
605 1.253 rillig
606 1.253 rillig if (!Lst_IsEmpty(gn->commands) || !Lst_IsEmpty(gn->children)) {
607 1.253 rillig SUFF_DEBUG1("transformation %s complete\n", gn->name);
608 1.253 rillig return;
609 1.253 rillig }
610 1.73 joerg
611 1.253 rillig /*
612 1.253 rillig * SuffParseTransform() may fail for special rules which are not
613 1.253 rillig * actual transformation rules. (e.g. .DEFAULT)
614 1.253 rillig */
615 1.281 rillig if (!ParseTransform(gn->name, &srcSuff, &targSuff))
616 1.253 rillig return;
617 1.233 rillig
618 1.254 rillig SUFF_DEBUG2("deleting incomplete transformation from `%s' to `%s'\n",
619 1.254 rillig srcSuff->name, targSuff->name);
620 1.254 rillig
621 1.269 rillig /* Remember parents since srcSuff could be deleted in SuffixList_Remove. */
622 1.253 rillig srcSuffParents = srcSuff->parents;
623 1.269 rillig SuffixList_Remove(targSuff->children, srcSuff);
624 1.269 rillig SuffixList_Remove(srcSuffParents, targSuff);
625 1.1 cgd }
626 1.1 cgd
627 1.217 rillig /* Called from Suff_AddSuffix to search through the list of
628 1.134 rillig * existing transformation rules and rebuild the transformation graph when
629 1.134 rillig * it has been destroyed by Suff_ClearSuffixes. If the given rule is a
630 1.134 rillig * transformation involving this suffix and another, existing suffix, the
631 1.134 rillig * proper relationship is established between the two.
632 1.134 rillig *
633 1.134 rillig * The appropriate links will be made between this suffix and others if
634 1.134 rillig * transformation rules exist for it.
635 1.1 cgd *
636 1.39 wiz * Input:
637 1.192 rillig * transform Transformation to test
638 1.219 rillig * suff Suffix to rebuild
639 1.1 cgd */
640 1.165 rillig static void
641 1.281 rillig RebuildGraph(GNode *transform, Suffix *suff)
642 1.6 jtc {
643 1.221 rillig const char *name = transform->name;
644 1.207 rillig size_t nameLen = strlen(name);
645 1.221 rillig const char *toName;
646 1.73 joerg
647 1.73 joerg /*
648 1.73 joerg * First see if it is a transformation from this suffix.
649 1.73 joerg */
650 1.292 rillig toName = StrTrimPrefix(suff->name, name);
651 1.221 rillig if (toName != NULL) {
652 1.271 rillig Suffix *to = FindSuffixByName(toName);
653 1.219 rillig if (to != NULL) {
654 1.166 rillig /* Link in and return, since it can't be anything else. */
655 1.281 rillig Relate(suff, to);
656 1.165 rillig return;
657 1.73 joerg }
658 1.73 joerg }
659 1.1 cgd
660 1.73 joerg /*
661 1.73 joerg * Not from, maybe to?
662 1.73 joerg */
663 1.293 rillig toName = Suffix_TrimSuffix(suff, nameLen, name + nameLen);
664 1.221 rillig if (toName != NULL) {
665 1.271 rillig Suffix *from = FindSuffixByNameLen(name, (size_t)(toName - name));
666 1.246 rillig if (from != NULL)
667 1.281 rillig Relate(from, suff);
668 1.1 cgd }
669 1.71 christos }
670 1.71 christos
671 1.186 rillig /* During Suff_AddSuffix, search through the list of existing targets and find
672 1.186 rillig * if any of the existing targets can be turned into a transformation rule.
673 1.134 rillig *
674 1.134 rillig * If such a target is found and the target is the current main target, the
675 1.134 rillig * main target is set to NULL and the next target examined (if that exists)
676 1.134 rillig * becomes the main target.
677 1.71 christos *
678 1.73 joerg * Results:
679 1.186 rillig * TRUE iff a new main target has been selected.
680 1.71 christos */
681 1.186 rillig static Boolean
682 1.281 rillig UpdateTarget(GNode *target, GNode **inout_main, Suffix *suff,
683 1.264 rillig Boolean *inout_removedMain)
684 1.71 christos {
685 1.268 rillig Suffix *srcSuff, *targSuff;
686 1.170 rillig char *ptr;
687 1.73 joerg
688 1.264 rillig if (*inout_main == NULL && *inout_removedMain &&
689 1.264 rillig !(target->type & OP_NOTARGET)) {
690 1.188 rillig *inout_main = target;
691 1.73 joerg Targ_SetMain(target);
692 1.284 rillig /*
693 1.284 rillig * XXX: Why could it be a good idea to return TRUE here?
694 1.284 rillig * The main task of this function is to turn ordinary nodes into
695 1.284 rillig * transformations, no matter whether or not a new .MAIN node
696 1.284 rillig * has been found.
697 1.284 rillig */
698 1.289 rillig /*
699 1.289 rillig * XXX: Even when changing this to FALSE, none of the existing unit
700 1.289 rillig * tests fails.
701 1.289 rillig */
702 1.186 rillig return TRUE;
703 1.73 joerg }
704 1.73 joerg
705 1.108 rillig if (target->type == OP_TRANSFORM)
706 1.186 rillig return FALSE;
707 1.73 joerg
708 1.258 rillig /*
709 1.258 rillig * XXX: What about a transformation ".cpp.c"? If ".c" is added as a new
710 1.258 rillig * suffix, it seems wrong that this transformation would be skipped just
711 1.258 rillig * because ".c" happens to be a prefix of ".cpp".
712 1.258 rillig */
713 1.263 rillig ptr = strstr(target->name, suff->name);
714 1.263 rillig if (ptr == NULL)
715 1.263 rillig return FALSE;
716 1.263 rillig
717 1.263 rillig /*
718 1.263 rillig * XXX: In suff-rebuild.mk, in the line '.SUFFIXES: .c .b .a', this
719 1.263 rillig * condition prevents the rule '.b.c' from being added again during
720 1.263 rillig * Suff_AddSuffix(".b").
721 1.263 rillig *
722 1.263 rillig * XXX: Removing this paragraph makes suff-add-later.mk use massive
723 1.263 rillig * amounts of memory.
724 1.263 rillig */
725 1.263 rillig if (ptr == target->name)
726 1.186 rillig return FALSE;
727 1.73 joerg
728 1.281 rillig if (ParseTransform(target->name, &srcSuff, &targSuff)) {
729 1.188 rillig if (*inout_main == target) {
730 1.264 rillig *inout_removedMain = TRUE;
731 1.188 rillig *inout_main = NULL;
732 1.73 joerg Targ_SetMain(NULL);
733 1.71 christos }
734 1.125 rillig Lst_Free(target->children);
735 1.180 rillig target->children = Lst_New();
736 1.73 joerg target->type = OP_TRANSFORM;
737 1.73 joerg /*
738 1.73 joerg * link the two together in the proper relationship and order
739 1.73 joerg */
740 1.140 rillig SUFF_DEBUG2("defining transformation from `%s' to `%s'\n",
741 1.233 rillig srcSuff->name, targSuff->name);
742 1.281 rillig Relate(srcSuff, targSuff);
743 1.71 christos }
744 1.186 rillig return FALSE;
745 1.14 christos }
746 1.14 christos
747 1.187 rillig /* Look at all existing targets to see if adding this suffix will make one
748 1.187 rillig * of the current targets mutate into a suffix rule.
749 1.187 rillig *
750 1.187 rillig * This is ugly, but other makes treat all targets that start with a '.' as
751 1.187 rillig * suffix rules. */
752 1.187 rillig static void
753 1.268 rillig UpdateTargets(GNode **inout_main, Suffix *suff)
754 1.187 rillig {
755 1.187 rillig Boolean r = FALSE;
756 1.187 rillig GNodeListNode *ln;
757 1.187 rillig for (ln = Targ_List()->first; ln != NULL; ln = ln->next) {
758 1.187 rillig GNode *gn = ln->datum;
759 1.281 rillig if (UpdateTarget(gn, inout_main, suff, &r))
760 1.187 rillig break;
761 1.187 rillig }
762 1.187 rillig }
763 1.187 rillig
764 1.134 rillig /* Add the suffix to the end of the list of known suffixes.
765 1.134 rillig * Should we restructure the suffix graph? Make doesn't...
766 1.134 rillig *
767 1.268 rillig * A GNode is created for the suffix and a Suffix structure is created and
768 1.134 rillig * added to the suffixes list unless the suffix was already known.
769 1.134 rillig * The mainNode passed can be modified if a target mutated into a
770 1.134 rillig * transform and that target happened to be the main target.
771 1.1 cgd *
772 1.39 wiz * Input:
773 1.134 rillig * name the name of the suffix to add
774 1.1 cgd */
775 1.1 cgd void
776 1.188 rillig Suff_AddSuffix(const char *name, GNode **inout_main)
777 1.1 cgd {
778 1.192 rillig GNodeListNode *ln;
779 1.192 rillig
780 1.271 rillig Suffix *suff = FindSuffixByName(name);
781 1.255 rillig if (suff != NULL)
782 1.166 rillig return;
783 1.166 rillig
784 1.271 rillig suff = Suffix_New(name);
785 1.255 rillig Lst_Append(sufflist, suff);
786 1.256 rillig DEBUG1(SUFF, "Adding suffix \"%s\"\n", suff->name);
787 1.73 joerg
788 1.255 rillig UpdateTargets(inout_main, suff);
789 1.71 christos
790 1.166 rillig /*
791 1.166 rillig * Look for any existing transformations from or to this suffix.
792 1.166 rillig * XXX: Only do this after a Suff_ClearSuffixes?
793 1.166 rillig */
794 1.192 rillig for (ln = transforms->first; ln != NULL; ln = ln->next)
795 1.281 rillig RebuildGraph(ln->datum, suff);
796 1.1 cgd }
797 1.1 cgd
798 1.134 rillig /* Return the search path for the given suffix, or NULL. */
799 1.157 rillig SearchPath *
800 1.167 rillig Suff_GetPath(const char *sname)
801 1.1 cgd {
802 1.271 rillig Suffix *suff = FindSuffixByName(sname);
803 1.255 rillig return suff != NULL ? suff->searchPath : NULL;
804 1.1 cgd }
805 1.1 cgd
806 1.238 rillig /*
807 1.238 rillig * Extend the search paths for all suffixes to include the default search
808 1.238 rillig * path (dirSearchPath).
809 1.1 cgd *
810 1.238 rillig * The default search path can be defined using the special target '.PATH'.
811 1.238 rillig * The search path of each suffix can be defined using the special target
812 1.238 rillig * '.PATH<suffix>'.
813 1.238 rillig *
814 1.238 rillig * If paths were specified for the ".h" suffix, the directories are stuffed
815 1.238 rillig * into a global variable called ".INCLUDES" with each directory preceded by
816 1.238 rillig * '-I'. The same is done for the ".a" suffix, except the variable is called
817 1.238 rillig * ".LIBS" and the flag is '-L'.
818 1.1 cgd */
819 1.1 cgd void
820 1.39 wiz Suff_DoPaths(void)
821 1.1 cgd {
822 1.269 rillig SuffixListNode *ln;
823 1.157 rillig char *ptr;
824 1.157 rillig SearchPath *inIncludes; /* Cumulative .INCLUDES path */
825 1.157 rillig SearchPath *inLibs; /* Cumulative .LIBS path */
826 1.1 cgd
827 1.180 rillig inIncludes = Lst_New();
828 1.180 rillig inLibs = Lst_New();
829 1.1 cgd
830 1.181 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next) {
831 1.268 rillig Suffix *suff = ln->datum;
832 1.255 rillig if (!Lst_IsEmpty(suff->searchPath)) {
833 1.1 cgd #ifdef INCLUDES
834 1.255 rillig if (suff->flags & SUFF_INCLUDE)
835 1.255 rillig Dir_Concat(inIncludes, suff->searchPath);
836 1.154 rillig #endif
837 1.1 cgd #ifdef LIBRARIES
838 1.255 rillig if (suff->flags & SUFF_LIBRARY)
839 1.255 rillig Dir_Concat(inLibs, suff->searchPath);
840 1.154 rillig #endif
841 1.255 rillig Dir_Concat(suff->searchPath, dirSearchPath);
842 1.1 cgd } else {
843 1.255 rillig Lst_Destroy(suff->searchPath, Dir_Destroy);
844 1.255 rillig suff->searchPath = Dir_CopyDirSearchPath();
845 1.1 cgd }
846 1.1 cgd }
847 1.1 cgd
848 1.87 rillig Var_Set(".INCLUDES", ptr = Dir_MakeFlags("-I", inIncludes), VAR_GLOBAL);
849 1.6 jtc free(ptr);
850 1.87 rillig Var_Set(".LIBS", ptr = Dir_MakeFlags("-L", inLibs), VAR_GLOBAL);
851 1.6 jtc free(ptr);
852 1.1 cgd
853 1.125 rillig Lst_Destroy(inIncludes, Dir_Destroy);
854 1.125 rillig Lst_Destroy(inLibs, Dir_Destroy);
855 1.1 cgd }
856 1.1 cgd
857 1.285 rillig /*
858 1.285 rillig * Add the given suffix as a type of file which gets included.
859 1.285 rillig * Called when a '.INCLUDES: .h' line is parsed.
860 1.285 rillig * To have an effect, the suffix must already exist.
861 1.285 rillig * This affects the magic variable '.INCLUDES'.
862 1.1 cgd */
863 1.1 cgd void
864 1.285 rillig Suff_AddInclude(const char *suffName)
865 1.1 cgd {
866 1.285 rillig Suffix *suff = FindSuffixByName(suffName);
867 1.166 rillig if (suff != NULL)
868 1.166 rillig suff->flags |= SUFF_INCLUDE;
869 1.1 cgd }
870 1.1 cgd
871 1.285 rillig /*
872 1.285 rillig * Add the given suffix as a type of file which is a library.
873 1.285 rillig * Called when a '.LIBS: .a' line is parsed.
874 1.285 rillig * To have an effect, the suffix must already exist.
875 1.285 rillig * This affects the magic variable '.LIBS'.
876 1.1 cgd */
877 1.1 cgd void
878 1.285 rillig Suff_AddLib(const char *suffName)
879 1.1 cgd {
880 1.285 rillig Suffix *suff = FindSuffixByName(suffName);
881 1.166 rillig if (suff != NULL)
882 1.166 rillig suff->flags |= SUFF_LIBRARY;
883 1.1 cgd }
884 1.1 cgd
885 1.93 rillig /********** Implicit Source Search Functions *********/
886 1.1 cgd
887 1.149 rillig #ifdef DEBUG_SRC
888 1.165 rillig static void
889 1.283 rillig CandidateList_PrintAddrs(CandidateList *list)
890 1.149 rillig {
891 1.283 rillig CandidateListNode *ln;
892 1.283 rillig
893 1.283 rillig for (ln = list->first; ln != NULL; ln = ln->next)
894 1.194 rillig debug_printf(" %p", ln->datum);
895 1.200 rillig debug_printf("\n");
896 1.149 rillig }
897 1.149 rillig #endif
898 1.149 rillig
899 1.282 rillig static Candidate *
900 1.282 rillig Candidate_New(char *name, char *pref, Suffix *suff, Candidate *parent,
901 1.282 rillig GNode *gn)
902 1.282 rillig {
903 1.282 rillig Candidate *cand = bmake_malloc(sizeof *cand);
904 1.282 rillig
905 1.282 rillig cand->file = name;
906 1.282 rillig cand->pref = pref;
907 1.282 rillig cand->suff = Suffix_Ref(suff);
908 1.282 rillig cand->parent = parent;
909 1.282 rillig cand->node = gn;
910 1.282 rillig cand->numChildren = 0;
911 1.209 rillig #ifdef DEBUG_SRC
912 1.282 rillig cand->childrenList = Lst_New();
913 1.209 rillig #endif
914 1.209 rillig
915 1.282 rillig return cand;
916 1.209 rillig }
917 1.209 rillig
918 1.283 rillig /* Add a new candidate to the list. */
919 1.190 rillig static void
920 1.283 rillig CandidateList_Add(CandidateList *list, char *srcName, Candidate *targ,
921 1.283 rillig Suffix *suff, const char *debug_tag)
922 1.190 rillig {
923 1.283 rillig Candidate *cand = Candidate_New(srcName, targ->pref, suff, targ, NULL);
924 1.234 rillig targ->numChildren++;
925 1.283 rillig Lst_Append(list, cand);
926 1.283 rillig
927 1.190 rillig #ifdef DEBUG_SRC
928 1.283 rillig Lst_Append(targ->childrenList, cand);
929 1.283 rillig debug_printf("%s add suff %p candidate %p to list %p:",
930 1.283 rillig debug_tag, targ, cand, list);
931 1.283 rillig CandidateList_PrintAddrs(list);
932 1.190 rillig #endif
933 1.190 rillig }
934 1.190 rillig
935 1.286 rillig /* Add all candidates to the list that can be formed by applying a suffix to
936 1.286 rillig * the candidate. */
937 1.165 rillig static void
938 1.286 rillig CandidateList_AddCandidatesFor(CandidateList *list, Candidate *cand)
939 1.1 cgd {
940 1.286 rillig SuffixListNode *ln;
941 1.286 rillig for (ln = cand->suff->children->first; ln != NULL; ln = ln->next) {
942 1.286 rillig Suffix *suff = ln->datum;
943 1.286 rillig
944 1.286 rillig if ((suff->flags & SUFF_NULL) && suff->name[0] != '\0') {
945 1.286 rillig /*
946 1.286 rillig * If the suffix has been marked as the NULL suffix, also
947 1.286 rillig * create a candidate for a file with no suffix attached.
948 1.286 rillig */
949 1.286 rillig CandidateList_Add(list, bmake_strdup(cand->pref),
950 1.286 rillig cand, suff, "1");
951 1.286 rillig }
952 1.1 cgd
953 1.286 rillig CandidateList_Add(list, str_concat2(cand->pref, suff->name),
954 1.286 rillig cand, suff, "2");
955 1.183 rillig }
956 1.1 cgd }
957 1.1 cgd
958 1.282 rillig /* Free the first candidate in the list that is not referenced anymore.
959 1.282 rillig * Return whether a candidate was removed. */
960 1.134 rillig static Boolean
961 1.288 rillig RemoveCandidate(CandidateList *srcs)
962 1.73 joerg {
963 1.283 rillig CandidateListNode *ln;
964 1.73 joerg
965 1.73 joerg #ifdef DEBUG_SRC
966 1.276 rillig debug_printf("cleaning list %p:", srcs);
967 1.283 rillig CandidateList_PrintAddrs(srcs);
968 1.73 joerg #endif
969 1.73 joerg
970 1.276 rillig for (ln = srcs->first; ln != NULL; ln = ln->next) {
971 1.282 rillig Candidate *src = ln->datum;
972 1.214 rillig
973 1.234 rillig if (src->numChildren == 0) {
974 1.233 rillig free(src->file);
975 1.233 rillig if (src->parent == NULL)
976 1.233 rillig free(src->pref);
977 1.73 joerg else {
978 1.73 joerg #ifdef DEBUG_SRC
979 1.283 rillig /* XXX: Lst_RemoveDatum */
980 1.283 rillig CandidateListNode *ln2;
981 1.283 rillig ln2 = Lst_FindDatum(src->parent->childrenList, src);
982 1.84 dholland if (ln2 != NULL)
983 1.233 rillig Lst_Remove(src->parent->childrenList, ln2);
984 1.73 joerg #endif
985 1.234 rillig src->parent->numChildren--;
986 1.73 joerg }
987 1.73 joerg #ifdef DEBUG_SRC
988 1.224 rillig debug_printf("free: list %p src %p children %d\n",
989 1.276 rillig srcs, src, src->numChildren);
990 1.233 rillig Lst_Free(src->childrenList);
991 1.73 joerg #endif
992 1.276 rillig Lst_Remove(srcs, ln);
993 1.233 rillig free(src);
994 1.73 joerg return TRUE;
995 1.73 joerg }
996 1.73 joerg #ifdef DEBUG_SRC
997 1.73 joerg else {
998 1.224 rillig debug_printf("keep: list %p src %p children %d:",
999 1.276 rillig srcs, src, src->numChildren);
1000 1.283 rillig CandidateList_PrintAddrs(src->childrenList);
1001 1.73 joerg }
1002 1.73 joerg #endif
1003 1.73 joerg }
1004 1.6 jtc
1005 1.134 rillig return FALSE;
1006 1.1 cgd }
1007 1.1 cgd
1008 1.238 rillig /* Find the first existing file/target in srcs. */
1009 1.283 rillig /* XXX: The parameter names are too similar. */
1010 1.282 rillig static Candidate *
1011 1.283 rillig FindThem(CandidateList *srcs, CandidateList *slst)
1012 1.1 cgd {
1013 1.282 rillig Candidate *retsrc = NULL;
1014 1.1 cgd
1015 1.125 rillig while (!Lst_IsEmpty(srcs)) {
1016 1.282 rillig Candidate *src = Lst_Dequeue(srcs);
1017 1.1 cgd
1018 1.220 rillig SUFF_DEBUG1("\ttrying %s...", src->file);
1019 1.6 jtc
1020 1.1 cgd /*
1021 1.73 joerg * A file is considered to exist if either a node exists in the
1022 1.73 joerg * graph for it or the file actually exists.
1023 1.1 cgd */
1024 1.220 rillig if (Targ_FindNode(src->file) != NULL) {
1025 1.6 jtc #ifdef DEBUG_SRC
1026 1.224 rillig debug_printf("remove from list %p src %p\n", srcs, src);
1027 1.6 jtc #endif
1028 1.220 rillig retsrc = src;
1029 1.73 joerg break;
1030 1.73 joerg }
1031 1.73 joerg
1032 1.220 rillig {
1033 1.220 rillig char *file = Dir_FindFile(src->file, src->suff->searchPath);
1034 1.220 rillig if (file != NULL) {
1035 1.220 rillig retsrc = src;
1036 1.6 jtc #ifdef DEBUG_SRC
1037 1.224 rillig debug_printf("remove from list %p src %p\n", srcs, src);
1038 1.6 jtc #endif
1039 1.220 rillig free(file);
1040 1.220 rillig break;
1041 1.220 rillig }
1042 1.1 cgd }
1043 1.6 jtc
1044 1.140 rillig SUFF_DEBUG0("not there\n");
1045 1.6 jtc
1046 1.286 rillig CandidateList_AddCandidatesFor(srcs, src);
1047 1.220 rillig Lst_Append(slst, src);
1048 1.6 jtc }
1049 1.6 jtc
1050 1.220 rillig if (retsrc) {
1051 1.140 rillig SUFF_DEBUG0("got it\n");
1052 1.73 joerg }
1053 1.220 rillig return retsrc;
1054 1.1 cgd }
1055 1.1 cgd
1056 1.282 rillig /*
1057 1.282 rillig * See if any of the children of the candidate's GNode is one from which the
1058 1.282 rillig * target can be transformed. If there is one, a candidate is put together
1059 1.282 rillig * for it and returned.
1060 1.1 cgd */
1061 1.282 rillig static Candidate *
1062 1.283 rillig FindCmds(Candidate *targ, CandidateList *slst)
1063 1.1 cgd {
1064 1.157 rillig GNodeListNode *gln;
1065 1.215 rillig GNode *tgn; /* Target GNode */
1066 1.215 rillig GNode *sgn; /* Source GNode */
1067 1.170 rillig size_t prefLen; /* The length of the defined prefix */
1068 1.268 rillig Suffix *suff; /* Suffix on matching beastie */
1069 1.282 rillig Candidate *ret; /* Return value */
1070 1.170 rillig char *cp;
1071 1.73 joerg
1072 1.215 rillig tgn = targ->node;
1073 1.73 joerg prefLen = strlen(targ->pref);
1074 1.73 joerg
1075 1.216 rillig for (gln = tgn->children->first; gln != NULL; gln = gln->next) {
1076 1.215 rillig sgn = gln->datum;
1077 1.73 joerg
1078 1.215 rillig if (sgn->type & OP_OPTIONAL && Lst_IsEmpty(tgn->commands)) {
1079 1.73 joerg /*
1080 1.73 joerg * We haven't looked to see if .OPTIONAL files exist yet, so
1081 1.73 joerg * don't use one as the implicit source.
1082 1.73 joerg * This allows us to use .OPTIONAL in .depend files so make won't
1083 1.73 joerg * complain "don't know how to make xxx.h' when a dependent file
1084 1.73 joerg * has been moved/deleted.
1085 1.73 joerg */
1086 1.73 joerg continue;
1087 1.73 joerg }
1088 1.73 joerg
1089 1.215 rillig cp = strrchr(sgn->name, '/');
1090 1.73 joerg if (cp == NULL) {
1091 1.215 rillig cp = sgn->name;
1092 1.73 joerg } else {
1093 1.73 joerg cp++;
1094 1.73 joerg }
1095 1.73 joerg if (strncmp(cp, targ->pref, prefLen) != 0)
1096 1.73 joerg continue;
1097 1.238 rillig /* The node matches the prefix ok, see if it has a known suffix. */
1098 1.271 rillig suff = FindSuffixByName(cp + prefLen);
1099 1.166 rillig if (suff == NULL)
1100 1.73 joerg continue;
1101 1.166 rillig
1102 1.73 joerg /*
1103 1.73 joerg * It even has a known suffix, see if there's a transformation
1104 1.73 joerg * defined between the node's suffix and the target's suffix.
1105 1.73 joerg *
1106 1.73 joerg * XXX: Handle multi-stage transformations here, too.
1107 1.73 joerg */
1108 1.73 joerg
1109 1.280 rillig if (Lst_FindDatum(suff->parents, targ->suff) != NULL)
1110 1.73 joerg break;
1111 1.73 joerg }
1112 1.1 cgd
1113 1.216 rillig if (gln == NULL)
1114 1.216 rillig return NULL;
1115 1.216 rillig
1116 1.282 rillig ret = Candidate_New(bmake_strdup(sgn->name), targ->pref, suff, targ, sgn);
1117 1.234 rillig targ->numChildren++;
1118 1.73 joerg #ifdef DEBUG_SRC
1119 1.224 rillig debug_printf("3 add targ %p ret %p\n", targ, ret);
1120 1.211 rillig Lst_Append(targ->childrenList, ret);
1121 1.73 joerg #endif
1122 1.125 rillig Lst_Append(slst, ret);
1123 1.215 rillig SUFF_DEBUG1("\tusing existing source %s\n", sgn->name);
1124 1.88 rillig return ret;
1125 1.1 cgd }
1126 1.1 cgd
1127 1.274 rillig static void
1128 1.281 rillig ExpandWildcards(GNodeListNode *cln, GNode *pgn)
1129 1.274 rillig {
1130 1.274 rillig GNode *cgn = cln->datum;
1131 1.274 rillig StringList *expansions;
1132 1.274 rillig
1133 1.274 rillig if (!Dir_HasWildcards(cgn->name))
1134 1.274 rillig return;
1135 1.274 rillig
1136 1.274 rillig /*
1137 1.274 rillig * Expand the word along the chosen path
1138 1.274 rillig */
1139 1.274 rillig expansions = Lst_New();
1140 1.274 rillig Dir_Expand(cgn->name, Suff_FindPath(cgn), expansions);
1141 1.274 rillig
1142 1.274 rillig while (!Lst_IsEmpty(expansions)) {
1143 1.274 rillig GNode *gn;
1144 1.274 rillig /*
1145 1.274 rillig * Fetch next expansion off the list and find its GNode
1146 1.274 rillig */
1147 1.274 rillig char *cp = Lst_Dequeue(expansions);
1148 1.274 rillig
1149 1.274 rillig SUFF_DEBUG1("%s...", cp);
1150 1.274 rillig gn = Targ_GetNode(cp);
1151 1.274 rillig
1152 1.274 rillig /* Add gn to the parents child list before the original child */
1153 1.274 rillig Lst_InsertBefore(pgn->children, cln, gn);
1154 1.274 rillig Lst_Append(gn->parents, pgn);
1155 1.274 rillig pgn->unmade++;
1156 1.274 rillig }
1157 1.274 rillig
1158 1.274 rillig Lst_Free(expansions);
1159 1.274 rillig
1160 1.274 rillig SUFF_DEBUG0("\n");
1161 1.274 rillig
1162 1.274 rillig /*
1163 1.274 rillig * Now the source is expanded, remove it from the list of children to
1164 1.274 rillig * keep it from being processed.
1165 1.274 rillig */
1166 1.274 rillig pgn->unmade--;
1167 1.274 rillig Lst_Remove(pgn->children, cln);
1168 1.274 rillig Lst_Remove(cgn->parents, Lst_FindDatum(cgn->parents, pgn));
1169 1.274 rillig }
1170 1.274 rillig
1171 1.134 rillig /* Expand the names of any children of a given node that contain variable
1172 1.153 rillig * expressions or file wildcards into actual targets.
1173 1.134 rillig *
1174 1.134 rillig * The expanded node is removed from the parent's list of children, and the
1175 1.134 rillig * parent's unmade counter is decremented, but other nodes may be added.
1176 1.1 cgd *
1177 1.39 wiz * Input:
1178 1.73 joerg * cln Child to examine
1179 1.73 joerg * pgn Parent node being processed
1180 1.1 cgd */
1181 1.56 dsl static void
1182 1.281 rillig ExpandChildren(GNodeListNode *cln, GNode *pgn)
1183 1.1 cgd {
1184 1.195 rillig GNode *cgn = cln->datum;
1185 1.170 rillig GNode *gn; /* New source 8) */
1186 1.170 rillig char *cp; /* Expanded value */
1187 1.1 cgd
1188 1.125 rillig if (!Lst_IsEmpty(cgn->order_pred) || !Lst_IsEmpty(cgn->order_succ))
1189 1.61 dsl /* It is all too hard to process the result of .ORDER */
1190 1.61 dsl return;
1191 1.61 dsl
1192 1.61 dsl if (cgn->type & OP_WAIT)
1193 1.61 dsl /* Ignore these (& OP_PHONY ?) */
1194 1.61 dsl return;
1195 1.61 dsl
1196 1.1 cgd /*
1197 1.1 cgd * First do variable expansion -- this takes precedence over
1198 1.1 cgd * wildcard expansion. If the result contains wildcards, they'll be gotten
1199 1.1 cgd * to later since the resulting words are tacked on to the end of
1200 1.1 cgd * the children list.
1201 1.1 cgd */
1202 1.56 dsl if (strchr(cgn->name, '$') == NULL) {
1203 1.281 rillig ExpandWildcards(cln, pgn);
1204 1.56 dsl return;
1205 1.56 dsl }
1206 1.56 dsl
1207 1.140 rillig SUFF_DEBUG1("Expanding \"%s\"...", cgn->name);
1208 1.235 rillig (void)Var_Subst(cgn->name, pgn, VARE_WANTRES | VARE_UNDEFERR, &cp);
1209 1.158 rillig /* TODO: handle errors */
1210 1.1 cgd
1211 1.135 rillig {
1212 1.180 rillig GNodeList *members = Lst_New();
1213 1.13 christos
1214 1.56 dsl if (cgn->type & OP_ARCHV) {
1215 1.56 dsl /*
1216 1.56 dsl * Node was an archive(member) target, so we want to call
1217 1.56 dsl * on the Arch module to find the nodes for us, expanding
1218 1.56 dsl * variables in the parent's context.
1219 1.56 dsl */
1220 1.56 dsl char *sacrifice = cp;
1221 1.1 cgd
1222 1.56 dsl (void)Arch_ParseArchive(&sacrifice, members, pgn);
1223 1.56 dsl } else {
1224 1.56 dsl /*
1225 1.56 dsl * Break the result into a vector of strings whose nodes
1226 1.56 dsl * we can find, then add those nodes to the members list.
1227 1.245 rillig * Unfortunately, we can't use Str_Words because it
1228 1.56 dsl * doesn't understand about variable specifications with
1229 1.56 dsl * spaces in them...
1230 1.56 dsl */
1231 1.56 dsl char *start;
1232 1.73 joerg char *initcp = cp; /* For freeing... */
1233 1.1 cgd
1234 1.232 rillig start = cp;
1235 1.232 rillig pp_skip_hspace(&start);
1236 1.145 rillig cp = start;
1237 1.145 rillig while (*cp != '\0') {
1238 1.56 dsl if (*cp == ' ' || *cp == '\t') {
1239 1.56 dsl /*
1240 1.56 dsl * White-space -- terminate element, find the node,
1241 1.56 dsl * add it, skip any further spaces.
1242 1.56 dsl */
1243 1.56 dsl *cp++ = '\0';
1244 1.168 rillig gn = Targ_GetNode(start);
1245 1.125 rillig Lst_Append(members, gn);
1246 1.232 rillig pp_skip_hspace(&cp);
1247 1.145 rillig start = cp; /* Continue at the next non-space. */
1248 1.56 dsl } else if (*cp == '$') {
1249 1.262 rillig /* Skip over the variable expression. */
1250 1.144 rillig const char *nested_p = cp;
1251 1.90 rillig const char *junk;
1252 1.56 dsl void *freeIt;
1253 1.56 dsl
1254 1.262 rillig (void)Var_Parse(&nested_p, pgn, VARE_NONE, &junk, &freeIt);
1255 1.156 rillig /* TODO: handle errors */
1256 1.145 rillig if (junk == var_Error) {
1257 1.145 rillig Parse_Error(PARSE_FATAL,
1258 1.145 rillig "Malformed variable expression at \"%s\"",
1259 1.145 rillig cp);
1260 1.148 rillig cp++;
1261 1.145 rillig } else {
1262 1.144 rillig cp += nested_p - cp;
1263 1.56 dsl }
1264 1.1 cgd
1265 1.77 christos free(freeIt);
1266 1.242 rillig } else if (cp[0] == '\\' && cp[1] != '\0') {
1267 1.1 cgd /*
1268 1.56 dsl * Escaped something -- skip over it
1269 1.1 cgd */
1270 1.145 rillig /* XXX: In other places, escaping at this syntactical
1271 1.145 rillig * position is done by a '$', not a '\'. The '\' is only
1272 1.145 rillig * used in variable modifiers. */
1273 1.145 rillig cp += 2;
1274 1.145 rillig } else {
1275 1.56 dsl cp++;
1276 1.1 cgd }
1277 1.56 dsl }
1278 1.56 dsl
1279 1.56 dsl if (cp != start) {
1280 1.1 cgd /*
1281 1.56 dsl * Stuff left over -- add it to the list too
1282 1.1 cgd */
1283 1.168 rillig gn = Targ_GetNode(start);
1284 1.125 rillig Lst_Append(members, gn);
1285 1.1 cgd }
1286 1.73 joerg /*
1287 1.73 joerg * Point cp back at the beginning again so the variable value
1288 1.73 joerg * can be freed.
1289 1.73 joerg */
1290 1.73 joerg cp = initcp;
1291 1.56 dsl }
1292 1.1 cgd
1293 1.1 cgd /*
1294 1.56 dsl * Add all elements of the members list to the parent node.
1295 1.1 cgd */
1296 1.125 rillig while(!Lst_IsEmpty(members)) {
1297 1.125 rillig gn = Lst_Dequeue(members);
1298 1.56 dsl
1299 1.140 rillig SUFF_DEBUG1("%s...", gn->name);
1300 1.56 dsl /* Add gn to the parents child list before the original child */
1301 1.125 rillig Lst_InsertBefore(pgn->children, cln, gn);
1302 1.125 rillig Lst_Append(gn->parents, pgn);
1303 1.56 dsl pgn->unmade++;
1304 1.56 dsl /* Expand wildcards on new node */
1305 1.281 rillig ExpandWildcards(cln->prev, pgn);
1306 1.1 cgd }
1307 1.125 rillig Lst_Free(members);
1308 1.1 cgd
1309 1.73 joerg /*
1310 1.73 joerg * Free the result
1311 1.73 joerg */
1312 1.73 joerg free(cp);
1313 1.73 joerg }
1314 1.135 rillig
1315 1.140 rillig SUFF_DEBUG0("\n");
1316 1.1 cgd
1317 1.56 dsl /*
1318 1.56 dsl * Now the source is expanded, remove it from the list of children to
1319 1.56 dsl * keep it from being processed.
1320 1.56 dsl */
1321 1.56 dsl pgn->unmade--;
1322 1.125 rillig Lst_Remove(pgn->children, cln);
1323 1.137 rillig Lst_Remove(cgn->parents, Lst_FindDatum(cgn->parents, pgn));
1324 1.56 dsl }
1325 1.56 dsl
1326 1.294 rillig static void
1327 1.294 rillig ExpandAllChildren(GNode *gn)
1328 1.294 rillig {
1329 1.294 rillig GNodeListNode *ln, *nln;
1330 1.294 rillig
1331 1.294 rillig for (ln = gn->children->first; ln != NULL; ln = nln) {
1332 1.294 rillig nln = ln->next;
1333 1.294 rillig ExpandChildren(ln, gn);
1334 1.294 rillig }
1335 1.294 rillig }
1336 1.294 rillig
1337 1.134 rillig /* Find a path along which to expand the node.
1338 1.47 christos *
1339 1.238 rillig * If the node has a known suffix, use that path.
1340 1.134 rillig * If it has no known suffix, use the default system search path.
1341 1.47 christos *
1342 1.47 christos * Input:
1343 1.47 christos * gn Node being examined
1344 1.47 christos *
1345 1.47 christos * Results:
1346 1.47 christos * The appropriate path to search for the GNode.
1347 1.46 christos */
1348 1.157 rillig SearchPath *
1349 1.46 christos Suff_FindPath(GNode* gn)
1350 1.46 christos {
1351 1.268 rillig Suffix *suff = gn->suffix;
1352 1.46 christos
1353 1.46 christos if (suff == NULL) {
1354 1.228 rillig char *name = gn->name;
1355 1.207 rillig size_t nameLen = strlen(gn->name);
1356 1.269 rillig SuffixListNode *ln;
1357 1.207 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next)
1358 1.271 rillig if (Suffix_IsSuffix(ln->datum, nameLen, name + nameLen))
1359 1.207 rillig break;
1360 1.46 christos
1361 1.140 rillig SUFF_DEBUG1("Wildcard expanding \"%s\"...", gn->name);
1362 1.65 dsl if (ln != NULL)
1363 1.195 rillig suff = ln->datum;
1364 1.46 christos /* XXX: Here we can save the suffix so we don't have to do this again */
1365 1.46 christos }
1366 1.46 christos
1367 1.73 joerg if (suff != NULL) {
1368 1.226 rillig SUFF_DEBUG1("suffix is \"%s\"...\n", suff->name);
1369 1.46 christos return suff->searchPath;
1370 1.73 joerg } else {
1371 1.228 rillig SUFF_DEBUG0("\n");
1372 1.226 rillig return dirSearchPath; /* Use default search path */
1373 1.46 christos }
1374 1.46 christos }
1375 1.46 christos
1376 1.134 rillig /* Apply a transformation rule, given the source and target nodes and
1377 1.134 rillig * suffixes.
1378 1.1 cgd *
1379 1.238 rillig * The source and target are linked and the commands from the transformation
1380 1.238 rillig * are added to the target node's commands list. The target also inherits all
1381 1.238 rillig * the sources for the transformation rule.
1382 1.39 wiz *
1383 1.1 cgd * Results:
1384 1.1 cgd * TRUE if successful, FALSE if not.
1385 1.1 cgd */
1386 1.1 cgd static Boolean
1387 1.281 rillig ApplyTransform(GNode *tgn, GNode *sgn, Suffix *tsuff, Suffix *ssuff)
1388 1.1 cgd {
1389 1.242 rillig GNodeListNode *ln;
1390 1.170 rillig char *tname; /* Name of transformation rule */
1391 1.170 rillig GNode *gn; /* Node for same */
1392 1.1 cgd
1393 1.31 mycroft /*
1394 1.31 mycroft * Form the proper links between the target and source.
1395 1.31 mycroft */
1396 1.241 rillig Lst_Append(tgn->children, sgn);
1397 1.241 rillig Lst_Append(sgn->parents, tgn);
1398 1.241 rillig tgn->unmade++;
1399 1.1 cgd
1400 1.1 cgd /*
1401 1.1 cgd * Locate the transformation rule itself
1402 1.1 cgd */
1403 1.241 rillig tname = str_concat2(ssuff->name, tsuff->name);
1404 1.210 rillig gn = FindTransformByName(tname);
1405 1.1 cgd free(tname);
1406 1.1 cgd
1407 1.210 rillig if (gn == NULL) {
1408 1.238 rillig /* This can happen when linking an OP_MEMBER and OP_ARCHV node. */
1409 1.88 rillig return FALSE;
1410 1.73 joerg }
1411 1.73 joerg
1412 1.243 rillig DEBUG3(SUFF,"\tapplying %s -> %s to \"%s\"\n",
1413 1.241 rillig ssuff->name, tsuff->name, tgn->name);
1414 1.1 cgd
1415 1.238 rillig /* Record last child; Make_HandleUse may add child nodes. */
1416 1.241 rillig ln = tgn->children->last;
1417 1.13 christos
1418 1.238 rillig /* Apply the rule. */
1419 1.242 rillig Make_HandleUse(gn, tgn);
1420 1.1 cgd
1421 1.238 rillig /* Deal with wildcards and variables in any acquired sources. */
1422 1.242 rillig ln = ln != NULL ? ln->next : NULL;
1423 1.242 rillig while (ln != NULL) {
1424 1.242 rillig GNodeListNode *nln = ln->next;
1425 1.281 rillig ExpandChildren(ln, tgn);
1426 1.242 rillig ln = nln;
1427 1.73 joerg }
1428 1.1 cgd
1429 1.73 joerg /*
1430 1.238 rillig * Keep track of another parent to which this node is transformed so
1431 1.73 joerg * the .IMPSRC variable can be set correctly for the parent.
1432 1.73 joerg */
1433 1.241 rillig Lst_Append(sgn->implicitParents, tgn);
1434 1.1 cgd
1435 1.88 rillig return TRUE;
1436 1.1 cgd }
1437 1.1 cgd
1438 1.295 rillig /*
1439 1.295 rillig * Member has a known suffix, so look for a transformation rule from
1440 1.295 rillig * it to a possible suffix of the archive.
1441 1.295 rillig *
1442 1.295 rillig * Rather than searching through the entire list, we just look at
1443 1.295 rillig * suffixes to which the member's suffix may be transformed.
1444 1.295 rillig */
1445 1.295 rillig static void
1446 1.295 rillig ExpandMember(GNode *gn, const char *eoarch, GNode *mem, Suffix *memSuff)
1447 1.295 rillig {
1448 1.295 rillig GNodeListNode *ln;
1449 1.295 rillig size_t nameLen = (size_t)(eoarch - gn->name);
1450 1.295 rillig
1451 1.295 rillig /* Use first matching suffix... */
1452 1.295 rillig for (ln = memSuff->parents->first; ln != NULL; ln = ln->next)
1453 1.295 rillig if (Suffix_IsSuffix(ln->datum, nameLen, eoarch))
1454 1.295 rillig break;
1455 1.295 rillig
1456 1.295 rillig if (ln != NULL) {
1457 1.295 rillig /* Got one -- apply it */
1458 1.295 rillig Suffix *suff = ln->datum;
1459 1.295 rillig if (!ApplyTransform(gn, mem, suff, memSuff)) {
1460 1.295 rillig SUFF_DEBUG2("\tNo transformation from %s -> %s\n",
1461 1.295 rillig memSuff->name, suff->name);
1462 1.295 rillig }
1463 1.295 rillig }
1464 1.295 rillig }
1465 1.1 cgd
1466 1.283 rillig static void FindDeps(GNode *, CandidateList *);
1467 1.275 rillig
1468 1.134 rillig /* Locate dependencies for an OP_ARCHV node.
1469 1.1 cgd *
1470 1.39 wiz * Input:
1471 1.73 joerg * gn Node for which to locate dependencies
1472 1.39 wiz *
1473 1.1 cgd * Side Effects:
1474 1.73 joerg * Same as Suff_FindDeps
1475 1.1 cgd */
1476 1.1 cgd static void
1477 1.283 rillig FindDepsArchive(GNode *gn, CandidateList *slst)
1478 1.1 cgd {
1479 1.157 rillig char *eoarch; /* End of archive portion */
1480 1.157 rillig char *eoname; /* End of member portion */
1481 1.157 rillig GNode *mem; /* Node for member */
1482 1.295 rillig Suffix *memSuff;
1483 1.295 rillig const char *name; /* Start of member's name */
1484 1.71 christos
1485 1.73 joerg /*
1486 1.73 joerg * The node is an archive(member) pair. so we must find a
1487 1.73 joerg * suffix for both of them.
1488 1.73 joerg */
1489 1.73 joerg eoarch = strchr(gn->name, '(');
1490 1.73 joerg eoname = strchr(eoarch, ')');
1491 1.13 christos
1492 1.86 riastrad /*
1493 1.86 riastrad * Caller guarantees the format `libname(member)', via
1494 1.86 riastrad * Arch_ParseArchive.
1495 1.86 riastrad */
1496 1.86 riastrad assert(eoarch != NULL);
1497 1.86 riastrad assert(eoname != NULL);
1498 1.86 riastrad
1499 1.73 joerg *eoname = '\0'; /* Nuke parentheses during suffix search */
1500 1.73 joerg *eoarch = '\0'; /* So a suffix can be found */
1501 1.1 cgd
1502 1.73 joerg name = eoarch + 1;
1503 1.1 cgd
1504 1.73 joerg /*
1505 1.73 joerg * To simplify things, call Suff_FindDeps recursively on the member now,
1506 1.73 joerg * so we can simply compare the member's .PREFIX and .TARGET variables
1507 1.73 joerg * to locate its suffix. This allows us to figure out the suffix to
1508 1.73 joerg * use for the archive without having to do a quadratic search over the
1509 1.73 joerg * suffix list, backtracking for each one...
1510 1.73 joerg */
1511 1.168 rillig mem = Targ_GetNode(name);
1512 1.281 rillig FindDeps(mem, slst);
1513 1.13 christos
1514 1.1 cgd /*
1515 1.73 joerg * Create the link between the two nodes right off
1516 1.1 cgd */
1517 1.125 rillig Lst_Append(gn->children, mem);
1518 1.125 rillig Lst_Append(mem->parents, gn);
1519 1.173 rillig gn->unmade++;
1520 1.13 christos
1521 1.1 cgd /*
1522 1.73 joerg * Copy in the variables from the member node to this one.
1523 1.1 cgd */
1524 1.230 rillig Var_Set(PREFIX, GNode_VarPrefix(mem), gn);
1525 1.230 rillig Var_Set(TARGET, GNode_VarTarget(mem), gn);
1526 1.1 cgd
1527 1.295 rillig memSuff = mem->suffix;
1528 1.295 rillig if (memSuff == NULL) { /* Didn't know what it was. */
1529 1.140 rillig SUFF_DEBUG0("using null suffix\n");
1530 1.295 rillig memSuff = nullSuff;
1531 1.1 cgd }
1532 1.1 cgd
1533 1.73 joerg
1534 1.1 cgd /*
1535 1.73 joerg * Set the other two local variables required for this target.
1536 1.1 cgd */
1537 1.87 rillig Var_Set(MEMBER, name, gn);
1538 1.87 rillig Var_Set(ARCHIVE, gn->name, gn);
1539 1.73 joerg
1540 1.79 matthias /*
1541 1.79 matthias * Set $@ for compatibility with other makes
1542 1.79 matthias */
1543 1.87 rillig Var_Set(TARGET, gn->name, gn);
1544 1.80 matthias
1545 1.80 matthias /*
1546 1.80 matthias * Now we've got the important local variables set, expand any sources
1547 1.80 matthias * that still contain variables or wildcards in their names.
1548 1.80 matthias */
1549 1.294 rillig ExpandAllChildren(gn);
1550 1.80 matthias
1551 1.295 rillig if (memSuff != NULL)
1552 1.295 rillig ExpandMember(gn, eoarch, mem, memSuff);
1553 1.1 cgd
1554 1.73 joerg /*
1555 1.73 joerg * Replace the opening and closing parens now we've no need of the separate
1556 1.73 joerg * pieces.
1557 1.73 joerg */
1558 1.242 rillig *eoarch = '(';
1559 1.242 rillig *eoname = ')';
1560 1.71 christos
1561 1.1 cgd /*
1562 1.73 joerg * Pretend gn appeared to the left of a dependency operator so
1563 1.73 joerg * the user needn't provide a transformation from the member to the
1564 1.73 joerg * archive.
1565 1.1 cgd */
1566 1.240 rillig if (!GNode_IsTarget(gn))
1567 1.73 joerg gn->type |= OP_DEPENDS;
1568 1.71 christos
1569 1.73 joerg /*
1570 1.73 joerg * Flag the member as such so we remember to look in the archive for
1571 1.81 matthias * its modification time. The OP_JOIN | OP_MADE is needed because this
1572 1.81 matthias * target should never get made.
1573 1.73 joerg */
1574 1.81 matthias mem->type |= OP_MEMBER | OP_JOIN | OP_MADE;
1575 1.1 cgd }
1576 1.1 cgd
1577 1.201 rillig static void
1578 1.281 rillig FindDepsRegularKnown(const char *name, size_t nameLen, GNode *gn,
1579 1.283 rillig CandidateList *srcs, CandidateList *targs)
1580 1.201 rillig {
1581 1.269 rillig SuffixListNode *ln;
1582 1.282 rillig Candidate *targ;
1583 1.209 rillig char *pref;
1584 1.201 rillig
1585 1.203 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next) {
1586 1.268 rillig Suffix *suff = ln->datum;
1587 1.271 rillig if (!Suffix_IsSuffix(suff, nameLen, name + nameLen))
1588 1.203 rillig continue;
1589 1.201 rillig
1590 1.209 rillig pref = bmake_strldup(name, (size_t)(nameLen - suff->nameLen));
1591 1.282 rillig targ = Candidate_New(bmake_strdup(gn->name), pref, suff, NULL, gn);
1592 1.201 rillig
1593 1.286 rillig CandidateList_AddCandidatesFor(srcs, targ);
1594 1.201 rillig
1595 1.203 rillig /*
1596 1.203 rillig * Record the target so we can nuke it
1597 1.203 rillig */
1598 1.203 rillig Lst_Append(targs, targ);
1599 1.201 rillig }
1600 1.201 rillig }
1601 1.201 rillig
1602 1.202 rillig static void
1603 1.281 rillig FindDepsRegularUnknown(GNode *gn, const char *sopref,
1604 1.283 rillig CandidateList *srcs, CandidateList *targs)
1605 1.202 rillig {
1606 1.282 rillig Candidate *targ;
1607 1.202 rillig
1608 1.267 rillig if (!Lst_IsEmpty(targs) || nullSuff == NULL)
1609 1.228 rillig return;
1610 1.202 rillig
1611 1.204 rillig SUFF_DEBUG1("\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
1612 1.204 rillig
1613 1.282 rillig targ = Candidate_New(bmake_strdup(gn->name), bmake_strdup(sopref),
1614 1.267 rillig nullSuff, NULL, gn);
1615 1.202 rillig
1616 1.204 rillig /*
1617 1.204 rillig * Only use the default suffix rules if we don't have commands
1618 1.204 rillig * defined for this gnode; traditional make programs used to
1619 1.204 rillig * not define suffix rules if the gnode had children but we
1620 1.204 rillig * don't do this anymore.
1621 1.204 rillig */
1622 1.204 rillig if (Lst_IsEmpty(gn->commands))
1623 1.286 rillig CandidateList_AddCandidatesFor(srcs, targ);
1624 1.204 rillig else {
1625 1.204 rillig SUFF_DEBUG0("not ");
1626 1.204 rillig }
1627 1.202 rillig
1628 1.204 rillig SUFF_DEBUG0("adding suffix rules\n");
1629 1.202 rillig
1630 1.204 rillig Lst_Append(targs, targ);
1631 1.202 rillig }
1632 1.202 rillig
1633 1.205 rillig /*
1634 1.205 rillig * Deal with finding the thing on the default search path. We
1635 1.205 rillig * always do that, not only if the node is only a source (not
1636 1.205 rillig * on the lhs of a dependency operator or [XXX] it has neither
1637 1.205 rillig * children or commands) as the old pmake did.
1638 1.205 rillig */
1639 1.205 rillig static void
1640 1.282 rillig FindDepsRegularPath(GNode *gn, Candidate *targ)
1641 1.205 rillig {
1642 1.206 rillig if (gn->type & (OP_PHONY | OP_NOPATH))
1643 1.228 rillig return;
1644 1.206 rillig
1645 1.206 rillig free(gn->path);
1646 1.206 rillig gn->path = Dir_FindFile(gn->name,
1647 1.206 rillig (targ == NULL ? dirSearchPath :
1648 1.206 rillig targ->suff->searchPath));
1649 1.206 rillig if (gn->path == NULL)
1650 1.228 rillig return;
1651 1.205 rillig
1652 1.206 rillig Var_Set(TARGET, gn->path, gn);
1653 1.206 rillig
1654 1.206 rillig if (targ != NULL) {
1655 1.206 rillig /*
1656 1.206 rillig * Suffix known for the thing -- trim the suffix off
1657 1.206 rillig * the path to form the proper .PREFIX variable.
1658 1.206 rillig */
1659 1.206 rillig size_t savep = strlen(gn->path) - targ->suff->nameLen;
1660 1.206 rillig char savec;
1661 1.206 rillig char *ptr;
1662 1.206 rillig
1663 1.271 rillig Suffix_Reassign(&gn->suffix, targ->suff);
1664 1.206 rillig
1665 1.206 rillig savec = gn->path[savep];
1666 1.206 rillig gn->path[savep] = '\0';
1667 1.205 rillig
1668 1.206 rillig if ((ptr = strrchr(gn->path, '/')) != NULL)
1669 1.206 rillig ptr++;
1670 1.206 rillig else
1671 1.206 rillig ptr = gn->path;
1672 1.205 rillig
1673 1.206 rillig Var_Set(PREFIX, ptr, gn);
1674 1.205 rillig
1675 1.206 rillig gn->path[savep] = savec;
1676 1.206 rillig } else {
1677 1.206 rillig char *ptr;
1678 1.205 rillig
1679 1.206 rillig /* The .PREFIX gets the full path if the target has no known suffix. */
1680 1.271 rillig Suffix_Unassign(&gn->suffix);
1681 1.205 rillig
1682 1.206 rillig if ((ptr = strrchr(gn->path, '/')) != NULL)
1683 1.206 rillig ptr++;
1684 1.206 rillig else
1685 1.206 rillig ptr = gn->path;
1686 1.205 rillig
1687 1.206 rillig Var_Set(PREFIX, ptr, gn);
1688 1.205 rillig }
1689 1.205 rillig }
1690 1.205 rillig
1691 1.134 rillig /* Locate implicit dependencies for regular targets.
1692 1.1 cgd *
1693 1.39 wiz * Input:
1694 1.73 joerg * gn Node for which to find sources
1695 1.39 wiz *
1696 1.1 cgd * Side Effects:
1697 1.134 rillig * Same as Suff_FindDeps
1698 1.1 cgd */
1699 1.1 cgd static void
1700 1.283 rillig FindDepsRegular(GNode *gn, CandidateList *slst)
1701 1.1 cgd {
1702 1.283 rillig CandidateList *srcs; /* List of sources at which to look */
1703 1.283 rillig CandidateList *targs; /* List of targets to which things can be
1704 1.170 rillig * transformed. They all have the same file,
1705 1.170 rillig * but different suff and pref fields */
1706 1.282 rillig Candidate *bottom; /* Start of found transformation path */
1707 1.282 rillig Candidate *src;
1708 1.170 rillig char *pref; /* Prefix to use */
1709 1.282 rillig Candidate *targ;
1710 1.73 joerg
1711 1.227 rillig const char *name = gn->name;
1712 1.208 rillig size_t nameLen = strlen(name);
1713 1.73 joerg
1714 1.73 joerg /*
1715 1.73 joerg * Begin at the beginning...
1716 1.73 joerg */
1717 1.180 rillig srcs = Lst_New();
1718 1.180 rillig targs = Lst_New();
1719 1.73 joerg
1720 1.73 joerg /*
1721 1.73 joerg * We're caught in a catch-22 here. On the one hand, we want to use any
1722 1.73 joerg * transformation implied by the target's sources, but we can't examine
1723 1.73 joerg * the sources until we've expanded any variables/wildcards they may hold,
1724 1.73 joerg * and we can't do that until we've set up the target's local variables
1725 1.73 joerg * and we can't do that until we know what the proper suffix for the
1726 1.73 joerg * target is (in case there are two suffixes one of which is a suffix of
1727 1.73 joerg * the other) and we can't know that until we've found its implied
1728 1.73 joerg * source, which we may not want to use if there's an existing source
1729 1.73 joerg * that implies a different transformation.
1730 1.73 joerg *
1731 1.73 joerg * In an attempt to get around this, which may not work all the time,
1732 1.73 joerg * but should work most of the time, we look for implied sources first,
1733 1.73 joerg * checking transformations to all possible suffixes of the target,
1734 1.73 joerg * use what we find to set the target's local variables, expand the
1735 1.73 joerg * children, then look for any overriding transformations they imply.
1736 1.73 joerg * Should we find one, we discard the one we found before.
1737 1.73 joerg */
1738 1.73 joerg bottom = NULL;
1739 1.73 joerg targ = NULL;
1740 1.71 christos
1741 1.73 joerg if (!(gn->type & OP_PHONY)) {
1742 1.73 joerg
1743 1.281 rillig FindDepsRegularKnown(name, nameLen, gn, srcs, targs);
1744 1.73 joerg
1745 1.202 rillig /* Handle target of unknown suffix... */
1746 1.281 rillig FindDepsRegularUnknown(gn, name, srcs, targs);
1747 1.73 joerg
1748 1.73 joerg /*
1749 1.73 joerg * Using the list of possible sources built up from the target
1750 1.73 joerg * suffix(es), try and find an existing file/target that matches.
1751 1.73 joerg */
1752 1.281 rillig bottom = FindThem(srcs, slst);
1753 1.73 joerg
1754 1.73 joerg if (bottom == NULL) {
1755 1.73 joerg /*
1756 1.73 joerg * No known transformations -- use the first suffix found
1757 1.73 joerg * for setting the local variables.
1758 1.73 joerg */
1759 1.240 rillig if (targs->first != NULL)
1760 1.195 rillig targ = targs->first->datum;
1761 1.240 rillig else
1762 1.73 joerg targ = NULL;
1763 1.73 joerg } else {
1764 1.73 joerg /*
1765 1.73 joerg * Work up the transformation path to find the suffix of the
1766 1.73 joerg * target to which the transformation was made.
1767 1.73 joerg */
1768 1.73 joerg for (targ = bottom; targ->parent != NULL; targ = targ->parent)
1769 1.73 joerg continue;
1770 1.73 joerg }
1771 1.73 joerg }
1772 1.73 joerg
1773 1.225 rillig Var_Set(TARGET, GNode_Path(gn), gn);
1774 1.73 joerg
1775 1.240 rillig pref = targ != NULL ? targ->pref : gn->name;
1776 1.87 rillig Var_Set(PREFIX, pref, gn);
1777 1.1 cgd
1778 1.1 cgd /*
1779 1.73 joerg * Now we've got the important local variables set, expand any sources
1780 1.73 joerg * that still contain variables or wildcards in their names.
1781 1.1 cgd */
1782 1.201 rillig {
1783 1.290 rillig GNodeListNode *ln, *nln;
1784 1.201 rillig for (ln = gn->children->first; ln != NULL; ln = nln) {
1785 1.201 rillig nln = ln->next;
1786 1.281 rillig ExpandChildren(ln, gn);
1787 1.201 rillig }
1788 1.73 joerg }
1789 1.73 joerg
1790 1.73 joerg if (targ == NULL) {
1791 1.140 rillig SUFF_DEBUG1("\tNo valid suffix on %s\n", gn->name);
1792 1.73 joerg
1793 1.73 joerg sfnd_abort:
1794 1.281 rillig FindDepsRegularPath(gn, targ);
1795 1.73 joerg goto sfnd_return;
1796 1.1 cgd }
1797 1.1 cgd
1798 1.1 cgd /*
1799 1.73 joerg * If the suffix indicates that the target is a library, mark that in
1800 1.73 joerg * the node's type field.
1801 1.1 cgd */
1802 1.236 rillig if (targ->suff->flags & SUFF_LIBRARY)
1803 1.73 joerg gn->type |= OP_LIB;
1804 1.1 cgd
1805 1.73 joerg /*
1806 1.73 joerg * Check for overriding transformation rule implied by sources
1807 1.73 joerg */
1808 1.125 rillig if (!Lst_IsEmpty(gn->children)) {
1809 1.281 rillig src = FindCmds(targ, slst);
1810 1.1 cgd
1811 1.73 joerg if (src != NULL) {
1812 1.73 joerg /*
1813 1.282 rillig * Free up all the candidates in the transformation path,
1814 1.282 rillig * up to but not including the parent node.
1815 1.73 joerg */
1816 1.239 rillig while (bottom != NULL && bottom->parent != NULL) {
1817 1.240 rillig if (Lst_FindDatum(slst, bottom) == NULL)
1818 1.125 rillig Lst_Append(slst, bottom);
1819 1.73 joerg bottom = bottom->parent;
1820 1.1 cgd }
1821 1.73 joerg bottom = src;
1822 1.1 cgd }
1823 1.73 joerg }
1824 1.1 cgd
1825 1.73 joerg if (bottom == NULL) {
1826 1.73 joerg /*
1827 1.73 joerg * No idea from where it can come -- return now.
1828 1.73 joerg */
1829 1.73 joerg goto sfnd_abort;
1830 1.73 joerg }
1831 1.73 joerg
1832 1.73 joerg /*
1833 1.282 rillig * We now have a list of candidates headed by 'bottom' and linked via
1834 1.73 joerg * their 'parent' pointers. What we do next is create links between
1835 1.73 joerg * source and target nodes (which may or may not have been created)
1836 1.282 rillig * and set the necessary local variables in each target.
1837 1.282 rillig *
1838 1.282 rillig * The commands for each target are set from the commands of the
1839 1.73 joerg * transformation rule used to get from the src suffix to the targ
1840 1.73 joerg * suffix. Note that this causes the commands list of the original
1841 1.282 rillig * node, gn, to be replaced with the commands of the final
1842 1.282 rillig * transformation rule.
1843 1.73 joerg */
1844 1.240 rillig if (bottom->node == NULL)
1845 1.168 rillig bottom->node = Targ_GetNode(bottom->file);
1846 1.1 cgd
1847 1.73 joerg for (src = bottom; src->parent != NULL; src = src->parent) {
1848 1.73 joerg targ = src->parent;
1849 1.73 joerg
1850 1.271 rillig Suffix_Reassign(&src->node->suffix, src->suff);
1851 1.73 joerg
1852 1.240 rillig if (targ->node == NULL)
1853 1.168 rillig targ->node = Targ_GetNode(targ->file);
1854 1.73 joerg
1855 1.281 rillig ApplyTransform(targ->node, src->node,
1856 1.73 joerg targ->suff, src->suff);
1857 1.73 joerg
1858 1.73 joerg if (targ->node != gn) {
1859 1.73 joerg /*
1860 1.73 joerg * Finish off the dependency-search process for any nodes
1861 1.73 joerg * between bottom and gn (no point in questing around the
1862 1.73 joerg * filesystem for their implicit source when it's already
1863 1.73 joerg * known). Note that the node can't have any sources that
1864 1.73 joerg * need expanding, since SuffFindThem will stop on an existing
1865 1.238 rillig * node, so all we need to do is set the standard variables.
1866 1.73 joerg */
1867 1.73 joerg targ->node->type |= OP_DEPS_FOUND;
1868 1.87 rillig Var_Set(PREFIX, targ->pref, targ->node);
1869 1.87 rillig Var_Set(TARGET, targ->node->name, targ->node);
1870 1.1 cgd }
1871 1.1 cgd }
1872 1.1 cgd
1873 1.271 rillig Suffix_Reassign(&gn->suffix, src->suff);
1874 1.73 joerg
1875 1.73 joerg /*
1876 1.282 rillig * Nuke the transformation path and the candidates left over in the
1877 1.73 joerg * two lists.
1878 1.73 joerg */
1879 1.73 joerg sfnd_return:
1880 1.242 rillig if (bottom != NULL && Lst_FindDatum(slst, bottom) == NULL)
1881 1.242 rillig Lst_Append(slst, bottom);
1882 1.1 cgd
1883 1.288 rillig while (RemoveCandidate(srcs) || RemoveCandidate(targs))
1884 1.73 joerg continue;
1885 1.1 cgd
1886 1.125 rillig Lst_MoveAll(slst, srcs);
1887 1.125 rillig Lst_MoveAll(slst, targs);
1888 1.1 cgd }
1889 1.13 christos
1890 1.13 christos
1891 1.238 rillig /* Find implicit sources for the target.
1892 1.1 cgd *
1893 1.134 rillig * Nodes are added to the graph below the passed-in node. The nodes are
1894 1.134 rillig * marked to have their IMPSRC variable filled in. The PREFIX variable is set
1895 1.134 rillig * for the given node and all its implied children.
1896 1.134 rillig *
1897 1.134 rillig * The path found by this target is the shortest path in the transformation
1898 1.134 rillig * graph, which may pass through non-existent targets, to an existing target.
1899 1.134 rillig * The search continues on all paths from the root suffix until a file is
1900 1.134 rillig * found. I.e. if there's a path .o -> .c -> .l -> .l,v from the root and the
1901 1.134 rillig * .l,v file exists but the .c and .l files don't, the search will branch out
1902 1.134 rillig * in all directions from .o and again from all the nodes on the next level
1903 1.134 rillig * until the .l,v node is encountered.
1904 1.1 cgd */
1905 1.1 cgd void
1906 1.73 joerg Suff_FindDeps(GNode *gn)
1907 1.6 jtc {
1908 1.283 rillig CandidateList *srcs = Lst_New();
1909 1.13 christos
1910 1.281 rillig FindDeps(gn, srcs);
1911 1.276 rillig
1912 1.288 rillig while (RemoveCandidate(srcs))
1913 1.73 joerg continue;
1914 1.277 rillig
1915 1.277 rillig assert(Lst_IsEmpty(srcs));
1916 1.277 rillig Lst_Free(srcs);
1917 1.73 joerg }
1918 1.73 joerg
1919 1.73 joerg static void
1920 1.283 rillig FindDeps(GNode *gn, CandidateList *slst)
1921 1.73 joerg {
1922 1.127 rillig if (gn->type & OP_DEPS_FOUND)
1923 1.1 cgd return;
1924 1.127 rillig gn->type |= OP_DEPS_FOUND;
1925 1.127 rillig
1926 1.69 sjg /*
1927 1.69 sjg * Make sure we have these set, may get revised below.
1928 1.69 sjg */
1929 1.225 rillig Var_Set(TARGET, GNode_Path(gn), gn);
1930 1.87 rillig Var_Set(PREFIX, gn->name, gn);
1931 1.70 sjg
1932 1.140 rillig SUFF_DEBUG1("SuffFindDeps (%s)\n", gn->name);
1933 1.13 christos
1934 1.73 joerg if (gn->type & OP_ARCHV) {
1935 1.281 rillig FindDepsArchive(gn, slst);
1936 1.73 joerg } else if (gn->type & OP_LIB) {
1937 1.1 cgd /*
1938 1.1 cgd * If the node is a library, it is the arch module's job to find it
1939 1.1 cgd * and set the TARGET variable accordingly. We merely provide the
1940 1.1 cgd * search path, assuming all libraries end in ".a" (if the suffix
1941 1.1 cgd * hasn't been defined, there's nothing we can do for it, so we just
1942 1.1 cgd * set the TARGET variable to the node's name in order to give it a
1943 1.1 cgd * value).
1944 1.1 cgd */
1945 1.271 rillig Suffix *suff = FindSuffixByName(LIBSUFF);
1946 1.255 rillig if (suff != NULL) {
1947 1.271 rillig Suffix_Reassign(&gn->suffix, suff);
1948 1.255 rillig Arch_FindLib(gn, suff->searchPath);
1949 1.73 joerg } else {
1950 1.271 rillig Suffix_Unassign(&gn->suffix);
1951 1.87 rillig Var_Set(TARGET, gn->name, gn);
1952 1.73 joerg }
1953 1.1 cgd /*
1954 1.1 cgd * Because a library (-lfoo) target doesn't follow the standard
1955 1.1 cgd * filesystem conventions, we don't set the regular variables for
1956 1.1 cgd * the thing. .PREFIX is simply made empty...
1957 1.1 cgd */
1958 1.87 rillig Var_Set(PREFIX, "", gn);
1959 1.73 joerg } else {
1960 1.281 rillig FindDepsRegular(gn, slst);
1961 1.73 joerg }
1962 1.73 joerg }
1963 1.71 christos
1964 1.134 rillig /* Define which suffix is the null suffix.
1965 1.134 rillig *
1966 1.134 rillig * Need to handle the changing of the null suffix gracefully so the old
1967 1.134 rillig * transformation rules don't just go away.
1968 1.1 cgd *
1969 1.39 wiz * Input:
1970 1.73 joerg * name Name of null suffix
1971 1.1 cgd */
1972 1.1 cgd void
1973 1.167 rillig Suff_SetNull(const char *name)
1974 1.1 cgd {
1975 1.271 rillig Suffix *suff = FindSuffixByName(name);
1976 1.241 rillig if (suff == NULL) {
1977 1.166 rillig Parse_Error(PARSE_WARNING, "Desired null suffix %s not defined.",
1978 1.166 rillig name);
1979 1.166 rillig return;
1980 1.166 rillig }
1981 1.1 cgd
1982 1.267 rillig if (nullSuff != NULL)
1983 1.267 rillig nullSuff->flags &= ~(unsigned)SUFF_NULL;
1984 1.241 rillig suff->flags |= SUFF_NULL;
1985 1.166 rillig /*
1986 1.166 rillig * XXX: Here's where the transformation mangling would take place
1987 1.166 rillig */
1988 1.267 rillig nullSuff = suff;
1989 1.1 cgd }
1990 1.1 cgd
1991 1.127 rillig /* Initialize the suffixes module. */
1992 1.1 cgd void
1993 1.39 wiz Suff_Init(void)
1994 1.1 cgd {
1995 1.73 joerg #ifdef CLEANUP
1996 1.180 rillig suffClean = Lst_New();
1997 1.180 rillig sufflist = Lst_New();
1998 1.73 joerg #endif
1999 1.180 rillig transforms = Lst_New();
2000 1.1 cgd
2001 1.73 joerg /*
2002 1.73 joerg * Create null suffix for single-suffix rules (POSIX). The thing doesn't
2003 1.73 joerg * actually go on the suffix list or everyone will think that's its
2004 1.73 joerg * suffix.
2005 1.73 joerg */
2006 1.75 sjg Suff_ClearSuffixes();
2007 1.1 cgd }
2008 1.5 jtc
2009 1.5 jtc
2010 1.127 rillig /* Clean up the suffixes module. */
2011 1.6 jtc void
2012 1.39 wiz Suff_End(void)
2013 1.5 jtc {
2014 1.25 mycroft #ifdef CLEANUP
2015 1.125 rillig Lst_Destroy(sufflist, SuffFree);
2016 1.125 rillig Lst_Destroy(suffClean, SuffFree);
2017 1.267 rillig if (nullSuff != NULL)
2018 1.267 rillig SuffFree(nullSuff);
2019 1.125 rillig Lst_Free(transforms);
2020 1.25 mycroft #endif
2021 1.5 jtc }
2022 1.5 jtc
2023 1.1 cgd
2024 1.165 rillig static void
2025 1.269 rillig PrintSuffNames(const char *prefix, SuffixList *suffs)
2026 1.6 jtc {
2027 1.269 rillig SuffixListNode *ln;
2028 1.191 rillig
2029 1.191 rillig debug_printf("#\t%s: ", prefix);
2030 1.191 rillig for (ln = suffs->first; ln != NULL; ln = ln->next) {
2031 1.268 rillig Suffix *suff = ln->datum;
2032 1.191 rillig debug_printf("%s ", suff->name);
2033 1.191 rillig }
2034 1.191 rillig debug_printf("\n");
2035 1.6 jtc }
2036 1.1 cgd
2037 1.165 rillig static void
2038 1.271 rillig Suffix_Print(Suffix *suff)
2039 1.1 cgd {
2040 1.233 rillig debug_printf("# \"%s\" (num %d, ref %d)",
2041 1.233 rillig suff->name, suff->sNum, suff->refCount);
2042 1.233 rillig if (suff->flags != 0) {
2043 1.270 rillig char flags_buf[SuffixFlags_ToStringSize];
2044 1.122 rillig
2045 1.172 rillig debug_printf(" (%s)",
2046 1.172 rillig Enum_FlagsToString(flags_buf, sizeof flags_buf,
2047 1.270 rillig suff->flags,
2048 1.270 rillig SuffixFlags_ToStringSpecs));
2049 1.1 cgd }
2050 1.191 rillig debug_printf("\n");
2051 1.191 rillig
2052 1.233 rillig PrintSuffNames("To", suff->parents);
2053 1.233 rillig PrintSuffNames("From", suff->children);
2054 1.191 rillig
2055 1.172 rillig debug_printf("#\tSearch Path: ");
2056 1.233 rillig Dir_PrintPath(suff->searchPath);
2057 1.191 rillig debug_printf("\n");
2058 1.1 cgd }
2059 1.1 cgd
2060 1.165 rillig static void
2061 1.191 rillig PrintTransformation(GNode *t)
2062 1.1 cgd {
2063 1.172 rillig debug_printf("%-16s:", t->name);
2064 1.48 christos Targ_PrintType(t->type);
2065 1.191 rillig debug_printf("\n");
2066 1.151 rillig Targ_PrintCmds(t);
2067 1.191 rillig debug_printf("\n");
2068 1.1 cgd }
2069 1.1 cgd
2070 1.4 cgd void
2071 1.39 wiz Suff_PrintAll(void)
2072 1.1 cgd {
2073 1.172 rillig debug_printf("#*** Suffixes:\n");
2074 1.191 rillig {
2075 1.269 rillig SuffixListNode *ln;
2076 1.191 rillig for (ln = sufflist->first; ln != NULL; ln = ln->next)
2077 1.271 rillig Suffix_Print(ln->datum);
2078 1.191 rillig }
2079 1.1 cgd
2080 1.172 rillig debug_printf("#*** Transformations:\n");
2081 1.191 rillig {
2082 1.191 rillig GNodeListNode *ln;
2083 1.191 rillig for (ln = transforms->first; ln != NULL; ln = ln->next)
2084 1.191 rillig PrintTransformation(ln->datum);
2085 1.191 rillig }
2086 1.1 cgd }
2087