rule.c

   1 /* Pattern and suffix rule internals for GNU Make.
   2 Copyright (C) 1988,89,90,91,92,93, 1998 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, 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
  28 static void freerule PARAMS ((struct rule *rule, struct rule *lastrule));
  29 \f
  30 /* Chain of all pattern rules.  */
  31
  32 struct rule *pattern_rules;
  33
  34 /* Pointer to last rule in the chain, so we can add onto the end.  */
  35
  36 struct rule *last_pattern_rule;
  37
  38 /* Number of rules in the chain.  */
  39
  40 unsigned int num_pattern_rules;
  41
  42 /* Maximum number of target patterns of any pattern rule.  */
  43
  44 unsigned int max_pattern_targets;
  45
  46 /* Maximum number of dependencies of any pattern rule.  */
  47
  48 unsigned int max_pattern_deps;
  49
  50 /* Maximum length of the name of a dependencies of any pattern rule.  */
  51
  52 unsigned int max_pattern_dep_length;
  53
  54 /* Chain of all pattern-specific variables.  */
  55
  56 static struct pattern_var *pattern_vars;
  57
  58 /* Pointer to last struct in the chain, so we can add onto the end.  */
  59
  60 static 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
  65 struct file *suffix_file;
  66
  67 /* Maximum length of a suffix.  */
  68
  69 unsigned int maxsuffix;
  70 \f
  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
  76 void
  77 count_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 \f
 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
 184 static void
 185 convert_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
 243 void
 244 convert_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
 312 int
 313 new_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
 389 void
 390 install_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
 441 static void
 442 freerule (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 \f
 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
 503 void
 504 create_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 \f
 551 /* Create a new pattern-specific variable struct.  */
 552
 553 struct pattern_var *
 554 create_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 \f
 583 /* Look up a target in the pattern-specific variable list.  */
 584
 585 struct pattern_var *
 586 lookup_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 \f
 623 /* Print the data base of rules.  */
 624
 625 static void                     /* Useful to call from gdb.  */
 626 print_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
 651 void
 652 print_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 }