file.c

   1 /* Target file hash table management for GNU Make.
   2 Copyright (C) 1988,89,90,91,92,93,94,95,96,97 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 <assert.h>
  21
  22 #include "make.h"
  23 #include "dep.h"
  24 #include "filedef.h"
  25 #include "job.h"
  26 #include "commands.h"
  27 #include "variable.h"
  28
  29
  30 /* Hash table of files the makefile knows how to make.  */
  31
  32 #ifndef FILE_BUCKETS
  33 #define FILE_BUCKETS    1007
  34 #endif
  35 static struct file *files[FILE_BUCKETS];
  36
  37 /* Number of files with the `intermediate' flag set.  */
  38
  39 unsigned int num_intermediates = 0;
  40
  41 /* Current value for pruning the scan of the goal chain (toggle 0/1).  */
  42
  43 unsigned int considered = 0;
  44
  45 /* Access the hash table of all file records.
  46    lookup_file  given a name, return the struct file * for that name,
  47            or nil if there is none.
  48    enter_file   similar, but create one if there is none.  */
  49
  50 struct file *
  51 lookup_file (name)
  52      char *name;
  53 {
  54   register struct file *f;
  55   register char *n;
  56   register unsigned int hashval;
  57 #ifdef VMS
  58   register char *lname, *ln;
  59 #endif
  60
  61   if (*name == '\0')
  62     abort ();
  63
  64   /* This is also done in parse_file_seq, so this is redundant
  65      for names read from makefiles.  It is here for names passed
  66      on the command line.  */
  67 #ifdef VMS
  68   lname = (char *)malloc(strlen(name) + 1);
  69   for (n=name, ln=lname; *n != '\0'; ++n, ++ln)
  70     *ln = isupper((unsigned char)*n) ? tolower((unsigned char)*n) : *n;
  71   *ln = '\0';
  72   name = lname;
  73
  74   while (name[0] == '[' && name[1] == ']' && name[2] != '\0')
  75       name += 2;
  76 #endif
  77   while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
  78     {
  79       name += 2;
  80       while (*name == '/')
  81         /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
  82         ++name;
  83     }
  84
  85   if (*name == '\0')
  86     /* It was all slashes after a dot.  */
  87 #ifdef VMS
  88     name = "[]";
  89 #else
  90 #ifdef _AMIGA
  91     name = "";
  92 #else
  93     name = "./";
  94 #endif /* AMIGA */
  95 #endif /* VMS */
  96
  97   hashval = 0;
  98   for (n = name; *n != '\0'; ++n)
  99     HASHI (hashval, *n);
 100   hashval %= FILE_BUCKETS;
 101
 102   for (f = files[hashval]; f != 0; f = f->next)
 103     {
 104       if (strieq (f->hname, name))
 105         {
 106 #ifdef VMS
 107           free (lname);
 108 #endif
 109           return f;
 110         }
 111     }
 112 #ifdef VMS
 113   free (lname);
 114 #endif
 115   return 0;
 116 }
 117
 118 struct file *
 119 enter_file (name)
 120      char *name;
 121 {
 122   register struct file *f, *new;
 123   register char *n;
 124   register unsigned int hashval;
 125 #ifdef VMS
 126   char *lname, *ln;
 127 #endif
 128
 129   if (*name == '\0')
 130     abort ();
 131
 132 #ifdef VMS
 133   lname = (char *)malloc (strlen (name) + 1);
 134   for (n = name, ln = lname; *n != '\0'; ++n, ++ln)
 135     {
 136       if (isupper((unsigned char)*n))
 137         *ln = tolower((unsigned char)*n);
 138       else
 139         *ln = *n;
 140     }
 141   *ln = 0;
 142   name = lname;
 143 #endif
 144
 145   hashval = 0;
 146   for (n = name; *n != '\0'; ++n)
 147     HASHI (hashval, *n);
 148   hashval %= FILE_BUCKETS;
 149
 150   for (f = files[hashval]; f != 0; f = f->next)
 151     if (strieq (f->hname, name))
 152       break;
 153
 154   if (f != 0 && !f->double_colon)
 155     {
 156 #ifdef VMS
 157       free(lname);
 158 #endif
 159       return f;
 160     }
 161
 162   new = (struct file *) xmalloc (sizeof (struct file));
 163   bzero ((char *) new, sizeof (struct file));
 164   new->name = new->hname = name;
 165   new->update_status = -1;
 166
 167   if (f == 0)
 168     {
 169       /* This is a completely new file.  */
 170       new->next = files[hashval];
 171       files[hashval] = new;
 172     }
 173   else
 174     {
 175       /* There is already a double-colon entry for this file.  */
 176       new->double_colon = f;
 177       while (f->prev != 0)
 178         f = f->prev;
 179       f->prev = new;
 180     }
 181
 182   return new;
 183 }
 184 \f
 185 /* Rehash FILE to NAME.  This is not as simple as resetting
 186    the `hname' member, since it must be put in a new hash bucket,
 187    and possibly merged with an existing file called NAME.  */
 188
 189 void
 190 rehash_file (file, name)
 191      register struct file *file;
 192      char *name;
 193 {
 194   char *oldname = file->hname;
 195   register unsigned int oldhash;
 196   register char *n;
 197
 198   while (file->renamed != 0)
 199     file = file->renamed;
 200
 201   /* Find the hash values of the old and new names.  */
 202
 203   oldhash = 0;
 204   for (n = oldname; *n != '\0'; ++n)
 205     HASHI (oldhash, *n);
 206
 207   file_hash_enter (file, name, oldhash, file->name);
 208 }
 209
 210 /* Rename FILE to NAME.  This is not as simple as resetting
 211    the `name' member, since it must be put in a new hash bucket,
 212    and possibly merged with an existing file called NAME.  */
 213
 214 void
 215 rename_file (file, name)
 216      register struct file *file;
 217      char *name;
 218 {
 219   rehash_file(file, name);
 220   while (file)
 221     {
 222       file->name = file->hname;
 223       file = file->prev;
 224     }
 225 }
 226
 227 void
 228 file_hash_enter (file, name, oldhash, oldname)
 229      register struct file *file;
 230      char *name;
 231      unsigned int oldhash;
 232      char *oldname;
 233 {
 234   unsigned int oldbucket = oldhash % FILE_BUCKETS;
 235   register unsigned int newhash, newbucket;
 236   struct file *oldfile;
 237   register char *n;
 238   register struct file *f;
 239
 240   newhash = 0;
 241   for (n = name; *n != '\0'; ++n)
 242     HASHI (newhash, *n);
 243   newbucket = newhash % FILE_BUCKETS;
 244
 245   /* Look for an existing file under the new name.  */
 246
 247   for (oldfile = files[newbucket]; oldfile != 0; oldfile = oldfile->next)
 248     if (strieq (oldfile->hname, name))
 249       break;
 250
 251   /* If the old file is the same as the new file, something's wrong.  */
 252   assert (oldfile != file);
 253
 254   if (oldhash != 0 && (newbucket != oldbucket || oldfile != 0))
 255     {
 256       /* Remove FILE from its hash bucket.  */
 257
 258       struct file *lastf = 0;
 259
 260       for (f = files[oldbucket]; f != file; f = f->next)
 261         lastf = f;
 262
 263       if (lastf == 0)
 264         files[oldbucket] = f->next;
 265       else
 266         lastf->next = f->next;
 267     }
 268
 269   /* Give FILE its new name.  */
 270
 271   file->hname = name;
 272   for (f = file->double_colon; f != 0; f = f->prev)
 273     f->hname = name;
 274
 275   if (oldfile == 0)
 276     {
 277       /* There is no existing file with the new name.  */
 278
 279       if (newbucket != oldbucket)
 280         {
 281           /* Put FILE in its new hash bucket.  */
 282           file->next = files[newbucket];
 283           files[newbucket] = file;
 284         }
 285     }
 286   else
 287     {
 288       /* There is an existing file with the new name.
 289          We must merge FILE into the existing file.  */
 290
 291       register struct dep *d;
 292
 293       if (file->cmds != 0)
 294         {
 295           if (oldfile->cmds == 0)
 296             oldfile->cmds = file->cmds;
 297           else if (file->cmds != oldfile->cmds)
 298             {
 299               /* We have two sets of commands.  We will go with the
 300                  one given in the rule explicitly mentioning this name,
 301                  but give a message to let the user know what's going on.  */
 302               if (oldfile->cmds->fileinfo.filenm != 0)
 303                 error (&file->cmds->fileinfo,
 304                                 _("Commands were specified for \
 305 file `%s' at %s:%lu,"),
 306                                 oldname, oldfile->cmds->fileinfo.filenm,
 307                                 oldfile->cmds->fileinfo.lineno);
 308               else
 309                 error (&file->cmds->fileinfo,
 310                                 _("Commands for file `%s' were found by \
 311 implicit rule search,"),
 312                                 oldname);
 313               error (&file->cmds->fileinfo,
 314                               _("but `%s' is now considered the same file \
 315 as `%s'."),
 316                               oldname, name);
 317               error (&file->cmds->fileinfo,
 318                               _("Commands for `%s' will be ignored \
 319 in favor of those for `%s'."),
 320                               name, oldname);
 321             }
 322         }
 323
 324       /* Merge the dependencies of the two files.  */
 325
 326       d = oldfile->deps;
 327       if (d == 0)
 328         oldfile->deps = file->deps;
 329       else
 330         {
 331           while (d->next != 0)
 332             d = d->next;
 333           d->next = file->deps;
 334         }
 335
 336       merge_variable_set_lists (&oldfile->variables, file->variables);
 337
 338       if (oldfile->double_colon && file->is_target && !file->double_colon)
 339         fatal (NILF, _("can't rename single-colon `%s' to double-colon `%s'"),
 340                oldname, name);
 341       if (!oldfile->double_colon  && file->double_colon)
 342         {
 343           if (oldfile->is_target)
 344             fatal (NILF, _("can't rename double-colon `%s' to single-colon `%s'"),
 345                    oldname, name);
 346           else
 347             oldfile->double_colon = file->double_colon;
 348         }
 349
 350       if (file->last_mtime > oldfile->last_mtime)
 351         /* %%% Kludge so -W wins on a file that gets vpathized.  */
 352         oldfile->last_mtime = file->last_mtime;
 353
 354       oldfile->mtime_before_update = file->mtime_before_update;
 355
 356 #define MERGE(field) oldfile->field |= file->field
 357       MERGE (precious);
 358       MERGE (tried_implicit);
 359       MERGE (updating);
 360       MERGE (updated);
 361       MERGE (is_target);
 362       MERGE (cmd_target);
 363       MERGE (phony);
 364       MERGE (ignore_vpath);
 365 #undef MERGE
 366
 367       file->renamed = oldfile;
 368     }
 369 }
 370 \f
 371 /* Remove all nonprecious intermediate files.
 372    If SIG is nonzero, this was caused by a fatal signal,
 373    meaning that a different message will be printed, and
 374    the message will go to stderr rather than stdout.  */
 375
 376 void
 377 remove_intermediates (sig)
 378      int sig;
 379 {
 380   register int i;
 381   register struct file *f;
 382   char doneany;
 383
 384   if (question_flag || touch_flag)
 385     return;
 386   if (sig && just_print_flag)
 387     return;
 388
 389   doneany = 0;
 390   for (i = 0; i < FILE_BUCKETS; ++i)
 391     for (f = files[i]; f != 0; f = f->next)
 392       if (f->intermediate && (f->dontcare || !f->precious)
 393           && !f->secondary)
 394         {
 395           int status;
 396           if (f->update_status == -1)
 397             /* If nothing would have created this file yet,
 398                don't print an "rm" command for it.  */
 399             continue;
 400           else if (just_print_flag)
 401             status = 0;
 402           else
 403             {
 404               status = unlink (f->name);
 405               if (status < 0 && errno == ENOENT)
 406                 continue;
 407             }
 408           if (!f->dontcare)
 409             {
 410               if (sig)
 411                 error (NILF, _("*** Deleting intermediate file `%s'"), f->name);
 412               else if (!silent_flag)
 413                 {
 414                   if (! doneany)
 415                     {
 416                       fputs ("rm ", stdout);
 417                       doneany = 1;
 418                     }
 419                   else
 420                     putchar (' ');
 421                   fputs (f->name, stdout);
 422                   fflush (stdout);
 423                 }
 424               if (status < 0)
 425                 perror_with_name ("unlink: ", f->name);
 426             }
 427         }
 428
 429   if (doneany && !sig)
 430     {
 431       putchar ('\n');
 432       fflush (stdout);
 433     }
 434 }
 435 \f
 436 /* For each dependency of each file, make the `struct dep' point
 437    at the appropriate `struct file' (which may have to be created).
 438
 439    Also mark the files depended on by .PRECIOUS, .PHONY, .SILENT,
 440    and various other special targets.  */
 441
 442 void
 443 snap_deps ()
 444 {
 445   register struct file *f, *f2;
 446   register struct dep *d;
 447   register int i;
 448
 449   /* Enter each dependency name as a file.  */
 450   for (i = 0; i < FILE_BUCKETS; ++i)
 451     for (f = files[i]; f != 0; f = f->next)
 452       for (f2 = f; f2 != 0; f2 = f2->prev)
 453         for (d = f2->deps; d != 0; d = d->next)
 454           if (d->name != 0)
 455             {
 456               d->file = lookup_file (d->name);
 457               if (d->file == 0)
 458                 d->file = enter_file (d->name);
 459               else
 460                 free (d->name);
 461               d->name = 0;
 462             }
 463
 464   for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev)
 465     for (d = f->deps; d != 0; d = d->next)
 466       for (f2 = d->file; f2 != 0; f2 = f2->prev)
 467         f2->precious = 1;
 468
 469   for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
 470     for (d = f->deps; d != 0; d = d->next)
 471       for (f2 = d->file; f2 != 0; f2 = f2->prev)
 472         {
 473           /* Mark this file as phony and nonexistent.  */
 474           f2->phony = 1;
 475           f2->last_mtime = (FILE_TIMESTAMP) -1;
 476           f2->mtime_before_update = (FILE_TIMESTAMP) -1;
 477         }
 478
 479   for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev)
 480     {
 481       /* .INTERMEDIATE with deps listed
 482          marks those deps as intermediate files.  */
 483       for (d = f->deps; d != 0; d = d->next)
 484         for (f2 = d->file; f2 != 0; f2 = f2->prev)
 485           f2->intermediate = 1;
 486       /* .INTERMEDIATE with no deps does nothing.
 487          Marking all files as intermediates is useless
 488          since the goal targets would be deleted after they are built.  */
 489     }
 490
 491   for (f = lookup_file (".SECONDARY"); f != 0; f = f->prev)
 492     {
 493       /* .SECONDARY with deps listed
 494          marks those deps as intermediate files
 495          in that they don't get rebuilt if not actually needed;
 496          but unlike real intermediate files,
 497          these are not deleted after make finishes.  */
 498       if (f->deps)
 499         {
 500           for (d = f->deps; d != 0; d = d->next)
 501             for (f2 = d->file; f2 != 0; f2 = f2->prev)
 502               f2->intermediate = f2->secondary = 1;
 503         }
 504       /* .SECONDARY with no deps listed marks *all* files that way.  */
 505       else
 506         {
 507           int i;
 508           for (i = 0; i < FILE_BUCKETS; i++)
 509             for (f2 = files[i]; f2; f2= f2->next)
 510               f2->intermediate = f2->secondary = 1;
 511         }
 512     }
 513
 514   f = lookup_file (".EXPORT_ALL_VARIABLES");
 515   if (f != 0 && f->is_target)
 516     export_all_variables = 1;
 517
 518   f = lookup_file (".IGNORE");
 519   if (f != 0 && f->is_target)
 520     {
 521       if (f->deps == 0)
 522         ignore_errors_flag = 1;
 523       else
 524         for (d = f->deps; d != 0; d = d->next)
 525           for (f2 = d->file; f2 != 0; f2 = f2->prev)
 526             f2->command_flags |= COMMANDS_NOERROR;
 527     }
 528
 529   f = lookup_file (".SILENT");
 530   if (f != 0 && f->is_target)
 531     {
 532       if (f->deps == 0)
 533         silent_flag = 1;
 534       else
 535         for (d = f->deps; d != 0; d = d->next)
 536           for (f2 = d->file; f2 != 0; f2 = f2->prev)
 537             f2->command_flags |= COMMANDS_SILENT;
 538     }
 539
 540   f = lookup_file (".POSIX");
 541   if (f != 0 && f->is_target)
 542     posix_pedantic = 1;
 543
 544   f = lookup_file (".NOTPARALLEL");
 545   if (f != 0 && f->is_target)
 546     not_parallel = 1;
 547 }
 548 \f
 549 /* Set the `command_state' member of FILE and all its `also_make's.  */
 550
 551 void
 552 set_command_state (file, state)
 553      struct file *file;
 554      int state;
 555 {
 556   struct dep *d;
 557
 558   file->command_state = state;
 559
 560   for (d = file->also_make; d != 0; d = d->next)
 561     d->file->command_state = state;
 562 }
 563 \f
 564 /* Get and print file timestamps.  */
 565
 566 FILE_TIMESTAMP
 567 file_timestamp_now ()
 568 {
 569 #if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
 570   struct timespec timespec;
 571   if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
 572     return FILE_TIMESTAMP_FROM_S_AND_NS (timespec.tv_sec, timespec.tv_nsec);
 573 #endif
 574   return FILE_TIMESTAMP_FROM_S_AND_NS (time ((time_t *) 0), 0);
 575 }
 576
 577 void
 578 file_timestamp_sprintf (p, ts)
 579      char *p;
 580      FILE_TIMESTAMP ts;
 581 {
 582   time_t t = FILE_TIMESTAMP_S (ts);
 583   struct tm *tm = localtime (&t);
 584
 585   if (tm)
 586     sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d",
 587              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 588              tm->tm_hour, tm->tm_min, tm->tm_sec);
 589   else if (t < 0)
 590     sprintf (p, "%ld", (long) t);
 591   else
 592     sprintf (p, "%lu", (unsigned long) t);
 593   p += strlen (p);
 594
 595   /* Append nanoseconds as a fraction, but remove trailing zeros.
 596      We don't know the actual timestamp resolution, since clock_getres
 597      applies only to local times, whereas this timestamp might come
 598      from a remote filesystem.  So removing trailing zeros is the
 599      best guess that we can do.  */
 600   sprintf (p, ".%09ld", (long) FILE_TIMESTAMP_NS (ts));
 601   p += strlen (p) - 1;
 602   while (*p == '0')
 603     p--;
 604   p += *p != '.';
 605
 606   *p = '\0';
 607 }
 608 \f
 609 /* Print the data base of files.  */
 610
 611 static void
 612 print_file (f)
 613      struct file *f;
 614 {
 615   register struct dep *d;
 616
 617   putchar ('\n');
 618   if (!f->is_target)
 619     puts (_("# Not a target:"));
 620   printf ("%s:%s", f->name, f->double_colon ? ":" : "");
 621
 622   for (d = f->deps; d != 0; d = d->next)
 623     printf (" %s", dep_name (d));
 624   putchar ('\n');
 625
 626   if (f->precious)
 627     puts (_("#  Precious file (prerequisite of .PRECIOUS)."));
 628   if (f->phony)
 629     puts (_("#  Phony target (prerequisite of .PHONY)."));
 630   if (f->cmd_target)
 631     puts (_("#  Command-line target."));
 632   if (f->dontcare)
 633     puts (_("#  A default or MAKEFILES makefile."));
 634   printf (_("#  Implicit rule search has%s been done.\n"),
 635           f->tried_implicit ? "" : _(" not"));
 636   if (f->stem != 0)
 637     printf (_("#  Implicit/static pattern stem: `%s'\n"), f->stem);
 638   if (f->intermediate)
 639     puts (_("#  File is an intermediate prerequisite."));
 640   if (f->also_make != 0)
 641     {
 642       fputs (_("#  Also makes:"), stdout);
 643       for (d = f->also_make; d != 0; d = d->next)
 644         printf (" %s", dep_name (d));
 645       putchar ('\n');
 646     }
 647   if (f->last_mtime == 0)
 648     puts (_("#  Modification time never checked."));
 649   else if (f->last_mtime == (FILE_TIMESTAMP) -1)
 650     puts (_("#  File does not exist."));
 651   else
 652     {
 653       char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
 654       file_timestamp_sprintf (buf, f->last_mtime);
 655       printf (_("#  Last modified %s\n"), buf);
 656     }
 657   puts (f->updated
 658         ? _("#  File has been updated.") : _("#  File has not been updated."));
 659   switch (f->command_state)
 660     {
 661     case cs_running:
 662       puts (_("#  Commands currently running (THIS IS A BUG)."));
 663       break;
 664     case cs_deps_running:
 665       puts (_("#  Dependencies commands running (THIS IS A BUG)."));
 666       break;
 667     case cs_not_started:
 668     case cs_finished:
 669       switch (f->update_status)
 670         {
 671         case -1:
 672           break;
 673         case 0:
 674           puts (_("#  Successfully updated."));
 675           break;
 676         case 1:
 677           assert (question_flag);
 678           puts (_("#  Needs to be updated (-q is set)."));
 679           break;
 680         case 2:
 681           puts (_("#  Failed to be updated."));
 682           break;
 683         default:
 684           puts (_("#  Invalid value in `update_status' member!"));
 685           fflush (stdout);
 686           fflush (stderr);
 687           abort ();
 688         }
 689       break;
 690     default:
 691       puts (_("#  Invalid value in `command_state' member!"));
 692       fflush (stdout);
 693       fflush (stderr);
 694       abort ();
 695     }
 696
 697   if (f->variables != 0)
 698     print_file_variables (f);
 699
 700   if (f->cmds != 0)
 701     print_commands (f->cmds);
 702 }
 703
 704 void
 705 print_file_data_base ()
 706 {
 707   register unsigned int i, nfiles, per_bucket;
 708   register struct file *file;
 709
 710   puts (_("\n# Files"));
 711
 712   per_bucket = nfiles = 0;
 713   for (i = 0; i < FILE_BUCKETS; ++i)
 714     {
 715       register unsigned int this_bucket = 0;
 716
 717       for (file = files[i]; file != 0; file = file->next)
 718         {
 719           register struct file *f;
 720
 721           ++this_bucket;
 722
 723           for (f = file; f != 0; f = f->prev)
 724             print_file (f);
 725         }
 726
 727       nfiles += this_bucket;
 728       if (this_bucket > per_bucket)
 729         per_bucket = this_bucket;
 730     }
 731
 732   if (nfiles == 0)
 733     puts (_("\n# No files."));
 734   else
 735     {
 736       printf (_("\n# %u files in %u hash buckets.\n"), nfiles, FILE_BUCKETS);
 737 #ifndef NO_FLOAT
 738       printf (_("# average %.3f files per bucket, max %u files in one bucket.\n"),
 739               ((double) nfiles) / ((double) FILE_BUCKETS), per_bucket);
 740 #endif
 741     }
 742 }
 743
 744 /* EOF */