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