1/* Pattern and suffix rule internals for GNU Make. 2Copyright (C) 1988,89,90,91,92,93, 1998 Free Software Foundation, Inc. 3This file is part of GNU Make. 4 5GNU Make is free software; you can redistribute it and/or modify 6it under the terms of the GNU General Public License as published by 7the Free Software Foundation; either version 2, or (at your option) 8any later version. 9 10GNU Make is distributed in the hope that it will be useful, 11but WITHOUT ANY WARRANTY; without even the implied warranty of 12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13GNU General Public License for more details. 14 15You should have received a copy of the GNU General Public License 16along with GNU Make; see the file COPYING. If not, write to 17the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 18Boston, MA 02111-1307, USA. */ 19 20#include "make.h" 21#include "dep.h" 22#include "filedef.h" 23#include "job.h" 24#include "commands.h" 25#include "variable.h" 26#include "rule.h" 27 28static void freerule PARAMS ((struct rule *rule, struct rule *lastrule)); 29 30/* Chain of all pattern rules. */ 31 32struct rule *pattern_rules; 33 34/* Pointer to last rule in the chain, so we can add onto the end. */ 35 36struct rule *last_pattern_rule; 37 38/* Number of rules in the chain. */ 39 40unsigned int num_pattern_rules; 41 42/* Maximum number of target patterns of any pattern rule. */ 43 44unsigned int max_pattern_targets; 45 46/* Maximum number of dependencies of any pattern rule. */ 47 48unsigned int max_pattern_deps; 49 50/* Maximum length of the name of a dependencies of any pattern rule. */ 51 52unsigned int max_pattern_dep_length; 53 54/* Chain of all pattern-specific variables. */ 55 56static struct pattern_var *pattern_vars; 57 58/* Pointer to last struct in the chain, so we can add onto the end. */ 59 60static struct pattern_var *last_pattern_var; 61 62/* Pointer to structure for the file .SUFFIXES 63 whose dependencies are the suffixes to be searched. */ 64 65struct file *suffix_file; 66 67/* Maximum length of a suffix. */ 68 69unsigned int maxsuffix; 70 71/* Compute the maximum dependency length and maximum number of 72 dependencies of all implicit rules. Also sets the subdir 73 flag for a rule when appropriate, possibly removing the rule 74 completely when appropriate. */ 75 76void 77count_implicit_rule_limits () 78{ 79 char *name; 80 unsigned int namelen; 81 register struct rule *rule, *lastrule; 82 83 num_pattern_rules = max_pattern_targets = max_pattern_deps = 0; 84 max_pattern_dep_length = 0; 85 86 name = 0; 87 namelen = 0; 88 rule = pattern_rules; 89 lastrule = 0; 90 while (rule != 0) 91 { 92 unsigned int ndeps = 0; 93 register struct dep *dep; 94 struct rule *next = rule->next; 95 unsigned int ntargets; 96 97 ++num_pattern_rules; 98 99 ntargets = 0; 100 while (rule->targets[ntargets] != 0) 101 ++ntargets; 102 103 if (ntargets > max_pattern_targets) 104 max_pattern_targets = ntargets; 105 106 for (dep = rule->deps; dep != 0; dep = dep->next) 107 { 108 unsigned int len = strlen (dep->name); 109 110#ifdef VMS 111 char *p = strrchr (dep->name, ']'); 112 char *p2; 113 if (p == 0) 114 p = strrchr (dep->name, ':'); 115 p2 = p != 0 ? strchr (dep->name, '%') : 0; 116#else 117 char *p = strrchr (dep->name, '/'); 118 char *p2 = p != 0 ? strchr (dep->name, '%') : 0; 119#endif 120 ndeps++; 121 122 if (len > max_pattern_dep_length) 123 max_pattern_dep_length = len; 124 125 if (p != 0 && p2 > p) 126 { 127 /* There is a slash before the % in the dep name. 128 Extract the directory name. */ 129 if (p == dep->name) 130 ++p; 131 if (p - dep->name > namelen) 132 { 133 if (name != 0) 134 free (name); 135 namelen = p - dep->name; 136 name = (char *) xmalloc (namelen + 1); 137 } 138 bcopy (dep->name, name, p - dep->name); 139 name[p - dep->name] = '\0'; 140 141 /* In the deps of an implicit rule the `changed' flag 142 actually indicates that the dependency is in a 143 nonexistent subdirectory. */ 144 145 dep->changed = !dir_file_exists_p (name, ""); 146#ifdef VMS 147 if (dep->changed && strchr (name, ':') != 0) 148#else 149 if (dep->changed && *name == '/') 150#endif 151 { 152 /* The name is absolute and the directory does not exist. 153 This rule can never possibly match, since this dependency 154 can never possibly exist. So just remove the rule from 155 the list. */ 156 freerule (rule, lastrule); 157 --num_pattern_rules; 158 goto end_main_loop; 159 } 160 } 161 else 162 /* This dependency does not reside in a subdirectory. */ 163 dep->changed = 0; 164 } 165 166 if (ndeps > max_pattern_deps) 167 max_pattern_deps = ndeps; 168 169 lastrule = rule; 170 end_main_loop: 171 rule = next; 172 } 173 174 if (name != 0) 175 free (name); 176} 177 178/* Create a pattern rule from a suffix rule. 179 TARGET is the target suffix; SOURCE is the source suffix. 180 CMDS are the commands. 181 If TARGET is nil, it means the target pattern should be `(%.o)'. 182 If SOURCE is nil, it means there should be no deps. */ 183 184static void 185convert_suffix_rule (target, source, cmds) 186 char *target, *source; 187 struct commands *cmds; 188{ 189 char *targname, *targpercent, *depname; 190 char **names, **percents; 191 struct dep *deps; 192 unsigned int len; 193 194 if (target == 0) 195 /* Special case: TARGET being nil means we are defining a 196 `.X.a' suffix rule; the target pattern is always `(%.o)'. */ 197 { 198#ifdef VMS 199 targname = savestring ("(%.obj)", 7); 200#else 201 targname = savestring ("(%.o)", 5); 202#endif 203 targpercent = targname + 1; 204 } 205 else 206 { 207 /* Construct the target name. */ 208 len = strlen (target); 209 targname = xmalloc (1 + len + 1); 210 targname[0] = '%'; 211 bcopy (target, targname + 1, len + 1); 212 targpercent = targname; 213 } 214 215 names = (char **) xmalloc (2 * sizeof (char *)); 216 percents = (char **) alloca (2 * sizeof (char *)); 217 names[0] = targname; 218 percents[0] = targpercent; 219 names[1] = percents[1] = 0; 220 221 if (source == 0) 222 deps = 0; 223 else 224 { 225 /* Construct the dependency name. */ 226 len = strlen (source); 227 depname = xmalloc (1 + len + 1); 228 depname[0] = '%'; 229 bcopy (source, depname + 1, len + 1); 230 deps = (struct dep *) xmalloc (sizeof (struct dep)); 231 deps->next = 0; 232 deps->name = depname; 233 deps->ignore_mtime = 0; 234 } 235 236 create_pattern_rule (names, percents, 0, deps, cmds, 0); 237} 238 239/* Convert old-style suffix rules to pattern rules. 240 All rules for the suffixes on the .SUFFIXES list 241 are converted and added to the chain of pattern rules. */ 242 243void 244convert_to_pattern () 245{ 246 register struct dep *d, *d2; 247 register struct file *f; 248 register char *rulename; 249 register unsigned int slen, s2len; 250 251 /* Compute maximum length of all the suffixes. */ 252 253 maxsuffix = 0; 254 for (d = suffix_file->deps; d != 0; d = d->next) 255 { 256 register unsigned int namelen = strlen (dep_name (d)); 257 if (namelen > maxsuffix) 258 maxsuffix = namelen; 259 } 260 261 rulename = (char *) alloca ((maxsuffix * 2) + 1); 262 263 for (d = suffix_file->deps; d != 0; d = d->next) 264 { 265 /* Make a rule that is just the suffix, with no deps or commands. 266 This rule exists solely to disqualify match-anything rules. */ 267 convert_suffix_rule (dep_name (d), (char *) 0, (struct commands *) 0); 268 269 f = d->file; 270 if (f->cmds != 0) 271 /* Record a pattern for this suffix's null-suffix rule. */ 272 convert_suffix_rule ("", dep_name (d), f->cmds); 273 274 /* Record a pattern for each of this suffix's two-suffix rules. */ 275 slen = strlen (dep_name (d)); 276 bcopy (dep_name (d), rulename, slen); 277 for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next) 278 { 279 s2len = strlen (dep_name (d2)); 280 281 if (slen == s2len && streq (dep_name (d), dep_name (d2))) 282 continue; 283 284 bcopy (dep_name (d2), rulename + slen, s2len + 1); 285 f = lookup_file (rulename); 286 if (f == 0 || f->cmds == 0) 287 continue; 288 289 if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a') 290 /* A suffix rule `.X.a:' generates the pattern rule `(%.o): %.X'. 291 It also generates a normal `%.a: %.X' rule below. */ 292 convert_suffix_rule ((char *) 0, /* Indicates `(%.o)'. */ 293 dep_name (d), 294 f->cmds); 295 296 /* The suffix rule `.X.Y:' is converted 297 to the pattern rule `%.Y: %.X'. */ 298 convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds); 299 } 300 } 301} 302 303 304/* Install the pattern rule RULE (whose fields have been filled in) 305 at the end of the list (so that any rules previously defined 306 will take precedence). If this rule duplicates a previous one 307 (identical target and dependencies), the old one is replaced 308 if OVERRIDE is nonzero, otherwise this new one is thrown out. 309 When an old rule is replaced, the new one is put at the end of the 310 list. Return nonzero if RULE is used; zero if not. */ 311 312int 313new_pattern_rule (rule, override) 314 register struct rule *rule; 315 int override; 316{ 317 register struct rule *r, *lastrule; 318 register unsigned int i, j; 319 320 rule->in_use = 0; 321 rule->terminal = 0; 322 323 rule->next = 0; 324 325 /* Search for an identical rule. */ 326 lastrule = 0; 327 for (r = pattern_rules; r != 0; lastrule = r, r = r->next) 328 for (i = 0; rule->targets[i] != 0; ++i) 329 { 330 for (j = 0; r->targets[j] != 0; ++j) 331 if (!streq (rule->targets[i], r->targets[j])) 332 break; 333 if (r->targets[j] == 0) 334 /* All the targets matched. */ 335 { 336 register struct dep *d, *d2; 337 for (d = rule->deps, d2 = r->deps; 338 d != 0 && d2 != 0; d = d->next, d2 = d2->next) 339 if (!streq (dep_name (d), dep_name (d2))) 340 break; 341 if (d == 0 && d2 == 0) 342 { 343 /* All the dependencies matched. */ 344 if (override) 345 { 346 /* Remove the old rule. */ 347 freerule (r, lastrule); 348 /* Install the new one. */ 349 if (pattern_rules == 0) 350 pattern_rules = rule; 351 else 352 last_pattern_rule->next = rule; 353 last_pattern_rule = rule; 354 355 /* We got one. Stop looking. */ 356 goto matched; 357 } 358 else 359 { 360 /* The old rule stays intact. Destroy the new one. */ 361 freerule (rule, (struct rule *) 0); 362 return 0; 363 } 364 } 365 } 366 } 367 368 matched:; 369 370 if (r == 0) 371 { 372 /* There was no rule to replace. */ 373 if (pattern_rules == 0) 374 pattern_rules = rule; 375 else 376 last_pattern_rule->next = rule; 377 last_pattern_rule = rule; 378 } 379 380 return 1; 381} 382 383 384/* Install an implicit pattern rule based on the three text strings 385 in the structure P points to. These strings come from one of 386 the arrays of default implicit pattern rules. 387 TERMINAL specifies what the `terminal' field of the rule should be. */ 388 389void 390install_pattern_rule (p, terminal) 391 struct pspec *p; 392 int terminal; 393{ 394 register struct rule *r; 395 char *ptr; 396 397 r = (struct rule *) xmalloc (sizeof (struct rule)); 398 399 r->targets = (char **) xmalloc (2 * sizeof (char *)); 400 r->suffixes = (char **) xmalloc (2 * sizeof (char *)); 401 r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); 402 403 r->targets[1] = 0; 404 r->suffixes[1] = 0; 405 r->lens[1] = 0; 406 407 r->lens[0] = strlen (p->target); 408 /* These will all be string literals, but we malloc space for 409 them anyway because somebody might want to free them later on. */ 410 r->targets[0] = savestring (p->target, r->lens[0]); 411 r->suffixes[0] = find_percent (r->targets[0]); 412 if (r->suffixes[0] == 0) 413 /* Programmer-out-to-lunch error. */ 414 abort (); 415 else 416 ++r->suffixes[0]; 417 418 ptr = p->dep; 419 r->deps = (struct dep *) multi_glob (parse_file_seq (&ptr, '\0', 420 sizeof (struct dep), 1), 421 sizeof (struct dep)); 422 423 if (new_pattern_rule (r, 0)) 424 { 425 r->terminal = terminal; 426 r->cmds = (struct commands *) xmalloc (sizeof (struct commands)); 427 r->cmds->fileinfo.filenm = 0; 428 r->cmds->fileinfo.lineno = 0; 429 /* These will all be string literals, but we malloc space for them 430 anyway because somebody might want to free them later. */ 431 r->cmds->commands = xstrdup (p->commands); 432 r->cmds->command_lines = 0; 433 } 434} 435 436 437/* Free all the storage used in RULE and take it out of the 438 pattern_rules chain. LASTRULE is the rule whose next pointer 439 points to RULE. */ 440 441static void 442freerule (rule, lastrule) 443 register struct rule *rule, *lastrule; 444{ 445 struct rule *next = rule->next; 446 register unsigned int i; 447 register struct dep *dep; 448 449 for (i = 0; rule->targets[i] != 0; ++i) 450 free (rule->targets[i]); 451 452 dep = rule->deps; 453 while (dep) 454 { 455 struct dep *t; 456 457 t = dep->next; 458 /* We might leak dep->name here, but I'm not sure how to fix this: I 459 think that pointer might be shared (e.g., in the file hash?) */ 460 free ((char *) dep); 461 dep = t; 462 } 463 464 free ((char *) rule->targets); 465 free ((char *) rule->suffixes); 466 free ((char *) rule->lens); 467 468 /* We can't free the storage for the commands because there 469 are ways that they could be in more than one place: 470 * If the commands came from a suffix rule, they could also be in 471 the `struct file's for other suffix rules or plain targets given 472 on the same makefile line. 473 * If two suffixes that together make a two-suffix rule were each 474 given twice in the .SUFFIXES list, and in the proper order, two 475 identical pattern rules would be created and the second one would 476 be discarded here, but both would contain the same `struct commands' 477 pointer from the `struct file' for the suffix rule. */ 478 479 free ((char *) rule); 480 481 if (pattern_rules == rule) 482 if (lastrule != 0) 483 abort (); 484 else 485 pattern_rules = next; 486 else if (lastrule != 0) 487 lastrule->next = next; 488 if (last_pattern_rule == rule) 489 last_pattern_rule = lastrule; 490} 491 492/* Create a new pattern rule with the targets in the nil-terminated 493 array TARGETS. If TARGET_PERCENTS is not nil, it is an array of 494 pointers into the elements of TARGETS, where the `%'s are. 495 The new rule has dependencies DEPS and commands from COMMANDS. 496 It is a terminal rule if TERMINAL is nonzero. This rule overrides 497 identical rules with different commands if OVERRIDE is nonzero. 498 499 The storage for TARGETS and its elements is used and must not be freed 500 until the rule is destroyed. The storage for TARGET_PERCENTS is not used; 501 it may be freed. */ 502 503void 504create_pattern_rule (targets, target_percents, 505 terminal, deps, commands, override) 506 char **targets, **target_percents; 507 int terminal; 508 struct dep *deps; 509 struct commands *commands; 510 int override; 511{ 512 register struct rule *r = (struct rule *) xmalloc (sizeof (struct rule)); 513 register unsigned int max_targets, i; 514 515 r->cmds = commands; 516 r->deps = deps; 517 r->targets = targets; 518 519 max_targets = 2; 520 r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); 521 r->suffixes = (char **) xmalloc (2 * sizeof (char *)); 522 for (i = 0; targets[i] != 0; ++i) 523 { 524 if (i == max_targets - 1) 525 { 526 max_targets += 5; 527 r->lens = (unsigned int *) 528 xrealloc ((char *) r->lens, max_targets * sizeof (unsigned int)); 529 r->suffixes = (char **) 530 xrealloc ((char *) r->suffixes, max_targets * sizeof (char *)); 531 } 532 r->lens[i] = strlen (targets[i]); 533 r->suffixes[i] = (target_percents == 0 ? find_percent (targets[i]) 534 : target_percents[i]) + 1; 535 if (r->suffixes[i] == 0) 536 abort (); 537 } 538 539 if (i < max_targets - 1) 540 { 541 r->lens = (unsigned int *) xrealloc ((char *) r->lens, 542 (i + 1) * sizeof (unsigned int)); 543 r->suffixes = (char **) xrealloc ((char *) r->suffixes, 544 (i + 1) * sizeof (char *)); 545 } 546 547 if (new_pattern_rule (r, override)) 548 r->terminal = terminal; 549} 550 551/* Create a new pattern-specific variable struct. */ 552 553struct pattern_var * 554create_pattern_var (target, suffix) 555 char *target, *suffix; 556{ 557 register struct pattern_var *p = 0; 558 unsigned int len = strlen(target); 559 560 /* Look to see if this pattern already exists in the list. */ 561 for (p = pattern_vars; p != NULL; p = p->next) 562 if (p->len == len && !strcmp(p->target, target)) 563 break; 564 565 if (p == 0) 566 { 567 p = (struct pattern_var *) xmalloc (sizeof (struct pattern_var)); 568 if (last_pattern_var != 0) 569 last_pattern_var->next = p; 570 else 571 pattern_vars = p; 572 last_pattern_var = p; 573 p->next = 0; 574 p->target = target; 575 p->len = len; 576 p->suffix = suffix + 1; 577 p->vars = create_new_variable_set(); 578 } 579 580 return p; 581} 582 583/* Look up a target in the pattern-specific variable list. */ 584 585struct pattern_var * 586lookup_pattern_var (target) 587 char *target; 588{ 589 struct pattern_var *p; 590 unsigned int targlen = strlen(target); 591 592 for (p = pattern_vars; p != 0; p = p->next) 593 { 594 char *stem; 595 unsigned int stemlen; 596 597 if (p->len > targlen) 598 /* It can't possibly match. */ 599 continue; 600 601 /* From the lengths of the filename and the pattern parts, 602 find the stem: the part of the filename that matches the %. */ 603 stem = target + (p->suffix - p->target - 1); 604 stemlen = targlen - p->len + 1; 605 606 /* Compare the text in the pattern before the stem, if any. */ 607 if (stem > target && !strneq (p->target, target, stem - target)) 608 continue; 609 610 /* Compare the text in the pattern after the stem, if any. 611 We could test simply using streq, but this way we compare the 612 first two characters immediately. This saves time in the very 613 common case where the first character matches because it is a 614 period. */ 615 if (*p->suffix == stem[stemlen] 616 && (*p->suffix == '\0' || streq (&p->suffix[1], &stem[stemlen+1]))) 617 break; 618 } 619 620 return p; 621} 622 623/* Print the data base of rules. */ 624 625static void /* Useful to call from gdb. */ 626print_rule (r) 627 struct rule *r; 628{ 629 register unsigned int i; 630 register struct dep *d; 631 632 for (i = 0; r->targets[i] != 0; ++i) 633 { 634 fputs (r->targets[i], stdout); 635 if (r->targets[i + 1] != 0) 636 putchar (' '); 637 else 638 putchar (':'); 639 } 640 if (r->terminal) 641 putchar (':'); 642 643 for (d = r->deps; d != 0; d = d->next) 644 printf (" %s", dep_name (d)); 645 putchar ('\n'); 646 647 if (r->cmds != 0) 648 print_commands (r->cmds); 649} 650 651void 652print_rule_data_base () 653{ 654 register unsigned int rules, terminal; 655 register struct rule *r; 656 657 puts (_("\n# Implicit Rules")); 658 659 rules = terminal = 0; 660 for (r = pattern_rules; r != 0; r = r->next) 661 { 662 ++rules; 663 664 putchar ('\n'); 665 print_rule (r); 666 667 if (r->terminal) 668 ++terminal; 669 } 670 671 if (rules == 0) 672 puts (_("\n# No implicit rules.")); 673 else 674 { 675 printf (_("\n# %u implicit rules, %u"), rules, terminal); 676#ifndef NO_FLOAT 677 printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0); 678#else 679 { 680 int f = (terminal * 1000 + 5) / rules; 681 printf (" (%d.%d%%)", f/10, f%10); 682 } 683#endif 684 puts (_(" terminal.")); 685 } 686 687 if (num_pattern_rules != rules) 688 { 689 /* This can happen if a fatal error was detected while reading the 690 makefiles and thus count_implicit_rule_limits wasn't called yet. */ 691 if (num_pattern_rules != 0) 692 fatal (NILF, _("BUG: num_pattern_rules wrong! %u != %u"), 693 num_pattern_rules, rules); 694 } 695 696 puts (_("\n# Pattern-specific variable values")); 697 698 { 699 struct pattern_var *p; 700 701 rules = 0; 702 for (p = pattern_vars; p != 0; p = p->next) 703 { 704 ++rules; 705 706 printf ("\n%s :\n", p->target); 707 print_variable_set (p->vars->set, "# "); 708 } 709 710 if (rules == 0) 711 puts (_("\n# No pattern-specific variable values.")); 712 else 713 { 714 printf (_("\n# %u pattern-specific variable values"), rules); 715 } 716 } 717} 718