automake.in

   1 #!@PERL@ -w
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval 'case $# in 0) exec @PERL@ -S "$0";; *) exec @PERL@ -S "$0" "$@";; esac'
   6     if 0;
   7
   8 # automake - create Makefile.in from Makefile.am
   9 # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
  10 # 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
  11 # Foundation, Inc.
  12
  13 # This program is free software; you can redistribute it and/or modify
  14 # it under the terms of the GNU General Public License as published by
  15 # the Free Software Foundation; either version 2, or (at your option)
  16 # any later version.
  17
  18 # This program is distributed in the hope that it will be useful,
  19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 # GNU General Public License for more details.
  22
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 # Originally written by David Mackenzie <djm@gnu.ai.mit.edu>.
  27 # Perl reimplementation by Tom Tromey <tromey@redhat.com>, and
  28 # Alexandre Duret-Lutz <adl@gnu.org>.
  29
  30 package Language;
  31
  32 BEGIN
  33 {
  34   my $perllibdir = $ENV{'perllibdir'} || '@datadir@/@PACKAGE@-@APIVERSION@';
  35   unshift @INC, (split '@PATH_SEPARATOR@', $perllibdir);
  36
  37   # Override SHELL.  This is required on DJGPP so that system() uses
  38   # bash, not COMMAND.COM which doesn't quote arguments properly.
  39   # Other systems aren't expected to use $SHELL when Automake
  40   # runs, but it should be safe to drop the `if DJGPP' guard if
  41   # it turns up other systems need the same thing.  After all,
  42   # if SHELL is used, ./configure's SHELL is always better than
  43   # the user's SHELL (which may be something like tcsh).
  44   $ENV{'SHELL'} = '@SHELL@' if exists $ENV{'DJDIR'};
  45 }
  46
  47 use Automake::Struct;
  48 struct (# Short name of the language (c, f77...).
  49         'name' => "\$",
  50         # Nice name of the language (C, Fortran 77...).
  51         'Name' => "\$",
  52
  53         # List of configure variables which must be defined.
  54         'config_vars' => '@',
  55
  56         'ansi'    => "\$",
  57         # `pure' is `1' or `'.  A `pure' language is one where, if
  58         # all the files in a directory are of that language, then we
  59         # do not require the C compiler or any code to call it.
  60         'pure'   => "\$",
  61
  62         'autodep' => "\$",
  63
  64         # Name of the compiling variable (COMPILE).
  65         'compiler'  => "\$",
  66         # Content of the compiling variable.
  67         'compile'  => "\$",
  68         # Flag to require compilation without linking (-c).
  69         'compile_flag' => "\$",
  70         'extensions' => '@',
  71         # A subroutine to compute a list of possible extensions of
  72         # the product given the input extensions.
  73         # (defaults to a subroutine which returns ('.$(OBJEXT)', '.lo'))
  74         'output_extensions' => "\$",
  75         # A list of flag variables used in 'compile'.
  76         # (defaults to [])
  77         'flags' => "@",
  78
  79         # Any tag to pass to libtool while compiling.
  80         'libtool_tag' => "\$",
  81
  82         # The file to use when generating rules for this language.
  83         # The default is 'depend2'.
  84         'rule_file' => "\$",
  85
  86         # Name of the linking variable (LINK).
  87         'linker' => "\$",
  88         # Content of the linking variable.
  89         'link' => "\$",
  90
  91         # Name of the compiler variable (CC).
  92         'ccer' => "\$",
  93
  94         # Name of the linker variable (LD).
  95         'lder' => "\$",
  96         # Content of the linker variable ($(CC)).
  97         'ld' => "\$",
  98
  99         # Flag to specify the output file (-o).
 100         'output_flag' => "\$",
 101         '_finish' => "\$",
 102
 103         # This is a subroutine which is called whenever we finally
 104         # determine the context in which a source file will be
 105         # compiled.
 106         '_target_hook' => "\$",
 107
 108         # If TRUE, nodist_ sources will be compiled using specific rules
 109         # (i.e. not inference rules).  The default is FALSE.
 110         'nodist_specific' => "\$");
 111
 112
 113 sub finish ($)
 114 {
 115   my ($self) = @_;
 116   if (defined $self->_finish)
 117     {
 118       &{$self->_finish} (@_);
 119     }
 120 }
 121
 122 sub target_hook ($$$$%)
 123 {
 124     my ($self) = @_;
 125     if (defined $self->_target_hook)
 126     {
 127         &{$self->_target_hook} (@_);
 128     }
 129 }
 130
 131 package Automake;
 132
 133 use strict;
 134 use Automake::Config;
 135 BEGIN
 136 {
 137   if ($perl_threads)
 138     {
 139       require threads;
 140       import threads;
 141       require Thread::Queue;
 142       import Thread::Queue;
 143     }
 144 }
 145 use Automake::General;
 146 use Automake::XFile;
 147 use Automake::Channels;
 148 use Automake::ChannelDefs;
 149 use Automake::Configure_ac;
 150 use Automake::FileUtils;
 151 use Automake::Location;
 152 use Automake::Condition qw/TRUE FALSE/;
 153 use Automake::DisjConditions;
 154 use Automake::Options;
 155 use Automake::Version;
 156 use Automake::Variable;
 157 use Automake::VarDef;
 158 use Automake::Rule;
 159 use Automake::RuleDef;
 160 use Automake::Wrap 'makefile_wrap';
 161 use File::Basename;
 162 use File::Spec;
 163 use Carp;
 164
 165 ## ----------- ##
 166 ## Constants.  ##
 167 ## ----------- ##
 168
 169 # Some regular expressions.  One reason to put them here is that it
 170 # makes indentation work better in Emacs.
 171
 172 # Writing singled-quoted-$-terminated regexes is a pain because
 173 # perl-mode thinks of $' as the ${'} variable (instead of a $ followed
 174 # by a closing quote.  Letting perl-mode think the quote is not closed
 175 # leads to all sort of misindentations.  On the other hand, defining
 176 # regexes as double-quoted strings is far less readable.  So usually
 177 # we will write:
 178 #
 179 #  $REGEX = '^regex_value' . "\$";
 180
 181 my $IGNORE_PATTERN = '^\s*##([^#\n].*)?\n';
 182 my $WHITE_PATTERN = '^\s*' . "\$";
 183 my $COMMENT_PATTERN = '^#';
 184 my $TARGET_PATTERN='[$a-zA-Z0-9_.@%][-.a-zA-Z0-9_(){}/$+@%]*';
 185 # A rule has three parts: a list of targets, a list of dependencies,
 186 # and optionally actions.
 187 my $RULE_PATTERN =
 188   "^($TARGET_PATTERN(?:(?:\\\\\n|\\s)+$TARGET_PATTERN)*) *:([^=].*|)\$";
 189
 190 # Only recognize leading spaces, not leading tabs.  If we recognize
 191 # leading tabs here then we need to make the reader smarter, because
 192 # otherwise it will think rules like `foo=bar; \' are errors.
 193 my $ASSIGNMENT_PATTERN = '^ *([^ \t=:+]*)\s*([:+]?)=\s*(.*)' . "\$";
 194 # This pattern recognizes a Gnits version id and sets $1 if the
 195 # release is an alpha release.  We also allow a suffix which can be
 196 # used to extend the version number with a "fork" identifier.
 197 my $GNITS_VERSION_PATTERN = '\d+\.\d+([a-z]|\.\d+)?(-[A-Za-z0-9]+)?';
 198
 199 my $IF_PATTERN = '^if\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*)\s*(?:#.*)?' . "\$";
 200 my $ELSE_PATTERN =
 201   '^else(?:\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*))?\s*(?:#.*)?' . "\$";
 202 my $ENDIF_PATTERN =
 203   '^endif(?:\s+(!?)\s*([A-Za-z][A-Za-z0-9_]*))?\s*(?:#.*)?' . "\$";
 204 my $PATH_PATTERN = '(\w|[+/.-])+';
 205 # This will pass through anything not of the prescribed form.
 206 my $INCLUDE_PATTERN = ('^include\s+'
 207                        . '((\$\(top_srcdir\)/' . $PATH_PATTERN . ')'
 208                        . '|(\$\(srcdir\)/' . $PATH_PATTERN . ')'
 209                        . '|([^/\$]' . $PATH_PATTERN . '))\s*(#.*)?' . "\$");
 210
 211 # Match `-d' as a command-line argument in a string.
 212 my $DASH_D_PATTERN = "(^|\\s)-d(\\s|\$)";
 213 # Directories installed during 'install-exec' phase.
 214 my $EXEC_DIR_PATTERN =
 215   '^(?:bin|sbin|libexec|sysconf|localstate|lib|pkglib|.*exec.*)' . "\$";
 216
 217 # Values for AC_CANONICAL_*
 218 use constant AC_CANONICAL_BUILD  => 1;
 219 use constant AC_CANONICAL_HOST   => 2;
 220 use constant AC_CANONICAL_TARGET => 3;
 221
 222 # Values indicating when something should be cleaned.
 223 use constant MOSTLY_CLEAN     => 0;
 224 use constant CLEAN            => 1;
 225 use constant DIST_CLEAN       => 2;
 226 use constant MAINTAINER_CLEAN => 3;
 227
 228 # Libtool files.
 229 my @libtool_files = qw(ltmain.sh config.guess config.sub);
 230 # ltconfig appears here for compatibility with old versions of libtool.
 231 my @libtool_sometimes = qw(ltconfig ltcf-c.sh ltcf-cxx.sh ltcf-gcj.sh);
 232
 233 # Commonly found files we look for and automatically include in
 234 # DISTFILES.
 235 my @common_files =
 236     (qw(ABOUT-GNU ABOUT-NLS AUTHORS BACKLOG COPYING COPYING.DOC COPYING.LIB
 237         COPYING.LESSER ChangeLog INSTALL NEWS README THANKS TODO
 238         ansi2knr.1 ansi2knr.c ar-lib compile config.guess config.rpath
 239         config.sub depcomp elisp-comp install-sh libversion.in mdate-sh
 240         missing mkinstalldirs py-compile texinfo.tex ylwrap),
 241      @libtool_files, @libtool_sometimes);
 242
 243 # Commonly used files we auto-include, but only sometimes.  This list
 244 # is used for the --help output only.
 245 my @common_sometimes =
 246   qw(aclocal.m4 acconfig.h config.h.top config.h.bot configure
 247      configure.ac configure.in stamp-vti);
 248
 249 # Standard directories from the GNU Coding Standards, and additional
 250 # pkg* directories from Automake.  Stored in a hash for fast member check.
 251 my %standard_prefix =
 252     map { $_ => 1 } (qw(bin data dataroot doc dvi exec html include info
 253                         lib libexec lisp locale localstate man man1 man2
 254                         man3 man4 man5 man6 man7 man8 man9 oldinclude pdf
 255                         pkgdata pkginclude pkglib pkglibexec ps sbin
 256                         sharedstate sysconf));
 257
 258 # Copyright on generated Makefile.ins.
 259 my $gen_copyright = "\
 260 # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
 261 # 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
 262 # Foundation, Inc.
 263 # This Makefile.in is free software; the Free Software Foundation
 264 # gives unlimited permission to copy and/or distribute it,
 265 # with or without modifications, as long as this notice is preserved.
 266
 267 # This program is distributed in the hope that it will be useful,
 268 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 269 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 270 # PARTICULAR PURPOSE.
 271 ";
 272
 273 # These constants are returned by the lang_*_rewrite functions.
 274 # LANG_SUBDIR means that the resulting object file should be in a
 275 # subdir if the source file is.  In this case the file name cannot
 276 # have `..' components.
 277 use constant LANG_IGNORE  => 0;
 278 use constant LANG_PROCESS => 1;
 279 use constant LANG_SUBDIR  => 2;
 280
 281 # These are used when keeping track of whether an object can be built
 282 # by two different paths.
 283 use constant COMPILE_LIBTOOL  => 1;
 284 use constant COMPILE_ORDINARY => 2;
 285
 286 # We can't always associate a location to a variable or a rule,
 287 # when it's defined by Automake.  We use INTERNAL in this case.
 288 use constant INTERNAL => new Automake::Location;
 289
 290 # Serialization keys for message queues.
 291 use constant QUEUE_MESSAGE   => "msg";
 292 use constant QUEUE_CONF_FILE => "conf file";
 293 use constant QUEUE_LOCATION  => "location";
 294 use constant QUEUE_STRING    => "string";
 295 \f
 296
 297 ## ---------------------------------- ##
 298 ## Variables related to the options.  ##
 299 ## ---------------------------------- ##
 300
 301 # TRUE if we should always generate Makefile.in.
 302 my $force_generation = 1;
 303
 304 # From the Perl manual.
 305 my $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
 306
 307 # TRUE if missing standard files should be installed.
 308 my $add_missing = 0;
 309
 310 # TRUE if we should copy missing files; otherwise symlink if possible.
 311 my $copy_missing = 0;
 312
 313 # TRUE if we should always update files that we know about.
 314 my $force_missing = 0;
 315
 316
 317 ## ---------------------------------------- ##
 318 ## Variables filled during files scanning.  ##
 319 ## ---------------------------------------- ##
 320
 321 # Name of the configure.ac file.
 322 my $configure_ac;
 323
 324 # Files found by scanning configure.ac for LIBOBJS.
 325 my %libsources = ();
 326
 327 # Names used in AC_CONFIG_HEADER call.
 328 my @config_headers = ();
 329
 330 # Names used in AC_CONFIG_LINKS call.
 331 my @config_links = ();
 332
 333 # Directory where output files go.  Actually, output files are
 334 # relative to this directory.
 335 my $output_directory;
 336
 337 # List of Makefile.am's to process, and their corresponding outputs.
 338 my @input_files = ();
 339 my %output_files = ();
 340
 341 # Complete list of Makefile.am's that exist.
 342 my @configure_input_files = ();
 343
 344 # List of files in AC_CONFIG_FILES/AC_OUTPUT without Makefile.am's,
 345 # and their outputs.
 346 my @other_input_files = ();
 347 # Where each AC_CONFIG_FILES/AC_OUTPUT/AC_CONFIG_LINK/AC_CONFIG_HEADER appears.
 348 # The keys are the files created by these macros.
 349 my %ac_config_files_location = ();
 350 # The condition under which AC_CONFIG_FOOS appears.
 351 my %ac_config_files_condition = ();
 352
 353 # Directory to search for configure-required files.  This
 354 # will be computed by &locate_aux_dir and can be set using
 355 # AC_CONFIG_AUX_DIR in configure.ac.
 356 # $CONFIG_AUX_DIR is the `raw' directory, valid only in the source-tree.
 357 my $config_aux_dir = '';
 358 my $config_aux_dir_set_in_configure_ac = 0;
 359 # $AM_CONFIG_AUX_DIR is prefixed with $(top_srcdir), so it can be used
 360 # in Makefiles.
 361 my $am_config_aux_dir = '';
 362
 363 # Directory to search for AC_LIBSOURCE files, as set by AC_CONFIG_LIBOBJ_DIR
 364 # in configure.ac.
 365 my $config_libobj_dir = '';
 366
 367 # Whether AM_GNU_GETTEXT has been seen in configure.ac.
 368 my $seen_gettext = 0;
 369 # Whether AM_GNU_GETTEXT([external]) is used.
 370 my $seen_gettext_external = 0;
 371 # Where AM_GNU_GETTEXT appears.
 372 my $ac_gettext_location;
 373 # Whether AM_GNU_GETTEXT_INTL_SUBDIR has been seen.
 374 my $seen_gettext_intl = 0;
 375
 376 # Lists of tags supported by Libtool.
 377 my %libtool_tags = ();
 378 # 1 if Libtool uses LT_SUPPORTED_TAG.  If it does, then it also
 379 # uses AC_REQUIRE_AUX_FILE.
 380 my $libtool_new_api = 0;
 381
 382 # Most important AC_CANONICAL_* macro seen so far.
 383 my $seen_canonical = 0;
 384 # Location of that macro.
 385 my $canonical_location;
 386
 387 # Where AM_MAINTAINER_MODE appears.
 388 my $seen_maint_mode;
 389
 390 # Actual version we've seen.
 391 my $package_version = '';
 392
 393 # Where version is defined.
 394 my $package_version_location;
 395
 396 # TRUE if we've seen AM_ENABLE_MULTILIB.
 397 my $seen_multilib = 0;
 398
 399 # TRUE if we've seen AM_PROG_AR
 400 my $seen_ar = 0;
 401
 402 # TRUE if we've seen AM_PROG_CC_C_O
 403 my $seen_cc_c_o = 0;
 404
 405 # Location of AC_REQUIRE_AUX_FILE calls, indexed by their argument.
 406 my %required_aux_file = ();
 407
 408 # Where AM_INIT_AUTOMAKE is called;
 409 my $seen_init_automake = 0;
 410
 411 # TRUE if we've seen AM_AUTOMAKE_VERSION.
 412 my $seen_automake_version = 0;
 413
 414 # Hash table of discovered configure substitutions.  Keys are names,
 415 # values are `FILE:LINE' strings which are used by error message
 416 # generation.
 417 my %configure_vars = ();
 418
 419 # Ignored configure substitutions (i.e., variables not to be output in
 420 # Makefile.in)
 421 my %ignored_configure_vars = ();
 422
 423 # Files included by $configure_ac.
 424 my @configure_deps = ();
 425
 426 # Greatest timestamp of configure's dependencies.
 427 my $configure_deps_greatest_timestamp = 0;
 428
 429 # Hash table of AM_CONDITIONAL variables seen in configure.
 430 my %configure_cond = ();
 431
 432 # This maps extensions onto language names.
 433 my %extension_map = ();
 434
 435 # List of the DIST_COMMON files we discovered while reading
 436 # configure.in
 437 my $configure_dist_common = '';
 438
 439 # This maps languages names onto objects.
 440 my %languages = ();
 441 # Maps each linker variable onto a language object.
 442 my %link_languages = ();
 443
 444 # maps extensions to needed source flags.
 445 my %sourceflags = ();
 446
 447 # List of targets we must always output.
 448 # FIXME: Complete, and remove falsely required targets.
 449 my %required_targets =
 450   (
 451    'all'          => 1,
 452    'dvi'          => 1,
 453    'pdf'          => 1,
 454    'ps'           => 1,
 455    'info'         => 1,
 456    'install-info' => 1,
 457    'install'      => 1,
 458    'install-data' => 1,
 459    'install-exec' => 1,
 460    'uninstall'    => 1,
 461
 462    # FIXME: Not required, temporary hacks.
 463    # Well, actually they are sort of required: the -recursive
 464    # targets will run them anyway...
 465    'html-am'         => 1,
 466    'dvi-am'          => 1,
 467    'pdf-am'          => 1,
 468    'ps-am'           => 1,
 469    'info-am'         => 1,
 470    'install-data-am' => 1,
 471    'install-exec-am' => 1,
 472    'install-html-am' => 1,
 473    'install-dvi-am'  => 1,
 474    'install-pdf-am'  => 1,
 475    'install-ps-am'   => 1,
 476    'install-info-am' => 1,
 477    'installcheck-am' => 1,
 478    'uninstall-am' => 1,
 479
 480    'install-man' => 1,
 481   );
 482
 483 # Set to 1 if this run will create the Makefile.in that distributes
 484 # the files in config_aux_dir.
 485 my $automake_will_process_aux_dir = 0;
 486
 487 # The name of the Makefile currently being processed.
 488 my $am_file = 'BUG';
 489 \f
 490
 491 ################################################################
 492
 493 ## ------------------------------------------ ##
 494 ## Variables reset by &initialize_per_input.  ##
 495 ## ------------------------------------------ ##
 496
 497 # Basename and relative dir of the input file.
 498 my $am_file_name;
 499 my $am_relative_dir;
 500
 501 # Same but wrt Makefile.in.
 502 my $in_file_name;
 503 my $relative_dir;
 504
 505 # Relative path to the top directory.
 506 my $topsrcdir;
 507
 508 # Greatest timestamp of the output's dependencies (excluding
 509 # configure's dependencies).
 510 my $output_deps_greatest_timestamp;
 511
 512 # These variables are used when generating each Makefile.in.
 513 # They hold the Makefile.in until it is ready to be printed.
 514 my $output_vars;
 515 my $output_all;
 516 my $output_header;
 517 my $output_rules;
 518 my $output_trailer;
 519
 520 # This is the conditional stack, updated on if/else/endif, and
 521 # used to build Condition objects.
 522 my @cond_stack;
 523
 524 # This holds the set of included files.
 525 my @include_stack;
 526
 527 # List of dependencies for the obvious targets.
 528 my @all;
 529 my @check;
 530 my @check_tests;
 531
 532 # Keys in this hash table are files to delete.  The associated
 533 # value tells when this should happen (MOSTLY_CLEAN, DIST_CLEAN, etc.)
 534 my %clean_files;
 535
 536 # Keys in this hash table are object files or other files in
 537 # subdirectories which need to be removed.  This only holds files
 538 # which are created by compilations.  The value in the hash indicates
 539 # when the file should be removed.
 540 my %compile_clean_files;
 541
 542 # Keys in this hash table are directories where we expect to build a
 543 # libtool object.  We use this information to decide what directories
 544 # to delete.
 545 my %libtool_clean_directories;
 546
 547 # Value of `$(SOURCES)', used by tags.am.
 548 my @sources;
 549 # Sources which go in the distribution.
 550 my @dist_sources;
 551
 552 # This hash maps object file names onto their corresponding source
 553 # file names.  This is used to ensure that each object is created
 554 # by a single source file.
 555 my %object_map;
 556
 557 # This hash maps object file names onto an integer value representing
 558 # whether this object has been built via ordinary compilation or
 559 # libtool compilation (the COMPILE_* constants).
 560 my %object_compilation_map;
 561
 562
 563 # This keeps track of the directories for which we've already
 564 # created dirstamp code.  Keys are directories, values are stamp files.
 565 # Several keys can share the same stamp files if they are equivalent
 566 # (as are `.//foo' and `foo').
 567 my %directory_map;
 568
 569 # All .P files.
 570 my %dep_files;
 571
 572 # This is a list of all targets to run during "make dist".
 573 my @dist_targets;
 574
 575 # Keep track of all programs declared in this Makefile, without
 576 # $(EXEEXT).  @substitutions@ are not listed.
 577 my %known_programs;
 578 my %known_libraries;
 579
 580 # Keys in this hash are the basenames of files which must depend on
 581 # ansi2knr.  Values are either the empty string, or the directory in
 582 # which the ANSI source file appears; the directory must have a
 583 # trailing `/'.
 584 my %de_ansi_files;
 585
 586 # This keeps track of which extensions we've seen (that we care
 587 # about).
 588 my %extension_seen;
 589
 590 # This is random scratch space for the language finish functions.
 591 # Don't randomly overwrite it; examine other uses of keys first.
 592 my %language_scratch;
 593
 594 # We keep track of which objects need special (per-executable)
 595 # handling on a per-language basis.
 596 my %lang_specific_files;
 597
 598 # This is set when `handle_dist' has finished.  Once this happens,
 599 # we should no longer push on dist_common.
 600 my $handle_dist_run;
 601
 602 # Used to store a set of linkers needed to generate the sources currently
 603 # under consideration.
 604 my %linkers_used;
 605
 606 # True if we need `LINK' defined.  This is a hack.
 607 my $need_link;
 608
 609 # Was get_object_extension run?
 610 # FIXME: This is a hack. a better switch should be found.
 611 my $get_object_extension_was_run;
 612
 613 # Record each file processed by make_paragraphs.
 614 my %transformed_files;
 615 \f
 616
 617 ################################################################
 618
 619 ## ---------------------------------------------- ##
 620 ## Variables not reset by &initialize_per_input.  ##
 621 ## ---------------------------------------------- ##
 622
 623 # Cache each file processed by make_paragraphs.
 624 # (This is different from %transformed_files because
 625 # %transformed_files is reset for each file while %am_file_cache
 626 # it global to the run.)
 627 my %am_file_cache;
 628
 629 ################################################################
 630
 631 # var_SUFFIXES_trigger ($TYPE, $VALUE)
 632 # ------------------------------------
 633 # This is called by Automake::Variable::define() when SUFFIXES
 634 # is defined ($TYPE eq '') or appended ($TYPE eq '+').
 635 # The work here needs to be performed as a side-effect of the
 636 # macro_define() call because SUFFIXES definitions impact
 637 # on $KNOWN_EXTENSIONS_PATTERN which is used used when parsing
 638 # the input am file.
 639 sub var_SUFFIXES_trigger ($$)
 640 {
 641     my ($type, $value) = @_;
 642     accept_extensions (split (' ', $value));
 643 }
 644 Automake::Variable::hook ('SUFFIXES', \&var_SUFFIXES_trigger);
 645
 646 ################################################################
 647
 648 ## --------------------------------- ##
 649 ## Forward subroutine declarations.  ##
 650 ## --------------------------------- ##
 651 sub register_language (%);
 652 sub file_contents_internal ($$$%);
 653 sub define_files_variable ($\@$$);
 654
 655
 656 # &initialize_per_input ()
 657 # ------------------------
 658 # (Re)-Initialize per-Makefile.am variables.
 659 sub initialize_per_input ()
 660 {
 661     reset_local_duplicates ();
 662
 663     $am_file_name = undef;
 664     $am_relative_dir = undef;
 665
 666     $in_file_name = undef;
 667     $relative_dir = undef;
 668     $topsrcdir = undef;
 669
 670     $output_deps_greatest_timestamp = 0;
 671
 672     $output_vars = '';
 673     $output_all = '';
 674     $output_header = '';
 675     $output_rules = '';
 676     $output_trailer = '';
 677
 678     Automake::Options::reset;
 679     Automake::Variable::reset;
 680     Automake::Rule::reset;
 681
 682     @cond_stack = ();
 683
 684     @include_stack = ();
 685
 686     @all = ();
 687     @check = ();
 688     @check_tests = ();
 689
 690     %clean_files = ();
 691     %compile_clean_files = ();
 692
 693     # We always include `.'.  This isn't strictly correct.
 694     %libtool_clean_directories = ('.' => 1);
 695
 696     @sources = ();
 697     @dist_sources = ();
 698
 699     %object_map = ();
 700     %object_compilation_map = ();
 701
 702     %directory_map = ();
 703
 704     %dep_files = ();
 705
 706     @dist_targets = ();
 707
 708     %known_programs = ();
 709     %known_libraries= ();
 710
 711     %de_ansi_files = ();
 712
 713     %extension_seen = ();
 714
 715     %language_scratch = ();
 716
 717     %lang_specific_files = ();
 718
 719     $handle_dist_run = 0;
 720
 721     $need_link = 0;
 722
 723     $get_object_extension_was_run = 0;
 724
 725     %transformed_files = ();
 726 }
 727
 728
 729 ################################################################
 730
 731 # Initialize our list of languages that are internally supported.
 732
 733 # C.
 734 register_language ('name' => 'c',
 735                    'Name' => 'C',
 736                    'config_vars' => ['CC'],
 737                    'ansi' => 1,
 738                    'autodep' => '',
 739                    'flags' => ['CFLAGS', 'CPPFLAGS'],
 740                    'ccer' => 'CC',
 741                    'compiler' => 'COMPILE',
 742                    'compile' => '$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)',
 743                    'lder' => 'CCLD',
 744                    'ld' => '$(CC)',
 745                    'linker' => 'LINK',
 746                    'link' => '$(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 747                    'compile_flag' => '-c',
 748                    'libtool_tag' => 'CC',
 749                    'extensions' => ['.c'],
 750                    '_finish' => \&lang_c_finish);
 751
 752 # C++.
 753 register_language ('name' => 'cxx',
 754                    'Name' => 'C++',
 755                    'config_vars' => ['CXX'],
 756                    'linker' => 'CXXLINK',
 757                    'link' => '$(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 758                    'autodep' => 'CXX',
 759                    'flags' => ['CXXFLAGS', 'CPPFLAGS'],
 760                    'compile' => '$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)',
 761                    'ccer' => 'CXX',
 762                    'compiler' => 'CXXCOMPILE',
 763                    'compile_flag' => '-c',
 764                    'output_flag' => '-o',
 765                    'libtool_tag' => 'CXX',
 766                    'lder' => 'CXXLD',
 767                    'ld' => '$(CXX)',
 768                    'pure' => 1,
 769                    'extensions' => ['.c++', '.cc', '.cpp', '.cxx', '.C']);
 770
 771 # Objective C.
 772 register_language ('name' => 'objc',
 773                    'Name' => 'Objective C',
 774                    'config_vars' => ['OBJC'],
 775                    'linker' => 'OBJCLINK',
 776                    'link' => '$(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 777                    'autodep' => 'OBJC',
 778                    'flags' => ['OBJCFLAGS', 'CPPFLAGS'],
 779                    'compile' => '$(OBJC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_OBJCFLAGS) $(OBJCFLAGS)',
 780                    'ccer' => 'OBJC',
 781                    'compiler' => 'OBJCCOMPILE',
 782                    'compile_flag' => '-c',
 783                    'output_flag' => '-o',
 784                    'lder' => 'OBJCLD',
 785                    'ld' => '$(OBJC)',
 786                    'pure' => 1,
 787                    'extensions' => ['.m']);
 788
 789 # Unified Parallel C.
 790 register_language ('name' => 'upc',
 791                    'Name' => 'Unified Parallel C',
 792                    'config_vars' => ['UPC'],
 793                    'linker' => 'UPCLINK',
 794                    'link' => '$(UPCLD) $(AM_UPCFLAGS) $(UPCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 795                    'autodep' => 'UPC',
 796                    'flags' => ['UPCFLAGS', 'CPPFLAGS'],
 797                    'compile' => '$(UPC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_UPCFLAGS) $(UPCFLAGS)',
 798                    'ccer' => 'UPC',
 799                    'compiler' => 'UPCCOMPILE',
 800                    'compile_flag' => '-c',
 801                    'output_flag' => '-o',
 802                    'lder' => 'UPCLD',
 803                    'ld' => '$(UPC)',
 804                    'pure' => 1,
 805                    'extensions' => ['.upc']);
 806
 807 # Headers.
 808 register_language ('name' => 'header',
 809                    'Name' => 'Header',
 810                    'extensions' => ['.h', '.H', '.hxx', '.h++', '.hh',
 811                                     '.hpp', '.inc'],
 812                    # No output.
 813                    'output_extensions' => sub { return () },
 814                    # Nothing to do.
 815                    '_finish' => sub { });
 816
 817 # Vala
 818 register_language ('name' => 'vala',
 819                    'Name' => 'Vala',
 820                    'config_vars' => ['VALAC'],
 821                    'flags' => [],
 822                    'compile' => '$(VALAC) $(AM_VALAFLAGS) $(VALAFLAGS)',
 823                    'ccer' => 'VALAC',
 824                    'compiler' => 'VALACOMPILE',
 825                    'extensions' => ['.vala'],
 826                    'output_extensions' => sub { (my $ext = $_[0]) =~ s/vala$/c/;
 827                                                 return ($ext,) },
 828                    'rule_file' => 'vala',
 829                    '_finish' => \&lang_vala_finish,
 830                    '_target_hook' => \&lang_vala_target_hook,
 831                    'nodist_specific' => 1);
 832
 833 # Yacc (C & C++).
 834 register_language ('name' => 'yacc',
 835                    'Name' => 'Yacc',
 836                    'config_vars' => ['YACC'],
 837                    'flags' => ['YFLAGS'],
 838                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
 839                    'ccer' => 'YACC',
 840                    'compiler' => 'YACCCOMPILE',
 841                    'extensions' => ['.y'],
 842                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
 843                                                 return ($ext,) },
 844                    'rule_file' => 'yacc',
 845                    '_finish' => \&lang_yacc_finish,
 846                    '_target_hook' => \&lang_yacc_target_hook,
 847                    'nodist_specific' => 1);
 848 register_language ('name' => 'yaccxx',
 849                    'Name' => 'Yacc (C++)',
 850                    'config_vars' => ['YACC'],
 851                    'rule_file' => 'yacc',
 852                    'flags' => ['YFLAGS'],
 853                    'ccer' => 'YACC',
 854                    'compiler' => 'YACCCOMPILE',
 855                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
 856                    'extensions' => ['.y++', '.yy', '.yxx', '.ypp'],
 857                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
 858                                                 return ($ext,) },
 859                    '_finish' => \&lang_yacc_finish,
 860                    '_target_hook' => \&lang_yacc_target_hook,
 861                    'nodist_specific' => 1);
 862
 863 # Lex (C & C++).
 864 register_language ('name' => 'lex',
 865                    'Name' => 'Lex',
 866                    'config_vars' => ['LEX'],
 867                    'rule_file' => 'lex',
 868                    'flags' => ['LFLAGS'],
 869                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
 870                    'ccer' => 'LEX',
 871                    'compiler' => 'LEXCOMPILE',
 872                    'extensions' => ['.l'],
 873                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
 874                                                 return ($ext,) },
 875                    '_finish' => \&lang_lex_finish,
 876                    '_target_hook' => \&lang_lex_target_hook,
 877                    'nodist_specific' => 1);
 878 register_language ('name' => 'lexxx',
 879                    'Name' => 'Lex (C++)',
 880                    'config_vars' => ['LEX'],
 881                    'rule_file' => 'lex',
 882                    'flags' => ['LFLAGS'],
 883                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
 884                    'ccer' => 'LEX',
 885                    'compiler' => 'LEXCOMPILE',
 886                    'extensions' => ['.l++', '.ll', '.lxx', '.lpp'],
 887                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
 888                                                 return ($ext,) },
 889                    '_finish' => \&lang_lex_finish,
 890                    '_target_hook' => \&lang_lex_target_hook,
 891                    'nodist_specific' => 1);
 892
 893 # Assembler.
 894 register_language ('name' => 'asm',
 895                    'Name' => 'Assembler',
 896                    'config_vars' => ['CCAS', 'CCASFLAGS'],
 897
 898                    'flags' => ['CCASFLAGS'],
 899                    # Users can set AM_CCASFLAGS to include DEFS, INCLUDES,
 900                    # or anything else required.  They can also set CCAS.
 901                    # Or simply use Preprocessed Assembler.
 902                    'compile' => '$(CCAS) $(AM_CCASFLAGS) $(CCASFLAGS)',
 903                    'ccer' => 'CCAS',
 904                    'compiler' => 'CCASCOMPILE',
 905                    'compile_flag' => '-c',
 906                    'output_flag' => '-o',
 907                    'extensions' => ['.s'],
 908
 909                    # With assembly we still use the C linker.
 910                    '_finish' => \&lang_c_finish);
 911
 912 # Preprocessed Assembler.
 913 register_language ('name' => 'cppasm',
 914                    'Name' => 'Preprocessed Assembler',
 915                    'config_vars' => ['CCAS', 'CCASFLAGS'],
 916
 917                    'autodep' => 'CCAS',
 918                    'flags' => ['CCASFLAGS', 'CPPFLAGS'],
 919                    'compile' => '$(CCAS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CCASFLAGS) $(CCASFLAGS)',
 920                    'ccer' => 'CPPAS',
 921                    'compiler' => 'CPPASCOMPILE',
 922                    'compile_flag' => '-c',
 923                    'output_flag' => '-o',
 924                    'extensions' => ['.S', '.sx'],
 925
 926                    # With assembly we still use the C linker.
 927                    '_finish' => \&lang_c_finish);
 928
 929 # Fortran 77
 930 register_language ('name' => 'f77',
 931                    'Name' => 'Fortran 77',
 932                    'config_vars' => ['F77'],
 933                    'linker' => 'F77LINK',
 934                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 935                    'flags' => ['FFLAGS'],
 936                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS)',
 937                    'ccer' => 'F77',
 938                    'compiler' => 'F77COMPILE',
 939                    'compile_flag' => '-c',
 940                    'output_flag' => '-o',
 941                    'libtool_tag' => 'F77',
 942                    'lder' => 'F77LD',
 943                    'ld' => '$(F77)',
 944                    'pure' => 1,
 945                    'extensions' => ['.f', '.for']);
 946
 947 # Fortran
 948 register_language ('name' => 'fc',
 949                    'Name' => 'Fortran',
 950                    'config_vars' => ['FC'],
 951                    'linker' => 'FCLINK',
 952                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 953                    'flags' => ['FCFLAGS'],
 954                    'compile' => '$(FC) $(AM_FCFLAGS) $(FCFLAGS)',
 955                    'ccer' => 'FC',
 956                    'compiler' => 'FCCOMPILE',
 957                    'compile_flag' => '-c',
 958                    'output_flag' => '-o',
 959                    'libtool_tag' => 'FC',
 960                    'lder' => 'FCLD',
 961                    'ld' => '$(FC)',
 962                    'pure' => 1,
 963                    'extensions' => ['.f90', '.f95', '.f03', '.f08']);
 964
 965 # Preprocessed Fortran
 966 register_language ('name' => 'ppfc',
 967                    'Name' => 'Preprocessed Fortran',
 968                    'config_vars' => ['FC'],
 969                    'linker' => 'FCLINK',
 970                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 971                    'lder' => 'FCLD',
 972                    'ld' => '$(FC)',
 973                    'flags' => ['FCFLAGS', 'CPPFLAGS'],
 974                    'ccer' => 'PPFC',
 975                    'compiler' => 'PPFCCOMPILE',
 976                    'compile' => '$(FC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_FCFLAGS) $(FCFLAGS)',
 977                    'compile_flag' => '-c',
 978                    'output_flag' => '-o',
 979                    'libtool_tag' => 'FC',
 980                    'pure' => 1,
 981                    'extensions' => ['.F90','.F95', '.F03', '.F08']);
 982
 983 # Preprocessed Fortran 77
 984 #
 985 # The current support for preprocessing Fortran 77 just involves
 986 # passing `$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS)
 987 # $(CPPFLAGS)' as additional flags to the Fortran 77 compiler, since
 988 # this is how GNU Make does it; see the `GNU Make Manual, Edition 0.51
 989 # for `make' Version 3.76 Beta' (specifically, from info file
 990 # `(make)Catalogue of Rules').
 991 #
 992 # A better approach would be to write an Autoconf test
 993 # (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
 994 # Fortran 77 compilers know how to do preprocessing.  The Autoconf
 995 # macro AC_PROG_FPP should test the Fortran 77 compiler first for
 996 # preprocessing capabilities, and then fall back on cpp (if cpp were
 997 # available).
 998 register_language ('name' => 'ppf77',
 999                    'Name' => 'Preprocessed Fortran 77',
1000                    'config_vars' => ['F77'],
1001                    'linker' => 'F77LINK',
1002                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1003                    'lder' => 'F77LD',
1004                    'ld' => '$(F77)',
1005                    'flags' => ['FFLAGS', 'CPPFLAGS'],
1006                    'ccer' => 'PPF77',
1007                    'compiler' => 'PPF77COMPILE',
1008                    'compile' => '$(F77) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_FFLAGS) $(FFLAGS)',
1009                    'compile_flag' => '-c',
1010                    'output_flag' => '-o',
1011                    'libtool_tag' => 'F77',
1012                    'pure' => 1,
1013                    'extensions' => ['.F']);
1014
1015 # Ratfor.
1016 register_language ('name' => 'ratfor',
1017                    'Name' => 'Ratfor',
1018                    'config_vars' => ['F77'],
1019                    'linker' => 'F77LINK',
1020                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1021                    'lder' => 'F77LD',
1022                    'ld' => '$(F77)',
1023                    'flags' => ['RFLAGS', 'FFLAGS'],
1024                    # FIXME also FFLAGS.
1025                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS) $(AM_RFLAGS) $(RFLAGS)',
1026                    'ccer' => 'F77',
1027                    'compiler' => 'RCOMPILE',
1028                    'compile_flag' => '-c',
1029                    'output_flag' => '-o',
1030                    'libtool_tag' => 'F77',
1031                    'pure' => 1,
1032                    'extensions' => ['.r']);
1033
1034 # Java via gcj.
1035 register_language ('name' => 'java',
1036                    'Name' => 'Java',
1037                    'config_vars' => ['GCJ'],
1038                    'linker' => 'GCJLINK',
1039                    'link' => '$(GCJLD) $(AM_GCJFLAGS) $(GCJFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1040                    'autodep' => 'GCJ',
1041                    'flags' => ['GCJFLAGS'],
1042                    'compile' => '$(GCJ) $(AM_GCJFLAGS) $(GCJFLAGS)',
1043                    'ccer' => 'GCJ',
1044                    'compiler' => 'GCJCOMPILE',
1045                    'compile_flag' => '-c',
1046                    'output_flag' => '-o',
1047                    'libtool_tag' => 'GCJ',
1048                    'lder' => 'GCJLD',
1049                    'ld' => '$(GCJ)',
1050                    'pure' => 1,
1051                    'extensions' => ['.java', '.class', '.zip', '.jar']);
1052
1053 ################################################################
1054
1055 # Error reporting functions.
1056
1057 # err_am ($MESSAGE, [%OPTIONS])
1058 # -----------------------------
1059 # Uncategorized errors about the current Makefile.am.
1060 sub err_am ($;%)
1061 {
1062   msg_am ('error', @_);
1063 }
1064
1065 # err_ac ($MESSAGE, [%OPTIONS])
1066 # -----------------------------
1067 # Uncategorized errors about configure.ac.
1068 sub err_ac ($;%)
1069 {
1070   msg_ac ('error', @_);
1071 }
1072
1073 # msg_am ($CHANNEL, $MESSAGE, [%OPTIONS])
1074 # ---------------------------------------
1075 # Messages about about the current Makefile.am.
1076 sub msg_am ($$;%)
1077 {
1078   my ($channel, $msg, %opts) = @_;
1079   msg $channel, "${am_file}.am", $msg, %opts;
1080 }
1081
1082 # msg_ac ($CHANNEL, $MESSAGE, [%OPTIONS])
1083 # ---------------------------------------
1084 # Messages about about configure.ac.
1085 sub msg_ac ($$;%)
1086 {
1087   my ($channel, $msg, %opts) = @_;
1088   msg $channel, $configure_ac, $msg, %opts;
1089 }
1090
1091 ################################################################
1092
1093 # subst ($TEXT)
1094 # -------------
1095 # Return a configure-style substitution using the indicated text.
1096 # We do this to avoid having the substitutions directly in automake.in;
1097 # when we do that they are sometimes removed and this causes confusion
1098 # and bugs.
1099 sub subst ($)
1100 {
1101     my ($text) = @_;
1102     return '@' . $text . '@';
1103 }
1104
1105 ################################################################
1106
1107
1108 # $BACKPATH
1109 # &backname ($REL-DIR)
1110 # --------------------
1111 # If I `cd $REL-DIR', then to come back, I should `cd $BACKPATH'.
1112 # For instance `src/foo' => `../..'.
1113 # Works with non strictly increasing paths, i.e., `src/../lib' => `..'.
1114 sub backname ($)
1115 {
1116     my ($file) = @_;
1117     my @res;
1118     foreach (split (/\//, $file))
1119     {
1120         next if $_ eq '.' || $_ eq '';
1121         if ($_ eq '..')
1122         {
1123             pop @res
1124               or prog_error ("trying to reverse path `$file' pointing outside tree");
1125         }
1126         else
1127         {
1128             push (@res, '..');
1129         }
1130     }
1131     return join ('/', @res) || '.';
1132 }
1133
1134 ################################################################
1135
1136 # `silent-rules' mode handling functions.
1137
1138 # verbose_var (NAME)
1139 # ------------------
1140 # The public variable stem used to implement `silent-rules'.
1141 sub verbose_var ($)
1142 {
1143     my ($name) = @_;
1144     return 'AM_V_' . $name;
1145 }
1146
1147 # verbose_private_var (NAME)
1148 # --------------------------
1149 # The naming policy for the private variables for `silent-rules'.
1150 sub verbose_private_var ($)
1151 {
1152     my ($name) = @_;
1153     return 'am__v_' . $name;
1154 }
1155
1156 # define_verbose_var (NAME, VAL)
1157 # ------------------------------
1158 # For `silent-rules' mode, setup VAR and dispatcher, to expand to VAL if silent.
1159 sub define_verbose_var ($$)
1160 {
1161     my ($name, $val) = @_;
1162     my $var = verbose_var ($name);
1163     my $pvar = verbose_private_var ($name);
1164     my $silent_var = $pvar . '_0';
1165     if (option 'silent-rules')
1166       {
1167         # Using `$V' instead of `$(V)' breaks IRIX make.
1168         define_variable ($var, '$(' . $pvar . '_$(V))', INTERNAL);
1169         define_variable ($pvar . '_', '$(' . $pvar . '_$(AM_DEFAULT_VERBOSITY))', INTERNAL);
1170         Automake::Variable::define ($silent_var, VAR_AUTOMAKE, '', TRUE, $val,
1171                                     '', INTERNAL, VAR_ASIS)
1172           if (! vardef ($silent_var, TRUE));
1173       }
1174 }
1175
1176 # Above should not be needed in the general automake code.
1177
1178 # verbose_flag (NAME)
1179 # -------------------
1180 # Contents of %VERBOSE%: variable to expand before rule command.
1181 sub verbose_flag ($)
1182 {
1183     my ($name) = @_;
1184     return '$(' . verbose_var ($name) . ')'
1185       if (option 'silent-rules');
1186     return '';
1187 }
1188
1189 sub verbose_nodep_flag ($)
1190 {
1191     my ($name) = @_;
1192     return '$(' . verbose_var ($name) . subst ('am__nodep') . ')'
1193       if (option 'silent-rules');
1194     return '';
1195 }
1196
1197 # silent_flag
1198 # -----------
1199 # Contents of %SILENT%: variable to expand to `@' when silent.
1200 sub silent_flag ()
1201 {
1202     return verbose_flag ('at');
1203 }
1204
1205 # define_verbose_tagvar (NAME)
1206 # ----------------------------
1207 # Engage the needed `silent-rules' machinery for tag NAME.
1208 sub define_verbose_tagvar ($)
1209 {
1210     my ($name) = @_;
1211     if (option 'silent-rules')
1212       {
1213         define_verbose_var ($name, '@echo "  '. $name . ' ' x (6 - length ($name)) . '" $@;');
1214         define_verbose_var ('at', '@');
1215       }
1216 }
1217
1218 # define_verbose_libtool
1219 # ----------------------
1220 # Engage the needed `silent-rules' machinery for `libtool --silent'.
1221 sub define_verbose_libtool ()
1222 {
1223     define_verbose_var ('lt', '--silent');
1224     return verbose_flag ('lt');
1225 }
1226
1227
1228 ################################################################
1229
1230
1231 # Handle AUTOMAKE_OPTIONS variable.  Return 1 on error, 0 otherwise.
1232 sub handle_options
1233 {
1234   my $var = var ('AUTOMAKE_OPTIONS');
1235   if ($var)
1236     {
1237       if ($var->has_conditional_contents)
1238         {
1239           msg_var ('unsupported', $var,
1240                    "`AUTOMAKE_OPTIONS' cannot have conditional contents");
1241         }
1242       foreach my $locvals ($var->value_as_list_recursive (cond_filter => TRUE,
1243                                                           location => 1))
1244         {
1245           my ($loc, $value) = @$locvals;
1246           return 1 if (process_option_list ($loc, $value))
1247         }
1248     }
1249
1250   # Override portability-recursive warning.
1251   switch_warning ('no-portability-recursive')
1252     if option 'silent-rules';
1253
1254   if ($strictness == GNITS)
1255     {
1256       set_option ('readme-alpha', INTERNAL);
1257       set_option ('std-options', INTERNAL);
1258       set_option ('check-news', INTERNAL);
1259     }
1260
1261   return 0;
1262 }
1263
1264 # shadow_unconditionally ($varname, $where)
1265 # -----------------------------------------
1266 # Return a $(variable) that contains all possible values
1267 # $varname can take.
1268 # If the VAR wasn't defined conditionally, return $(VAR).
1269 # Otherwise we create an am__VAR_DIST variable which contains
1270 # all possible values, and return $(am__VAR_DIST).
1271 sub shadow_unconditionally ($$)
1272 {
1273   my ($varname, $where) = @_;
1274   my $var = var $varname;
1275   if ($var->has_conditional_contents)
1276     {
1277       $varname = "am__${varname}_DIST";
1278       my @files = uniq ($var->value_as_list_recursive);
1279       define_pretty_variable ($varname, TRUE, $where, @files);
1280     }
1281   return "\$($varname)"
1282 }
1283
1284 # get_object_extension ($EXTENSION)
1285 # ---------------------------------
1286 # Prefix $EXTENSION with $U if ansi2knr is in use.
1287 sub get_object_extension ($)
1288 {
1289     my ($extension) = @_;
1290
1291     # Check for automatic de-ANSI-fication.
1292     $extension = '$U' . $extension
1293       if option 'ansi2knr';
1294
1295     $get_object_extension_was_run = 1;
1296
1297     return $extension;
1298 }
1299
1300 # check_user_variables (@LIST)
1301 # ----------------------------
1302 # Make sure each variable VAR in @LIST does not exist, suggest using AM_VAR
1303 # otherwise.
1304 sub check_user_variables (@)
1305 {
1306   my @dont_override = @_;
1307   foreach my $flag (@dont_override)
1308     {
1309       my $var = var $flag;
1310       if ($var)
1311         {
1312           for my $cond ($var->conditions->conds)
1313             {
1314               if ($var->rdef ($cond)->owner == VAR_MAKEFILE)
1315                 {
1316                   msg_cond_var ('gnu', $cond, $flag,
1317                                 "`$flag' is a user variable, "
1318                                 . "you should not override it;\n"
1319                                 . "use `AM_$flag' instead.");
1320                 }
1321             }
1322         }
1323     }
1324 }
1325
1326 # Call finish function for each language that was used.
1327 sub handle_languages
1328 {
1329     if (! option 'no-dependencies')
1330     {
1331         # Include auto-dep code.  Don't include it if DEP_FILES would
1332         # be empty.
1333         if (&saw_sources_p (0) && keys %dep_files)
1334         {
1335             # Set location of depcomp.
1336             &define_variable ('depcomp',
1337                               "\$(SHELL) $am_config_aux_dir/depcomp",
1338                               INTERNAL);
1339             &define_variable ('am__depfiles_maybe', 'depfiles', INTERNAL);
1340
1341             require_conf_file ("$am_file.am", FOREIGN, 'depcomp');
1342
1343             my @deplist = sort keys %dep_files;
1344             # Generate each `include' individually.  Irix 6 make will
1345             # not properly include several files resulting from a
1346             # variable expansion; generating many separate includes
1347             # seems safest.
1348             $output_rules .= "\n";
1349             foreach my $iter (@deplist)
1350             {
1351                 $output_rules .= (subst ('AMDEP_TRUE')
1352                                   . subst ('am__include')
1353                                   . ' '
1354                                   . subst ('am__quote')
1355                                   . $iter
1356                                   . subst ('am__quote')
1357                                   . "\n");
1358             }
1359
1360             # Compute the set of directories to remove in distclean-depend.
1361             my @depdirs = uniq (map { dirname ($_) } @deplist);
1362             $output_rules .= &file_contents ('depend',
1363                                              new Automake::Location,
1364                                              DEPDIRS => "@depdirs");
1365         }
1366     }
1367     else
1368     {
1369         &define_variable ('depcomp', '', INTERNAL);
1370         &define_variable ('am__depfiles_maybe', '', INTERNAL);
1371     }
1372
1373     my %done;
1374
1375     # Is the C linker needed?
1376     my $needs_c = 0;
1377     foreach my $ext (sort keys %extension_seen)
1378     {
1379         next unless $extension_map{$ext};
1380
1381         my $lang = $languages{$extension_map{$ext}};
1382
1383         my $rule_file = $lang->rule_file || 'depend2';
1384
1385         # Get information on $LANG.
1386         my $pfx = $lang->autodep;
1387         my $fpfx = ($pfx eq '') ? 'CC' : $pfx;
1388
1389         my ($AMDEP, $FASTDEP) =
1390           (option 'no-dependencies' || $lang->autodep eq 'no')
1391           ? ('FALSE', 'FALSE') : ('AMDEP', "am__fastdep$fpfx");
1392
1393         my $verbose = verbose_flag ($lang->ccer || 'GEN');
1394         my $verbose_nodep = ($AMDEP eq 'FALSE')
1395           ? $verbose : verbose_nodep_flag ($lang->ccer || 'GEN');
1396         my $silent = silent_flag ();
1397
1398         my %transform = ('EXT'     => $ext,
1399                          'PFX'     => $pfx,
1400                          'FPFX'    => $fpfx,
1401                          'AMDEP'   => $AMDEP,
1402                          'FASTDEP' => $FASTDEP,
1403                          '-c'      => $lang->compile_flag || '',
1404                          # These are not used, but they need to be defined
1405                          # so &transform do not complain.
1406                          SUBDIROBJ     => 0,
1407                          'DERIVED-EXT' => 'BUG',
1408                          DIST_SOURCE   => 1,
1409                          VERBOSE   => $verbose,
1410                          'VERBOSE-NODEP' => $verbose_nodep,
1411                          SILENT    => $silent,
1412                         );
1413
1414         # Generate the appropriate rules for this extension.
1415         if (((! option 'no-dependencies') && $lang->autodep ne 'no')
1416             || defined $lang->compile)
1417         {
1418             # Some C compilers don't support -c -o.  Use it only if really
1419             # needed.
1420             my $output_flag = $lang->output_flag || '';
1421             $output_flag = '-o'
1422               if (! $output_flag
1423                   && $lang->name eq 'c'
1424                   && option 'subdir-objects');
1425
1426             # Compute a possible derived extension.
1427             # This is not used by depend2.am.
1428             my $der_ext = (&{$lang->output_extensions} ($ext))[0];
1429
1430             # When we output an inference rule like `.c.o:' we
1431             # have two cases to consider: either subdir-objects
1432             # is used, or it is not.
1433             #
1434             # In the latter case the rule is used to build objects
1435             # in the current directory, and dependencies always
1436             # go into `./$(DEPDIR)/'.  We can hard-code this value.
1437             #
1438             # In the former case the rule can be used to build
1439             # objects in sub-directories too.  Dependencies should
1440             # go into the appropriate sub-directories, e.g.,
1441             # `sub/$(DEPDIR)/'.  The value of this directory
1442             # needs to be computed on-the-fly.
1443             #
1444             # DEPBASE holds the name of this directory, plus the
1445             # basename part of the object file (extensions Po, TPo,
1446             # Plo, TPlo will be added later as appropriate).  It is
1447             # either hardcoded, or a shell variable (`$depbase') that
1448             # will be computed by the rule.
1449             my $depbase =
1450               option ('subdir-objects') ? '$$depbase' : '$(DEPDIR)/$*';
1451             $output_rules .=
1452               file_contents ($rule_file,
1453                              new Automake::Location,
1454                              %transform,
1455                              GENERIC   => 1,
1456
1457                              'DERIVED-EXT' => $der_ext,
1458
1459                              DEPBASE   => $depbase,
1460                              BASE      => '$*',
1461                              SOURCE    => '$<',
1462                              SOURCEFLAG => $sourceflags{$ext} || '',
1463                              OBJ       => '$@',
1464                              OBJOBJ    => '$@',
1465                              LTOBJ     => '$@',
1466
1467                              COMPILE   => '$(' . $lang->compiler . ')',
1468                              LTCOMPILE => '$(LT' . $lang->compiler . ')',
1469                              -o        => $output_flag,
1470                              SUBDIROBJ => !! option 'subdir-objects');
1471         }
1472
1473         # Now include code for each specially handled object with this
1474         # language.
1475         my %seen_files = ();
1476         foreach my $file (@{$lang_specific_files{$lang->name}})
1477         {
1478             my ($derived, $source, $obj, $myext, $srcext, %file_transform) = @$file;
1479
1480             # We might see a given object twice, for instance if it is
1481             # used under different conditions.
1482             next if defined $seen_files{$obj};
1483             $seen_files{$obj} = 1;
1484
1485             prog_error ("found " . $lang->name .
1486                         " in handle_languages, but compiler not defined")
1487               unless defined $lang->compile;
1488
1489             my $obj_compile = $lang->compile;
1490
1491             # Rewrite each occurrence of `AM_$flag' in the compile
1492             # rule into `${derived}_$flag' if it exists.
1493             for my $flag (@{$lang->flags})
1494               {
1495                 my $val = "${derived}_$flag";
1496                 $obj_compile =~ s/\(AM_$flag\)/\($val\)/
1497                   if set_seen ($val);
1498               }
1499
1500             my $libtool_tag = '';
1501             if ($lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag})
1502               {
1503                 $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
1504               }
1505
1506             my $ptltflags = "${derived}_LIBTOOLFLAGS";
1507             $ptltflags = 'AM_LIBTOOLFLAGS' unless set_seen $ptltflags;
1508
1509             my $ltverbose = define_verbose_libtool ();
1510             my $obj_ltcompile =
1511               "\$(LIBTOOL) $ltverbose $libtool_tag\$($ptltflags) \$(LIBTOOLFLAGS) "
1512               . "--mode=compile $obj_compile";
1513
1514             # We _need_ `-o' for per object rules.
1515             my $output_flag = $lang->output_flag || '-o';
1516
1517             my $depbase = dirname ($obj);
1518             $depbase = ''
1519                 if $depbase eq '.';
1520             $depbase .= '/'
1521                 unless $depbase eq '';
1522             $depbase .= '$(DEPDIR)/' . basename ($obj);
1523
1524             # Support for deansified files in subdirectories is ugly
1525             # enough to deserve an explanation.
1526             #
1527             # A Note about normal ansi2knr processing first.  On
1528             #
1529             #   AUTOMAKE_OPTIONS = ansi2knr
1530             #   bin_PROGRAMS = foo
1531             #   foo_SOURCES = foo.c
1532             #
1533             # we generate rules similar to:
1534             #
1535             #   foo: foo$U.o; link ...
1536             #   foo$U.o: foo$U.c; compile ...
1537             #   foo_.c: foo.c; ansi2knr ...
1538             #
1539             # this is fairly compact, and will call ansi2knr depending
1540             # on the value of $U (`' or `_').
1541             #
1542             # It's harder with subdir sources. On
1543             #
1544             #   AUTOMAKE_OPTIONS = ansi2knr
1545             #   bin_PROGRAMS = foo
1546             #   foo_SOURCES = sub/foo.c
1547             #
1548             # we have to create foo_.c in the current directory.
1549             # (Unless the user asks 'subdir-objects'.)  This is important
1550             # in case the same file (`foo.c') is compiled from other
1551             # directories with different cpp options: foo_.c would
1552             # be preprocessed for only one set of options if it were
1553             # put in the subdirectory.
1554             #
1555             # Because foo$U.o must be built from either foo_.c or
1556             # sub/foo.c we can't be as concise as in the first example.
1557             # Instead we output
1558             #
1559             #   foo: foo$U.o; link ...
1560             #   foo_.o: foo_.c; compile ...
1561             #   foo.o: sub/foo.c; compile ...
1562             #   foo_.c: foo.c; ansi2knr ...
1563             #
1564             # This is why we'll now transform $rule_file twice
1565             # if we detect this case.
1566             # A first time we output the compile rule with `$U'
1567             # replaced by `_' and the source directory removed,
1568             # and another time we simply remove `$U'.
1569             #
1570             # Note that at this point $source (as computed by
1571             # &handle_single_transform) is `sub/foo$U.c'.
1572             # This can be confusing: it can be used as-is when
1573             # subdir-objects is set, otherwise you have to know
1574             # it really means `foo_.c' or `sub/foo.c'.
1575             my $objdir = dirname ($obj);
1576             my $srcdir = dirname ($source);
1577             if ($lang->ansi && $obj =~ /\$U/)
1578               {
1579                 prog_error "`$obj' contains \$U, but `$source' doesn't."
1580                   if $source !~ /\$U/;
1581
1582                 (my $source_ = $source) =~ s/\$U/_/g;
1583                 # Output an additional rule if _.c and .c are not in
1584                 # the same directory.  (_.c is always in $objdir.)
1585                 if ($objdir ne $srcdir)
1586                   {
1587                     (my $obj_ = $obj) =~ s/\$U/_/g;
1588                     (my $depbase_ = $depbase) =~ s/\$U/_/g;
1589                     $source_ = basename ($source_);
1590
1591                     $output_rules .=
1592                       file_contents ($rule_file,
1593                                      new Automake::Location,
1594                                      %transform,
1595                                      GENERIC   => 0,
1596
1597                                      DEPBASE   => $depbase_,
1598                                      BASE      => $obj_,
1599                                      SOURCE    => $source_,
1600                                      SOURCEFLAG => $sourceflags{$srcext} || '',
1601                                      OBJ       => "$obj_$myext",
1602                                      OBJOBJ    => "$obj_.obj",
1603                                      LTOBJ     => "$obj_.lo",
1604
1605                                      COMPILE   => $obj_compile,
1606                                      LTCOMPILE => $obj_ltcompile,
1607                                      -o        => $output_flag,
1608                                      %file_transform);
1609                     $obj =~ s/\$U//g;
1610                     $depbase =~ s/\$U//g;
1611                     $source =~ s/\$U//g;
1612                   }
1613               }
1614
1615             $output_rules .=
1616               file_contents ($rule_file,
1617                              new Automake::Location,
1618                              %transform,
1619                              GENERIC   => 0,
1620
1621                              DEPBASE   => $depbase,
1622                              BASE      => $obj,
1623                              SOURCE    => $source,
1624                              SOURCEFLAG => $sourceflags{$srcext} || '',
1625                              # Use $myext and not `.o' here, in case
1626                              # we are actually building a new source
1627                              # file -- e.g. via yacc.
1628                              OBJ       => "$obj$myext",
1629                              OBJOBJ    => "$obj.obj",
1630                              LTOBJ     => "$obj.lo",
1631
1632                              VERBOSE   => $verbose,
1633                              'VERBOSE-NODEP'  => $verbose_nodep,
1634                              SILENT    => $silent,
1635                              COMPILE   => $obj_compile,
1636                              LTCOMPILE => $obj_ltcompile,
1637                              -o        => $output_flag,
1638                              %file_transform);
1639         }
1640
1641         # The rest of the loop is done once per language.
1642         next if defined $done{$lang};
1643         $done{$lang} = 1;
1644
1645         # Load the language dependent Makefile chunks.
1646         my %lang = map { uc ($_) => 0 } keys %languages;
1647         $lang{uc ($lang->name)} = 1;
1648         $output_rules .= file_contents ('lang-compile',
1649                                         new Automake::Location,
1650                                         %transform, %lang);
1651
1652         # If the source to a program consists entirely of code from a
1653         # `pure' language, for instance C++ or Fortran 77, then we
1654         # don't need the C compiler code.  However if we run into
1655         # something unusual then we do generate the C code.  There are
1656         # probably corner cases here that do not work properly.
1657         # People linking Java code to Fortran code deserve pain.
1658         $needs_c ||= ! $lang->pure;
1659
1660         define_compiler_variable ($lang)
1661           if ($lang->compile);
1662
1663         define_linker_variable ($lang)
1664           if ($lang->link);
1665
1666         require_variables ("$am_file.am", $lang->Name . " source seen",
1667                            TRUE, @{$lang->config_vars});
1668
1669         # Call the finisher.
1670         $lang->finish;
1671
1672         # Flags listed in `->flags' are user variables (per GNU Standards),
1673         # they should not be overridden in the Makefile...
1674         my @dont_override = @{$lang->flags};
1675         # ... and so is LDFLAGS.
1676         push @dont_override, 'LDFLAGS' if $lang->link;
1677
1678         check_user_variables @dont_override;
1679     }
1680
1681     # If the project is entirely C++ or entirely Fortran 77 (i.e., 1
1682     # suffix rule was learned), don't bother with the C stuff.  But if
1683     # anything else creeps in, then use it.
1684     $needs_c = 1
1685       if $need_link || suffix_rules_count > 1;
1686
1687     if ($needs_c)
1688       {
1689         &define_compiler_variable ($languages{'c'})
1690           unless defined $done{$languages{'c'}};
1691         define_linker_variable ($languages{'c'});
1692       }
1693
1694     # Always provide the user with `AM_V_GEN' for `silent-rules' mode.
1695     define_verbose_tagvar ('GEN');
1696 }
1697
1698
1699 # append_exeext { PREDICATE } $MACRO
1700 # ----------------------------------
1701 # Append $(EXEEXT) to each filename in $F appearing in the Makefile
1702 # variable $MACRO if &PREDICATE($F) is true.  @substitutions@ are
1703 # ignored.
1704 #
1705 # This is typically used on all filenames of *_PROGRAMS, and filenames
1706 # of TESTS that are programs.
1707 sub append_exeext (&$)
1708 {
1709   my ($pred, $macro) = @_;
1710
1711   transform_variable_recursively
1712     ($macro, $macro, 'am__EXEEXT', 0, INTERNAL,
1713      sub {
1714        my ($subvar, $val, $cond, $full_cond) = @_;
1715        # Append $(EXEEXT) unless the user did it already, or it's a
1716        # @substitution@.
1717        $val .= '$(EXEEXT)'
1718          if $val !~ /(?:\$\(EXEEXT\)$|^[@]\w+[@]$)/ && &$pred ($val);
1719        return $val;
1720      });
1721 }
1722
1723
1724 # Check to make sure a source defined in LIBOBJS is not explicitly
1725 # mentioned.  This is a separate function (as opposed to being inlined
1726 # in handle_source_transform) because it isn't always appropriate to
1727 # do this check.
1728 sub check_libobjs_sources
1729 {
1730   my ($one_file, $unxformed) = @_;
1731
1732   foreach my $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
1733                       'dist_EXTRA_', 'nodist_EXTRA_')
1734     {
1735       my @files;
1736       my $varname = $prefix . $one_file . '_SOURCES';
1737       my $var = var ($varname);
1738       if ($var)
1739         {
1740           @files = $var->value_as_list_recursive;
1741         }
1742       elsif ($prefix eq '')
1743         {
1744           @files = ($unxformed . '.c');
1745         }
1746       else
1747         {
1748           next;
1749         }
1750
1751       foreach my $file (@files)
1752         {
1753           err_var ($prefix . $one_file . '_SOURCES',
1754                    "automatically discovered file `$file' should not" .
1755                    " be explicitly mentioned")
1756             if defined $libsources{$file};
1757         }
1758     }
1759 }
1760
1761
1762 # @OBJECTS
1763 # handle_single_transform ($VAR, $TOPPARENT, $DERIVED, $OBJ, $FILE, %TRANSFORM)
1764 # -----------------------------------------------------------------------------
1765 # Does much of the actual work for handle_source_transform.
1766 # Arguments are:
1767 #   $VAR is the name of the variable that the source filenames come from
1768 #   $TOPPARENT is the name of the _SOURCES variable which is being processed
1769 #   $DERIVED is the name of resulting executable or library
1770 #   $OBJ is the object extension (e.g., `$U.lo')
1771 #   $FILE the source file to transform
1772 #   %TRANSFORM contains extras arguments to pass to file_contents
1773 #     when producing explicit rules
1774 # Result is a list of the names of objects
1775 # %linkers_used will be updated with any linkers needed
1776 sub handle_single_transform ($$$$$%)
1777 {
1778     my ($var, $topparent, $derived, $obj, $_file, %transform) = @_;
1779     my @files = ($_file);
1780     my @result = ();
1781     my $nonansi_obj = $obj;
1782     $nonansi_obj =~ s/\$U//g;
1783
1784     # Turn sources into objects.  We use a while loop like this
1785     # because we might add to @files in the loop.
1786     while (scalar @files > 0)
1787     {
1788         $_ = shift @files;
1789
1790         # Configure substitutions in _SOURCES variables are errors.
1791         if (/^\@.*\@$/)
1792         {
1793           my $parent_msg = '';
1794           $parent_msg = "\nand is referred to from `$topparent'"
1795             if $topparent ne $var->name;
1796           err_var ($var,
1797                    "`" . $var->name . "' includes configure substitution `$_'"
1798                    . $parent_msg . ";\nconfigure " .
1799                    "substitutions are not allowed in _SOURCES variables");
1800           next;
1801         }
1802
1803         # If the source file is in a subdirectory then the `.o' is put
1804         # into the current directory, unless the subdir-objects option
1805         # is in effect.
1806
1807         # Split file name into base and extension.
1808         next if ! /^(?:(.*)\/)?([^\/]*)($KNOWN_EXTENSIONS_PATTERN)$/;
1809         my $full = $_;
1810         my $directory = $1 || '';
1811         my $base = $2;
1812         my $extension = $3;
1813
1814         # We must generate a rule for the object if it requires its own flags.
1815         my $renamed = 0;
1816         my ($linker, $object);
1817
1818         # This records whether we've seen a derived source file (e.g.
1819         # yacc output).
1820         my $derived_source = 0;
1821
1822         # This holds the `aggregate context' of the file we are
1823         # currently examining.  If the file is compiled with
1824         # per-object flags, then it will be the name of the object.
1825         # Otherwise it will be `AM'.  This is used by the target hook
1826         # language function.
1827         my $aggregate = 'AM';
1828
1829         $extension = &derive_suffix ($extension, $nonansi_obj);
1830         my $lang;
1831         if ($extension_map{$extension} &&
1832             ($lang = $languages{$extension_map{$extension}}))
1833         {
1834             # Found the language, so see what it says.
1835             &saw_extension ($extension);
1836
1837             # Do we have per-executable flags for this executable?
1838             my $have_per_exec_flags = 0;
1839             my @peflags = @{$lang->flags};
1840             push @peflags, 'LIBTOOLFLAGS' if $nonansi_obj eq '.lo';
1841             foreach my $flag (@peflags)
1842               {
1843                 if (set_seen ("${derived}_$flag"))
1844                   {
1845                     $have_per_exec_flags = 1;
1846                     last;
1847                   }
1848               }
1849
1850             # Note: computed subr call.  The language rewrite function
1851             # should return one of the LANG_* constants.  It could
1852             # also return a list whose first value is such a constant
1853             # and whose second value is a new source extension which
1854             # should be applied.  This means this particular language
1855             # generates another source file which we must then process
1856             # further.
1857             my $subr = \&{'lang_' . $lang->name . '_rewrite'};
1858             my ($r, $source_extension)
1859                 = &$subr ($directory, $base, $extension,
1860                           $nonansi_obj, $have_per_exec_flags, $var);
1861             # Skip this entry if we were asked not to process it.
1862             next if $r == LANG_IGNORE;
1863
1864             # Now extract linker and other info.
1865             $linker = $lang->linker;
1866
1867             my $this_obj_ext;
1868             if (defined $source_extension)
1869             {
1870                 $this_obj_ext = $source_extension;
1871                 $derived_source = 1;
1872             }
1873             elsif ($lang->ansi)
1874             {
1875                 $this_obj_ext = $obj;
1876             }
1877             else
1878             {
1879                 $this_obj_ext = $nonansi_obj;
1880             }
1881             $object = $base . $this_obj_ext;
1882
1883             if ($have_per_exec_flags)
1884             {
1885                 # We have a per-executable flag in effect for this
1886                 # object.  In this case we rewrite the object's
1887                 # name to ensure it is unique.
1888
1889                 # We choose the name `DERIVED_OBJECT' to ensure
1890                 # (1) uniqueness, and (2) continuity between
1891                 # invocations.  However, this will result in a
1892                 # name that is too long for losing systems, in
1893                 # some situations.  So we provide _SHORTNAME to
1894                 # override.
1895
1896                 my $dname = $derived;
1897                 my $var = var ($derived . '_SHORTNAME');
1898                 if ($var)
1899                 {
1900                     # FIXME: should use the same Condition as
1901                     # the _SOURCES variable.  But this is really
1902                     # silly overkill -- nobody should have
1903                     # conditional shortnames.
1904                     $dname = $var->variable_value;
1905                 }
1906                 $object = $dname . '-' . $object;
1907
1908                 prog_error ($lang->name . " flags defined without compiler")
1909                   if ! defined $lang->compile;
1910
1911                 $renamed = 1;
1912             }
1913
1914             # If rewrite said it was ok, put the object into a
1915             # subdir.
1916             if ($r == LANG_SUBDIR && $directory ne '')
1917             {
1918                 $object = $directory . '/' . $object;
1919             }
1920
1921             # If the object file has been renamed (because per-target
1922             # flags are used) we cannot compile the file with an
1923             # inference rule: we need an explicit rule.
1924             #
1925             # If the source is in a subdirectory and the object is in
1926             # the current directory, we also need an explicit rule.
1927             #
1928             # If both source and object files are in a subdirectory
1929             # (this happens when the subdir-objects option is used),
1930             # then the inference will work.
1931             #
1932             # The latter case deserves a historical note.  When the
1933             # subdir-objects option was added on 1999-04-11 it was
1934             # thought that inferences rules would work for
1935             # subdirectory objects too.  Later, on 1999-11-22,
1936             # automake was changed to output explicit rules even for
1937             # subdir-objects.  Nobody remembers why, but this occurred
1938             # soon after the merge of the user-dep-gen-branch so it
1939             # might be related.  In late 2003 people complained about
1940             # the size of the generated Makefile.ins (libgcj, with
1941             # 2200+ subdir objects was reported to have a 9MB
1942             # Makefile), so we now rely on inference rules again.
1943             # Maybe we'll run across the same issue as in the past,
1944             # but at least this time we can document it.  However since
1945             # dependency tracking has evolved it is possible that
1946             # our old problem no longer exists.
1947             # Using inference rules for subdir-objects has been tested
1948             # with GNU make, Solaris make, Ultrix make, BSD make,
1949             # HP-UX make, and OSF1 make successfully.
1950             if ($renamed
1951                 || ($directory ne '' && ! option 'subdir-objects')
1952                 # We must also use specific rules for a nodist_ source
1953                 # if its language requests it.
1954                 || ($lang->nodist_specific && ! $transform{'DIST_SOURCE'}))
1955             {
1956                 my $obj_sans_ext = substr ($object, 0,
1957                                            - length ($this_obj_ext));
1958                 my $full_ansi;
1959                 if ($directory ne '')
1960                   {
1961                         $full_ansi = $directory . '/' . $base . $extension;
1962                   }
1963                 else
1964                   {
1965                         $full_ansi = $base . $extension;
1966                   }
1967
1968                 if ($lang->ansi && option 'ansi2knr')
1969                   {
1970                     $full_ansi =~ s/$KNOWN_EXTENSIONS_PATTERN$/\$U$&/;
1971                     $obj_sans_ext .= '$U';
1972                   }
1973
1974                 my @specifics = ($full_ansi, $obj_sans_ext,
1975                                  # Only use $this_obj_ext in the derived
1976                                  # source case because in the other case we
1977                                  # *don't* want $(OBJEXT) to appear here.
1978                                  ($derived_source ? $this_obj_ext : '.o'),
1979                                  $extension);
1980
1981                 # If we renamed the object then we want to use the
1982                 # per-executable flag name.  But if this is simply a
1983                 # subdir build then we still want to use the AM_ flag
1984                 # name.
1985                 if ($renamed)
1986                   {
1987                     unshift @specifics, $derived;
1988                     $aggregate = $derived;
1989                   }
1990                 else
1991                   {
1992                     unshift @specifics, 'AM';
1993                   }
1994
1995                 # Each item on this list is a reference to a list consisting
1996                 # of four values followed by additional transform flags for
1997                 # file_contents.  The four values are the derived flag prefix
1998                 # (e.g. for `foo_CFLAGS', it is `foo'), the name of the
1999                 # source file, the base name of the output file, and
2000                 # the extension for the object file.
2001                 push (@{$lang_specific_files{$lang->name}},
2002                       [@specifics, %transform]);
2003             }
2004         }
2005         elsif ($extension eq $nonansi_obj)
2006         {
2007             # This is probably the result of a direct suffix rule.
2008             # In this case we just accept the rewrite.
2009             $object = "$base$extension";
2010             $object = "$directory/$object" if $directory ne '';
2011             $linker = '';
2012         }
2013         else
2014         {
2015             # No error message here.  Used to have one, but it was
2016             # very unpopular.
2017             # FIXME: we could potentially do more processing here,
2018             # perhaps treating the new extension as though it were a
2019             # new source extension (as above).  This would require
2020             # more restructuring than is appropriate right now.
2021             next;
2022         }
2023
2024         err_am "object `$object' created by `$full' and `$object_map{$object}'"
2025           if (defined $object_map{$object}
2026               && $object_map{$object} ne $full);
2027
2028         my $comp_val = (($object =~ /\.lo$/)
2029                         ? COMPILE_LIBTOOL : COMPILE_ORDINARY);
2030         (my $comp_obj = $object) =~ s/\.lo$/.\$(OBJEXT)/;
2031         if (defined $object_compilation_map{$comp_obj}
2032             && $object_compilation_map{$comp_obj} != 0
2033             # Only see the error once.
2034             && ($object_compilation_map{$comp_obj}
2035                 != (COMPILE_LIBTOOL | COMPILE_ORDINARY))
2036             && $object_compilation_map{$comp_obj} != $comp_val)
2037           {
2038             err_am "object `$comp_obj' created both with libtool and without";
2039           }
2040         $object_compilation_map{$comp_obj} |= $comp_val;
2041
2042         if (defined $lang)
2043         {
2044             # Let the language do some special magic if required.
2045             $lang->target_hook ($aggregate, $object, $full, %transform);
2046         }
2047
2048         if ($derived_source)
2049           {
2050             prog_error ($lang->name . " has automatic dependency tracking")
2051               if $lang->autodep ne 'no';
2052             # Make sure this new source file is handled next.  That will
2053             # make it appear to be at the right place in the list.
2054             unshift (@files, $object);
2055             # Distribute derived sources unless the source they are
2056             # derived from is not.
2057             &push_dist_common ($object)
2058               unless ($topparent =~ /^(?:nobase_)?nodist_/);
2059             next;
2060           }
2061
2062         $linkers_used{$linker} = 1;
2063
2064         push (@result, $object);
2065
2066         if (! defined $object_map{$object})
2067         {
2068             my @dep_list = ();
2069             $object_map{$object} = $full;
2070
2071             # If resulting object is in subdir, we need to make
2072             # sure the subdir exists at build time.
2073             if ($object =~ /\//)
2074             {
2075                 # FIXME: check that $DIRECTORY is somewhere in the
2076                 # project
2077
2078                 # For Java, the way we're handling it right now, a
2079                 # `..' component doesn't make sense.
2080                 if ($lang && $lang->name eq 'java' && $object =~ /(\/|^)\.\.\//)
2081                   {
2082                     err_am "`$full' should not contain a `..' component";
2083                   }
2084
2085                 # Make sure object is removed by `make mostlyclean'.
2086                 $compile_clean_files{$object} = MOSTLY_CLEAN;
2087                 # If we have a libtool object then we also must remove
2088                 # the ordinary .o.
2089                 if ($object =~ /\.lo$/)
2090                 {
2091                     (my $xobj = $object) =~ s,lo$,\$(OBJEXT),;
2092                     $compile_clean_files{$xobj} = MOSTLY_CLEAN;
2093
2094                     # Remove any libtool object in this directory.
2095                     $libtool_clean_directories{$directory} = 1;
2096                 }
2097
2098                 push (@dep_list, require_build_directory ($directory));
2099
2100                 # If we're generating dependencies, we also want
2101                 # to make sure that the appropriate subdir of the
2102                 # .deps directory is created.
2103                 push (@dep_list,
2104                       require_build_directory ($directory . '/$(DEPDIR)'))
2105                   unless option 'no-dependencies';
2106             }
2107
2108             &pretty_print_rule ($object . ':', "\t", @dep_list)
2109                 if scalar @dep_list > 0;
2110         }
2111
2112         # Transform .o or $o file into .P file (for automatic
2113         # dependency code).
2114         # Properly flatten multiple adjacent slashes, as Solaris 10 make
2115         # might fail over them in an include statement.
2116         # Leading double slashes may be special, as per Posix, so deal
2117         # with them carefully.
2118         if ($lang && $lang->autodep ne 'no')
2119         {
2120             my $depfile = $object;
2121             $depfile =~ s/\.([^.]*)$/.P$1/;
2122             $depfile =~ s/\$\(OBJEXT\)$/o/;
2123             my $maybe_extra_leading_slash = '';
2124             $maybe_extra_leading_slash = '/' if $depfile =~ m,^//[^/],;
2125             $depfile =~ s,/+,/,g;
2126             my $basename = basename ($depfile);
2127             # This might make $dirname empty, but we account for that below.
2128             (my $dirname = dirname ($depfile)) =~ s/\/*$//;
2129             $dirname = $maybe_extra_leading_slash . $dirname;
2130             $dep_files{$dirname . '/$(DEPDIR)/' . $basename} = 1;
2131         }
2132     }
2133
2134     return @result;
2135 }
2136
2137
2138 # $LINKER
2139 # define_objects_from_sources ($VAR, $OBJVAR, $NODEFINE, $ONE_FILE,
2140 #                              $OBJ, $PARENT, $TOPPARENT, $WHERE, %TRANSFORM)
2141 # ---------------------------------------------------------------------------
2142 # Define an _OBJECTS variable for a _SOURCES variable (or subvariable)
2143 #
2144 # Arguments are:
2145 #   $VAR is the name of the _SOURCES variable
2146 #   $OBJVAR is the name of the _OBJECTS variable if known (otherwise
2147 #     it will be generated and returned).
2148 #   $NODEFINE is a boolean: if true, $OBJVAR will not be defined (but
2149 #     work done to determine the linker will be).
2150 #   $ONE_FILE is the canonical (transformed) name of object to build
2151 #   $OBJ is the object extension (i.e. either `.o' or `.lo').
2152 #   $TOPPARENT is the _SOURCES variable being processed.
2153 #   $WHERE context into which this definition is done
2154 #   %TRANSFORM extra arguments to pass to file_contents when producing
2155 #     rules
2156 #
2157 # Result is a pair ($LINKER, $OBJVAR):
2158 #    $LINKER is a boolean, true if a linker is needed to deal with the objects
2159 sub define_objects_from_sources ($$$$$$$%)
2160 {
2161   my ($var, $objvar, $nodefine, $one_file,
2162       $obj, $topparent, $where, %transform) = @_;
2163
2164   my $needlinker = "";
2165
2166   transform_variable_recursively
2167     ($var, $objvar, 'am__objects', $nodefine, $where,
2168      # The transform code to run on each filename.
2169      sub {
2170        my ($subvar, $val, $cond, $full_cond) = @_;
2171        my @trans = handle_single_transform ($subvar, $topparent,
2172                                             $one_file, $obj, $val,
2173                                             %transform);
2174        $needlinker = "true" if @trans;
2175        return @trans;
2176      });
2177
2178   return $needlinker;
2179 }
2180
2181
2182 # handle_source_transform ($CANON_TARGET, $TARGET, $OBJEXT, $WHERE, %TRANSFORM)
2183 # -----------------------------------------------------------------------------
2184 # Handle SOURCE->OBJECT transform for one program or library.
2185 # Arguments are:
2186 #   canonical (transformed) name of target to build
2187 #   actual target of object to build
2188 #   object extension (i.e., either `.o' or `$o')
2189 #   location of the source variable
2190 #   extra arguments to pass to file_contents when producing rules
2191 # Return the name of the linker variable that must be used.
2192 # Empty return means just use `LINK'.
2193 sub handle_source_transform ($$$$%)
2194 {
2195     # one_file is canonical name.  unxformed is given name.  obj is
2196     # object extension.
2197     my ($one_file, $unxformed, $obj, $where, %transform) = @_;
2198
2199     my $linker = '';
2200
2201     # No point in continuing if _OBJECTS is defined.
2202     return if reject_var ($one_file . '_OBJECTS',
2203                           $one_file . '_OBJECTS should not be defined');
2204
2205     my %used_pfx = ();
2206     my $needlinker;
2207     %linkers_used = ();
2208     foreach my $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
2209                         'dist_EXTRA_', 'nodist_EXTRA_')
2210     {
2211         my $varname = $prefix . $one_file . "_SOURCES";
2212         my $var = var $varname;
2213         next unless $var;
2214
2215         # We are going to define _OBJECTS variables using the prefix.
2216         # Then we glom them all together.  So we can't use the null
2217         # prefix here as we need it later.
2218         my $xpfx = ($prefix eq '') ? 'am_' : $prefix;
2219
2220         # Keep track of which prefixes we saw.
2221         $used_pfx{$xpfx} = 1
2222           unless $prefix =~ /EXTRA_/;
2223
2224         push @sources, "\$($varname)";
2225         push @dist_sources, shadow_unconditionally ($varname, $where)
2226           unless (option ('no-dist') || $prefix =~ /^nodist_/);
2227
2228         $needlinker |=
2229             define_objects_from_sources ($varname,
2230                                          $xpfx . $one_file . '_OBJECTS',
2231                                          $prefix =~ /EXTRA_/,
2232                                          $one_file, $obj, $varname, $where,
2233                                          DIST_SOURCE => ($prefix !~ /^nodist_/),
2234                                          %transform);
2235     }
2236     if ($needlinker)
2237     {
2238         $linker ||= &resolve_linker (%linkers_used);
2239     }
2240
2241     my @keys = sort keys %used_pfx;
2242     if (scalar @keys == 0)
2243     {
2244         # The default source for libfoo.la is libfoo.c, but for
2245         # backward compatibility we first look at libfoo_la.c,
2246         # if no default source suffix is given.
2247         my $old_default_source = "$one_file.c";
2248         my $ext_var = var ('AM_DEFAULT_SOURCE_EXT');
2249         my $default_source_ext = $ext_var ? variable_value ($ext_var) : '.c';
2250         msg_var ('unsupported', $ext_var, $ext_var->name . " can assume at most one value")
2251           if $default_source_ext =~ /[\t ]/;
2252         (my $default_source = $unxformed) =~ s,(\.[^./\\]*)?$,$default_source_ext,;
2253         if ($old_default_source ne $default_source
2254             && !$ext_var
2255             && (rule $old_default_source
2256                 || rule '$(srcdir)/' . $old_default_source
2257                 || rule '${srcdir}/' . $old_default_source
2258                 || -f $old_default_source))
2259           {
2260             my $loc = $where->clone;
2261             $loc->pop_context;
2262             msg ('obsolete', $loc,
2263                  "the default source for `$unxformed' has been changed "
2264                  . "to `$default_source'.\n(Using `$old_default_source' for "
2265                  . "backward compatibility.)");
2266             $default_source = $old_default_source;
2267           }
2268         # If a rule exists to build this source with a $(srcdir)
2269         # prefix, use that prefix in our variables too.  This is for
2270         # the sake of BSD Make.
2271         if (rule '$(srcdir)/' . $default_source
2272             || rule '${srcdir}/' . $default_source)
2273           {
2274             $default_source = '$(srcdir)/' . $default_source;
2275           }
2276
2277         &define_variable ($one_file . "_SOURCES", $default_source, $where);
2278         push (@sources, $default_source);
2279         push (@dist_sources, $default_source);
2280
2281         %linkers_used = ();
2282         my (@result) =
2283           handle_single_transform ($one_file . '_SOURCES',
2284                                    $one_file . '_SOURCES',
2285                                    $one_file, $obj,
2286                                    $default_source, %transform);
2287         $linker ||= &resolve_linker (%linkers_used);
2288         define_pretty_variable ($one_file . '_OBJECTS', TRUE, $where, @result);
2289     }
2290     else
2291     {
2292         @keys = map { '$(' . $_ . $one_file . '_OBJECTS)' } @keys;
2293         define_pretty_variable ($one_file . '_OBJECTS', TRUE, $where, @keys);
2294     }
2295
2296     # If we want to use `LINK' we must make sure it is defined.
2297     if ($linker eq '')
2298     {
2299         $need_link = 1;
2300     }
2301
2302     return $linker;
2303 }
2304
2305
2306 # handle_lib_objects ($XNAME, $VAR)
2307 # ---------------------------------
2308 # Special-case ALLOCA and LIBOBJS substitutions in _LDADD or _LIBADD variables.
2309 # Also, generate _DEPENDENCIES variable if appropriate.
2310 # Arguments are:
2311 #   transformed name of object being built, or empty string if no object
2312 #   name of _LDADD/_LIBADD-type variable to examine
2313 # Returns 1 if LIBOBJS seen, 0 otherwise.
2314 sub handle_lib_objects
2315 {
2316   my ($xname, $varname) = @_;
2317
2318   my $var = var ($varname);
2319   prog_error "handle_lib_objects: `$varname' undefined"
2320     unless $var;
2321   prog_error "handle_lib_objects: unexpected variable name `$varname'"
2322     unless $varname =~ /^(.*)(?:LIB|LD)ADD$/;
2323   my $prefix = $1 || 'AM_';
2324
2325   my $seen_libobjs = 0;
2326   my $flagvar = 0;
2327
2328   transform_variable_recursively
2329     ($varname, $xname . '_DEPENDENCIES', 'am__DEPENDENCIES',
2330      ! $xname, INTERNAL,
2331      # Transformation function, run on each filename.
2332      sub {
2333        my ($subvar, $val, $cond, $full_cond) = @_;
2334
2335        if ($val =~ /^-/)
2336          {
2337            # Skip -lfoo and -Ldir silently; these are explicitly allowed.
2338            if ($val !~ /^-[lL]/ &&
2339                # Skip -dlopen and -dlpreopen; these are explicitly allowed
2340                # for Libtool libraries or programs.  (Actually we are a bit
2341                # lax here since this code also applies to non-libtool
2342                # libraries or programs, for which -dlopen and -dlopreopen
2343                # are pure nonsense.  Diagnosing this doesn't seem very
2344                # important: the developer will quickly get complaints from
2345                # the linker.)
2346                $val !~ /^-dl(?:pre)?open$/ &&
2347                # Only get this error once.
2348                ! $flagvar)
2349              {
2350                $flagvar = 1;
2351                # FIXME: should display a stack of nested variables
2352                # as context when $var != $subvar.
2353                err_var ($var, "linker flags such as `$val' belong in "
2354                         . "`${prefix}LDFLAGS");
2355              }
2356            return ();
2357          }
2358        elsif ($val !~ /^\@.*\@$/)
2359          {
2360            # Assume we have a file of some sort, and output it into the
2361            # dependency variable.  Autoconf substitutions are not output;
2362            # rarely is a new dependency substituted into e.g. foo_LDADD
2363            # -- but bad things (e.g. -lX11) are routinely substituted.
2364            # Note that LIBOBJS and ALLOCA are exceptions to this rule,
2365            # and handled specially below.
2366            return $val;
2367          }
2368        elsif ($val =~ /^\@(LT)?LIBOBJS\@$/)
2369          {
2370            handle_LIBOBJS ($subvar, $cond, $1);
2371            $seen_libobjs = 1;
2372            return $val;
2373          }
2374        elsif ($val =~ /^\@(LT)?ALLOCA\@$/)
2375          {
2376            handle_ALLOCA ($subvar, $cond, $1);
2377            return $val;
2378          }
2379        else
2380          {
2381            return ();
2382          }
2383      });
2384
2385   return $seen_libobjs;
2386 }
2387
2388 # handle_LIBOBJS_or_ALLOCA ($VAR)
2389 # -------------------------------
2390 # Definitions common to LIBOBJS and ALLOCA.
2391 # VAR should be one of LIBOBJS, LTLIBOBJS, ALLOCA, or LTALLOCA.
2392 sub handle_LIBOBJS_or_ALLOCA ($)
2393 {
2394   my ($var) = @_;
2395
2396   my $dir = '';
2397
2398   # If LIBOBJS files must be built in another directory we have
2399   # to define LIBOBJDIR and ensure the files get cleaned.
2400   # Otherwise LIBOBJDIR can be left undefined, and the cleaning
2401   # is achieved by `rm -f *.$(OBJEXT)' in compile.am.
2402   if ($config_libobj_dir
2403       && $relative_dir ne $config_libobj_dir)
2404     {
2405       if (option 'subdir-objects')
2406         {
2407           # In the top-level Makefile we do not use $(top_builddir), because
2408           # we are already there, and since the targets are built without
2409           # a $(top_builddir), it helps BSD Make to match them with
2410           # dependencies.
2411           $dir = "$config_libobj_dir/" if $config_libobj_dir ne '.';
2412           $dir = "$topsrcdir/$dir" if $relative_dir ne '.';
2413           define_variable ('LIBOBJDIR', "$dir", INTERNAL);
2414           $clean_files{"\$($var)"} = MOSTLY_CLEAN;
2415           # If LTLIBOBJS is used, we must also clear LIBOBJS (which might
2416           # be created by libtool as a side-effect of creating LTLIBOBJS).
2417           $clean_files{"\$($var)"} = MOSTLY_CLEAN if $var =~ s/^LT//;
2418         }
2419       else
2420         {
2421           error ("`\$($var)' cannot be used outside `$config_libobj_dir' if"
2422                  . " `subdir-objects' is not set");
2423         }
2424     }
2425
2426   return $dir;
2427 }
2428
2429 sub handle_LIBOBJS ($$$)
2430 {
2431   my ($var, $cond, $lt) = @_;
2432   my $myobjext = $lt ? 'lo' : 'o';
2433   $lt ||= '';
2434
2435   $var->requires_variables ("\@${lt}LIBOBJS\@ used", $lt . 'LIBOBJS')
2436     if ! keys %libsources;
2437
2438   my $dir = handle_LIBOBJS_or_ALLOCA "${lt}LIBOBJS";
2439
2440   foreach my $iter (keys %libsources)
2441     {
2442       if ($iter =~ /\.[cly]$/)
2443         {
2444           &saw_extension ($&);
2445           &saw_extension ('.c');
2446         }
2447
2448       if ($iter =~ /\.h$/)
2449         {
2450           require_libsource_with_macro ($cond, $var, FOREIGN, $iter);
2451         }
2452       elsif ($iter ne 'alloca.c')
2453         {
2454           my $rewrite = $iter;
2455           $rewrite =~ s/\.c$/.P$myobjext/;
2456           $dep_files{$dir . '$(DEPDIR)/' . $rewrite} = 1;
2457           $rewrite = "^" . quotemeta ($iter) . "\$";
2458           # Only require the file if it is not a built source.
2459           my $bs = var ('BUILT_SOURCES');
2460           if (! $bs || ! grep (/$rewrite/, $bs->value_as_list_recursive))
2461             {
2462               require_libsource_with_macro ($cond, $var, FOREIGN, $iter);
2463             }
2464         }
2465     }
2466 }
2467
2468 sub handle_ALLOCA ($$$)
2469 {
2470   my ($var, $cond, $lt) = @_;
2471   my $myobjext = $lt ? 'lo' : 'o';
2472   $lt ||= '';
2473   my $dir = handle_LIBOBJS_or_ALLOCA "${lt}ALLOCA";
2474
2475   $var->requires_variables ("\@${lt}ALLOCA\@ used", $lt . 'ALLOCA');
2476   $dep_files{$dir . '$(DEPDIR)/alloca.P' . $myobjext} = 1;
2477   require_libsource_with_macro ($cond, $var, FOREIGN, 'alloca.c');
2478   &saw_extension ('.c');
2479 }
2480
2481 # Canonicalize the input parameter
2482 sub canonicalize
2483 {
2484     my ($string) = @_;
2485     $string =~ tr/A-Za-z0-9_\@/_/c;
2486     return $string;
2487 }
2488
2489 # Canonicalize a name, and check to make sure the non-canonical name
2490 # is never used.  Returns canonical name.  Arguments are name and a
2491 # list of suffixes to check for.
2492 sub check_canonical_spelling
2493 {
2494   my ($name, @suffixes) = @_;
2495
2496   my $xname = &canonicalize ($name);
2497   if ($xname ne $name)
2498     {
2499       foreach my $xt (@suffixes)
2500         {
2501           reject_var ("$name$xt", "use `$xname$xt', not `$name$xt'");
2502         }
2503     }
2504
2505   return $xname;
2506 }
2507
2508
2509 # handle_compile ()
2510 # -----------------
2511 # Set up the compile suite.
2512 sub handle_compile ()
2513 {
2514     return
2515       unless $get_object_extension_was_run;
2516
2517     # Boilerplate.
2518     my $default_includes = '';
2519     if (! option 'nostdinc')
2520       {
2521         my @incs = ('-I.', subst ('am__isrc'));
2522
2523         my $var = var 'CONFIG_HEADER';
2524         if ($var)
2525           {
2526             foreach my $hdr (split (' ', $var->variable_value))
2527               {
2528                 push @incs, '-I' . dirname ($hdr);
2529               }
2530           }
2531         # We want `-I. -I$(srcdir)', but the latter -I is redundant
2532         # and unaesthetic in non-VPATH builds.  We use `-I.@am__isrc@`
2533         # instead.  It will be replaced by '-I.' or '-I. -I$(srcdir)'.
2534         # Items in CONFIG_HEADER are never in $(srcdir) so it is safe
2535         # to just put @am__isrc@ right after `-I.', without a space.
2536         ($default_includes = ' ' . uniq (@incs)) =~ s/ @/@/;
2537       }
2538
2539     my (@mostly_rms, @dist_rms);
2540     foreach my $item (sort keys %compile_clean_files)
2541     {
2542         if ($compile_clean_files{$item} == MOSTLY_CLEAN)
2543         {
2544             push (@mostly_rms, "\t-rm -f $item");
2545         }
2546         elsif ($compile_clean_files{$item} == DIST_CLEAN)
2547         {
2548             push (@dist_rms, "\t-rm -f $item");
2549         }
2550         else
2551         {
2552           prog_error 'invalid entry in %compile_clean_files';
2553         }
2554     }
2555
2556     my ($coms, $vars, $rules) =
2557       &file_contents_internal (1, "$libdir/am/compile.am",
2558                                new Automake::Location,
2559                                ('DEFAULT_INCLUDES' => $default_includes,
2560                                 'MOSTLYRMS' => join ("\n", @mostly_rms),
2561                                 'DISTRMS' => join ("\n", @dist_rms)));
2562     $output_vars .= $vars;
2563     $output_rules .= "$coms$rules";
2564
2565     # Check for automatic de-ANSI-fication.
2566     if (option 'ansi2knr')
2567       {
2568         my ($ansi2knr_filename, $ansi2knr_where) = @{option 'ansi2knr'};
2569         my $ansi2knr_dir = '';
2570
2571         require_variables ($ansi2knr_where, "option `ansi2knr' is used",
2572                            TRUE, "ANSI2KNR", "U");
2573
2574         # topdir is where ansi2knr should be.
2575         if ($ansi2knr_filename eq 'ansi2knr')
2576           {
2577             # Only require ansi2knr files if they should appear in
2578             # this directory.
2579             require_file ($ansi2knr_where, FOREIGN,
2580                           'ansi2knr.c', 'ansi2knr.1');
2581
2582             # ansi2knr needs to be built before subdirs, so unshift it
2583             # rather then pushing it.
2584             unshift (@all, '$(ANSI2KNR)');
2585           }
2586         else
2587           {
2588             $ansi2knr_dir = dirname ($ansi2knr_filename);
2589           }
2590
2591         $output_rules .= &file_contents ('ansi2knr',
2592                                          new Automake::Location,
2593                                          'ANSI2KNR-DIR' => $ansi2knr_dir);
2594
2595     }
2596 }
2597
2598 # handle_libtool ()
2599 # -----------------
2600 # Handle libtool rules.
2601 sub handle_libtool
2602 {
2603   return unless var ('LIBTOOL');
2604
2605   # Libtool requires some files, but only at top level.
2606   # (Starting with Libtool 2.0 we do not have to bother.  These
2607   # requirements are done with AC_REQUIRE_AUX_FILE.)
2608   require_conf_file_with_macro (TRUE, 'LIBTOOL', FOREIGN, @libtool_files)
2609     if $relative_dir eq '.' && ! $libtool_new_api;
2610
2611   my @libtool_rms;
2612   foreach my $item (sort keys %libtool_clean_directories)
2613     {
2614       my $dir = ($item eq '.') ? '' : "$item/";
2615       # .libs is for Unix, _libs for DOS.
2616       push (@libtool_rms, "\t-rm -rf ${dir}.libs ${dir}_libs");
2617     }
2618
2619   check_user_variables 'LIBTOOLFLAGS';
2620
2621   # Output the libtool compilation rules.
2622   $output_rules .= &file_contents ('libtool',
2623                                    new Automake::Location,
2624                                    LTRMS => join ("\n", @libtool_rms));
2625 }
2626
2627 # handle_programs ()
2628 # ------------------
2629 # Handle C programs.
2630 sub handle_programs
2631 {
2632   my @proglist = &am_install_var ('progs', 'PROGRAMS',
2633                                   'bin', 'sbin', 'libexec', 'pkglibexec',
2634                                   'noinst', 'check');
2635   return if ! @proglist;
2636
2637   my $seen_global_libobjs =
2638     var ('LDADD') && &handle_lib_objects ('', 'LDADD');
2639
2640   foreach my $pair (@proglist)
2641     {
2642       my ($where, $one_file) = @$pair;
2643
2644       my $seen_libobjs = 0;
2645       my $obj = get_object_extension '.$(OBJEXT)';
2646
2647       $known_programs{$one_file} = $where;
2648
2649       # Canonicalize names and check for misspellings.
2650       my $xname = &check_canonical_spelling ($one_file, '_LDADD', '_LDFLAGS',
2651                                              '_SOURCES', '_OBJECTS',
2652                                              '_DEPENDENCIES');
2653
2654       $where->push_context ("while processing program `$one_file'");
2655       $where->set (INTERNAL->get);
2656
2657       my $linker = &handle_source_transform ($xname, $one_file, $obj, $where,
2658                                              NONLIBTOOL => 1, LIBTOOL => 0);
2659
2660       if (var ($xname . "_LDADD"))
2661         {
2662           $seen_libobjs = &handle_lib_objects ($xname, $xname . '_LDADD');
2663         }
2664       else
2665         {
2666           # User didn't define prog_LDADD override.  So do it.
2667           &define_variable ($xname . '_LDADD', '$(LDADD)', $where);
2668
2669           # This does a bit too much work.  But we need it to
2670           # generate _DEPENDENCIES when appropriate.
2671           if (var ('LDADD'))
2672             {
2673               $seen_libobjs = &handle_lib_objects ($xname, 'LDADD');
2674             }
2675         }
2676
2677       reject_var ($xname . '_LIBADD',
2678                   "use `${xname}_LDADD', not `${xname}_LIBADD'");
2679
2680       set_seen ($xname . '_DEPENDENCIES');
2681       set_seen ($xname . '_LDFLAGS');
2682
2683       # Determine program to use for link.
2684       my($xlink, $vlink) = &define_per_target_linker_variable ($linker, $xname);
2685       $vlink = verbose_flag ($vlink || 'GEN');
2686
2687       # If the resulting program lies into a subdirectory,
2688       # make sure this directory will exist.
2689       my $dirstamp = require_build_directory_maybe ($one_file);
2690
2691       $libtool_clean_directories{dirname ($one_file)} = 1;
2692
2693       $output_rules .= &file_contents ('program',
2694                                        $where,
2695                                        PROGRAM  => $one_file,
2696                                        XPROGRAM => $xname,
2697                                        XLINK    => $xlink,
2698                                        VERBOSE  => $vlink,
2699                                        DIRSTAMP => $dirstamp,
2700                                        EXEEXT   => '$(EXEEXT)');
2701
2702       if ($seen_libobjs || $seen_global_libobjs)
2703         {
2704           if (var ($xname . '_LDADD'))
2705             {
2706               &check_libobjs_sources ($xname, $xname . '_LDADD');
2707             }
2708           elsif (var ('LDADD'))
2709             {
2710               &check_libobjs_sources ($xname, 'LDADD');
2711             }
2712         }
2713     }
2714 }
2715
2716
2717 # handle_libraries ()
2718 # -------------------
2719 # Handle libraries.
2720 sub handle_libraries
2721 {
2722   my @liblist = &am_install_var ('libs', 'LIBRARIES',
2723                                  'lib', 'pkglib', 'noinst', 'check');
2724   return if ! @liblist;
2725
2726   my @prefix = am_primary_prefixes ('LIBRARIES', 0, 'lib', 'pkglib',
2727                                     'noinst', 'check');
2728
2729   if (@prefix)
2730     {
2731       my $var = rvar ($prefix[0] . '_LIBRARIES');
2732       $var->requires_variables ('library used', 'RANLIB');
2733     }
2734
2735   &define_variable ('AR', 'ar', INTERNAL);
2736   &define_variable ('ARFLAGS', 'cru', INTERNAL);
2737   &define_verbose_tagvar ('AR');
2738
2739   foreach my $pair (@liblist)
2740     {
2741       my ($where, $onelib) = @$pair;
2742
2743       my $seen_libobjs = 0;
2744       # Check that the library fits the standard naming convention.
2745       my $bn = basename ($onelib);
2746       if ($bn !~ /^lib.*\.a$/)
2747         {
2748           $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.a/;
2749           my $suggestion = dirname ($onelib) . "/$bn";
2750           $suggestion =~ s|^\./||g;
2751           msg ('error-gnu/warn', $where,
2752                "`$onelib' is not a standard library name\n"
2753                . "did you mean `$suggestion'?")
2754         }
2755
2756       ($known_libraries{$onelib} = $bn) =~ s/\.a$//;
2757
2758       $where->push_context ("while processing library `$onelib'");
2759       $where->set (INTERNAL->get);
2760
2761       my $obj = get_object_extension '.$(OBJEXT)';
2762
2763       # Canonicalize names and check for misspellings.
2764       my $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
2765                                             '_OBJECTS', '_DEPENDENCIES',
2766                                             '_AR');
2767
2768       if (! var ($xlib . '_AR'))
2769         {
2770           &define_variable ($xlib . '_AR', '$(AR) $(ARFLAGS)', $where);
2771         }
2772
2773       # Generate support for conditional object inclusion in
2774       # libraries.
2775       if (var ($xlib . '_LIBADD'))
2776         {
2777           if (&handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2778             {
2779               $seen_libobjs = 1;
2780             }
2781         }
2782       else
2783         {
2784           &define_variable ($xlib . "_LIBADD", '', $where);
2785         }
2786
2787       reject_var ($xlib . '_LDADD',
2788                   "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
2789
2790       # Make sure we at look at this.
2791       set_seen ($xlib . '_DEPENDENCIES');
2792
2793       &handle_source_transform ($xlib, $onelib, $obj, $where,
2794                                 NONLIBTOOL => 1, LIBTOOL => 0);
2795
2796       # If the resulting library lies into a subdirectory,
2797       # make sure this directory will exist.
2798       my $dirstamp = require_build_directory_maybe ($onelib);
2799       my $verbose = verbose_flag ('AR');
2800       my $silent = silent_flag ();
2801
2802       $output_rules .= &file_contents ('library',
2803                                        $where,
2804                                        VERBOSE  => $verbose,
2805                                        SILENT   => $silent,
2806                                        LIBRARY  => $onelib,
2807                                        XLIBRARY => $xlib,
2808                                        DIRSTAMP => $dirstamp);
2809
2810       if ($seen_libobjs)
2811         {
2812           if (var ($xlib . '_LIBADD'))
2813             {
2814               &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
2815             }
2816         }
2817
2818       if (! $seen_ar)
2819         {
2820           msg ('extra-portability', $where,
2821                "`$onelib': linking libraries using a non-POSIX\n"
2822                . "archiver requires `AM_PROG_AR' in `$configure_ac'")
2823         }
2824     }
2825 }
2826
2827
2828 # handle_ltlibraries ()
2829 # ---------------------
2830 # Handle shared libraries.
2831 sub handle_ltlibraries
2832 {
2833   my @liblist = &am_install_var ('ltlib', 'LTLIBRARIES',
2834                                  'noinst', 'lib', 'pkglib', 'check');
2835   return if ! @liblist;
2836
2837   my @prefix = am_primary_prefixes ('LTLIBRARIES', 0, 'lib', 'pkglib',
2838                                     'noinst', 'check');
2839
2840   if (@prefix)
2841     {
2842       my $var = rvar ($prefix[0] . '_LTLIBRARIES');
2843       $var->requires_variables ('Libtool library used', 'LIBTOOL');
2844     }
2845
2846   my %instdirs = ();
2847   my %instsubdirs = ();
2848   my %instconds = ();
2849   my %liblocations = ();        # Location (in Makefile.am) of each library.
2850
2851   foreach my $key (@prefix)
2852     {
2853       # Get the installation directory of each library.
2854       my $dir = $key;
2855       my $strip_subdir = 1;
2856       if ($dir =~ /^nobase_/)
2857         {
2858           $dir =~ s/^nobase_//;
2859           $strip_subdir = 0;
2860         }
2861       my $var = rvar ($key . '_LTLIBRARIES');
2862
2863       # We reject libraries which are installed in several places
2864       # in the same condition, because we can only specify one
2865       # `-rpath' option.
2866       $var->traverse_recursively
2867         (sub
2868          {
2869            my ($var, $val, $cond, $full_cond) = @_;
2870            my $hcond = $full_cond->human;
2871            my $where = $var->rdef ($cond)->location;
2872            my $ldir = '';
2873            $ldir = '/' . dirname ($val)
2874              if (!$strip_subdir);
2875            # A library cannot be installed in different directories
2876            # in overlapping conditions.
2877            if (exists $instconds{$val})
2878              {
2879                my ($msg, $acond) =
2880                  $instconds{$val}->ambiguous_p ($val, $full_cond);
2881
2882                if ($msg)
2883                  {
2884                    error ($where, $msg, partial => 1);
2885                    my $dirtxt = "installed " . ($strip_subdir ? "in" : "below") . " `$dir'";
2886                    $dirtxt = "built for `$dir'"
2887                      if $dir eq 'EXTRA' || $dir eq 'noinst' || $dir eq 'check';
2888                    my $dircond =
2889                      $full_cond->true ? "" : " in condition $hcond";
2890
2891                    error ($where, "`$val' should be $dirtxt$dircond ...",
2892                           partial => 1);
2893
2894                    my $hacond = $acond->human;
2895                    my $adir = $instdirs{$val}{$acond};
2896                    my $adirtxt = "installed in `$adir'";
2897                    $adirtxt = "built for `$adir'"
2898                      if ($adir eq 'EXTRA' || $adir eq 'noinst'
2899                          || $adir eq 'check');
2900                    my $adircond = $acond->true ? "" : " in condition $hacond";
2901
2902                    my $onlyone = ($dir ne $adir) ?
2903                      ("\nLibtool libraries can be built for only one "
2904                       . "destination.") : "";
2905
2906                    error ($liblocations{$val}{$acond},
2907                           "... and should also be $adirtxt$adircond.$onlyone");
2908                    return;
2909                  }
2910              }
2911            else
2912              {
2913                $instconds{$val} = new Automake::DisjConditions;
2914              }
2915            $instdirs{$val}{$full_cond} = $dir;
2916            $instsubdirs{$val}{$full_cond} = $ldir;
2917            $liblocations{$val}{$full_cond} = $where;
2918            $instconds{$val} = $instconds{$val}->merge ($full_cond);
2919          },
2920          sub
2921          {
2922            return ();
2923          },
2924          skip_ac_subst => 1);
2925     }
2926
2927   foreach my $pair (@liblist)
2928     {
2929       my ($where, $onelib) = @$pair;
2930
2931       my $seen_libobjs = 0;
2932       my $obj = get_object_extension '.lo';
2933
2934       # Canonicalize names and check for misspellings.
2935       my $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
2936                                             '_SOURCES', '_OBJECTS',
2937                                             '_DEPENDENCIES');
2938
2939       # Check that the library fits the standard naming convention.
2940       my $libname_rx = '^lib.*\.la';
2941       my $ldvar = var ("${xlib}_LDFLAGS") || var ('AM_LDFLAGS');
2942       my $ldvar2 = var ('LDFLAGS');
2943       if (($ldvar && grep (/-module/, $ldvar->value_as_list_recursive))
2944           || ($ldvar2 && grep (/-module/, $ldvar2->value_as_list_recursive)))
2945         {
2946           # Relax name checking for libtool modules.
2947           $libname_rx = '\.la';
2948         }
2949
2950       my $bn = basename ($onelib);
2951       if ($bn !~ /$libname_rx$/)
2952         {
2953           my $type = 'library';
2954           if ($libname_rx eq '\.la')
2955             {
2956               $bn =~ s/^(lib|)(.*?)(?:\.[^.]*)?$/$1$2.la/;
2957               $type = 'module';
2958             }
2959           else
2960             {
2961               $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.la/;
2962             }
2963           my $suggestion = dirname ($onelib) . "/$bn";
2964           $suggestion =~ s|^\./||g;
2965           msg ('error-gnu/warn', $where,
2966                "`$onelib' is not a standard libtool $type name\n"
2967                . "did you mean `$suggestion'?")
2968         }
2969
2970       ($known_libraries{$onelib} = $bn) =~ s/\.la$//;
2971
2972       $where->push_context ("while processing Libtool library `$onelib'");
2973       $where->set (INTERNAL->get);
2974
2975       # Make sure we look at these.
2976       set_seen ($xlib . '_LDFLAGS');
2977       set_seen ($xlib . '_DEPENDENCIES');
2978
2979       # Generate support for conditional object inclusion in
2980       # libraries.
2981       if (var ($xlib . '_LIBADD'))
2982         {
2983           if (&handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2984             {
2985               $seen_libobjs = 1;
2986             }
2987         }
2988       else
2989         {
2990           &define_variable ($xlib . "_LIBADD", '', $where);
2991         }
2992
2993       reject_var ("${xlib}_LDADD",
2994                   "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
2995
2996
2997       my $linker = &handle_source_transform ($xlib, $onelib, $obj, $where,
2998                                              NONLIBTOOL => 0, LIBTOOL => 1);
2999
3000       # Determine program to use for link.
3001       my($xlink, $vlink) = &define_per_target_linker_variable ($linker, $xlib);
3002       $vlink = verbose_flag ($vlink || 'GEN');
3003
3004       my $rpathvar = "am_${xlib}_rpath";
3005       my $rpath = "\$($rpathvar)";
3006       foreach my $rcond ($instconds{$onelib}->conds)
3007         {
3008           my $val;
3009           if ($instdirs{$onelib}{$rcond} eq 'EXTRA'
3010               || $instdirs{$onelib}{$rcond} eq 'noinst'
3011               || $instdirs{$onelib}{$rcond} eq 'check')
3012             {
3013               # It's an EXTRA_ library, so we can't specify -rpath,
3014               # because we don't know where the library will end up.
3015               # The user probably knows, but generally speaking automake
3016               # doesn't -- and in fact configure could decide
3017               # dynamically between two different locations.
3018               $val = '';
3019             }
3020           else
3021             {
3022               $val = ('-rpath $(' . $instdirs{$onelib}{$rcond} . 'dir)');
3023               $val .= $instsubdirs{$onelib}{$rcond}
3024                 if defined $instsubdirs{$onelib}{$rcond};
3025             }
3026           if ($rcond->true)
3027             {
3028               # If $rcond is true there is only one condition and
3029               # there is no point defining an helper variable.
3030               $rpath = $val;
3031             }
3032           else
3033             {
3034               define_pretty_variable ($rpathvar, $rcond, INTERNAL, $val);
3035             }
3036         }
3037
3038       # If the resulting library lies into a subdirectory,
3039       # make sure this directory will exist.
3040       my $dirstamp = require_build_directory_maybe ($onelib);
3041
3042       # Remember to cleanup .libs/ in this directory.
3043       my $dirname = dirname $onelib;
3044       $libtool_clean_directories{$dirname} = 1;
3045
3046       $output_rules .= &file_contents ('ltlibrary',
3047                                        $where,
3048                                        LTLIBRARY  => $onelib,
3049                                        XLTLIBRARY => $xlib,
3050                                        RPATH      => $rpath,
3051                                        XLINK      => $xlink,
3052                                        VERBOSE    => $vlink,
3053                                        DIRSTAMP   => $dirstamp);
3054       if ($seen_libobjs)
3055         {
3056           if (var ($xlib . '_LIBADD'))
3057             {
3058               &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
3059             }
3060         }
3061
3062       if (! $seen_ar)
3063         {
3064           msg ('extra-portability', $where,
3065                "`$onelib': linking libtool libraries using a non-POSIX\n"
3066                . "archiver requires `AM_PROG_AR' in `$configure_ac'")
3067         }
3068     }
3069 }
3070
3071 # See if any _SOURCES variable were misspelled.
3072 sub check_typos ()
3073 {
3074   # It is ok if the user sets this particular variable.
3075   set_seen 'AM_LDFLAGS';
3076
3077   foreach my $primary ('SOURCES', 'LIBADD', 'LDADD', 'LDFLAGS', 'DEPENDENCIES')
3078     {
3079       foreach my $var (variables $primary)
3080         {
3081           my $varname = $var->name;
3082           # A configure variable is always legitimate.
3083           next if exists $configure_vars{$varname};
3084
3085           for my $cond ($var->conditions->conds)
3086             {
3087               $varname =~ /^(?:nobase_)?(?:dist_|nodist_)?(.*)_[[:alnum:]]+$/;
3088               msg_var ('syntax', $var, "variable `$varname' is defined but no"
3089                        . " program or\nlibrary has `$1' as canonical name"
3090                        . " (possible typo)")
3091                 unless $var->rdef ($cond)->seen;
3092             }
3093         }
3094     }
3095 }
3096
3097
3098 # Handle scripts.
3099 sub handle_scripts
3100 {
3101     # NOTE we no longer automatically clean SCRIPTS, because it is
3102     # useful to sometimes distribute scripts verbatim.  This happens
3103     # e.g. in Automake itself.
3104     &am_install_var ('-candist', 'scripts', 'SCRIPTS',
3105                      'bin', 'sbin', 'libexec', 'pkgdata',
3106                      'noinst', 'check');
3107 }
3108
3109
3110
3111
3112 ## ------------------------ ##
3113 ## Handling Texinfo files.  ##
3114 ## ------------------------ ##
3115
3116 # ($OUTFILE, $VFILE, @CLEAN_FILES)
3117 # &scan_texinfo_file ($FILENAME)
3118 # ------------------------------
3119 # $OUTFILE     - name of the info file produced by $FILENAME.
3120 # $VFILE       - name of the version.texi file used (undef if none).
3121 # @CLEAN_FILES - list of byproducts (indexes etc.)
3122 sub scan_texinfo_file ($)
3123 {
3124   my ($filename) = @_;
3125
3126   # Some of the following extensions are always created, no matter
3127   # whether indexes are used or not.  Other (like cps, fns, ... pgs)
3128   # are only created when they are used.  We used to scan $FILENAME
3129   # for their use, but that is not enough: they could be used in
3130   # included files.  We can't scan included files because we don't
3131   # know the include path.  Therefore we always erase these files, no
3132   # matter whether they are used or not.
3133   #
3134   # (tmp is only created if an @macro is used and a certain e-TeX
3135   # feature is not available.)
3136   my %clean_suffixes =
3137     map { $_ => 1 } (qw(aux log toc tmp
3138                         cp cps
3139                         fn fns
3140                         ky kys
3141                         vr vrs
3142                         tp tps
3143                         pg pgs)); # grep 'new.*index' texinfo.tex
3144
3145   my $texi = new Automake::XFile "< $filename";
3146   verb "reading $filename";
3147
3148   my ($outfile, $vfile);
3149   while ($_ = $texi->getline)
3150     {
3151       if (/^\@setfilename +(\S+)/)
3152         {
3153           # Honor only the first @setfilename.  (It's possible to have
3154           # more occurrences later if the manual shows examples of how
3155           # to use @setfilename...)
3156           next if $outfile;
3157
3158           $outfile = $1;
3159           if ($outfile =~ /\.([^.]+)$/ && $1 ne 'info')
3160             {
3161               error ("$filename:$.",
3162                      "output `$outfile' has unrecognized extension");
3163               return;
3164             }
3165         }
3166       # A "version.texi" file is actually any file whose name matches
3167       # "vers*.texi".
3168       elsif (/^\@include\s+(vers[^.]*\.texi)\s*$/)
3169         {
3170           $vfile = $1;
3171         }
3172
3173       # Try to find new or unused indexes.
3174
3175       # Creating a new category of index.
3176       elsif (/^\@def(code)?index (\w+)/)
3177         {
3178           $clean_suffixes{$2} = 1;
3179           $clean_suffixes{"$2s"} = 1;
3180         }
3181
3182       # Merging an index into an another.
3183       elsif (/^\@syn(code)?index (\w+) (\w+)/)
3184         {
3185           delete $clean_suffixes{"$2s"};
3186           $clean_suffixes{"$3s"} = 1;
3187         }
3188
3189     }
3190
3191   if (! $outfile)
3192     {
3193       err_am "`$filename' missing \@setfilename";
3194       return;
3195     }
3196
3197   my $infobase = basename ($filename);
3198   $infobase =~ s/\.te?xi(nfo)?$//;
3199   return ($outfile, $vfile,
3200           map { "$infobase.$_" } (sort keys %clean_suffixes));
3201 }
3202
3203
3204 # ($DIRSTAMP, @CLEAN_FILES)
3205 # output_texinfo_build_rules ($SOURCE, $DEST, $INSRC, @DEPENDENCIES)
3206 # ------------------------------------------------------------------
3207 # SOURCE - the source Texinfo file
3208 # DEST - the destination Info file
3209 # INSRC - whether DEST should be built in the source tree
3210 # DEPENDENCIES - known dependencies
3211 sub output_texinfo_build_rules ($$$@)
3212 {
3213   my ($source, $dest, $insrc, @deps) = @_;
3214
3215   # Split `a.texi' into `a' and `.texi'.
3216   my ($spfx, $ssfx) = ($source =~ /^(.*?)(\.[^.]*)?$/);
3217   my ($dpfx, $dsfx) = ($dest =~ /^(.*?)(\.[^.]*)?$/);
3218
3219   $ssfx ||= "";
3220   $dsfx ||= "";
3221
3222   # We can output two kinds of rules: the "generic" rules use Make
3223   # suffix rules and are appropriate when $source and $dest do not lie
3224   # in a sub-directory; the "specific" rules are needed in the other
3225   # case.
3226   #
3227   # The former are output only once (this is not really apparent here,
3228   # but just remember that some logic deeper in Automake will not
3229   # output the same rule twice); while the later need to be output for
3230   # each Texinfo source.
3231   my $generic;
3232   my $makeinfoflags;
3233   my $sdir = dirname $source;
3234   if ($sdir eq '.' && dirname ($dest) eq '.')
3235     {
3236       $generic = 1;
3237       $makeinfoflags = '-I $(srcdir)';
3238     }
3239   else
3240     {
3241       $generic = 0;
3242       $makeinfoflags = "-I $sdir -I \$(srcdir)/$sdir";
3243     }
3244
3245   # A directory can contain two kinds of info files: some built in the
3246   # source tree, and some built in the build tree.  The rules are
3247   # different in each case.  However we cannot output two different
3248   # set of generic rules.  Because in-source builds are more usual, we
3249   # use generic rules in this case and fall back to "specific" rules
3250   # for build-dir builds.  (It should not be a problem to invert this
3251   # if needed.)
3252   $generic = 0 unless $insrc;
3253
3254   # We cannot use a suffix rule to build info files with an empty
3255   # extension.  Otherwise we would output a single suffix inference
3256   # rule, with separate dependencies, as in
3257   #
3258   #    .texi:
3259   #             $(MAKEINFO) ...
3260   #    foo.info: foo.texi
3261   #
3262   # which confuse Solaris make.  (See the Autoconf manual for
3263   # details.)  Therefore we use a specific rule in this case.  This
3264   # applies to info files only (dvi and pdf files always have an
3265   # extension).
3266   my $generic_info = ($generic && $dsfx) ? 1 : 0;
3267
3268   # If the resulting file lie into a subdirectory,
3269   # make sure this directory will exist.
3270   my $dirstamp = require_build_directory_maybe ($dest);
3271
3272   my $dipfx = ($insrc ? '$(srcdir)/' : '') . $dpfx;
3273
3274   $output_rules .= file_contents ('texibuild',
3275                                   new Automake::Location,
3276                                   DEPS             => "@deps",
3277                                   DEST_PREFIX      => $dpfx,
3278                                   DEST_INFO_PREFIX => $dipfx,
3279                                   DEST_SUFFIX      => $dsfx,
3280                                   DIRSTAMP         => $dirstamp,
3281                                   GENERIC          => $generic,
3282                                   GENERIC_INFO     => $generic_info,
3283                                   INSRC            => $insrc,
3284                                   MAKEINFOFLAGS    => $makeinfoflags,
3285                                   SOURCE           => ($generic
3286                                                        ? '$<' : $source),
3287                                   SOURCE_INFO      => ($generic_info
3288                                                        ? '$<' : $source),
3289                                   SOURCE_REAL      => $source,
3290                                   SOURCE_SUFFIX    => $ssfx,
3291                                   );
3292   return ($dirstamp, "$dpfx.dvi", "$dpfx.pdf", "$dpfx.ps", "$dpfx.html");
3293 }
3294
3295
3296 # ($MOSTLYCLEAN, $TEXICLEAN, $MAINTCLEAN)
3297 # handle_texinfo_helper ($info_texinfos)
3298 # --------------------------------------
3299 # Handle all Texinfo source; helper for handle_texinfo.
3300 sub handle_texinfo_helper ($)
3301 {
3302   my ($info_texinfos) = @_;
3303   my (@infobase, @info_deps_list, @texi_deps);
3304   my %versions;
3305   my $done = 0;
3306   my (@mostly_cleans, @texi_cleans, @maint_cleans) = ('', '', '');
3307
3308   # Build a regex matching user-cleaned files.
3309   my $d = var 'DISTCLEANFILES';
3310   my $c = var 'CLEANFILES';
3311   my @f = ();
3312   push @f, $d->value_as_list_recursive (inner_expand => 1) if $d;
3313   push @f, $c->value_as_list_recursive (inner_expand => 1) if $c;
3314   @f = map { s|[^A-Za-z_0-9*\[\]\-]|\\$&|g; s|\*|[^/]*|g; $_; } @f;
3315   my $user_cleaned_files = '^(?:' . join ('|', @f) . ')$';
3316
3317   foreach my $texi
3318       ($info_texinfos->value_as_list_recursive (inner_expand => 1))
3319     {
3320       my $infobase = $texi;
3321       $infobase =~ s/\.(txi|texinfo|texi)$//;
3322
3323       if ($infobase eq $texi)
3324         {
3325           # FIXME: report line number.
3326           err_am "texinfo file `$texi' has unrecognized extension";
3327           next;
3328         }
3329
3330       push @infobase, $infobase;
3331
3332       # If 'version.texi' is referenced by input file, then include
3333       # automatic versioning capability.
3334       my ($out_file, $vtexi, @clean_files) =
3335         scan_texinfo_file ("$relative_dir/$texi")
3336         or next;
3337       push (@mostly_cleans, @clean_files);
3338
3339       # If the Texinfo source is in a subdirectory, create the
3340       # resulting info in this subdirectory.  If it is in the current
3341       # directory, try hard to not prefix "./" because it breaks the
3342       # generic rules.
3343       my $outdir = dirname ($texi) . '/';
3344       $outdir = "" if $outdir eq './';
3345       $out_file =  $outdir . $out_file;
3346
3347       # Until Automake 1.6.3, .info files were built in the
3348       # source tree.  This was an obstacle to the support of
3349       # non-distributed .info files, and non-distributed .texi
3350       # files.
3351       #
3352       # * Non-distributed .texi files is important in some packages
3353       #   where .texi files are built at make time, probably using
3354       #   other binaries built in the package itself, maybe using
3355       #   tools or information found on the build host.  Because
3356       #   these files are not distributed they are always rebuilt
3357       #   at make time; they should therefore not lie in the source
3358       #   directory.  One plan was to support this using
3359       #   nodist_info_TEXINFOS or something similar.  (Doing this
3360       #   requires some sanity checks.  For instance Automake should
3361       #   not allow:
3362       #      dist_info_TEXINFOS = foo.texi
3363       #      nodist_foo_TEXINFOS = included.texi
3364       #   because a distributed file should never depend on a
3365       #   non-distributed file.)
3366       #
3367       # * If .texi files are not distributed, then .info files should
3368       #   not be distributed either.  There are also cases where one
3369       #   wants to distribute .texi files, but does not want to
3370       #   distribute the .info files.  For instance the Texinfo package
3371       #   distributes the tool used to build these files; it would
3372       #   be a waste of space to distribute them.  It's not clear
3373       #   which syntax we should use to indicate that .info files should
3374       #   not be distributed.  Akim Demaille suggested that eventually
3375       #   we switch to a new syntax:
3376       #   |  Maybe we should take some inspiration from what's already
3377       #   |  done in the rest of Automake.  Maybe there is too much
3378       #   |  syntactic sugar here, and you want
3379       #   |     nodist_INFO = bar.info
3380       #   |     dist_bar_info_SOURCES = bar.texi
3381       #   |     bar_texi_DEPENDENCIES = foo.texi
3382       #   |  with a bit of magic to have bar.info represent the whole
3383       #   |  bar*info set.  That's a lot more verbose that the current
3384       #   |  situation, but it is # not new, hence the user has less
3385       #   |  to learn.
3386       #   |
3387       #   |  But there is still too much room for meaningless specs:
3388       #   |     nodist_INFO = bar.info
3389       #   |     dist_bar_info_SOURCES = bar.texi
3390       #   |     dist_PS = bar.ps something-written-by-hand.ps
3391       #   |     nodist_bar_ps_SOURCES = bar.texi
3392       #   |     bar_texi_DEPENDENCIES = foo.texi
3393       #   |  here bar.texi is dist_ in line 2, and nodist_ in 4.
3394       #
3395       # Back to the point, it should be clear that in order to support
3396       # non-distributed .info files, we need to build them in the
3397       # build tree, not in the source tree (non-distributed .texi
3398       # files are less of a problem, because we do not output build
3399       # rules for them).  In Automake 1.7 .info build rules have been
3400       # largely cleaned up so that .info files get always build in the
3401       # build tree, even when distributed.  The idea was that
3402       #   (1) if during a VPATH build the .info file was found to be
3403       #       absent or out-of-date (in the source tree or in the
3404       #       build tree), Make would rebuild it in the build tree.
3405       #       If an up-to-date source-tree of the .info file existed,
3406       #       make would not rebuild it in the build tree.
3407       #   (2) having two copies of .info files, one in the source tree
3408       #       and one (newer) in the build tree is not a problem
3409       #       because `make dist' always pick files in the build tree
3410       #       first.
3411       # However it turned out the be a bad idea for several reasons:
3412       #   * Tru64, OpenBSD, and FreeBSD (not NetBSD) Make do not behave
3413       #     like GNU Make on point (1) above.  These implementations
3414       #     of Make would always rebuild .info files in the build
3415       #     tree, even if such files were up to date in the source
3416       #     tree.  Consequently, it was impossible to perform a VPATH
3417       #     build of a package containing Texinfo files using these
3418       #     Make implementations.
3419       #     (Refer to the Autoconf Manual, section "Limitation of
3420       #     Make", paragraph "VPATH", item "target lookup", for
3421       #     an account of the differences between these
3422       #     implementations.)
3423       #   * The GNU Coding Standards require these files to be built
3424       #     in the source-tree (when they are distributed, that is).
3425       #   * Keeping a fresher copy of distributed files in the
3426       #     build tree can be annoying during development because
3427       #     - if the files is kept under CVS, you really want it
3428       #       to be updated in the source tree
3429       #     - it is confusing that `make distclean' does not erase
3430       #       all files in the build tree.
3431       #
3432       # Consequently, starting with Automake 1.8, .info files are
3433       # built in the source tree again.  Because we still plan to
3434       # support non-distributed .info files at some point, we
3435       # have a single variable ($INSRC) that controls whether
3436       # the current .info file must be built in the source tree
3437       # or in the build tree.  Actually this variable is switched
3438       # off for .info files that appear to be cleaned; this is
3439       # for backward compatibility with package such as Texinfo,
3440       # which do things like
3441       #   info_TEXINFOS = texinfo.txi info-stnd.texi info.texi
3442       #   DISTCLEANFILES = texinfo texinfo-* info*.info*
3443       #   # Do not create info files for distribution.
3444       #   dist-info:
3445       # in order not to distribute .info files.
3446       my $insrc = ($out_file =~ $user_cleaned_files) ? 0 : 1;
3447
3448       my $soutdir = '$(srcdir)/' . $outdir;
3449       $outdir = $soutdir if $insrc;
3450
3451       # If user specified file_TEXINFOS, then use that as explicit
3452       # dependency list.
3453       @texi_deps = ();
3454       push (@texi_deps, "$soutdir$vtexi") if $vtexi;
3455
3456       my $canonical = canonicalize ($infobase);
3457       if (var ($canonical . "_TEXINFOS"))
3458         {
3459           push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
3460           push_dist_common ('$(' . $canonical . '_TEXINFOS)');
3461         }
3462
3463       my ($dirstamp, @cfiles) =
3464         output_texinfo_build_rules ($texi, $out_file, $insrc, @texi_deps);
3465       push (@texi_cleans, @cfiles);
3466
3467       push (@info_deps_list, $out_file);
3468
3469       # If a vers*.texi file is needed, emit the rule.
3470       if ($vtexi)
3471         {
3472           err_am ("`$vtexi', included in `$texi', "
3473                   . "also included in `$versions{$vtexi}'")
3474             if defined $versions{$vtexi};
3475           $versions{$vtexi} = $texi;
3476
3477           # We number the stamp-vti files.  This is doable since the
3478           # actual names don't matter much.  We only number starting
3479           # with the second one, so that the common case looks nice.
3480           my $vti = ($done ? $done : 'vti');
3481           ++$done;
3482
3483           # This is ugly, but it is our historical practice.
3484           if ($config_aux_dir_set_in_configure_ac)
3485             {
3486               require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3487                                             'mdate-sh');
3488             }
3489           else
3490             {
3491               require_file_with_macro (TRUE, 'info_TEXINFOS',
3492                                        FOREIGN, 'mdate-sh');
3493             }
3494
3495           my $conf_dir;
3496           if ($config_aux_dir_set_in_configure_ac)
3497             {
3498               $conf_dir = "$am_config_aux_dir/";
3499             }
3500           else
3501             {
3502               $conf_dir = '$(srcdir)/';
3503             }
3504           $output_rules .= file_contents ('texi-vers',
3505                                           new Automake::Location,
3506                                           TEXI     => $texi,
3507                                           VTI      => $vti,
3508                                           STAMPVTI => "${soutdir}stamp-$vti",
3509                                           VTEXI    => "$soutdir$vtexi",
3510                                           MDDIR    => $conf_dir,
3511                                           DIRSTAMP => $dirstamp);
3512         }
3513     }
3514
3515   # Handle location of texinfo.tex.
3516   my $need_texi_file = 0;
3517   my $texinfodir;
3518   if (var ('TEXINFO_TEX'))
3519     {
3520       # The user defined TEXINFO_TEX so assume he knows what he is
3521       # doing.
3522       $texinfodir = ('$(srcdir)/'
3523                      . dirname (variable_value ('TEXINFO_TEX')));
3524     }
3525   elsif (option 'cygnus')
3526     {
3527       $texinfodir = '$(top_srcdir)/../texinfo';
3528       define_variable ('TEXINFO_TEX', "$texinfodir/texinfo.tex", INTERNAL);
3529     }
3530   elsif ($config_aux_dir_set_in_configure_ac)
3531     {
3532       $texinfodir = $am_config_aux_dir;
3533       define_variable ('TEXINFO_TEX', "$texinfodir/texinfo.tex", INTERNAL);
3534       $need_texi_file = 2; # so that we require_conf_file later
3535     }
3536   else
3537     {
3538       $texinfodir = '$(srcdir)';
3539       $need_texi_file = 1;
3540     }
3541   define_variable ('am__TEXINFO_TEX_DIR', $texinfodir, INTERNAL);
3542
3543   push (@dist_targets, 'dist-info');
3544
3545   if (! option 'no-installinfo')
3546     {
3547       # Make sure documentation is made and installed first.  Use
3548       # $(INFO_DEPS), not 'info', because otherwise recursive makes
3549       # get run twice during "make all".
3550       unshift (@all, '$(INFO_DEPS)');
3551     }
3552
3553   define_files_variable ("DVIS", @infobase, 'dvi', INTERNAL);
3554   define_files_variable ("PDFS", @infobase, 'pdf', INTERNAL);
3555   define_files_variable ("PSS", @infobase, 'ps', INTERNAL);
3556   define_files_variable ("HTMLS", @infobase, 'html', INTERNAL);
3557
3558   # This next isn't strictly needed now -- the places that look here
3559   # could easily be changed to look in info_TEXINFOS.  But this is
3560   # probably better, in case noinst_TEXINFOS is ever supported.
3561   define_variable ("TEXINFOS", variable_value ('info_TEXINFOS'), INTERNAL);
3562
3563   # Do some error checking.  Note that this file is not required
3564   # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
3565   # up above.
3566   if ($need_texi_file && ! option 'no-texinfo.tex')
3567     {
3568       if ($need_texi_file > 1)
3569         {
3570           require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3571                                         'texinfo.tex');
3572         }
3573       else
3574         {
3575           require_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3576                                    'texinfo.tex');
3577         }
3578     }
3579
3580   return (makefile_wrap ("", "\t  ", @mostly_cleans),
3581           makefile_wrap ("", "\t  ", @texi_cleans),
3582           makefile_wrap ("", "\t  ", @maint_cleans));
3583 }
3584
3585
3586 # handle_texinfo ()
3587 # -----------------
3588 # Handle all Texinfo source.
3589 sub handle_texinfo ()
3590 {
3591   reject_var 'TEXINFOS', "`TEXINFOS' is an anachronism; use `info_TEXINFOS'";
3592   # FIXME: I think this is an obsolete future feature name.
3593   reject_var 'html_TEXINFOS', "HTML generation not yet supported";
3594
3595   my $info_texinfos = var ('info_TEXINFOS');
3596   my ($mostlyclean, $clean, $maintclean) = ('', '', '');
3597   if ($info_texinfos)
3598     {
3599       ($mostlyclean, $clean, $maintclean) = handle_texinfo_helper ($info_texinfos);
3600       chomp $mostlyclean;
3601       chomp $clean;
3602       chomp $maintclean;
3603     }
3604
3605   $output_rules .=  file_contents ('texinfos',
3606                                    new Automake::Location,
3607                                    MOSTLYCLEAN   => $mostlyclean,
3608                                    TEXICLEAN     => $clean,
3609                                    MAINTCLEAN    => $maintclean,
3610                                    'LOCAL-TEXIS' => !!$info_texinfos);
3611 }
3612
3613
3614 # Handle any man pages.
3615 sub handle_man_pages
3616 {
3617   reject_var 'MANS', "`MANS' is an anachronism; use `man_MANS'";
3618
3619   # Find all the sections in use.  We do this by first looking for
3620   # "standard" sections, and then looking for any additional
3621   # sections used in man_MANS.
3622   my (%sections, %notrans_sections, %trans_sections,
3623       %notrans_vars, %trans_vars, %notrans_sect_vars, %trans_sect_vars);
3624   # We handle nodist_ for uniformity.  man pages aren't distributed
3625   # by default so it isn't actually very important.
3626   foreach my $npfx ('', 'notrans_')
3627     {
3628       foreach my $pfx ('', 'dist_', 'nodist_')
3629         {
3630           # Add more sections as needed.
3631           foreach my $section ('0'..'9', 'n', 'l')
3632             {
3633               my $varname = $npfx . $pfx . 'man' . $section . '_MANS';
3634               if (var ($varname))
3635                 {
3636                   $sections{$section} = 1;
3637                   $varname = '$(' . $varname . ')';
3638                   if ($npfx eq 'notrans_')
3639                     {
3640                       $notrans_sections{$section} = 1;
3641                       $notrans_sect_vars{$varname} = 1;
3642                     }
3643                   else
3644                     {
3645                       $trans_sections{$section} = 1;
3646                       $trans_sect_vars{$varname} = 1;
3647                     }
3648
3649                   &push_dist_common ($varname)
3650                     if $pfx eq 'dist_';
3651                 }
3652             }
3653
3654           my $varname = $npfx . $pfx . 'man_MANS';
3655           my $var = var ($varname);
3656           if ($var)
3657             {
3658               foreach ($var->value_as_list_recursive)
3659                 {
3660                   # A page like `foo.1c' goes into man1dir.
3661                   if (/\.([0-9a-z])([a-z]*)$/)
3662                     {
3663                       $sections{$1} = 1;
3664                       if ($npfx eq 'notrans_')
3665                         {
3666                           $notrans_sections{$1} = 1;
3667                         }
3668                       else
3669                         {
3670                           $trans_sections{$1} = 1;
3671                         }
3672                     }
3673                 }
3674
3675               $varname = '$(' . $varname . ')';
3676               if ($npfx eq 'notrans_')
3677                 {
3678                   $notrans_vars{$varname} = 1;
3679                 }
3680               else
3681                 {
3682                   $trans_vars{$varname} = 1;
3683                 }
3684               &push_dist_common ($varname)
3685                 if $pfx eq 'dist_';
3686             }
3687         }
3688     }
3689
3690   return unless %sections;
3691
3692   my @unsorted_deps;
3693
3694   # Build section independent variables.
3695   my $have_notrans = %notrans_vars;
3696   my @notrans_list = sort keys %notrans_vars;
3697   my $have_trans = %trans_vars;
3698   my @trans_list = sort keys %trans_vars;
3699
3700   # Now for each section, generate an install and uninstall rule.
3701   # Sort sections so output is deterministic.
3702   foreach my $section (sort keys %sections)
3703     {
3704       # Build section dependent variables.
3705       my $notrans_mans = $have_notrans || exists $notrans_sections{$section};
3706       my $trans_mans = $have_trans || exists $trans_sections{$section};
3707       my (%notrans_this_sect, %trans_this_sect);
3708       my $expr = 'man' . $section . '_MANS';
3709       foreach my $varname (keys %notrans_sect_vars)
3710         {
3711           if ($varname =~ /$expr/)
3712             {
3713               $notrans_this_sect{$varname} = 1;
3714             }
3715         }
3716       foreach my $varname (keys %trans_sect_vars)
3717         {
3718           if ($varname =~ /$expr/)
3719             {
3720               $trans_this_sect{$varname} = 1;
3721             }
3722         }
3723       my @notrans_sect_list = sort keys %notrans_this_sect;
3724       my @trans_sect_list = sort keys %trans_this_sect;
3725       @unsorted_deps = (keys %notrans_vars, keys %trans_vars,
3726                         keys %notrans_this_sect, keys %trans_this_sect);
3727       my @deps = sort @unsorted_deps;
3728       $output_rules .= &file_contents ('mans',
3729                                        new Automake::Location,
3730                                        SECTION           => $section,
3731                                        DEPS              => "@deps",
3732                                        NOTRANS_MANS      => $notrans_mans,
3733                                        NOTRANS_SECT_LIST => "@notrans_sect_list",
3734                                        HAVE_NOTRANS      => $have_notrans,
3735                                        NOTRANS_LIST      => "@notrans_list",
3736                                        TRANS_MANS        => $trans_mans,
3737                                        TRANS_SECT_LIST   => "@trans_sect_list",
3738                                        HAVE_TRANS        => $have_trans,
3739                                        TRANS_LIST        => "@trans_list");
3740     }
3741
3742   @unsorted_deps  = (keys %notrans_vars, keys %trans_vars,
3743                      keys %notrans_sect_vars, keys %trans_sect_vars);
3744   my @mans = sort @unsorted_deps;
3745   $output_vars .= file_contents ('mans-vars',
3746                                  new Automake::Location,
3747                                  MANS => "@mans");
3748
3749   push (@all, '$(MANS)')
3750     unless option 'no-installman';
3751 }
3752
3753 # Handle DATA variables.
3754 sub handle_data
3755 {
3756     &am_install_var ('-noextra', '-candist', 'data', 'DATA',
3757                      'data', 'dataroot', 'doc', 'dvi', 'html', 'pdf',
3758                      'ps', 'sysconf', 'sharedstate', 'localstate',
3759                      'pkgdata', 'lisp', 'noinst', 'check');
3760 }
3761
3762 # Handle TAGS.
3763 sub handle_tags
3764 {
3765     my @tag_deps = ();
3766     my @ctag_deps = ();
3767     if (var ('SUBDIRS'))
3768     {
3769         $output_rules .= ("tags-recursive:\n"
3770                           . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
3771                           # Never fail here if a subdir fails; it
3772                           # isn't important.
3773                           . "\t  test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
3774                           . " && \$(MAKE) \$(AM_MAKEFLAGS) tags); \\\n"
3775                           . "\tdone\n");
3776         push (@tag_deps, 'tags-recursive');
3777         &depend ('.PHONY', 'tags-recursive');
3778         &depend ('.MAKE', 'tags-recursive');
3779
3780         $output_rules .= ("ctags-recursive:\n"
3781                           . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
3782                           # Never fail here if a subdir fails; it
3783                           # isn't important.
3784                           . "\t  test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
3785                           . " && \$(MAKE) \$(AM_MAKEFLAGS) ctags); \\\n"
3786                           . "\tdone\n");
3787         push (@ctag_deps, 'ctags-recursive');
3788         &depend ('.PHONY', 'ctags-recursive');
3789         &depend ('.MAKE', 'ctags-recursive');
3790     }
3791
3792     if (&saw_sources_p (1)
3793         || var ('ETAGS_ARGS')
3794         || @tag_deps)
3795     {
3796         my @config;
3797         foreach my $spec (@config_headers)
3798         {
3799             my ($out, @ins) = split_config_file_spec ($spec);
3800             foreach my $in (@ins)
3801               {
3802                 # If the config header source is in this directory,
3803                 # require it.
3804                 push @config, basename ($in)
3805                   if $relative_dir eq dirname ($in);
3806               }
3807         }
3808         $output_rules .= &file_contents ('tags',
3809                                          new Automake::Location,
3810                                          CONFIG    => "@config",
3811                                          TAGSDIRS  => "@tag_deps",
3812                                          CTAGSDIRS => "@ctag_deps");
3813
3814         set_seen 'TAGS_DEPENDENCIES';
3815     }
3816     elsif (reject_var ('TAGS_DEPENDENCIES',
3817                        "doesn't make sense to define `TAGS_DEPENDENCIES'"
3818                        . "without\nsources or `ETAGS_ARGS'"))
3819     {
3820     }
3821     else
3822     {
3823         # Every Makefile must define some sort of TAGS rule.
3824         # Otherwise, it would be possible for a top-level "make TAGS"
3825         # to fail because some subdirectory failed.
3826         $output_rules .= "tags: TAGS\nTAGS:\n\n";
3827         # Ditto ctags.
3828         $output_rules .= "ctags: CTAGS\nCTAGS:\n\n";
3829     }
3830 }
3831
3832 # Handle multilib support.
3833 sub handle_multilib
3834 {
3835   if ($seen_multilib && $relative_dir eq '.')
3836     {
3837       $output_rules .= &file_contents ('multilib', new Automake::Location);
3838       push (@all, 'all-multi');
3839     }
3840 }
3841
3842
3843 # user_phony_rule ($NAME)
3844 # -----------------------
3845 # Return false if rule $NAME does not exist.  Otherwise,
3846 # declare it as phony, complete its definition (in case it is
3847 # conditional), and return its Automake::Rule instance.
3848 sub user_phony_rule ($)
3849 {
3850   my ($name) = @_;
3851   my $rule = rule $name;
3852   if ($rule)
3853     {
3854       depend ('.PHONY', $name);
3855       # Define $NAME in all condition where it is not already defined,
3856       # so that it is always OK to depend on $NAME.
3857       for my $c ($rule->not_always_defined_in_cond (TRUE)->conds)
3858         {
3859           Automake::Rule::define ($name, 'internal', RULE_AUTOMAKE,
3860                                   $c, INTERNAL);
3861           $output_rules .= $c->subst_string . "$name:\n";
3862         }
3863     }
3864   return $rule;
3865 }
3866
3867
3868 # $BOOLEAN
3869 # &for_dist_common ($A, $B)
3870 # -------------------------
3871 # Subroutine for &handle_dist: sort files to dist.
3872 #
3873 # We put README first because it then becomes easier to make a
3874 # Usenet-compliant shar file (in these, README must be first).
3875 #
3876 # FIXME: do more ordering of files here.
3877 sub for_dist_common
3878 {
3879     return 0
3880         if $a eq $b;
3881     return -1
3882         if $a eq 'README';
3883     return 1
3884         if $b eq 'README';
3885     return $a cmp $b;
3886 }
3887
3888 # handle_dist
3889 # -----------
3890 # Handle 'dist' target.
3891 sub handle_dist ()
3892 {
3893   # Substitutions for distdir.am
3894   my %transform;
3895
3896   # Define DIST_SUBDIRS.  This must always be done, regardless of the
3897   # no-dist setting: target like `distclean' or `maintainer-clean' use it.
3898   my $subdirs = var ('SUBDIRS');
3899   if ($subdirs)
3900     {
3901       # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
3902       # to all possible directories, and use it.  If DIST_SUBDIRS is
3903       # defined, just use it.
3904
3905       # Note that we check DIST_SUBDIRS first on purpose, so that
3906       # we don't call has_conditional_contents for now reason.
3907       # (In the past one project used so many conditional subdirectories
3908       # that calling has_conditional_contents on SUBDIRS caused
3909       # automake to grow to 150Mb -- this should not happen with
3910       # the current implementation of has_conditional_contents,
3911       # but it's more efficient to avoid the call anyway.)
3912       if (var ('DIST_SUBDIRS'))
3913         {
3914         }
3915       elsif ($subdirs->has_conditional_contents)
3916         {
3917           define_pretty_variable
3918             ('DIST_SUBDIRS', TRUE, INTERNAL,
3919              uniq ($subdirs->value_as_list_recursive));
3920         }
3921       else
3922         {
3923           # We always define this because that is what `distclean'
3924           # wants.
3925           define_pretty_variable ('DIST_SUBDIRS', TRUE, INTERNAL,
3926                                   '$(SUBDIRS)');
3927         }
3928     }
3929
3930   # The remaining definitions are only required when a dist target is used.
3931   return if option 'no-dist';
3932
3933   # At least one of the archive formats must be enabled.
3934   if ($relative_dir eq '.')
3935     {
3936       my $archive_defined = option 'no-dist-gzip' ? 0 : 1;
3937       $archive_defined ||=
3938         grep { option "dist-$_" } qw(shar zip tarZ bzip2 lzma xz);
3939       error (option 'no-dist-gzip',
3940              "no-dist-gzip specified but no dist-* specified, "
3941              . "at least one archive format must be enabled")
3942         unless $archive_defined;
3943     }
3944
3945   # Look for common files that should be included in distribution.
3946   # If the aux dir is set, and it does not have a Makefile.am, then
3947   # we check for these files there as well.
3948   my $check_aux = 0;
3949   if ($relative_dir eq '.'
3950       && $config_aux_dir_set_in_configure_ac)
3951     {
3952       if (! &is_make_dir ($config_aux_dir))
3953         {
3954           $check_aux = 1;
3955         }
3956     }
3957   foreach my $cfile (@common_files)
3958     {
3959       if (dir_has_case_matching_file ($relative_dir, $cfile)
3960           # The file might be absent, but if it can be built it's ok.
3961           || rule $cfile)
3962         {
3963           &push_dist_common ($cfile);
3964         }
3965
3966       # Don't use `elsif' here because a file might meaningfully
3967       # appear in both directories.
3968       if ($check_aux && dir_has_case_matching_file ($config_aux_dir, $cfile))
3969         {
3970           &push_dist_common ("$config_aux_dir/$cfile")
3971         }
3972     }
3973
3974   # We might copy elements from $configure_dist_common to
3975   # %dist_common if we think we need to.  If the file appears in our
3976   # directory, we would have discovered it already, so we don't
3977   # check that.  But if the file is in a subdir without a Makefile,
3978   # we want to distribute it here if we are doing `.'.  Ugly!
3979   if ($relative_dir eq '.')
3980     {
3981       foreach my $file (split (' ' , $configure_dist_common))
3982         {
3983           push_dist_common ($file)
3984             unless is_make_dir (dirname ($file));
3985         }
3986     }
3987
3988   # Files to distributed.  Don't use ->value_as_list_recursive
3989   # as it recursively expands `$(dist_pkgdata_DATA)' etc.
3990   my @dist_common = split (' ', rvar ('DIST_COMMON')->variable_value);
3991   @dist_common = uniq (sort for_dist_common (@dist_common));
3992   variable_delete 'DIST_COMMON';
3993   define_pretty_variable ('DIST_COMMON', TRUE, INTERNAL, @dist_common);
3994
3995   # Now that we've processed DIST_COMMON, disallow further attempts
3996   # to set it.
3997   $handle_dist_run = 1;
3998
3999   # Scan EXTRA_DIST to see if we need to distribute anything from a
4000   # subdir.  If so, add it to the list.  I didn't want to do this
4001   # originally, but there were so many requests that I finally
4002   # relented.
4003   my $extra_dist = var ('EXTRA_DIST');
4004
4005   $transform{'DISTCHECK-HOOK'} = !! rule 'distcheck-hook';
4006   $transform{'GETTEXT'} = $seen_gettext && !$seen_gettext_external;
4007
4008   # If the target `dist-hook' exists, make sure it is run.  This
4009   # allows users to do random weird things to the distribution
4010   # before it is packaged up.
4011   push (@dist_targets, 'dist-hook')
4012     if user_phony_rule 'dist-hook';
4013   $transform{'DIST-TARGETS'} = join (' ', @dist_targets);
4014
4015   my $flm = option ('filename-length-max');
4016   my $filename_filter = $flm ? '.' x $flm->[1] : '';
4017
4018   $output_rules .= &file_contents ('distdir',
4019                                    new Automake::Location,
4020                                    %transform,
4021                                    FILENAME_FILTER => $filename_filter);
4022 }
4023
4024
4025 # check_directory ($NAME, $WHERE)
4026 # -------------------------------
4027 # Ensure $NAME is a directory, and that it uses a sane name.
4028 # Use $WHERE as a location in the diagnostic, if any.
4029 sub check_directory ($$)
4030 {
4031   my ($dir, $where) = @_;
4032
4033   error $where, "required directory $relative_dir/$dir does not exist"
4034     unless -d "$relative_dir/$dir";
4035
4036   # If an `obj/' directory exists, BSD make will enter it before
4037   # reading `Makefile'.  Hence the `Makefile' in the current directory
4038   # will not be read.
4039   #
4040   #  % cat Makefile
4041   #  all:
4042   #          echo Hello
4043   #  % cat obj/Makefile
4044   #  all:
4045   #          echo World
4046   #  % make      # GNU make
4047   #  echo Hello
4048   #  Hello
4049   #  % pmake     # BSD make
4050   #  echo World
4051   #  World
4052   msg ('portability', $where,
4053        "naming a subdirectory `obj' causes troubles with BSD make")
4054     if $dir eq 'obj';
4055
4056   # `aux' is probably the most important of the following forbidden name,
4057   # since it's tempting to use it as an AC_CONFIG_AUX_DIR.
4058   msg ('portability', $where,
4059        "name `$dir' is reserved on W32 and DOS platforms")
4060     if grep (/^\Q$dir\E$/i, qw/aux lpt1 lpt2 lpt3 com1 com2 com3 com4 con prn/);
4061 }
4062
4063 # check_directories_in_var ($VARIABLE)
4064 # ------------------------------------
4065 # Recursively check all items in variables $VARIABLE as directories
4066 sub check_directories_in_var ($)
4067 {
4068   my ($var) = @_;
4069   $var->traverse_recursively
4070     (sub
4071      {
4072        my ($var, $val, $cond, $full_cond) = @_;
4073        check_directory ($val, $var->rdef ($cond)->location);
4074        return ();
4075      },
4076      undef,
4077      skip_ac_subst => 1);
4078 }
4079
4080 # &handle_subdirs ()
4081 # ------------------
4082 # Handle subdirectories.
4083 sub handle_subdirs ()
4084 {
4085   my $subdirs = var ('SUBDIRS');
4086   return
4087     unless $subdirs;
4088
4089   check_directories_in_var $subdirs;
4090
4091   my $dsubdirs = var ('DIST_SUBDIRS');
4092   check_directories_in_var $dsubdirs
4093     if $dsubdirs;
4094
4095   $output_rules .= &file_contents ('subdirs', new Automake::Location);
4096   rvar ('RECURSIVE_TARGETS')->rdef (TRUE)->{'pretty'} = VAR_SORTED; # Gross!
4097 }
4098
4099
4100 # ($REGEN, @DEPENDENCIES)
4101 # &scan_aclocal_m4
4102 # ----------------
4103 # If aclocal.m4 creation is automated, return the list of its dependencies.
4104 sub scan_aclocal_m4 ()
4105 {
4106   my $regen_aclocal = 0;
4107
4108   set_seen 'CONFIG_STATUS_DEPENDENCIES';
4109   set_seen 'CONFIGURE_DEPENDENCIES';
4110
4111   if (-f 'aclocal.m4')
4112     {
4113       &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4', INTERNAL);
4114
4115       my $aclocal = new Automake::XFile "< aclocal.m4";
4116       my $line = $aclocal->getline;
4117       $regen_aclocal = $line =~ 'generated automatically by aclocal';
4118     }
4119
4120   my @ac_deps = ();
4121
4122   if (set_seen ('ACLOCAL_M4_SOURCES'))
4123     {
4124       push (@ac_deps, '$(ACLOCAL_M4_SOURCES)');
4125       msg_var ('obsolete', 'ACLOCAL_M4_SOURCES',
4126                "`ACLOCAL_M4_SOURCES' is obsolete.\n"
4127                . "It should be safe to simply remove it.");
4128     }
4129
4130   # Note that it might be possible that aclocal.m4 doesn't exist but
4131   # should be auto-generated.  This case probably isn't very
4132   # important.
4133
4134   return ($regen_aclocal, @ac_deps);
4135 }
4136
4137
4138 # Helper function for substitute_ac_subst_variables.
4139 sub substitute_ac_subst_variables_worker($)
4140 {
4141   my ($token) = @_;
4142   return "\@$token\@" if var $token;
4143   return "\${$token\}";
4144 }
4145
4146 # substitute_ac_subst_variables ($TEXT)
4147 # -------------------------------------
4148 # Replace any occurrence of ${FOO} in $TEXT by @FOO@ if FOO is an AC_SUBST
4149 # variable.
4150 sub substitute_ac_subst_variables ($)
4151 {
4152   my ($text) = @_;
4153   $text =~ s/\${([^ \t=:+{}]+)}/&substitute_ac_subst_variables_worker ($1)/ge;
4154   return $text;
4155 }
4156
4157 # @DEPENDENCIES
4158 # &prepend_srcdir (@INPUTS)
4159 # -------------------------
4160 # Prepend $(srcdir) or $(top_srcdir) to all @INPUTS.  The idea is that
4161 # if an input file has a directory part the same as the current
4162 # directory, then the directory part is simply replaced by $(srcdir).
4163 # But if the directory part is different, then $(top_srcdir) is
4164 # prepended.
4165 sub prepend_srcdir (@)
4166 {
4167   my (@inputs) = @_;
4168   my @newinputs;
4169
4170   foreach my $single (@inputs)
4171     {
4172       if (dirname ($single) eq $relative_dir)
4173         {
4174           push (@newinputs, '$(srcdir)/' . basename ($single));
4175         }
4176       else
4177         {
4178           push (@newinputs, '$(top_srcdir)/' . $single);
4179         }
4180     }
4181   return @newinputs;
4182 }
4183
4184 # @DEPENDENCIES
4185 # rewrite_inputs_into_dependencies ($OUTPUT, @INPUTS)
4186 # ---------------------------------------------------
4187 # Compute a list of dependencies appropriate for the rebuild
4188 # rule of
4189 #   AC_CONFIG_FILES($OUTPUT:$INPUT[0]:$INPUTS[1]:...)
4190 # Also distribute $INPUTs which are not built by another AC_CONFIG_FOOs.
4191 sub rewrite_inputs_into_dependencies ($@)
4192 {
4193   my ($file, @inputs) = @_;
4194   my @res = ();
4195
4196   for my $i (@inputs)
4197     {
4198       # We cannot create dependencies on shell variables.
4199       next if (substitute_ac_subst_variables $i) =~ /\$/;
4200
4201       if (exists $ac_config_files_location{$i} && $i ne $file)
4202         {
4203           my $di = dirname $i;
4204           if ($di eq $relative_dir)
4205             {
4206               $i = basename $i;
4207             }
4208           # In the top-level Makefile we do not use $(top_builddir), because
4209           # we are already there, and since the targets are built without
4210           # a $(top_builddir), it helps BSD Make to match them with
4211           # dependencies.
4212           elsif ($relative_dir ne '.')
4213             {
4214               $i = '$(top_builddir)/' . $i;
4215             }
4216         }
4217       else
4218         {
4219           msg ('error', $ac_config_files_location{$file},
4220                "required file `$i' not found")
4221             unless $i =~ /\$/ || exists $output_files{$i} || -f $i;
4222           ($i) = prepend_srcdir ($i);
4223           push_dist_common ($i);
4224         }
4225       push @res, $i;
4226     }
4227   return @res;
4228 }
4229
4230
4231
4232 # &handle_configure ($MAKEFILE_AM, $MAKEFILE_IN, $MAKEFILE, @INPUTS)
4233 # ------------------------------------------------------------------
4234 # Handle remaking and configure stuff.
4235 # We need the name of the input file, to do proper remaking rules.
4236 sub handle_configure ($$$@)
4237 {
4238   my ($makefile_am, $makefile_in, $makefile, @inputs) = @_;
4239
4240   prog_error 'empty @inputs'
4241     unless @inputs;
4242
4243   my ($rel_makefile_am, $rel_makefile_in) = prepend_srcdir ($makefile_am,
4244                                                             $makefile_in);
4245   my $rel_makefile = basename $makefile;
4246
4247   my $colon_infile = ':' . join (':', @inputs);
4248   $colon_infile = '' if $colon_infile eq ":$makefile.in";
4249   my @rewritten = rewrite_inputs_into_dependencies ($makefile, @inputs);
4250   my ($regen_aclocal_m4, @aclocal_m4_deps) = scan_aclocal_m4;
4251   define_pretty_variable ('am__aclocal_m4_deps', TRUE, INTERNAL,
4252                           @configure_deps, @aclocal_m4_deps,
4253                           '$(top_srcdir)/' . $configure_ac);
4254   my @configuredeps = ('$(am__aclocal_m4_deps)', '$(CONFIGURE_DEPENDENCIES)');
4255   push @configuredeps, '$(ACLOCAL_M4)' if -f 'aclocal.m4';
4256   define_pretty_variable ('am__configure_deps', TRUE, INTERNAL,
4257                           @configuredeps);
4258
4259   my $automake_options = '--' . (global_option 'cygnus' ? 'cygnus' : $strictness_name)
4260                          . (global_option 'no-dependencies' ? ' --ignore-deps' : '');
4261
4262   $output_rules .= file_contents
4263     ('configure',
4264      new Automake::Location,
4265      MAKEFILE              => $rel_makefile,
4266      'MAKEFILE-DEPS'       => "@rewritten",
4267      'CONFIG-MAKEFILE'     => ($relative_dir eq '.') ? '$@' : '$(subdir)/$@',
4268      'MAKEFILE-IN'         => $rel_makefile_in,
4269      'MAKEFILE-IN-DEPS'    => "@include_stack",
4270      'MAKEFILE-AM'         => $rel_makefile_am,
4271      'AUTOMAKE-OPTIONS'    => $automake_options,
4272      'MAKEFILE-AM-SOURCES' => "$makefile$colon_infile",
4273      'REGEN-ACLOCAL-M4'    => $regen_aclocal_m4,
4274      VERBOSE               => verbose_flag ('GEN'));
4275
4276   if ($relative_dir eq '.')
4277     {
4278       &push_dist_common ('acconfig.h')
4279         if -f 'acconfig.h';
4280     }
4281
4282   # If we have a configure header, require it.
4283   my $hdr_index = 0;
4284   my @distclean_config;
4285   foreach my $spec (@config_headers)
4286     {
4287       $hdr_index += 1;
4288       # $CONFIG_H_PATH: config.h from top level.
4289       my ($config_h_path, @ins) = split_config_file_spec ($spec);
4290       my $config_h_dir = dirname ($config_h_path);
4291
4292       # If the header is in the current directory we want to build
4293       # the header here.  Otherwise, if we're at the topmost
4294       # directory and the header's directory doesn't have a
4295       # Makefile, then we also want to build the header.
4296       if ($relative_dir eq $config_h_dir
4297           || ($relative_dir eq '.' && ! &is_make_dir ($config_h_dir)))
4298         {
4299           my ($cn_sans_dir, $stamp_dir);
4300           if ($relative_dir eq $config_h_dir)
4301             {
4302               $cn_sans_dir = basename ($config_h_path);
4303               $stamp_dir = '';
4304             }
4305           else
4306             {
4307               $cn_sans_dir = $config_h_path;
4308               if ($config_h_dir eq '.')
4309                 {
4310                   $stamp_dir = '';
4311                 }
4312               else
4313                 {
4314                   $stamp_dir = $config_h_dir . '/';
4315                 }
4316             }
4317
4318           # This will also distribute all inputs.
4319           @ins = rewrite_inputs_into_dependencies ($config_h_path, @ins);
4320
4321           # Cannot define rebuild rules for filenames with shell variables.
4322           next if (substitute_ac_subst_variables $config_h_path) =~ /\$/;
4323
4324           # Header defined in this directory.
4325           my @files;
4326           if (-f $config_h_path . '.top')
4327             {
4328               push (@files, "$cn_sans_dir.top");
4329             }
4330           if (-f $config_h_path . '.bot')
4331             {
4332               push (@files, "$cn_sans_dir.bot");
4333             }
4334
4335           push_dist_common (@files);
4336
4337           # For now, acconfig.h can only appear in the top srcdir.
4338           if (-f 'acconfig.h')
4339             {
4340               push (@files, '$(top_srcdir)/acconfig.h');
4341             }
4342
4343           my $stamp = "${stamp_dir}stamp-h${hdr_index}";
4344           $output_rules .=
4345             file_contents ('remake-hdr',
4346                            new Automake::Location,
4347                            FILES            => "@files",
4348                            CONFIG_H         => $cn_sans_dir,
4349                            CONFIG_HIN       => $ins[0],
4350                            CONFIG_H_DEPS    => "@ins",
4351                            CONFIG_H_PATH    => $config_h_path,
4352                            STAMP            => "$stamp");
4353
4354           push @distclean_config, $cn_sans_dir, $stamp;
4355         }
4356     }
4357
4358   $output_rules .= file_contents ('clean-hdr',
4359                                   new Automake::Location,
4360                                   FILES => "@distclean_config")
4361     if @distclean_config;
4362
4363   # Distribute and define mkinstalldirs only if it is already present
4364   # in the package, for backward compatibility (some people may still
4365   # use $(mkinstalldirs)).
4366   my $mkidpath = "$config_aux_dir/mkinstalldirs";
4367   if (-f $mkidpath)
4368     {
4369       # Use require_file so that any existing script gets updated
4370       # by --force-missing.
4371       require_conf_file ($mkidpath, FOREIGN, 'mkinstalldirs');
4372       define_variable ('mkinstalldirs',
4373                        "\$(SHELL) $am_config_aux_dir/mkinstalldirs", INTERNAL);
4374     }
4375   else
4376     {
4377       # Use $(install_sh), not $(MKDIR_P) because the latter requires
4378       # at least one argument, and $(mkinstalldirs) used to work
4379       # even without arguments (e.g. $(mkinstalldirs) $(conditional_dir)).
4380       define_variable ('mkinstalldirs', '$(install_sh) -d', INTERNAL);
4381     }
4382
4383   reject_var ('CONFIG_HEADER',
4384               "`CONFIG_HEADER' is an anachronism; now determined "
4385               . "automatically\nfrom `$configure_ac'");
4386
4387   my @config_h;
4388   foreach my $spec (@config_headers)
4389     {
4390       my ($out, @ins) = split_config_file_spec ($spec);
4391       # Generate CONFIG_HEADER define.
4392       if ($relative_dir eq dirname ($out))
4393         {
4394           push @config_h, basename ($out);
4395         }
4396       else
4397         {
4398           push @config_h, "\$(top_builddir)/$out";
4399         }
4400     }
4401   define_variable ("CONFIG_HEADER", "@config_h", INTERNAL)
4402     if @config_h;
4403
4404   # Now look for other files in this directory which must be remade
4405   # by config.status, and generate rules for them.
4406   my @actual_other_files = ();
4407   # These get cleaned only in a VPATH build.
4408   my @actual_other_vpath_files = ();
4409   foreach my $lfile (@other_input_files)
4410     {
4411       my $file;
4412       my @inputs;
4413       if ($lfile =~ /^([^:]*):(.*)$/)
4414         {
4415           # This is the ":" syntax of AC_OUTPUT.
4416           $file = $1;
4417           @inputs = split (':', $2);
4418         }
4419       else
4420         {
4421           # Normal usage.
4422           $file = $lfile;
4423           @inputs = $file . '.in';
4424         }
4425
4426       # Automake files should not be stored in here, but in %MAKE_LIST.
4427       prog_error ("$lfile in \@other_input_files\n"
4428                   . "\@other_input_files = (@other_input_files)")
4429         if -f $file . '.am';
4430
4431       my $local = basename ($file);
4432
4433       # We skip files that aren't in this directory.  However, if
4434       # the file's directory does not have a Makefile, and we are
4435       # currently doing `.', then we create a rule to rebuild the
4436       # file in the subdir.
4437       my $fd = dirname ($file);
4438       if ($fd ne $relative_dir)
4439         {
4440           if ($relative_dir eq '.' && ! &is_make_dir ($fd))
4441             {
4442               $local = $file;
4443             }
4444           else
4445             {
4446               next;
4447             }
4448         }
4449
4450       my @rewritten_inputs = rewrite_inputs_into_dependencies ($file, @inputs);
4451
4452       # Cannot output rules for shell variables.
4453       next if (substitute_ac_subst_variables $local) =~ /\$/;
4454
4455       my $condstr = '';
4456       my $cond = $ac_config_files_condition{$lfile};
4457       if (defined $cond)
4458         {
4459           $condstr = $cond->subst_string;
4460           Automake::Rule::define ($local, $configure_ac, RULE_AUTOMAKE, $cond,
4461                                   $ac_config_files_location{$file});
4462         }
4463       $output_rules .= ($condstr . $local . ': '
4464                         . '$(top_builddir)/config.status '
4465                         . "@rewritten_inputs\n"
4466                         . $condstr . "\t"
4467                         . 'cd $(top_builddir) && '
4468                         . '$(SHELL) ./config.status '
4469                         . ($relative_dir eq '.' ? '' : '$(subdir)/')
4470                         . '$@'
4471                         . "\n");
4472       push (@actual_other_files, $local);
4473     }
4474
4475   # For links we should clean destinations and distribute sources.
4476   foreach my $spec (@config_links)
4477     {
4478       my ($link, $file) = split /:/, $spec;
4479       # Some people do AC_CONFIG_LINKS($computed).  We only handle
4480       # the DEST:SRC form.
4481       next unless $file;
4482       my $where = $ac_config_files_location{$link};
4483
4484       # Skip destinations that contain shell variables.
4485       if ((substitute_ac_subst_variables $link) !~ /\$/)
4486         {
4487           # We skip links that aren't in this directory.  However, if
4488           # the link's directory does not have a Makefile, and we are
4489           # currently doing `.', then we add the link to CONFIG_CLEAN_FILES
4490           # in `.'s Makefile.in.
4491           my $local = basename ($link);
4492           my $fd = dirname ($link);
4493           if ($fd ne $relative_dir)
4494             {
4495               if ($relative_dir eq '.' && ! &is_make_dir ($fd))
4496                 {
4497                   $local = $link;
4498                 }
4499               else
4500                 {
4501                   $local = undef;
4502                 }
4503             }
4504           if ($file ne $link)
4505             {
4506               push @actual_other_files, $local if $local;
4507             }
4508           else
4509             {
4510               push @actual_other_vpath_files, $local if $local;
4511             }
4512         }
4513
4514       # Do not process sources that contain shell variables.
4515       if ((substitute_ac_subst_variables $file) !~ /\$/)
4516         {
4517           my $fd = dirname ($file);
4518
4519           # We distribute files that are in this directory.
4520           # At the top-level (`.') we also distribute files whose
4521           # directory does not have a Makefile.
4522           if (($fd eq $relative_dir)
4523               || ($relative_dir eq '.' && ! &is_make_dir ($fd)))
4524             {
4525               # The following will distribute $file as a side-effect when
4526               # it is appropriate (i.e., when $file is not already an output).
4527               # We do not need the result, just the side-effect.
4528               rewrite_inputs_into_dependencies ($link, $file);
4529             }
4530         }
4531     }
4532
4533   # These files get removed by "make distclean".
4534   define_pretty_variable ('CONFIG_CLEAN_FILES', TRUE, INTERNAL,
4535                           @actual_other_files);
4536   define_pretty_variable ('CONFIG_CLEAN_VPATH_FILES', TRUE, INTERNAL,
4537                           @actual_other_vpath_files);
4538 }
4539
4540 # Handle C headers.
4541 sub handle_headers
4542 {
4543     my @r = &am_install_var ('-defaultdist', 'header', 'HEADERS', 'include',
4544                              'oldinclude', 'pkginclude',
4545                              'noinst', 'check');
4546     foreach (@r)
4547     {
4548       next unless $_->[1] =~ /\..*$/;
4549       &saw_extension ($&);
4550     }
4551 }
4552
4553 sub handle_gettext
4554 {
4555   return if ! $seen_gettext || $relative_dir ne '.';
4556
4557   my $subdirs = var 'SUBDIRS';
4558
4559   if (! $subdirs)
4560     {
4561       err_ac "AM_GNU_GETTEXT used but SUBDIRS not defined";
4562       return;
4563     }
4564
4565   # Perform some sanity checks to help users get the right setup.
4566   # We disable these tests when po/ doesn't exist in order not to disallow
4567   # unusual gettext setups.
4568   #
4569   # Bruno Haible:
4570   # | The idea is:
4571   # |
4572   # |  1) If a package doesn't have a directory po/ at top level, it
4573   # |     will likely have multiple po/ directories in subpackages.
4574   # |
4575   # |  2) It is useful to warn for the absence of intl/ if AM_GNU_GETTEXT
4576   # |     is used without 'external'. It is also useful to warn for the
4577   # |     presence of intl/ if AM_GNU_GETTEXT([external]) is used. Both
4578   # |     warnings apply only to the usual layout of packages, therefore
4579   # |     they should both be disabled if no po/ directory is found at
4580   # |     top level.
4581
4582   if (-d 'po')
4583     {
4584       my @subdirs = $subdirs->value_as_list_recursive;
4585
4586       msg_var ('syntax', $subdirs,
4587                "AM_GNU_GETTEXT used but `po' not in SUBDIRS")
4588         if ! grep ($_ eq 'po', @subdirs);
4589
4590       # intl/ is not required when AM_GNU_GETTEXT is called with the
4591       # `external' option and AM_GNU_GETTEXT_INTL_SUBDIR is not called.
4592       msg_var ('syntax', $subdirs,
4593                "AM_GNU_GETTEXT used but `intl' not in SUBDIRS")
4594         if (! ($seen_gettext_external && ! $seen_gettext_intl)
4595             && ! grep ($_ eq 'intl', @subdirs));
4596
4597       # intl/ should not be used with AM_GNU_GETTEXT([external]), except
4598       # if AM_GNU_GETTEXT_INTL_SUBDIR is called.
4599       msg_var ('syntax', $subdirs,
4600                "`intl' should not be in SUBDIRS when "
4601                . "AM_GNU_GETTEXT([external]) is used")
4602         if ($seen_gettext_external && ! $seen_gettext_intl
4603             && grep ($_ eq 'intl', @subdirs));
4604     }
4605
4606   require_file ($ac_gettext_location, GNU, 'ABOUT-NLS');
4607 }
4608
4609 # Handle footer elements.
4610 sub handle_footer
4611 {
4612     reject_rule ('.SUFFIXES',
4613                  "use variable `SUFFIXES', not target `.SUFFIXES'");
4614
4615     # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
4616     # before .SUFFIXES.  So we make sure that .SUFFIXES appears before
4617     # anything else, by sticking it right after the default: target.
4618     $output_header .= ".SUFFIXES:\n";
4619     my $suffixes = var 'SUFFIXES';
4620     my @suffixes = Automake::Rule::suffixes;
4621     if (@suffixes || $suffixes)
4622     {
4623         # Make sure SUFFIXES has unique elements.  Sort them to ensure
4624         # the output remains consistent.  However, $(SUFFIXES) is
4625         # always at the start of the list, unsorted.  This is done
4626         # because make will choose rules depending on the ordering of
4627         # suffixes, and this lets the user have some control.  Push
4628         # actual suffixes, and not $(SUFFIXES).  Some versions of make
4629         # do not like variable substitutions on the .SUFFIXES line.
4630         my @user_suffixes = ($suffixes
4631                              ? $suffixes->value_as_list_recursive : ());
4632
4633         my %suffixes = map { $_ => 1 } @suffixes;
4634         delete @suffixes{@user_suffixes};
4635
4636         $output_header .= (".SUFFIXES: "
4637                            . join (' ', @user_suffixes, sort keys %suffixes)
4638                            . "\n");
4639     }
4640
4641     $output_trailer .= file_contents ('footer', new Automake::Location);
4642 }
4643
4644
4645 # Generate `make install' rules.
4646 sub handle_install ()
4647 {
4648   $output_rules .= &file_contents
4649     ('install',
4650      new Automake::Location,
4651      maybe_BUILT_SOURCES => (set_seen ('BUILT_SOURCES')
4652                              ? (" \$(BUILT_SOURCES)\n"
4653                                 . "\t\$(MAKE) \$(AM_MAKEFLAGS)")
4654                              : ''),
4655      'installdirs-local' => (user_phony_rule 'installdirs-local'
4656                              ? ' installdirs-local' : ''),
4657      am__installdirs => variable_value ('am__installdirs') || '');
4658 }
4659
4660
4661 # Deal with all and all-am.
4662 sub handle_all ($)
4663 {
4664     my ($makefile) = @_;
4665
4666     # Output `all-am'.
4667
4668     # Put this at the beginning for the sake of non-GNU makes.  This
4669     # is still wrong if these makes can run parallel jobs.  But it is
4670     # right enough.
4671     unshift (@all, basename ($makefile));
4672
4673     foreach my $spec (@config_headers)
4674       {
4675         my ($out, @ins) = split_config_file_spec ($spec);
4676         push (@all, basename ($out))
4677           if dirname ($out) eq $relative_dir;
4678       }
4679
4680     # Install `all' hooks.
4681     push (@all, "all-local")
4682       if user_phony_rule "all-local";
4683
4684     &pretty_print_rule ("all-am:", "\t\t", @all);
4685     &depend ('.PHONY', 'all-am', 'all');
4686
4687
4688     # Output `all'.
4689
4690     my @local_headers = ();
4691     push @local_headers, '$(BUILT_SOURCES)'
4692       if var ('BUILT_SOURCES');
4693     foreach my $spec (@config_headers)
4694       {
4695         my ($out, @ins) = split_config_file_spec ($spec);
4696         push @local_headers, basename ($out)
4697           if dirname ($out) eq $relative_dir;
4698       }
4699
4700     if (@local_headers)
4701       {
4702         # We need to make sure config.h is built before we recurse.
4703         # We also want to make sure that built sources are built
4704         # before any ordinary `all' targets are run.  We can't do this
4705         # by changing the order of dependencies to the "all" because
4706         # that breaks when using parallel makes.  Instead we handle
4707         # things explicitly.
4708         $output_all .= ("all: @local_headers"
4709                         . "\n\t"
4710                         . '$(MAKE) $(AM_MAKEFLAGS) '
4711                         . (var ('SUBDIRS') ? 'all-recursive' : 'all-am')
4712                         . "\n\n");
4713         depend ('.MAKE', 'all');
4714       }
4715     else
4716       {
4717         $output_all .= "all: " . (var ('SUBDIRS')
4718                                   ? 'all-recursive' : 'all-am') . "\n\n";
4719       }
4720 }
4721
4722
4723 # &do_check_merge_target ()
4724 # -------------------------
4725 # Handle check merge target specially.
4726 sub do_check_merge_target ()
4727 {
4728   # Include user-defined local form of target.
4729   push @check_tests, 'check-local'
4730     if user_phony_rule 'check-local';
4731
4732   # In --cygnus mode, check doesn't depend on all.
4733   if (option 'cygnus')
4734     {
4735       # Just run the local check rules.
4736       pretty_print_rule ('check-am:', "\t\t", @check);
4737     }
4738   else
4739     {
4740       # The check target must depend on the local equivalent of
4741       # `all', to ensure all the primary targets are built.  Then it
4742       # must build the local check rules.
4743       $output_rules .= "check-am: all-am\n";
4744       if (@check)
4745         {
4746           pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ",
4747                              @check);
4748           depend ('.MAKE', 'check-am');
4749         }
4750     }
4751   if (@check_tests)
4752     {
4753       pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ",
4754                          @check_tests);
4755       depend ('.MAKE', 'check-am');
4756     }
4757
4758   depend '.PHONY', 'check', 'check-am';
4759   # Handle recursion.  We have to honor BUILT_SOURCES like for `all:'.
4760   $output_rules .= ("check: "
4761                     . (var ('BUILT_SOURCES')
4762                        ? "\$(BUILT_SOURCES)\n\t\$(MAKE) \$(AM_MAKEFLAGS) "
4763                        : '')
4764                     . (var ('SUBDIRS') ? 'check-recursive' : 'check-am')
4765                     . "\n");
4766   depend ('.MAKE', 'check')
4767     if var ('BUILT_SOURCES');
4768 }
4769
4770 # handle_clean ($MAKEFILE)
4771 # ------------------------
4772 # Handle all 'clean' targets.
4773 sub handle_clean ($)
4774 {
4775   my ($makefile) = @_;
4776
4777   # Clean the files listed in user variables if they exist.
4778   $clean_files{'$(MOSTLYCLEANFILES)'} = MOSTLY_CLEAN
4779     if var ('MOSTLYCLEANFILES');
4780   $clean_files{'$(CLEANFILES)'} = CLEAN
4781     if var ('CLEANFILES');
4782   $clean_files{'$(DISTCLEANFILES)'} = DIST_CLEAN
4783     if var ('DISTCLEANFILES');
4784   $clean_files{'$(MAINTAINERCLEANFILES)'} = MAINTAINER_CLEAN
4785     if var ('MAINTAINERCLEANFILES');
4786
4787   # Built sources are automatically removed by maintainer-clean.
4788   $clean_files{'$(BUILT_SOURCES)'} = MAINTAINER_CLEAN
4789     if var ('BUILT_SOURCES');
4790
4791   # Compute a list of "rm"s to run for each target.
4792   my %rms = (MOSTLY_CLEAN, [],
4793              CLEAN, [],
4794              DIST_CLEAN, [],
4795              MAINTAINER_CLEAN, []);
4796
4797   foreach my $file (keys %clean_files)
4798     {
4799       my $when = $clean_files{$file};
4800       prog_error 'invalid entry in %clean_files'
4801         unless exists $rms{$when};
4802
4803       my $rm = "rm -f $file";
4804       # If file is a variable, make sure when don't call `rm -f' without args.
4805       $rm ="test -z \"$file\" || $rm"
4806         if ($file =~ /^\s*\$(\(.*\)|\{.*\})\s*$/);
4807
4808       push @{$rms{$when}}, "\t-$rm\n";
4809     }
4810
4811   $output_rules .= &file_contents
4812     ('clean',
4813      new Automake::Location,
4814      MOSTLYCLEAN_RMS      => join ('', sort @{$rms{&MOSTLY_CLEAN}}),
4815      CLEAN_RMS            => join ('', sort @{$rms{&CLEAN}}),
4816      DISTCLEAN_RMS        => join ('', sort @{$rms{&DIST_CLEAN}}),
4817      MAINTAINER_CLEAN_RMS => join ('', sort @{$rms{&MAINTAINER_CLEAN}}),
4818      MAKEFILE             => basename $makefile,
4819      );
4820 }
4821
4822
4823 # &target_cmp ($A, $B)
4824 # --------------------
4825 # Subroutine for &handle_factored_dependencies to let `.PHONY' and
4826 # other `.TARGETS' be last.
4827 sub target_cmp
4828 {
4829   return 0 if $a eq $b;
4830
4831   my $a1 = substr ($a, 0, 1);
4832   my $b1 = substr ($b, 0, 1);
4833   if ($a1 ne $b1)
4834     {
4835       return -1 if $b1 eq '.';
4836       return 1 if $a1 eq '.';
4837     }
4838   return $a cmp $b;
4839 }
4840
4841
4842 # &handle_factored_dependencies ()
4843 # --------------------------------
4844 # Handle everything related to gathered targets.
4845 sub handle_factored_dependencies
4846 {
4847   # Reject bad hooks.
4848   foreach my $utarg ('uninstall-data-local', 'uninstall-data-hook',
4849                      'uninstall-exec-local', 'uninstall-exec-hook',
4850                      'uninstall-dvi-local',
4851                      'uninstall-html-local',
4852                      'uninstall-info-local',
4853                      'uninstall-pdf-local',
4854                      'uninstall-ps-local')
4855     {
4856       my $x = $utarg;
4857       $x =~ s/-.*-/-/;
4858       reject_rule ($utarg, "use `$x', not `$utarg'");
4859     }
4860
4861   reject_rule ('install-local',
4862                "use `install-data-local' or `install-exec-local', "
4863                . "not `install-local'");
4864
4865   reject_rule ('install-hook',
4866                "use `install-data-hook' or `install-exec-hook', "
4867                . "not `install-hook'");
4868
4869   # Install the -local hooks.
4870   foreach (keys %dependencies)
4871     {
4872       # Hooks are installed on the -am targets.
4873       s/-am$// or next;
4874       depend ("$_-am", "$_-local")
4875         if user_phony_rule "$_-local";
4876     }
4877
4878   # Install the -hook hooks.
4879   # FIXME: Why not be as liberal as we are with -local hooks?
4880   foreach ('install-exec', 'install-data', 'uninstall')
4881     {
4882       if (user_phony_rule "$_-hook")
4883         {
4884           depend ('.MAKE', "$_-am");
4885           register_action("$_-am",
4886                           ("\t\@\$(NORMAL_INSTALL)\n"
4887                            . "\t\$(MAKE) \$(AM_MAKEFLAGS) $_-hook"));
4888         }
4889     }
4890
4891   # All the required targets are phony.
4892   depend ('.PHONY', keys %required_targets);
4893
4894   # Actually output gathered targets.
4895   foreach (sort target_cmp keys %dependencies)
4896     {
4897       # If there is nothing about this guy, skip it.
4898       next
4899         unless (@{$dependencies{$_}}
4900                 || $actions{$_}
4901                 || $required_targets{$_});
4902
4903       # Define gathered targets in undefined conditions.
4904       # FIXME: Right now we must handle .PHONY as an exception,
4905       # because people write things like
4906       #    .PHONY: myphonytarget
4907       # to append dependencies.  This would not work if Automake
4908       # refrained from defining its own .PHONY target as it does
4909       # with other overridden targets.
4910       # Likewise for `.MAKE'.
4911       my @undefined_conds = (TRUE,);
4912       if ($_ ne '.PHONY' && $_ ne '.MAKE')
4913         {
4914           @undefined_conds =
4915             Automake::Rule::define ($_, 'internal',
4916                                     RULE_AUTOMAKE, TRUE, INTERNAL);
4917         }
4918       my @uniq_deps = uniq (sort @{$dependencies{$_}});
4919       foreach my $cond (@undefined_conds)
4920         {
4921           my $condstr = $cond->subst_string;
4922           &pretty_print_rule ("$condstr$_:", "$condstr\t", @uniq_deps);
4923           $output_rules .= $actions{$_} if defined $actions{$_};
4924           $output_rules .= "\n";
4925         }
4926     }
4927 }
4928
4929
4930 # &handle_tests_dejagnu ()
4931 # ------------------------
4932 sub handle_tests_dejagnu
4933 {
4934     push (@check_tests, 'check-DEJAGNU');
4935     $output_rules .= file_contents ('dejagnu', new Automake::Location);
4936 }
4937
4938 # is_valid_test_extension ($EXT)
4939 # ------------------------------
4940 # Return true if $EXT can appear in $(TEST_EXTENSIONS), return false
4941 # otherwise.
4942 sub is_valid_test_extension ($)
4943 {
4944   my $ext = shift;
4945   return 1
4946     if ($ext =~ /^\.[a-zA-Z_][a-zA-Z0-9_]*$/);
4947   return 1
4948     if (exists $configure_vars{'EXEEXT'} && $ext eq subst ('EXEEXT'));
4949   return 0;
4950 }
4951
4952 # Handle TESTS variable and other checks.
4953 sub handle_tests
4954 {
4955   if (option 'dejagnu')
4956     {
4957       &handle_tests_dejagnu;
4958     }
4959   else
4960     {
4961       foreach my $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
4962         {
4963           reject_var ($c, "`$c' defined but `dejagnu' not in "
4964                       . "`AUTOMAKE_OPTIONS'");
4965         }
4966     }
4967
4968   if (var ('TESTS'))
4969     {
4970       push (@check_tests, 'check-TESTS');
4971       $output_rules .= &file_contents ('check', new Automake::Location,
4972                                        COLOR => !! option 'color-tests',
4973                                        PARALLEL_TESTS => !! option 'parallel-tests');
4974
4975       # Tests that are known programs should have $(EXEEXT) appended.
4976       # For matching purposes, we need to adjust XFAIL_TESTS as well.
4977       append_exeext { exists $known_programs{$_[0]} } 'TESTS';
4978       append_exeext { exists $known_programs{$_[0]} } 'XFAIL_TESTS'
4979         if (var ('XFAIL_TESTS'));
4980
4981       if (option 'parallel-tests')
4982         {
4983           define_variable ('TEST_SUITE_LOG', 'test-suite.log', INTERNAL);
4984           define_variable ('TEST_SUITE_HTML', '$(TEST_SUITE_LOG:.log=.html)', INTERNAL);
4985           my $suff = '.test';
4986           my $at_exeext = '';
4987           my $handle_exeext = exists $configure_vars{'EXEEXT'};
4988           if ($handle_exeext)
4989             {
4990               $at_exeext = subst ('EXEEXT');
4991               $suff = $at_exeext  . ' ' . $suff;
4992             }
4993           if (! var 'TEST_EXTENSIONS')
4994             {
4995               define_variable ('TEST_EXTENSIONS', $suff, INTERNAL);
4996             }
4997           my $var = var 'TEST_EXTENSIONS';
4998           # Currently, we are not able to deal with conditional contents
4999           # in TEST_EXTENSIONS.
5000           if ($var->has_conditional_contents)
5001            {
5002              msg_var 'unsupported', $var,
5003                      "`TEST_EXTENSIONS' cannot have conditional contents";
5004            }
5005           my @test_suffixes = $var->value_as_list_recursive;
5006           if ((my @invalid_test_suffixes =
5007                   grep { !is_valid_test_extension $_ } @test_suffixes) > 0)
5008             {
5009               error $var->rdef (TRUE)->location,
5010                     "invalid test extensions: @invalid_test_suffixes";
5011             }
5012           @test_suffixes = grep { is_valid_test_extension $_ } @test_suffixes;
5013           if ($handle_exeext)
5014             {
5015               unshift (@test_suffixes, $at_exeext)
5016                 unless $test_suffixes[0] eq $at_exeext;
5017             }
5018           unshift (@test_suffixes, '');
5019
5020           transform_variable_recursively
5021             ('TESTS', 'TEST_LOGS', 'am__testlogs', 1, INTERNAL,
5022               sub {
5023                 my ($subvar, $val, $cond, $full_cond) = @_;
5024                 my $obj = $val;
5025                 return $obj
5026                   if $val =~ /^\@.*\@$/;
5027                 $obj =~ s/\$\(EXEEXT\)$//o;
5028
5029                 if ($val =~ /(\$\((top_)?srcdir\))\//o)
5030                   {
5031                     msg ('error', $subvar->rdef ($cond)->location,
5032                          "parallel-tests: using `$1' in TESTS is currently broken: `$val'");
5033                   }
5034
5035                 foreach my $test_suffix (@test_suffixes)
5036                   {
5037                     next
5038                       if $test_suffix eq $at_exeext || $test_suffix eq '';
5039                     return substr ($obj, 0, length ($obj) - length ($test_suffix)) . '.log'
5040                       if substr ($obj, - length ($test_suffix)) eq $test_suffix;
5041                   }
5042                 $obj .= '.log';
5043                 my $compile = 'LOG_COMPILE';
5044                 define_variable ($compile,
5045                                  '$(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)', INTERNAL);
5046                 $output_rules .= file_contents ('check2', new Automake::Location,
5047                                                 GENERIC => 0,
5048                                                 OBJ => $obj,
5049                                                 SOURCE => $val,
5050                                                 COMPILE =>'$(' . $compile . ')',
5051                                                 EXT => '',
5052                                                 am__EXEEXT => 'FALSE');
5053                 return $obj;
5054               });
5055
5056           my $nhelper=1;
5057           my $prev = 'TESTS';
5058           my $post = '';
5059           my $last_suffix = $test_suffixes[$#test_suffixes];
5060           my $cur = '';
5061           foreach my $test_suffix (@test_suffixes)
5062             {
5063               if ($test_suffix eq $last_suffix)
5064                 {
5065                   $cur = 'TEST_LOGS';
5066                 }
5067               else
5068                 {
5069                   $cur = 'am__test_logs' . $nhelper;
5070                 }
5071               define_variable ($cur,
5072                 '$(' . $prev . ':' . $test_suffix . $post . '=.log)', INTERNAL);
5073               $post = '.log';
5074               $prev = $cur;
5075               $nhelper++;
5076               if ($test_suffix ne $at_exeext && $test_suffix ne '')
5077                 {
5078                   (my $ext = $test_suffix) =~ s/^\.//;
5079                   $ext = uc $ext;
5080                   my $compile = $ext . '_LOG_COMPILE';
5081                   define_variable ($compile,
5082                                    '$(' . $ext . '_LOG_COMPILER) $(AM_' .  $ext . '_LOG_FLAGS)'
5083                                    . ' $(' . $ext . '_LOG_FLAGS)', INTERNAL);
5084                   my $am_exeext = $handle_exeext ? 'am__EXEEXT' : 'FALSE';
5085                   $output_rules .= file_contents ('check2', new Automake::Location,
5086                                                   GENERIC => 1,
5087                                                   OBJ => '',
5088                                                   SOURCE => '$<',
5089                                                   COMPILE => '$(' . $compile . ')',
5090                                                   EXT => $test_suffix,
5091                                                   am__EXEEXT => $am_exeext);
5092                 }
5093             }
5094
5095           define_variable ('TEST_LOGS_TMP', '$(TEST_LOGS:.log=.log-t)', INTERNAL);
5096
5097           $clean_files{'$(TEST_LOGS_TMP)'} = MOSTLY_CLEAN;
5098           $clean_files{'$(TEST_LOGS)'} = MOSTLY_CLEAN;
5099           $clean_files{'$(TEST_SUITE_LOG)'} = MOSTLY_CLEAN;
5100           $clean_files{'$(TEST_SUITE_HTML)'} = MOSTLY_CLEAN;
5101         }
5102     }
5103 }
5104
5105 # Handle Emacs Lisp.
5106 sub handle_emacs_lisp
5107 {
5108   my @elfiles = &am_install_var ('-candist', 'lisp', 'LISP',
5109                                  'lisp', 'noinst');
5110
5111   return if ! @elfiles;
5112
5113   define_pretty_variable ('am__ELFILES', TRUE, INTERNAL,
5114                           map { $_->[1] } @elfiles);
5115   define_pretty_variable ('am__ELCFILES', TRUE, INTERNAL,
5116                           '$(am__ELFILES:.el=.elc)');
5117   # This one can be overridden by users.
5118   define_pretty_variable ('ELCFILES', TRUE, INTERNAL, '$(LISP:.el=.elc)');
5119
5120   push @all, '$(ELCFILES)';
5121
5122   require_variables ($elfiles[0][0], "Emacs Lisp sources seen", TRUE,
5123                      'EMACS', 'lispdir');
5124   require_conf_file ($elfiles[0][0], FOREIGN, 'elisp-comp');
5125   &define_variable ('elisp_comp', "$am_config_aux_dir/elisp-comp", INTERNAL);
5126 }
5127
5128 # Handle Python
5129 sub handle_python
5130 {
5131   my @pyfiles = &am_install_var ('-defaultdist', 'python', 'PYTHON',
5132                                  'noinst');
5133   return if ! @pyfiles;
5134
5135   require_variables ($pyfiles[0][0], "Python sources seen", TRUE, 'PYTHON');
5136   require_conf_file ($pyfiles[0][0], FOREIGN, 'py-compile');
5137   &define_variable ('py_compile', "$am_config_aux_dir/py-compile", INTERNAL);
5138 }
5139
5140 # Handle Java.
5141 sub handle_java
5142 {
5143     my @sourcelist = &am_install_var ('-candist',
5144                                       'java', 'JAVA',
5145                                       'noinst', 'check');
5146     return if ! @sourcelist;
5147
5148     my @prefixes = am_primary_prefixes ('JAVA', 1,
5149                                         'noinst', 'check');
5150
5151     my $dir;
5152     my @java_sources = ();
5153     foreach my $prefix (@prefixes)
5154       {
5155         (my $curs = $prefix) =~ s/^(?:nobase_)?(?:dist_|nodist_)?//;
5156
5157         next
5158           if $curs eq 'EXTRA';
5159
5160         push @java_sources, '$(' . $prefix . '_JAVA' . ')';
5161
5162         if (defined $dir)
5163           {
5164             err_var "${curs}_JAVA", "multiple _JAVA primaries in use"
5165              unless $curs eq $dir;
5166           }
5167
5168         $dir = $curs;
5169       }
5170
5171     define_pretty_variable ('am__java_sources', TRUE, INTERNAL,
5172                             "@java_sources");
5173
5174     if ($dir eq 'check')
5175       {
5176         push (@check, "class$dir.stamp");
5177       }
5178     else
5179       {
5180         push (@all, "class$dir.stamp");
5181       }
5182 }
5183
5184
5185 # Handle some of the minor options.
5186 sub handle_minor_options
5187 {
5188   if (option 'readme-alpha')
5189     {
5190       if ($relative_dir eq '.')
5191         {
5192           if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
5193             {
5194               msg ('error-gnits', $package_version_location,
5195                    "version `$package_version' doesn't follow " .
5196                    "Gnits standards");
5197             }
5198           if (defined $1 && -f 'README-alpha')
5199             {
5200               # This means we have an alpha release.  See
5201               # GNITS_VERSION_PATTERN for details.
5202               push_dist_common ('README-alpha');
5203             }
5204         }
5205     }
5206 }
5207
5208 ################################################################
5209
5210 # ($OUTPUT, @INPUTS)
5211 # &split_config_file_spec ($SPEC)
5212 # -------------------------------
5213 # Decode the Autoconf syntax for config files (files, headers, links
5214 # etc.).
5215 sub split_config_file_spec ($)
5216 {
5217   my ($spec) = @_;
5218   my ($output, @inputs) = split (/:/, $spec);
5219
5220   push @inputs, "$output.in"
5221     unless @inputs;
5222
5223   return ($output, @inputs);
5224 }
5225
5226 # $input
5227 # locate_am (@POSSIBLE_SOURCES)
5228 # -----------------------------
5229 # AC_CONFIG_FILES allow specifications such as Makefile:top.in:mid.in:bot.in
5230 # This functions returns the first *.in file for which a *.am exists.
5231 # It returns undef otherwise.
5232 sub locate_am (@)
5233 {
5234   my (@rest) = @_;
5235   my $input;
5236   foreach my $file (@rest)
5237     {
5238       if (($file =~ /^(.*)\.in$/) && -f "$1.am")
5239         {
5240           $input = $file;
5241           last;
5242         }
5243     }
5244   return $input;
5245 }
5246
5247 my %make_list;
5248
5249 # &scan_autoconf_config_files ($WHERE, $CONFIG-FILES)
5250 # ---------------------------------------------------
5251 # Study $CONFIG-FILES which is the first argument to AC_CONFIG_FILES
5252 # (or AC_OUTPUT).
5253 sub scan_autoconf_config_files ($$)
5254 {
5255   my ($where, $config_files) = @_;
5256
5257   # Look at potential Makefile.am's.
5258   foreach (split ' ', $config_files)
5259     {
5260       # Must skip empty string for Perl 4.
5261       next if $_ eq "\\" || $_ eq '';
5262
5263       # Handle $local:$input syntax.
5264       my ($local, @rest) = split (/:/);
5265       @rest = ("$local.in",) unless @rest;
5266       msg ('portability', $where,
5267           "Omit leading `./' from config file names such as `$local',"
5268           . "\nas not all make implementations treat `file' and `./file' equally.")
5269         if ($local =~ /^\.\//);
5270       my $input = locate_am @rest;
5271       if ($input)
5272         {
5273           # We have a file that automake should generate.
5274           $make_list{$input} = join (':', ($local, @rest));
5275         }
5276       else
5277         {
5278           # We have a file that automake should cause to be
5279           # rebuilt, but shouldn't generate itself.
5280           push (@other_input_files, $_);
5281         }
5282       $ac_config_files_location{$local} = $where;
5283       $ac_config_files_condition{$local} =
5284         new Automake::Condition (@cond_stack)
5285           if (@cond_stack);
5286     }
5287 }
5288
5289
5290 # &scan_autoconf_traces ($FILENAME)
5291 # ---------------------------------
5292 sub scan_autoconf_traces ($)
5293 {
5294   my ($filename) = @_;
5295
5296   # Macros to trace, with their minimal number of arguments.
5297   #
5298   # IMPORTANT: If you add a macro here, you should also add this macro
5299   # =========  to Automake-preselection in autoconf/lib/autom4te.in.
5300   my %traced = (
5301                 AC_CANONICAL_BUILD => 0,
5302                 AC_CANONICAL_HOST => 0,
5303                 AC_CANONICAL_TARGET => 0,
5304                 AC_CONFIG_AUX_DIR => 1,
5305                 AC_CONFIG_FILES => 1,
5306                 AC_CONFIG_HEADERS => 1,
5307                 AC_CONFIG_LIBOBJ_DIR => 1,
5308                 AC_CONFIG_LINKS => 1,
5309                 AC_FC_SRCEXT => 1,
5310                 AC_INIT => 0,
5311                 AC_LIBSOURCE => 1,
5312                 AC_REQUIRE_AUX_FILE => 1,
5313                 AC_SUBST_TRACE => 1,
5314                 AM_AUTOMAKE_VERSION => 1,
5315                 AM_CONDITIONAL => 2,
5316                 AM_ENABLE_MULTILIB => 0,
5317                 AM_GNU_GETTEXT => 0,
5318                 AM_GNU_GETTEXT_INTL_SUBDIR => 0,
5319                 AM_INIT_AUTOMAKE => 0,
5320                 AM_MAINTAINER_MODE => 0,
5321                 AM_PROG_AR => 0,
5322                 AM_PROG_CC_C_O => 0,
5323                 AM_SILENT_RULES => 0,
5324                 _AM_SUBST_NOTMAKE => 1,
5325                 _AM_COND_IF => 1,
5326                 _AM_COND_ELSE => 1,
5327                 _AM_COND_ENDIF => 1,
5328                 LT_SUPPORTED_TAG => 1,
5329                 _LT_AC_TAGCONFIG => 0,
5330                 m4_include => 1,
5331                 m4_sinclude => 1,
5332                 sinclude => 1,
5333               );
5334
5335   my $traces = ($ENV{AUTOCONF} || '@am_AUTOCONF@') . " ";
5336
5337   # Use a separator unlikely to be used, not `:', the default, which
5338   # has a precise meaning for AC_CONFIG_FILES and so on.
5339   $traces .= join (' ',
5340                    map { "--trace=$_" . ':\$f:\$l::\$d::\$n::\${::}%' }
5341                    (keys %traced));
5342
5343   my $tracefh = new Automake::XFile ("$traces $filename |");
5344   verb "reading $traces";
5345
5346   @cond_stack = ();
5347   my $where;
5348
5349   while ($_ = $tracefh->getline)
5350     {
5351       chomp;
5352       my ($here, $depth, @args) = split (/::/);
5353       $where = new Automake::Location $here;
5354       my $macro = $args[0];
5355
5356       prog_error ("unrequested trace `$macro'")
5357         unless exists $traced{$macro};
5358
5359       # Skip and diagnose malformed calls.
5360       if ($#args < $traced{$macro})
5361         {
5362           msg ('syntax', $where, "not enough arguments for $macro");
5363           next;
5364         }
5365
5366       # Alphabetical ordering please.
5367       if ($macro eq 'AC_CANONICAL_BUILD')
5368         {
5369           if ($seen_canonical <= AC_CANONICAL_BUILD)
5370             {
5371               $seen_canonical = AC_CANONICAL_BUILD;
5372               $canonical_location = $where;
5373             }
5374         }
5375       elsif ($macro eq 'AC_CANONICAL_HOST')
5376         {
5377           if ($seen_canonical <= AC_CANONICAL_HOST)
5378             {
5379               $seen_canonical = AC_CANONICAL_HOST;
5380               $canonical_location = $where;
5381             }
5382         }
5383       elsif ($macro eq 'AC_CANONICAL_TARGET')
5384         {
5385           $seen_canonical = AC_CANONICAL_TARGET;
5386           $canonical_location = $where;
5387         }
5388       elsif ($macro eq 'AC_CONFIG_AUX_DIR')
5389         {
5390           if ($seen_init_automake)
5391             {
5392               error ($where, "AC_CONFIG_AUX_DIR must be called before "
5393                      . "AM_INIT_AUTOMAKE...", partial => 1);
5394               error ($seen_init_automake, "... AM_INIT_AUTOMAKE called here");
5395             }
5396           $config_aux_dir = $args[1];
5397           $config_aux_dir_set_in_configure_ac = 1;
5398           $relative_dir = '.';
5399           check_directory ($config_aux_dir, $where);
5400         }
5401       elsif ($macro eq 'AC_CONFIG_FILES')
5402         {
5403           # Look at potential Makefile.am's.
5404           scan_autoconf_config_files ($where, $args[1]);
5405         }
5406       elsif ($macro eq 'AC_CONFIG_HEADERS')
5407         {
5408           foreach my $spec (split (' ', $args[1]))
5409             {
5410               my ($dest, @src) = split (':', $spec);
5411               $ac_config_files_location{$dest} = $where;
5412               push @config_headers, $spec;
5413             }
5414         }
5415       elsif ($macro eq 'AC_CONFIG_LIBOBJ_DIR')
5416         {
5417           $config_libobj_dir = $args[1];
5418           $relative_dir = '.';
5419           check_directory ($config_libobj_dir, $where);
5420         }
5421       elsif ($macro eq 'AC_CONFIG_LINKS')
5422         {
5423           foreach my $spec (split (' ', $args[1]))
5424             {
5425               my ($dest, $src) = split (':', $spec);
5426               $ac_config_files_location{$dest} = $where;
5427               push @config_links, $spec;
5428             }
5429         }
5430       elsif ($macro eq 'AC_FC_SRCEXT')
5431         {
5432           my $suffix = $args[1];
5433           # These flags are used as %SOURCEFLAG% in depend2.am,
5434           # where the trailing space is important.
5435           $sourceflags{'.' . $suffix} = '$(FCFLAGS_' . $suffix . ') '
5436             if ($suffix eq 'f90' || $suffix eq 'f95' || $suffix eq 'f03' || $suffix eq 'f08');
5437         }
5438       elsif ($macro eq 'AC_INIT')
5439         {
5440           if (defined $args[2])
5441             {
5442               $package_version = $args[2];
5443               $package_version_location = $where;
5444             }
5445         }
5446       elsif ($macro eq 'AC_LIBSOURCE')
5447         {
5448           $libsources{$args[1]} = $here;
5449         }
5450       elsif ($macro eq 'AC_REQUIRE_AUX_FILE')
5451         {
5452           # Only remember the first time a file is required.
5453           $required_aux_file{$args[1]} = $where
5454             unless exists $required_aux_file{$args[1]};
5455         }
5456       elsif ($macro eq 'AC_SUBST_TRACE')
5457         {
5458           # Just check for alphanumeric in AC_SUBST_TRACE.  If you do
5459           # AC_SUBST(5), then too bad.
5460           $configure_vars{$args[1]} = $where
5461             if $args[1] =~ /^\w+$/;
5462         }
5463       elsif ($macro eq 'AM_AUTOMAKE_VERSION')
5464         {
5465           error ($where,
5466                  "version mismatch.  This is Automake $VERSION,\n" .
5467                  "but the definition used by this AM_INIT_AUTOMAKE\n" .
5468                  "comes from Automake $args[1].  You should recreate\n" .
5469                  "aclocal.m4 with aclocal and run automake again.\n",
5470                  # $? = 63 is used to indicate version mismatch to missing.
5471                  exit_code => 63)
5472             if $VERSION ne $args[1];
5473
5474           $seen_automake_version = 1;
5475         }
5476       elsif ($macro eq 'AM_CONDITIONAL')
5477         {
5478           $configure_cond{$args[1]} = $where;
5479         }
5480       elsif ($macro eq 'AM_ENABLE_MULTILIB')
5481         {
5482           $seen_multilib = $where;
5483         }
5484       elsif ($macro eq 'AM_GNU_GETTEXT')
5485         {
5486           $seen_gettext = $where;
5487           $ac_gettext_location = $where;
5488           $seen_gettext_external = grep ($_ eq 'external', @args);
5489         }
5490       elsif ($macro eq 'AM_GNU_GETTEXT_INTL_SUBDIR')
5491         {
5492           $seen_gettext_intl = $where;
5493         }
5494       elsif ($macro eq 'AM_INIT_AUTOMAKE')
5495         {
5496           $seen_init_automake = $where;
5497           if (defined $args[2])
5498             {
5499               $package_version = $args[2];
5500               $package_version_location = $where;
5501             }
5502           elsif (defined $args[1])
5503             {
5504               exit $exit_code
5505                 if (process_global_option_list ($where,
5506                                                 split (' ', $args[1])));
5507             }
5508         }
5509       elsif ($macro eq 'AM_MAINTAINER_MODE')
5510         {
5511           $seen_maint_mode = $where;
5512         }
5513       elsif ($macro eq 'AM_PROG_AR')
5514         {
5515           $seen_ar = $where;
5516         }
5517       elsif ($macro eq 'AM_PROG_CC_C_O')
5518         {
5519           $seen_cc_c_o = $where;
5520         }
5521       elsif ($macro eq 'AM_SILENT_RULES')
5522         {
5523           set_global_option ('silent-rules', $where);
5524         }
5525       elsif ($macro eq '_AM_COND_IF')
5526         {
5527           cond_stack_if ('', $args[1], $where);
5528           error ($where, "missing m4 quoting, macro depth $depth")
5529             if ($depth != 1);
5530         }
5531       elsif ($macro eq '_AM_COND_ELSE')
5532         {
5533           cond_stack_else ('!', $args[1], $where);
5534           error ($where, "missing m4 quoting, macro depth $depth")
5535             if ($depth != 1);
5536         }
5537       elsif ($macro eq '_AM_COND_ENDIF')
5538         {
5539           cond_stack_endif (undef, undef, $where);
5540           error ($where, "missing m4 quoting, macro depth $depth")
5541             if ($depth != 1);
5542         }
5543       elsif ($macro eq '_AM_SUBST_NOTMAKE')
5544         {
5545           $ignored_configure_vars{$args[1]} = $where;
5546         }
5547       elsif ($macro eq 'm4_include'
5548              || $macro eq 'm4_sinclude'
5549              || $macro eq 'sinclude')
5550         {
5551           # Skip missing `sinclude'd files.
5552           next if $macro ne 'm4_include' && ! -f $args[1];
5553
5554           # Some modified versions of Autoconf don't use
5555           # frozen files.  Consequently it's possible that we see all
5556           # m4_include's performed during Autoconf's startup.
5557           # Obviously we don't want to distribute Autoconf's files
5558           # so we skip absolute filenames here.
5559           push @configure_deps, '$(top_srcdir)/' . $args[1]
5560             unless $here =~ m,^(?:\w:)?[\\/],;
5561           # Keep track of the greatest timestamp.
5562           if (-e $args[1])
5563             {
5564               my $mtime = mtime $args[1];
5565               $configure_deps_greatest_timestamp = $mtime
5566                 if $mtime > $configure_deps_greatest_timestamp;
5567             }
5568         }
5569       elsif ($macro eq 'LT_SUPPORTED_TAG')
5570         {
5571           $libtool_tags{$args[1]} = 1;
5572           $libtool_new_api = 1;
5573         }
5574       elsif ($macro eq '_LT_AC_TAGCONFIG')
5575         {
5576           # _LT_AC_TAGCONFIG is an old macro present in Libtool 1.5.
5577           # We use it to detect whether tags are supported.  Our
5578           # preferred interface is LT_SUPPORTED_TAG, but it was
5579           # introduced in Libtool 1.6.
5580           if (0 == keys %libtool_tags)
5581             {
5582               # Hardcode the tags supported by Libtool 1.5.
5583               %libtool_tags = (CC => 1, CXX => 1, GCJ => 1, F77 => 1);
5584             }
5585         }
5586     }
5587
5588   error ($where, "condition stack not properly closed")
5589     if (@cond_stack);
5590
5591   $tracefh->close;
5592 }
5593
5594
5595 # &scan_autoconf_files ()
5596 # -----------------------
5597 # Check whether we use `configure.ac' or `configure.in'.
5598 # Scan it (and possibly `aclocal.m4') for interesting things.
5599 # We must scan aclocal.m4 because there might be AC_SUBSTs and such there.
5600 sub scan_autoconf_files ()
5601 {
5602   # Reinitialize libsources here.  This isn't really necessary,
5603   # since we currently assume there is only one configure.ac.  But
5604   # that won't always be the case.
5605   %libsources = ();
5606
5607   # Keep track of the youngest configure dependency.
5608   $configure_deps_greatest_timestamp = mtime $configure_ac;
5609   if (-e 'aclocal.m4')
5610     {
5611       my $mtime = mtime 'aclocal.m4';
5612       $configure_deps_greatest_timestamp = $mtime
5613         if $mtime > $configure_deps_greatest_timestamp;
5614     }
5615
5616   scan_autoconf_traces ($configure_ac);
5617
5618   @configure_input_files = sort keys %make_list;
5619   # Set input and output files if not specified by user.
5620   if (! @input_files)
5621     {
5622       @input_files = @configure_input_files;
5623       %output_files = %make_list;
5624     }
5625
5626
5627   if (! $seen_init_automake)
5628     {
5629       err_ac ("no proper invocation of AM_INIT_AUTOMAKE was found.\nYou "
5630               . "should verify that $configure_ac invokes AM_INIT_AUTOMAKE,"
5631               . "\nthat aclocal.m4 is present in the top-level directory,\n"
5632               . "and that aclocal.m4 was recently regenerated "
5633               . "(using aclocal).");
5634     }
5635   else
5636     {
5637       if (! $seen_automake_version)
5638         {
5639           if (-f 'aclocal.m4')
5640             {
5641               error ($seen_init_automake,
5642                      "your implementation of AM_INIT_AUTOMAKE comes from " .
5643                      "an\nold Automake version.  You should recreate " .
5644                      "aclocal.m4\nwith aclocal and run automake again.\n",
5645                      # $? = 63 is used to indicate version mismatch to missing.
5646                      exit_code => 63);
5647             }
5648           else
5649             {
5650               error ($seen_init_automake,
5651                      "no proper implementation of AM_INIT_AUTOMAKE was " .
5652                      "found,\nprobably because aclocal.m4 is missing...\n" .
5653                      "You should run aclocal to create this file, then\n" .
5654                      "run automake again.\n");
5655             }
5656         }
5657     }
5658
5659   locate_aux_dir ();
5660
5661   # Reorder @input_files so that the Makefile that distributes aux
5662   # files is processed last.  This is important because each directory
5663   # can require auxiliary scripts and we should wait until they have
5664   # been installed before distributing them.
5665
5666   # The Makefile.in that distribute the aux files is the one in
5667   # $config_aux_dir or the top-level Makefile.
5668   my $auxdirdist = is_make_dir ($config_aux_dir) ? $config_aux_dir : '.';
5669   my @new_input_files = ();
5670   while (@input_files)
5671     {
5672       my $in = pop @input_files;
5673       my @ins = split (/:/, $output_files{$in});
5674       if (dirname ($ins[0]) eq $auxdirdist)
5675         {
5676           push @new_input_files, $in;
5677           $automake_will_process_aux_dir = 1;
5678         }
5679       else
5680         {
5681           unshift @new_input_files, $in;
5682         }
5683     }
5684   @input_files = @new_input_files;
5685
5686   # If neither the auxdir/Makefile nor the ./Makefile are generated
5687   # by Automake, we won't distribute the aux files anyway.  Assume
5688   # the user know what (s)he does, and pretend we will distribute
5689   # them to disable the error in require_file_internal.
5690   $automake_will_process_aux_dir = 1 if ! is_make_dir ($auxdirdist);
5691
5692   # Look for some files we need.  Always check for these.  This
5693   # check must be done for every run, even those where we are only
5694   # looking at a subdir Makefile.  We must set relative_dir for
5695   # maybe_push_required_file to work.
5696   # Sort the files for stable verbose output.
5697   $relative_dir = '.';
5698   foreach my $file (sort keys %required_aux_file)
5699     {
5700       require_conf_file ($required_aux_file{$file}->get, FOREIGN, $file)
5701     }
5702   err_am "`install.sh' is an anachronism; use `install-sh' instead"
5703     if -f $config_aux_dir . '/install.sh';
5704
5705   # Preserve dist_common for later.
5706   $configure_dist_common = variable_value ('DIST_COMMON') || '';
5707
5708 }
5709
5710 ################################################################
5711
5712 # Set up for Cygnus mode.
5713 sub check_cygnus
5714 {
5715   my $cygnus = option 'cygnus';
5716   return unless $cygnus;
5717
5718   set_strictness ('foreign');
5719   set_option ('no-installinfo', $cygnus);
5720   set_option ('no-dependencies', $cygnus);
5721   set_option ('no-dist', $cygnus);
5722
5723   err_ac "`AM_MAINTAINER_MODE' required when --cygnus specified"
5724     if !$seen_maint_mode;
5725 }
5726
5727 # Do any extra checking for GNU standards.
5728 sub check_gnu_standards
5729 {
5730   if ($relative_dir eq '.')
5731     {
5732       # In top level (or only) directory.
5733       require_file ("$am_file.am", GNU,
5734                     qw/INSTALL NEWS README AUTHORS ChangeLog/);
5735
5736       # Accept one of these three licenses; default to COPYING.
5737       # Make sure we do not overwrite an existing license.
5738       my $license;
5739       foreach (qw /COPYING COPYING.LIB COPYING.LESSER/)
5740         {
5741           if (-f $_)
5742             {
5743               $license = $_;
5744               last;
5745             }
5746         }
5747       require_file ("$am_file.am", GNU, 'COPYING')
5748         unless $license;
5749     }
5750
5751   for my $opt ('no-installman', 'no-installinfo')
5752     {
5753       msg ('error-gnu', option $opt,
5754            "option `$opt' disallowed by GNU standards")
5755         if option $opt;
5756     }
5757 }
5758
5759 # Do any extra checking for GNITS standards.
5760 sub check_gnits_standards
5761 {
5762   if ($relative_dir eq '.')
5763     {
5764       # In top level (or only) directory.
5765       require_file ("$am_file.am", GNITS, 'THANKS');
5766     }
5767 }
5768
5769 ################################################################
5770 #
5771 # Functions to handle files of each language.
5772
5773 # Each `lang_X_rewrite($DIRECTORY, $BASE, $EXT)' function follows a
5774 # simple formula: Return value is LANG_SUBDIR if the resulting object
5775 # file should be in a subdir if the source file is, LANG_PROCESS if
5776 # file is to be dealt with, LANG_IGNORE otherwise.
5777
5778 # Much of the actual processing is handled in
5779 # handle_single_transform.  These functions exist so that
5780 # auxiliary information can be recorded for a later cleanup pass.
5781 # Note that the calls to these functions are computed, so don't bother
5782 # searching for their precise names in the source.
5783
5784 # This is just a convenience function that can be used to determine
5785 # when a subdir object should be used.
5786 sub lang_sub_obj
5787 {
5788     return option 'subdir-objects' ? LANG_SUBDIR : LANG_PROCESS;
5789 }
5790
5791 # Rewrite a single C source file.
5792 sub lang_c_rewrite
5793 {
5794   my ($directory, $base, $ext, $nonansi_obj, $have_per_exec_flags, $var) = @_;
5795
5796   if (option 'ansi2knr' && $base =~ /_$/)
5797     {
5798       # FIXME: include line number in error.
5799       err_am "C source file `$base.c' would be deleted by ansi2knr rules";
5800     }
5801
5802   my $r = LANG_PROCESS;
5803   if (option 'subdir-objects')
5804     {
5805       $r = LANG_SUBDIR;
5806       if ($directory && $directory ne '.')
5807         {
5808           $base = $directory . '/' . $base;
5809
5810           # libtool is always able to put the object at the proper place,
5811           # so we do not have to require AM_PROG_CC_C_O when building .lo files.
5812           msg_var ('portability', $var,
5813                    "compiling `$base.c' in subdir requires "
5814                    . "`AM_PROG_CC_C_O' in `$configure_ac'",
5815                    uniq_scope => US_GLOBAL,
5816                    uniq_part => 'AM_PROG_CC_C_O subdir')
5817             unless $seen_cc_c_o || $nonansi_obj eq '.lo';
5818         }
5819
5820       # In this case we already have the directory information, so
5821       # don't add it again.
5822       $de_ansi_files{$base} = '';
5823     }
5824   else
5825     {
5826       $de_ansi_files{$base} = (($directory eq '.' || $directory eq '')
5827                                ? ''
5828                                : "$directory/");
5829     }
5830
5831   if (! $seen_cc_c_o
5832       && $have_per_exec_flags
5833       && ! option 'subdir-objects'
5834       && $nonansi_obj ne '.lo')
5835     {
5836       msg_var ('portability',
5837                $var, "compiling `$base.c' with per-target flags requires "
5838                . "`AM_PROG_CC_C_O' in `$configure_ac'",
5839                uniq_scope => US_GLOBAL,
5840                uniq_part => 'AM_PROG_CC_C_O per-target')
5841     }
5842
5843     return $r;
5844 }
5845
5846 # Rewrite a single C++ source file.
5847 sub lang_cxx_rewrite
5848 {
5849     return &lang_sub_obj;
5850 }
5851
5852 # Rewrite a single header file.
5853 sub lang_header_rewrite
5854 {
5855     # Header files are simply ignored.
5856     return LANG_IGNORE;
5857 }
5858
5859 # Rewrite a single Vala source file.
5860 sub lang_vala_rewrite
5861 {
5862     my ($directory, $base, $ext) = @_;
5863
5864     (my $newext = $ext) =~ s/vala$/c/;
5865     return (LANG_SUBDIR, $newext);
5866 }
5867
5868 # Rewrite a single yacc file.
5869 sub lang_yacc_rewrite
5870 {
5871     my ($directory, $base, $ext) = @_;
5872
5873     my $r = &lang_sub_obj;
5874     (my $newext = $ext) =~ tr/y/c/;
5875     return ($r, $newext);
5876 }
5877
5878 # Rewrite a single yacc++ file.
5879 sub lang_yaccxx_rewrite
5880 {
5881     my ($directory, $base, $ext) = @_;
5882
5883     my $r = &lang_sub_obj;
5884     (my $newext = $ext) =~ tr/y/c/;
5885     return ($r, $newext);
5886 }
5887
5888 # Rewrite a single lex file.
5889 sub lang_lex_rewrite
5890 {
5891     my ($directory, $base, $ext) = @_;
5892
5893     my $r = &lang_sub_obj;
5894     (my $newext = $ext) =~ tr/l/c/;
5895     return ($r, $newext);
5896 }
5897
5898 # Rewrite a single lex++ file.
5899 sub lang_lexxx_rewrite
5900 {
5901     my ($directory, $base, $ext) = @_;
5902
5903     my $r = &lang_sub_obj;
5904     (my $newext = $ext) =~ tr/l/c/;
5905     return ($r, $newext);
5906 }
5907
5908 # Rewrite a single assembly file.
5909 sub lang_asm_rewrite
5910 {
5911     return &lang_sub_obj;
5912 }
5913
5914 # Rewrite a single preprocessed assembly file.
5915 sub lang_cppasm_rewrite
5916 {
5917     return &lang_sub_obj;
5918 }
5919
5920 # Rewrite a single Fortran 77 file.
5921 sub lang_f77_rewrite
5922 {
5923     return &lang_sub_obj;
5924 }
5925
5926 # Rewrite a single Fortran file.
5927 sub lang_fc_rewrite
5928 {
5929     return &lang_sub_obj;
5930 }
5931
5932 # Rewrite a single preprocessed Fortran file.
5933 sub lang_ppfc_rewrite
5934 {
5935     return &lang_sub_obj;
5936 }
5937
5938 # Rewrite a single preprocessed Fortran 77 file.
5939 sub lang_ppf77_rewrite
5940 {
5941     return &lang_sub_obj;
5942 }
5943
5944 # Rewrite a single ratfor file.
5945 sub lang_ratfor_rewrite
5946 {
5947     return &lang_sub_obj;
5948 }
5949
5950 # Rewrite a single Objective C file.
5951 sub lang_objc_rewrite
5952 {
5953     return &lang_sub_obj;
5954 }
5955
5956 # Rewrite a single Unified Parallel C file.
5957 sub lang_upc_rewrite
5958 {
5959     return &lang_sub_obj;
5960 }
5961
5962 # Rewrite a single Java file.
5963 sub lang_java_rewrite
5964 {
5965     return LANG_SUBDIR;
5966 }
5967
5968 # The lang_X_finish functions are called after all source file
5969 # processing is done.  Each should handle defining rules for the
5970 # language, etc.  A finish function is only called if a source file of
5971 # the appropriate type has been seen.
5972
5973 sub lang_c_finish
5974 {
5975     # Push all libobjs files onto de_ansi_files.  We actually only
5976     # push files which exist in the current directory, and which are
5977     # genuine source files.
5978     foreach my $file (keys %libsources)
5979     {
5980         if ($file =~ /^(.*)\.[cly]$/ && -f "$relative_dir/$file")
5981         {
5982             $de_ansi_files{$1} = ''
5983         }
5984     }
5985
5986     if (option 'ansi2knr' && keys %de_ansi_files)
5987     {
5988         # Make all _.c files depend on their corresponding .c files.
5989         my @objects;
5990         foreach my $base (sort keys %de_ansi_files)
5991         {
5992             # Each _.c file must depend on ansi2knr; otherwise it
5993             # might be used in a parallel build before it is built.
5994             # We need to support files in the srcdir and in the build
5995             # dir (because these files might be auto-generated.  But
5996             # we can't use $< -- some makes only define $< during a
5997             # suffix rule.
5998             my $ansfile = $de_ansi_files{$base} . $base . '.c';
5999             $output_rules .= ($base . "_.c: $ansfile \$(ANSI2KNR)\n\t"
6000                               . '$(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) '
6001                               . '`if test -f $(srcdir)/' . $ansfile
6002                               . '; then echo $(srcdir)/' . $ansfile
6003                               . '; else echo ' . $ansfile . '; fi` '
6004                               . "| sed 's/^# \\([0-9]\\)/#line \\1/' "
6005                               . '| $(ANSI2KNR) > $@'
6006                               # If ansi2knr fails then we shouldn't
6007                               # create the _.c file
6008                               . " || rm -f \$\@\n");
6009             push (@objects, $base . '_.$(OBJEXT)');
6010             push (@objects, $base . '_.lo')
6011               if var ('LIBTOOL');
6012
6013             # Explicitly clean the _.c files if they are in a
6014             # subdirectory. (In the current directory they get erased
6015             # by a `rm -f *_.c' rule.)
6016             $clean_files{$base . '_.c'} = MOSTLY_CLEAN
6017               if dirname ($base) ne '.';
6018         }
6019
6020         # Make all _.o (and _.lo) files depend on ansi2knr.
6021         # Use a sneaky little hack to make it print nicely.
6022         &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
6023     }
6024 }
6025
6026 sub lang_vala_finish_target ($$)
6027 {
6028   my ($self, $name) = @_;
6029
6030   my $derived = canonicalize ($name);
6031   my $varname = $derived . '_SOURCES';
6032   my $var = var ($varname);
6033
6034   if ($var)
6035     {
6036       foreach my $file ($var->value_as_list_recursive)
6037         {
6038           $output_rules .= "\$(srcdir)/$file: \$(srcdir)/${derived}_vala.stamp\n"
6039             . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6040             . "\t\@if test -f \$@; then :; else \\\n"
6041             . "\t  \$(am__cd) \$(srcdir) && \$(MAKE) \$(AM_MAKEFLAGS) ${derived}_vala.stamp; \\\n"
6042             . "\tfi\n"
6043             if $file =~ s/(.*)\.vala$/$1.c/;
6044         }
6045     }
6046
6047   # Add rebuild rules for generated header and vapi files
6048   my $flags = var ($derived . '_VALAFLAGS');
6049   if ($flags)
6050     {
6051       my $lastflag = '';
6052       foreach my $flag ($flags->value_as_list_recursive)
6053         {
6054           if (grep (/$lastflag/, ('-H', '-h', '--header', '--internal-header',
6055                                   '--vapi', '--internal-vapi', '--gir')))
6056             {
6057               my $headerfile = $flag;
6058               $output_rules .= "\$(srcdir)/$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
6059                 . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6060                 . "\t\@if test -f \$@; then :; else \\\n"
6061                 . "\t  \$(am__cd) \$(srcdir) && \$(MAKE) \$(AM_MAKEFLAGS) ${derived}_vala.stamp; \\\n"
6062                 . "\tfi\n";
6063
6064               # valac is not used when building from dist tarballs
6065               # distribute the generated files
6066               push_dist_common ($headerfile);
6067               $clean_files{$headerfile} = MAINTAINER_CLEAN;
6068             }
6069           $lastflag = $flag;
6070         }
6071     }
6072
6073   my $compile = $self->compile;
6074
6075   # Rewrite each occurrence of `AM_VALAFLAGS' in the compile
6076   # rule into `${derived}_VALAFLAGS' if it exists.
6077   my $val = "${derived}_VALAFLAGS";
6078   $compile =~ s/\(AM_VALAFLAGS\)/\($val\)/
6079     if set_seen ($val);
6080
6081   # VALAFLAGS is a user variable (per GNU Standards),
6082   # it should not be overridden in the Makefile...
6083   check_user_variables ['VALAFLAGS'];
6084
6085   my $dirname = dirname ($name);
6086
6087   # Only generate C code, do not run C compiler
6088   $compile .= " -C";
6089
6090   my $verbose = verbose_flag ('VALAC');
6091   my $silent = silent_flag ();
6092
6093   $output_rules .=
6094     "${derived}_vala.stamp: \$(${derived}_SOURCES)\n".
6095     "\t${verbose}${compile} \$(${derived}_SOURCES)\n".
6096     "\t${silent}touch \$@\n";
6097
6098   push_dist_common ("${derived}_vala.stamp");
6099
6100   $clean_files{"${derived}_vala.stamp"} = MAINTAINER_CLEAN;
6101 }
6102
6103 # Add output rules to invoke valac and create stamp file as a witness
6104 # to handle multiple outputs. This function is called after all source
6105 # file processing is done.
6106 sub lang_vala_finish
6107 {
6108   my ($self) = @_;
6109
6110   foreach my $prog (keys %known_programs)
6111     {
6112       lang_vala_finish_target ($self, $prog);
6113     }
6114
6115   while (my ($name) = each %known_libraries)
6116     {
6117       lang_vala_finish_target ($self, $name);
6118     }
6119 }
6120
6121 # The built .c files should be cleaned only on maintainer-clean
6122 # as the .c files are distributed. This function is called for each
6123 # .vala source file.
6124 sub lang_vala_target_hook
6125 {
6126   my ($self, $aggregate, $output, $input, %transform) = @_;
6127
6128   $clean_files{$output} = MAINTAINER_CLEAN;
6129 }
6130
6131 # This is a yacc helper which is called whenever we have decided to
6132 # compile a yacc file.
6133 sub lang_yacc_target_hook
6134 {
6135     my ($self, $aggregate, $output, $input, %transform) = @_;
6136
6137     my $flag = $aggregate . "_YFLAGS";
6138     my $flagvar = var $flag;
6139     my $YFLAGSvar = var 'YFLAGS';
6140     if (($flagvar && $flagvar->variable_value =~ /$DASH_D_PATTERN/o)
6141         || ($YFLAGSvar && $YFLAGSvar->variable_value =~ /$DASH_D_PATTERN/o))
6142     {
6143         (my $output_base = $output) =~ s/$KNOWN_EXTENSIONS_PATTERN$//;
6144         my $header = $output_base . '.h';
6145
6146         # Found a `-d' that applies to the compilation of this file.
6147         # Add a dependency for the generated header file, and arrange
6148         # for that file to be included in the distribution.
6149         foreach my $cond (Automake::Rule::define (${header}, 'internal',
6150                                                   RULE_AUTOMAKE, TRUE,
6151                                                   INTERNAL))
6152           {
6153             my $condstr = $cond->subst_string;
6154             $output_rules .=
6155               "$condstr${header}: $output\n"
6156               # Recover from removal of $header
6157               . "$condstr\t\@if test ! -f \$@; then rm -f $output; else :; fi\n"
6158               . "$condstr\t\@if test ! -f \$@; then \$(MAKE) \$(AM_MAKEFLAGS) $output; else :; fi\n";
6159           }
6160         # Distribute the generated file, unless its .y source was
6161         # listed in a nodist_ variable.  (&handle_source_transform
6162         # will set DIST_SOURCE.)
6163         &push_dist_common ($header)
6164           if $transform{'DIST_SOURCE'};
6165
6166         # If the files are built in the build directory, then we want
6167         # to remove them with `make clean'.  If they are in srcdir
6168         # they shouldn't be touched.  However, we can't determine this
6169         # statically, and the GNU rules say that yacc/lex output files
6170         # should be removed by maintainer-clean.  So that's what we
6171         # do.
6172         $clean_files{$header} = MAINTAINER_CLEAN;
6173     }
6174     # Erase $OUTPUT on `make maintainer-clean' (by GNU standards).
6175     # See the comment above for $HEADER.
6176     $clean_files{$output} = MAINTAINER_CLEAN;
6177 }
6178
6179 # This is a lex helper which is called whenever we have decided to
6180 # compile a lex file.
6181 sub lang_lex_target_hook
6182 {
6183     my ($self, $aggregate, $output, $input) = @_;
6184     # If the files are built in the build directory, then we want to
6185     # remove them with `make clean'.  If they are in srcdir they
6186     # shouldn't be touched.  However, we can't determine this
6187     # statically, and the GNU rules say that yacc/lex output files
6188     # should be removed by maintainer-clean.  So that's what we do.
6189     $clean_files{$output} = MAINTAINER_CLEAN;
6190 }
6191
6192 # This is a helper for both lex and yacc.
6193 sub yacc_lex_finish_helper
6194 {
6195   return if defined $language_scratch{'lex-yacc-done'};
6196   $language_scratch{'lex-yacc-done'} = 1;
6197
6198   # FIXME: for now, no line number.
6199   require_conf_file ($configure_ac, FOREIGN, 'ylwrap');
6200   &define_variable ('YLWRAP', "$am_config_aux_dir/ylwrap", INTERNAL);
6201 }
6202
6203 sub lang_yacc_finish
6204 {
6205   return if defined $language_scratch{'yacc-done'};
6206   $language_scratch{'yacc-done'} = 1;
6207
6208   reject_var 'YACCFLAGS', "`YACCFLAGS' obsolete; use `YFLAGS' instead";
6209
6210   yacc_lex_finish_helper;
6211 }
6212
6213
6214 sub lang_lex_finish
6215 {
6216   return if defined $language_scratch{'lex-done'};
6217   $language_scratch{'lex-done'} = 1;
6218
6219   yacc_lex_finish_helper;
6220 }
6221
6222
6223 # Given a hash table of linker names, pick the name that has the most
6224 # precedence.  This is lame, but something has to have global
6225 # knowledge in order to eliminate the conflict.  Add more linkers as
6226 # required.
6227 sub resolve_linker
6228 {
6229     my (%linkers) = @_;
6230
6231     foreach my $l (qw(GCJLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
6232     {
6233         return $l if defined $linkers{$l};
6234     }
6235     return 'LINK';
6236 }
6237
6238 # Called to indicate that an extension was used.
6239 sub saw_extension
6240 {
6241     my ($ext) = @_;
6242     if (! defined $extension_seen{$ext})
6243     {
6244         $extension_seen{$ext} = 1;
6245     }
6246     else
6247     {
6248         ++$extension_seen{$ext};
6249     }
6250 }
6251
6252 # Return the number of files seen for a given language.  Knows about
6253 # special cases we care about.  FIXME: this is hideous.  We need
6254 # something that involves real language objects.  For instance yacc
6255 # and yaccxx could both derive from a common yacc class which would
6256 # know about the strange ylwrap requirement.  (Or better yet we could
6257 # just not support legacy yacc!)
6258 sub count_files_for_language
6259 {
6260     my ($name) = @_;
6261
6262     my @names;
6263     if ($name eq 'yacc' || $name eq 'yaccxx')
6264     {
6265         @names = ('yacc', 'yaccxx');
6266     }
6267     elsif ($name eq 'lex' || $name eq 'lexxx')
6268     {
6269         @names = ('lex', 'lexxx');
6270     }
6271     else
6272     {
6273         @names = ($name);
6274     }
6275
6276     my $r = 0;
6277     foreach $name (@names)
6278     {
6279         my $lang = $languages{$name};
6280         foreach my $ext (@{$lang->extensions})
6281         {
6282             $r += $extension_seen{$ext}
6283                 if defined $extension_seen{$ext};
6284         }
6285     }
6286
6287     return $r
6288 }
6289
6290 # Called to ask whether source files have been seen . If HEADERS is 1,
6291 # headers can be included.
6292 sub saw_sources_p
6293 {
6294     my ($headers) = @_;
6295
6296     # count all the sources
6297     my $count = 0;
6298     foreach my $val (values %extension_seen)
6299     {
6300         $count += $val;
6301     }
6302
6303     if (!$headers)
6304     {
6305         $count -= count_files_for_language ('header');
6306     }
6307
6308     return $count > 0;
6309 }
6310
6311
6312 # register_language (%ATTRIBUTE)
6313 # ------------------------------
6314 # Register a single language.
6315 # Each %ATTRIBUTE is of the form ATTRIBUTE => VALUE.
6316 sub register_language (%)
6317 {
6318   my (%option) = @_;
6319
6320   # Set the defaults.
6321   $option{'ansi'} = 0
6322     unless defined $option{'ansi'};
6323   $option{'autodep'} = 'no'
6324     unless defined $option{'autodep'};
6325   $option{'linker'} = ''
6326     unless defined $option{'linker'};
6327   $option{'flags'} = []
6328     unless defined $option{'flags'};
6329   $option{'output_extensions'} = sub { return ( '.$(OBJEXT)', '.lo' ) }
6330     unless defined $option{'output_extensions'};
6331   $option{'nodist_specific'} = 0
6332     unless defined $option{'nodist_specific'};
6333
6334   my $lang = new Language (%option);
6335
6336   # Fill indexes.
6337   $extension_map{$_} = $lang->name foreach @{$lang->extensions};
6338   $languages{$lang->name} = $lang;
6339   my $link = $lang->linker;
6340   if ($link)
6341     {
6342       if (exists $link_languages{$link})
6343         {
6344           prog_error ("`$link' has different definitions in "
6345                       . $lang->name . " and " . $link_languages{$link}->name)
6346             if $lang->link ne $link_languages{$link}->link;
6347         }
6348       else
6349         {
6350           $link_languages{$link} = $lang;
6351         }
6352     }
6353
6354   # Update the pattern of known extensions.
6355   accept_extensions (@{$lang->extensions});
6356
6357   # Upate the $suffix_rule map.
6358   foreach my $suffix (@{$lang->extensions})
6359     {
6360       foreach my $dest (&{$lang->output_extensions} ($suffix))
6361         {
6362           register_suffix_rule (INTERNAL, $suffix, $dest);
6363         }
6364     }
6365 }
6366
6367 # derive_suffix ($EXT, $OBJ)
6368 # --------------------------
6369 # This function is used to find a path from a user-specified suffix $EXT
6370 # to $OBJ or to some other suffix we recognize internally, e.g. `cc'.
6371 sub derive_suffix ($$)
6372 {
6373   my ($source_ext, $obj) = @_;
6374
6375   while (! $extension_map{$source_ext}
6376          && $source_ext ne $obj
6377          && exists $suffix_rules->{$source_ext}
6378          && exists $suffix_rules->{$source_ext}{$obj})
6379     {
6380       $source_ext = $suffix_rules->{$source_ext}{$obj}[0];
6381     }
6382
6383   return $source_ext;
6384 }
6385
6386
6387 ################################################################
6388
6389 # Pretty-print something and append to output_rules.
6390 sub pretty_print_rule
6391 {
6392     $output_rules .= &makefile_wrap (@_);
6393 }
6394
6395
6396 ################################################################
6397
6398
6399 ## -------------------------------- ##
6400 ## Handling the conditional stack.  ##
6401 ## -------------------------------- ##
6402
6403
6404 # $STRING
6405 # make_conditional_string ($NEGATE, $COND)
6406 # ----------------------------------------
6407 sub make_conditional_string ($$)
6408 {
6409   my ($negate, $cond) = @_;
6410   $cond = "${cond}_TRUE"
6411     unless $cond =~ /^TRUE|FALSE$/;
6412   $cond = Automake::Condition::conditional_negate ($cond)
6413     if $negate;
6414   return $cond;
6415 }
6416
6417
6418 my %_am_macro_for_cond =
6419   (
6420   AMDEP => "one of the compiler tests\n"
6421            . "    AC_PROG_CC, AC_PROG_CXX, AC_PROG_CXX, AC_PROG_OBJC,\n"
6422            . "    AM_PROG_AS, AM_PROG_GCJ, AM_PROG_UPC",
6423   am__fastdepCC => 'AC_PROG_CC',
6424   am__fastdepCCAS => 'AM_PROG_AS',
6425   am__fastdepCXX => 'AC_PROG_CXX',
6426   am__fastdepGCJ => 'AM_PROG_GCJ',
6427   am__fastdepOBJC => 'AC_PROG_OBJC',
6428   am__fastdepUPC => 'AM_PROG_UPC'
6429   );
6430
6431 # $COND
6432 # cond_stack_if ($NEGATE, $COND, $WHERE)
6433 # --------------------------------------
6434 sub cond_stack_if ($$$)
6435 {
6436   my ($negate, $cond, $where) = @_;
6437
6438   if (! $configure_cond{$cond} && $cond !~ /^TRUE|FALSE$/)
6439     {
6440       my $text = "$cond does not appear in AM_CONDITIONAL";
6441       my $scope = US_LOCAL;
6442       if (exists $_am_macro_for_cond{$cond})
6443         {
6444           my $mac = $_am_macro_for_cond{$cond};
6445           $text .= "\n  The usual way to define `$cond' is to add ";
6446           $text .= ($mac =~ / /) ? $mac : "`$mac'";
6447           $text .= "\n  to `$configure_ac' and run `aclocal' and `autoconf' again.";
6448           # These warnings appear in Automake files (depend2.am),
6449           # so there is no need to display them more than once:
6450           $scope = US_GLOBAL;
6451         }
6452       error $where, $text, uniq_scope => $scope;
6453     }
6454
6455   push (@cond_stack, make_conditional_string ($negate, $cond));
6456
6457   return new Automake::Condition (@cond_stack);
6458 }
6459
6460
6461 # $COND
6462 # cond_stack_else ($NEGATE, $COND, $WHERE)
6463 # ----------------------------------------
6464 sub cond_stack_else ($$$)
6465 {
6466   my ($negate, $cond, $where) = @_;
6467
6468   if (! @cond_stack)
6469     {
6470       error $where, "else without if";
6471       return FALSE;
6472     }
6473
6474   $cond_stack[$#cond_stack] =
6475     Automake::Condition::conditional_negate ($cond_stack[$#cond_stack]);
6476
6477   # If $COND is given, check against it.
6478   if (defined $cond)
6479     {
6480       $cond = make_conditional_string ($negate, $cond);
6481
6482       error ($where, "else reminder ($negate$cond) incompatible with "
6483              . "current conditional: $cond_stack[$#cond_stack]")
6484         if $cond_stack[$#cond_stack] ne $cond;
6485     }
6486
6487   return new Automake::Condition (@cond_stack);
6488 }
6489
6490
6491 # $COND
6492 # cond_stack_endif ($NEGATE, $COND, $WHERE)
6493 # -----------------------------------------
6494 sub cond_stack_endif ($$$)
6495 {
6496   my ($negate, $cond, $where) = @_;
6497   my $old_cond;
6498
6499   if (! @cond_stack)
6500     {
6501       error $where, "endif without if";
6502       return TRUE;
6503     }
6504
6505   # If $COND is given, check against it.
6506   if (defined $cond)
6507     {
6508       $cond = make_conditional_string ($negate, $cond);
6509
6510       error ($where, "endif reminder ($negate$cond) incompatible with "
6511              . "current conditional: $cond_stack[$#cond_stack]")
6512         if $cond_stack[$#cond_stack] ne $cond;
6513     }
6514
6515   pop @cond_stack;
6516
6517   return new Automake::Condition (@cond_stack);
6518 }
6519
6520
6521
6522
6523
6524 ## ------------------------ ##
6525 ## Handling the variables.  ##
6526 ## ------------------------ ##
6527
6528
6529 # &define_pretty_variable ($VAR, $COND, $WHERE, @VALUE)
6530 # -----------------------------------------------------
6531 # Like define_variable, but the value is a list, and the variable may
6532 # be defined conditionally.  The second argument is the condition
6533 # under which the value should be defined; this should be the empty
6534 # string to define the variable unconditionally.  The third argument
6535 # is a list holding the values to use for the variable.  The value is
6536 # pretty printed in the output file.
6537 sub define_pretty_variable ($$$@)
6538 {
6539     my ($var, $cond, $where, @value) = @_;
6540
6541     if (! vardef ($var, $cond))
6542     {
6543         Automake::Variable::define ($var, VAR_AUTOMAKE, '', $cond, "@value",
6544                                     '', $where, VAR_PRETTY);
6545         rvar ($var)->rdef ($cond)->set_seen;
6546     }
6547 }
6548
6549
6550 # define_variable ($VAR, $VALUE, $WHERE)
6551 # --------------------------------------
6552 # Define a new Automake Makefile variable VAR to VALUE, but only if
6553 # not already defined.
6554 sub define_variable ($$$)
6555 {
6556     my ($var, $value, $where) = @_;
6557     define_pretty_variable ($var, TRUE, $where, $value);
6558 }
6559
6560
6561 # define_files_variable ($VAR, \@BASENAME, $EXTENSION, $WHERE)
6562 # ------------------------------------------------------------
6563 # Define the $VAR which content is the list of file names composed of
6564 # a @BASENAME and the $EXTENSION.
6565 sub define_files_variable ($\@$$)
6566 {
6567   my ($var, $basename, $extension, $where) = @_;
6568   define_variable ($var,
6569                    join (' ', map { "$_.$extension" } @$basename),
6570                    $where);
6571 }
6572
6573
6574 # Like define_variable, but define a variable to be the configure
6575 # substitution by the same name.
6576 sub define_configure_variable ($)
6577 {
6578   my ($var) = @_;
6579
6580   my $pretty = VAR_ASIS;
6581   my $owner = VAR_CONFIGURE;
6582
6583   # Some variables we do not want to output.  For instance it
6584   # would be a bad idea to output `U = @U@` when `@U@` can be
6585   # substituted as `\`.
6586   $pretty = VAR_SILENT if exists $ignored_configure_vars{$var};
6587
6588   # ANSI2KNR is a variable that Automake wants to redefine, so
6589   # it must be owned by Automake.  (It is also used as a proof
6590   # that AM_C_PROTOTYPES has been run, that's why we do not simply
6591   # omit the AC_SUBST.)
6592   $owner = VAR_AUTOMAKE if $var eq 'ANSI2KNR';
6593
6594   Automake::Variable::define ($var, $owner, '', TRUE, subst $var,
6595                               '', $configure_vars{$var}, $pretty);
6596 }
6597
6598
6599 # define_compiler_variable ($LANG)
6600 # --------------------------------
6601 # Define a compiler variable.  We also handle defining the `LT'
6602 # version of the command when using libtool.
6603 sub define_compiler_variable ($)
6604 {
6605     my ($lang) = @_;
6606
6607     my ($var, $value) = ($lang->compiler, $lang->compile);
6608     my $libtool_tag = '';
6609     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6610       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6611     &define_variable ($var, $value, INTERNAL);
6612     if (var ('LIBTOOL'))
6613       {
6614         my $verbose = define_verbose_libtool ();
6615         &define_variable ("LT$var",
6616                           "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6617                           . "\$(LIBTOOLFLAGS) --mode=compile $value",
6618                           INTERNAL);
6619       }
6620     define_verbose_tagvar ($lang->ccer || 'GEN');
6621 }
6622
6623
6624 # define_linker_variable ($LANG)
6625 # ------------------------------
6626 # Define linker variables.
6627 sub define_linker_variable ($)
6628 {
6629     my ($lang) = @_;
6630
6631     my $libtool_tag = '';
6632     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6633       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6634     # CCLD = $(CC).
6635     &define_variable ($lang->lder, $lang->ld, INTERNAL);
6636     # CCLINK = $(CCLD) blah blah...
6637     my $link = '';
6638     if (var ('LIBTOOL'))
6639       {
6640         my $verbose = define_verbose_libtool ();
6641         $link = "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6642                 . "\$(LIBTOOLFLAGS) --mode=link ";
6643       }
6644     &define_variable ($lang->linker, $link . $lang->link, INTERNAL);
6645     &define_variable ($lang->compiler,  $lang);
6646     &define_verbose_tagvar ($lang->lder || 'GEN');
6647 }
6648
6649 sub define_per_target_linker_variable ($$)
6650 {
6651   my ($linker, $target) = @_;
6652
6653   # If the user wrote a custom link command, we don't define ours.
6654   return "${target}_LINK"
6655     if set_seen "${target}_LINK";
6656
6657   my $xlink = $linker ? $linker : 'LINK';
6658
6659   my $lang = $link_languages{$xlink};
6660   prog_error "Unknown language for linker variable `$xlink'"
6661     unless $lang;
6662
6663   my $link_command = $lang->link;
6664   if (var 'LIBTOOL')
6665     {
6666       my $libtool_tag = '';
6667       $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6668         if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6669
6670       my $verbose = define_verbose_libtool ();
6671       $link_command =
6672         "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) \$(LIBTOOLFLAGS) "
6673         . "--mode=link " . $link_command;
6674     }
6675
6676   # Rewrite each occurrence of `AM_$flag' in the link
6677   # command into `${derived}_$flag' if it exists.
6678   my $orig_command = $link_command;
6679   my @flags = (@{$lang->flags}, 'LDFLAGS');
6680   push @flags, 'LIBTOOLFLAGS' if var 'LIBTOOL';
6681   for my $flag (@flags)
6682     {
6683       my $val = "${target}_$flag";
6684       $link_command =~ s/\(AM_$flag\)/\($val\)/
6685         if set_seen ($val);
6686     }
6687
6688   # If the computed command is the same as the generic command, use
6689   # the command linker variable.
6690   return ($lang->linker, $lang->lder)
6691     if $link_command eq $orig_command;
6692
6693   &define_variable ("${target}_LINK", $link_command, INTERNAL);
6694   return ("${target}_LINK", $lang->lder);
6695 }
6696
6697 ################################################################
6698
6699 # &check_trailing_slash ($WHERE, $LINE)
6700 # -------------------------------------
6701 # Return 1 iff $LINE ends with a slash.
6702 # Might modify $LINE.
6703 sub check_trailing_slash ($\$)
6704 {
6705   my ($where, $line) = @_;
6706
6707   # Ignore `##' lines.
6708   return 0 if $$line =~ /$IGNORE_PATTERN/o;
6709
6710   # Catch and fix a common error.
6711   msg "syntax", $where, "whitespace following trailing backslash"
6712     if $$line =~ s/\\\s+\n$/\\\n/;
6713
6714   return $$line =~ /\\$/;
6715 }
6716
6717
6718 # &read_am_file ($AMFILE, $WHERE)
6719 # -------------------------------
6720 # Read Makefile.am and set up %contents.  Simultaneously copy lines
6721 # from Makefile.am into $output_trailer, or define variables as
6722 # appropriate.  NOTE we put rules in the trailer section.  We want
6723 # user rules to come after our generated stuff.
6724 sub read_am_file ($$)
6725 {
6726     my ($amfile, $where) = @_;
6727
6728     my $am_file = new Automake::XFile ("< $amfile");
6729     verb "reading $amfile";
6730
6731     # Keep track of the youngest output dependency.
6732     my $mtime = mtime $amfile;
6733     $output_deps_greatest_timestamp = $mtime
6734       if $mtime > $output_deps_greatest_timestamp;
6735
6736     my $spacing = '';
6737     my $comment = '';
6738     my $blank = 0;
6739     my $saw_bk = 0;
6740     my $var_look = VAR_ASIS;
6741
6742     use constant IN_VAR_DEF => 0;
6743     use constant IN_RULE_DEF => 1;
6744     use constant IN_COMMENT => 2;
6745     my $prev_state = IN_RULE_DEF;
6746
6747     while ($_ = $am_file->getline)
6748     {
6749         $where->set ("$amfile:$.");
6750         if (/$IGNORE_PATTERN/o)
6751         {
6752             # Merely delete comments beginning with two hashes.
6753         }
6754         elsif (/$WHITE_PATTERN/o)
6755         {
6756             error $where, "blank line following trailing backslash"
6757               if $saw_bk;
6758             # Stick a single white line before the incoming macro or rule.
6759             $spacing = "\n";
6760             $blank = 1;
6761             # Flush all comments seen so far.
6762             if ($comment ne '')
6763             {
6764                 $output_vars .= $comment;
6765                 $comment = '';
6766             }
6767         }
6768         elsif (/$COMMENT_PATTERN/o)
6769         {
6770             # Stick comments before the incoming macro or rule.  Make
6771             # sure a blank line precedes the first block of comments.
6772             $spacing = "\n" unless $blank;
6773             $blank = 1;
6774             $comment .= $spacing . $_;
6775             $spacing = '';
6776             $prev_state = IN_COMMENT;
6777         }
6778         else
6779         {
6780             last;
6781         }
6782         $saw_bk = check_trailing_slash ($where, $_);
6783     }
6784
6785     # We save the conditional stack on entry, and then check to make
6786     # sure it is the same on exit.  This lets us conditionally include
6787     # other files.
6788     my @saved_cond_stack = @cond_stack;
6789     my $cond = new Automake::Condition (@cond_stack);
6790
6791     my $last_var_name = '';
6792     my $last_var_type = '';
6793     my $last_var_value = '';
6794     my $last_where;
6795     # FIXME: shouldn't use $_ in this loop; it is too big.
6796     while ($_)
6797     {
6798         $where->set ("$amfile:$.");
6799
6800         # Make sure the line is \n-terminated.
6801         chomp;
6802         $_ .= "\n";
6803
6804         # Don't look at MAINTAINER_MODE_TRUE here.  That shouldn't be
6805         # used by users.  @MAINT@ is an anachronism now.
6806         $_ =~ s/\@MAINT\@//g
6807             unless $seen_maint_mode;
6808
6809         my $new_saw_bk = check_trailing_slash ($where, $_);
6810
6811         if (/$IGNORE_PATTERN/o)
6812         {
6813             # Merely delete comments beginning with two hashes.
6814
6815             # Keep any backslash from the previous line.
6816             $new_saw_bk = $saw_bk;
6817         }
6818         elsif (/$WHITE_PATTERN/o)
6819         {
6820             # Stick a single white line before the incoming macro or rule.
6821             $spacing = "\n";
6822             error $where, "blank line following trailing backslash"
6823               if $saw_bk;
6824         }
6825         elsif (/$COMMENT_PATTERN/o)
6826         {
6827             error $where, "comment following trailing backslash"
6828               if $saw_bk && $prev_state != IN_COMMENT;
6829
6830             # Stick comments before the incoming macro or rule.
6831             $comment .= $spacing . $_;
6832             $spacing = '';
6833             $prev_state = IN_COMMENT;
6834         }
6835         elsif ($saw_bk)
6836         {
6837             if ($prev_state == IN_RULE_DEF)
6838             {
6839               my $cond = new Automake::Condition @cond_stack;
6840               $output_trailer .= $cond->subst_string;
6841               $output_trailer .= $_;
6842             }
6843             elsif ($prev_state == IN_COMMENT)
6844             {
6845                 # If the line doesn't start with a `#', add it.
6846                 # We do this because a continued comment like
6847                 #   # A = foo \
6848                 #         bar \
6849                 #         baz
6850                 # is not portable.  BSD make doesn't honor
6851                 # escaped newlines in comments.
6852                 s/^#?/#/;
6853                 $comment .= $spacing . $_;
6854             }
6855             else # $prev_state == IN_VAR_DEF
6856             {
6857               $last_var_value .= ' '
6858                 unless $last_var_value =~ /\s$/;
6859               $last_var_value .= $_;
6860
6861               if (!/\\$/)
6862                 {
6863                   Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6864                                               $last_var_type, $cond,
6865                                               $last_var_value, $comment,
6866                                               $last_where, VAR_ASIS)
6867                     if $cond != FALSE;
6868                   $comment = $spacing = '';
6869                 }
6870             }
6871         }
6872
6873         elsif (/$IF_PATTERN/o)
6874           {
6875             $cond = cond_stack_if ($1, $2, $where);
6876           }
6877         elsif (/$ELSE_PATTERN/o)
6878           {
6879             $cond = cond_stack_else ($1, $2, $where);
6880           }
6881         elsif (/$ENDIF_PATTERN/o)
6882           {
6883             $cond = cond_stack_endif ($1, $2, $where);
6884           }
6885
6886         elsif (/$RULE_PATTERN/o)
6887         {
6888             # Found a rule.
6889             $prev_state = IN_RULE_DEF;
6890
6891             # For now we have to output all definitions of user rules
6892             # and can't diagnose duplicates (see the comment in
6893             # Automake::Rule::define). So we go on and ignore the return value.
6894             Automake::Rule::define ($1, $amfile, RULE_USER, $cond, $where);
6895
6896             check_variable_expansions ($_, $where);
6897
6898             $output_trailer .= $comment . $spacing;
6899             my $cond = new Automake::Condition @cond_stack;
6900             $output_trailer .= $cond->subst_string;
6901             $output_trailer .= $_;
6902             $comment = $spacing = '';
6903         }
6904         elsif (/$ASSIGNMENT_PATTERN/o)
6905         {
6906             # Found a macro definition.
6907             $prev_state = IN_VAR_DEF;
6908             $last_var_name = $1;
6909             $last_var_type = $2;
6910             $last_var_value = $3;
6911             $last_where = $where->clone;
6912             if ($3 ne '' && substr ($3, -1) eq "\\")
6913               {
6914                 # We preserve the `\' because otherwise the long lines
6915                 # that are generated will be truncated by broken
6916                 # `sed's.
6917                 $last_var_value = $3 . "\n";
6918               }
6919             # Normally we try to output variable definitions in the
6920             # same format they were input.  However, POSIX compliant
6921             # systems are not required to support lines longer than
6922             # 2048 bytes (most notably, some sed implementation are
6923             # limited to 4000 bytes, and sed is used by config.status
6924             # to rewrite Makefile.in into Makefile).  Moreover nobody
6925             # would really write such long lines by hand since it is
6926             # hardly maintainable.  So if a line is longer that 1000
6927             # bytes (an arbitrary limit), assume it has been
6928             # automatically generated by some tools, and flatten the
6929             # variable definition.  Otherwise, keep the variable as it
6930             # as been input.
6931             $var_look = VAR_PRETTY if length ($last_var_value) >= 1000;
6932
6933             if (!/\\$/)
6934               {
6935                 Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6936                                             $last_var_type, $cond,
6937                                             $last_var_value, $comment,
6938                                             $last_where, $var_look)
6939                   if $cond != FALSE;
6940                 $comment = $spacing = '';
6941                 $var_look = VAR_ASIS;
6942               }
6943         }
6944         elsif (/$INCLUDE_PATTERN/o)
6945         {
6946             my $path = $1;
6947
6948             if ($path =~ s/^\$\(top_srcdir\)\///)
6949               {
6950                 push (@include_stack, "\$\(top_srcdir\)/$path");
6951                 # Distribute any included file.
6952
6953                 # Always use the $(top_srcdir) prefix in DIST_COMMON,
6954                 # otherwise OSF make will implicitly copy the included
6955                 # file in the build tree during `make distdir' to satisfy
6956                 # the dependency.
6957                 # (subdircond2.test and subdircond3.test will fail.)
6958                 push_dist_common ("\$\(top_srcdir\)/$path");
6959               }
6960             else
6961               {
6962                 $path =~ s/\$\(srcdir\)\///;
6963                 push (@include_stack, "\$\(srcdir\)/$path");
6964                 # Always use the $(srcdir) prefix in DIST_COMMON,
6965                 # otherwise OSF make will implicitly copy the included
6966                 # file in the build tree during `make distdir' to satisfy
6967                 # the dependency.
6968                 # (subdircond2.test and subdircond3.test will fail.)
6969                 push_dist_common ("\$\(srcdir\)/$path");
6970                 $path = $relative_dir . "/" . $path if $relative_dir ne '.';
6971               }
6972             $where->push_context ("`$path' included from here");
6973             &read_am_file ($path, $where);
6974             $where->pop_context;
6975         }
6976         else
6977         {
6978             # This isn't an error; it is probably a continued rule.
6979             # In fact, this is what we assume.
6980             $prev_state = IN_RULE_DEF;
6981             check_variable_expansions ($_, $where);
6982             $output_trailer .= $comment . $spacing;
6983             my $cond = new Automake::Condition @cond_stack;
6984             $output_trailer .= $cond->subst_string;
6985             $output_trailer .= $_;
6986             $comment = $spacing = '';
6987             error $where, "`#' comment at start of rule is unportable"
6988               if $_ =~ /^\t\s*\#/;
6989         }
6990
6991         $saw_bk = $new_saw_bk;
6992         $_ = $am_file->getline;
6993     }
6994
6995     $output_trailer .= $comment;
6996
6997     error ($where, "trailing backslash on last line")
6998       if $saw_bk;
6999
7000     error ($where, (@cond_stack ? "unterminated conditionals: @cond_stack"
7001                     : "too many conditionals closed in include file"))
7002       if "@saved_cond_stack" ne "@cond_stack";
7003 }
7004
7005
7006 # define_standard_variables ()
7007 # ----------------------------
7008 # A helper for read_main_am_file which initializes configure variables
7009 # and variables from header-vars.am.
7010 sub define_standard_variables
7011 {
7012   my $saved_output_vars = $output_vars;
7013   my ($comments, undef, $rules) =
7014     file_contents_internal (1, "$libdir/am/header-vars.am",
7015                             new Automake::Location);
7016
7017   foreach my $var (sort keys %configure_vars)
7018     {
7019       &define_configure_variable ($var);
7020     }
7021
7022   $output_vars .= $comments . $rules;
7023 }
7024
7025 # Read main am file.
7026 sub read_main_am_file
7027 {
7028     my ($amfile) = @_;
7029
7030     # This supports the strange variable tricks we are about to play.
7031     prog_error ("variable defined before read_main_am_file\n" . variables_dump ())
7032       if (scalar (variables) > 0);
7033
7034     # Generate copyright header for generated Makefile.in.
7035     # We do discard the output of predefined variables, handled below.
7036     $output_vars = ("# $in_file_name generated by automake "
7037                    . $VERSION . " from $am_file_name.\n");
7038     $output_vars .= '# ' . subst ('configure_input') . "\n";
7039     $output_vars .= $gen_copyright;
7040
7041     # We want to predefine as many variables as possible.  This lets
7042     # the user set them with `+=' in Makefile.am.
7043     &define_standard_variables;
7044
7045     # Read user file, which might override some of our values.
7046     &read_am_file ($amfile, new Automake::Location);
7047 }
7048
7049
7050
7051 ################################################################
7052
7053 # $FLATTENED
7054 # &flatten ($STRING)
7055 # ------------------
7056 # Flatten the $STRING and return the result.
7057 sub flatten
7058 {
7059   $_ = shift;
7060
7061   s/\\\n//somg;
7062   s/\s+/ /g;
7063   s/^ //;
7064   s/ $//;
7065
7066   return $_;
7067 }
7068
7069
7070 # transform_token ($TOKEN, \%PAIRS, $KEY)
7071 # =======================================
7072 # Return the value associated to $KEY in %PAIRS, as used on $TOKEN
7073 # (which should be ?KEY? or any of the special %% requests)..
7074 sub transform_token ($$$)
7075 {
7076   my ($token, $transform, $key) = @_;
7077   my $res = $transform->{$key};
7078   prog_error "Unknown key `$key' in `$token'" unless defined $res;
7079   return $res;
7080 }
7081
7082
7083 # transform ($TOKEN, \%PAIRS)
7084 # ===========================
7085 # If ($TOKEN, $VAL) is in %PAIRS:
7086 #   - replaces %KEY% with $VAL,
7087 #   - enables/disables ?KEY? and ?!KEY?,
7088 #   - replaces %?KEY% with TRUE or FALSE.
7089 #   - replaces %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE% with
7090 #     IFTRUE / IFFALSE, as appropriate.
7091 sub transform ($$)
7092 {
7093   my ($token, $transform) = @_;
7094
7095   # %KEY%.
7096   # Must be before the following pattern to exclude the case
7097   # when there is neither IFTRUE nor IFFALSE.
7098   if ($token =~ /^%([\w\-]+)%$/)
7099     {
7100       return transform_token ($token, $transform, $1);
7101     }
7102   # %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE%.
7103   elsif ($token =~ /^%([\w\-]+)(?:\?([^?:%]+))?(?::([^?:%]+))?%$/)
7104     {
7105       return transform_token ($token, $transform, $1) ? ($2 || '') : ($3 || '');
7106     }
7107   # %?KEY%.
7108   elsif ($token =~ /^%\?([\w\-]+)%$/)
7109     {
7110       return transform_token ($token, $transform, $1) ? 'TRUE' : 'FALSE';
7111     }
7112   # ?KEY? and ?!KEY?.
7113   elsif ($token =~ /^ \? (!?) ([\w\-]+) \? $/x)
7114     {
7115       my $neg = ($1 eq '!') ? 1 : 0;
7116       my $val = transform_token ($token, $transform, $2);
7117       return (!!$val == $neg) ? '##%' : '';
7118     }
7119   else
7120     {
7121       prog_error "Unknown request format: $token";
7122     }
7123 }
7124
7125
7126 # @PARAGRAPHS
7127 # &make_paragraphs ($MAKEFILE, [%TRANSFORM])
7128 # ------------------------------------------
7129 # Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
7130 # paragraphs.
7131 sub make_paragraphs ($%)
7132 {
7133   my ($file, %transform) = @_;
7134
7135   # Complete %transform with global options.
7136   # Note that %transform goes last, so it overrides global options.
7137   %transform = ('CYGNUS'      => !! option 'cygnus',
7138                  'MAINTAINER-MODE'
7139                  => $seen_maint_mode ? subst ('MAINTAINER_MODE_TRUE') : '',
7140
7141                  'XZ'          => !! option 'dist-xz',
7142                  'LZMA'        => !! option 'dist-lzma',
7143                  'BZIP2'       => !! option 'dist-bzip2',
7144                  'COMPRESS'    => !! option 'dist-tarZ',
7145                  'GZIP'        =>  ! option 'no-dist-gzip',
7146                  'SHAR'        => !! option 'dist-shar',
7147                  'ZIP'         => !! option 'dist-zip',
7148
7149                  'INSTALL-INFO' =>  ! option 'no-installinfo',
7150                  'INSTALL-MAN'  =>  ! option 'no-installman',
7151                  'HAVE-MANS'    => !! var ('MANS'),
7152                  'CK-NEWS'      => !! option 'check-news',
7153
7154                  'SUBDIRS'      => !! var ('SUBDIRS'),
7155                  'TOPDIR_P'     => $relative_dir eq '.',
7156
7157                  'BUILD'    => ($seen_canonical >= AC_CANONICAL_BUILD),
7158                  'HOST'     => ($seen_canonical >= AC_CANONICAL_HOST),
7159                  'TARGET'   => ($seen_canonical >= AC_CANONICAL_TARGET),
7160
7161                  'LIBTOOL'      => !! var ('LIBTOOL'),
7162                  'NONLIBTOOL'   => 1,
7163                  'FIRST'        => ! $transformed_files{$file},
7164                 %transform);
7165
7166   $transformed_files{$file} = 1;
7167   $_ = $am_file_cache{$file};
7168
7169   if (! defined $_)
7170     {
7171       verb "reading $file";
7172       # Swallow the whole file.
7173       my $fc_file = new Automake::XFile "< $file";
7174       my $saved_dollar_slash = $/;
7175       undef $/;
7176       $_ = $fc_file->getline;
7177       $/ = $saved_dollar_slash;
7178       $fc_file->close;
7179
7180       # Remove ##-comments.
7181       # Besides we don't need more than two consecutive new-lines.
7182       s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
7183
7184       $am_file_cache{$file} = $_;
7185     }
7186
7187   # Substitute Automake template tokens.
7188   s/(?: % \?? [\w\-]+ %
7189       | % [\w\-]+ (?:\?[^?:%]+)? (?::[^?:%]+)? %
7190       | \? !? [\w\-]+ \?
7191     )/transform($&, \%transform)/gex;
7192   # transform() may have added some ##%-comments to strip.
7193   # (we use `##%' instead of `##' so we can distinguish ##%##%##% from
7194   # ####### and do not remove the latter.)
7195   s/^[ \t]*(?:##%)+.*\n//gm;
7196
7197   # Split at unescaped new lines.
7198   my @lines = split (/(?<!\\)\n/, $_);
7199   my @res;
7200
7201   while (defined ($_ = shift @lines))
7202     {
7203       my $paragraph = $_;
7204       # If we are a rule, eat as long as we start with a tab.
7205       if (/$RULE_PATTERN/smo)
7206         {
7207           while (defined ($_ = shift @lines) && $_ =~ /^\t/)
7208             {
7209               $paragraph .= "\n$_";
7210             }
7211           unshift (@lines, $_);
7212         }
7213
7214       # If we are a comments, eat as much comments as you can.
7215       elsif (/$COMMENT_PATTERN/smo)
7216         {
7217           while (defined ($_ = shift @lines)
7218                  && $_ =~ /$COMMENT_PATTERN/smo)
7219             {
7220               $paragraph .= "\n$_";
7221             }
7222           unshift (@lines, $_);
7223         }
7224
7225       push @res, $paragraph;
7226     }
7227
7228   return @res;
7229 }
7230
7231
7232
7233 # ($COMMENT, $VARIABLES, $RULES)
7234 # &file_contents_internal ($IS_AM, $FILE, $WHERE, [%TRANSFORM])
7235 # -------------------------------------------------------------
7236 # Return contents of a file from $libdir/am, automatically skipping
7237 # macros or rules which are already known. $IS_AM iff the caller is
7238 # reading an Automake file (as opposed to the user's Makefile.am).
7239 sub file_contents_internal ($$$%)
7240 {
7241     my ($is_am, $file, $where, %transform) = @_;
7242
7243     $where->set ($file);
7244
7245     my $result_vars = '';
7246     my $result_rules = '';
7247     my $comment = '';
7248     my $spacing = '';
7249
7250     # The following flags are used to track rules spanning across
7251     # multiple paragraphs.
7252     my $is_rule = 0;            # 1 if we are processing a rule.
7253     my $discard_rule = 0;       # 1 if the current rule should not be output.
7254
7255     # We save the conditional stack on entry, and then check to make
7256     # sure it is the same on exit.  This lets us conditionally include
7257     # other files.
7258     my @saved_cond_stack = @cond_stack;
7259     my $cond = new Automake::Condition (@cond_stack);
7260
7261     foreach (make_paragraphs ($file, %transform))
7262     {
7263         # FIXME: no line number available.
7264         $where->set ($file);
7265
7266         # Sanity checks.
7267         error $where, "blank line following trailing backslash:\n$_"
7268           if /\\$/;
7269         error $where, "comment following trailing backslash:\n$_"
7270           if /\\#/;
7271
7272         if (/^$/)
7273         {
7274             $is_rule = 0;
7275             # Stick empty line before the incoming macro or rule.
7276             $spacing = "\n";
7277         }
7278         elsif (/$COMMENT_PATTERN/mso)
7279         {
7280             $is_rule = 0;
7281             # Stick comments before the incoming macro or rule.
7282             $comment = "$_\n";
7283         }
7284
7285         # Handle inclusion of other files.
7286         elsif (/$INCLUDE_PATTERN/o)
7287         {
7288             if ($cond != FALSE)
7289               {
7290                 my $file = ($is_am ? "$libdir/am/" : '') . $1;
7291                 $where->push_context ("`$file' included from here");
7292                 # N-ary `.=' fails.
7293                 my ($com, $vars, $rules)
7294                   = file_contents_internal ($is_am, $file, $where, %transform);
7295                 $where->pop_context;
7296                 $comment .= $com;
7297                 $result_vars .= $vars;
7298                 $result_rules .= $rules;
7299               }
7300         }
7301
7302         # Handling the conditionals.
7303         elsif (/$IF_PATTERN/o)
7304           {
7305             $cond = cond_stack_if ($1, $2, $file);
7306           }
7307         elsif (/$ELSE_PATTERN/o)
7308           {
7309             $cond = cond_stack_else ($1, $2, $file);
7310           }
7311         elsif (/$ENDIF_PATTERN/o)
7312           {
7313             $cond = cond_stack_endif ($1, $2, $file);
7314           }
7315
7316         # Handling rules.
7317         elsif (/$RULE_PATTERN/mso)
7318         {
7319           $is_rule = 1;
7320           $discard_rule = 0;
7321           # Separate relationship from optional actions: the first
7322           # `new-line tab" not preceded by backslash (continuation
7323           # line).
7324           my $paragraph = $_;
7325           /^(.*?)(?:(?<!\\)\n(\t.*))?$/s;
7326           my ($relationship, $actions) = ($1, $2 || '');
7327
7328           # Separate targets from dependencies: the first colon.
7329           $relationship =~ /^([^:]+\S+) *: *(.*)$/som;
7330           my ($targets, $dependencies) = ($1, $2);
7331           # Remove the escaped new lines.
7332           # I don't know why, but I have to use a tmp $flat_deps.
7333           my $flat_deps = &flatten ($dependencies);
7334           my @deps = split (' ', $flat_deps);
7335
7336           foreach (split (' ', $targets))
7337             {
7338               # FIXME: 1. We are not robust to people defining several targets
7339               # at once, only some of them being in %dependencies.  The
7340               # actions from the targets in %dependencies are usually generated
7341               # from the content of %actions, but if some targets in $targets
7342               # are not in %dependencies the ELSE branch will output
7343               # a rule for all $targets (i.e. the targets which are both
7344               # in %dependencies and $targets will have two rules).
7345
7346               # FIXME: 2. The logic here is not able to output a
7347               # multi-paragraph rule several time (e.g. for each condition
7348               # it is defined for) because it only knows the first paragraph.
7349
7350               # FIXME: 3. We are not robust to people defining a subset
7351               # of a previously defined "multiple-target" rule.  E.g.
7352               # `foo:' after `foo bar:'.
7353
7354               # Output only if not in FALSE.
7355               if (defined $dependencies{$_} && $cond != FALSE)
7356                 {
7357                   &depend ($_, @deps);
7358                   register_action ($_, $actions);
7359                 }
7360               else
7361                 {
7362                   # Free-lance dependency.  Output the rule for all the
7363                   # targets instead of one by one.
7364                   my @undefined_conds =
7365                     Automake::Rule::define ($targets, $file,
7366                                             $is_am ? RULE_AUTOMAKE : RULE_USER,
7367                                             $cond, $where);
7368                   for my $undefined_cond (@undefined_conds)
7369                     {
7370                       my $condparagraph = $paragraph;
7371                       $condparagraph =~ s/^/$undefined_cond->subst_string/gme;
7372                       $result_rules .= "$spacing$comment$condparagraph\n";
7373                     }
7374                   if (scalar @undefined_conds == 0)
7375                     {
7376                       # Remember to discard next paragraphs
7377                       # if they belong to this rule.
7378                       # (but see also FIXME: #2 above.)
7379                       $discard_rule = 1;
7380                     }
7381                   $comment = $spacing = '';
7382                   last;
7383                 }
7384             }
7385         }
7386
7387         elsif (/$ASSIGNMENT_PATTERN/mso)
7388         {
7389             my ($var, $type, $val) = ($1, $2, $3);
7390             error $where, "variable `$var' with trailing backslash"
7391               if /\\$/;
7392
7393             $is_rule = 0;
7394
7395             Automake::Variable::define ($var,
7396                                         $is_am ? VAR_AUTOMAKE : VAR_MAKEFILE,
7397                                         $type, $cond, $val, $comment, $where,
7398                                         VAR_ASIS)
7399               if $cond != FALSE;
7400
7401             $comment = $spacing = '';
7402         }
7403         else
7404         {
7405             # This isn't an error; it is probably some tokens which
7406             # configure is supposed to replace, such as `@SET-MAKE@',
7407             # or some part of a rule cut by an if/endif.
7408             if (! $cond->false && ! ($is_rule && $discard_rule))
7409               {
7410                 s/^/$cond->subst_string/gme;
7411                 $result_rules .= "$spacing$comment$_\n";
7412               }
7413             $comment = $spacing = '';
7414         }
7415     }
7416
7417     error ($where, @cond_stack ?
7418            "unterminated conditionals: @cond_stack" :
7419            "too many conditionals closed in include file")
7420       if "@saved_cond_stack" ne "@cond_stack";
7421
7422     return ($comment, $result_vars, $result_rules);
7423 }
7424
7425
7426 # $CONTENTS
7427 # &file_contents ($BASENAME, $WHERE, [%TRANSFORM])
7428 # ------------------------------------------------
7429 # Return contents of a file from $libdir/am, automatically skipping
7430 # macros or rules which are already known.
7431 sub file_contents ($$%)
7432 {
7433     my ($basename, $where, %transform) = @_;
7434     my ($comments, $variables, $rules) =
7435       file_contents_internal (1, "$libdir/am/$basename.am", $where,
7436                               %transform);
7437     return "$comments$variables$rules";
7438 }
7439
7440
7441 # @PREFIX
7442 # &am_primary_prefixes ($PRIMARY, $CAN_DIST, @PREFIXES)
7443 # -----------------------------------------------------
7444 # Find all variable prefixes that are used for install directories.  A
7445 # prefix `zar' qualifies iff:
7446 #
7447 # * `zardir' is a variable.
7448 # * `zar_PRIMARY' is a variable.
7449 #
7450 # As a side effect, it looks for misspellings.  It is an error to have
7451 # a variable ending in a "reserved" suffix whose prefix is unknown, e.g.
7452 # "bni_PROGRAMS".  However, unusual prefixes are allowed if a variable
7453 # of the same name (with "dir" appended) exists.  For instance, if the
7454 # variable "zardir" is defined, then "zar_PROGRAMS" becomes valid.
7455 # This is to provide a little extra flexibility in those cases which
7456 # need it.
7457 sub am_primary_prefixes ($$@)
7458 {
7459   my ($primary, $can_dist, @prefixes) = @_;
7460
7461   local $_;
7462   my %valid = map { $_ => 0 } @prefixes;
7463   $valid{'EXTRA'} = 0;
7464   foreach my $var (variables $primary)
7465     {
7466       # Automake is allowed to define variables that look like primaries
7467       # but which aren't.  E.g. INSTALL_sh_DATA.
7468       # Autoconf can also define variables like INSTALL_DATA, so
7469       # ignore all configure variables (at least those which are not
7470       # redefined in Makefile.am).
7471       # FIXME: We should make sure that these variables are not
7472       # conditionally defined (or else adjust the condition below).
7473       my $def = $var->def (TRUE);
7474       next if $def && $def->owner != VAR_MAKEFILE;
7475
7476       my $varname = $var->name;
7477
7478       if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_[[:alnum:]]+$/)
7479         {
7480           my ($base, $dist, $X) = ($1 || '', $2 || '', $3 || '');
7481           if ($dist ne '' && ! $can_dist)
7482             {
7483               err_var ($var,
7484                        "invalid variable `$varname': `dist' is forbidden");
7485             }
7486           # Standard directories must be explicitly allowed.
7487           elsif (! defined $valid{$X} && exists $standard_prefix{$X})
7488             {
7489               err_var ($var,
7490                        "`${X}dir' is not a legitimate directory " .
7491                        "for `$primary'");
7492             }
7493           # A not explicitly valid directory is allowed if Xdir is defined.
7494           elsif (! defined $valid{$X} &&
7495                  $var->requires_variables ("`$varname' is used", "${X}dir"))
7496             {
7497               # Nothing to do.  Any error message has been output
7498               # by $var->requires_variables.
7499             }
7500           else
7501             {
7502               # Ensure all extended prefixes are actually used.
7503               $valid{"$base$dist$X"} = 1;
7504             }
7505         }
7506       else
7507         {
7508           prog_error "unexpected variable name: $varname";
7509         }
7510     }
7511
7512   # Return only those which are actually defined.
7513   return sort grep { var ($_ . '_' . $primary) } keys %valid;
7514 }
7515
7516
7517 # Handle `where_HOW' variable magic.  Does all lookups, generates
7518 # install code, and possibly generates code to define the primary
7519 # variable.  The first argument is the name of the .am file to munge,
7520 # the second argument is the primary variable (e.g. HEADERS), and all
7521 # subsequent arguments are possible installation locations.
7522 #
7523 # Returns list of [$location, $value] pairs, where
7524 # $value's are the values in all where_HOW variable, and $location
7525 # there associated location (the place here their parent variables were
7526 # defined).
7527 #
7528 # FIXME: this should be rewritten to be cleaner.  It should be broken
7529 # up into multiple functions.
7530 #
7531 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7532 sub am_install_var
7533 {
7534   my (@args) = @_;
7535
7536   my $do_require = 1;
7537   my $can_dist = 0;
7538   my $default_dist = 0;
7539   while (@args)
7540     {
7541       if ($args[0] eq '-noextra')
7542         {
7543           $do_require = 0;
7544         }
7545       elsif ($args[0] eq '-candist')
7546         {
7547           $can_dist = 1;
7548         }
7549       elsif ($args[0] eq '-defaultdist')
7550         {
7551           $default_dist = 1;
7552           $can_dist = 1;
7553         }
7554       elsif ($args[0] !~ /^-/)
7555         {
7556           last;
7557         }
7558       shift (@args);
7559     }
7560
7561   my ($file, $primary, @prefix) = @args;
7562
7563   # Now that configure substitutions are allowed in where_HOW
7564   # variables, it is an error to actually define the primary.  We
7565   # allow `JAVA', as it is customarily used to mean the Java
7566   # interpreter.  This is but one of several Java hacks.  Similarly,
7567   # `PYTHON' is customarily used to mean the Python interpreter.
7568   reject_var $primary, "`$primary' is an anachronism"
7569     unless $primary eq 'JAVA' || $primary eq 'PYTHON';
7570
7571   # Get the prefixes which are valid and actually used.
7572   @prefix = am_primary_prefixes ($primary, $can_dist, @prefix);
7573
7574   # If a primary includes a configure substitution, then the EXTRA_
7575   # form is required.  Otherwise we can't properly do our job.
7576   my $require_extra;
7577
7578   my @used = ();
7579   my @result = ();
7580
7581   foreach my $X (@prefix)
7582     {
7583       my $nodir_name = $X;
7584       my $one_name = $X . '_' . $primary;
7585       my $one_var = var $one_name;
7586
7587       my $strip_subdir = 1;
7588       # If subdir prefix should be preserved, do so.
7589       if ($nodir_name =~ /^nobase_/)
7590         {
7591           $strip_subdir = 0;
7592           $nodir_name =~ s/^nobase_//;
7593         }
7594
7595       # If files should be distributed, do so.
7596       my $dist_p = 0;
7597       if ($can_dist)
7598         {
7599           $dist_p = (($default_dist && $nodir_name !~ /^nodist_/)
7600                      || (! $default_dist && $nodir_name =~ /^dist_/));
7601           $nodir_name =~ s/^(dist|nodist)_//;
7602         }
7603
7604
7605       # Use the location of the currently processed variable.
7606       # We are not processing a particular condition, so pick the first
7607       # available.
7608       my $tmpcond = $one_var->conditions->one_cond;
7609       my $where = $one_var->rdef ($tmpcond)->location->clone;
7610
7611       # Append actual contents of where_PRIMARY variable to
7612       # @result, skipping @substitutions@.
7613       foreach my $locvals ($one_var->value_as_list_recursive (location => 1))
7614         {
7615           my ($loc, $value) = @$locvals;
7616           # Skip configure substitutions.
7617           if ($value =~ /^\@.*\@$/)
7618             {
7619               if ($nodir_name eq 'EXTRA')
7620                 {
7621                   error ($where,
7622                          "`$one_name' contains configure substitution, "
7623                          . "but shouldn't");
7624                 }
7625               # Check here to make sure variables defined in
7626               # configure.ac do not imply that EXTRA_PRIMARY
7627               # must be defined.
7628               elsif (! defined $configure_vars{$one_name})
7629                 {
7630                   $require_extra = $one_name
7631                     if $do_require;
7632                 }
7633             }
7634           else
7635             {
7636               # Strip any $(EXEEXT) suffix the user might have added, or this
7637               # will confuse &handle_source_transform and &check_canonical_spelling.
7638               # We'll add $(EXEEXT) back later anyway.
7639               # Do it here rather than in handle_programs so the uniquifying at the
7640               # end of this function works.
7641               ${$locvals}[1] =~ s/\$\(EXEEXT\)$//
7642                 if $primary eq 'PROGRAMS';
7643
7644               push (@result, $locvals);
7645             }
7646         }
7647       # A blatant hack: we rewrite each _PROGRAMS primary to include
7648       # EXEEXT.
7649       append_exeext { 1 } $one_name
7650         if $primary eq 'PROGRAMS';
7651       # "EXTRA" shouldn't be used when generating clean targets,
7652       # all, or install targets.  We used to warn if EXTRA_FOO was
7653       # defined uselessly, but this was annoying.
7654       next
7655         if $nodir_name eq 'EXTRA';
7656
7657       if ($nodir_name eq 'check')
7658         {
7659           push (@check, '$(' . $one_name . ')');
7660         }
7661       else
7662         {
7663           push (@used, '$(' . $one_name . ')');
7664         }
7665
7666       # Is this to be installed?
7667       my $install_p = $nodir_name ne 'noinst' && $nodir_name ne 'check';
7668
7669       # If so, with install-exec? (or install-data?).
7670       my $exec_p = ($nodir_name =~ /$EXEC_DIR_PATTERN/o);
7671
7672       my $check_options_p = $install_p && !! option 'std-options';
7673
7674       # Use the location of the currently processed variable as context.
7675       $where->push_context ("while processing `$one_name'");
7676
7677       # The variable containing all files to distribute.
7678       my $distvar = "\$($one_name)";
7679       $distvar = shadow_unconditionally ($one_name, $where)
7680         if ($dist_p && $one_var->has_conditional_contents);
7681
7682       # Singular form of $PRIMARY.
7683       (my $one_primary = $primary) =~ s/S$//;
7684       $output_rules .= &file_contents ($file, $where,
7685                                        PRIMARY     => $primary,
7686                                        ONE_PRIMARY => $one_primary,
7687                                        DIR         => $X,
7688                                        NDIR        => $nodir_name,
7689                                        BASE        => $strip_subdir,
7690
7691                                        EXEC      => $exec_p,
7692                                        INSTALL   => $install_p,
7693                                        DIST      => $dist_p,
7694                                        DISTVAR   => $distvar,
7695                                        'CK-OPTS' => $check_options_p);
7696     }
7697
7698   # The JAVA variable is used as the name of the Java interpreter.
7699   # The PYTHON variable is used as the name of the Python interpreter.
7700   if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7701     {
7702       # Define it.
7703       define_pretty_variable ($primary, TRUE, INTERNAL, @used);
7704       $output_vars .= "\n";
7705     }
7706
7707   err_var ($require_extra,
7708            "`$require_extra' contains configure substitution,\n"
7709            . "but `EXTRA_$primary' not defined")
7710     if ($require_extra && ! var ('EXTRA_' . $primary));
7711
7712   # Push here because PRIMARY might be configure time determined.
7713   push (@all, '$(' . $primary . ')')
7714     if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7715
7716   # Make the result unique.  This lets the user use conditionals in
7717   # a natural way, but still lets us program lazily -- we don't have
7718   # to worry about handling a particular object more than once.
7719   # We will keep only one location per object.
7720   my %result = ();
7721   for my $pair (@result)
7722     {
7723       my ($loc, $val) = @$pair;
7724       $result{$val} = $loc;
7725     }
7726   my @l = sort keys %result;
7727   return map { [$result{$_}->clone, $_] } @l;
7728 }
7729
7730
7731 ################################################################
7732
7733 # Each key in this hash is the name of a directory holding a
7734 # Makefile.in.  These variables are local to `is_make_dir'.
7735 my %make_dirs = ();
7736 my $make_dirs_set = 0;
7737
7738 sub is_make_dir
7739 {
7740     my ($dir) = @_;
7741     if (! $make_dirs_set)
7742     {
7743         foreach my $iter (@configure_input_files)
7744         {
7745             $make_dirs{dirname ($iter)} = 1;
7746         }
7747         # We also want to notice Makefile.in's.
7748         foreach my $iter (@other_input_files)
7749         {
7750             if ($iter =~ /Makefile\.in$/)
7751             {
7752                 $make_dirs{dirname ($iter)} = 1;
7753             }
7754         }
7755         $make_dirs_set = 1;
7756     }
7757     return defined $make_dirs{$dir};
7758 }
7759
7760 ################################################################
7761
7762 # Find the aux dir.  This should match the algorithm used by
7763 # ./configure. (See the Autoconf documentation for for
7764 # AC_CONFIG_AUX_DIR.)
7765 sub locate_aux_dir ()
7766 {
7767   if (! $config_aux_dir_set_in_configure_ac)
7768     {
7769       # The default auxiliary directory is the first
7770       # of ., .., or ../.. that contains install-sh.
7771       # Assume . if install-sh doesn't exist yet.
7772       for my $dir (qw (. .. ../..))
7773         {
7774           if (-f "$dir/install-sh")
7775             {
7776               $config_aux_dir = $dir;
7777               last;
7778             }
7779         }
7780       $config_aux_dir = '.' unless $config_aux_dir;
7781     }
7782   # Avoid unsightly '/.'s.
7783   $am_config_aux_dir =
7784     '$(top_srcdir)' . ($config_aux_dir eq '.' ? "" : "/$config_aux_dir");
7785   $am_config_aux_dir =~ s,/*$,,;
7786 }
7787
7788
7789 # &maybe_push_required_file ($DIR, $FILE, $FULLFILE)
7790 # --------------------------------------------------
7791 # See if we want to push this file onto dist_common.  This function
7792 # encodes the rules for deciding when to do so.
7793 sub maybe_push_required_file
7794 {
7795   my ($dir, $file, $fullfile) = @_;
7796
7797   if ($dir eq $relative_dir)
7798     {
7799       push_dist_common ($file);
7800       return 1;
7801     }
7802   elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7803     {
7804       # If we are doing the topmost directory, and the file is in a
7805       # subdir which does not have a Makefile, then we distribute it
7806       # here.
7807
7808       # If a required file is above the source tree, it is important
7809       # to prefix it with `$(srcdir)' so that no VPATH search is
7810       # performed.  Otherwise problems occur with Make implementations
7811       # that rewrite and simplify rules whose dependencies are found in a
7812       # VPATH location.  Here is an example with OSF1/Tru64 Make.
7813       #
7814       #   % cat Makefile
7815       #   VPATH = sub
7816       #   distdir: ../a
7817       #           echo ../a
7818       #   % ls
7819       #   Makefile a
7820       #   % make
7821       #   echo a
7822       #   a
7823       #
7824       # Dependency `../a' was found in `sub/../a', but this make
7825       # implementation simplified it as `a'.  (Note that the sub/
7826       # directory does not even exist.)
7827       #
7828       # This kind of VPATH rewriting seems hard to cancel.  The
7829       # distdir.am hack against VPATH rewriting works only when no
7830       # simplification is done, i.e., for dependencies which are in
7831       # subdirectories, not in enclosing directories.  Hence, in
7832       # the latter case we use a full path to make sure no VPATH
7833       # search occurs.
7834       $fullfile = '$(srcdir)/' . $fullfile
7835         if $dir =~ m,^\.\.(?:$|/),;
7836
7837       push_dist_common ($fullfile);
7838       return 1;
7839     }
7840   return 0;
7841 }
7842
7843
7844 # If a file name appears as a key in this hash, then it has already
7845 # been checked for.  This allows us not to report the same error more
7846 # than once.
7847 my %required_file_not_found = ();
7848
7849 # &require_file_internal ($WHERE, $MYSTRICT, $DIRECTORY, @FILES)
7850 # --------------------------------------------------------------
7851 # Verify that the file must exist in $DIRECTORY, or install it.
7852 # $MYSTRICT is the strictness level at which this file becomes required.
7853 sub require_file_internal ($$$@)
7854 {
7855   my ($where, $mystrict, $dir, @files) = @_;
7856
7857   foreach my $file (@files)
7858     {
7859       my $fullfile = "$dir/$file";
7860       my $found_it = 0;
7861       my $dangling_sym = 0;
7862
7863       if (-l $fullfile && ! -f $fullfile)
7864         {
7865           $dangling_sym = 1;
7866         }
7867       elsif (dir_has_case_matching_file ($dir, $file))
7868         {
7869           $found_it = 1;
7870           maybe_push_required_file ($dir, $file, $fullfile);
7871         }
7872
7873       # `--force-missing' only has an effect if `--add-missing' is
7874       # specified.
7875       if ($found_it && (! $add_missing || ! $force_missing))
7876         {
7877           next;
7878         }
7879       else
7880         {
7881           # If we've already looked for it, we're done.  You might
7882           # wonder why we don't do this before searching for the
7883           # file.  If we do that, then something like
7884           # AC_OUTPUT(subdir/foo foo) will fail to put foo.in into
7885           # DIST_COMMON.
7886           if (! $found_it)
7887             {
7888               next if defined $required_file_not_found{$fullfile};
7889               $required_file_not_found{$fullfile} = 1;
7890             }
7891
7892           if ($strictness >= $mystrict)
7893             {
7894               if ($dangling_sym && $add_missing)
7895                 {
7896                   unlink ($fullfile);
7897                 }
7898
7899               my $trailer = '';
7900               my $trailer2 = '';
7901               my $suppress = 0;
7902
7903               # Only install missing files according to our desired
7904               # strictness level.
7905               my $message = "required file `$fullfile' not found";
7906               if ($add_missing)
7907                 {
7908                   if (-f "$libdir/$file")
7909                     {
7910                       $suppress = 1;
7911
7912                       # Install the missing file.  Symlink if we
7913                       # can, copy if we must.  Note: delete the file
7914                       # first, in case it is a dangling symlink.
7915                       $message = "installing `$fullfile'";
7916
7917                       # The license file should not be volatile.
7918                       if ($file eq "COPYING")
7919                         {
7920                           $message .= " using GNU General Public License v3 file";
7921                           $trailer2 = "\n    Consider adding the COPYING file"
7922                                     . " to the version control system"
7923                                     . "\n    for your code, to avoid questions"
7924                                     . " about which license your project uses.";
7925                         }
7926
7927                       # Windows Perl will hang if we try to delete a
7928                       # file that doesn't exist.
7929                       unlink ($fullfile) if -f $fullfile;
7930                       if ($symlink_exists && ! $copy_missing)
7931                         {
7932                           if (! symlink ("$libdir/$file", $fullfile)
7933                               || ! -e $fullfile)
7934                             {
7935                               $suppress = 0;
7936                               $trailer = "; error while making link: $!";
7937                             }
7938                         }
7939                       elsif (system ('cp', "$libdir/$file", $fullfile))
7940                         {
7941                           $suppress = 0;
7942                           $trailer = "\n    error while copying";
7943                         }
7944                       set_dir_cache_file ($dir, $file);
7945                     }
7946
7947                   if (! maybe_push_required_file (dirname ($fullfile),
7948                                                   $file, $fullfile))
7949                     {
7950                       if (! $found_it && ! $automake_will_process_aux_dir)
7951                         {
7952                           # We have added the file but could not push it
7953                           # into DIST_COMMON, probably because this is
7954                           # an auxiliary file and we are not processing
7955                           # the top level Makefile.  Furthermore Automake
7956                           # hasn't been asked to create the Makefile.in
7957                           # that distributes the aux dir files.
7958                           error ($where, 'Please make a full run of automake'
7959                                  . " so $fullfile gets distributed.");
7960                         }
7961                     }
7962                 }
7963               else
7964                 {
7965                   $trailer = "\n  `automake --add-missing' can install `$file'"
7966                     if -f "$libdir/$file";
7967                 }
7968
7969               # If --force-missing was specified, and we have
7970               # actually found the file, then do nothing.
7971               next
7972                 if $found_it && $force_missing;
7973
7974               # If we couldn't install the file, but it is a target in
7975               # the Makefile, don't print anything.  This allows files
7976               # like README, AUTHORS, or THANKS to be generated.
7977               next
7978                 if !$suppress && rule $file;
7979
7980               msg ($suppress ? 'note' : 'error', $where, "$message$trailer$trailer2");
7981             }
7982         }
7983     }
7984 }
7985
7986 # &require_file ($WHERE, $MYSTRICT, @FILES)
7987 # -----------------------------------------
7988 sub require_file ($$@)
7989 {
7990     my ($where, $mystrict, @files) = @_;
7991     require_file_internal ($where, $mystrict, $relative_dir, @files);
7992 }
7993
7994 # &require_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7995 # -----------------------------------------------------------
7996 sub require_file_with_macro ($$$@)
7997 {
7998     my ($cond, $macro, $mystrict, @files) = @_;
7999     $macro = rvar ($macro) unless ref $macro;
8000     require_file ($macro->rdef ($cond)->location, $mystrict, @files);
8001 }
8002
8003 # &require_libsource_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
8004 # ----------------------------------------------------------------
8005 # Require an AC_LIBSOURCEd file.  If AC_CONFIG_LIBOBJ_DIR was called, it
8006 # must be in that directory.  Otherwise expect it in the current directory.
8007 sub require_libsource_with_macro ($$$@)
8008 {
8009     my ($cond, $macro, $mystrict, @files) = @_;
8010     $macro = rvar ($macro) unless ref $macro;
8011     if ($config_libobj_dir)
8012       {
8013         require_file_internal ($macro->rdef ($cond)->location, $mystrict,
8014                                $config_libobj_dir, @files);
8015       }
8016     else
8017       {
8018         require_file ($macro->rdef ($cond)->location, $mystrict, @files);
8019       }
8020 }
8021
8022 # Queue to push require_conf_file requirements to.
8023 my $required_conf_file_queue;
8024
8025 # &queue_required_conf_file ($QUEUE, $KEY, $DIR, $WHERE, $MYSTRICT, @FILES)
8026 # -------------------------------------------------------------------------
8027 sub queue_required_conf_file ($$$$@)
8028 {
8029     my ($queue, $key, $dir, $where, $mystrict, @files) = @_;
8030     my @serial_loc;
8031     if (ref $where)
8032       {
8033         @serial_loc = (QUEUE_LOCATION, $where->serialize ());
8034       }
8035     else
8036       {
8037         @serial_loc = (QUEUE_STRING, $where);
8038       }
8039     $queue->enqueue ($key, $dir, @serial_loc, $mystrict, 0 + @files, @files);
8040 }
8041
8042 # &require_queued_conf_file ($QUEUE)
8043 # ----------------------------------
8044 sub require_queued_conf_file ($)
8045 {
8046     my ($queue) = @_;
8047     my $where;
8048     my $dir = $queue->dequeue ();
8049     my $loc_key = $queue->dequeue ();
8050     if ($loc_key eq QUEUE_LOCATION)
8051       {
8052         $where = Automake::Location::deserialize ($queue);
8053       }
8054     elsif ($loc_key eq QUEUE_STRING)
8055       {
8056         $where = $queue->dequeue ();
8057       }
8058     else
8059       {
8060         prog_error "unexpected key $loc_key";
8061       }
8062     my $mystrict = $queue->dequeue ();
8063     my $nfiles = $queue->dequeue ();
8064     my @files;
8065     push @files, $queue->dequeue ()
8066       foreach (1 .. $nfiles);
8067
8068     # Dequeuing happens outside of per-makefile context, so we have to
8069     # set the variables used by require_file_internal and the functions
8070     # it calls.  Gross!
8071     $relative_dir = $dir;
8072     require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8073 }
8074
8075 # &require_conf_file ($WHERE, $MYSTRICT, @FILES)
8076 # ----------------------------------------------
8077 # Looks in configuration path, as specified by AC_CONFIG_AUX_DIR;
8078 # worker threads may queue up the action to be serialized by the master.
8079 #
8080 # FIXME: this seriously relies on the semantics of require_file_internal
8081 # and maybe_push_required_file, in that we exploit the fact that only the
8082 # contents of the last handled output file may be impacted (which in turn
8083 # is dealt with by the master thread).
8084 sub require_conf_file ($$@)
8085 {
8086     my ($where, $mystrict, @files) = @_;
8087     if (defined $required_conf_file_queue)
8088       {
8089         queue_required_conf_file ($required_conf_file_queue, QUEUE_CONF_FILE,
8090                                   $relative_dir, $where, $mystrict, @files);
8091       }
8092     else
8093       {
8094         require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8095       }
8096 }
8097
8098
8099 # &require_conf_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
8100 # ----------------------------------------------------------------
8101 sub require_conf_file_with_macro ($$$@)
8102 {
8103     my ($cond, $macro, $mystrict, @files) = @_;
8104     require_conf_file (rvar ($macro)->rdef ($cond)->location,
8105                        $mystrict, @files);
8106 }
8107
8108 ################################################################
8109
8110 # &require_build_directory ($DIRECTORY)
8111 # -------------------------------------
8112 # Emit rules to create $DIRECTORY if needed, and return
8113 # the file that any target requiring this directory should be made
8114 # dependent upon.
8115 # We don't want to emit the rule twice, and want to reuse it
8116 # for directories with equivalent names (e.g., `foo/bar' and `./foo//bar').
8117 sub require_build_directory ($)
8118 {
8119   my $directory = shift;
8120
8121   return $directory_map{$directory} if exists $directory_map{$directory};
8122
8123   my $cdir = File::Spec->canonpath ($directory);
8124
8125   if (exists $directory_map{$cdir})
8126     {
8127       my $stamp = $directory_map{$cdir};
8128       $directory_map{$directory} = $stamp;
8129       return $stamp;
8130     }
8131
8132   my $dirstamp = "$cdir/\$(am__dirstamp)";
8133
8134   $directory_map{$directory} = $dirstamp;
8135   $directory_map{$cdir} = $dirstamp;
8136
8137   # Set a variable for the dirstamp basename.
8138   define_pretty_variable ('am__dirstamp', TRUE, INTERNAL,
8139                           '$(am__leading_dot)dirstamp');
8140
8141   # Directory must be removed by `make distclean'.
8142   $clean_files{$dirstamp} = DIST_CLEAN;
8143
8144   $output_rules .= ("$dirstamp:\n"
8145                     . "\t\@\$(MKDIR_P) $directory\n"
8146                     . "\t\@: > $dirstamp\n");
8147
8148   return $dirstamp;
8149 }
8150
8151 # &require_build_directory_maybe ($FILE)
8152 # --------------------------------------
8153 # If $FILE lies in a subdirectory, emit a rule to create this
8154 # directory and return the file that $FILE should be made
8155 # dependent upon.  Otherwise, just return the empty string.
8156 sub require_build_directory_maybe ($)
8157 {
8158     my $file = shift;
8159     my $directory = dirname ($file);
8160
8161     if ($directory ne '.')
8162     {
8163         return require_build_directory ($directory);
8164     }
8165     else
8166     {
8167         return '';
8168     }
8169 }
8170
8171 ################################################################
8172
8173 # Push a list of files onto dist_common.
8174 sub push_dist_common
8175 {
8176   prog_error "push_dist_common run after handle_dist"
8177     if $handle_dist_run;
8178   Automake::Variable::define ('DIST_COMMON', VAR_AUTOMAKE, '+', TRUE, "@_",
8179                               '', INTERNAL, VAR_PRETTY);
8180 }
8181
8182
8183 ################################################################
8184
8185 # generate_makefile ($MAKEFILE_AM, $MAKEFILE_IN)
8186 # ----------------------------------------------
8187 # Generate a Makefile.in given the name of the corresponding Makefile and
8188 # the name of the file output by config.status.
8189 sub generate_makefile ($$)
8190 {
8191   my ($makefile_am, $makefile_in) = @_;
8192
8193   # Reset all the Makefile.am related variables.
8194   initialize_per_input;
8195
8196   # AUTOMAKE_OPTIONS can contains -W flags to disable or enable
8197   # warnings for this file.  So hold any warning issued before
8198   # we have processed AUTOMAKE_OPTIONS.
8199   buffer_messages ('warning');
8200
8201   # Name of input file ("Makefile.am") and output file
8202   # ("Makefile.in").  These have no directory components.
8203   $am_file_name = basename ($makefile_am);
8204   $in_file_name = basename ($makefile_in);
8205
8206   # $OUTPUT is encoded.  If it contains a ":" then the first element
8207   # is the real output file, and all remaining elements are input
8208   # files.  We don't scan or otherwise deal with these input files,
8209   # other than to mark them as dependencies.  See
8210   # &scan_autoconf_files for details.
8211   my ($makefile, @inputs) = split (/:/, $output_files{$makefile_in});
8212
8213   $relative_dir = dirname ($makefile);
8214   $am_relative_dir = dirname ($makefile_am);
8215   $topsrcdir = backname ($relative_dir);
8216
8217   read_main_am_file ($makefile_am);
8218   if (handle_options)
8219     {
8220       # Process buffered warnings.
8221       flush_messages;
8222       # Fatal error.  Just return, so we can continue with next file.
8223       return;
8224     }
8225   # Process buffered warnings.
8226   flush_messages;
8227
8228   # There are a few install-related variables that you should not define.
8229   foreach my $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
8230     {
8231       my $v = var $var;
8232       if ($v)
8233         {
8234           my $def = $v->def (TRUE);
8235           prog_error "$var not defined in condition TRUE"
8236             unless $def;
8237           reject_var $var, "`$var' should not be defined"
8238             if $def->owner != VAR_AUTOMAKE;
8239         }
8240     }
8241
8242   # Catch some obsolete variables.
8243   msg_var ('obsolete', 'INCLUDES',
8244            "`INCLUDES' is the old name for `AM_CPPFLAGS' (or `*_CPPFLAGS')")
8245     if var ('INCLUDES');
8246
8247   # Must do this after reading .am file.
8248   define_variable ('subdir', $relative_dir, INTERNAL);
8249
8250   # If DIST_SUBDIRS is defined, make sure SUBDIRS is, so that
8251   # recursive rules are enabled.
8252   define_pretty_variable ('SUBDIRS', TRUE, INTERNAL, '')
8253     if var 'DIST_SUBDIRS' && ! var 'SUBDIRS';
8254
8255   # Check first, because we might modify some state.
8256   check_cygnus;
8257   check_gnu_standards;
8258   check_gnits_standards;
8259
8260   handle_configure ($makefile_am, $makefile_in, $makefile, @inputs);
8261   handle_gettext;
8262   handle_libraries;
8263   handle_ltlibraries;
8264   handle_programs;
8265   handle_scripts;
8266
8267   # These must be run after all the sources are scanned.  They
8268   # use variables defined by &handle_libraries, &handle_ltlibraries,
8269   # or &handle_programs.
8270   handle_compile;
8271   handle_languages;
8272   handle_libtool;
8273
8274   # Variables used by distdir.am and tags.am.
8275   define_pretty_variable ('SOURCES', TRUE, INTERNAL, @sources);
8276   if (! option 'no-dist')
8277     {
8278       define_pretty_variable ('DIST_SOURCES', TRUE, INTERNAL, @dist_sources);
8279     }
8280
8281   handle_multilib;
8282   handle_texinfo;
8283   handle_emacs_lisp;
8284   handle_python;
8285   handle_java;
8286   handle_man_pages;
8287   handle_data;
8288   handle_headers;
8289   handle_subdirs;
8290   handle_tags;
8291   handle_minor_options;
8292   # Must come after handle_programs so that %known_programs is up-to-date.
8293   handle_tests;
8294
8295   # This must come after most other rules.
8296   handle_dist;
8297
8298   handle_footer;
8299   do_check_merge_target;
8300   handle_all ($makefile);
8301
8302   # FIXME: Gross!
8303   if (var ('lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8304     {
8305       $output_rules .= "install-binPROGRAMS: install-libLTLIBRARIES\n\n";
8306     }
8307   if (var ('nobase_lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8308     {
8309       $output_rules .= "install-binPROGRAMS: install-nobase_libLTLIBRARIES\n\n";
8310     }
8311
8312   handle_install;
8313   handle_clean ($makefile);
8314   handle_factored_dependencies;
8315
8316   # Comes last, because all the above procedures may have
8317   # defined or overridden variables.
8318   $output_vars .= output_variables;
8319
8320   check_typos;
8321
8322   my ($out_file) = $output_directory . '/' . $makefile_in;
8323
8324   if ($exit_code != 0)
8325     {
8326       verb "not writing $out_file because of earlier errors";
8327       return;
8328     }
8329
8330   if (! -d ($output_directory . '/' . $am_relative_dir))
8331     {
8332       mkdir ($output_directory . '/' . $am_relative_dir, 0755);
8333     }
8334
8335   # We make sure that `all:' is the first target.
8336   my $output =
8337     "$output_vars$output_all$output_header$output_rules$output_trailer";
8338
8339   # Decide whether we must update the output file or not.
8340   # We have to update in the following situations.
8341   #  * $force_generation is set.
8342   #  * any of the output dependencies is younger than the output
8343   #  * the contents of the output is different (this can happen
8344   #    if the project has been populated with a file listed in
8345   #    @common_files since the last run).
8346   # Output's dependencies are split in two sets:
8347   #  * dependencies which are also configure dependencies
8348   #    These do not change between each Makefile.am
8349   #  * other dependencies, specific to the Makefile.am being processed
8350   #    (such as the Makefile.am itself, or any Makefile fragment
8351   #    it includes).
8352   my $timestamp = mtime $out_file;
8353   if (! $force_generation
8354       && $configure_deps_greatest_timestamp < $timestamp
8355       && $output_deps_greatest_timestamp < $timestamp
8356       && $output eq contents ($out_file))
8357     {
8358       verb "$out_file unchanged";
8359       # No need to update.
8360       return;
8361     }
8362
8363   if (-e $out_file)
8364     {
8365       unlink ($out_file)
8366         or fatal "cannot remove $out_file: $!\n";
8367     }
8368
8369   my $gm_file = new Automake::XFile "> $out_file";
8370   verb "creating $out_file";
8371   print $gm_file $output;
8372 }
8373
8374 ################################################################
8375
8376
8377
8378
8379 ################################################################
8380
8381 # Helper function for usage().
8382 sub print_autodist_files (@)
8383 {
8384   my @lcomm = sort (&uniq (@_));
8385
8386   my @four;
8387   format USAGE_FORMAT =
8388   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
8389   $four[0],           $four[1],           $four[2],           $four[3]
8390 .
8391   local $~ = "USAGE_FORMAT";
8392
8393   my $cols = 4;
8394   my $rows = int(@lcomm / $cols);
8395   my $rest = @lcomm % $cols;
8396
8397   if ($rest)
8398     {
8399       $rows++;
8400     }
8401   else
8402     {
8403       $rest = $cols;
8404     }
8405
8406   for (my $y = 0; $y < $rows; $y++)
8407     {
8408       @four = ("", "", "", "");
8409       for (my $x = 0; $x < $cols; $x++)
8410         {
8411           last if $y + 1 == $rows && $x == $rest;
8412
8413           my $idx = (($x > $rest)
8414                ?  ($rows * $rest + ($rows - 1) * ($x - $rest))
8415                : ($rows * $x));
8416
8417           $idx += $y;
8418           $four[$x] = $lcomm[$idx];
8419         }
8420       write;
8421     }
8422 }
8423
8424
8425 # Print usage information.
8426 sub usage ()
8427 {
8428     print "Usage: $0 [OPTION] ... [Makefile]...
8429
8430 Generate Makefile.in for configure from Makefile.am.
8431
8432 Operation modes:
8433       --help               print this help, then exit
8434       --version            print version number, then exit
8435   -v, --verbose            verbosely list files processed
8436       --no-force           only update Makefile.in's that are out of date
8437   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY
8438
8439 Dependency tracking:
8440   -i, --ignore-deps      disable dependency tracking code
8441       --include-deps     enable dependency tracking code
8442
8443 Flavors:
8444       --cygnus           assume program is part of Cygnus-style tree
8445       --foreign          set strictness to foreign
8446       --gnits            set strictness to gnits
8447       --gnu              set strictness to gnu
8448
8449 Library files:
8450   -a, --add-missing      add missing standard files to package
8451       --libdir=DIR       directory storing library files
8452   -c, --copy             with -a, copy missing files (default is symlink)
8453   -f, --force-missing    force update of standard files
8454
8455 ";
8456     Automake::ChannelDefs::usage;
8457
8458     print "\nFiles automatically distributed if found " .
8459           "(always):\n";
8460     print_autodist_files @common_files;
8461     print "\nFiles automatically distributed if found " .
8462           "(under certain conditions):\n";
8463     print_autodist_files @common_sometimes;
8464
8465     print '
8466 Report bugs to <@PACKAGE_BUGREPORT@>.
8467 GNU Automake home page: <@PACKAGE_URL@>.
8468 General help using GNU software: <http://www.gnu.org/gethelp/>.
8469 ';
8470
8471     # --help always returns 0 per GNU standards.
8472     exit 0;
8473 }
8474
8475
8476 # &version ()
8477 # -----------
8478 # Print version information
8479 sub version ()
8480 {
8481   print <<EOF;
8482 automake (GNU $PACKAGE) $VERSION
8483 Copyright (C) 2011 Free Software Foundation, Inc.
8484 License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
8485 This is free software: you are free to change and redistribute it.
8486 There is NO WARRANTY, to the extent permitted by law.
8487
8488 Written by Tom Tromey <tromey\@redhat.com>
8489        and Alexandre Duret-Lutz <adl\@gnu.org>.
8490 EOF
8491   # --version always returns 0 per GNU standards.
8492   exit 0;
8493 }
8494
8495 ################################################################
8496
8497 # Parse command line.
8498 sub parse_arguments ()
8499 {
8500   # Start off as gnu.
8501   set_strictness ('gnu');
8502
8503   my $cli_where = new Automake::Location;
8504   my %cli_options =
8505     (
8506      'libdir=s' => \$libdir,
8507      'gnu'              => sub { set_strictness ('gnu'); },
8508      'gnits'            => sub { set_strictness ('gnits'); },
8509      'cygnus'           => sub { set_global_option ('cygnus', $cli_where); },
8510      'foreign'          => sub { set_strictness ('foreign'); },
8511      'include-deps'     => sub { unset_global_option ('no-dependencies'); },
8512      'i|ignore-deps'    => sub { set_global_option ('no-dependencies',
8513                                                     $cli_where); },
8514      'no-force' => sub { $force_generation = 0; },
8515      'f|force-missing'  => \$force_missing,
8516      'o|output-dir=s'   => \$output_directory,
8517      'a|add-missing'    => \$add_missing,
8518      'c|copy'           => \$copy_missing,
8519      'v|verbose'        => sub { setup_channel 'verb', silent => 0; },
8520      'W|warnings=s'     => \&parse_warnings,
8521      # These long options (--Werror and --Wno-error) for backward
8522      # compatibility.  Use -Werror and -Wno-error today.
8523      'Werror'           => sub { parse_warnings 'W', 'error'; },
8524      'Wno-error'        => sub { parse_warnings 'W', 'no-error'; },
8525      );
8526   use Getopt::Long;
8527   Getopt::Long::config ("bundling", "pass_through");
8528
8529   # See if --version or --help is used.  We want to process these before
8530   # anything else because the GNU Coding Standards require us to
8531   # `exit 0' after processing these options, and we can't guarantee this
8532   # if we treat other options first.  (Handling other options first
8533   # could produce error diagnostics, and in this condition it is
8534   # confusing if Automake does `exit 0'.)
8535   my %cli_options_1st_pass =
8536     (
8537      'version' => \&version,
8538      'help'    => \&usage,
8539      # Recognize all other options (and their arguments) but do nothing.
8540      map { $_ => sub {} } (keys %cli_options)
8541      );
8542   my @ARGV_backup = @ARGV;
8543   Getopt::Long::GetOptions %cli_options_1st_pass
8544     or exit 1;
8545   @ARGV = @ARGV_backup;
8546
8547   # Now *really* process the options.  This time we know that --help
8548   # and --version are not present, but we specify them nonetheless so
8549   # that ambiguous abbreviation are diagnosed.
8550   Getopt::Long::GetOptions %cli_options, 'version' => sub {}, 'help' => sub {}
8551     or exit 1;
8552
8553   if (defined $output_directory)
8554     {
8555       msg 'obsolete', "`--output-dir' is deprecated\n";
8556     }
8557   else
8558     {
8559       # In the next release we'll remove this entirely.
8560       $output_directory = '.';
8561     }
8562
8563   return unless @ARGV;
8564
8565   if ($ARGV[0] =~ /^-./)
8566     {
8567       my %argopts;
8568       for my $k (keys %cli_options)
8569         {
8570           if ($k =~ /(.*)=s$/)
8571             {
8572               map { $argopts{(length ($_) == 1)
8573                              ? "-$_" : "--$_" } = 1; } (split (/\|/, $1));
8574             }
8575         }
8576       if ($ARGV[0] eq '--')
8577         {
8578           shift @ARGV;
8579         }
8580       elsif (exists $argopts{$ARGV[0]})
8581         {
8582           fatal ("option `$ARGV[0]' requires an argument\n"
8583                  . "Try `$0 --help' for more information.");
8584         }
8585       else
8586         {
8587           fatal ("unrecognized option `$ARGV[0]'.\n"
8588                  . "Try `$0 --help' for more information.");
8589         }
8590     }
8591
8592   my $errspec = 0;
8593   foreach my $arg (@ARGV)
8594     {
8595       fatal ("empty argument\nTry `$0 --help' for more information.")
8596         if ($arg eq '');
8597
8598       # Handle $local:$input syntax.
8599       my ($local, @rest) = split (/:/, $arg);
8600       @rest = ("$local.in",) unless @rest;
8601       my $input = locate_am @rest;
8602       if ($input)
8603         {
8604           push @input_files, $input;
8605           $output_files{$input} = join (':', ($local, @rest));
8606         }
8607       else
8608         {
8609           error "no Automake input file found for `$arg'";
8610           $errspec = 1;
8611         }
8612     }
8613   fatal "no input file found among supplied arguments"
8614     if $errspec && ! @input_files;
8615 }
8616
8617
8618 # handle_makefile ($MAKEFILE_IN)
8619 # ------------------------------
8620 # Deal with $MAKEFILE_IN.
8621 sub handle_makefile ($)
8622 {
8623   my ($file) =  @_;
8624   ($am_file = $file) =~ s/\.in$//;
8625   if (! -f ($am_file . '.am'))
8626     {
8627       error "`$am_file.am' does not exist";
8628     }
8629   else
8630     {
8631       # Any warning setting now local to this Makefile.am.
8632       dup_channel_setup;
8633
8634       generate_makefile ($am_file . '.am', $file);
8635
8636       # Back out any warning setting.
8637       drop_channel_setup;
8638     }
8639 }
8640
8641 # handle_makefiles_serial ()
8642 # --------------------------
8643 # Deal with all makefiles, without threads.
8644 sub handle_makefiles_serial ()
8645 {
8646   foreach my $file (@input_files)
8647     {
8648       handle_makefile ($file);
8649     }
8650 }
8651
8652 # get_number_of_threads ()
8653 # ------------------------
8654 # Logic for deciding how many worker threads to use.
8655 sub get_number_of_threads
8656 {
8657   my $nthreads = $ENV{'AUTOMAKE_JOBS'} || 0;
8658
8659   $nthreads = 0
8660     unless $nthreads =~ /^[0-9]+$/;
8661
8662   # It doesn't make sense to use more threads than makefiles,
8663   my $max_threads = @input_files;
8664
8665   # but a single worker thread is helpful for exposing bugs.
8666   if ($automake_will_process_aux_dir && $max_threads > 1)
8667     {
8668       $max_threads--;
8669     }
8670   if ($nthreads > $max_threads)
8671     {
8672       $nthreads = $max_threads;
8673     }
8674   return $nthreads;
8675 }
8676
8677 # handle_makefiles_threaded ($NTHREADS)
8678 # -------------------------------------
8679 # Deal with all makefiles, using threads.  The general strategy is to
8680 # spawn NTHREADS worker threads, dispatch makefiles to them, and let the
8681 # worker threads push back everything that needs serialization:
8682 # * warning and (normal) error messages, for stable stderr output
8683 #   order and content (avoiding duplicates, for example),
8684 # * races when installing aux files (and respective messages),
8685 # * races when collecting aux files for distribution.
8686 #
8687 # The latter requires that the makefile that deals with the aux dir
8688 # files be handled last, done by the master thread.
8689 sub handle_makefiles_threaded ($)
8690 {
8691   my ($nthreads) = @_;
8692
8693   my @queued_input_files = @input_files;
8694   my $last_input_file = undef;
8695   if ($automake_will_process_aux_dir)
8696     {
8697       $last_input_file = pop @queued_input_files;
8698     }
8699
8700   # The file queue distributes all makefiles, the message queues
8701   # collect all serializations needed for respective files.
8702   my $file_queue = Thread::Queue->new;
8703   my %msg_queues;
8704   foreach my $file (@queued_input_files)
8705     {
8706       $msg_queues{$file} = Thread::Queue->new;
8707     }
8708
8709   verb "spawning $nthreads worker threads";
8710   my @threads = (1 .. $nthreads);
8711   foreach my $t (@threads)
8712     {
8713       $t = threads->new (sub
8714         {
8715           while (my $file = $file_queue->dequeue)
8716             {
8717               verb "handling $file";
8718               my $queue = $msg_queues{$file};
8719               setup_channel_queue ($queue, QUEUE_MESSAGE);
8720               $required_conf_file_queue = $queue;
8721               handle_makefile ($file);
8722               $queue->enqueue (undef);
8723               setup_channel_queue (undef, undef);
8724               $required_conf_file_queue = undef;
8725             }
8726           return $exit_code;
8727         });
8728     }
8729
8730   # Queue all normal makefiles.
8731   verb "queuing " . @queued_input_files . " input files";
8732   $file_queue->enqueue (@queued_input_files, (undef) x @threads);
8733
8734   # Collect and process serializations.
8735   foreach my $file (@queued_input_files)
8736     {
8737       verb "dequeuing messages for " . $file;
8738       reset_local_duplicates ();
8739       my $queue = $msg_queues{$file};
8740       while (my $key = $queue->dequeue)
8741         {
8742           if ($key eq QUEUE_MESSAGE)
8743             {
8744               pop_channel_queue ($queue);
8745             }
8746           elsif ($key eq QUEUE_CONF_FILE)
8747             {
8748               require_queued_conf_file ($queue);
8749             }
8750           else
8751             {
8752               prog_error "unexpected key $key";
8753             }
8754         }
8755     }
8756
8757   foreach my $t (@threads)
8758     {
8759       my @exit_thread = $t->join;
8760       $exit_code = $exit_thread[0]
8761         if ($exit_thread[0] > $exit_code);
8762     }
8763
8764   # The master processes the last file.
8765   if ($automake_will_process_aux_dir)
8766     {
8767       verb "processing last input file";
8768       handle_makefile ($last_input_file);
8769     }
8770 }
8771
8772 ################################################################
8773
8774 # Parse the WARNINGS environment variable.
8775 parse_WARNINGS;
8776
8777 # Parse command line.
8778 parse_arguments;
8779
8780 $configure_ac = require_configure_ac;
8781
8782 # Do configure.ac scan only once.
8783 scan_autoconf_files;
8784
8785 if (! @input_files)
8786   {
8787     my $msg = '';
8788     $msg = "\nDid you forget AC_CONFIG_FILES([Makefile]) in $configure_ac?"
8789       if -f 'Makefile.am';
8790     fatal ("no `Makefile.am' found for any configure output$msg");
8791   }
8792
8793 my $nthreads = get_number_of_threads ();
8794
8795 if ($perl_threads && $nthreads >= 1)
8796   {
8797     handle_makefiles_threaded ($nthreads);
8798   }
8799 else
8800   {
8801     handle_makefiles_serial ();
8802   }
8803
8804 exit $exit_code;
8805
8806
8807 ### Setup "GNU" style for perl-mode and cperl-mode.
8808 ## Local Variables:
8809 ## perl-indent-level: 2
8810 ## perl-continued-statement-offset: 2
8811 ## perl-continued-brace-offset: 0
8812 ## perl-brace-offset: 0
8813 ## perl-brace-imaginary-offset: 0
8814 ## perl-label-offset: -2
8815 ## cperl-indent-level: 2
8816 ## cperl-brace-offset: 0
8817 ## cperl-continued-brace-offset: 0
8818 ## cperl-label-offset: -2
8819 ## cperl-extra-newline-before-brace: t
8820 ## cperl-merge-trailing-else: nil
8821 ## cperl-continued-statement-offset: 2
8822 ## End: