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