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