aclocal.in

   1 #!@PERL@ -w
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval 'case $# in 0) exec @PERL@ -S "$0";; *) exec @PERL@ -S "$0" "$@";; esac'
   6     if 0;
   7
   8 # aclocal - create aclocal.m4 by scanning configure.ac
   9
  10 # Copyright (C) 1996-2012 Free Software Foundation, Inc.
  11
  12 # This program is free software; you can redistribute it and/or modify
  13 # it under the terms of the GNU General Public License as published by
  14 # the Free Software Foundation; either version 2, or (at your option)
  15 # any later version.
  16
  17 # This program is distributed in the hope that it will be useful,
  18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 # GNU General Public License for more details.
  21
  22 # You should have received a copy of the GNU General Public License
  23 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 # Written by Tom Tromey <tromey@redhat.com>, and
  26 # Alexandre Duret-Lutz <adl@gnu.org>.
  27
  28 BEGIN
  29 {
  30   my $perllibdir = $ENV{'perllibdir'} || '@datadir@/@PACKAGE@-@APIVERSION@';
  31   unshift @INC, (split '@PATH_SEPARATOR@', $perllibdir);
  32 }
  33
  34 use strict;
  35
  36 use Automake::Config;
  37 use Automake::General;
  38 use Automake::Configure_ac;
  39 use Automake::Channels;
  40 use Automake::ChannelDefs;
  41 use Automake::XFile;
  42 use Automake::FileUtils;
  43 use File::Basename;
  44 use File::Path ();
  45
  46 # Some globals.
  47
  48 # We do not operate in threaded mode.
  49 $perl_threads = 0;
  50
  51 # Include paths for searching macros.  We search macros in this order:
  52 # user-supplied directories first, then the directory containing the
  53 # automake macros, and finally the system-wide directories for
  54 # third-party macros.
  55 # @user_includes can be augmented with -I.
  56 # @automake_includes can be reset with the '--automake-acdir' option.
  57 # @system_includes can be augmented with the 'dirlist' file or the
  58 # ACLOCAL_PATH environment variable, and reset with the '--system-acdir'
  59 # option.
  60 my @user_includes = ();
  61 my @automake_includes = ("@datadir@/aclocal-$APIVERSION");
  62 my @system_includes = ('@datadir@/aclocal');
  63
  64 # Whether we should copy M4 file in $user_includes[0].
  65 my $install = 0;
  66
  67 # --diff
  68 my @diff_command;
  69
  70 # --dry-run
  71 my $dry_run = 0;
  72
  73 # configure.ac or configure.in.
  74 my $configure_ac;
  75
  76 # Output file name.
  77 my $output_file = 'aclocal.m4';
  78
  79 # Option --force.
  80 my $force_output = 0;
  81
  82 # Modification time of the youngest dependency.
  83 my $greatest_mtime = 0;
  84
  85 # Which macros have been seen.
  86 my %macro_seen = ();
  87
  88 # Remember the order into which we scanned the files.
  89 # It's important to output the contents of aclocal.m4 in the opposite order.
  90 # (Definitions in first files we have scanned should override those from
  91 # later files.  So they must appear last in the output.)
  92 my @file_order = ();
  93
  94 # Map macro names to file names.
  95 my %map = ();
  96
  97 # Ditto, but records the last definition of each macro as returned by --trace.
  98 my %map_traced_defs = ();
  99
 100 # Map basenames to macro names.
 101 my %invmap = ();
 102
 103 # Map file names to file contents.
 104 my %file_contents = ();
 105
 106 # Map file names to file types.
 107 my %file_type = ();
 108 use constant FT_USER => 1;
 109 use constant FT_AUTOMAKE => 2;
 110 use constant FT_SYSTEM => 3;
 111
 112 # Map file names to included files (transitively closed).
 113 my %file_includes = ();
 114
 115 # Files which have already been added.
 116 my %file_added = ();
 117
 118 # Files that have already been scanned.
 119 my %scanned_configure_dep = ();
 120
 121 # Serial numbers, for files that have one.
 122 # The key is the basename of the file,
 123 # the value is the serial number represented as a list.
 124 my %serial = ();
 125
 126 # Matches a macro definition.
 127 #   AC_DEFUN([macroname], ...)
 128 # or
 129 #   AC_DEFUN(macroname, ...)
 130 # When macroname is '['-quoted , we accept any character in the name,
 131 # except ']'.  Otherwise macroname stops on the first ']', ',', ')',
 132 # or '\n' encountered.
 133 my $ac_defun_rx =
 134   "(?:AU_ALIAS|A[CU]_DEFUN|AC_DEFUN_ONCE)\\((?:\\[([^]]+)\\]|([^],)\n]+))";
 135
 136 # Matches an AC_REQUIRE line.
 137 my $ac_require_rx = "AC_REQUIRE\\((?:\\[([^]]+)\\]|([^],)\n]+))\\)";
 138
 139 # Matches an m4_include line.
 140 my $m4_include_rx = "(m4_|m4_s|s)include\\((?:\\[([^]]+)\\]|([^],)\n]+))\\)";
 141
 142 # Match a serial number.
 143 my $serial_line_rx = '^#\s*serial\s+(\S*)';
 144 my $serial_number_rx = '^\d+(?:\.\d+)*$';
 145
 146 # Autoconf version
 147 # Set by trace_used_macros.
 148 my $ac_version;
 149
 150 # If set, names a temporary file that must be erased on abnormal exit.
 151 my $erase_me;
 152
 153 ################################################################
 154
 155 # Erase temporary file ERASE_ME.  Handle signals.
 156 sub unlink_tmp
 157 {
 158   my ($sig) = @_;
 159
 160   if ($sig)
 161     {
 162       verb "caught SIG$sig, bailing out";
 163     }
 164   if (defined $erase_me && -e $erase_me && !unlink ($erase_me))
 165     {
 166       fatal "could not remove '$erase_me': $!";
 167     }
 168   undef $erase_me;
 169
 170   # reraise default handler.
 171   if ($sig)
 172     {
 173       $SIG{$sig} = 'DEFAULT';
 174       kill $sig => $$;
 175     }
 176 }
 177
 178 $SIG{'INT'} = $SIG{'TERM'} = $SIG{'QUIT'} = $SIG{'HUP'} = 'unlink_tmp';
 179 END { unlink_tmp }
 180
 181 sub xmkdir_p ($)
 182 {
 183   my $dir = shift;
 184   local $@ = undef;
 185   return
 186     if -d $dir or eval { File::Path::mkpath $dir };
 187   chomp $@;
 188   $@ =~ s/\s+at\s.*\bline\s\d+.*$//;
 189   fatal "could not create directory '$dir': $@";
 190 }
 191
 192 # Check macros in acinclude.m4.  If one is not used, warn.
 193 sub check_acinclude ()
 194 {
 195   foreach my $key (keys %map)
 196     {
 197       # FIXME: should print line number of acinclude.m4.
 198       msg ('syntax', "macro '$key' defined in acinclude.m4 but never used")
 199         if $map{$key} eq 'acinclude.m4' && ! exists $macro_seen{$key};
 200     }
 201 }
 202
 203 sub reset_maps ()
 204 {
 205   $greatest_mtime = 0;
 206   %macro_seen = ();
 207   @file_order = ();
 208   %map = ();
 209   %map_traced_defs = ();
 210   %file_contents = ();
 211   %file_type = ();
 212   %file_includes = ();
 213   %file_added = ();
 214   %scanned_configure_dep = ();
 215   %invmap = ();
 216   %serial = ();
 217   undef &search;
 218 }
 219
 220 # install_file ($SRC, $DESTDIR)
 221 sub install_file ($$)
 222 {
 223   my ($src, $destdir) = @_;
 224   my $dest = $destdir . "/" . basename ($src);
 225   my $diff_dest;
 226
 227   verb "installing $src to $dest";
 228
 229   if ($force_output
 230       || !exists $file_contents{$dest}
 231       || $file_contents{$src} ne $file_contents{$dest})
 232     {
 233       if (-e $dest)
 234         {
 235           msg 'note', "overwriting '$dest' with '$src'";
 236           $diff_dest = $dest;
 237         }
 238       else
 239         {
 240           msg 'note', "installing '$dest' from '$src'";
 241         }
 242
 243       if (@diff_command)
 244         {
 245           if (! defined $diff_dest)
 246             {
 247               # $dest does not exist.  We create an empty one just to
 248               # run diff, and we erase it afterward.  Using the real
 249               # the destination file (rather than a temporary file) is
 250               # good when diff is run with options that display the
 251               # file name.
 252               #
 253               # If creating $dest fails, fall back to /dev/null.  At
 254               # least one diff implementation (Tru64's) cannot deal
 255               # with /dev/null.  However working around this is not
 256               # worth the trouble since nobody run aclocal on a
 257               # read-only tree anyway.
 258               $erase_me = $dest;
 259               my $f = new IO::File "> $dest";
 260               if (! defined $f)
 261                 {
 262                   undef $erase_me;
 263                   $diff_dest = '/dev/null';
 264                 }
 265               else
 266                 {
 267                   $diff_dest = $dest;
 268                   $f->close;
 269                 }
 270             }
 271           my @cmd = (@diff_command, $diff_dest, $src);
 272           $! = 0;
 273           verb "running: @cmd";
 274           my $res = system (@cmd);
 275           Automake::FileUtils::handle_exec_errors "@cmd", 1
 276             if $res;
 277           unlink_tmp;
 278         }
 279       elsif (!$dry_run)
 280         {
 281           xmkdir_p ($destdir);
 282           xsystem ('cp', $src, $dest);
 283         }
 284     }
 285 }
 286
 287 # Compare two lists of numbers.
 288 sub list_compare (\@\@)
 289 {
 290   my @l = @{$_[0]};
 291   my @r = @{$_[1]};
 292   while (1)
 293     {
 294       if (0 == @l)
 295         {
 296           return (0 == @r) ? 0 : -1;
 297         }
 298       elsif (0 == @r)
 299         {
 300           return 1;
 301         }
 302       elsif ($l[0] < $r[0])
 303         {
 304           return -1;
 305         }
 306       elsif ($l[0] > $r[0])
 307         {
 308           return 1;
 309         }
 310       shift @l;
 311       shift @r;
 312     }
 313 }
 314
 315 ################################################################
 316
 317 # scan_m4_dirs($TYPE, @DIRS)
 318 # --------------------------
 319 # Scan all M4 files installed in @DIRS for new macro definitions.
 320 # Register each file as of type $TYPE (one of the FT_* constants).
 321 my $first_user_m4dir = 1;
 322 sub scan_m4_dirs ($@)
 323 {
 324   my ($type, @dirlist) = @_;
 325
 326   foreach my $m4dir (@dirlist)
 327     {
 328       if (! opendir (DIR, $m4dir))
 329         {
 330           if ($install && $type == FT_USER && $first_user_m4dir)
 331             {
 332               # We will try to create this directory later, so don't
 333               # complain if it doesn't exist.
 334               # TODO: maybe we should avoid complaining only if errno
 335               # is ENONENT?
 336               $first_user_m4dir = 0;
 337               next;
 338             }
 339           fatal "couldn't open directory '$m4dir': $!";
 340         }
 341
 342       # We reverse the directory contents so that foo2.m4 gets
 343       # used in preference to foo1.m4.
 344       foreach my $file (reverse sort grep (! /^\./, readdir (DIR)))
 345         {
 346           # Only examine .m4 files.
 347           next unless $file =~ /\.m4$/;
 348
 349           # Skip some files when running out of srcdir.
 350           next if $file eq 'aclocal.m4';
 351
 352           my $fullfile = File::Spec->canonpath ("$m4dir/$file");
 353             &scan_file ($type, $fullfile, 'aclocal');
 354         }
 355       closedir (DIR);
 356     }
 357 }
 358
 359 # Scan all the installed m4 files and construct a map.
 360 sub scan_m4_files ()
 361 {
 362   # First, scan configure.ac.  It may contain macro definitions,
 363   # or may include other files that define macros.
 364   &scan_file (FT_USER, $configure_ac, 'aclocal');
 365
 366   # Then, scan acinclude.m4 if it exists.
 367   if (-f 'acinclude.m4')
 368     {
 369       &scan_file (FT_USER, 'acinclude.m4', 'aclocal');
 370     }
 371
 372   # Finally, scan all files in our search paths.
 373   scan_m4_dirs (FT_USER, @user_includes);
 374   scan_m4_dirs (FT_AUTOMAKE, @automake_includes);
 375   scan_m4_dirs (FT_SYSTEM, @system_includes);
 376
 377   # Construct a new function that does the searching.  We use a
 378   # function (instead of just evaluating $search in the loop) so that
 379   # "die" is correctly and easily propagated if run.
 380   my $search = "sub search {\nmy \$found = 0;\n";
 381   foreach my $key (reverse sort keys %map)
 382     {
 383       $search .= ('if (/\b\Q' . $key . '\E(?!\w)/) { & add_macro ("' . $key
 384                   . '"); $found = 1; }' . "\n");
 385     }
 386   $search .= "return \$found;\n};\n";
 387   eval $search;
 388   prog_error "$@\n search is $search" if $@;
 389 }
 390
 391 ################################################################
 392
 393 # Add a macro to the output.
 394 sub add_macro ($)
 395 {
 396   my ($macro) = @_;
 397
 398   # Ignore unknown required macros.  Either they are not really
 399   # needed (e.g., a conditional AC_REQUIRE), in which case aclocal
 400   # should be quiet, or they are needed and Autoconf itself will
 401   # complain when we trace for macro usage later.
 402   return unless defined $map{$macro};
 403
 404   verb "saw macro $macro";
 405   $macro_seen{$macro} = 1;
 406   &add_file ($map{$macro});
 407 }
 408
 409 # scan_configure_dep ($file)
 410 # --------------------------
 411 # Scan a configure dependency (configure.ac, or separate m4 files)
 412 # for uses of known macros and AC_REQUIREs of possibly unknown macros.
 413 # Recursively scan m4_included files.
 414 sub scan_configure_dep ($)
 415 {
 416   my ($file) = @_;
 417   # Do not scan a file twice.
 418   return ()
 419     if exists $scanned_configure_dep{$file};
 420   $scanned_configure_dep{$file} = 1;
 421
 422   my $mtime = mtime $file;
 423   $greatest_mtime = $mtime if $greatest_mtime < $mtime;
 424
 425   my $contents = exists $file_contents{$file} ?
 426     $file_contents{$file} : contents $file;
 427
 428   my $line = 0;
 429   my @rlist = ();
 430   my @ilist = ();
 431   foreach (split ("\n", $contents))
 432     {
 433       ++$line;
 434       # Remove comments from current line.
 435       s/\bdnl\b.*$//;
 436       s/\#.*$//;
 437       # Avoid running all the following regexes on white lines.
 438       next if /^\s*$/;
 439
 440       while (/$m4_include_rx/go)
 441         {
 442           my $ifile = $2 || $3;
 443           # Skip missing 'sinclude'd files.
 444           next if $1 ne 'm4_' && ! -f $ifile;
 445           push @ilist, $ifile;
 446         }
 447
 448       while (/$ac_require_rx/go)
 449         {
 450           push (@rlist, $1 || $2);
 451         }
 452
 453       # The search function is constructed dynamically by
 454       # scan_m4_files.  The last parenthetical match makes sure we
 455       # don't match things that look like macro assignments or
 456       # AC_SUBSTs.
 457       if (! &search && /(^|\s+)(AM_[A-Z0-9_]+)($|[^\]\)=A-Z0-9_])/)
 458         {
 459           # Macro not found, but AM_ prefix found.
 460           # Make this just a warning, because we do not know whether
 461           # the macro is actually used (it could be called conditionally).
 462           msg ('unsupported', "$file:$line",
 463                "macro '$2' not found in library");
 464         }
 465     }
 466
 467   add_macro ($_) foreach (@rlist);
 468   &scan_configure_dep ($_) foreach @ilist;
 469 }
 470
 471 # add_file ($FILE)
 472 # ----------------
 473 # Add $FILE to output.
 474 sub add_file ($)
 475 {
 476   my ($file) = @_;
 477
 478   # Only add a file once.
 479   return if ($file_added{$file});
 480   $file_added{$file} = 1;
 481
 482   scan_configure_dep $file;
 483 }
 484
 485 # Point to the documentation for underquoted AC_DEFUN only once.
 486 my $underquoted_manual_once = 0;
 487
 488 # scan_file ($TYPE, $FILE, $WHERE)
 489 # --------------------------------
 490 # Scan a single M4 file ($FILE), and all files it includes.
 491 # Return the list of included files.
 492 # $TYPE is one of FT_USER, FT_AUTOMAKE, or FT_SYSTEM, depending
 493 # on where the file comes from.
 494 # $WHERE is the location to use in the diagnostic if the file
 495 # does not exist.
 496 sub scan_file ($$$)
 497 {
 498   my ($type, $file, $where) = @_;
 499   my $basename = basename $file;
 500
 501   # Do not scan the same file twice.
 502   return @{$file_includes{$file}} if exists $file_includes{$file};
 503   # Prevent potential infinite recursion (if two files include each other).
 504   return () if exists $file_contents{$file};
 505
 506   unshift @file_order, $file;
 507
 508   $file_type{$file} = $type;
 509
 510   fatal "$where: file '$file' does not exist" if ! -e $file;
 511
 512   my $fh = new Automake::XFile $file;
 513   my $contents = '';
 514   my @inc_files = ();
 515   my %inc_lines = ();
 516
 517   my $defun_seen = 0;
 518   my $serial_seen = 0;
 519   my $serial_older = 0;
 520
 521   while ($_ = $fh->getline)
 522     {
 523       # Ignore '##' lines.
 524       next if /^##/;
 525
 526       $contents .= $_;
 527       my $line = $_;
 528
 529       if ($line =~ /$serial_line_rx/go)
 530         {
 531           my $number = $1;
 532           if ($number !~ /$serial_number_rx/go)
 533             {
 534               msg ('syntax', "$file:$.",
 535                    "ill-formed serial number '$number', "
 536                    . "expecting a version string with only digits and dots");
 537             }
 538           elsif ($defun_seen)
 539             {
 540               # aclocal removes all definitions from M4 file with the
 541               # same basename if a greater serial number is found.
 542               # Encountering a serial after some macros will undefine
 543               # these macros...
 544               msg ('syntax', "$file:$.",
 545                    'the serial number must appear before any macro definition');
 546             }
 547           # We really care about serials only for non-automake macros
 548           # and when --install is used.  But the above diagnostics are
 549           # made regardless of this, because not using --install is
 550           # not a reason not the fix macro files.
 551           elsif ($install && $type != FT_AUTOMAKE)
 552             {
 553               $serial_seen = 1;
 554               my @new = split (/\./, $number);
 555
 556               verb "$file:$.: serial $number";
 557
 558               if (!exists $serial{$basename}
 559                   || list_compare (@new, @{$serial{$basename}}) > 0)
 560                 {
 561                   # Delete any definition we knew from the old macro.
 562                   foreach my $def (@{$invmap{$basename}})
 563                     {
 564                       verb "$file:$.: ignoring previous definition of $def";
 565                       delete $map{$def};
 566                     }
 567                   $invmap{$basename} = [];
 568                   $serial{$basename} = \@new;
 569                 }
 570               else
 571                 {
 572                   $serial_older = 1;
 573                 }
 574             }
 575         }
 576
 577       # Remove comments from current line.
 578       # Do not do it earlier, because the serial line is a comment.
 579       $line =~ s/\bdnl\b.*$//;
 580       $line =~ s/\#.*$//;
 581
 582       while ($line =~ /$ac_defun_rx/go)
 583         {
 584           $defun_seen = 1;
 585           if (! defined $1)
 586             {
 587               msg ('syntax', "$file:$.", "underquoted definition of $2"
 588                    . "\n  run info Automake 'Extending aclocal'\n"
 589                    . "  or see http://www.gnu.org/software/automake/manual/"
 590                    . "automake.html#Extending-aclocal")
 591                 unless $underquoted_manual_once;
 592               $underquoted_manual_once = 1;
 593             }
 594
 595           # If this macro does not have a serial and we have already
 596           # seen a macro with the same basename earlier, we should
 597           # ignore the macro (don't exit immediately so we can still
 598           # diagnose later #serial numbers and underquoted macros).
 599           $serial_older ||= ($type != FT_AUTOMAKE
 600                              && !$serial_seen && exists $serial{$basename});
 601
 602           my $macro = $1 || $2;
 603           if (!$serial_older && !defined $map{$macro})
 604             {
 605               verb "found macro $macro in $file: $.";
 606               $map{$macro} = $file;
 607               push @{$invmap{$basename}}, $macro;
 608             }
 609           else
 610             {
 611               # Note: we used to give an error here if we saw a
 612               # duplicated macro.  However, this turns out to be
 613               # extremely unpopular.  It causes actual problems which
 614               # are hard to work around, especially when you must
 615               # mix-and-match tool versions.
 616               verb "ignoring macro $macro in $file: $.";
 617             }
 618         }
 619
 620       while ($line =~ /$m4_include_rx/go)
 621         {
 622           my $ifile = $2 || $3;
 623           # Skip missing 'sinclude'd files.
 624           next if $1 ne 'm4_' && ! -f $ifile;
 625           push (@inc_files, $ifile);
 626           $inc_lines{$ifile} = $.;
 627         }
 628     }
 629
 630   # Ignore any file that has an old serial (or no serial if we know
 631   # another one with a serial).
 632   return ()
 633     if ($serial_older ||
 634         ($type != FT_AUTOMAKE && !$serial_seen && exists $serial{$basename}));
 635
 636   $file_contents{$file} = $contents;
 637
 638   # For some reason I don't understand, it does not work
 639   # to do "map { scan_file ($_, ...) } @inc_files" below.
 640   # With Perl 5.8.2 it undefines @inc_files.
 641   my @copy = @inc_files;
 642   my @all_inc_files = (@inc_files,
 643                        map { scan_file ($type, $_,
 644                                         "$file:$inc_lines{$_}") } @copy);
 645   $file_includes{$file} = \@all_inc_files;
 646   return @all_inc_files;
 647 }
 648
 649 # strip_redundant_includes (%FILES)
 650 # ---------------------------------
 651 # Each key in %FILES is a file that must be present in the output.
 652 # However some of these files might already include other files in %FILES,
 653 # so there is no point in including them another time.
 654 # This removes items of %FILES which are already included by another file.
 655 sub strip_redundant_includes (%)
 656 {
 657   my %files = @_;
 658
 659   # Always include acinclude.m4, even if it does not appear to be used.
 660   $files{'acinclude.m4'} = 1 if -f 'acinclude.m4';
 661   # File included by $configure_ac are redundant.
 662   $files{$configure_ac} = 1;
 663
 664   # Files at the end of @file_order should override those at the beginning,
 665   # so it is important to preserve these trailing files.  We can remove
 666   # a file A if it is going to be output before a file B that includes
 667   # file A, not the converse.
 668   foreach my $file (reverse @file_order)
 669     {
 670       next unless exists $files{$file};
 671       foreach my $ifile (@{$file_includes{$file}})
 672         {
 673           next unless exists $files{$ifile};
 674           delete $files{$ifile};
 675           verb "$ifile is already included by $file";
 676         }
 677     }
 678
 679   # configure.ac is implicitly included.
 680   delete $files{$configure_ac};
 681
 682   return %files;
 683 }
 684
 685 sub trace_used_macros ()
 686 {
 687   my %files = map { $map{$_} => 1 } keys %macro_seen;
 688   %files = strip_redundant_includes %files;
 689
 690   my $traces = ($ENV{AUTOM4TE} || '@am_AUTOM4TE@');
 691   $traces .= " --language Autoconf-without-aclocal-m4 ";
 692   # All candidate files.
 693   $traces .= join (' ',
 694                    (map { "'$_'" }
 695                     (grep { exists $files{$_} } @file_order))) . " ";
 696   # All candidate macros.
 697   $traces .= join (' ',
 698                    (map { "--trace='$_:\$f::\$n::\$1'" }
 699                     ('AC_DEFUN',
 700                      'AC_DEFUN_ONCE',
 701                      'AU_DEFUN',
 702                      '_AM_AUTOCONF_VERSION')),
 703                    # Do not trace $1 for all other macros as we do
 704                    # not need it and it might contains harmful
 705                    # characters (like newlines).
 706                    (map { "--trace='$_:\$f::\$n'" } (keys %macro_seen)));
 707
 708   verb "running $traces $configure_ac";
 709
 710   my $tracefh = new Automake::XFile ("$traces $configure_ac |");
 711
 712   my %traced = ();
 713
 714   while ($_ = $tracefh->getline)
 715     {
 716       chomp;
 717       my ($file, $macro, $arg1) = split (/::/);
 718
 719       $traced{$macro} = 1 if exists $macro_seen{$macro};
 720
 721       $map_traced_defs{$arg1} = $file
 722         if ($macro eq 'AC_DEFUN'
 723             || $macro eq 'AC_DEFUN_ONCE'
 724             || $macro eq 'AU_DEFUN');
 725
 726       $ac_version = $arg1 if $macro eq '_AM_AUTOCONF_VERSION';
 727     }
 728
 729   $tracefh->close;
 730
 731   return %traced;
 732 }
 733
 734 sub scan_configure ()
 735 {
 736   # Make sure we include acinclude.m4 if it exists.
 737   if (-f 'acinclude.m4')
 738     {
 739       add_file ('acinclude.m4');
 740     }
 741   scan_configure_dep ($configure_ac);
 742 }
 743
 744 ################################################################
 745
 746 # Write output.
 747 # Return 0 iff some files were installed locally.
 748 sub write_aclocal ($@)
 749 {
 750   my ($output_file, @macros) = @_;
 751   my $output = '';
 752
 753   my %files = ();
 754   # Get the list of files containing definitions for the macros used.
 755   # (Filter out unused macro definitions with $map_traced_defs.  This
 756   # can happen when an Autoconf macro is conditionally defined:
 757   # aclocal sees the potential definition, but this definition is
 758   # actually never processed and the Autoconf implementation is used
 759   # instead.)
 760   for my $m (@macros)
 761     {
 762       $files{$map{$m}} = 1
 763         if (exists $map_traced_defs{$m}
 764             && $map{$m} eq $map_traced_defs{$m});
 765     }
 766   # Do not explicitly include a file that is already indirectly included.
 767   %files = strip_redundant_includes %files;
 768
 769   my $installed = 0;
 770
 771   for my $file (grep { exists $files{$_} } @file_order)
 772     {
 773       # Check the time stamp of this file, and of all files it includes.
 774       for my $ifile ($file, @{$file_includes{$file}})
 775         {
 776           my $mtime = mtime $ifile;
 777           $greatest_mtime = $mtime if $greatest_mtime < $mtime;
 778         }
 779
 780       # If the file to add looks like outside the project, copy it
 781       # to the output.  The regex catches filenames starting with
 782       # things like '/', '\', or 'c:\'.
 783       if ($file_type{$file} != FT_USER
 784           || $file =~ m,^(?:\w:)?[\\/],)
 785         {
 786           if (!$install || $file_type{$file} != FT_SYSTEM)
 787             {
 788               # Copy the file into aclocal.m4.
 789               $output .= $file_contents{$file} . "\n";
 790             }
 791           else
 792             {
 793               # Install the file (and any file it includes).
 794               my $dest;
 795               for my $ifile (@{$file_includes{$file}}, $file)
 796                 {
 797                   install_file ($ifile, $user_includes[0]);
 798                 }
 799               $installed = 1;
 800             }
 801         }
 802       else
 803         {
 804           # Otherwise, simply include the file.
 805           $output .= "m4_include([$file])\n";
 806         }
 807     }
 808
 809   if ($installed)
 810     {
 811       verb "running aclocal anew, because some files were installed locally";
 812       return 0;
 813     }
 814
 815   # Nothing to output?!
 816   # FIXME: Shouldn't we diagnose this?
 817   return 1 if ! length ($output);
 818
 819   if ($ac_version)
 820     {
 821       # Do not use "$output_file" here for the same reason we do not
 822       # use it in the header below.  autom4te will output the name of
 823       # the file in the diagnostic anyway.
 824       $output = "m4_ifndef([AC_AUTOCONF_VERSION],
 825   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
 826 m4_if(m4_defn([AC_AUTOCONF_VERSION]), [$ac_version],,
 827 [m4_warning([this file was generated for autoconf $ac_version.
 828 You have another version of autoconf.  It may work, but is not guaranteed to.
 829 If you have problems, you may need to regenerate the build system entirely.
 830 To do so, use the procedure documented by the package, typically 'autoreconf'.])])
 831
 832 $output";
 833     }
 834
 835   # We used to print "# $output_file generated automatically etc."  But
 836   # this creates spurious differences when using autoreconf.  Autoreconf
 837   # creates aclocal.m4t and then rename it to aclocal.m4, but the
 838   # rebuild rules generated by Automake create aclocal.m4 directly --
 839   # this would gives two ways to get the same file, with a different
 840   # name in the header.
 841   $output = "# generated automatically by aclocal $VERSION -*- Autoconf -*-
 842
 843 # Copyright (C) 1996-$RELEASE_YEAR Free Software Foundation, Inc.
 844
 845 # This file is free software; the Free Software Foundation
 846 # gives unlimited permission to copy and/or distribute it,
 847 # with or without modifications, as long as this notice is preserved.
 848
 849 # This program is distributed in the hope that it will be useful,
 850 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 851 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 852 # PARTICULAR PURPOSE.
 853
 854 $output";
 855
 856   # We try not to update $output_file unless necessary, because
 857   # doing so invalidate Autom4te's cache and therefore slows down
 858   # tools called after aclocal.
 859   #
 860   # We need to overwrite $output_file in the following situations.
 861   #   * The --force option is in use.
 862   #   * One of the dependencies is younger.
 863   #     (Not updating $output_file in this situation would cause
 864   #     make to call aclocal in loop.)
 865   #   * The contents of the current file are different from what
 866   #     we have computed.
 867   if (!$force_output
 868       && $greatest_mtime < mtime ($output_file)
 869       && $output eq contents ($output_file))
 870     {
 871       verb "$output_file unchanged";
 872       return 1;
 873     }
 874
 875   verb "writing $output_file";
 876
 877   if (!$dry_run)
 878     {
 879       if (-e $output_file && !unlink $output_file)
 880         {
 881           fatal "could not remove '$output_file': $!";
 882         }
 883       my $out = new Automake::XFile "> $output_file";
 884       print $out $output;
 885     }
 886   return 1;
 887 }
 888
 889 ################################################################
 890
 891 # Print usage and exit.
 892 sub usage ($)
 893 {
 894   my ($status) = @_;
 895
 896   print <<'EOF';
 897 Usage: aclocal [OPTION]...
 898
 899 Generate 'aclocal.m4' by scanning 'configure.ac' or 'configure.in'
 900
 901 Options:
 902       --automake-acdir=DIR  directory holding automake-provided m4 files
 903       --system-acdir=DIR    directory holding third-party system-wide files
 904       --diff[=COMMAND]      run COMMAND [diff -u] on M4 files that would be
 905                             changed (implies --install and --dry-run)
 906       --dry-run             pretend to, but do not actually update any file
 907       --force               always update output file
 908       --help                print this help, then exit
 909   -I DIR                    add directory to search list for .m4 files
 910       --install             copy third-party files to the first -I directory
 911       --output=FILE         put output in FILE (default aclocal.m4)
 912       --print-ac-dir        print name of directory holding system-wide
 913                               third-party m4 files, then exit
 914       --verbose             don't be silent
 915       --version             print version number, then exit
 916   -W, --warnings=CATEGORY   report the warnings falling in CATEGORY
 917
 918 Warning categories include:
 919   syntax        dubious syntactic constructs (default)
 920   unsupported   unknown macros (default)
 921   all           all the warnings (default)
 922   no-CATEGORY   turn off warnings in CATEGORY
 923   none          turn off all the warnings
 924   error         treat warnings as errors
 925
 926 Report bugs to <@PACKAGE_BUGREPORT@>.
 927 GNU Automake home page: <@PACKAGE_URL@>.
 928 General help using GNU software: <http://www.gnu.org/gethelp/>.
 929 EOF
 930   exit $status;
 931 }
 932
 933 # Print version and exit.
 934 sub version()
 935 {
 936   print <<EOF;
 937 aclocal (GNU $PACKAGE) $VERSION
 938 Copyright (C) $RELEASE_YEAR Free Software Foundation, Inc.
 939 License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
 940 This is free software: you are free to change and redistribute it.
 941 There is NO WARRANTY, to the extent permitted by law.
 942
 943 Written by Tom Tromey <tromey\@redhat.com>
 944        and Alexandre Duret-Lutz <adl\@gnu.org>.
 945 EOF
 946   exit 0;
 947 }
 948
 949 # Using --acdir overrides both the automake (versioned) directory and
 950 # the public (unversioned) system directory.  This usage is obsolete.
 951 sub handle_acdir_option ($$)
 952 {
 953   msg 'obsolete', '', "'--acdir' is deprecated\n";
 954   @system_includes = ($_[1]);
 955   @automake_includes = ();
 956 }
 957
 958 # Parse command line.
 959 sub parse_arguments ()
 960 {
 961   my $print_and_exit = 0;
 962   my $diff_command;
 963
 964   my %cli_options =
 965     (
 966      'help'             => sub { usage(0); },
 967      'version'          => \&version,
 968      'acdir=s'          => \&handle_acdir_option,
 969      'system-acdir=s'   => sub { shift; @system_includes = @_; },
 970      'automake-acdir=s' => sub { shift; @automake_includes = @_; },
 971      'diff:s'           => \$diff_command,
 972      'dry-run'          => \$dry_run,
 973      'force'            => \$force_output,
 974      'I=s'              => \@user_includes,
 975      'install'          => \$install,
 976      'output=s'         => \$output_file,
 977      'print-ac-dir'     => \$print_and_exit,
 978      'verbose'          => sub { setup_channel 'verb', silent => 0; },
 979      'W|warnings=s'     => \&parse_warnings,
 980      );
 981
 982   use Automake::Getopt ();
 983   Automake::Getopt::parse_options %cli_options;
 984
 985   if (@ARGV > 0)
 986     {
 987       fatal ("non-option arguments are not accepted: '$ARGV[0]'.\n"
 988              . "Try '$0 --help' for more information.");
 989     }
 990
 991   if ($print_and_exit)
 992     {
 993       print "@system_includes\n";
 994       exit 0;
 995     }
 996
 997   if (defined $diff_command)
 998     {
 999       $diff_command = 'diff -u' if $diff_command eq '';
1000       @diff_command = split (' ', $diff_command);
1001       $install = 1;
1002       $dry_run = 1;
1003     }
1004
1005   if ($install && !@user_includes)
1006     {
1007       fatal ("--install should copy macros in the directory indicated by the"
1008              . "\nfirst -I option, but no -I was supplied");
1009     }
1010
1011   # Finally, adds any directory listed in the 'dirlist' file.
1012   if (open (DIRLIST, "$system_includes[0]/dirlist"))
1013     {
1014       while (<DIRLIST>)
1015         {
1016           # Ignore '#' lines.
1017           next if /^#/;
1018           # strip off newlines and end-of-line comments
1019           s/\s*\#.*$//;
1020           chomp;
1021           foreach my $dir (glob)
1022             {
1023               push (@system_includes, $dir) if -d $dir;
1024             }
1025         }
1026       close (DIRLIST);
1027     }
1028 }
1029
1030 # Add any directory listed in the 'ACLOCAL_PATH' environment variable
1031 # to the list of system include directories.
1032 sub parse_ACLOCAL_PATH ()
1033 {
1034   return if not defined $ENV{"ACLOCAL_PATH"};
1035   # Directories in ACLOCAL_PATH should take precedence over system
1036   # directories, so we use unshift.  However, directories that
1037   # come first in ACLOCAL_PATH take precedence over directories
1038   # coming later, which is why the result of split is reversed.
1039   foreach my $dir (reverse split /:/, $ENV{"ACLOCAL_PATH"})
1040     {
1041       unshift (@system_includes, $dir) if $dir ne '' && -d $dir;
1042     }
1043 }
1044
1045 ################################################################
1046
1047 parse_WARNINGS;             # Parse the WARNINGS environment variable.
1048 parse_arguments;
1049 parse_ACLOCAL_PATH;
1050 $configure_ac = require_configure_ac;
1051
1052 # We may have to rerun aclocal if some file have been installed, but
1053 # it should not happen more than once.  The reason we must run again
1054 # is that once the file has been moved from /usr/share/aclocal/ to the
1055 # local m4/ directory it appears at a new place in the search path,
1056 # hence it should be output at a different position in aclocal.m4.  If
1057 # we did not rerun aclocal, the next run of aclocal would produce a
1058 # different aclocal.m4.
1059 my $loop = 0;
1060 while (1)
1061   {
1062     ++$loop;
1063     prog_error "too many loops" if $loop > 2;
1064
1065     reset_maps;
1066     scan_m4_files;
1067     scan_configure;
1068     last if $exit_code;
1069     my %macro_traced = trace_used_macros;
1070     last if write_aclocal ($output_file, keys %macro_traced);
1071     last if $dry_run;
1072   }
1073 check_acinclude;
1074
1075 exit $exit_code;
1076
1077 ### Setup "GNU" style for perl-mode and cperl-mode.
1078 ## Local Variables:
1079 ## perl-indent-level: 2
1080 ## perl-continued-statement-offset: 2
1081 ## perl-continued-brace-offset: 0
1082 ## perl-brace-offset: 0
1083 ## perl-brace-imaginary-offset: 0
1084 ## perl-label-offset: -2
1085 ## cperl-indent-level: 2
1086 ## cperl-brace-offset: 0
1087 ## cperl-continued-brace-offset: 0
1088 ## cperl-label-offset: -2
1089 ## cperl-extra-newline-before-brace: t
1090 ## cperl-merge-trailing-else: nil
1091 ## cperl-continued-statement-offset: 2
1092 ## End: