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