doc: Fix various typos and phrasing
[automake.git] / bin / automake.in
blobb4ae8f43f1064ee8ac229676dbcc69c402fce687
1 #!@PERL@ -w
2 # automake - create Makefile.in from Makefile.am            -*- perl -*-
3 # @configure_input@
4 # Copyright (C) 1994-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 # Originally written by David Mackenzie <djm@gnu.ai.mit.edu>.
20 # Perl reimplementation by Tom Tromey <tromey@redhat.com>, and
21 # Alexandre Duret-Lutz <adl@gnu.org>.
23 package Automake;
25 use strict;
27 BEGIN
29   unshift (@INC, '@datadir@/@PACKAGE@-@APIVERSION@')
30     unless $ENV{AUTOMAKE_UNINSTALLED};
32   # Override SHELL.  This is required on DJGPP so that system() uses
33   # bash, not COMMAND.COM which doesn't quote arguments properly.
34   # Other systems aren't expected to use $SHELL when Automake
35   # runs, but it should be safe to drop the "if DJGPP" guard if
36   # it turns up other systems need the same thing.  After all,
37   # if SHELL is used, ./configure's SHELL is always better than
38   # the user's SHELL (which may be something like tcsh).
39   $ENV{'SHELL'} = '@SHELL@' if exists $ENV{'DJDIR'};
42 use Automake::Config;
43 BEGIN
45   if ($perl_threads)
46     {
47       require threads;
48       import threads;
49       require Thread::Queue;
50       import Thread::Queue;
51     }
53 use Automake::General;
54 use Automake::XFile;
55 use Automake::Channels;
56 use Automake::ChannelDefs;
57 use Automake::Configure_ac;
58 use Automake::FileUtils;
59 use Automake::Location;
60 use Automake::Condition qw/TRUE FALSE/;
61 use Automake::DisjConditions;
62 use Automake::Options;
63 use Automake::Variable;
64 use Automake::VarDef;
65 use Automake::Rule;
66 use Automake::RuleDef;
67 use Automake::Wrap 'makefile_wrap';
68 use Automake::Language;
69 use File::Basename;
70 use File::Spec;
71 use Carp;
73 ## ----------------------- ##
74 ## Subroutine prototypes.  ##
75 ## ----------------------- ##
77 sub append_exeext (&$);
78 sub check_gnits_standards ();
79 sub check_gnu_standards ();
80 sub check_trailing_slash ($\$);
81 sub check_typos ();
82 sub define_files_variable ($\@$$);
83 sub define_standard_variables ();
84 sub define_verbose_libtool ();
85 sub define_verbose_texinfo ();
86 sub do_check_merge_target ();
87 sub get_number_of_threads ();
88 sub handle_compile ();
89 sub handle_data ();
90 sub handle_dist ();
91 sub handle_emacs_lisp ();
92 sub handle_factored_dependencies ();
93 sub handle_footer ();
94 sub handle_gettext ();
95 sub handle_headers ();
96 sub handle_install ();
97 sub handle_java ();
98 sub handle_languages ();
99 sub handle_libraries ();
100 sub handle_libtool ();
101 sub handle_ltlibraries ();
102 sub handle_makefiles_serial ();
103 sub handle_man_pages ();
104 sub handle_minor_options ();
105 sub handle_options ();
106 sub handle_programs ();
107 sub handle_python ();
108 sub handle_scripts ();
109 sub handle_silent ();
110 sub handle_subdirs ();
111 sub handle_tags ();
112 sub handle_targets ();
113 sub handle_tests ();
114 sub handle_tests_dejagnu ();
115 sub handle_texinfo ();
116 sub handle_user_recursion ();
117 sub initialize_per_input ();
118 sub lang_lex_finish ();
119 sub lang_sub_obj ();
120 sub lang_vala_finish ();
121 sub lang_yacc_finish ();
122 sub locate_aux_dir ();
123 sub parse_arguments ();
124 sub scan_aclocal_m4 ();
125 sub scan_autoconf_files ();
126 sub silent_flag ();
127 sub transform ($\%);
128 sub transform_token ($\%$);
129 sub usage ();
130 sub version ();
131 sub yacc_lex_finish_helper ();
133 ## ----------- ##
134 ## Constants.  ##
135 ## ----------- ##
137 # Some regular expressions.  One reason to put them here is that it
138 # makes indentation work better in Emacs.
140 # Writing singled-quoted-$-terminated regexes is a pain because
141 # perl-mode thinks of $' as the ${'} variable (instead of a $ followed
142 # by a closing quote.  Letting perl-mode think the quote is not closed
143 # leads to all sort of misindentations.  On the other hand, defining
144 # regexes as double-quoted strings is far less readable.  So usually
145 # we will write:
147 #  $REGEX = '^regex_value' . "\$";
149 my $IGNORE_PATTERN = '^\s*##([^#\n].*)?\n';
150 my $WHITE_PATTERN = '^\s*' . "\$";
151 my $COMMENT_PATTERN = '^#';
152 my $TARGET_PATTERN='[$a-zA-Z0-9_.@%][-.a-zA-Z0-9_(){}/$+@%]*';
153 # A rule has three parts: a list of targets, a list of dependencies,
154 # and optionally actions.
155 my $RULE_PATTERN =
156   "^($TARGET_PATTERN(?:(?:\\\\\n|\\s)+$TARGET_PATTERN)*) *:([^=].*|)\$";
158 # Only recognize leading spaces, not leading tabs.  If we recognize
159 # leading tabs here then we need to make the reader smarter, because
160 # otherwise it will think rules like 'foo=bar; \' are errors.
161 my $ASSIGNMENT_PATTERN = '^ *([^ \t=:+]*)\s*([:+]?)=\s*(.*)' . "\$";
162 # This pattern recognizes a Gnits version id and sets $1 if the
163 # release is an alpha release.  We also allow a suffix which can be
164 # used to extend the version number with a "fork" identifier.
165 my $GNITS_VERSION_PATTERN = '\d+\.\d+([a-z]|\.\d+)?(-[A-Za-z0-9]+)?';
167 my $IF_PATTERN = '^if\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*)\s*(?:#.*)?' . "\$";
168 my $ELSE_PATTERN =
169   '^else(?:\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*))?\s*(?:#.*)?' . "\$";
170 my $ENDIF_PATTERN =
171   '^endif(?:\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*))?\s*(?:#.*)?' . "\$";
172 my $PATH_PATTERN = '(\w|[+/.-])+';
173 # This will pass through anything not of the prescribed form.
174 my $INCLUDE_PATTERN = ('^include\s+'
175                        . '((\$\(top_srcdir\)/' . $PATH_PATTERN . ')'
176                        . '|(\$\(srcdir\)/' . $PATH_PATTERN . ')'
177                        . '|([^/\$]' . $PATH_PATTERN . '))\s*(#.*)?' . "\$");
179 # Directories installed during 'install-exec' phase.
180 my $EXEC_DIR_PATTERN =
181   '^(?:bin|sbin|libexec|sysconf|localstate|lib|pkglib|.*exec.*)' . "\$";
183 # Values for AC_CANONICAL_*
184 use constant AC_CANONICAL_BUILD  => 1;
185 use constant AC_CANONICAL_HOST   => 2;
186 use constant AC_CANONICAL_TARGET => 3;
188 # Values indicating when something should be cleaned.
189 use constant MOSTLY_CLEAN     => 0;
190 use constant CLEAN            => 1;
191 use constant DIST_CLEAN       => 2;
192 use constant MAINTAINER_CLEAN => 3;
194 # Libtool files.
195 my @libtool_files = qw(ltmain.sh config.guess config.sub);
196 # ltconfig appears here for compatibility with old versions of libtool.
197 my @libtool_sometimes = qw(ltconfig ltcf-c.sh ltcf-cxx.sh ltcf-gcj.sh);
199 # Commonly found files we look for and automatically include in
200 # DISTFILES.
201 my @common_files =
202     (qw(ABOUT-GNU ABOUT-NLS AUTHORS BACKLOG COPYING COPYING.DOC COPYING.LIB
203         COPYING.LESSER ChangeLog INSTALL NEWS README THANKS TODO
204         ar-lib compile config.guess config.rpath
205         config.sub depcomp install-sh libversion.in mdate-sh
206         missing mkinstalldirs py-compile texinfo.tex ylwrap),
207      @libtool_files, @libtool_sometimes);
209 # Commonly used files we auto-include, but only sometimes.  This list
210 # is used for the --help output only.
211 my @common_sometimes =
212   qw(aclocal.m4 acconfig.h config.h.top config.h.bot configure
213      configure.ac configure.in stamp-vti);
215 # Standard directories from the GNU Coding Standards, and additional
216 # pkg* directories from Automake.  Stored in a hash for fast member check.
217 my %standard_prefix =
218     map { $_ => 1 } (qw(bin data dataroot doc dvi exec html include info
219                         lib libexec lisp locale localstate man man1 man2
220                         man3 man4 man5 man6 man7 man8 man9 oldinclude pdf
221                         pkgdata pkginclude pkglib pkglibexec ps sbin
222                         sharedstate sysconf));
224 # Copyright on generated Makefile.ins.
225 my $gen_copyright = "\
226 # Copyright (C) 1994-$RELEASE_YEAR Free Software Foundation, Inc.
228 # This Makefile.in is free software; the Free Software Foundation
229 # gives unlimited permission to copy and/or distribute it,
230 # with or without modifications, as long as this notice is preserved.
232 # This program is distributed in the hope that it will be useful,
233 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
234 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
235 # PARTICULAR PURPOSE.
238 # These constants are returned by the lang_*_rewrite functions.
239 # LANG_SUBDIR means that the resulting object file should be in a
240 # subdir if the source file is.  In this case the file name cannot
241 # have '..' components.
242 use constant LANG_IGNORE  => 0;
243 use constant LANG_PROCESS => 1;
244 use constant LANG_SUBDIR  => 2;
246 # These are used when keeping track of whether an object can be built
247 # by two different paths.
248 use constant COMPILE_LIBTOOL  => 1;
249 use constant COMPILE_ORDINARY => 2;
251 # We can't always associate a location to a variable or a rule,
252 # when it's defined by Automake.  We use INTERNAL in this case.
253 use constant INTERNAL => new Automake::Location;
255 # Serialization keys for message queues.
256 use constant QUEUE_MESSAGE   => "msg";
257 use constant QUEUE_CONF_FILE => "conf file";
258 use constant QUEUE_LOCATION  => "location";
259 use constant QUEUE_STRING    => "string";
261 ## ---------------------------------- ##
262 ## Variables related to the options.  ##
263 ## ---------------------------------- ##
265 # TRUE if we should always generate Makefile.in.
266 my $force_generation = 1;
268 # From the Perl manual.
269 my $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
271 # TRUE if missing standard files should be installed.
272 my $add_missing = 0;
274 # TRUE if we should copy missing files; otherwise symlink if possible.
275 my $copy_missing = 0;
277 # TRUE if we should always update files that we know about.
278 my $force_missing = 0;
281 ## ---------------------------------------- ##
282 ## Variables filled during files scanning.  ##
283 ## ---------------------------------------- ##
285 # Name of the configure.ac file.
286 my $configure_ac;
288 # Files found by scanning configure.ac for LIBOBJS.
289 my %libsources = ();
291 # Names used in AC_CONFIG_HEADERS call.
292 my @config_headers = ();
294 # Names used in AC_CONFIG_LINKS call.
295 my @config_links = ();
297 # List of Makefile.am's to process, and their corresponding outputs.
298 my @input_files = ();
299 my %output_files = ();
301 # Complete list of Makefile.am's that exist.
302 my @configure_input_files = ();
304 # List of files in AC_CONFIG_FILES/AC_OUTPUT without Makefile.am's,
305 # and their outputs.
306 my @other_input_files = ();
307 # Where each AC_CONFIG_FILES/AC_OUTPUT/AC_CONFIG_LINK/AC_CONFIG_HEADERS
308 # appears.  The keys are the files created by these macros.
309 my %ac_config_files_location = ();
310 # The condition under which AC_CONFIG_FOOS appears.
311 my %ac_config_files_condition = ();
313 # Directory to search for configure-required files.  This
314 # will be computed by locate_aux_dir() and can be set using
315 # AC_CONFIG_AUX_DIR in configure.ac.
316 # $CONFIG_AUX_DIR is the 'raw' directory, valid only in the source-tree.
317 my $config_aux_dir = '';
318 my $config_aux_dir_set_in_configure_ac = 0;
319 # $AM_CONFIG_AUX_DIR is prefixed with $(top_srcdir), so it can be used
320 # in Makefiles.
321 my $am_config_aux_dir = '';
323 # Directory to search for AC_LIBSOURCE files, as set by AC_CONFIG_LIBOBJ_DIR
324 # in configure.ac.
325 my $config_libobj_dir = '';
327 # Whether AM_GNU_GETTEXT has been seen in configure.ac.
328 my $seen_gettext = 0;
329 # Whether AM_GNU_GETTEXT([external]) is used.
330 my $seen_gettext_external = 0;
331 # Where AM_GNU_GETTEXT appears.
332 my $ac_gettext_location;
333 # Whether AM_GNU_GETTEXT_INTL_SUBDIR has been seen.
334 my $seen_gettext_intl = 0;
336 # The arguments of the AM_EXTRA_RECURSIVE_TARGETS call (if any).
337 my @extra_recursive_targets = ();
339 # Lists of tags supported by Libtool.
340 my %libtool_tags = ();
341 # 1 if Libtool uses LT_SUPPORTED_TAG.  If it does, then it also
342 # uses AC_REQUIRE_AUX_FILE.
343 my $libtool_new_api = 0;
345 # Most important AC_CANONICAL_* macro seen so far.
346 my $seen_canonical = 0;
348 # Where AM_MAINTAINER_MODE appears.
349 my $seen_maint_mode;
351 # Actual version we've seen.
352 my $package_version = '';
354 # Where version is defined.
355 my $package_version_location;
357 # TRUE if we've seen AM_PROG_AR
358 my $seen_ar = 0;
360 # Location of AC_REQUIRE_AUX_FILE calls, indexed by their argument.
361 my %required_aux_file = ();
363 # Where AM_INIT_AUTOMAKE is called.
364 my $seen_init_automake = 0;
366 # TRUE if we've seen AM_AUTOMAKE_VERSION.
367 my $seen_automake_version = 0;
369 # Hash table of discovered configure substitutions.  Keys are names,
370 # values are 'FILE:LINE' strings which are used by error message
371 # generation.
372 my %configure_vars = ();
374 # Ignored configure substitutions (i.e., variables not to be output in
375 # Makefile.in)
376 my %ignored_configure_vars = ();
378 # Files included by $configure_ac.
379 my @configure_deps = ();
381 # Greatest timestamp of configure's dependencies.
382 my $configure_deps_greatest_timestamp = 0;
384 # Hash table of AM_CONDITIONAL variables seen in configure.
385 my %configure_cond = ();
387 # This maps extensions onto language names.
388 my %extension_map = ();
390 # List of the DIST_COMMON files we discovered while reading
391 # configure.ac.
392 my @configure_dist_common = ();
394 # This maps languages names onto objects.
395 my %languages = ();
396 # Maps each linker variable onto a language object.
397 my %link_languages = ();
399 # maps extensions to needed source flags.
400 my %sourceflags = ();
402 # List of targets we must always output.
403 # FIXME: Complete, and remove falsely required targets.
404 my %required_targets =
405   (
406    'all'          => 1,
407    'dvi'          => 1,
408    'pdf'          => 1,
409    'ps'           => 1,
410    'info'         => 1,
411    'install-info' => 1,
412    'install'      => 1,
413    'install-data' => 1,
414    'install-exec' => 1,
415    'uninstall'    => 1,
417    # FIXME: Not required, temporary hacks.
418    # Well, actually they are sort of required: the -recursive
419    # targets will run them anyway...
420    'html-am'         => 1,
421    'dvi-am'          => 1,
422    'pdf-am'          => 1,
423    'ps-am'           => 1,
424    'info-am'         => 1,
425    'install-data-am' => 1,
426    'install-exec-am' => 1,
427    'install-html-am' => 1,
428    'install-dvi-am'  => 1,
429    'install-pdf-am'  => 1,
430    'install-ps-am'   => 1,
431    'install-info-am' => 1,
432    'installcheck-am' => 1,
433    'uninstall-am'    => 1,
434    'tags-am'         => 1,
435    'ctags-am'        => 1,
436    'cscopelist-am'   => 1,
437    'install-man'     => 1,
438   );
440 # Queue to push require_conf_file requirements to.
441 my $required_conf_file_queue;
443 # The name of the Makefile currently being processed.
444 my $am_file = 'BUG';
446 ################################################################
448 ## ------------------------------------------ ##
449 ## Variables reset by &initialize_per_input.  ##
450 ## ------------------------------------------ ##
452 # Relative dir of the output makefile.
453 my $relative_dir;
455 # Greatest timestamp of the output's dependencies (excluding
456 # configure's dependencies).
457 my $output_deps_greatest_timestamp;
459 # These variables are used when generating each Makefile.in.
460 # They hold the Makefile.in until it is ready to be printed.
461 my $output_vars;
462 my $output_all;
463 my $output_header;
464 my $output_rules;
465 my $output_trailer;
467 # This is the conditional stack, updated on if/else/endif, and
468 # used to build Condition objects.
469 my @cond_stack;
471 # This holds the set of included files.
472 my @include_stack;
474 # List of dependencies for the obvious targets.
475 my @all;
476 my @check;
477 my @check_tests;
479 # Keys in this hash table are files to delete.  The associated
480 # value tells when this should happen (MOSTLY_CLEAN, DIST_CLEAN, etc.)
481 my %clean_files;
483 # Keys in this hash table are object files or other files in
484 # subdirectories which need to be removed.  This only holds files
485 # which are created by compilations.  The value in the hash indicates
486 # when the file should be removed.
487 my %compile_clean_files;
489 # Keys in this hash table are directories where we expect to build a
490 # libtool object.  We use this information to decide what directories
491 # to delete.
492 my %libtool_clean_directories;
494 # Value of $(SOURCES), used by tags.am.
495 my @sources;
496 # Sources which go in the distribution.
497 my @dist_sources;
499 # This hash maps object file names onto their corresponding source
500 # file names.  This is used to ensure that each object is created
501 # by a single source file.
502 my %object_map;
504 # This hash maps object file names onto an integer value representing
505 # whether this object has been built via ordinary compilation or
506 # libtool compilation (the COMPILE_* constants).
507 my %object_compilation_map;
510 # This keeps track of the directories for which we've already
511 # created dirstamp code.  Keys are directories, values are stamp files.
512 # Several keys can share the same stamp files if they are equivalent
513 # (as are './/foo' and 'foo').
514 my %directory_map;
516 # All .P files.
517 my %dep_files;
519 # This is a list of all targets to run during "make dist".
520 my @dist_targets;
522 # List of all programs, libraries and ltlibraries as returned
523 # by am_install_var
524 my @proglist;
525 my @liblist;
526 my @ltliblist;
527 # Blacklist of targets (as canonical base name) for which object file names
528 # may not be automatically shortened
529 my @dup_shortnames;
531 # Keep track of all programs declared in this Makefile, without
532 # $(EXEEXT).  @substitutions@ are not listed.
533 my %known_programs;
534 my %known_libraries;
536 # This keeps track of which extensions we've seen (that we care
537 # about).
538 my %extension_seen;
540 # This is random scratch space for the language finish functions.
541 # Don't randomly overwrite it; examine other uses of keys first.
542 my %language_scratch;
544 # We keep track of which objects need special (per-executable)
545 # handling on a per-language basis.
546 my %lang_specific_files;
548 # List of distributed files to be put in DIST_COMMON.
549 my @dist_common;
551 # This is set when 'handle_dist' has finished.  Once this happens,
552 # we should no longer push on dist_common.
553 my $handle_dist_run;
555 # Used to store a set of linkers needed to generate the sources currently
556 # under consideration.
557 my %linkers_used;
559 # True if we need 'LINK' defined.  This is a hack.
560 my $need_link;
562 # Does the generated Makefile have to build some compiled object
563 # (for binary programs, or plain or libtool libraries)?
564 my $must_handle_compiled_objects;
566 # Record each file processed by make_paragraphs.
567 my %transformed_files;
569 ################################################################
571 ## ---------------------------------------------- ##
572 ## Variables not reset by &initialize_per_input.  ##
573 ## ---------------------------------------------- ##
575 # Cache each file processed by make_paragraphs.
576 # (This is different from %transformed_files because
577 # %transformed_files is reset for each file while %am_file_cache
578 # it global to the run.)
579 my %am_file_cache;
581 ################################################################
583 # var_SUFFIXES_trigger ($TYPE, $VALUE)
584 # ------------------------------------
585 # This is called by Automake::Variable::define() when SUFFIXES
586 # is defined ($TYPE eq '') or appended ($TYPE eq '+').
587 # The work here needs to be performed as a side-effect of the
588 # macro_define() call because SUFFIXES definitions impact
589 # on $KNOWN_EXTENSIONS_PATTERN which is used used when parsing
590 # the input am file.
591 sub var_SUFFIXES_trigger
593     my ($type, $value) = @_;
594     accept_extensions (split (' ', $value));
596 Automake::Variable::hook ('SUFFIXES', \&var_SUFFIXES_trigger);
598 ################################################################
601 # initialize_per_input ()
602 # -----------------------
603 # (Re)-Initialize per-Makefile.am variables.
604 sub initialize_per_input ()
606     reset_local_duplicates ();
608     $relative_dir = undef;
610     $output_deps_greatest_timestamp = 0;
612     $output_vars = '';
613     $output_all = '';
614     $output_header = '';
615     $output_rules = '';
616     $output_trailer = '';
618     Automake::Options::reset;
619     Automake::Variable::reset;
620     Automake::Rule::reset;
622     @cond_stack = ();
624     @include_stack = ();
626     @all = ();
627     @check = ();
628     @check_tests = ();
630     %clean_files = ();
631     %compile_clean_files = ();
633     # We always include '.'.  This isn't strictly correct.
634     %libtool_clean_directories = ('.' => 1);
636     @sources = ();
637     @dist_sources = ();
639     %object_map = ();
640     %object_compilation_map = ();
642     %directory_map = ();
644     %dep_files = ();
646     @dist_targets = ();
648     @dist_common = ();
649     $handle_dist_run = 0;
651     @proglist = ();
652     @liblist = ();
653     @ltliblist = ();
654     @dup_shortnames = ();
656     %known_programs = ();
657     %known_libraries = ();
659     %extension_seen = ();
661     %language_scratch = ();
663     %lang_specific_files = ();
665     $need_link = 0;
667     $must_handle_compiled_objects = 0;
669     %transformed_files = ();
673 ################################################################
675 # Initialize our list of languages that are internally supported.
677 my @cpplike_flags =
678   qw{
679     $(DEFS)
680     $(DEFAULT_INCLUDES)
681     $(INCLUDES)
682     $(AM_CPPFLAGS)
683     $(CPPFLAGS)
684   };
686 # C.
687 register_language ('name' => 'c',
688                    'Name' => 'C',
689                    'config_vars' => ['CC'],
690                    'autodep' => '',
691                    'flags' => ['CFLAGS', 'CPPFLAGS'],
692                    'ccer' => 'CC',
693                    'compiler' => 'COMPILE',
694                    'compile' => "\$(CC) @cpplike_flags \$(AM_CFLAGS) \$(CFLAGS)",
695                    'lder' => 'CCLD',
696                    'ld' => '$(CC)',
697                    'linker' => 'LINK',
698                    'link' => '$(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
699                    'compile_flag' => '-c',
700                    'output_flag' => '-o',
701                    'libtool_tag' => 'CC',
702                    'extensions' => ['.c']);
704 # C++.
705 register_language ('name' => 'cxx',
706                    'Name' => 'C++',
707                    'config_vars' => ['CXX'],
708                    'linker' => 'CXXLINK',
709                    'link' => '$(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
710                    'autodep' => 'CXX',
711                    'flags' => ['CXXFLAGS', 'CPPFLAGS'],
712                    'compile' => "\$(CXX) @cpplike_flags \$(AM_CXXFLAGS) \$(CXXFLAGS)",
713                    'ccer' => 'CXX',
714                    'compiler' => 'CXXCOMPILE',
715                    'compile_flag' => '-c',
716                    'output_flag' => '-o',
717                    'libtool_tag' => 'CXX',
718                    'lder' => 'CXXLD',
719                    'ld' => '$(CXX)',
720                    'pure' => 1,
721                    'extensions' => ['.c++', '.cc', '.cpp', '.cxx', '.C']);
723 # Objective C.
724 register_language ('name' => 'objc',
725                    'Name' => 'Objective C',
726                    'config_vars' => ['OBJC'],
727                    'linker' => 'OBJCLINK',
728                    'link' => '$(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
729                    'autodep' => 'OBJC',
730                    'flags' => ['OBJCFLAGS', 'CPPFLAGS'],
731                    'compile' => "\$(OBJC) @cpplike_flags \$(AM_OBJCFLAGS) \$(OBJCFLAGS)",
732                    'ccer' => 'OBJC',
733                    'compiler' => 'OBJCCOMPILE',
734                    'compile_flag' => '-c',
735                    'output_flag' => '-o',
736                    'lder' => 'OBJCLD',
737                    'ld' => '$(OBJC)',
738                    'pure' => 1,
739                    'extensions' => ['.m']);
741 # Objective C++.
742 register_language ('name' => 'objcxx',
743                    'Name' => 'Objective C++',
744                    'config_vars' => ['OBJCXX'],
745                    'linker' => 'OBJCXXLINK',
746                    'link' => '$(OBJCXXLD) $(AM_OBJCXXFLAGS) $(OBJCXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
747                    'autodep' => 'OBJCXX',
748                    'flags' => ['OBJCXXFLAGS', 'CPPFLAGS'],
749                    'compile' => "\$(OBJCXX) @cpplike_flags \$(AM_OBJCXXFLAGS) \$(OBJCXXFLAGS)",
750                    'ccer' => 'OBJCXX',
751                    'compiler' => 'OBJCXXCOMPILE',
752                    'compile_flag' => '-c',
753                    'output_flag' => '-o',
754                    'lder' => 'OBJCXXLD',
755                    'ld' => '$(OBJCXX)',
756                    'pure' => 1,
757                    'extensions' => ['.mm']);
759 # Unified Parallel C.
760 register_language ('name' => 'upc',
761                    'Name' => 'Unified Parallel C',
762                    'config_vars' => ['UPC'],
763                    'linker' => 'UPCLINK',
764                    'link' => '$(UPCLD) $(AM_UPCFLAGS) $(UPCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
765                    'autodep' => 'UPC',
766                    'flags' => ['UPCFLAGS', 'CPPFLAGS'],
767                    'compile' => "\$(UPC) @cpplike_flags \$(AM_UPCFLAGS) \$(UPCFLAGS)",
768                    'ccer' => 'UPC',
769                    'compiler' => 'UPCCOMPILE',
770                    'compile_flag' => '-c',
771                    'output_flag' => '-o',
772                    'lder' => 'UPCLD',
773                    'ld' => '$(UPC)',
774                    'pure' => 1,
775                    'extensions' => ['.upc']);
777 # Headers.
778 register_language ('name' => 'header',
779                    'Name' => 'Header',
780                    'extensions' => ['.h', '.H', '.hxx', '.h++', '.hh',
781                                     '.hpp', '.inc'],
782                    # No output.
783                    'output_extensions' => sub { return () },
784                    # Nothing to do.
785                    '_finish' => sub { });
787 # Vala
788 register_language ('name' => 'vala',
789                    'Name' => 'Vala',
790                    'config_vars' => ['VALAC'],
791                    'flags' => [],
792                    'compile' => '$(VALAC) $(AM_VALAFLAGS) $(VALAFLAGS)',
793                    'ccer' => 'VALAC',
794                    'compiler' => 'VALACOMPILE',
795                    'extensions' => ['.vala'],
796                    'output_extensions' => sub { (my $ext = $_[0]) =~ s/vala$/c/;
797                                                 return ($ext,) },
798                    'rule_file' => 'vala',
799                    '_finish' => \&lang_vala_finish,
800                    '_target_hook' => \&lang_vala_target_hook,
801                    'nodist_specific' => 1);
803 # Yacc (C & C++).
804 register_language ('name' => 'yacc',
805                    'Name' => 'Yacc',
806                    'config_vars' => ['YACC'],
807                    'flags' => ['YFLAGS'],
808                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
809                    'ccer' => 'YACC',
810                    'compiler' => 'YACCCOMPILE',
811                    'extensions' => ['.y'],
812                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
813                                                 return ($ext,) },
814                    'rule_file' => 'yacc',
815                    '_finish' => \&lang_yacc_finish,
816                    '_target_hook' => \&lang_yacc_target_hook,
817                    'nodist_specific' => 1);
818 register_language ('name' => 'yaccxx',
819                    'Name' => 'Yacc (C++)',
820                    'config_vars' => ['YACC'],
821                    'rule_file' => 'yacc',
822                    'flags' => ['YFLAGS'],
823                    'ccer' => 'YACC',
824                    'compiler' => 'YACCCOMPILE',
825                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
826                    'extensions' => ['.y++', '.yy', '.yxx', '.ypp'],
827                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
828                                                 return ($ext,) },
829                    '_finish' => \&lang_yacc_finish,
830                    '_target_hook' => \&lang_yacc_target_hook,
831                    'nodist_specific' => 1);
833 # Lex (C & C++).
834 register_language ('name' => 'lex',
835                    'Name' => 'Lex',
836                    'config_vars' => ['LEX'],
837                    'rule_file' => 'lex',
838                    'flags' => ['LFLAGS'],
839                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
840                    'ccer' => 'LEX',
841                    'compiler' => 'LEXCOMPILE',
842                    'extensions' => ['.l'],
843                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
844                                                 return ($ext,) },
845                    '_finish' => \&lang_lex_finish,
846                    '_target_hook' => \&lang_lex_target_hook,
847                    'nodist_specific' => 1);
848 register_language ('name' => 'lexxx',
849                    'Name' => 'Lex (C++)',
850                    'config_vars' => ['LEX'],
851                    'rule_file' => 'lex',
852                    'flags' => ['LFLAGS'],
853                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
854                    'ccer' => 'LEX',
855                    'compiler' => 'LEXCOMPILE',
856                    'extensions' => ['.l++', '.ll', '.lxx', '.lpp'],
857                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
858                                                 return ($ext,) },
859                    '_finish' => \&lang_lex_finish,
860                    '_target_hook' => \&lang_lex_target_hook,
861                    'nodist_specific' => 1);
863 # Assembler.
864 register_language ('name' => 'asm',
865                    'Name' => 'Assembler',
866                    'config_vars' => ['CCAS', 'CCASFLAGS'],
868                    'flags' => ['CCASFLAGS'],
869                    # Users can set AM_CCASFLAGS to include DEFS, INCLUDES,
870                    # or anything else required.  They can also set CCAS.
871                    # Or simply use Preprocessed Assembler.
872                    'compile' => '$(CCAS) $(AM_CCASFLAGS) $(CCASFLAGS)',
873                    'ccer' => 'CCAS',
874                    'compiler' => 'CCASCOMPILE',
875                    'compile_flag' => '-c',
876                    'output_flag' => '-o',
877                    'extensions' => ['.s']);
879 # Preprocessed Assembler.
880 register_language ('name' => 'cppasm',
881                    'Name' => 'Preprocessed Assembler',
882                    'config_vars' => ['CCAS', 'CCASFLAGS'],
884                    'autodep' => 'CCAS',
885                    'flags' => ['CCASFLAGS', 'CPPFLAGS'],
886                    'compile' => "\$(CCAS) @cpplike_flags \$(AM_CCASFLAGS) \$(CCASFLAGS)",
887                    'ccer' => 'CPPAS',
888                    'compiler' => 'CPPASCOMPILE',
889                    'libtool_tag' => 'CC',
890                    'compile_flag' => '-c',
891                    'output_flag' => '-o',
892                    'extensions' => ['.S', '.sx']);
894 # Fortran 77
895 register_language ('name' => 'f77',
896                    'Name' => 'Fortran 77',
897                    'config_vars' => ['F77'],
898                    'linker' => 'F77LINK',
899                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
900                    'flags' => ['FFLAGS'],
901                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS)',
902                    'ccer' => 'F77',
903                    'compiler' => 'F77COMPILE',
904                    'compile_flag' => '-c',
905                    'output_flag' => '-o',
906                    'libtool_tag' => 'F77',
907                    'lder' => 'F77LD',
908                    'ld' => '$(F77)',
909                    'pure' => 1,
910                    'extensions' => ['.f', '.for']);
912 # Fortran
913 register_language ('name' => 'fc',
914                    'Name' => 'Fortran',
915                    'config_vars' => ['FC'],
916                    'linker' => 'FCLINK',
917                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
918                    'flags' => ['FCFLAGS'],
919                    'compile' => '$(FC) $(AM_FCFLAGS) $(FCFLAGS)',
920                    'ccer' => 'FC',
921                    'compiler' => 'FCCOMPILE',
922                    'compile_flag' => '-c',
923                    'output_flag' => '-o',
924                    'libtool_tag' => 'FC',
925                    'lder' => 'FCLD',
926                    'ld' => '$(FC)',
927                    'pure' => 1,
928                    'extensions' => ['.f90', '.f95', '.f03', '.f08']);
930 # Preprocessed Fortran
931 register_language ('name' => 'ppfc',
932                    'Name' => 'Preprocessed Fortran',
933                    'config_vars' => ['FC'],
934                    'linker' => 'FCLINK',
935                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
936                    'lder' => 'FCLD',
937                    'ld' => '$(FC)',
938                    'flags' => ['FCFLAGS', 'CPPFLAGS'],
939                    'ccer' => 'PPFC',
940                    'compiler' => 'PPFCCOMPILE',
941                    'compile' => "\$(FC) @cpplike_flags \$(AM_FCFLAGS) \$(FCFLAGS)",
942                    'compile_flag' => '-c',
943                    'output_flag' => '-o',
944                    'libtool_tag' => 'FC',
945                    'pure' => 1,
946                    'extensions' => ['.F90','.F95', '.F03', '.F08']);
948 # Preprocessed Fortran 77
950 # The current support for preprocessing Fortran 77 just involves
951 # passing "$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS)
952 # $(CPPFLAGS)" as additional flags to the Fortran 77 compiler, since
953 # this is how GNU Make does it; see the "GNU Make Manual, Edition 0.51
954 # for 'make' Version 3.76 Beta" (specifically, from info file
955 # '(make)Catalogue of Rules').
957 # A better approach would be to write an Autoconf test
958 # (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
959 # Fortran 77 compilers know how to do preprocessing.  The Autoconf
960 # macro AC_PROG_FPP should test the Fortran 77 compiler first for
961 # preprocessing capabilities, and then fall back on cpp (if cpp were
962 # available).
963 register_language ('name' => 'ppf77',
964                    'Name' => 'Preprocessed Fortran 77',
965                    'config_vars' => ['F77'],
966                    'linker' => 'F77LINK',
967                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
968                    'lder' => 'F77LD',
969                    'ld' => '$(F77)',
970                    'flags' => ['FFLAGS', 'CPPFLAGS'],
971                    'ccer' => 'PPF77',
972                    'compiler' => 'PPF77COMPILE',
973                    'compile' => "\$(F77) @cpplike_flags \$(AM_FFLAGS) \$(FFLAGS)",
974                    'compile_flag' => '-c',
975                    'output_flag' => '-o',
976                    'libtool_tag' => 'F77',
977                    'pure' => 1,
978                    'extensions' => ['.F']);
980 # Ratfor.
981 register_language ('name' => 'ratfor',
982                    'Name' => 'Ratfor',
983                    'config_vars' => ['F77'],
984                    'linker' => 'F77LINK',
985                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
986                    'lder' => 'F77LD',
987                    'ld' => '$(F77)',
988                    'flags' => ['RFLAGS', 'FFLAGS'],
989                    # FIXME also FFLAGS.
990                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS) $(AM_RFLAGS) $(RFLAGS)',
991                    'ccer' => 'F77',
992                    'compiler' => 'RCOMPILE',
993                    'compile_flag' => '-c',
994                    'output_flag' => '-o',
995                    'libtool_tag' => 'F77',
996                    'pure' => 1,
997                    'extensions' => ['.r']);
999 # Java via gcj.
1000 register_language ('name' => 'java',
1001                    'Name' => 'Java',
1002                    'config_vars' => ['GCJ'],
1003                    'linker' => 'GCJLINK',
1004                    'link' => '$(GCJLD) $(AM_GCJFLAGS) $(GCJFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1005                    'autodep' => 'GCJ',
1006                    'flags' => ['GCJFLAGS'],
1007                    'compile' => '$(GCJ) $(AM_GCJFLAGS) $(GCJFLAGS)',
1008                    'ccer' => 'GCJ',
1009                    'compiler' => 'GCJCOMPILE',
1010                    'compile_flag' => '-c',
1011                    'output_flag' => '-o',
1012                    'libtool_tag' => 'GCJ',
1013                    'lder' => 'GCJLD',
1014                    'ld' => '$(GCJ)',
1015                    'pure' => 1,
1016                    'extensions' => ['.java', '.class', '.zip', '.jar']);
1018 ################################################################
1020 # Error reporting functions.
1022 # err_am ($MESSAGE, [%OPTIONS])
1023 # -----------------------------
1024 # Uncategorized errors about the current Makefile.am.
1025 sub err_am
1027   msg_am ('error', @_);
1030 # err_ac ($MESSAGE, [%OPTIONS])
1031 # -----------------------------
1032 # Uncategorized errors about configure.ac.
1033 sub err_ac
1035   msg_ac ('error', @_);
1038 # msg_am ($CHANNEL, $MESSAGE, [%OPTIONS])
1039 # ---------------------------------------
1040 # Messages about about the current Makefile.am.
1041 sub msg_am
1043   my ($channel, $msg, %opts) = @_;
1044   msg $channel, "${am_file}.am", $msg, %opts;
1047 # msg_ac ($CHANNEL, $MESSAGE, [%OPTIONS])
1048 # ---------------------------------------
1049 # Messages about about configure.ac.
1050 sub msg_ac
1052   my ($channel, $msg, %opts) = @_;
1053   msg $channel, $configure_ac, $msg, %opts;
1056 ################################################################
1058 # subst ($TEXT)
1059 # -------------
1060 # Return a configure-style substitution using the indicated text.
1061 # We do this to avoid having the substitutions directly in automake.in;
1062 # when we do that they are sometimes removed and this causes confusion
1063 # and bugs.
1064 sub subst
1066     my ($text) = @_;
1067     return '@' . $text . '@';
1070 ################################################################
1073 # $BACKPATH
1074 # backname ($RELDIR)
1075 # -------------------
1076 # If I "cd $RELDIR", then to come back, I should "cd $BACKPATH".
1077 # For instance 'src/foo' => '../..'.
1078 # Works with non strictly increasing paths, i.e., 'src/../lib' => '..'.
1079 sub backname
1081     my ($file) = @_;
1082     my @res;
1083     foreach (split (/\//, $file))
1084     {
1085         next if $_ eq '.' || $_ eq '';
1086         if ($_ eq '..')
1087         {
1088             pop @res
1089               or prog_error ("trying to reverse path '$file' pointing outside tree");
1090         }
1091         else
1092         {
1093             push (@res, '..');
1094         }
1095     }
1096     return join ('/', @res) || '.';
1099 ################################################################
1101 # Silent rules handling functions.
1103 # verbose_var (NAME)
1104 # ------------------
1105 # The public variable stem used to implement silent rules.
1106 sub verbose_var
1108     my ($name) = @_;
1109     return 'AM_V_' . $name;
1112 # verbose_private_var (NAME)
1113 # --------------------------
1114 # The naming policy for the private variables for silent rules.
1115 sub verbose_private_var
1117     my ($name) = @_;
1118     return 'am__v_' . $name;
1121 # define_verbose_var (NAME, VAL-IF-SILENT, [VAL-IF-VERBOSE])
1122 # ----------------------------------------------------------
1123 # For  silent rules, setup VAR and dispatcher, to expand to
1124 # VAL-IF-SILENT if silent, to VAL-IF-VERBOSE (defaulting to
1125 # empty) if not.
1126 sub define_verbose_var
1128     my ($name, $silent_val, $verbose_val) = @_;
1129     $verbose_val = '' unless defined $verbose_val;
1130     my $var = verbose_var ($name);
1131     my $pvar = verbose_private_var ($name);
1132     my $silent_var = $pvar . '_0';
1133     my $verbose_var = $pvar . '_1';
1134     # For typical 'make's, 'configure' replaces AM_V (inside @@) with $(V)
1135     # and AM_DEFAULT_V (inside @@) with $(AM_DEFAULT_VERBOSITY).
1136     # For strict POSIX 2008 'make's, it replaces them with 0 or 1 instead.
1137     # See AM_SILENT_RULES in m4/silent.m4.
1138     define_variable ($var, '$(' . $pvar . '_@'.'AM_V'.'@)', INTERNAL);
1139     define_variable ($pvar . '_', '$(' . $pvar . '_@'.'AM_DEFAULT_V'.'@)',
1140                      INTERNAL);
1141     Automake::Variable::define ($silent_var, VAR_AUTOMAKE, '', TRUE,
1142                                 $silent_val, '', INTERNAL, VAR_ASIS)
1143       if (! vardef ($silent_var, TRUE));
1144     Automake::Variable::define ($verbose_var, VAR_AUTOMAKE, '', TRUE,
1145                                 $verbose_val, '', INTERNAL, VAR_ASIS)
1146       if (! vardef ($verbose_var, TRUE));
1149 # verbose_flag (NAME)
1150 # -------------------
1151 # Contents of '%VERBOSE%' variable to expand before rule command.
1152 sub verbose_flag
1154     my ($name) = @_;
1155     return '$(' . verbose_var ($name) . ')';
1158 sub verbose_nodep_flag
1160     my ($name) = @_;
1161     return '$(' . verbose_var ($name) . subst ('am__nodep') . ')';
1164 # silent_flag
1165 # -----------
1166 # Contents of %SILENT%: variable to expand to '@' when silent.
1167 sub silent_flag ()
1169     return verbose_flag ('at');
1172 # define_verbose_tagvar (NAME)
1173 # ----------------------------
1174 # Engage the needed silent rules machinery for tag NAME.
1175 sub define_verbose_tagvar
1177     my ($name) = @_;
1178     define_verbose_var ($name, '@echo "  '. $name . ' ' x (8 - length ($name)) . '" $@;');
1181 # Engage the needed silent rules machinery for assorted texinfo commands.
1182 sub define_verbose_texinfo ()
1184   my @tagvars = ('DVIPS', 'MAKEINFO', 'INFOHTML', 'TEXI2DVI', 'TEXI2PDF');
1185   foreach my $tag (@tagvars)
1186     {
1187       define_verbose_tagvar($tag);
1188     }
1189   define_verbose_var('texinfo', '-q');
1190   define_verbose_var('texidevnull', '> /dev/null');
1193 # Engage the needed silent rules machinery for 'libtool --silent'.
1194 sub define_verbose_libtool ()
1196     define_verbose_var ('lt', '--silent');
1197     return verbose_flag ('lt');
1200 sub handle_silent ()
1202     # Define "$(AM_V_P)", expanding to a shell conditional that can be
1203     # used in make recipes to determine whether we are being run in
1204     # silent mode or not.  The choice of the name derives from the LISP
1205     # convention of appending the letter 'P' to denote a predicate (see
1206     # also "the '-P' convention" in the Jargon File); we do so for lack
1207     # of a better convention.
1208     define_verbose_var ('P', 'false', ':');
1209     # *Always* provide the user with '$(AM_V_GEN)', unconditionally.
1210     define_verbose_tagvar ('GEN');
1211     define_verbose_var ('at', '@');
1215 ################################################################
1218 # Handle AUTOMAKE_OPTIONS variable.  Return 0 on error, 1 otherwise.
1219 sub handle_options ()
1221   my $var = var ('AUTOMAKE_OPTIONS');
1222   if ($var)
1223     {
1224       if ($var->has_conditional_contents)
1225         {
1226           msg_var ('unsupported', $var,
1227                    "'AUTOMAKE_OPTIONS' cannot have conditional contents");
1228         }
1229       my @options = map { { option => $_->[1], where => $_->[0] } }
1230                         $var->value_as_list_recursive (cond_filter => TRUE,
1231                                                        location => 1);
1232       return 0 unless process_option_list (@options);
1233     }
1235   if ($strictness == GNITS)
1236     {
1237       set_option ('readme-alpha', INTERNAL);
1238       set_option ('std-options', INTERNAL);
1239       set_option ('check-news', INTERNAL);
1240     }
1242   return 1;
1245 # shadow_unconditionally ($varname, $where)
1246 # -----------------------------------------
1247 # Return a $(variable) that contains all possible values
1248 # $varname can take.
1249 # If the VAR wasn't defined conditionally, return $(VAR).
1250 # Otherwise we create an am__VAR_DIST variable which contains
1251 # all possible values, and return $(am__VAR_DIST).
1252 sub shadow_unconditionally
1254   my ($varname, $where) = @_;
1255   my $var = var $varname;
1256   if ($var->has_conditional_contents)
1257     {
1258       $varname = "am__${varname}_DIST";
1259       my @files = uniq ($var->value_as_list_recursive);
1260       define_pretty_variable ($varname, TRUE, $where, @files);
1261     }
1262   return "\$($varname)"
1265 # check_user_variables (@LIST)
1266 # ----------------------------
1267 # Make sure each variable VAR in @LIST does not exist, suggest using AM_VAR
1268 # otherwise.
1269 sub check_user_variables
1271   my @dont_override = @_;
1272   foreach my $flag (@dont_override)
1273     {
1274       my $var = var $flag;
1275       if ($var)
1276         {
1277           for my $cond ($var->conditions->conds)
1278             {
1279               if ($var->rdef ($cond)->owner == VAR_MAKEFILE)
1280                 {
1281                   msg_cond_var ('gnu', $cond, $flag,
1282                                 "'$flag' is a user variable, "
1283                                 . "you should not override it;\n"
1284                                 . "use 'AM_$flag' instead");
1285                 }
1286             }
1287         }
1288     }
1291 # Call finish function for each language that was used.
1292 sub handle_languages ()
1294     if (! option 'no-dependencies')
1295       {
1296         # Include auto-dep code.  Don't include it if DEP_FILES would
1297         # be empty.
1298         if (keys %extension_seen && keys %dep_files)
1299           {
1300             my @dep_files = sort keys %dep_files;
1301             # Set location of depcomp.
1302             define_variable ('depcomp',
1303                              "\$(SHELL) $am_config_aux_dir/depcomp",
1304                              INTERNAL);
1305             define_variable ('am__maybe_remake_depfiles', 'depfiles', INTERNAL);
1306             define_variable ('am__depfiles_remade', "@dep_files", INTERNAL);
1307             $output_rules .= "\n";
1308             my @dist_rms;
1309             foreach my $depfile (@dep_files)
1310               {
1311                 push @dist_rms, "\t-rm -f $depfile";
1312                 # Generate each 'include' directive individually.  Several
1313                 # make implementations (IRIX 6, Solaris 10, FreeBSD 8) will
1314                 # fail to properly include several files resulting from a
1315                 # variable expansion. Just Generating many separate includes
1316                 # seems thus safest.
1317                 $output_rules .= subst ('AMDEP_TRUE') .
1318                                  subst ('am__include') .
1319                                  " " .
1320                                  subst('am__quote') .
1321                                  $depfile .
1322                                  subst('am__quote') .
1323                                  " " .
1324                                  "# am--include-marker\n";
1325               }
1327             require_conf_file ("$am_file.am", FOREIGN, 'depcomp');
1329             $output_rules .= file_contents (
1330                 'depend', new Automake::Location,
1331                 'DISTRMS' => join ("\n", @dist_rms));
1332           }
1333       }
1334     else
1335       {
1336         define_variable ('depcomp', '', INTERNAL);
1337         define_variable ('am__maybe_remake_depfiles', '', INTERNAL);
1338       }
1340     my %done;
1342     # Is the C linker needed?
1343     my $needs_c = 0;
1344     foreach my $ext (sort keys %extension_seen)
1345     {
1346         next unless $extension_map{$ext};
1348         my $lang = $languages{$extension_map{$ext}};
1350         my $rule_file = $lang->rule_file || 'depend2';
1352         # Get information on $LANG.
1353         my $pfx = $lang->autodep;
1354         my $fpfx = ($pfx eq '') ? 'CC' : $pfx;
1356         my ($AMDEP, $FASTDEP) =
1357           (option 'no-dependencies' || $lang->autodep eq 'no')
1358           ? ('FALSE', 'FALSE') : ('AMDEP', "am__fastdep$fpfx");
1360         my $verbose = verbose_flag ($lang->ccer || 'GEN');
1361         my $verbose_nodep = ($AMDEP eq 'FALSE')
1362           ? $verbose : verbose_nodep_flag ($lang->ccer || 'GEN');
1363         my $silent = silent_flag ();
1365         my %transform = ('EXT'     => $ext,
1366                          'PFX'     => $pfx,
1367                          'FPFX'    => $fpfx,
1368                          'AMDEP'   => $AMDEP,
1369                          'FASTDEP' => $FASTDEP,
1370                          '-c'      => $lang->compile_flag || '',
1371                          # These are not used, but they need to be defined
1372                          # so transform() do not complain.
1373                          SUBDIROBJ     => 0,
1374                          'DERIVED-EXT' => 'BUG',
1375                          DIST_SOURCE   => 1,
1376                          VERBOSE   => $verbose,
1377                          'VERBOSE-NODEP' => $verbose_nodep,
1378                          SILENT    => $silent,
1379                         );
1381         # Generate the appropriate rules for this extension.
1382         if (((! option 'no-dependencies') && $lang->autodep ne 'no')
1383             || defined $lang->compile)
1384         {
1385             # Compute a possible derived extension.
1386             # This is not used by depend2.am.
1387             my $der_ext = ($lang->output_extensions->($ext))[0];
1389             # When we output an inference rule like '.c.o:' we
1390             # have two cases to consider: either subdir-objects
1391             # is used, or it is not.
1392             #
1393             # In the latter case the rule is used to build objects
1394             # in the current directory, and dependencies always
1395             # go into './$(DEPDIR)/'.  We can hard-code this value.
1396             #
1397             # In the former case the rule can be used to build
1398             # objects in sub-directories too.  Dependencies should
1399             # go into the appropriate sub-directories, e.g.,
1400             # 'sub/$(DEPDIR)/'.  The value of this directory
1401             # needs to be computed on-the-fly.
1402             #
1403             # DEPBASE holds the name of this directory, plus the
1404             # basename part of the object file (extensions Po, TPo,
1405             # Plo, TPlo will be added later as appropriate).  It is
1406             # either hardcoded, or a shell variable ('$depbase') that
1407             # will be computed by the rule.
1408             my $depbase =
1409               option ('subdir-objects') ? '$$depbase' : '$(DEPDIR)/$*';
1410             $output_rules .=
1411               file_contents ($rule_file,
1412                              new Automake::Location,
1413                              %transform,
1414                              GENERIC   => 1,
1416                              'DERIVED-EXT' => $der_ext,
1418                              DEPBASE   => $depbase,
1419                              BASE      => '$*',
1420                              SOURCE    => '$<',
1421                              SOURCEFLAG => $sourceflags{$ext} || '',
1422                              OBJ       => '$@',
1423                              OBJOBJ    => '$@',
1424                              LTOBJ     => '$@',
1426                              COMPILE   => '$(' . $lang->compiler . ')',
1427                              LTCOMPILE => '$(LT' . $lang->compiler . ')',
1428                              -o        => $lang->output_flag,
1429                              SUBDIROBJ => !! option 'subdir-objects');
1430         }
1432         # Now include code for each specially handled object with this
1433         # language.
1434         my %seen_files = ();
1435         foreach my $file (@{$lang_specific_files{$lang->name}})
1436         {
1437             my ($derived, $source, $obj, $myext, $srcext, %file_transform) = @$file;
1439             # We might see a given object twice, for instance if it is
1440             # used under different conditions.
1441             next if defined $seen_files{$obj};
1442             $seen_files{$obj} = 1;
1444             prog_error ("found " . $lang->name .
1445                         " in handle_languages, but compiler not defined")
1446               unless defined $lang->compile;
1448             my $obj_compile = $lang->compile;
1450             # Rewrite each occurrence of 'AM_$flag' in the compile
1451             # rule into '${derived}_$flag' if it exists.
1452             for my $flag (@{$lang->flags})
1453               {
1454                 my $val = "${derived}_$flag";
1455                 $obj_compile =~ s/\(AM_$flag\)/\($val\)/
1456                   if set_seen ($val);
1457               }
1459             my $libtool_tag = '';
1460             if ($lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag})
1461               {
1462                 $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
1463               }
1465             my $ptltflags = "${derived}_LIBTOOLFLAGS";
1466             $ptltflags = 'AM_LIBTOOLFLAGS' unless set_seen $ptltflags;
1468             my $ltverbose = define_verbose_libtool ();
1469             my $obj_ltcompile =
1470               "\$(LIBTOOL) $ltverbose $libtool_tag\$($ptltflags) \$(LIBTOOLFLAGS) "
1471               . "--mode=compile $obj_compile";
1473             # We _need_ '-o' for per object rules.
1474             my $output_flag = $lang->output_flag || '-o';
1476             my $depbase = dirname ($obj);
1477             $depbase = ''
1478                 if $depbase eq '.';
1479             $depbase .= '/'
1480                 unless $depbase eq '';
1481             $depbase .= '$(DEPDIR)/' . basename ($obj);
1483             $output_rules .=
1484               file_contents ($rule_file,
1485                              new Automake::Location,
1486                              %transform,
1487                              GENERIC   => 0,
1489                              DEPBASE   => $depbase,
1490                              BASE      => $obj,
1491                              SOURCE    => $source,
1492                              SOURCEFLAG => $sourceflags{$srcext} || '',
1493                              # Use $myext and not '.o' here, in case
1494                              # we are actually building a new source
1495                              # file -- e.g. via yacc.
1496                              OBJ       => "$obj$myext",
1497                              OBJOBJ    => "$obj.obj",
1498                              LTOBJ     => "$obj.lo",
1500                              VERBOSE   => $verbose,
1501                              'VERBOSE-NODEP'  => $verbose_nodep,
1502                              SILENT    => $silent,
1503                              COMPILE   => $obj_compile,
1504                              LTCOMPILE => $obj_ltcompile,
1505                              -o        => $output_flag,
1506                              %file_transform);
1507         }
1509         # The rest of the loop is done once per language.
1510         next if defined $done{$lang};
1511         $done{$lang} = 1;
1513         # Load the language dependent Makefile chunks.
1514         my %lang = map { uc ($_) => 0 } keys %languages;
1515         $lang{uc ($lang->name)} = 1;
1516         $output_rules .= file_contents ('lang-compile',
1517                                         new Automake::Location,
1518                                         %transform, %lang);
1520         # If the source to a program consists entirely of code from a
1521         # 'pure' language, for instance C++ or Fortran 77, then we
1522         # don't need the C compiler code.  However if we run into
1523         # something unusual then we do generate the C code.  There are
1524         # probably corner cases here that do not work properly.
1525         # People linking Java code to Fortran code deserve pain.
1526         $needs_c ||= ! $lang->pure;
1528         define_compiler_variable ($lang)
1529           if ($lang->compile);
1531         define_linker_variable ($lang)
1532           if ($lang->link);
1534         require_variables ("$am_file.am", $lang->Name . " source seen",
1535                            TRUE, @{$lang->config_vars});
1537         # Call the finisher.
1538         $lang->finish;
1540         # Flags listed in '->flags' are user variables (per GNU Standards),
1541         # they should not be overridden in the Makefile...
1542         my @dont_override = @{$lang->flags};
1543         # ... and so is LDFLAGS.
1544         push @dont_override, 'LDFLAGS' if $lang->link;
1546         check_user_variables @dont_override;
1547     }
1549     # If the project is entirely C++ or entirely Fortran 77 (i.e., 1
1550     # suffix rule was learned), don't bother with the C stuff.  But if
1551     # anything else creeps in, then use it.
1552     my @languages_seen = map { $languages{$extension_map{$_}}->name }
1553                              (keys %extension_seen);
1554     @languages_seen = uniq (@languages_seen);
1555     $needs_c = 1 if @languages_seen > 1;
1556     if ($need_link || $needs_c)
1557       {
1558         define_compiler_variable ($languages{'c'})
1559           unless defined $done{$languages{'c'}};
1560         define_linker_variable ($languages{'c'});
1561       }
1565 # append_exeext { PREDICATE } $MACRO
1566 # ----------------------------------
1567 # Append $(EXEEXT) to each filename in $F appearing in the Makefile
1568 # variable $MACRO if &PREDICATE($F) is true.  @substitutions@ are
1569 # ignored.
1571 # This is typically used on all filenames of *_PROGRAMS, and filenames
1572 # of TESTS that are programs.
1573 sub append_exeext (&$)
1575   my ($pred, $macro) = @_;
1577   transform_variable_recursively
1578     ($macro, $macro, 'am__EXEEXT', 0, INTERNAL,
1579      sub {
1580        my ($subvar, $val, $cond, $full_cond) = @_;
1581        # Append $(EXEEXT) unless the user did it already, or it's a
1582        # @substitution@.
1583        $val .= '$(EXEEXT)'
1584          if $val !~ /(?:\$\(EXEEXT\)$|^[@]\w+[@]$)/ && &$pred ($val);
1585        return $val;
1586      });
1590 # Check to make sure a source defined in LIBOBJS is not explicitly
1591 # mentioned.  This is a separate function (as opposed to being inlined
1592 # in handle_source_transform) because it isn't always appropriate to
1593 # do this check.
1594 sub check_libobjs_sources
1596   my ($one_file, $unxformed) = @_;
1598   foreach my $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
1599                       'dist_EXTRA_', 'nodist_EXTRA_')
1600     {
1601       my @files;
1602       my $varname = $prefix . $one_file . '_SOURCES';
1603       my $var = var ($varname);
1604       if ($var)
1605         {
1606           @files = $var->value_as_list_recursive;
1607         }
1608       elsif ($prefix eq '')
1609         {
1610           @files = ($unxformed . '.c');
1611         }
1612       else
1613         {
1614           next;
1615         }
1617       foreach my $file (@files)
1618         {
1619           err_var ($prefix . $one_file . '_SOURCES',
1620                    "automatically discovered file '$file' should not" .
1621                    " be explicitly mentioned")
1622             if defined $libsources{$file};
1623         }
1624     }
1628 # @OBJECTS
1629 # handle_single_transform ($VAR, $TOPPARENT, $DERIVED, $OBJ, $FILE, %TRANSFORM)
1630 # -----------------------------------------------------------------------------
1631 # Does much of the actual work for handle_source_transform.
1632 # Arguments are:
1633 #   $VAR is the name of the variable that the source filenames come from
1634 #   $TOPPARENT is the name of the _SOURCES variable which is being processed
1635 #   $DERIVED is the name of resulting executable or library
1636 #   $OBJ is the object extension (e.g., '.lo')
1637 #   $FILE the source file to transform
1638 #   %TRANSFORM contains extras arguments to pass to file_contents
1639 #     when producing explicit rules
1640 # Result is a list of the names of objects
1641 # %linkers_used will be updated with any linkers needed
1642 sub handle_single_transform
1644     my ($var, $topparent, $derived, $obj, $_file, %transform) = @_;
1645     my @files = ($_file);
1646     my @result = ();
1648     # Turn sources into objects.  We use a while loop like this
1649     # because we might add to @files in the loop.
1650     while (scalar @files > 0)
1651     {
1652         $_ = shift @files;
1654         # Configure substitutions in _SOURCES variables are errors.
1655         if (/^\@.*\@$/)
1656         {
1657           my $parent_msg = '';
1658           $parent_msg = "\nand is referred to from '$topparent'"
1659             if $topparent ne $var->name;
1660           err_var ($var,
1661                    "'" . $var->name . "' includes configure substitution '$_'"
1662                    . $parent_msg . ";\nconfigure " .
1663                    "substitutions are not allowed in _SOURCES variables");
1664           next;
1665         }
1667         # If the source file is in a subdirectory then the '.o' is put
1668         # into the current directory, unless the subdir-objects option
1669         # is in effect.
1671         # Split file name into base and extension.
1672         next if ! /^(?:(.*)\/)?([^\/]*)($KNOWN_EXTENSIONS_PATTERN)$/;
1673         my $full = $_;
1674         my $directory = $1 || '';
1675         my $base = $2;
1676         my $extension = $3;
1678         # We must generate a rule for the object if it requires its own flags.
1679         my $renamed = 0;
1680         my ($linker, $object);
1682         # This records whether we've seen a derived source file (e.g., yacc
1683         # or lex output).
1684         my $derived_source;
1686         # This holds the 'aggregate context' of the file we are
1687         # currently examining.  If the file is compiled with
1688         # per-object flags, then it will be the name of the object.
1689         # Otherwise it will be 'AM'.  This is used by the target hook
1690         # language function.
1691         my $aggregate = 'AM';
1693         $extension = derive_suffix ($extension, $obj);
1694         my $lang;
1695         if ($extension_map{$extension} &&
1696             ($lang = $languages{$extension_map{$extension}}))
1697         {
1698             # Found the language, so see what it says.
1699             saw_extension ($extension);
1701             # Do we have per-executable flags for this executable?
1702             my $have_per_exec_flags = 0;
1703             my @peflags = @{$lang->flags};
1704             push @peflags, 'LIBTOOLFLAGS' if $obj eq '.lo';
1705             foreach my $flag (@peflags)
1706               {
1707                 if (set_seen ("${derived}_$flag"))
1708                   {
1709                     $have_per_exec_flags = 1;
1710                     last;
1711                   }
1712               }
1714             # Note: computed subr call.  The language rewrite function
1715             # should return one of the LANG_* constants.  It could
1716             # also return a list whose first value is such a constant
1717             # and whose second value is a new source extension which
1718             # should be applied.  This means this particular language
1719             # generates another source file which we must then process
1720             # further.
1721             my $subr = \&{'lang_' . $lang->name . '_rewrite'};
1722             defined &$subr or $subr = \&lang_sub_obj;
1723             my ($r, $source_extension)
1724                 = &$subr ($directory, $base, $extension,
1725                           $obj, $have_per_exec_flags, $var);
1726             # Skip this entry if we were asked not to process it.
1727             next if $r == LANG_IGNORE;
1729             # Now extract linker and other info.
1730             $linker = $lang->linker;
1732             my $this_obj_ext;
1733             if (defined $source_extension)
1734               {
1735                 $this_obj_ext = $source_extension;
1736                 $derived_source = 1;
1737               }
1738             else
1739               {
1740                 $this_obj_ext = $obj;
1741                 $derived_source = 0;
1742                 # Don't ever place built object files in $(srcdir),
1743                 # even when sources are specified explicitly as (say)
1744                 # '$(srcdir)/foo.c' or '$(top_srcdir)/foo.c'.
1745                 # See automake bug#13928.
1746                 my @d = split '/', $directory;
1747                 if (@d > 0 && option 'subdir-objects')
1748                   {
1749                     my $d = $d[0];
1750                     if ($d eq '$(srcdir)' or $d eq '${srcdir}')
1751                       {
1752                         shift @d;
1753                       }
1754                     elsif ($d eq '$(top_srcdir)' or $d eq '${top_srcdir}')
1755                       {
1756                         $d[0] = '$(top_builddir)';
1757                       }
1758                     $directory = join '/', @d;
1759                   }
1760               }
1761             $object = $base . $this_obj_ext;
1763             if ($have_per_exec_flags)
1764             {
1765                 # We have a per-executable flag in effect for this
1766                 # object.  In this case we rewrite the object's
1767                 # name to ensure it is unique.
1769                 # We choose the name 'DERIVED_OBJECT' to ensure (1) uniqueness,
1770                 # and (2) continuity between invocations.  However, this will
1771                 # result in a name that is too long for losing systems, in some
1772                 # situations.  So we attempt to shorten automatically under
1773                 # subdir-objects, and provide _SHORTNAME to override as a last
1774                 # resort.  If subdir-object is in effect, it's usually
1775                 # unnecessary to use the complete 'DERIVED_OBJECT' (that is
1776                 # often the result from %canon_reldir%/%C% usage) since objects
1777                 # are placed next to their source file.  Generally, this means
1778                 # it is already unique within that directory (see below for an
1779                 # exception).  Thus, we try to avoid unnecessarily long file
1780                 # names by stripping the directory components of
1781                 # 'DERIVED_OBJECT'.  This allows avoiding explicit _SHORTNAME
1782                 # usage in many cases.  EXCEPTION: If two (or more) targets in
1783                 # different directories but with the same base name (after
1784                 # canonicalization), using target-specific FLAGS, link the same
1785                 # object, then this logic clashes.  Thus, we don't strip if
1786                 # this is detected.
1787                 my $dname = $derived;
1788                 if ($directory ne ''
1789                     && option 'subdir-objects'
1790                     && none { $dname =~ /$_[0]$/ } @dup_shortnames)
1791                   {
1792                     # At this point, we don't clear information about what
1793                     # parts of $derived are truly file name components.  We can
1794                     # determine that by comparing against the canonicalization
1795                     # of $directory.
1796                     my $dir = $directory . "/";
1797                     my $cdir = canonicalize ($dir);
1798                     my $dir_len = length ($dir);
1799                     # Make sure we only strip full file name components.  This
1800                     # is done by repeatedly trying to find cdir at the
1801                     # beginning.  Each iteration removes one file name
1802                     # component from the end of cdir.
1803                     while ($dir_len > 0 && index ($derived, $cdir) != 0)
1804                       {
1805                         # Eventually $dir_len becomes 0.
1806                         $dir_len = rindex ($dir, "/", $dir_len - 2) + 1;
1807                         $cdir = substr ($cdir, 0, $dir_len);
1808                       }
1809                     $dname = substr ($derived, $dir_len);
1810                   }
1811                 my $var = var ($derived . '_SHORTNAME');
1812                 if ($var)
1813                 {
1814                     # FIXME: should use the same Condition as
1815                     # the _SOURCES variable.  But this is really
1816                     # silly overkill -- nobody should have
1817                     # conditional shortnames.
1818                     $dname = $var->variable_value;
1819                 }
1820                 $object = $dname . '-' . $object;
1822                 prog_error ($lang->name . " flags defined without compiler")
1823                   if ! defined $lang->compile;
1825                 $renamed = 1;
1826             }
1828             # If rewrite said it was ok, put the object into a subdir.
1829             if ($directory ne '')
1830             {
1831               if ($r == LANG_SUBDIR)
1832                 {
1833                   $object = $directory . '/' . $object;
1834                 }
1835               else
1836                 {
1837                   # Since the next major version of automake (2.0) will
1838                   # make the behaviour so far only activated with the
1839                   # 'subdir-object' option mandatory, it's better if we
1840                   # start warning users not using that option.
1841                   # As suggested by Peter Johansson, we strive to avoid
1842                   # the warning when it would be irrelevant, i.e., if
1843                   # all source files sit in "current" directory.
1844                   msg_var 'unsupported', $var,
1845                           "source file '$full' is in a subdirectory,"
1846                           . "\nbut option 'subdir-objects' is disabled";
1847                   msg 'unsupported', INTERNAL, <<'EOF', uniq_scope => US_GLOBAL;
1848 possible forward-incompatibility.
1849 At least a source file is in a subdirectory, but the 'subdir-objects'
1850 automake option hasn't been enabled.  For now, the corresponding output
1851 object file(s) will be placed in the top-level directory.  However,
1852 this behaviour will change in future Automake versions: they will
1853 unconditionally cause object files to be placed in the same subdirectory
1854 of the corresponding sources.
1855 You are advised to start using 'subdir-objects' option throughout your
1856 project, to avoid future incompatibilities.
1858                 }
1859             }
1861             # If the object file has been renamed (because per-target
1862             # flags are used) we cannot compile the file with an
1863             # inference rule: we need an explicit rule.
1864             #
1865             # If the source is in a subdirectory and the object is in
1866             # the current directory, we also need an explicit rule.
1867             #
1868             # If both source and object files are in a subdirectory
1869             # (this happens when the subdir-objects option is used),
1870             # then the inference will work.
1871             #
1872             # The latter case deserves a historical note.  When the
1873             # subdir-objects option was added on 1999-04-11 it was
1874             # thought that inferences rules would work for
1875             # subdirectory objects too.  Later, on 1999-11-22,
1876             # automake was changed to output explicit rules even for
1877             # subdir-objects.  Nobody remembers why, but this occurred
1878             # soon after the merge of the user-dep-gen-branch so it
1879             # might be related.  In late 2003 people complained about
1880             # the size of the generated Makefile.ins (libgcj, with
1881             # 2200+ subdir objects was reported to have a 9MB
1882             # Makefile), so we now rely on inference rules again.
1883             # Maybe we'll run across the same issue as in the past,
1884             # but at least this time we can document it.  However since
1885             # dependency tracking has evolved it is possible that
1886             # our old problem no longer exists.
1887             # Using inference rules for subdir-objects has been tested
1888             # with GNU make, Solaris make, Ultrix make, BSD make,
1889             # HP-UX make, and OSF1 make successfully.
1890             if ($renamed
1891                 || ($directory ne '' && ! option 'subdir-objects')
1892                 # We must also use specific rules for a nodist_ source
1893                 # if its language requests it.
1894                 || ($lang->nodist_specific && ! $transform{'DIST_SOURCE'}))
1895             {
1896                 my $obj_sans_ext = substr ($object, 0,
1897                                            - length ($this_obj_ext));
1898                 my $full_ansi;
1899                 if ($directory ne '')
1900                   {
1901                         $full_ansi = $directory . '/' . $base . $extension;
1902                   }
1903                 else
1904                   {
1905                         $full_ansi = $base . $extension;
1906                   }
1908                 my @specifics = ($full_ansi, $obj_sans_ext,
1909                                  # Only use $this_obj_ext in the derived
1910                                  # source case because in the other case we
1911                                  # *don't* want $(OBJEXT) to appear here.
1912                                  ($derived_source ? $this_obj_ext : '.o'),
1913                                  $extension);
1915                 # If we renamed the object then we want to use the
1916                 # per-executable flag name.  But if this is simply a
1917                 # subdir build then we still want to use the AM_ flag
1918                 # name.
1919                 if ($renamed)
1920                   {
1921                     unshift @specifics, $derived;
1922                     $aggregate = $derived;
1923                   }
1924                 else
1925                   {
1926                     unshift @specifics, 'AM';
1927                   }
1929                 # Each item on this list is a reference to a list consisting
1930                 # of four values followed by additional transform flags for
1931                 # file_contents.  The four values are the derived flag prefix
1932                 # (e.g. for 'foo_CFLAGS', it is 'foo'), the name of the
1933                 # source file, the base name of the output file, and
1934                 # the extension for the object file.
1935                 push (@{$lang_specific_files{$lang->name}},
1936                       [@specifics, %transform]);
1937             }
1938         }
1939         elsif ($extension eq $obj)
1940         {
1941             # This is probably the result of a direct suffix rule.
1942             # In this case we just accept the rewrite.
1943             $object = "$base$extension";
1944             $object = "$directory/$object" if $directory ne '';
1945             $linker = '';
1946         }
1947         else
1948         {
1949             # No error message here.  Used to have one, but it was
1950             # very unpopular.
1951             # FIXME: we could potentially do more processing here,
1952             # perhaps treating the new extension as though it were a
1953             # new source extension (as above).  This would require
1954             # more restructuring than is appropriate right now.
1955             next;
1956         }
1958         err_am "object '$object' created by '$full' and '$object_map{$object}'"
1959           if (defined $object_map{$object}
1960               && $object_map{$object} ne $full);
1962         my $comp_val = (($object =~ /\.lo$/)
1963                         ? COMPILE_LIBTOOL : COMPILE_ORDINARY);
1964         (my $comp_obj = $object) =~ s/\.lo$/.\$(OBJEXT)/;
1965         if (defined $object_compilation_map{$comp_obj}
1966             && $object_compilation_map{$comp_obj} != 0
1967             # Only see the error once.
1968             && ($object_compilation_map{$comp_obj}
1969                 != (COMPILE_LIBTOOL | COMPILE_ORDINARY))
1970             && $object_compilation_map{$comp_obj} != $comp_val)
1971           {
1972             err_am "object '$comp_obj' created both with libtool and without";
1973           }
1974         $object_compilation_map{$comp_obj} |= $comp_val;
1976         if (defined $lang)
1977         {
1978             # Let the language do some special magic if required.
1979             $lang->target_hook ($aggregate, $object, $full, %transform);
1980         }
1982         if ($derived_source)
1983           {
1984             prog_error ($lang->name . " has automatic dependency tracking")
1985               if $lang->autodep ne 'no';
1986             # Make sure this new source file is handled next.  That will
1987             # make it appear to be at the right place in the list.
1988             unshift (@files, $object);
1989             # Distribute derived sources unless the source they are
1990             # derived from is not.
1991             push_dist_common ($object)
1992               unless ($topparent =~ /^(?:nobase_)?nodist_/);
1993             next;
1994           }
1996         $linkers_used{$linker} = 1;
1998         push (@result, $object);
2000         if (! defined $object_map{$object})
2001         {
2002             my @dep_list = ();
2003             $object_map{$object} = $full;
2005             # If resulting object is in subdir, we need to make
2006             # sure the subdir exists at build time.
2007             if ($object =~ /\//)
2008             {
2009                 # FIXME: check that $DIRECTORY is somewhere in the
2010                 # project
2012                 # For Java, the way we're handling it right now, a
2013                 # '..' component doesn't make sense.
2014                 if ($lang && $lang->name eq 'java' && $object =~ /(\/|^)\.\.\//)
2015                   {
2016                     err_am "'$full' should not contain a '..' component";
2017                   }
2019                 # Make sure *all* objects files in the subdirectory are
2020                 # removed by "make mostlyclean".  Not only this is more
2021                 # efficient than listing the object files to be removed
2022                 # individually (which would cause an 'rm' invocation for
2023                 # each of them -- very inefficient, see bug#10697), it
2024                 # would also leave stale object files in the subdirectory
2025                 # whenever a source file there is removed or renamed.
2026                 $compile_clean_files{"$directory/*.\$(OBJEXT)"} = MOSTLY_CLEAN;
2027                 if ($object =~ /\.lo$/)
2028                   {
2029                     # If we have a libtool object, then we also must remove
2030                     # any '.lo' objects in its same subdirectory.
2031                     $compile_clean_files{"$directory/*.lo"} = MOSTLY_CLEAN;
2032                     # Remember to cleanup .libs/ in this directory.
2033                     $libtool_clean_directories{$directory} = 1;
2034                   }
2036                 push (@dep_list, require_build_directory ($directory));
2038                 # If we're generating dependencies, we also want
2039                 # to make sure that the appropriate subdir of the
2040                 # .deps directory is created.
2041                 push (@dep_list,
2042                       require_build_directory ($directory . '/$(DEPDIR)'))
2043                   unless option 'no-dependencies';
2044             }
2046             pretty_print_rule ($object . ':', "\t", @dep_list)
2047                 if scalar @dep_list > 0;
2048         }
2050         # Transform .o or $o file into .P file (for automatic
2051         # dependency code).
2052         # Properly flatten multiple adjacent slashes, as Solaris 10 make
2053         # might fail over them in an include statement.
2054         # Leading double slashes may be special, as per Posix, so deal
2055         # with them carefully.
2056         if ($lang && $lang->autodep ne 'no')
2057         {
2058             my $depfile = $object;
2059             $depfile =~ s/\.([^.]*)$/.P$1/;
2060             $depfile =~ s/\$\(OBJEXT\)$/o/;
2061             my $maybe_extra_leading_slash = '';
2062             $maybe_extra_leading_slash = '/' if $depfile =~ m,^//[^/],;
2063             $depfile =~ s,/+,/,g;
2064             my $basename = basename ($depfile);
2065             # This might make $dirname empty, but we account for that below.
2066             (my $dirname = dirname ($depfile)) =~ s/\/*$//;
2067             $dirname = $maybe_extra_leading_slash . $dirname;
2068             $dep_files{$dirname . '/$(DEPDIR)/' . $basename} = 1;
2069         }
2070     }
2072     return @result;
2076 # $LINKER
2077 # define_objects_from_sources ($VAR, $OBJVAR, $NODEFINE, $ONE_FILE,
2078 #                              $OBJ, $PARENT, $TOPPARENT, $WHERE, %TRANSFORM)
2079 # ---------------------------------------------------------------------------
2080 # Define an _OBJECTS variable for a _SOURCES variable (or subvariable)
2082 # Arguments are:
2083 #   $VAR is the name of the _SOURCES variable
2084 #   $OBJVAR is the name of the _OBJECTS variable if known (otherwise
2085 #     it will be generated and returned).
2086 #   $NODEFINE is a boolean: if true, $OBJVAR will not be defined (but
2087 #     work done to determine the linker will be).
2088 #   $ONE_FILE is the canonical (transformed) name of object to build
2089 #   $OBJ is the object extension (i.e. either '.o' or '.lo').
2090 #   $TOPPARENT is the _SOURCES variable being processed.
2091 #   $WHERE context into which this definition is done
2092 #   %TRANSFORM extra arguments to pass to file_contents when producing
2093 #     rules
2095 # Result is a pair ($LINKER, $OBJVAR):
2096 #    $LINKER is a boolean, true if a linker is needed to deal with the objects
2097 sub define_objects_from_sources
2099   my ($var, $objvar, $nodefine, $one_file,
2100       $obj, $topparent, $where, %transform) = @_;
2102   my $needlinker = "";
2104   transform_variable_recursively
2105     ($var, $objvar, 'am__objects', $nodefine, $where,
2106      # The transform code to run on each filename.
2107      sub {
2108        my ($subvar, $val, $cond, $full_cond) = @_;
2109        my @trans = handle_single_transform ($subvar, $topparent,
2110                                             $one_file, $obj, $val,
2111                                             %transform);
2112        $needlinker = "true" if @trans;
2113        return @trans;
2114      });
2116   return $needlinker;
2120 # handle_source_transform ($CANON_TARGET, $TARGET, $OBJEXT, $WHERE, %TRANSFORM)
2121 # -----------------------------------------------------------------------------
2122 # Handle SOURCE->OBJECT transform for one program or library.
2123 # Arguments are:
2124 #   canonical (transformed) name of target to build
2125 #   actual target of object to build
2126 #   object extension (i.e., either '.o' or '$o')
2127 #   location of the source variable
2128 #   extra arguments to pass to file_contents when producing rules
2129 # Return the name of the linker variable that must be used.
2130 # Empty return means just use 'LINK'.
2131 sub handle_source_transform
2133     # one_file is canonical name.  unxformed is given name.  obj is
2134     # object extension.
2135     my ($one_file, $unxformed, $obj, $where, %transform) = @_;
2137     my $linker = '';
2139     # No point in continuing if _OBJECTS is defined.
2140     return if reject_var ($one_file . '_OBJECTS',
2141                           $one_file . '_OBJECTS should not be defined');
2143     my %used_pfx = ();
2144     my $needlinker;
2145     %linkers_used = ();
2146     foreach my $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
2147                         'dist_EXTRA_', 'nodist_EXTRA_')
2148     {
2149         my $varname = $prefix . $one_file . "_SOURCES";
2150         my $var = var $varname;
2151         next unless $var;
2153         # We are going to define _OBJECTS variables using the prefix.
2154         # Then we glom them all together.  So we can't use the null
2155         # prefix here as we need it later.
2156         my $xpfx = ($prefix eq '') ? 'am_' : $prefix;
2158         # Keep track of which prefixes we saw.
2159         $used_pfx{$xpfx} = 1
2160           unless $prefix =~ /EXTRA_/;
2162         push @sources, "\$($varname)";
2163         push @dist_sources, shadow_unconditionally ($varname, $where)
2164           unless (option ('no-dist') || $prefix =~ /^nodist_/);
2166         $needlinker |=
2167             define_objects_from_sources ($varname,
2168                                          $xpfx . $one_file . '_OBJECTS',
2169                                          !!($prefix =~ /EXTRA_/),
2170                                          $one_file, $obj, $varname, $where,
2171                                          DIST_SOURCE => ($prefix !~ /^nodist_/),
2172                                          %transform);
2173     }
2174     if ($needlinker)
2175     {
2176         $linker ||= resolve_linker (%linkers_used);
2177     }
2179     my @keys = sort keys %used_pfx;
2180     if (scalar @keys == 0)
2181     {
2182         # The default source for libfoo.la is libfoo.c, but for
2183         # backward compatibility we first look at libfoo_la.c,
2184         # if no default source suffix is given.
2185         my $old_default_source = "$one_file.c";
2186         my $ext_var = var ('AM_DEFAULT_SOURCE_EXT');
2187         my $default_source_ext = $ext_var ? variable_value ($ext_var) : '.c';
2188         msg_var ('unsupported', $ext_var, $ext_var->name . " can assume at most one value")
2189           if $default_source_ext =~ /[\t ]/;
2190         (my $default_source = $unxformed) =~ s,(\.[^./\\]*)?$,$default_source_ext,;
2191         # TODO: Remove this backward-compatibility hack in Automake 2.0.
2192         if ($old_default_source ne $default_source
2193             && !$ext_var
2194             && (rule $old_default_source
2195                 || rule '$(srcdir)/' . $old_default_source
2196                 || rule '${srcdir}/' . $old_default_source
2197                 || -f $old_default_source))
2198           {
2199             my $loc = $where->clone;
2200             $loc->pop_context;
2201             msg ('obsolete', $loc,
2202                  "the default source for '$unxformed' has been changed "
2203                  . "to '$default_source'.\n(Using '$old_default_source' for "
2204                  . "backward compatibility.)");
2205             $default_source = $old_default_source;
2206           }
2207         # If a rule exists to build this source with a $(srcdir)
2208         # prefix, use that prefix in our variables too.  This is for
2209         # the sake of BSD Make.
2210         if (rule '$(srcdir)/' . $default_source
2211             || rule '${srcdir}/' . $default_source)
2212           {
2213             $default_source = '$(srcdir)/' . $default_source;
2214           }
2216         define_variable ($one_file . "_SOURCES", $default_source, $where);
2217         push (@sources, $default_source);
2218         push (@dist_sources, $default_source);
2220         %linkers_used = ();
2221         my (@result) =
2222           handle_single_transform ($one_file . '_SOURCES',
2223                                    $one_file . '_SOURCES',
2224                                    $one_file, $obj,
2225                                    $default_source, %transform);
2226         $linker ||= resolve_linker (%linkers_used);
2227         define_pretty_variable ($one_file . '_OBJECTS', TRUE, $where, @result);
2228     }
2229     else
2230     {
2231         @keys = map { '$(' . $_ . $one_file . '_OBJECTS)' } @keys;
2232         define_pretty_variable ($one_file . '_OBJECTS', TRUE, $where, @keys);
2233     }
2235     # If we want to use 'LINK' we must make sure it is defined.
2236     if ($linker eq '')
2237     {
2238         $need_link = 1;
2239     }
2241     return $linker;
2245 # handle_lib_objects ($XNAME, $VAR)
2246 # ---------------------------------
2247 # Special-case ALLOCA and LIBOBJS substitutions in _LDADD or _LIBADD variables.
2248 # Also, generate _DEPENDENCIES variable if appropriate.
2249 # Arguments are:
2250 #   transformed name of object being built, or empty string if no object
2251 #   name of _LDADD/_LIBADD-type variable to examine
2252 # Returns 1 if LIBOBJS seen, 0 otherwise.
2253 sub handle_lib_objects
2255   my ($xname, $varname) = @_;
2257   my $var = var ($varname);
2258   prog_error "'$varname' undefined"
2259     unless $var;
2260   prog_error "unexpected variable name '$varname'"
2261     unless $varname =~ /^(.*)(?:LIB|LD)ADD$/;
2262   my $prefix = $1 || 'AM_';
2264   my $seen_libobjs = 0;
2265   my $flagvar = 0;
2267   transform_variable_recursively
2268     ($varname, $xname . '_DEPENDENCIES', 'am__DEPENDENCIES',
2269      ! $xname, INTERNAL,
2270      # Transformation function, run on each filename.
2271      sub {
2272        my ($subvar, $val, $cond, $full_cond) = @_;
2274        if ($val =~ /^-/)
2275          {
2276            # Skip -lfoo and -Ldir silently; these are explicitly allowed.
2277            if ($val !~ /^-[lL]/ &&
2278                # Skip -dlopen and -dlpreopen; these are explicitly allowed
2279                # for Libtool libraries or programs.  (Actually we are a bit
2280                # lax here since this code also applies to non-libtool
2281                # libraries or programs, for which -dlopen and -dlopreopen
2282                # are pure nonsense.  Diagnosing this doesn't seem very
2283                # important: the developer will quickly get complaints from
2284                # the linker.)
2285                $val !~ /^-dl(?:pre)?open$/ &&
2286                # Only get this error once.
2287                ! $flagvar)
2288              {
2289                $flagvar = 1;
2290                # FIXME: should display a stack of nested variables
2291                # as context when $var != $subvar.
2292                err_var ($var, "linker flags such as '$val' belong in "
2293                         . "'${prefix}LDFLAGS'");
2294              }
2295            return ();
2296          }
2297        elsif ($val !~ /^\@.*\@$/)
2298          {
2299            # Assume we have a file of some sort, and output it into the
2300            # dependency variable.  Autoconf substitutions are not output;
2301            # rarely is a new dependency substituted into e.g. foo_LDADD
2302            # -- but bad things (e.g. -lX11) are routinely substituted.
2303            # Note that LIBOBJS and ALLOCA are exceptions to this rule,
2304            # and handled specially below.
2305            return $val;
2306          }
2307        elsif ($val =~ /^\@(LT)?LIBOBJS\@$/)
2308          {
2309            handle_LIBOBJS ($subvar, $cond, $1);
2310            $seen_libobjs = 1;
2311            return $val;
2312          }
2313        elsif ($val =~ /^\@(LT)?ALLOCA\@$/)
2314          {
2315            handle_ALLOCA ($subvar, $cond, $1);
2316            return $val;
2317          }
2318        else
2319          {
2320            return ();
2321          }
2322      });
2324   return $seen_libobjs;
2327 # handle_LIBOBJS_or_ALLOCA ($VAR, $BASE)
2328 # --------------------------------------
2329 # Definitions common to LIBOBJS and ALLOCA.
2330 # VAR should be one of LIBOBJS, LTLIBOBJS, ALLOCA, or LTALLOCA.
2331 # BASE should be one base file name from AC_LIBSOURCE, or alloca.
2332 sub handle_LIBOBJS_or_ALLOCA
2334   my ($var, $base) = @_;
2336   my $dir = '';
2338   # If LIBOBJS files must be built in another directory we have
2339   # to define LIBOBJDIR and ensure the files get cleaned.
2340   # Otherwise LIBOBJDIR can be left undefined, and the cleaning
2341   # is achieved by 'rm -f *.$(OBJEXT)' in compile.am.
2342   if ($config_libobj_dir
2343       && $relative_dir ne $config_libobj_dir)
2344     {
2345       if (option 'subdir-objects')
2346         {
2347           # In the top-level Makefile we do not use $(top_builddir), because
2348           # we are already there, and since the targets are built without
2349           # a $(top_builddir), it helps BSD Make to match them with
2350           # dependencies.
2351           $dir = "$config_libobj_dir/"
2352             if $config_libobj_dir ne '.';
2353           $dir = backname ($relative_dir) . "/$dir"
2354             if $relative_dir ne '.';
2355           define_variable ('LIBOBJDIR', "$dir", INTERNAL);
2356           if ($dir && !defined $clean_files{"$dir$base.\$(OBJEXT)"})
2357             {
2358               my $dirstamp = require_build_directory ($dir);
2359               $output_rules .= "$dir$base.\$(OBJEXT): $dirstamp\n";
2360               $output_rules .= "$dir$base.lo: $dirstamp\n"
2361                 if ($var =~ /^LT/);
2362             }
2363           # libtool might create .$(OBJEXT) as a side-effect of using
2364           # LTLIBOBJS or LTALLOCA.
2365           $clean_files{"$dir$base.\$(OBJEXT)"} = MOSTLY_CLEAN;
2366           $clean_files{"$dir$base.lo"} = MOSTLY_CLEAN
2367             if ($var =~ /^LT/);
2368         }
2369       else
2370         {
2371           error ("'\$($var)' cannot be used outside '$config_libobj_dir' if"
2372                  . " 'subdir-objects' is not set");
2373         }
2374     }
2376   return $dir;
2379 sub handle_LIBOBJS
2381   my ($var, $cond, $lt) = @_;
2382   my $myobjext = $lt ? 'lo' : 'o';
2383   $lt ||= '';
2385   $var->requires_variables ("\@${lt}LIBOBJS\@ used", $lt . 'LIBOBJS')
2386     if ! keys %libsources;
2388   foreach my $iter (keys %libsources)
2389     {
2390       my $dir = '';
2391       if ($iter =~ /^(.*)(\.[cly])$/)
2392         {
2393           saw_extension ($2);
2394           saw_extension ('.c');
2395           $dir = handle_LIBOBJS_or_ALLOCA ("${lt}LIBOBJS", $1);
2396         }
2398       if ($iter =~ /\.h$/)
2399         {
2400           require_libsource_with_macro ($cond, $var, FOREIGN, $iter);
2401         }
2402       elsif ($iter ne 'alloca.c')
2403         {
2404           my $rewrite = $iter;
2405           $rewrite =~ s/\.c$/.P$myobjext/;
2406           $dep_files{$dir . '$(DEPDIR)/' . $rewrite} = 1;
2407           $rewrite = "^" . quotemeta ($iter) . "\$";
2408           # Only require the file if it is not a built source.
2409           my $bs = var ('BUILT_SOURCES');
2410           if (! $bs || ! grep (/$rewrite/, $bs->value_as_list_recursive))
2411             {
2412               require_libsource_with_macro ($cond, $var, FOREIGN, $iter);
2413             }
2414         }
2415     }
2418 sub handle_ALLOCA
2420   my ($var, $cond, $lt) = @_;
2421   my $myobjext = $lt ? 'lo' : 'o';
2422   $lt ||= '';
2423   my $dir = handle_LIBOBJS_or_ALLOCA ("${lt}ALLOCA", "alloca");
2425   $dir eq '' and $dir = './';
2426   $var->requires_variables ("\@${lt}ALLOCA\@ used", $lt . 'ALLOCA');
2427   $dep_files{$dir . '$(DEPDIR)/alloca.P' . $myobjext} = 1;
2428   require_libsource_with_macro ($cond, $var, FOREIGN, 'alloca.c');
2429   saw_extension ('.c');
2432 # Canonicalize the input parameter.
2433 sub canonicalize
2435     my ($string) = @_;
2436     $string =~ tr/A-Za-z0-9_\@/_/c;
2437     return $string;
2440 # Canonicalize a name, and check to make sure the non-canonical name
2441 # is never used.  Returns canonical name.  Arguments are name and a
2442 # list of suffixes to check for.
2443 sub check_canonical_spelling
2445   my ($name, @suffixes) = @_;
2447   my $xname = canonicalize ($name);
2448   if ($xname ne $name)
2449     {
2450       foreach my $xt (@suffixes)
2451         {
2452           reject_var ("$name$xt", "use '$xname$xt', not '$name$xt'");
2453         }
2454     }
2456   return $xname;
2459 # Set up the compile suite.
2460 sub handle_compile ()
2462    return if ! $must_handle_compiled_objects;
2464     # Boilerplate.
2465     my $default_includes = '';
2466     if (! option 'nostdinc')
2467       {
2468         my @incs = ('-I.', subst ('am__isrc'));
2470         my $var = var 'CONFIG_HEADER';
2471         if ($var)
2472           {
2473             foreach my $hdr (split (' ', $var->variable_value))
2474               {
2475                 push @incs, '-I' . dirname ($hdr);
2476               }
2477           }
2478         # We want '-I. -I$(srcdir)', but the latter -I is redundant
2479         # and unaesthetic in non-VPATH builds.  We use `-I.@am__isrc@`
2480         # instead.  It will be replaced by '-I.' or '-I. -I$(srcdir)'.
2481         # Items in CONFIG_HEADER are never in $(srcdir) so it is safe
2482         # to just put @am__isrc@ right after '-I.', without a space.
2483         ($default_includes = ' ' . uniq (@incs)) =~ s/ @/@/;
2484       }
2486     my (@mostly_rms, @dist_rms);
2487     foreach my $item (sort keys %compile_clean_files)
2488     {
2489         if ($compile_clean_files{$item} == MOSTLY_CLEAN)
2490         {
2491             push (@mostly_rms, "\t-rm -f $item");
2492         }
2493         elsif ($compile_clean_files{$item} == DIST_CLEAN)
2494         {
2495             push (@dist_rms, "\t-rm -f $item");
2496         }
2497         else
2498         {
2499           prog_error 'invalid entry in %compile_clean_files';
2500         }
2501     }
2503     my ($coms, $vars, $rules) =
2504       file_contents_internal (1, "$libdir/am/compile.am",
2505                               new Automake::Location,
2506                               'DEFAULT_INCLUDES' => $default_includes,
2507                               'MOSTLYRMS' => join ("\n", @mostly_rms),
2508                               'DISTRMS' => join ("\n", @dist_rms));
2509     $output_vars .= $vars;
2510     $output_rules .= "$coms$rules";
2513 # Handle libtool rules.
2514 sub handle_libtool ()
2516   return unless var ('LIBTOOL');
2518   # Libtool requires some files, but only at top level.
2519   # (Starting with Libtool 2.0 we do not have to bother.  These
2520   # requirements are done with AC_REQUIRE_AUX_FILE.)
2521   require_conf_file_with_macro (TRUE, 'LIBTOOL', FOREIGN, @libtool_files)
2522     if $relative_dir eq '.' && ! $libtool_new_api;
2524   my @libtool_rms;
2525   foreach my $item (sort keys %libtool_clean_directories)
2526     {
2527       my $dir = ($item eq '.') ? '' : "$item/";
2528       # .libs is for Unix, _libs for DOS.
2529       push (@libtool_rms, "\t-rm -rf ${dir}.libs ${dir}_libs");
2530     }
2532   check_user_variables 'LIBTOOLFLAGS';
2534   # Output the libtool compilation rules.
2535   $output_rules .= file_contents ('libtool',
2536                                   new Automake::Location,
2537                                    LTRMS => join ("\n", @libtool_rms));
2540 # Check for duplicate targets
2541 sub handle_targets ()
2543   my %seen = ();
2544   my @dups = ();
2545   @proglist = am_install_var ('progs', 'PROGRAMS',
2546                               'bin', 'sbin', 'libexec', 'pkglibexec',
2547                               'noinst', 'check');
2548   @liblist = am_install_var ('libs', 'LIBRARIES',
2549                              'lib', 'pkglib', 'noinst', 'check');
2550   @ltliblist = am_install_var ('ltlib', 'LTLIBRARIES',
2551                                'noinst', 'lib', 'pkglib', 'check');
2553   # Record duplications that may arise after canonicalization of the
2554   # base names, in order to prevent object file clashes in the presence
2555   # of target-specific *FLAGS
2556   my @targetlist = (@proglist, @liblist, @ltliblist);
2557   foreach my $pair (@targetlist)
2558     {
2559       my $base = canonicalize (basename (@$pair[1]));
2560       push (@dup_shortnames, $base) if ($seen{$base});
2561       $seen{$base} = $base;
2562     }
2565 sub handle_programs ()
2567   return if ! @proglist;
2568   $must_handle_compiled_objects = 1;
2570   my $seen_global_libobjs =
2571     var ('LDADD') && handle_lib_objects ('', 'LDADD');
2573   foreach my $pair (@proglist)
2574     {
2575       my ($where, $one_file) = @$pair;
2577       my $seen_libobjs = 0;
2578       my $obj = '.$(OBJEXT)';
2580       $known_programs{$one_file} = $where;
2582       # Canonicalize names and check for misspellings.
2583       my $xname = check_canonical_spelling ($one_file, '_LDADD', '_LDFLAGS',
2584                                             '_SOURCES', '_OBJECTS',
2585                                             '_DEPENDENCIES');
2587       $where->push_context ("while processing program '$one_file'");
2588       $where->set (INTERNAL->get);
2590       my $linker = handle_source_transform ($xname, $one_file, $obj, $where,
2591                                             NONLIBTOOL => 1, LIBTOOL => 0);
2593       if (var ($xname . "_LDADD"))
2594         {
2595           $seen_libobjs = handle_lib_objects ($xname, $xname . '_LDADD');
2596         }
2597       else
2598         {
2599           # User didn't define prog_LDADD override.  So do it.
2600           define_variable ($xname . '_LDADD', '$(LDADD)', $where);
2602           # This does a bit too much work.  But we need it to
2603           # generate _DEPENDENCIES when appropriate.
2604           if (var ('LDADD'))
2605             {
2606               $seen_libobjs = handle_lib_objects ($xname, 'LDADD');
2607             }
2608         }
2610       reject_var ($xname . '_LIBADD',
2611                   "use '${xname}_LDADD', not '${xname}_LIBADD'");
2613       set_seen ($xname . '_DEPENDENCIES');
2614       set_seen ('EXTRA_' . $xname . '_DEPENDENCIES');
2615       set_seen ($xname . '_LDFLAGS');
2617       # Determine program to use for link.
2618       my($xlink, $vlink) = define_per_target_linker_variable ($linker, $xname);
2619       $vlink = verbose_flag ($vlink || 'GEN');
2621       # If the resulting program lies in a subdirectory,
2622       # ensure that the directory exists before we need it.
2623       my $dirstamp = require_build_directory_maybe ($one_file);
2625       $libtool_clean_directories{dirname ($one_file)} = 1;
2627       $output_rules .= file_contents ('program',
2628                                       $where,
2629                                       PROGRAM  => $one_file,
2630                                       XPROGRAM => $xname,
2631                                       XLINK    => $xlink,
2632                                       VERBOSE  => $vlink,
2633                                       DIRSTAMP => $dirstamp,
2634                                       EXEEXT   => '$(EXEEXT)');
2636       if ($seen_libobjs || $seen_global_libobjs)
2637         {
2638           if (var ($xname . '_LDADD'))
2639             {
2640               check_libobjs_sources ($xname, $xname . '_LDADD');
2641             }
2642           elsif (var ('LDADD'))
2643             {
2644               check_libobjs_sources ($xname, 'LDADD');
2645             }
2646         }
2647     }
2651 sub handle_libraries ()
2653   return if ! @liblist;
2654   $must_handle_compiled_objects = 1;
2656   my @prefix = am_primary_prefixes ('LIBRARIES', 0, 'lib', 'pkglib',
2657                                     'noinst', 'check');
2659   if (@prefix)
2660     {
2661       my $var = rvar ($prefix[0] . '_LIBRARIES');
2662       $var->requires_variables ('library used', 'RANLIB');
2663     }
2665   define_variable ('AR', 'ar', INTERNAL);
2666   define_variable ('ARFLAGS', 'cru', INTERNAL);
2667   define_verbose_tagvar ('AR');
2669   foreach my $pair (@liblist)
2670     {
2671       my ($where, $onelib) = @$pair;
2673       my $seen_libobjs = 0;
2674       # Check that the library fits the standard naming convention.
2675       my $bn = basename ($onelib);
2676       if ($bn !~ /^lib.*\.a$/)
2677         {
2678           $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.a/;
2679           my $suggestion = dirname ($onelib) . "/$bn";
2680           $suggestion =~ s|^\./||g;
2681           msg ('error-gnu/warn', $where,
2682                "'$onelib' is not a standard library name\n"
2683                . "did you mean '$suggestion'?")
2684         }
2686       ($known_libraries{$onelib} = $bn) =~ s/\.a$//;
2688       $where->push_context ("while processing library '$onelib'");
2689       $where->set (INTERNAL->get);
2691       my $obj = '.$(OBJEXT)';
2693       # Canonicalize names and check for misspellings.
2694       my $xlib = check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
2695                                            '_OBJECTS', '_DEPENDENCIES',
2696                                            '_AR');
2698       if (! var ($xlib . '_AR'))
2699         {
2700           define_variable ($xlib . '_AR', '$(AR) $(ARFLAGS)', $where);
2701         }
2703       # Generate support for conditional object inclusion in
2704       # libraries.
2705       if (var ($xlib . '_LIBADD'))
2706         {
2707           if (handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2708             {
2709               $seen_libobjs = 1;
2710             }
2711         }
2712       else
2713         {
2714           define_variable ($xlib . "_LIBADD", '', $where);
2715         }
2717       reject_var ($xlib . '_LDADD',
2718                   "use '${xlib}_LIBADD', not '${xlib}_LDADD'");
2720       # Make sure we at look at this.
2721       set_seen ($xlib . '_DEPENDENCIES');
2722       set_seen ('EXTRA_' . $xlib . '_DEPENDENCIES');
2724       handle_source_transform ($xlib, $onelib, $obj, $where,
2725                                NONLIBTOOL => 1, LIBTOOL => 0);
2727       # If the resulting library lies in a subdirectory,
2728       # make sure this directory will exist.
2729       my $dirstamp = require_build_directory_maybe ($onelib);
2730       my $verbose = verbose_flag ('AR');
2731       my $silent = silent_flag ();
2733       $output_rules .= file_contents ('library',
2734                                        $where,
2735                                        VERBOSE  => $verbose,
2736                                        SILENT   => $silent,
2737                                        LIBRARY  => $onelib,
2738                                        XLIBRARY => $xlib,
2739                                        DIRSTAMP => $dirstamp);
2741       if ($seen_libobjs)
2742         {
2743           if (var ($xlib . '_LIBADD'))
2744             {
2745               check_libobjs_sources ($xlib, $xlib . '_LIBADD');
2746             }
2747         }
2749       if (! $seen_ar)
2750         {
2751           msg ('extra-portability', $where,
2752                "'$onelib': linking libraries using a non-POSIX\n"
2753                . "archiver requires 'AM_PROG_AR' in '$configure_ac'")
2754         }
2755     }
2759 sub handle_ltlibraries ()
2761   return if ! @ltliblist;
2762   $must_handle_compiled_objects = 1;
2764   my @prefix = am_primary_prefixes ('LTLIBRARIES', 0, 'lib', 'pkglib',
2765                                     'noinst', 'check');
2767   if (@prefix)
2768     {
2769       my $var = rvar ($prefix[0] . '_LTLIBRARIES');
2770       $var->requires_variables ('Libtool library used', 'LIBTOOL');
2771     }
2773   my %instdirs = ();
2774   my %instsubdirs = ();
2775   my %instconds = ();
2776   my %liblocations = ();        # Location (in Makefile.am) of each library.
2778   foreach my $key (@prefix)
2779     {
2780       # Get the installation directory of each library.
2781       my $dir = $key;
2782       my $strip_subdir = 1;
2783       if ($dir =~ /^nobase_/)
2784         {
2785           $dir =~ s/^nobase_//;
2786           $strip_subdir = 0;
2787         }
2788       my $var = rvar ($key . '_LTLIBRARIES');
2790       # We reject libraries which are installed in several places
2791       # in the same condition, because we can only specify one
2792       # '-rpath' option.
2793       $var->traverse_recursively
2794         (sub
2795          {
2796            my ($var, $val, $cond, $full_cond) = @_;
2797            my $hcond = $full_cond->human;
2798            my $where = $var->rdef ($cond)->location;
2799            my $ldir = '';
2800            $ldir = '/' . dirname ($val)
2801              if (!$strip_subdir);
2802            # A library cannot be installed in different directories
2803            # in overlapping conditions.
2804            if (exists $instconds{$val})
2805              {
2806                my ($msg, $acond) =
2807                  $instconds{$val}->ambiguous_p ($val, $full_cond);
2809                if ($msg)
2810                  {
2811                    error ($where, $msg, partial => 1);
2812                    my $dirtxt = "installed " . ($strip_subdir ? "in" : "below") . " '$dir'";
2813                    $dirtxt = "built for '$dir'"
2814                      if $dir eq 'EXTRA' || $dir eq 'noinst' || $dir eq 'check';
2815                    my $dircond =
2816                      $full_cond->true ? "" : " in condition $hcond";
2818                    error ($where, "'$val' should be $dirtxt$dircond ...",
2819                           partial => 1);
2821                    my $hacond = $acond->human;
2822                    my $adir = $instdirs{$val}{$acond};
2823                    my $adirtxt = "installed in '$adir'";
2824                    $adirtxt = "built for '$adir'"
2825                      if ($adir eq 'EXTRA' || $adir eq 'noinst'
2826                          || $adir eq 'check');
2827                    my $adircond = $acond->true ? "" : " in condition $hacond";
2829                    my $onlyone = ($dir ne $adir) ?
2830                      ("\nLibtool libraries can be built for only one "
2831                       . "destination") : "";
2833                    error ($liblocations{$val}{$acond},
2834                           "... and should also be $adirtxt$adircond.$onlyone");
2835                    return;
2836                  }
2837              }
2838            else
2839              {
2840                $instconds{$val} = new Automake::DisjConditions;
2841              }
2842            $instdirs{$val}{$full_cond} = $dir;
2843            $instsubdirs{$val}{$full_cond} = $ldir;
2844            $liblocations{$val}{$full_cond} = $where;
2845            $instconds{$val} = $instconds{$val}->merge ($full_cond);
2846          },
2847          sub
2848          {
2849            return ();
2850          },
2851          skip_ac_subst => 1);
2852     }
2854   foreach my $pair (@ltliblist)
2855     {
2856       my ($where, $onelib) = @$pair;
2858       my $seen_libobjs = 0;
2859       my $obj = '.lo';
2861       # Canonicalize names and check for misspellings.
2862       my $xlib = check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
2863                                            '_SOURCES', '_OBJECTS',
2864                                            '_DEPENDENCIES');
2866       # Check that the library fits the standard naming convention.
2867       my $libname_rx = '^lib.*\.la';
2868       my $ldvar = var ("${xlib}_LDFLAGS") || var ('AM_LDFLAGS');
2869       my $ldvar2 = var ('LDFLAGS');
2870       if (($ldvar && grep (/-module/, $ldvar->value_as_list_recursive))
2871           || ($ldvar2 && grep (/-module/, $ldvar2->value_as_list_recursive)))
2872         {
2873           # Relax name checking for libtool modules.
2874           $libname_rx = '\.la';
2875         }
2877       my $bn = basename ($onelib);
2878       if ($bn !~ /$libname_rx$/)
2879         {
2880           my $type = 'library';
2881           if ($libname_rx eq '\.la')
2882             {
2883               $bn =~ s/^(lib|)(.*?)(?:\.[^.]*)?$/$1$2.la/;
2884               $type = 'module';
2885             }
2886           else
2887             {
2888               $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.la/;
2889             }
2890           my $suggestion = dirname ($onelib) . "/$bn";
2891           $suggestion =~ s|^\./||g;
2892           msg ('error-gnu/warn', $where,
2893                "'$onelib' is not a standard libtool $type name\n"
2894                . "did you mean '$suggestion'?")
2895         }
2897       ($known_libraries{$onelib} = $bn) =~ s/\.la$//;
2899       $where->push_context ("while processing Libtool library '$onelib'");
2900       $where->set (INTERNAL->get);
2902       # Make sure we look at these.
2903       set_seen ($xlib . '_LDFLAGS');
2904       set_seen ($xlib . '_DEPENDENCIES');
2905       set_seen ('EXTRA_' . $xlib . '_DEPENDENCIES');
2907       # Generate support for conditional object inclusion in
2908       # libraries.
2909       if (var ($xlib . '_LIBADD'))
2910         {
2911           if (handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2912             {
2913               $seen_libobjs = 1;
2914             }
2915         }
2916       else
2917         {
2918           define_variable ($xlib . "_LIBADD", '', $where);
2919         }
2921       reject_var ("${xlib}_LDADD",
2922                   "use '${xlib}_LIBADD', not '${xlib}_LDADD'");
2925       my $linker = handle_source_transform ($xlib, $onelib, $obj, $where,
2926                                             NONLIBTOOL => 0, LIBTOOL => 1);
2928       # Determine program to use for link.
2929       my($xlink, $vlink) = define_per_target_linker_variable ($linker, $xlib);
2930       $vlink = verbose_flag ($vlink || 'GEN');
2932       my $rpathvar = "am_${xlib}_rpath";
2933       my $rpath = "\$($rpathvar)";
2934       foreach my $rcond ($instconds{$onelib}->conds)
2935         {
2936           my $val;
2937           if ($instdirs{$onelib}{$rcond} eq 'EXTRA'
2938               || $instdirs{$onelib}{$rcond} eq 'noinst'
2939               || $instdirs{$onelib}{$rcond} eq 'check')
2940             {
2941               # It's an EXTRA_ library, so we can't specify -rpath,
2942               # because we don't know where the library will end up.
2943               # The user probably knows, but generally speaking automake
2944               # doesn't -- and in fact configure could decide
2945               # dynamically between two different locations.
2946               $val = '';
2947             }
2948           else
2949             {
2950               $val = ('-rpath $(' . $instdirs{$onelib}{$rcond} . 'dir)');
2951               $val .= $instsubdirs{$onelib}{$rcond}
2952                 if defined $instsubdirs{$onelib}{$rcond};
2953             }
2954           if ($rcond->true)
2955             {
2956               # If $rcond is true there is only one condition and
2957               # there is no point defining an helper variable.
2958               $rpath = $val;
2959             }
2960           else
2961             {
2962               define_pretty_variable ($rpathvar, $rcond, INTERNAL, $val);
2963             }
2964         }
2966       # If the resulting library lies in a subdirectory,
2967       # make sure this directory will exist.
2968       my $dirstamp = require_build_directory_maybe ($onelib);
2970       # Remember to cleanup .libs/ in this directory.
2971       my $dirname = dirname $onelib;
2972       $libtool_clean_directories{$dirname} = 1;
2974       $output_rules .= file_contents ('ltlibrary',
2975                                       $where,
2976                                       LTLIBRARY  => $onelib,
2977                                       XLTLIBRARY => $xlib,
2978                                       RPATH      => $rpath,
2979                                       XLINK      => $xlink,
2980                                       VERBOSE    => $vlink,
2981                                       DIRSTAMP   => $dirstamp);
2982       if ($seen_libobjs)
2983         {
2984           if (var ($xlib . '_LIBADD'))
2985             {
2986               check_libobjs_sources ($xlib, $xlib . '_LIBADD');
2987             }
2988         }
2990       if (! $seen_ar)
2991         {
2992           msg ('extra-portability', $where,
2993                "'$onelib': linking libtool libraries using a non-POSIX\n"
2994                . "archiver requires 'AM_PROG_AR' in '$configure_ac'")
2995         }
2996     }
2999 # See if any _SOURCES variable were misspelled.
3000 sub check_typos ()
3002   # It is ok if the user sets this particular variable.
3003   set_seen 'AM_LDFLAGS';
3005   foreach my $primary ('SOURCES', 'LIBADD', 'LDADD', 'LDFLAGS', 'DEPENDENCIES')
3006     {
3007       foreach my $var (variables $primary)
3008         {
3009           my $varname = $var->name;
3010           # A configure variable is always legitimate.
3011           next if exists $configure_vars{$varname};
3013           for my $cond ($var->conditions->conds)
3014             {
3015               $varname =~ /^(?:EXTRA_)?(?:nobase_)?(?:dist_|nodist_)?(.*)_[[:alnum:]]+$/;
3016               msg_var ('syntax', $var, "variable '$varname' is defined but no"
3017                        . " program or\nlibrary has '$1' as canonical name"
3018                        . " (possible typo)")
3019                 unless $var->rdef ($cond)->seen;
3020             }
3021         }
3022     }
3026 sub handle_scripts ()
3028     # NOTE we no longer automatically clean SCRIPTS, because it is
3029     # useful to sometimes distribute scripts verbatim.  This happens
3030     # e.g. in Automake itself.
3031     am_install_var ('-candist', 'scripts', 'SCRIPTS',
3032                     'bin', 'sbin', 'libexec', 'pkglibexec', 'pkgdata',
3033                     'noinst', 'check');
3037 ## ------------------------ ##
3038 ## Handling Texinfo files.  ##
3039 ## ------------------------ ##
3041 # ($OUTFILE, $VFILE)
3042 # scan_texinfo_file ($FILENAME)
3043 # -----------------------------
3044 # $OUTFILE     - name of the info file produced by $FILENAME.
3045 # $VFILE       - name of the version.texi file used (undef if none).
3046 sub scan_texinfo_file
3048   my ($filename) = @_;
3050   my $texi = new Automake::XFile "< $filename";
3051   verb "reading $filename";
3053   my ($outfile, $vfile);
3054   while ($_ = $texi->getline)
3055     {
3056       if (/^\@setfilename +(\S+)/)
3057         {
3058           # Honor only the first @setfilename.  (It's possible to have
3059           # more occurrences later if the manual shows examples of how
3060           # to use @setfilename...)
3061           next if $outfile;
3063           $outfile = $1;
3064           if (index ($outfile, '.') < 0)
3065             {
3066               msg 'obsolete', "$filename:$.",
3067                   "use of suffix-less info files is discouraged"
3068             }
3069           elsif ($outfile !~ /\.info$/)
3070             {
3071               error ("$filename:$.",
3072                      "output '$outfile' has unrecognized extension");
3073               return;
3074             }
3075         }
3076       # A "version.texi" file is actually any file whose name matches
3077       # "vers*.texi".
3078       elsif (/^\@include\s+(vers[^.]*\.texi)\s*$/)
3079         {
3080           $vfile = $1;
3081         }
3082     }
3084   if (! $outfile)
3085     {
3086       err_am "'$filename' missing \@setfilename";
3087       return;
3088     }
3090   return ($outfile, $vfile);
3094 # ($DIRSTAMP, @CLEAN_FILES)
3095 # output_texinfo_build_rules ($SOURCE, $DEST, $INSRC, @DEPENDENCIES)
3096 # ------------------------------------------------------------------
3097 # SOURCE - the source Texinfo file
3098 # DEST - the destination Info file
3099 # INSRC - whether DEST should be built in the source tree
3100 # DEPENDENCIES - known dependencies
3101 sub output_texinfo_build_rules
3103   my ($source, $dest, $insrc, @deps) = @_;
3105   # Split 'a.texi' into 'a' and '.texi'.
3106   my ($spfx, $ssfx) = ($source =~ /^(.*?)(\.[^.]*)?$/);
3107   my ($dpfx, $dsfx) = ($dest =~ /^(.*?)(\.[^.]*)?$/);
3109   $ssfx ||= "";
3110   $dsfx ||= "";
3112   # We can output two kinds of rules: the "generic" rules use Make
3113   # suffix rules and are appropriate when $source and $dest do not lie
3114   # in a sub-directory; the "specific" rules are needed in the other
3115   # case.
3116   #
3117   # The former are output only once (this is not really apparent here,
3118   # but just remember that some logic deeper in Automake will not
3119   # output the same rule twice); while the later need to be output for
3120   # each Texinfo source.
3121   my $generic;
3122   my $makeinfoflags;
3123   my $sdir = dirname $source;
3124   if ($sdir eq '.' && dirname ($dest) eq '.')
3125     {
3126       $generic = 1;
3127       $makeinfoflags = '-I $(srcdir)';
3128     }
3129   else
3130     {
3131       $generic = 0;
3132       $makeinfoflags = "-I $sdir -I \$(srcdir)/$sdir";
3133     }
3135   # A directory can contain two kinds of info files: some built in the
3136   # source tree, and some built in the build tree.  The rules are
3137   # different in each case.  However we cannot output two different
3138   # set of generic rules.  Because in-source builds are more usual, we
3139   # use generic rules in this case and fall back to "specific" rules
3140   # for build-dir builds.  (It should not be a problem to invert this
3141   # if needed.)
3142   $generic = 0 unless $insrc;
3144   # We cannot use a suffix rule to build info files with an empty
3145   # extension.  Otherwise we would output a single suffix inference
3146   # rule, with separate dependencies, as in
3147   #
3148   #    .texi:
3149   #             $(MAKEINFO) ...
3150   #    foo.info: foo.texi
3151   #
3152   # which confuse Solaris make.  (See the Autoconf manual for
3153   # details.)  Therefore we use a specific rule in this case.  This
3154   # applies to info files only (dvi and pdf files always have an
3155   # extension).
3156   my $generic_info = ($generic && $dsfx) ? 1 : 0;
3158   # If the resulting file lies in a subdirectory,
3159   # make sure this directory will exist.
3160   my $dirstamp = require_build_directory_maybe ($dest);
3162   my $dipfx = ($insrc ? '$(srcdir)/' : '') . $dpfx;
3164   $output_rules .= file_contents ('texibuild',
3165                                   new Automake::Location,
3166                                   AM_V_MAKEINFO    => verbose_flag('MAKEINFO'),
3167                                   AM_V_TEXI2DVI    => verbose_flag('TEXI2DVI'),
3168                                   AM_V_TEXI2PDF    => verbose_flag('TEXI2PDF'),
3169                                   DEPS             => "@deps",
3170                                   DEST_PREFIX      => $dpfx,
3171                                   DEST_INFO_PREFIX => $dipfx,
3172                                   DEST_SUFFIX      => $dsfx,
3173                                   DIRSTAMP         => $dirstamp,
3174                                   GENERIC          => $generic,
3175                                   GENERIC_INFO     => $generic_info,
3176                                   INSRC            => $insrc,
3177                                   MAKEINFOFLAGS    => $makeinfoflags,
3178                                   SILENT           => silent_flag(),
3179                                   SOURCE           => ($generic
3180                                                        ? '$<' : $source),
3181                                   SOURCE_INFO      => ($generic_info
3182                                                        ? '$<' : $source),
3183                                   SOURCE_REAL      => $source,
3184                                   SOURCE_SUFFIX    => $ssfx,
3185                                   TEXIQUIET        => verbose_flag('texinfo'),
3186                                   TEXIDEVNULL      => verbose_flag('texidevnull'),
3187                                   );
3188   return ($dirstamp, "$dpfx.dvi", "$dpfx.pdf", "$dpfx.ps", "$dpfx.html");
3192 # ($MOSTLYCLEAN, $TEXICLEAN, $MAINTCLEAN)
3193 # handle_texinfo_helper ($info_texinfos)
3194 # --------------------------------------
3195 # Handle all Texinfo source; helper for 'handle_texinfo'.
3196 sub handle_texinfo_helper
3198   my ($info_texinfos) = @_;
3199   my (@infobase, @info_deps_list, @texi_deps);
3200   my %versions;
3201   my $done = 0;
3202   my (@mostly_cleans, @texi_cleans, @maint_cleans) = ('', '', '');
3204   # Build a regex matching user-cleaned files.
3205   my $d = var 'DISTCLEANFILES';
3206   my $c = var 'CLEANFILES';
3207   my @f = ();
3208   push @f, $d->value_as_list_recursive (inner_expand => 1) if $d;
3209   push @f, $c->value_as_list_recursive (inner_expand => 1) if $c;
3210   @f = map { s|[^A-Za-z_0-9*\[\]\-]|\\$&|g; s|\*|[^/]*|g; $_; } @f;
3211   my $user_cleaned_files = '^(?:' . join ('|', @f) . ')$';
3213   foreach my $texi
3214       ($info_texinfos->value_as_list_recursive (inner_expand => 1))
3215     {
3216       my $infobase = $texi;
3217       if ($infobase =~ s/\.texi$//)
3218         {
3219           1; # Nothing more to do.
3220         }
3221       elsif ($infobase =~ s/\.(txi|texinfo)$//)
3222         {
3223           msg_var 'obsolete', $info_texinfos,
3224                   "suffix '.$1' for Texinfo files is discouraged;" .
3225                   " use '.texi' instead";
3226         }
3227       else
3228         {
3229           # FIXME: report line number.
3230           err_am "texinfo file '$texi' has unrecognized extension";
3231           next;
3232         }
3234       push @infobase, $infobase;
3236       # If 'version.texi' is referenced by input file, then include
3237       # automatic versioning capability.
3238       my ($out_file, $vtexi) =
3239         scan_texinfo_file ("$relative_dir/$texi")
3240         or next;
3241       # Directory of auxiliary files and build by-products used by texi2dvi
3242       # and texi2pdf.
3243       push @mostly_cleans, "$infobase.t2d";
3244       push @mostly_cleans, "$infobase.t2p";
3246       # If the Texinfo source is in a subdirectory, create the
3247       # resulting info in this subdirectory.  If it is in the current
3248       # directory, try hard to not prefix "./" because it breaks the
3249       # generic rules.
3250       my $outdir = dirname ($texi) . '/';
3251       $outdir = "" if $outdir eq './';
3252       $out_file =  $outdir . $out_file;
3254       # Until Automake 1.6.3, .info files were built in the
3255       # source tree.  This was an obstacle to the support of
3256       # non-distributed .info files, and non-distributed .texi
3257       # files.
3258       #
3259       # * Non-distributed .texi files is important in some packages
3260       #   where .texi files are built at make time, probably using
3261       #   other binaries built in the package itself, maybe using
3262       #   tools or information found on the build host.  Because
3263       #   these files are not distributed they are always rebuilt
3264       #   at make time; they should therefore not lie in the source
3265       #   directory.  One plan was to support this using
3266       #   nodist_info_TEXINFOS or something similar.  (Doing this
3267       #   requires some sanity checks.  For instance Automake should
3268       #   not allow:
3269       #      dist_info_TEXINFOS = foo.texi
3270       #      nodist_foo_TEXINFOS = included.texi
3271       #   because a distributed file should never depend on a
3272       #   non-distributed file.)
3273       #
3274       # * If .texi files are not distributed, then .info files should
3275       #   not be distributed either.  There are also cases where one
3276       #   wants to distribute .texi files, but does not want to
3277       #   distribute the .info files.  For instance the Texinfo package
3278       #   distributes the tool used to build these files; it would
3279       #   be a waste of space to distribute them.  It's not clear
3280       #   which syntax we should use to indicate that .info files should
3281       #   not be distributed.  Akim Demaille suggested that eventually
3282       #   we switch to a new syntax:
3283       #   |  Maybe we should take some inspiration from what's already
3284       #   |  done in the rest of Automake.  Maybe there is too much
3285       #   |  syntactic sugar here, and you want
3286       #   |     nodist_INFO = bar.info
3287       #   |     dist_bar_info_SOURCES = bar.texi
3288       #   |     bar_texi_DEPENDENCIES = foo.texi
3289       #   |  with a bit of magic to have bar.info represent the whole
3290       #   |  bar*info set.  That's a lot more verbose that the current
3291       #   |  situation, but it is # not new, hence the user has less
3292       #   |  to learn.
3293       #   |
3294       #   |  But there is still too much room for meaningless specs:
3295       #   |     nodist_INFO = bar.info
3296       #   |     dist_bar_info_SOURCES = bar.texi
3297       #   |     dist_PS = bar.ps something-written-by-hand.ps
3298       #   |     nodist_bar_ps_SOURCES = bar.texi
3299       #   |     bar_texi_DEPENDENCIES = foo.texi
3300       #   |  here bar.texi is dist_ in line 2, and nodist_ in 4.
3301       #
3302       # Back to the point, it should be clear that in order to support
3303       # non-distributed .info files, we need to build them in the
3304       # build tree, not in the source tree (non-distributed .texi
3305       # files are less of a problem, because we do not output build
3306       # rules for them).  In Automake 1.7 .info build rules have been
3307       # largely cleaned up so that .info files get always build in the
3308       # build tree, even when distributed.  The idea was that
3309       #   (1) if during a VPATH build the .info file was found to be
3310       #       absent or out-of-date (in the source tree or in the
3311       #       build tree), Make would rebuild it in the build tree.
3312       #       If an up-to-date source-tree of the .info file existed,
3313       #       make would not rebuild it in the build tree.
3314       #   (2) having two copies of .info files, one in the source tree
3315       #       and one (newer) in the build tree is not a problem
3316       #       because 'make dist' always pick files in the build tree
3317       #       first.
3318       # However it turned out the be a bad idea for several reasons:
3319       #   * Tru64, OpenBSD, and FreeBSD (not NetBSD) Make do not behave
3320       #     like GNU Make on point (1) above.  These implementations
3321       #     of Make would always rebuild .info files in the build
3322       #     tree, even if such files were up to date in the source
3323       #     tree.  Consequently, it was impossible to perform a VPATH
3324       #     build of a package containing Texinfo files using these
3325       #     Make implementations.
3326       #     (Refer to the Autoconf Manual, section "Limitation of
3327       #     Make", paragraph "VPATH", item "target lookup", for
3328       #     an account of the differences between these
3329       #     implementations.)
3330       #   * The GNU Coding Standards require these files to be built
3331       #     in the source-tree (when they are distributed, that is).
3332       #   * Keeping a fresher copy of distributed files in the
3333       #     build tree can be annoying during development because
3334       #     - if the files is kept under CVS, you really want it
3335       #       to be updated in the source tree
3336       #     - it is confusing that 'make distclean' does not erase
3337       #       all files in the build tree.
3338       #
3339       # Consequently, starting with Automake 1.8, .info files are
3340       # built in the source tree again.  Because we still plan to
3341       # support non-distributed .info files at some point, we
3342       # have a single variable ($INSRC) that controls whether
3343       # the current .info file must be built in the source tree
3344       # or in the build tree.  Actually this variable is switched
3345       # off in two cases:
3346       #  (1) For '.info' files that appear to be cleaned; this is for
3347       #      backward compatibility with package such as Texinfo,
3348       #      which do things like
3349       #        info_TEXINFOS = texinfo.txi info-stnd.texi info.texi
3350       #        DISTCLEANFILES = texinfo texinfo-* info*.info*
3351       #        # Do not create info files for distribution.
3352       #        dist-info:
3353       #      in order not to distribute .info files.
3354       #  (2) When the undocumented option 'info-in-builddir' is given.
3355       #      This is done to allow the developers of GCC, GDB, GNU
3356       #      binutils and the GNU bfd library to force the '.info' files
3357       #      to be generated in the builddir rather than the srcdir, as
3358       #      was once done when the (now removed) 'cygnus' option was
3359       #      given.  See automake bug#11034 for more discussion.
3360       my $insrc = 1;
3361       my $soutdir = '$(srcdir)/' . $outdir;
3363       if (option 'info-in-builddir')
3364         {
3365           $insrc = 0;
3366         }
3367       elsif ($out_file =~ $user_cleaned_files)
3368         {
3369           $insrc = 0;
3370           msg 'obsolete', "$am_file.am", <<EOF;
3371 Oops!
3372     It appears this file (or files included by it) are triggering
3373     an undocumented, soon-to-be-removed automake hack.
3374     Future automake versions will no longer place in the builddir
3375     (rather than in the srcdir) the generated '.info' files that
3376     appear to be cleaned, by e.g. being listed in CLEANFILES or
3377     DISTCLEANFILES.
3378     If you want your '.info' files to be placed in the builddir
3379     rather than in the srcdir, you have to use the shiny new
3380     'info-in-builddir' automake option.
3382         }
3384       $outdir = $soutdir if $insrc;
3386       # If user specified file_TEXINFOS, then use that as explicit
3387       # dependency list.
3388       @texi_deps = ();
3389       push (@texi_deps, "${soutdir}${vtexi}") if $vtexi;
3391       my $canonical = canonicalize ($infobase);
3392       if (var ($canonical . "_TEXINFOS"))
3393         {
3394           push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
3395           push_dist_common ('$(' . $canonical . '_TEXINFOS)');
3396         }
3398       my ($dirstamp, @cfiles) =
3399         output_texinfo_build_rules ($texi, $out_file, $insrc, @texi_deps);
3400       push (@texi_cleans, @cfiles);
3402       push (@info_deps_list, $out_file);
3404       # If a vers*.texi file is needed, emit the rule.
3405       if ($vtexi)
3406         {
3407           err_am ("'$vtexi', included in '$texi', "
3408                   . "also included in '$versions{$vtexi}'")
3409             if defined $versions{$vtexi};
3410           $versions{$vtexi} = $texi;
3412           # We number the stamp-vti files.  This is doable since the
3413           # actual names don't matter much.  We only number starting
3414           # with the second one, so that the common case looks nice.
3415           my $vti = ($done ? $done : 'vti');
3416           ++$done;
3418           # This is ugly, but it is our historical practice.
3419           if ($config_aux_dir_set_in_configure_ac)
3420             {
3421               require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3422                                             'mdate-sh');
3423             }
3424           else
3425             {
3426               require_file_with_macro (TRUE, 'info_TEXINFOS',
3427                                        FOREIGN, 'mdate-sh');
3428             }
3430           my $conf_dir;
3431           if ($config_aux_dir_set_in_configure_ac)
3432             {
3433               $conf_dir = "$am_config_aux_dir/";
3434             }
3435           else
3436             {
3437               $conf_dir = '$(srcdir)/';
3438             }
3439           $output_rules .= file_contents ('texi-vers',
3440                                           new Automake::Location,
3441                                           TEXI     => $texi,
3442                                           VTI      => $vti,
3443                                           STAMPVTI => "${soutdir}stamp-$vti",
3444                                           VTEXI    => "$soutdir$vtexi",
3445                                           MDDIR    => $conf_dir,
3446                                           DIRSTAMP => $dirstamp);
3447         }
3448     }
3450   # Handle location of texinfo.tex.
3451   my $need_texi_file = 0;
3452   my $texinfodir;
3453   if (var ('TEXINFO_TEX'))
3454     {
3455       # The user defined TEXINFO_TEX so assume he knows what he is
3456       # doing.
3457       $texinfodir = ('$(srcdir)/'
3458                      . dirname (variable_value ('TEXINFO_TEX')));
3459     }
3460   elsif ($config_aux_dir_set_in_configure_ac)
3461     {
3462       $texinfodir = $am_config_aux_dir;
3463       define_variable ('TEXINFO_TEX', "$texinfodir/texinfo.tex", INTERNAL);
3464       $need_texi_file = 2; # so that we require_conf_file later
3465     }
3466   else
3467     {
3468       $texinfodir = '$(srcdir)';
3469       $need_texi_file = 1;
3470     }
3471   define_variable ('am__TEXINFO_TEX_DIR', $texinfodir, INTERNAL);
3473   push (@dist_targets, 'dist-info');
3475   if (! option 'no-installinfo')
3476     {
3477       # Make sure documentation is made and installed first.  Use
3478       # $(INFO_DEPS), not 'info', because otherwise recursive makes
3479       # get run twice during "make all".
3480       unshift (@all, '$(INFO_DEPS)');
3481     }
3483   define_files_variable ("DVIS", @infobase, 'dvi', INTERNAL);
3484   define_files_variable ("PDFS", @infobase, 'pdf', INTERNAL);
3485   define_files_variable ("PSS", @infobase, 'ps', INTERNAL);
3486   define_files_variable ("HTMLS", @infobase, 'html', INTERNAL);
3488   # This next isn't strictly needed now -- the places that look here
3489   # could easily be changed to look in info_TEXINFOS.  But this is
3490   # probably better, in case noinst_TEXINFOS is ever supported.
3491   define_variable ("TEXINFOS", variable_value ('info_TEXINFOS'), INTERNAL);
3493   # Do some error checking.  Note that this file is not required
3494   # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
3495   # up above.
3496   if ($need_texi_file && ! option 'no-texinfo.tex')
3497     {
3498       if ($need_texi_file > 1)
3499         {
3500           require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3501                                         'texinfo.tex');
3502         }
3503       else
3504         {
3505           require_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3506                                    'texinfo.tex');
3507         }
3508     }
3510   return (makefile_wrap ("", "\t  ", @mostly_cleans),
3511           makefile_wrap ("", "\t  ", @texi_cleans),
3512           makefile_wrap ("", "\t  ", @maint_cleans));
3516 sub handle_texinfo ()
3518   reject_var 'TEXINFOS', "'TEXINFOS' is an anachronism; use 'info_TEXINFOS'";
3519   # FIXME: I think this is an obsolete future feature name.
3520   reject_var 'html_TEXINFOS', "HTML generation not yet supported";
3522   my $info_texinfos = var ('info_TEXINFOS');
3523   my ($mostlyclean, $clean, $maintclean) = ('', '', '');
3524   if ($info_texinfos)
3525     {
3526       define_verbose_texinfo;
3527       ($mostlyclean, $clean, $maintclean) = handle_texinfo_helper ($info_texinfos);
3528       chomp $mostlyclean;
3529       chomp $clean;
3530       chomp $maintclean;
3531     }
3533   $output_rules .=  file_contents ('texinfos',
3534                                    new Automake::Location,
3535                                    AM_V_DVIPS    => verbose_flag('DVIPS'),
3536                                    MOSTLYCLEAN   => $mostlyclean,
3537                                    TEXICLEAN     => $clean,
3538                                    MAINTCLEAN    => $maintclean,
3539                                    'LOCAL-TEXIS' => !!$info_texinfos,
3540                                    TEXIQUIET     => verbose_flag('texinfo'));
3544 sub handle_man_pages ()
3546   reject_var 'MANS', "'MANS' is an anachronism; use 'man_MANS'";
3548   # Find all the sections in use.  We do this by first looking for
3549   # "standard" sections, and then looking for any additional
3550   # sections used in man_MANS.
3551   my (%sections, %notrans_sections, %trans_sections,
3552       %notrans_vars, %trans_vars, %notrans_sect_vars, %trans_sect_vars);
3553   # We handle nodist_ for uniformity.  man pages aren't distributed
3554   # by default so it isn't actually very important.
3555   foreach my $npfx ('', 'notrans_')
3556     {
3557       foreach my $pfx ('', 'dist_', 'nodist_')
3558         {
3559           # Add more sections as needed.
3560           foreach my $section ('0'..'9', 'n', 'l')
3561             {
3562               my $varname = $npfx . $pfx . 'man' . $section . '_MANS';
3563               if (var ($varname))
3564                 {
3565                   $sections{$section} = 1;
3566                   $varname = '$(' . $varname . ')';
3567                   if ($npfx eq 'notrans_')
3568                     {
3569                       $notrans_sections{$section} = 1;
3570                       $notrans_sect_vars{$varname} = 1;
3571                     }
3572                   else
3573                     {
3574                       $trans_sections{$section} = 1;
3575                       $trans_sect_vars{$varname} = 1;
3576                     }
3578                   push_dist_common ($varname)
3579                     if $pfx eq 'dist_';
3580                 }
3581             }
3583           my $varname = $npfx . $pfx . 'man_MANS';
3584           my $var = var ($varname);
3585           if ($var)
3586             {
3587               foreach ($var->value_as_list_recursive)
3588                 {
3589                   # A page like 'foo.1c' goes into man1dir.
3590                   if (/\.([0-9a-z])([a-z]*)$/)
3591                     {
3592                       $sections{$1} = 1;
3593                       if ($npfx eq 'notrans_')
3594                         {
3595                           $notrans_sections{$1} = 1;
3596                         }
3597                       else
3598                         {
3599                           $trans_sections{$1} = 1;
3600                         }
3601                     }
3602                 }
3604               $varname = '$(' . $varname . ')';
3605               if ($npfx eq 'notrans_')
3606                 {
3607                   $notrans_vars{$varname} = 1;
3608                 }
3609               else
3610                 {
3611                   $trans_vars{$varname} = 1;
3612                 }
3613               push_dist_common ($varname)
3614                 if $pfx eq 'dist_';
3615             }
3616         }
3617     }
3619   return unless %sections;
3621   my @unsorted_deps;
3623   # Build section independent variables.
3624   my $have_notrans = %notrans_vars;
3625   my @notrans_list = sort keys %notrans_vars;
3626   my $have_trans = %trans_vars;
3627   my @trans_list = sort keys %trans_vars;
3629   # Now for each section, generate an install and uninstall rule.
3630   # Sort sections so output is deterministic.
3631   foreach my $section (sort keys %sections)
3632     {
3633       # Build section dependent variables.
3634       my $notrans_mans = $have_notrans || exists $notrans_sections{$section};
3635       my $trans_mans = $have_trans || exists $trans_sections{$section};
3636       my (%notrans_this_sect, %trans_this_sect);
3637       my $expr = 'man' . $section . '_MANS';
3638       foreach my $varname (keys %notrans_sect_vars)
3639         {
3640           if ($varname =~ /$expr/)
3641             {
3642               $notrans_this_sect{$varname} = 1;
3643             }
3644         }
3645       foreach my $varname (keys %trans_sect_vars)
3646         {
3647           if ($varname =~ /$expr/)
3648             {
3649               $trans_this_sect{$varname} = 1;
3650             }
3651         }
3652       my @notrans_sect_list = sort keys %notrans_this_sect;
3653       my @trans_sect_list = sort keys %trans_this_sect;
3654       @unsorted_deps = (keys %notrans_vars, keys %trans_vars,
3655                         keys %notrans_this_sect, keys %trans_this_sect);
3656       my @deps = sort @unsorted_deps;
3657       $output_rules .= file_contents ('mans',
3658                                       new Automake::Location,
3659                                       SECTION           => $section,
3660                                       DEPS              => "@deps",
3661                                       NOTRANS_MANS      => $notrans_mans,
3662                                       NOTRANS_SECT_LIST => "@notrans_sect_list",
3663                                       HAVE_NOTRANS      => $have_notrans,
3664                                       NOTRANS_LIST      => "@notrans_list",
3665                                       TRANS_MANS        => $trans_mans,
3666                                       TRANS_SECT_LIST   => "@trans_sect_list",
3667                                       HAVE_TRANS        => $have_trans,
3668                                       TRANS_LIST        => "@trans_list");
3669     }
3671   @unsorted_deps  = (keys %notrans_vars, keys %trans_vars,
3672                      keys %notrans_sect_vars, keys %trans_sect_vars);
3673   my @mans = sort @unsorted_deps;
3674   $output_vars .= file_contents ('mans-vars',
3675                                  new Automake::Location,
3676                                  MANS => "@mans");
3678   push (@all, '$(MANS)')
3679     unless option 'no-installman';
3683 sub handle_data ()
3685     am_install_var ('-noextra', '-candist', 'data', 'DATA',
3686                     'data', 'dataroot', 'doc', 'dvi', 'html', 'pdf',
3687                     'ps', 'sysconf', 'sharedstate', 'localstate',
3688                     'pkgdata', 'lisp', 'noinst', 'check');
3692 sub handle_tags ()
3694     my @config;
3695     foreach my $spec (@config_headers)
3696       {
3697         my ($out, @ins) = split_config_file_spec ($spec);
3698         foreach my $in (@ins)
3699           {
3700             # If the config header source is in this directory,
3701             # require it.
3702             push @config, basename ($in)
3703               if $relative_dir eq dirname ($in);
3704            }
3705       }
3707     define_variable ('am__tagged_files',
3708                      '$(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)'
3709                      . "@config", INTERNAL);
3711     if (rvar('am__tagged_files')->value_as_list_recursive
3712           || var ('ETAGS_ARGS') || var ('SUBDIRS'))
3713       {
3714         $output_rules .= file_contents ('tags', new Automake::Location);
3715         set_seen 'TAGS_DEPENDENCIES';
3716       }
3717     else
3718       {
3719         reject_var ('TAGS_DEPENDENCIES',
3720                     "it doesn't make sense to define 'TAGS_DEPENDENCIES'"
3721                     . " without\nsources or 'ETAGS_ARGS'");
3722         # Every Makefile must define some sort of TAGS rule.
3723         # Otherwise, it would be possible for a top-level "make TAGS"
3724         # to fail because some subdirectory failed.  Ditto ctags and
3725         # cscope.
3726         $output_rules .=
3727           "tags TAGS:\n\n" .
3728           "ctags CTAGS:\n\n" .
3729           "cscope cscopelist:\n\n";
3730       }
3734 # user_phony_rule ($NAME)
3735 # -----------------------
3736 # Return false if rule $NAME does not exist.  Otherwise,
3737 # declare it as phony, complete its definition (in case it is
3738 # conditional), and return its Automake::Rule instance.
3739 sub user_phony_rule
3741   my ($name) = @_;
3742   my $rule = rule $name;
3743   if ($rule)
3744     {
3745       depend ('.PHONY', $name);
3746       # Define $NAME in all condition where it is not already defined,
3747       # so that it is always OK to depend on $NAME.
3748       for my $c ($rule->not_always_defined_in_cond (TRUE)->conds)
3749         {
3750           Automake::Rule::define ($name, 'internal', RULE_AUTOMAKE,
3751                                   $c, INTERNAL);
3752           $output_rules .= $c->subst_string . "$name:\n";
3753         }
3754     }
3755   return $rule;
3759 # Handle 'dist' target.
3760 sub handle_dist ()
3762   # Substitutions for distdir.am
3763   my %transform;
3765   # Define DIST_SUBDIRS.  This must always be done, regardless of the
3766   # no-dist setting: target like 'distclean' or 'maintainer-clean' use it.
3767   my $subdirs = var ('SUBDIRS');
3768   if ($subdirs)
3769     {
3770       # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
3771       # to all possible directories, and use it.  If DIST_SUBDIRS is
3772       # defined, just use it.
3774       # Note that we check DIST_SUBDIRS first on purpose, so that
3775       # we don't call has_conditional_contents for now reason.
3776       # (In the past one project used so many conditional subdirectories
3777       # that calling has_conditional_contents on SUBDIRS caused
3778       # automake to grow to 150Mb -- this should not happen with
3779       # the current implementation of has_conditional_contents,
3780       # but it's more efficient to avoid the call anyway.)
3781       if (var ('DIST_SUBDIRS'))
3782         {
3783         }
3784       elsif ($subdirs->has_conditional_contents)
3785         {
3786           define_pretty_variable
3787             ('DIST_SUBDIRS', TRUE, INTERNAL,
3788              uniq ($subdirs->value_as_list_recursive));
3789         }
3790       else
3791         {
3792           # We always define this because that is what 'distclean'
3793           # wants.
3794           define_pretty_variable ('DIST_SUBDIRS', TRUE, INTERNAL,
3795                                   '$(SUBDIRS)');
3796         }
3797     }
3799   # The remaining definitions are only required when a dist target is used.
3800   return if option 'no-dist';
3802   # At least one of the archive formats must be enabled.
3803   if ($relative_dir eq '.')
3804     {
3805       my $archive_defined = option 'no-dist-gzip' ? 0 : 1;
3806       $archive_defined ||=
3807         grep { option "dist-$_" } qw(shar zip tarZ bzip2 lzip xz);
3808       error (option 'no-dist-gzip',
3809              "no-dist-gzip specified but no dist-* specified,\n"
3810              . "at least one archive format must be enabled")
3811         unless $archive_defined;
3812     }
3814   # Look for common files that should be included in distribution.
3815   # If the aux dir is set, and it does not have a Makefile.am, then
3816   # we check for these files there as well.
3817   my $check_aux = 0;
3818   if ($relative_dir eq '.'
3819       && $config_aux_dir_set_in_configure_ac)
3820     {
3821       if (! is_make_dir ($config_aux_dir))
3822         {
3823           $check_aux = 1;
3824         }
3825     }
3826   foreach my $cfile (@common_files)
3827     {
3828       if (dir_has_case_matching_file ($relative_dir, $cfile)
3829           # The file might be absent, but if it can be built it's ok.
3830           || rule $cfile)
3831         {
3832           push_dist_common ($cfile);
3833         }
3835       # Don't use 'elsif' here because a file might meaningfully
3836       # appear in both directories.
3837       if ($check_aux && dir_has_case_matching_file ($config_aux_dir, $cfile))
3838         {
3839           push_dist_common ("$config_aux_dir/$cfile")
3840         }
3841     }
3843   # We might copy elements from @configure_dist_common to
3844   # @dist_common if we think we need to.  If the file appears in our
3845   # directory, we would have discovered it already, so we don't
3846   # check that.  But if the file is in a subdir without a Makefile,
3847   # we want to distribute it here if we are doing '.'.  Ugly!
3848   # Also, in some corner cases, it's possible that the following code
3849   # will cause the same file to appear in the $(DIST_COMMON) variables
3850   # of two distinct Makefiles; but this is not a problem, since the
3851   # 'distdir' target in 'lib/am/distdir.am' can deal with the same
3852   # file being distributed multiple times.
3853   # See also automake bug#9651.
3854   if ($relative_dir eq '.')
3855     {
3856       foreach my $file (@configure_dist_common)
3857         {
3858           my $dir = dirname ($file);
3859           push_dist_common ($file)
3860             if ($dir eq '.' || ! is_make_dir ($dir));
3861         }
3862       @configure_dist_common = ();
3863     }
3865   # $(am__DIST_COMMON): files to be distributed automatically.  Will be
3866   # appended to $(DIST_COMMON) in the generated Makefile.
3867   # Use 'sort' so that the expansion of $(DIST_COMMON) in the generated
3868   # Makefile is deterministic, in face of m4 and/or perl randomizations
3869   # (see automake bug#17908).
3870   define_pretty_variable ('am__DIST_COMMON', TRUE, INTERNAL,
3871                           uniq (sort @dist_common));
3873   # Now that we've processed @dist_common, disallow further attempts
3874   # to modify it.
3875   $handle_dist_run = 1;
3877   $transform{'DISTCHECK-HOOK'} = !! rule 'distcheck-hook';
3878   $transform{'GETTEXT'} = $seen_gettext && !$seen_gettext_external;
3880   # If the target 'dist-hook' exists, make sure it is run.  This
3881   # allows users to do random weird things to the distribution
3882   # before it is packaged up.
3883   push (@dist_targets, 'dist-hook')
3884     if user_phony_rule 'dist-hook';
3885   $transform{'DIST-TARGETS'} = join (' ', @dist_targets);
3887   my $flm = option ('filename-length-max');
3888   my $filename_filter = $flm ? '.' x $flm->[1] : '';
3890   $output_rules .= file_contents ('distdir',
3891                                   new Automake::Location,
3892                                   %transform,
3893                                   FILENAME_FILTER => $filename_filter);
3897 # check_directory ($NAME, $WHERE [, $RELATIVE_DIR = "."])
3898 # -------------------------------------------------------
3899 # Ensure $NAME is a directory (in $RELATIVE_DIR), and that it uses a sane
3900 # name.  Use $WHERE as a location in the diagnostic, if any.
3901 sub check_directory
3903   my ($dir, $where, $reldir) = @_;
3904   $reldir = '.' unless defined $reldir;
3906   error $where, "required directory $reldir/$dir does not exist"
3907     unless -d "$reldir/$dir";
3909   # If an 'obj/' directory exists, BSD make will enter it before
3910   # reading 'Makefile'.  Hence the 'Makefile' in the current directory
3911   # will not be read.
3912   #
3913   #  % cat Makefile
3914   #  all:
3915   #          echo Hello
3916   #  % cat obj/Makefile
3917   #  all:
3918   #          echo World
3919   #  % make      # GNU make
3920   #  echo Hello
3921   #  Hello
3922   #  % pmake     # BSD make
3923   #  echo World
3924   #  World
3925   msg ('portability', $where,
3926        "naming a subdirectory 'obj' causes troubles with BSD make")
3927     if $dir eq 'obj';
3929   # 'aux' is probably the most important of the following forbidden name,
3930   # since it's tempting to use it as an AC_CONFIG_AUX_DIR.
3931   msg ('portability', $where,
3932        "name '$dir' is reserved on W32 and DOS platforms")
3933     if grep (/^\Q$dir\E$/i, qw/aux lpt1 lpt2 lpt3 com1 com2 com3 com4 con prn/);
3936 # check_directories_in_var ($VARIABLE)
3937 # ------------------------------------
3938 # Recursively check all items in variables $VARIABLE as directories
3939 sub check_directories_in_var
3941   my ($var) = @_;
3942   $var->traverse_recursively
3943     (sub
3944      {
3945        my ($var, $val, $cond, $full_cond) = @_;
3946        check_directory ($val, $var->rdef ($cond)->location, $relative_dir);
3947        return ();
3948      },
3949      undef,
3950      skip_ac_subst => 1);
3954 sub handle_subdirs ()
3956   my $subdirs = var ('SUBDIRS');
3957   return
3958     unless $subdirs;
3960   check_directories_in_var $subdirs;
3962   my $dsubdirs = var ('DIST_SUBDIRS');
3963   check_directories_in_var $dsubdirs
3964     if $dsubdirs;
3966   $output_rules .= file_contents ('subdirs', new Automake::Location);
3967   rvar ('RECURSIVE_TARGETS')->rdef (TRUE)->{'pretty'} = VAR_SORTED; # Gross!
3971 # ($REGEN, @DEPENDENCIES)
3972 # scan_aclocal_m4
3973 # ---------------
3974 # If aclocal.m4 creation is automated, return the list of its dependencies.
3975 sub scan_aclocal_m4 ()
3977   my $regen_aclocal = 0;
3979   set_seen 'CONFIG_STATUS_DEPENDENCIES';
3980   set_seen 'CONFIGURE_DEPENDENCIES';
3982   if (-f 'aclocal.m4')
3983     {
3984       define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4', INTERNAL);
3986       my $aclocal = new Automake::XFile "< aclocal.m4";
3987       my $line = $aclocal->getline;
3988       $regen_aclocal = $line =~ 'generated automatically by aclocal';
3989     }
3991   my @ac_deps = ();
3993   if (set_seen ('ACLOCAL_M4_SOURCES'))
3994     {
3995       push (@ac_deps, '$(ACLOCAL_M4_SOURCES)');
3996       msg_var ('obsolete', 'ACLOCAL_M4_SOURCES',
3997                "'ACLOCAL_M4_SOURCES' is obsolete.\n"
3998                . "It should be safe to simply remove it");
3999     }
4001   # Note that it might be possible that aclocal.m4 doesn't exist but
4002   # should be auto-generated.  This case probably isn't very
4003   # important.
4005   return ($regen_aclocal, @ac_deps);
4009 # Helper function for 'substitute_ac_subst_variables'.
4010 sub substitute_ac_subst_variables_worker
4012   my ($token) = @_;
4013   return "\@$token\@" if var $token;
4014   return "\${$token\}";
4017 # substitute_ac_subst_variables ($TEXT)
4018 # -------------------------------------
4019 # Replace any occurrence of ${FOO} in $TEXT by @FOO@ if FOO is an AC_SUBST
4020 # variable.
4021 sub substitute_ac_subst_variables
4023   my ($text) = @_;
4024   $text =~ s/\$[{]([^ \t=:+{}]+)}/substitute_ac_subst_variables_worker ($1)/ge;
4025   return $text;
4028 # @DEPENDENCIES
4029 # prepend_srcdir (@INPUTS)
4030 # ------------------------
4031 # Prepend $(srcdir) or $(top_srcdir) to all @INPUTS.  The idea is that
4032 # if an input file has a directory part the same as the current
4033 # directory, then the directory part is simply replaced by $(srcdir).
4034 # But if the directory part is different, then $(top_srcdir) is
4035 # prepended.
4036 sub prepend_srcdir
4038   my (@inputs) = @_;
4039   my @newinputs;
4041   foreach my $single (@inputs)
4042     {
4043       if (dirname ($single) eq $relative_dir)
4044         {
4045           push (@newinputs, '$(srcdir)/' . basename ($single));
4046         }
4047       else
4048         {
4049           push (@newinputs, '$(top_srcdir)/' . $single);
4050         }
4051     }
4052   return @newinputs;
4055 # @DEPENDENCIES
4056 # rewrite_inputs_into_dependencies ($OUTPUT, @INPUTS)
4057 # ---------------------------------------------------
4058 # Compute a list of dependencies appropriate for the rebuild
4059 # rule of
4060 #   AC_CONFIG_FILES($OUTPUT:$INPUT[0]:$INPUTS[1]:...)
4061 # Also distribute $INPUTs which are not built by another AC_CONFIG_FOOs.
4062 sub rewrite_inputs_into_dependencies
4064   my ($file, @inputs) = @_;
4065   my @res = ();
4067   for my $i (@inputs)
4068     {
4069       # We cannot create dependencies on shell variables.
4070       next if (substitute_ac_subst_variables $i) =~ /\$/;
4072       if (exists $ac_config_files_location{$i} && $i ne $file)
4073         {
4074           my $di = dirname $i;
4075           if ($di eq $relative_dir)
4076             {
4077               $i = basename $i;
4078             }
4079           # In the top-level Makefile we do not use $(top_builddir), because
4080           # we are already there, and since the targets are built without
4081           # a $(top_builddir), it helps BSD Make to match them with
4082           # dependencies.
4083           elsif ($relative_dir ne '.')
4084             {
4085               $i = '$(top_builddir)/' . $i;
4086             }
4087         }
4088       else
4089         {
4090           msg ('error', $ac_config_files_location{$file},
4091                "required file '$i' not found")
4092             unless $i =~ /\$/ || exists $output_files{$i} || -f $i;
4093           ($i) = prepend_srcdir ($i);
4094           push_dist_common ($i);
4095         }
4096       push @res, $i;
4097     }
4098   return @res;
4103 # handle_configure ($MAKEFILE_AM, $MAKEFILE_IN, $MAKEFILE, @INPUTS)
4104 # -----------------------------------------------------------------
4105 # Handle remaking and configure stuff.
4106 # We need the name of the input file, to do proper remaking rules.
4107 sub handle_configure
4109   my ($makefile_am, $makefile_in, $makefile, @inputs) = @_;
4111   prog_error 'empty @inputs'
4112     unless @inputs;
4114   my ($rel_makefile_am, $rel_makefile_in) = prepend_srcdir ($makefile_am,
4115                                                             $makefile_in);
4116   my $rel_makefile = basename $makefile;
4118   my $colon_infile = ':' . join (':', @inputs);
4119   $colon_infile = '' if $colon_infile eq ":$makefile.in";
4120   my @rewritten = rewrite_inputs_into_dependencies ($makefile, @inputs);
4121   my ($regen_aclocal_m4, @aclocal_m4_deps) = scan_aclocal_m4;
4122   define_pretty_variable ('am__aclocal_m4_deps', TRUE, INTERNAL,
4123                           @configure_deps, @aclocal_m4_deps,
4124                           '$(top_srcdir)/' . $configure_ac);
4125   my @configuredeps = ('$(am__aclocal_m4_deps)', '$(CONFIGURE_DEPENDENCIES)');
4126   push @configuredeps, '$(ACLOCAL_M4)' if -f 'aclocal.m4';
4127   define_pretty_variable ('am__configure_deps', TRUE, INTERNAL,
4128                           @configuredeps);
4130   my $automake_options = '--' . $strictness_name .
4131                          (global_option 'no-dependencies' ? ' --ignore-deps' : '');
4133   $output_rules .= file_contents
4134     ('configure',
4135      new Automake::Location,
4136      MAKEFILE              => $rel_makefile,
4137      'MAKEFILE-DEPS'       => "@rewritten",
4138      'CONFIG-MAKEFILE'     => ($relative_dir eq '.') ? '$@' : '$(subdir)/$@',
4139      'MAKEFILE-IN'         => $rel_makefile_in,
4140      'HAVE-MAKEFILE-IN-DEPS' => (@include_stack > 0),
4141      'MAKEFILE-IN-DEPS'    => "@include_stack",
4142      'MAKEFILE-AM'         => $rel_makefile_am,
4143      'AUTOMAKE-OPTIONS'    => $automake_options,
4144      'MAKEFILE-AM-SOURCES' => "$makefile$colon_infile",
4145      'REGEN-ACLOCAL-M4'    => $regen_aclocal_m4,
4146      VERBOSE               => verbose_flag ('GEN'));
4148   if ($relative_dir eq '.')
4149     {
4150       push_dist_common ('acconfig.h')
4151         if -f 'acconfig.h';
4152     }
4154   # If we have a configure header, require it.
4155   my $hdr_index = 0;
4156   my @distclean_config;
4157   foreach my $spec (@config_headers)
4158     {
4159       $hdr_index += 1;
4160       # $CONFIG_H_PATH: config.h from top level.
4161       my ($config_h_path, @ins) = split_config_file_spec ($spec);
4162       my $config_h_dir = dirname ($config_h_path);
4164       # If the header is in the current directory we want to build
4165       # the header here.  Otherwise, if we're at the topmost
4166       # directory and the header's directory doesn't have a
4167       # Makefile, then we also want to build the header.
4168       if ($relative_dir eq $config_h_dir
4169           || ($relative_dir eq '.' && ! is_make_dir ($config_h_dir)))
4170         {
4171           my ($cn_sans_dir, $stamp_dir);
4172           if ($relative_dir eq $config_h_dir)
4173             {
4174               $cn_sans_dir = basename ($config_h_path);
4175               $stamp_dir = '';
4176             }
4177           else
4178             {
4179               $cn_sans_dir = $config_h_path;
4180               if ($config_h_dir eq '.')
4181                 {
4182                   $stamp_dir = '';
4183                 }
4184               else
4185                 {
4186                   $stamp_dir = $config_h_dir . '/';
4187                 }
4188             }
4190           # This will also distribute all inputs.
4191           @ins = rewrite_inputs_into_dependencies ($config_h_path, @ins);
4193           # Cannot define rebuild rules for filenames with shell variables.
4194           next if (substitute_ac_subst_variables $config_h_path) =~ /\$/;
4196           # Header defined in this directory.
4197           my @files;
4198           if (-f $config_h_path . '.top')
4199             {
4200               push (@files, "$cn_sans_dir.top");
4201             }
4202           if (-f $config_h_path . '.bot')
4203             {
4204               push (@files, "$cn_sans_dir.bot");
4205             }
4207           push_dist_common (@files);
4209           # For now, acconfig.h can only appear in the top srcdir.
4210           if (-f 'acconfig.h')
4211             {
4212               push (@files, '$(top_srcdir)/acconfig.h');
4213             }
4215           my $stamp = "${stamp_dir}stamp-h${hdr_index}";
4216           $output_rules .=
4217             file_contents ('remake-hdr',
4218                            new Automake::Location,
4219                            FILES            => "@files",
4220                            'FIRST-HDR'      => ($hdr_index == 1),
4221                            CONFIG_H         => $cn_sans_dir,
4222                            CONFIG_HIN       => $ins[0],
4223                            CONFIG_H_DEPS    => "@ins",
4224                            CONFIG_H_PATH    => $config_h_path,
4225                            STAMP            => "$stamp");
4227           push @distclean_config, $cn_sans_dir, $stamp;
4228         }
4229     }
4231   $output_rules .= file_contents ('clean-hdr',
4232                                   new Automake::Location,
4233                                   FILES => "@distclean_config")
4234     if @distclean_config;
4236   # Distribute and define mkinstalldirs only if it is already present
4237   # in the package, for backward compatibility (some people may still
4238   # use $(mkinstalldirs)).
4239   # TODO: start warning about this in Automake 1.14, and have
4240   # TODO: Automake 2.0 drop it (and the mkinstalldirs script
4241   # TODO: as well).
4242   my $mkidpath = "$config_aux_dir/mkinstalldirs";
4243   if (-f $mkidpath)
4244     {
4245       # Use require_file so that any existing script gets updated
4246       # by --force-missing.
4247       require_conf_file ($mkidpath, FOREIGN, 'mkinstalldirs');
4248       define_variable ('mkinstalldirs',
4249                        "\$(SHELL) $am_config_aux_dir/mkinstalldirs", INTERNAL);
4250     }
4251   else
4252     {
4253       # Use $(install_sh), not $(MKDIR_P) because the latter requires
4254       # at least one argument, and $(mkinstalldirs) used to work
4255       # even without arguments (e.g. $(mkinstalldirs) $(conditional_dir)).
4256       define_variable ('mkinstalldirs', '$(install_sh) -d', INTERNAL);
4257     }
4259   reject_var ('CONFIG_HEADER',
4260               "'CONFIG_HEADER' is an anachronism; now determined "
4261               . "automatically\nfrom '$configure_ac'");
4263   my @config_h;
4264   foreach my $spec (@config_headers)
4265     {
4266       my ($out, @ins) = split_config_file_spec ($spec);
4267       # Generate CONFIG_HEADER define.
4268       if ($relative_dir eq dirname ($out))
4269         {
4270           push @config_h, basename ($out);
4271         }
4272       else
4273         {
4274           push @config_h, "\$(top_builddir)/$out";
4275         }
4276     }
4277   define_variable ("CONFIG_HEADER", "@config_h", INTERNAL)
4278     if @config_h;
4280   # Now look for other files in this directory which must be remade
4281   # by config.status, and generate rules for them.
4282   my @actual_other_files = ();
4283   # These get cleaned only in a VPATH build.
4284   my @actual_other_vpath_files = ();
4285   foreach my $lfile (@other_input_files)
4286     {
4287       my $file;
4288       my @inputs;
4289       if ($lfile =~ /^([^:]*):(.*)$/)
4290         {
4291           # This is the ":" syntax of AC_OUTPUT.
4292           $file = $1;
4293           @inputs = split (':', $2);
4294         }
4295       else
4296         {
4297           # Normal usage.
4298           $file = $lfile;
4299           @inputs = $file . '.in';
4300         }
4302       # Automake files should not be stored in here, but in %MAKE_LIST.
4303       prog_error ("$lfile in \@other_input_files\n"
4304                   . "\@other_input_files = (@other_input_files)")
4305         if -f $file . '.am';
4307       my $local = basename ($file);
4309       # We skip files that aren't in this directory.  However, if
4310       # the file's directory does not have a Makefile, and we are
4311       # currently doing '.', then we create a rule to rebuild the
4312       # file in the subdir.
4313       my $fd = dirname ($file);
4314       if ($fd ne $relative_dir)
4315         {
4316           if ($relative_dir eq '.' && ! is_make_dir ($fd))
4317             {
4318               $local = $file;
4319             }
4320           else
4321             {
4322               next;
4323             }
4324         }
4326       my @rewritten_inputs = rewrite_inputs_into_dependencies ($file, @inputs);
4328       # Cannot output rules for shell variables.
4329       next if (substitute_ac_subst_variables $local) =~ /\$/;
4331       my $condstr = '';
4332       my $cond = $ac_config_files_condition{$lfile};
4333       if (defined $cond)
4334         {
4335           $condstr = $cond->subst_string;
4336           Automake::Rule::define ($local, $configure_ac, RULE_AUTOMAKE, $cond,
4337                                   $ac_config_files_location{$file});
4338         }
4339       $output_rules .= ($condstr . $local . ': '
4340                         . '$(top_builddir)/config.status '
4341                         . "@rewritten_inputs\n"
4342                         . $condstr . "\t"
4343                         . 'cd $(top_builddir) && '
4344                         . '$(SHELL) ./config.status '
4345                         . ($relative_dir eq '.' ? '' : '$(subdir)/')
4346                         . '$@'
4347                         . "\n");
4348       push (@actual_other_files, $local);
4349     }
4351   # For links we should clean destinations and distribute sources.
4352   foreach my $spec (@config_links)
4353     {
4354       my ($link, $file) = split /:/, $spec;
4355       # Some people do AC_CONFIG_LINKS($computed).  We only handle
4356       # the DEST:SRC form.
4357       next unless $file;
4358       my $where = $ac_config_files_location{$link};
4360       # Skip destinations that contain shell variables.
4361       if ((substitute_ac_subst_variables $link) !~ /\$/)
4362         {
4363           # We skip links that aren't in this directory.  However, if
4364           # the link's directory does not have a Makefile, and we are
4365           # currently doing '.', then we add the link to CONFIG_CLEAN_FILES
4366           # in '.'s Makefile.in.
4367           my $local = basename ($link);
4368           my $fd = dirname ($link);
4369           if ($fd ne $relative_dir)
4370             {
4371               if ($relative_dir eq '.' && ! is_make_dir ($fd))
4372                 {
4373                   $local = $link;
4374                 }
4375               else
4376                 {
4377                   $local = undef;
4378                 }
4379             }
4380           if ($file ne $link)
4381             {
4382               push @actual_other_files, $local if $local;
4383             }
4384           else
4385             {
4386               push @actual_other_vpath_files, $local if $local;
4387             }
4388         }
4390       # Do not process sources that contain shell variables.
4391       if ((substitute_ac_subst_variables $file) !~ /\$/)
4392         {
4393           my $fd = dirname ($file);
4395           # We distribute files that are in this directory.
4396           # At the top-level ('.') we also distribute files whose
4397           # directory does not have a Makefile.
4398           if (($fd eq $relative_dir)
4399               || ($relative_dir eq '.' && ! is_make_dir ($fd)))
4400             {
4401               # The following will distribute $file as a side-effect when
4402               # it is appropriate (i.e., when $file is not already an output).
4403               # We do not need the result, just the side-effect.
4404               rewrite_inputs_into_dependencies ($link, $file);
4405             }
4406         }
4407     }
4409   # These files get removed by "make distclean".
4410   define_pretty_variable ('CONFIG_CLEAN_FILES', TRUE, INTERNAL,
4411                           @actual_other_files);
4412   define_pretty_variable ('CONFIG_CLEAN_VPATH_FILES', TRUE, INTERNAL,
4413                           @actual_other_vpath_files);
4416 sub handle_headers ()
4418     my @r = am_install_var ('-defaultdist', 'header', 'HEADERS', 'include',
4419                             'oldinclude', 'pkginclude',
4420                             'noinst', 'check');
4421     foreach (@r)
4422     {
4423       next unless $_->[1] =~ /\..*$/;
4424       saw_extension ($&);
4425     }
4428 sub handle_gettext ()
4430   return if ! $seen_gettext || $relative_dir ne '.';
4432   my $subdirs = var 'SUBDIRS';
4434   if (! $subdirs)
4435     {
4436       err_ac "AM_GNU_GETTEXT used but SUBDIRS not defined";
4437       return;
4438     }
4440   # Perform some sanity checks to help users get the right setup.
4441   # We disable these tests when po/ doesn't exist in order not to disallow
4442   # unusual gettext setups.
4443   #
4444   # Bruno Haible:
4445   # | The idea is:
4446   # |
4447   # |  1) If a package doesn't have a directory po/ at top level, it
4448   # |     will likely have multiple po/ directories in subpackages.
4449   # |
4450   # |  2) It is useful to warn for the absence of intl/ if AM_GNU_GETTEXT
4451   # |     is used without 'external'. It is also useful to warn for the
4452   # |     presence of intl/ if AM_GNU_GETTEXT([external]) is used. Both
4453   # |     warnings apply only to the usual layout of packages, therefore
4454   # |     they should both be disabled if no po/ directory is found at
4455   # |     top level.
4457   if (-d 'po')
4458     {
4459       my @subdirs = $subdirs->value_as_list_recursive;
4461       msg_var ('syntax', $subdirs,
4462                "AM_GNU_GETTEXT used but 'po' not in SUBDIRS")
4463         if ! grep ($_ eq 'po', @subdirs);
4465       # intl/ is not required when AM_GNU_GETTEXT is called with the
4466       # 'external' option and AM_GNU_GETTEXT_INTL_SUBDIR is not called.
4467       msg_var ('syntax', $subdirs,
4468                "AM_GNU_GETTEXT used but 'intl' not in SUBDIRS")
4469         if (! ($seen_gettext_external && ! $seen_gettext_intl)
4470             && ! grep ($_ eq 'intl', @subdirs));
4472       # intl/ should not be used with AM_GNU_GETTEXT([external]), except
4473       # if AM_GNU_GETTEXT_INTL_SUBDIR is called.
4474       msg_var ('syntax', $subdirs,
4475                "'intl' should not be in SUBDIRS when "
4476                . "AM_GNU_GETTEXT([external]) is used")
4477         if ($seen_gettext_external && ! $seen_gettext_intl
4478             && grep ($_ eq 'intl', @subdirs));
4479     }
4481   require_file ($ac_gettext_location, GNU, 'ABOUT-NLS');
4484 # Emit makefile footer.
4485 sub handle_footer ()
4487     reject_rule ('.SUFFIXES',
4488                  "use variable 'SUFFIXES', not target '.SUFFIXES'");
4490     # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
4491     # before .SUFFIXES.  So we make sure that .SUFFIXES appears before
4492     # anything else, by sticking it right after the default: target.
4493     $output_header .= ".SUFFIXES:\n";
4494     my $suffixes = var 'SUFFIXES';
4495     my @suffixes = Automake::Rule::suffixes;
4496     if (@suffixes || $suffixes)
4497     {
4498         # Make sure SUFFIXES has unique elements.  Sort them to ensure
4499         # the output remains consistent.  However, $(SUFFIXES) is
4500         # always at the start of the list, unsorted.  This is done
4501         # because make will choose rules depending on the ordering of
4502         # suffixes, and this lets the user have some control.  Push
4503         # actual suffixes, and not $(SUFFIXES).  Some versions of make
4504         # do not like variable substitutions on the .SUFFIXES line.
4505         my @user_suffixes = ($suffixes
4506                              ? $suffixes->value_as_list_recursive : ());
4508         my %suffixes = map { $_ => 1 } @suffixes;
4509         delete @suffixes{@user_suffixes};
4511         $output_header .= (".SUFFIXES: "
4512                            . join (' ', @user_suffixes, sort keys %suffixes)
4513                            . "\n");
4514     }
4516     $output_trailer .= file_contents ('footer', new Automake::Location);
4520 # Generate 'make install' rules.
4521 sub handle_install ()
4523   $output_rules .= file_contents
4524     ('install',
4525      new Automake::Location,
4526      maybe_BUILT_SOURCES => (set_seen ('BUILT_SOURCES')
4527                              ? (" \$(BUILT_SOURCES)\n"
4528                                 . "\t\$(MAKE) \$(AM_MAKEFLAGS)")
4529                              : ''),
4530      'installdirs-local' => (user_phony_rule ('installdirs-local')
4531                              ? ' installdirs-local' : ''),
4532      am__installdirs => variable_value ('am__installdirs') || '');
4536 # handle_all ($MAKEFILE)
4537 #-----------------------
4538 # Deal with 'all' and 'all-am'.
4539 sub handle_all
4541     my ($makefile) = @_;
4543     # Output 'all-am'.
4545     # Put this at the beginning for the sake of non-GNU makes.  This
4546     # is still wrong if these makes can run parallel jobs.  But it is
4547     # right enough.
4548     unshift (@all, basename ($makefile));
4550     foreach my $spec (@config_headers)
4551       {
4552         my ($out, @ins) = split_config_file_spec ($spec);
4553         push (@all, basename ($out))
4554           if dirname ($out) eq $relative_dir;
4555       }
4557     # Install 'all' hooks.
4558     push (@all, "all-local")
4559       if user_phony_rule "all-local";
4561     pretty_print_rule ("all-am:", "\t\t", @all);
4562     depend ('.PHONY', 'all-am', 'all');
4565     # Output 'all'.
4567     my @local_headers = ();
4568     push @local_headers, '$(BUILT_SOURCES)'
4569       if var ('BUILT_SOURCES');
4570     foreach my $spec (@config_headers)
4571       {
4572         my ($out, @ins) = split_config_file_spec ($spec);
4573         push @local_headers, basename ($out)
4574           if dirname ($out) eq $relative_dir;
4575       }
4577     if (@local_headers)
4578       {
4579         # We need to make sure config.h is built before we recurse.
4580         # We also want to make sure that built sources are built
4581         # before any ordinary 'all' targets are run.  We can't do this
4582         # by changing the order of dependencies to the "all" because
4583         # that breaks when using parallel makes.  Instead we handle
4584         # things explicitly.
4585         $output_all .= ("all: @local_headers"
4586                         . "\n\t"
4587                         . '$(MAKE) $(AM_MAKEFLAGS) '
4588                         . (var ('SUBDIRS') ? 'all-recursive' : 'all-am')
4589                         . "\n\n");
4590         depend ('.MAKE', 'all');
4591       }
4592     else
4593       {
4594         $output_all .= "all: " . (var ('SUBDIRS')
4595                                   ? 'all-recursive' : 'all-am') . "\n\n";
4596       }
4599 # Generate helper targets for user-defined recursive targets, where needed.
4600 sub handle_user_recursion ()
4602   return unless @extra_recursive_targets;
4604   define_pretty_variable ('am__extra_recursive_targets', TRUE, INTERNAL,
4605                           map { "$_-recursive" } @extra_recursive_targets);
4606   my $aux = var ('SUBDIRS') ? 'recursive' : 'am';
4607   foreach my $target (@extra_recursive_targets)
4608     {
4609       # This allows the default target's rules to be overridden in
4610       # Makefile.am.
4611       user_phony_rule ($target);
4612       depend ("$target", "$target-$aux");
4613       depend ("$target-am", "$target-local");
4614       # Every user-defined recursive target 'foo' *must* have a valid
4615       # associated 'foo-local' rule; we define it as an empty rule by
4616       # default, so that the user can transparently extend it in his
4617       # own Makefile.am.
4618       pretty_print_rule ("$target-local:", '', '');
4619       # $target-recursive might as well be undefined, so do not add
4620       # it here; it's taken care of in subdirs.am anyway.
4621       depend (".PHONY", "$target-am", "$target-local");
4622     }
4626 # Handle check merge target specially.
4627 sub do_check_merge_target ()
4629   # Include user-defined local form of target.
4630   push @check_tests, 'check-local'
4631     if user_phony_rule 'check-local';
4633   # The check target must depend on the local equivalent of
4634   # 'all', to ensure all the primary targets are built.  Then it
4635   # must build the local check rules.
4636   $output_rules .= "check-am: all-am\n";
4637   if (@check)
4638     {
4639       pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ", @check);
4640       depend ('.MAKE', 'check-am');
4641     }
4643   if (@check_tests)
4644     {
4645       pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ",
4646                          @check_tests);
4647       depend ('.MAKE', 'check-am');
4648     }
4650   depend '.PHONY', 'check', 'check-am';
4651   # Handle recursion.  We have to honor BUILT_SOURCES like for 'all:'.
4652   $output_rules .= ("check: "
4653                     . (var ('BUILT_SOURCES')
4654                        ? "\$(BUILT_SOURCES)\n\t\$(MAKE) \$(AM_MAKEFLAGS) "
4655                        : '')
4656                     . (var ('SUBDIRS') ? 'check-recursive' : 'check-am')
4657                     . "\n");
4658   depend ('.MAKE', 'check')
4659     if var ('BUILT_SOURCES');
4662 # Handle all 'clean' targets.
4663 sub handle_clean
4665   my ($makefile) = @_;
4667   # Clean the files listed in user variables if they exist.
4668   $clean_files{'$(MOSTLYCLEANFILES)'} = MOSTLY_CLEAN
4669     if var ('MOSTLYCLEANFILES');
4670   $clean_files{'$(CLEANFILES)'} = CLEAN
4671     if var ('CLEANFILES');
4672   $clean_files{'$(DISTCLEANFILES)'} = DIST_CLEAN
4673     if var ('DISTCLEANFILES');
4674   $clean_files{'$(MAINTAINERCLEANFILES)'} = MAINTAINER_CLEAN
4675     if var ('MAINTAINERCLEANFILES');
4677   # Built sources are automatically removed by maintainer-clean.
4678   $clean_files{'$(BUILT_SOURCES)'} = MAINTAINER_CLEAN
4679     if var ('BUILT_SOURCES');
4681   # Compute a list of "rm"s to run for each target.
4682   my %rms = (MOSTLY_CLEAN, [],
4683              CLEAN, [],
4684              DIST_CLEAN, [],
4685              MAINTAINER_CLEAN, []);
4687   foreach my $file (keys %clean_files)
4688     {
4689       my $when = $clean_files{$file};
4690       prog_error 'invalid entry in %clean_files'
4691         unless exists $rms{$when};
4693       my $rm = "rm -f $file";
4694       # If file is a variable, make sure when don't call 'rm -f' without args.
4695       $rm ="test -z \"$file\" || $rm"
4696         if ($file =~ /^\s*\$(\(.*\)|\{.*\})\s*$/);
4698       push @{$rms{$when}}, "\t-$rm\n";
4699     }
4701   $output_rules .= file_contents
4702     ('clean',
4703      new Automake::Location,
4704      MOSTLYCLEAN_RMS      => join ('', sort @{$rms{&MOSTLY_CLEAN}}),
4705      CLEAN_RMS            => join ('', sort @{$rms{&CLEAN}}),
4706      DISTCLEAN_RMS        => join ('', sort @{$rms{&DIST_CLEAN}}),
4707      MAINTAINER_CLEAN_RMS => join ('', sort @{$rms{&MAINTAINER_CLEAN}}),
4708      MAKEFILE             => basename $makefile,
4709      );
4713 # Subroutine for handle_factored_dependencies() to let '.PHONY' and
4714 # other '.TARGETS' be last.  This is meant to be used as a comparison
4715 # subroutine passed to the sort built-int.
4716 sub target_cmp
4718   return 0 if $a eq $b;
4720   my $a1 = substr ($a, 0, 1);
4721   my $b1 = substr ($b, 0, 1);
4722   if ($a1 ne $b1)
4723     {
4724       return -1 if $b1 eq '.';
4725       return 1 if $a1 eq '.';
4726     }
4727   return $a cmp $b;
4731 # Handle everything related to gathered targets.
4732 sub handle_factored_dependencies ()
4734   # Reject bad hooks.
4735   foreach my $utarg ('uninstall-data-local', 'uninstall-data-hook',
4736                      'uninstall-exec-local', 'uninstall-exec-hook',
4737                      'uninstall-dvi-local',
4738                      'uninstall-html-local',
4739                      'uninstall-info-local',
4740                      'uninstall-pdf-local',
4741                      'uninstall-ps-local')
4742     {
4743       my $x = $utarg;
4744       $x =~ s/-.*-/-/;
4745       reject_rule ($utarg, "use '$x', not '$utarg'");
4746     }
4748   reject_rule ('install-local',
4749                "use 'install-data-local' or 'install-exec-local', "
4750                . "not 'install-local'");
4752   reject_rule ('install-hook',
4753                "use 'install-data-hook' or 'install-exec-hook', "
4754                . "not 'install-hook'");
4756   # Install the -local hooks.
4757   foreach (keys %dependencies)
4758     {
4759       # Hooks are installed on the -am targets.
4760       s/-am$// or next;
4761       depend ("$_-am", "$_-local")
4762         if user_phony_rule "$_-local";
4763     }
4765   # Install the -hook hooks.
4766   # FIXME: Why not be as liberal as we are with -local hooks?
4767   foreach ('install-exec', 'install-data', 'uninstall')
4768     {
4769       if (user_phony_rule "$_-hook")
4770         {
4771           depend ('.MAKE', "$_-am");
4772           register_action("$_-am",
4773                           ("\t\@\$(NORMAL_INSTALL)\n"
4774                            . "\t\$(MAKE) \$(AM_MAKEFLAGS) $_-hook"));
4775         }
4776     }
4778   # All the required targets are phony.
4779   depend ('.PHONY', keys %required_targets);
4781   # Actually output gathered targets.
4782   foreach (sort target_cmp keys %dependencies)
4783     {
4784       # If there is nothing about this guy, skip it.
4785       next
4786         unless (@{$dependencies{$_}}
4787                 || $actions{$_}
4788                 || $required_targets{$_});
4790       # Define gathered targets in undefined conditions.
4791       # FIXME: Right now we must handle .PHONY as an exception,
4792       # because people write things like
4793       #    .PHONY: myphonytarget
4794       # to append dependencies.  This would not work if Automake
4795       # refrained from defining its own .PHONY target as it does
4796       # with other overridden targets.
4797       # Likewise for '.MAKE' and '.PRECIOUS'.
4798       my @undefined_conds = (TRUE,);
4799       if ($_ ne '.PHONY' && $_ ne '.MAKE' && $_ ne '.PRECIOUS')
4800         {
4801           @undefined_conds =
4802             Automake::Rule::define ($_, 'internal',
4803                                     RULE_AUTOMAKE, TRUE, INTERNAL);
4804         }
4805       my @uniq_deps = uniq (sort @{$dependencies{$_}});
4806       foreach my $cond (@undefined_conds)
4807         {
4808           my $condstr = $cond->subst_string;
4809           pretty_print_rule ("$condstr$_:", "$condstr\t", @uniq_deps);
4810           $output_rules .= $actions{$_} if defined $actions{$_};
4811           $output_rules .= "\n";
4812         }
4813     }
4817 sub handle_tests_dejagnu ()
4819     push (@check_tests, 'check-DEJAGNU');
4820     $output_rules .= file_contents ('dejagnu', new Automake::Location);
4823 # handle_per_suffix_test ($TEST_SUFFIX, [%TRANSFORM])
4824 #----------------------------------------------------
4825 sub handle_per_suffix_test
4827   my ($test_suffix, %transform) = @_;
4828   my ($pfx, $generic, $am_exeext);
4829   if ($test_suffix eq '')
4830     {
4831       $pfx = '';
4832       $generic = 0;
4833       $am_exeext = 'FALSE';
4834     }
4835   else
4836     {
4837       prog_error ("test suffix '$test_suffix' lacks leading dot")
4838         unless $test_suffix =~ m/^\.(.*)/;
4839       $pfx = uc ($1) . '_';
4840       $generic = 1;
4841       $am_exeext = exists $configure_vars{'EXEEXT'} ? 'am__EXEEXT'
4842                                                     : 'FALSE';
4843     }
4844   # The "test driver" program, deputed to handle tests protocol used by
4845   # test scripts.  By default, it's assumed that no protocol is used, so
4846   # we fall back to the old behaviour, implemented by the 'test-driver'
4847   # auxiliary script.
4848   if (! var "${pfx}LOG_DRIVER")
4849     {
4850       require_conf_file ("parallel-tests", FOREIGN, 'test-driver');
4851       define_variable ("${pfx}LOG_DRIVER",
4852                        "\$(SHELL) $am_config_aux_dir/test-driver",
4853                        INTERNAL);
4854     }
4855   my $driver = '$(' . $pfx . 'LOG_DRIVER)';
4856   my $driver_flags = '$(AM_' . $pfx . 'LOG_DRIVER_FLAGS)'
4857                        . ' $(' . $pfx . 'LOG_DRIVER_FLAGS)';
4858   my $compile = "${pfx}LOG_COMPILE";
4859   define_variable ($compile,
4860                    '$(' . $pfx . 'LOG_COMPILER)'
4861                       . ' $(AM_' .  $pfx . 'LOG_FLAGS)'
4862                       . ' $(' . $pfx . 'LOG_FLAGS)',
4863                      INTERNAL);
4864   $output_rules .= file_contents ('check2', new Automake::Location,
4865                                    GENERIC => $generic,
4866                                    DRIVER => $driver,
4867                                    DRIVER_FLAGS => $driver_flags,
4868                                    COMPILE => '$(' . $compile . ')',
4869                                    EXT => $test_suffix,
4870                                    am__EXEEXT => $am_exeext,
4871                                    %transform);
4874 # is_valid_test_extension ($EXT)
4875 # ------------------------------
4876 # Return true if $EXT can appear in $(TEST_EXTENSIONS), return false
4877 # otherwise.
4878 sub is_valid_test_extension
4880   my $ext = shift;
4881   return 1
4882     if ($ext =~ /^\.[a-zA-Z_][a-zA-Z0-9_]*$/);
4883   return 1
4884     if (exists $configure_vars{'EXEEXT'} && $ext eq subst ('EXEEXT'));
4885   return 0;
4889 sub handle_tests ()
4891   if (option 'dejagnu')
4892     {
4893       handle_tests_dejagnu;
4894     }
4895   else
4896     {
4897       foreach my $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
4898         {
4899           reject_var ($c, "'$c' defined but 'dejagnu' not in "
4900                       . "'AUTOMAKE_OPTIONS'");
4901         }
4902     }
4904   if (var ('TESTS'))
4905     {
4906       push (@check_tests, 'check-TESTS');
4907       my $check_deps = "@check";
4908       $output_rules .= file_contents ('check', new Automake::Location,
4909                                       SERIAL_TESTS => !! option 'serial-tests',
4910                                       CHECK_DEPS => $check_deps);
4912       # Tests that are known programs should have $(EXEEXT) appended.
4913       # For matching purposes, we need to adjust XFAIL_TESTS as well.
4914       append_exeext { exists $known_programs{$_[0]} } 'TESTS';
4915       append_exeext { exists $known_programs{$_[0]} } 'XFAIL_TESTS'
4916         if (var ('XFAIL_TESTS'));
4918       if (! option 'serial-tests')
4919         {
4920           define_variable ('TEST_SUITE_LOG', 'test-suite.log', INTERNAL);
4921           my $suff = '.test';
4922           my $at_exeext = '';
4923           my $handle_exeext = exists $configure_vars{'EXEEXT'};
4924           if ($handle_exeext)
4925             {
4926               $at_exeext = subst ('EXEEXT');
4927               $suff = $at_exeext  . ' ' . $suff;
4928             }
4929           if (! var 'TEST_EXTENSIONS')
4930             {
4931               define_variable ('TEST_EXTENSIONS', $suff, INTERNAL);
4932             }
4933           my $var = var 'TEST_EXTENSIONS';
4934           # Currently, we are not able to deal with conditional contents
4935           # in TEST_EXTENSIONS.
4936           if ($var->has_conditional_contents)
4937            {
4938              msg_var 'unsupported', $var,
4939                      "'TEST_EXTENSIONS' cannot have conditional contents";
4940            }
4941           my @test_suffixes = $var->value_as_list_recursive;
4942           if ((my @invalid_test_suffixes =
4943                   grep { !is_valid_test_extension $_ } @test_suffixes) > 0)
4944             {
4945               error $var->rdef (TRUE)->location,
4946                     "invalid test extensions: @invalid_test_suffixes";
4947             }
4948           @test_suffixes = grep { is_valid_test_extension $_ } @test_suffixes;
4949           if ($handle_exeext)
4950             {
4951               unshift (@test_suffixes, $at_exeext)
4952                 unless $test_suffixes[0] eq $at_exeext;
4953             }
4954           unshift (@test_suffixes, '');
4956           transform_variable_recursively
4957             ('TESTS', 'TEST_LOGS', 'am__testlogs', 1, INTERNAL,
4958               sub {
4959                 my ($subvar, $val, $cond, $full_cond) = @_;
4960                 my $obj = $val;
4961                 return $obj
4962                   if $val =~ /^\@.*\@$/;
4963                 $obj =~ s/\$\(EXEEXT\)$//o;
4965                 if ($val =~ /(\$\((top_)?srcdir\))\//o)
4966                   {
4967                     msg ('error', $subvar->rdef ($cond)->location,
4968                          "using '$1' in TESTS is currently broken: '$val'");
4969                   }
4971                 foreach my $test_suffix (@test_suffixes)
4972                   {
4973                     next
4974                       if $test_suffix eq $at_exeext || $test_suffix eq '';
4975                     return substr ($obj, 0, length ($obj) - length ($test_suffix)) . '.log'
4976                       if substr ($obj, - length ($test_suffix)) eq $test_suffix;
4977                   }
4978                 my $base = $obj;
4979                 $obj .= '.log';
4980                 handle_per_suffix_test ('',
4981                                         OBJ => $obj,
4982                                         BASE => $base,
4983                                         SOURCE => $val);
4984                 return $obj;
4985               });
4987           my $nhelper=1;
4988           my $prev = 'TESTS';
4989           my $post = '';
4990           my $last_suffix = $test_suffixes[$#test_suffixes];
4991           my $cur = '';
4992           foreach my $test_suffix (@test_suffixes)
4993             {
4994               if ($test_suffix eq $last_suffix)
4995                 {
4996                   $cur = 'TEST_LOGS';
4997                 }
4998               else
4999                 {
5000                   $cur = 'am__test_logs' . $nhelper;
5001                 }
5002               define_variable ($cur,
5003                 '$(' . $prev . ':' . $test_suffix . $post . '=.log)', INTERNAL);
5004               $post = '.log';
5005               $prev = $cur;
5006               $nhelper++;
5007               if ($test_suffix ne $at_exeext && $test_suffix ne '')
5008                 {
5009                   handle_per_suffix_test ($test_suffix,
5010                                           OBJ => '',
5011                                           BASE => '$*',
5012                                           SOURCE => '$<');
5013                 }
5014             }
5015           $clean_files{'$(TEST_LOGS)'} = MOSTLY_CLEAN;
5016           $clean_files{'$(TEST_LOGS:.log=.trs)'} = MOSTLY_CLEAN;
5017           $clean_files{'$(TEST_SUITE_LOG)'} = MOSTLY_CLEAN;
5018         }
5019     }
5022 sub handle_emacs_lisp ()
5024   my @elfiles = am_install_var ('-candist', 'lisp', 'LISP',
5025                                 'lisp', 'noinst');
5027   return if ! @elfiles;
5029   define_pretty_variable ('am__ELFILES', TRUE, INTERNAL,
5030                           map { $_->[1] } @elfiles);
5031   define_pretty_variable ('am__ELCFILES', TRUE, INTERNAL,
5032                           '$(am__ELFILES:.el=.elc)');
5033   # This one can be overridden by users.
5034   define_pretty_variable ('ELCFILES', TRUE, INTERNAL, '$(LISP:.el=.elc)');
5036   push @all, '$(ELCFILES)';
5038   require_variables ($elfiles[0][0], "Emacs Lisp sources seen", TRUE,
5039                      'EMACS', 'lispdir');
5042 sub handle_python ()
5044   my @pyfiles = am_install_var ('-defaultdist', 'python', 'PYTHON',
5045                                 'noinst');
5046   return if ! @pyfiles;
5048   require_variables ($pyfiles[0][0], "Python sources seen", TRUE, 'PYTHON');
5049   require_conf_file ($pyfiles[0][0], FOREIGN, 'py-compile');
5050   define_variable ('py_compile', "$am_config_aux_dir/py-compile", INTERNAL);
5053 sub handle_java ()
5055     my @sourcelist = am_install_var ('-candist',
5056                                      'java', 'JAVA',
5057