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