rule.c

   1 /* Pattern and suffix rule internals for GNU Make.
   2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 #include "make.h"
  20 #include "commands.h"
  21 #include "dep.h"
  22 #include "file.h"
  23 #include "variable.h"
  24 #include "rule.h"
  25
  26 static void freerule ();
  27 \f
  28 /* Chain of all pattern rules.  */
  29
  30 struct rule *pattern_rules;
  31
  32 /* Pointer to last rule in the chain, so we can add onto the end.  */
  33
  34 struct rule *last_pattern_rule;
  35
  36 /* Number of rules in the chain.  */
  37
  38 unsigned int num_pattern_rules;
  39
  40 /* Maximum number of target patterns of any pattern rule.  */
  41
  42 unsigned int max_pattern_targets;
  43
  44 /* Maximum number of dependencies of any pattern rule.  */
  45
  46 unsigned int max_pattern_deps;
  47
  48 /* Maximum length of the name of a dependencies of any pattern rule.  */
  49
  50 unsigned int max_pattern_dep_length;
  51
  52 /* Pointer to structure for the file .SUFFIXES
  53    whose dependencies are the suffixes to be searched.  */
  54
  55 struct file *suffix_file;
  56
  57 /* Maximum length of a suffix.  */
  58
  59 unsigned int maxsuffix;
  60 \f
  61 /* Compute the maximum dependency length and maximum number of
  62    dependencies of all implicit rules.  Also sets the subdir
  63    flag for a rule when appropriate, possibly removing the rule
  64    completely when appropriate.  */
  65
  66 void
  67 count_implicit_rule_limits ()
  68 {
  69   char *name;
  70   unsigned int namelen;
  71   register struct rule *rule, *lastrule;
  72
  73   num_pattern_rules = max_pattern_targets = max_pattern_deps = 0;
  74   max_pattern_dep_length = 0;
  75
  76   name = 0;
  77   namelen = 0;
  78   rule = pattern_rules;
  79   lastrule = 0;
  80   while (rule != 0)
  81     {
  82       unsigned int ndeps = 0;
  83       register struct dep *dep;
  84       struct rule *next = rule->next;
  85       unsigned int ntargets;
  86
  87       ++num_pattern_rules;
  88
  89       ntargets = 0;
  90       while (rule->targets[ntargets] != 0)
  91         ++ntargets;
  92
  93       if (ntargets > max_pattern_targets)
  94         max_pattern_targets = ntargets;
  95
  96       for (dep = rule->deps; dep != 0; dep = dep->next)
  97         {
  98           unsigned int len = strlen (dep->name);
  99           char *p = rindex (dep->name, '/');
 100           char *p2 = p != 0 ? index (dep->name, '%') : 0;
 101
 102           ndeps++;
 103
 104           if (len > max_pattern_dep_length)
 105             max_pattern_dep_length = len;
 106
 107           if (p != 0 && p2 > p)
 108             {
 109               /* There is a slash before the % in the dep name.
 110                  Extract the directory name.  */
 111               if (p == dep->name)
 112                 ++p;
 113               if (p - dep->name > namelen)
 114                 {
 115                   if (name != 0)
 116                     free (name);
 117                   namelen = p - dep->name;
 118                   name = (char *) xmalloc (namelen + 1);
 119                 }
 120               bcopy (dep->name, name, p - dep->name);
 121               name[p - dep->name] = '\0';
 122
 123               /* In the deps of an implicit rule the `changed' flag
 124                  actually indicates that the dependency is in a
 125                  nonexistent subdirectory.  */
 126
 127               dep->changed = !dir_file_exists_p (name, "");
 128               if (dep->changed && *name == '/')
 129                 {
 130                   /* The name is absolute and the directory does not exist.
 131                      This rule can never possibly match, since this dependency
 132                      can never possibly exist.  So just remove the rule from
 133                      the list.  */
 134                   freerule (rule, lastrule);
 135                   --num_pattern_rules;
 136                   goto end_main_loop;
 137                 }
 138             }
 139           else
 140             /* This dependency does not reside in a subdirectory.  */
 141             dep->changed = 0;
 142         }
 143
 144       if (ndeps > max_pattern_deps)
 145         max_pattern_deps = ndeps;
 146
 147       lastrule = rule;
 148     end_main_loop:
 149       rule = next;
 150     }
 151
 152   if (name != 0)
 153     free (name);
 154 }
 155 \f
 156 /* Create a pattern rule from a suffix rule.
 157    TARGET is the target suffix; SOURCE is the source suffix.
 158    CMDS are the commands.
 159    If TARGET is nil, it means the target pattern should be `(%.o)'.
 160    If SOURCE is nil, it means there should be no deps.  */
 161
 162 static void
 163 convert_suffix_rule (target, source, cmds)
 164      char *target, *source;
 165      struct commands *cmds;
 166 {
 167   char *targname, *targpercent, *depname;
 168   char **names, **percents;
 169   struct dep *deps;
 170   unsigned int len;
 171
 172   if (target == 0)
 173     /* Special case: TARGET being nil means we are defining a
 174        `.X.a' suffix rule; the target pattern is always `(%.o)'.  */
 175     {
 176       targname = savestring ("(%.o)", 5);
 177       targpercent = targname + 1;
 178     }
 179   else
 180     {
 181       /* Construct the target name.  */
 182       len = strlen (target);
 183       targname = xmalloc (1 + len + 1);
 184       targname[0] = '%';
 185       bcopy (target, targname + 1, len + 1);
 186       targpercent = targname;
 187     }
 188
 189   names = (char **) xmalloc (2 * sizeof (char *));
 190   percents = (char **) alloca (2 * sizeof (char *));
 191   names[0] = targname;
 192   percents[0] = targpercent;
 193   names[1] = percents[1] = 0;
 194
 195   if (source == 0)
 196     deps = 0;
 197   else
 198     {
 199       /* Construct the dependency name.  */
 200       len = strlen (source);
 201       depname = xmalloc (1 + len + 1);
 202       depname[0] = '%';
 203       bcopy (source, depname + 1, len + 1);
 204       deps = (struct dep *) xmalloc (sizeof (struct dep));
 205       deps->next = 0;
 206       deps->name = depname;
 207     }
 208
 209   create_pattern_rule (names, percents, 0, deps, cmds, 0);
 210 }
 211
 212 /* Convert old-style suffix rules to pattern rules.
 213    All rules for the suffixes on the .SUFFIXES list
 214    are converted and added to the chain of pattern rules.  */
 215
 216 void
 217 convert_to_pattern ()
 218 {
 219   register struct dep *d, *d2;
 220   register struct file *f;
 221   register char *rulename;
 222   register unsigned int slen, s2len;
 223
 224   /* Compute maximum length of all the suffixes.  */
 225
 226   maxsuffix = 0;
 227   for (d = suffix_file->deps; d != 0; d = d->next)
 228     {
 229       register unsigned int namelen = strlen (dep_name (d));
 230       if (namelen > maxsuffix)
 231         maxsuffix = namelen;
 232     }
 233
 234   rulename = (char *) alloca ((maxsuffix * 2) + 1);
 235
 236   for (d = suffix_file->deps; d != 0; d = d->next)
 237     {
 238       /* Make a rule that is just the suffix, with no deps or commands.
 239          This rule exists solely to disqualify match-anything rules.  */
 240       convert_suffix_rule (dep_name (d), (char *) 0, (struct commands *) 0);
 241
 242       f = d->file;
 243       if (f->cmds != 0)
 244         /* Record a pattern for this suffix's null-suffix rule.  */
 245         convert_suffix_rule ("", dep_name (d), f->cmds);
 246
 247       /* Record a pattern for each of this suffix's two-suffix rules.  */
 248       slen = strlen (dep_name (d));
 249       bcopy (dep_name (d), rulename, slen);
 250       for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
 251         {
 252           s2len = strlen (dep_name (d2));
 253
 254           if (slen == s2len && streq (dep_name (d), dep_name (d2)))
 255             continue;
 256
 257           bcopy (dep_name (d2), rulename + slen, s2len + 1);
 258           f = lookup_file (rulename);
 259           if (f == 0 || f->cmds == 0)
 260             continue;
 261
 262           if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a')
 263             /* A suffix rule `.X.a:' generates the pattern rule `(%.o): %.X'.
 264                It also generates a normal `%.a: %.X' rule below.  */
 265             convert_suffix_rule ((char *) 0, /* Indicates `(%.o)'.  */
 266                                  dep_name (d),
 267                                  f->cmds);
 268
 269           /* The suffix rule `.X.Y:' is converted
 270              to the pattern rule `%.Y: %.X'.  */
 271           convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds);
 272         }
 273     }
 274 }
 275
 276
 277 /* Install the pattern rule RULE (whose fields have been filled in)
 278    at the end of the list (so that any rules previously defined
 279    will take precedence).  If this rule duplicates a previous one
 280    (identical target and dependencies), the old one is replaced
 281    if OVERRIDE is nonzero, otherwise this new one is thrown out.
 282    When an old rule is replaced, the new one is put at the end of the
 283    list.  Return nonzero if RULE is used; zero if not.  */
 284
 285 int
 286 new_pattern_rule (rule, override)
 287      register struct rule *rule;
 288      int override;
 289 {
 290   register struct rule *r, *lastrule;
 291   register unsigned int i, j;
 292
 293   rule->in_use = 0;
 294   rule->terminal = 0;
 295
 296   rule->next = 0;
 297
 298   /* Search for an identical rule.  */
 299   lastrule = 0;
 300   for (r = pattern_rules; r != 0; lastrule = r, r = r->next)
 301     for (i = 0; rule->targets[i] != 0; ++i)
 302       {
 303         for (j = 0; r->targets[j] != 0; ++j)
 304           if (!streq (rule->targets[i], r->targets[j]))
 305             break;
 306         if (r->targets[j] == 0)
 307           /* All the targets matched.  */
 308           {
 309             register struct dep *d, *d2;
 310             for (d = rule->deps, d2 = r->deps;
 311                  d != 0 && d2 != 0; d = d->next, d2 = d2->next)
 312               if (!streq (dep_name (d), dep_name (d2)))
 313                 break;
 314             if (d == 0 && d2 == 0)
 315               /* All the dependencies matched.  */
 316               if (override)
 317                 {
 318                   /* Remove the old rule.  */
 319                   freerule (r, lastrule);
 320                   /* Install the new one.  */
 321                   if (pattern_rules == 0)
 322                     pattern_rules = rule;
 323                   else
 324                     last_pattern_rule->next = rule;
 325                   last_pattern_rule = rule;
 326
 327                   /* We got one.  Stop looking.  */
 328                   goto matched;
 329                 }
 330               else
 331                 {
 332                   /* The old rule stays intact.  Destroy the new one.  */
 333                   freerule (rule, (struct rule *) 0);
 334                   return 0;
 335                 }
 336           }
 337       }
 338
 339  matched:;
 340
 341   if (r == 0)
 342     {
 343       /* There was no rule to replace.  */
 344       if (pattern_rules == 0)
 345         pattern_rules = rule;
 346       else
 347         last_pattern_rule->next = rule;
 348       last_pattern_rule = rule;
 349     }
 350
 351   return 1;
 352 }
 353
 354
 355 /* Install an implicit pattern rule based on the three text strings
 356    in the structure P points to.  These strings come from one of
 357    the arrays of default implicit pattern rules.
 358    TERMINAL specifies what the `terminal' field of the rule should be.  */
 359
 360 void
 361 install_pattern_rule (p, terminal)
 362      struct pspec *p;
 363      int terminal;
 364 {
 365   register struct rule *r;
 366   char *ptr;
 367
 368   r = (struct rule *) xmalloc (sizeof (struct rule));
 369
 370   r->targets = (char **) xmalloc (2 * sizeof (char *));
 371   r->suffixes = (char **) xmalloc (2 * sizeof (char *));
 372   r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int));
 373
 374   r->targets[1] = 0;
 375   r->suffixes[1] = 0;
 376   r->lens[1] = 0;
 377
 378   r->lens[0] = strlen (p->target);
 379   /* These will all be string literals, but we malloc space for
 380      them anyway because somebody might want to free them later on.  */
 381   r->targets[0] = savestring (p->target, r->lens[0]);
 382   r->suffixes[0] = find_percent (r->targets[0]);
 383   if (r->suffixes[0] == 0)
 384     /* Programmer-out-to-lunch error.  */
 385     abort ();
 386   else
 387     ++r->suffixes[0];
 388
 389   ptr = p->dep;
 390   r->deps = (struct dep *) multi_glob (parse_file_seq (&ptr, '\0',
 391                                                        sizeof (struct dep), 1),
 392                                        sizeof (struct dep));
 393
 394   if (new_pattern_rule (r, 0))
 395     {
 396       r->terminal = terminal;
 397       r->cmds = (struct commands *) xmalloc (sizeof (struct commands));
 398       r->cmds->filename = 0;
 399       r->cmds->lineno = 0;
 400       /* These will all be string literals, but we malloc space for them
 401          anyway because somebody might want to free them later.  */
 402       r->cmds->commands = savestring (p->commands, strlen (p->commands));
 403       r->cmds->command_lines = 0;
 404     }
 405 }
 406
 407
 408 /* Free all the storage used in RULE and take it out of the
 409    pattern_rules chain.  LASTRULE is the rule whose next pointer
 410    points to RULE.  */
 411
 412 static void
 413 freerule (rule, lastrule)
 414      register struct rule *rule, *lastrule;
 415 {
 416   struct rule *next = rule->next;
 417   register unsigned int i;
 418
 419   for (i = 0; rule->targets[i] != 0; ++i)
 420     free (rule->targets[i]);
 421
 422   free ((char *) rule->targets);
 423   free ((char *) rule->suffixes);
 424   free ((char *) rule->lens);
 425
 426   /* We can't free the storage for the commands because there
 427      are ways that they could be in more than one place:
 428        * If the commands came from a suffix rule, they could also be in
 429        the `struct file's for other suffix rules or plain targets given
 430        on the same makefile line.
 431        * If two suffixes that together make a two-suffix rule were each
 432        given twice in the .SUFFIXES list, and in the proper order, two
 433        identical pattern rules would be created and the second one would
 434        be discarded here, but both would contain the same `struct commands'
 435        pointer from the `struct file' for the suffix rule.  */
 436
 437   free ((char *) rule);
 438
 439   if (pattern_rules == rule)
 440     if (lastrule != 0)
 441       abort ();
 442     else
 443       pattern_rules = next;
 444   else if (lastrule != 0)
 445     lastrule->next = next;
 446   if (last_pattern_rule == rule)
 447     last_pattern_rule = lastrule;
 448 }
 449 \f
 450 /* Create a new pattern rule with the targets in the nil-terminated
 451    array TARGETS.  If TARGET_PERCENTS is not nil, it is an array of
 452    pointers into the elements of TARGETS, where the `%'s are.
 453    The new rule has dependencies DEPS and commands from COMMANDS.
 454    It is a terminal rule if TERMINAL is nonzero.  This rule overrides
 455    identical rules with different commands if OVERRIDE is nonzero.
 456
 457    The storage for TARGETS and its elements is used and must not be freed
 458    until the rule is destroyed.  The storage for TARGET_PERCENTS is not used;
 459    it may be freed.  */
 460
 461 void
 462 create_pattern_rule (targets, target_percents,
 463                      terminal, deps, commands, override)
 464      char **targets, **target_percents;
 465      int terminal;
 466      struct dep *deps;
 467      struct commands *commands;
 468      int override;
 469 {
 470   register struct rule *r = (struct rule *) xmalloc (sizeof (struct rule));
 471   register unsigned int max_targets, i;
 472
 473   r->cmds = commands;
 474   r->deps = deps;
 475   r->targets = targets;
 476
 477   max_targets = 2;
 478   r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int));
 479   r->suffixes = (char **) xmalloc (2 * sizeof (char *));
 480   for (i = 0; targets[i] != 0; ++i)
 481     {
 482       if (i == max_targets - 1)
 483         {
 484           max_targets += 5;
 485           r->lens = (unsigned int *)
 486             xrealloc ((char *) r->lens, max_targets * sizeof (unsigned int));
 487           r->suffixes = (char **)
 488             xrealloc ((char *) r->suffixes, max_targets * sizeof (char *));
 489         }
 490       r->lens[i] = strlen (targets[i]);
 491       r->suffixes[i] = (target_percents == 0 ? find_percent (targets[i])
 492                         : target_percents[i]) + 1;
 493       if (r->suffixes[i] == 0)
 494         abort ();
 495     }
 496
 497   if (i < max_targets - 1)
 498     {
 499       r->lens = (unsigned int *) xrealloc ((char *) r->lens,
 500                                            (i + 1) * sizeof (unsigned int));
 501       r->suffixes = (char **) xrealloc ((char *) r->suffixes,
 502                                         (i + 1) * sizeof (char *));
 503     }
 504
 505   if (new_pattern_rule (r, override))
 506     r->terminal = terminal;
 507 }
 508 \f
 509 /* Print the data base of rules.  */
 510
 511 static void                     /* Useful to call from gdb.  */
 512 print_rule (r)
 513      struct rule *r;
 514 {
 515   register unsigned int i;
 516   register struct dep *d;
 517
 518   for (i = 0; r->targets[i] != 0; ++i)
 519     {
 520       fputs (r->targets[i], stdout);
 521       if (r->targets[i + 1] != 0)
 522         putchar (' ');
 523       else
 524         putchar (':');
 525     }
 526   if (r->terminal)
 527     putchar (':');
 528
 529   for (d = r->deps; d != 0; d = d->next)
 530     printf (" %s", dep_name (d));
 531   putchar ('\n');
 532
 533   if (r->cmds != 0)
 534     print_commands (r->cmds);
 535 }
 536
 537 void
 538 print_rule_data_base ()
 539 {
 540   register unsigned int rules, terminal;
 541   register struct rule *r;
 542
 543   puts ("\n# Implicit Rules");
 544
 545   rules = terminal = 0;
 546   for (r = pattern_rules; r != 0; r = r->next)
 547     {
 548       ++rules;
 549
 550       putchar ('\n');
 551       print_rule (r);
 552
 553       if (r->terminal)
 554         ++terminal;
 555     }
 556
 557   if (rules == 0)
 558     puts ("\n# No implicit rules.");
 559   else
 560     {
 561       printf ("\n# %u implicit rules, %u", rules, terminal);
 562 #ifndef NO_FLOAT
 563       printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0);
 564 #endif
 565       puts (" terminal.");
 566     }
 567
 568   if (num_pattern_rules != rules)
 569     fatal ("BUG: num_pattern_rules wrong!  %u != %u",
 570            num_pattern_rules, rules);
 571 }