1 /* Pattern and suffix rule internals for GNU Make.
2 Copyright (C) 1988-2013 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
28 static void freerule (struct rule *rule, struct rule *lastrule);
30 /* Chain of all pattern rules. */
32 struct rule *pattern_rules;
34 /* Pointer to last rule in the chain, so we can add onto the end. */
36 struct rule *last_pattern_rule;
38 /* Number of rules in the chain. */
40 unsigned int num_pattern_rules;
42 /* Maximum number of target patterns of any pattern rule. */
44 unsigned int max_pattern_targets;
46 /* Maximum number of dependencies of any pattern rule. */
48 unsigned int max_pattern_deps;
50 /* Maximum length of the name of a dependencies of any pattern rule. */
52 unsigned int max_pattern_dep_length;
54 /* Pointer to structure for the file .SUFFIXES
55 whose dependencies are the suffixes to be searched. */
57 struct file *suffix_file;
59 /* Maximum length of a suffix. */
61 unsigned int maxsuffix;
63 /* Compute the maximum dependency length and maximum number of
64 dependencies of all implicit rules. Also sets the subdir
65 flag for a rule when appropriate, possibly removing the rule
66 completely when appropriate. */
69 count_implicit_rule_limits (void)
75 num_pattern_rules = max_pattern_targets = max_pattern_deps = 0;
76 max_pattern_dep_length = 0;
83 unsigned int ndeps = 0;
85 struct rule *next = rule->next;
89 if (rule->num > max_pattern_targets)
90 max_pattern_targets = rule->num;
92 for (dep = rule->deps; dep != 0; dep = dep->next)
94 const char *dname = dep_name (dep);
95 unsigned int len = strlen (dname);
98 const char *p = strrchr (dname, ']');
101 p = strrchr (dname, ':');
102 p2 = p != 0 ? strchr (dname, '%') : 0;
104 const char *p = strrchr (dname, '/');
105 const char *p2 = p != 0 ? strchr (dname, '%') : 0;
109 if (len > max_pattern_dep_length)
110 max_pattern_dep_length = len;
112 if (p != 0 && p2 > p)
114 /* There is a slash before the % in the dep name.
115 Extract the directory name. */
118 if (p - dname > namelen)
121 name = xrealloc (name, namelen + 1);
123 memcpy (name, dname, p - dname);
124 name[p - dname] = '\0';
126 /* In the deps of an implicit rule the 'changed' flag
127 actually indicates that the dependency is in a
128 nonexistent subdirectory. */
130 dep->changed = !dir_file_exists_p (name, "");
133 /* This dependency does not reside in a subdirectory. */
137 if (ndeps > max_pattern_deps)
138 max_pattern_deps = ndeps;
147 /* Create a pattern rule from a suffix rule.
148 TARGET is the target suffix; SOURCE is the source suffix.
149 CMDS are the commands.
150 If TARGET is nil, it means the target pattern should be '(%.o)'.
151 If SOURCE is nil, it means there should be no deps. */
154 convert_suffix_rule (const char *target, const char *source,
155 struct commands *cmds)
157 const char **names, **percents;
160 names = xmalloc (sizeof (const char *));
161 percents = xmalloc (sizeof (const char *));
165 /* Special case: TARGET being nil means we are defining a '.X.a' suffix
166 rule; the target pattern is always '(%.o)'. */
168 *names = strcache_add_len ("(%.obj)", 7);
170 *names = strcache_add_len ("(%.o)", 5);
172 *percents = *names + 1;
176 /* Construct the target name. */
177 unsigned int len = strlen (target);
178 char *p = alloca (1 + len + 1);
180 memcpy (p + 1, target, len + 1);
181 *names = strcache_add_len (p, len + 1);
189 /* Construct the dependency name. */
190 unsigned int len = strlen (source);
191 char *p = alloca (1 + len + 1);
193 memcpy (p + 1, source, len + 1);
195 deps->name = strcache_add_len (p, len + 1);
198 create_pattern_rule (names, percents, 1, 0, deps, cmds, 0);
201 /* Convert old-style suffix rules to pattern rules.
202 All rules for the suffixes on the .SUFFIXES list are converted and added to
203 the chain of pattern rules. */
206 convert_to_pattern (void)
211 /* We will compute every potential suffix rule (.x.y) from the list of
212 suffixes in the .SUFFIXES target's dependencies and see if it exists.
213 First find the longest of the suffixes. */
216 for (d = suffix_file->deps; d != 0; d = d->next)
218 unsigned int l = strlen (dep_name (d));
223 /* Space to construct the suffix rule target name. */
224 rulename = alloca ((maxsuffix * 2) + 1);
226 for (d = suffix_file->deps; d != 0; d = d->next)
230 /* Make a rule that is just the suffix, with no deps or commands.
231 This rule exists solely to disqualify match-anything rules. */
232 convert_suffix_rule (dep_name (d), 0, 0);
234 if (d->file->cmds != 0)
235 /* Record a pattern for this suffix's null-suffix rule. */
236 convert_suffix_rule ("", dep_name (d), d->file->cmds);
238 /* Add every other suffix to this one and see if it exists as a
240 slen = strlen (dep_name (d));
241 memcpy (rulename, dep_name (d), slen);
243 for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
248 s2len = strlen (dep_name (d2));
250 /* Can't build something from itself. */
251 if (slen == s2len && streq (dep_name (d), dep_name (d2)))
254 memcpy (rulename + slen, dep_name (d2), s2len + 1);
255 f = lookup_file (rulename);
256 if (f == 0 || f->cmds == 0)
259 if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a')
260 /* A suffix rule '.X.a:' generates the pattern rule '(%.o): %.X'.
261 It also generates a normal '%.a: %.X' rule below. */
262 convert_suffix_rule (NULL, /* Indicates '(%.o)'. */
266 /* The suffix rule '.X.Y:' is converted
267 to the pattern rule '%.Y: %.X'. */
268 convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds);
274 /* Install the pattern rule RULE (whose fields have been filled in) at the end
275 of the list (so that any rules previously defined will take precedence).
276 If this rule duplicates a previous one (identical target and dependencies),
277 the old one is replaced if OVERRIDE is nonzero, otherwise this new one is
278 thrown out. When an old rule is replaced, the new one is put at the end of
279 the list. Return nonzero if RULE is used; zero if not. */
282 new_pattern_rule (struct rule *rule, int override)
284 struct rule *r, *lastrule;
292 /* Search for an identical rule. */
294 for (r = pattern_rules; r != 0; lastrule = r, r = r->next)
295 for (i = 0; i < rule->num; ++i)
297 for (j = 0; j < r->num; ++j)
298 if (!streq (rule->targets[i], r->targets[j]))
300 /* If all the targets matched... */
304 for (d = rule->deps, d2 = r->deps;
305 d != 0 && d2 != 0; d = d->next, d2 = d2->next)
306 if (!streq (dep_name (d), dep_name (d2)))
308 if (d == 0 && d2 == 0)
310 /* All the dependencies matched. */
313 /* Remove the old rule. */
314 freerule (r, lastrule);
315 /* Install the new one. */
316 if (pattern_rules == 0)
317 pattern_rules = rule;
319 last_pattern_rule->next = rule;
320 last_pattern_rule = rule;
322 /* We got one. Stop looking. */
327 /* The old rule stays intact. Destroy the new one. */
328 freerule (rule, (struct rule *) 0);
339 /* There was no rule to replace. */
340 if (pattern_rules == 0)
341 pattern_rules = rule;
343 last_pattern_rule->next = rule;
344 last_pattern_rule = rule;
351 /* Install an implicit pattern rule based on the three text strings
352 in the structure P points to. These strings come from one of
353 the arrays of default implicit pattern rules.
354 TERMINAL specifies what the 'terminal' field of the rule should be. */
357 install_pattern_rule (struct pspec *p, int terminal)
362 r = xmalloc (sizeof (struct rule));
365 r->targets = xmalloc (sizeof (const char *));
366 r->suffixes = xmalloc (sizeof (const char *));
367 r->lens = xmalloc (sizeof (unsigned int));
369 r->lens[0] = strlen (p->target);
370 r->targets[0] = p->target;
371 r->suffixes[0] = find_percent_cached (&r->targets[0]);
372 assert (r->suffixes[0] != NULL);
376 r->deps = PARSE_SIMPLE_SEQ (&ptr, struct dep);
378 if (new_pattern_rule (r, 0))
380 r->terminal = terminal;
381 r->cmds = xmalloc (sizeof (struct commands));
382 r->cmds->fileinfo.filenm = 0;
383 r->cmds->fileinfo.lineno = 0;
384 /* These will all be string literals, but we malloc space for them
385 anyway because somebody might want to free them later. */
386 r->cmds->commands = xstrdup (p->commands);
387 r->cmds->command_lines = 0;
388 r->cmds->recipe_prefix = RECIPEPREFIX_DEFAULT;
393 /* Free all the storage used in RULE and take it out of the
394 pattern_rules chain. LASTRULE is the rule whose next pointer
398 freerule (struct rule *rule, struct rule *lastrule)
400 struct rule *next = rule->next;
402 free_dep_chain (rule->deps);
404 /* MSVC erroneously warns without a cast here. */
405 free ((void *)rule->targets);
406 free ((void *)rule->suffixes);
409 /* We can't free the storage for the commands because there
410 are ways that they could be in more than one place:
411 * If the commands came from a suffix rule, they could also be in
412 the 'struct file's for other suffix rules or plain targets given
413 on the same makefile line.
414 * If two suffixes that together make a two-suffix rule were each
415 given twice in the .SUFFIXES list, and in the proper order, two
416 identical pattern rules would be created and the second one would
417 be discarded here, but both would contain the same 'struct commands'
418 pointer from the 'struct file' for the suffix rule. */
422 if (pattern_rules == rule)
426 pattern_rules = next;
427 else if (lastrule != 0)
428 lastrule->next = next;
429 if (last_pattern_rule == rule)
430 last_pattern_rule = lastrule;
433 /* Create a new pattern rule with the targets in the nil-terminated array
434 TARGETS. TARGET_PERCENTS is an array of pointers to the % in each element
435 of TARGETS. N is the number of items in the array (not counting the nil
436 element). The new rule has dependencies DEPS and commands from COMMANDS.
437 It is a terminal rule if TERMINAL is nonzero. This rule overrides
438 identical rules with different commands if OVERRIDE is nonzero.
440 The storage for TARGETS and its elements and TARGET_PERCENTS is used and
441 must not be freed until the rule is destroyed. */
444 create_pattern_rule (const char **targets, const char **target_percents,
445 unsigned int n, int terminal, struct dep *deps,
446 struct commands *commands, int override)
449 struct rule *r = xmalloc (sizeof (struct rule));
454 r->targets = targets;
455 r->suffixes = target_percents;
456 r->lens = xmalloc (n * sizeof (unsigned int));
458 for (i = 0; i < n; ++i)
460 r->lens[i] = strlen (targets[i]);
461 assert (r->suffixes[i] != NULL);
465 if (new_pattern_rule (r, override))
466 r->terminal = terminal;
469 /* Print the data base of rules. */
471 static void /* Useful to call from gdb. */
472 print_rule (struct rule *r)
476 for (i = 0; i < r->num; ++i)
478 fputs (r->targets[i], stdout);
479 putchar ((i + 1 == r->num) ? ':' : ' ');
484 print_prereqs (r->deps);
487 print_commands (r->cmds);
491 print_rule_data_base (void)
493 unsigned int rules, terminal;
496 puts (_("\n# Implicit Rules"));
498 rules = terminal = 0;
499 for (r = pattern_rules; r != 0; r = r->next)
511 puts (_("\n# No implicit rules."));
514 printf (_("\n# %u implicit rules, %u"), rules, terminal);
516 printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0);
519 int f = (terminal * 1000 + 5) / rules;
520 printf (" (%d.%d%%)", f/10, f%10);
523 puts (_(" terminal."));
526 if (num_pattern_rules != rules)
528 /* This can happen if a fatal error was detected while reading the
529 makefiles and thus count_implicit_rule_limits wasn't called yet. */
530 if (num_pattern_rules != 0)
531 fatal (NILF, _("BUG: num_pattern_rules is wrong! %u != %u"),
532 num_pattern_rules, rules);