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, 2012 Free
  11 # Software 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 compile config.guess config.rpath config.sub
 239         depcomp elisp-comp install-sh libversion.in mdate-sh missing
 240         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_CC_C_O
 400 my $seen_cc_c_o = 0;
 401
 402 # Location of AC_REQUIRE_AUX_FILE calls, indexed by their argument.
 403 my %required_aux_file = ();
 404
 405 # Where AM_INIT_AUTOMAKE is called;
 406 my $seen_init_automake = 0;
 407
 408 # TRUE if we've seen AM_AUTOMAKE_VERSION.
 409 my $seen_automake_version = 0;
 410
 411 # Hash table of discovered configure substitutions.  Keys are names,
 412 # values are `FILE:LINE' strings which are used by error message
 413 # generation.
 414 my %configure_vars = ();
 415
 416 # Ignored configure substitutions (i.e., variables not to be output in
 417 # Makefile.in)
 418 my %ignored_configure_vars = ();
 419
 420 # Files included by $configure_ac.
 421 my @configure_deps = ();
 422
 423 # Greatest timestamp of configure's dependencies.
 424 my $configure_deps_greatest_timestamp = 0;
 425
 426 # Hash table of AM_CONDITIONAL variables seen in configure.
 427 my %configure_cond = ();
 428
 429 # This maps extensions onto language names.
 430 my %extension_map = ();
 431
 432 # List of the DIST_COMMON files we discovered while reading
 433 # configure.in
 434 my $configure_dist_common = '';
 435
 436 # This maps languages names onto objects.
 437 my %languages = ();
 438 # Maps each linker variable onto a language object.
 439 my %link_languages = ();
 440
 441 # maps extensions to needed source flags.
 442 my %sourceflags = ();
 443
 444 # List of targets we must always output.
 445 # FIXME: Complete, and remove falsely required targets.
 446 my %required_targets =
 447   (
 448    'all'          => 1,
 449    'dvi'          => 1,
 450    'pdf'          => 1,
 451    'ps'           => 1,
 452    'info'         => 1,
 453    'install-info' => 1,
 454    'install'      => 1,
 455    'install-data' => 1,
 456    'install-exec' => 1,
 457    'uninstall'    => 1,
 458
 459    # FIXME: Not required, temporary hacks.
 460    # Well, actually they are sort of required: the -recursive
 461    # targets will run them anyway...
 462    'html-am'         => 1,
 463    'dvi-am'          => 1,
 464    'pdf-am'          => 1,
 465    'ps-am'           => 1,
 466    'info-am'         => 1,
 467    'install-data-am' => 1,
 468    'install-exec-am' => 1,
 469    'install-html-am' => 1,
 470    'install-dvi-am'  => 1,
 471    'install-pdf-am'  => 1,
 472    'install-ps-am'   => 1,
 473    'install-info-am' => 1,
 474    'installcheck-am' => 1,
 475    'uninstall-am' => 1,
 476
 477    'install-man' => 1,
 478   );
 479
 480 # Set to 1 if this run will create the Makefile.in that distributes
 481 # the files in config_aux_dir.
 482 my $automake_will_process_aux_dir = 0;
 483
 484 # The name of the Makefile currently being processed.
 485 my $am_file = 'BUG';
 486 \f
 487
 488 ################################################################
 489
 490 ## ------------------------------------------ ##
 491 ## Variables reset by &initialize_per_input.  ##
 492 ## ------------------------------------------ ##
 493
 494 # Basename and relative dir of the input file.
 495 my $am_file_name;
 496 my $am_relative_dir;
 497
 498 # Same but wrt Makefile.in.
 499 my $in_file_name;
 500 my $relative_dir;
 501
 502 # Relative path to the top directory.
 503 my $topsrcdir;
 504
 505 # Greatest timestamp of the output's dependencies (excluding
 506 # configure's dependencies).
 507 my $output_deps_greatest_timestamp;
 508
 509 # These variables are used when generating each Makefile.in.
 510 # They hold the Makefile.in until it is ready to be printed.
 511 my $output_vars;
 512 my $output_all;
 513 my $output_header;
 514 my $output_rules;
 515 my $output_trailer;
 516
 517 # This is the conditional stack, updated on if/else/endif, and
 518 # used to build Condition objects.
 519 my @cond_stack;
 520
 521 # This holds the set of included files.
 522 my @include_stack;
 523
 524 # List of dependencies for the obvious targets.
 525 my @all;
 526 my @check;
 527 my @check_tests;
 528
 529 # Keys in this hash table are files to delete.  The associated
 530 # value tells when this should happen (MOSTLY_CLEAN, DIST_CLEAN, etc.)
 531 my %clean_files;
 532
 533 # Keys in this hash table are object files or other files in
 534 # subdirectories which need to be removed.  This only holds files
 535 # which are created by compilations.  The value in the hash indicates
 536 # when the file should be removed.
 537 my %compile_clean_files;
 538
 539 # Keys in this hash table are directories where we expect to build a
 540 # libtool object.  We use this information to decide what directories
 541 # to delete.
 542 my %libtool_clean_directories;
 543
 544 # Value of `$(SOURCES)', used by tags.am.
 545 my @sources;
 546 # Sources which go in the distribution.
 547 my @dist_sources;
 548
 549 # This hash maps object file names onto their corresponding source
 550 # file names.  This is used to ensure that each object is created
 551 # by a single source file.
 552 my %object_map;
 553
 554 # This hash maps object file names onto an integer value representing
 555 # whether this object has been built via ordinary compilation or
 556 # libtool compilation (the COMPILE_* constants).
 557 my %object_compilation_map;
 558
 559
 560 # This keeps track of the directories for which we've already
 561 # created dirstamp code.  Keys are directories, values are stamp files.
 562 # Several keys can share the same stamp files if they are equivalent
 563 # (as are `.//foo' and `foo').
 564 my %directory_map;
 565
 566 # All .P files.
 567 my %dep_files;
 568
 569 # This is a list of all targets to run during "make dist".
 570 my @dist_targets;
 571
 572 # Keep track of all programs declared in this Makefile, without
 573 # $(EXEEXT).  @substitutions@ are not listed.
 574 my %known_programs;
 575 my %known_libraries;
 576
 577 # Keys in this hash are the basenames of files which must depend on
 578 # ansi2knr.  Values are either the empty string, or the directory in
 579 # which the ANSI source file appears; the directory must have a
 580 # trailing `/'.
 581 my %de_ansi_files;
 582
 583 # This keeps track of which extensions we've seen (that we care
 584 # about).
 585 my %extension_seen;
 586
 587 # This is random scratch space for the language finish functions.
 588 # Don't randomly overwrite it; examine other uses of keys first.
 589 my %language_scratch;
 590
 591 # We keep track of which objects need special (per-executable)
 592 # handling on a per-language basis.
 593 my %lang_specific_files;
 594
 595 # This is set when `handle_dist' has finished.  Once this happens,
 596 # we should no longer push on dist_common.
 597 my $handle_dist_run;
 598
 599 # Used to store a set of linkers needed to generate the sources currently
 600 # under consideration.
 601 my %linkers_used;
 602
 603 # True if we need `LINK' defined.  This is a hack.
 604 my $need_link;
 605
 606 # Was get_object_extension run?
 607 # FIXME: This is a hack. a better switch should be found.
 608 my $get_object_extension_was_run;
 609
 610 # Record each file processed by make_paragraphs.
 611 my %transformed_files;
 612 \f
 613
 614 ################################################################
 615
 616 ## ---------------------------------------------- ##
 617 ## Variables not reset by &initialize_per_input.  ##
 618 ## ---------------------------------------------- ##
 619
 620 # Cache each file processed by make_paragraphs.
 621 # (This is different from %transformed_files because
 622 # %transformed_files is reset for each file while %am_file_cache
 623 # it global to the run.)
 624 my %am_file_cache;
 625
 626 ################################################################
 627
 628 # var_SUFFIXES_trigger ($TYPE, $VALUE)
 629 # ------------------------------------
 630 # This is called by Automake::Variable::define() when SUFFIXES
 631 # is defined ($TYPE eq '') or appended ($TYPE eq '+').
 632 # The work here needs to be performed as a side-effect of the
 633 # macro_define() call because SUFFIXES definitions impact
 634 # on $KNOWN_EXTENSIONS_PATTERN which is used used when parsing
 635 # the input am file.
 636 sub var_SUFFIXES_trigger ($$)
 637 {
 638     my ($type, $value) = @_;
 639     accept_extensions (split (' ', $value));
 640 }
 641 Automake::Variable::hook ('SUFFIXES', \&var_SUFFIXES_trigger);
 642
 643 ################################################################
 644
 645 ## --------------------------------- ##
 646 ## Forward subroutine declarations.  ##
 647 ## --------------------------------- ##
 648 sub register_language (%);
 649 sub file_contents_internal ($$$%);
 650 sub define_files_variable ($\@$$);
 651
 652
 653 # &initialize_per_input ()
 654 # ------------------------
 655 # (Re)-Initialize per-Makefile.am variables.
 656 sub initialize_per_input ()
 657 {
 658     reset_local_duplicates ();
 659
 660     $am_file_name = undef;
 661     $am_relative_dir = undef;
 662
 663     $in_file_name = undef;
 664     $relative_dir = undef;
 665     $topsrcdir = undef;
 666
 667     $output_deps_greatest_timestamp = 0;
 668
 669     $output_vars = '';
 670     $output_all = '';
 671     $output_header = '';
 672     $output_rules = '';
 673     $output_trailer = '';
 674
 675     Automake::Options::reset;
 676     Automake::Variable::reset;
 677     Automake::Rule::reset;
 678
 679     @cond_stack = ();
 680
 681     @include_stack = ();
 682
 683     @all = ();
 684     @check = ();
 685     @check_tests = ();
 686
 687     %clean_files = ();
 688     %compile_clean_files = ();
 689
 690     # We always include `.'.  This isn't strictly correct.
 691     %libtool_clean_directories = ('.' => 1);
 692
 693     @sources = ();
 694     @dist_sources = ();
 695
 696     %object_map = ();
 697     %object_compilation_map = ();
 698
 699     %directory_map = ();
 700
 701     %dep_files = ();
 702
 703     @dist_targets = ();
 704
 705     %known_programs = ();
 706     %known_libraries= ();
 707
 708     %de_ansi_files = ();
 709
 710     %extension_seen = ();
 711
 712     %language_scratch = ();
 713
 714     %lang_specific_files = ();
 715
 716     $handle_dist_run = 0;
 717
 718     $need_link = 0;
 719
 720     $get_object_extension_was_run = 0;
 721
 722     %transformed_files = ();
 723 }
 724
 725
 726 ################################################################
 727
 728 # Initialize our list of languages that are internally supported.
 729
 730 # C.
 731 register_language ('name' => 'c',
 732                    'Name' => 'C',
 733                    'config_vars' => ['CC'],
 734                    'ansi' => 1,
 735                    'autodep' => '',
 736                    'flags' => ['CFLAGS', 'CPPFLAGS'],
 737                    'ccer' => 'CC',
 738                    'compiler' => 'COMPILE',
 739                    'compile' => '$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)',
 740                    'lder' => 'CCLD',
 741                    'ld' => '$(CC)',
 742                    'linker' => 'LINK',
 743                    'link' => '$(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 744                    'compile_flag' => '-c',
 745                    'libtool_tag' => 'CC',
 746                    'extensions' => ['.c'],
 747                    '_finish' => \&lang_c_finish);
 748
 749 # C++.
 750 register_language ('name' => 'cxx',
 751                    'Name' => 'C++',
 752                    'config_vars' => ['CXX'],
 753                    'linker' => 'CXXLINK',
 754                    'link' => '$(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 755                    'autodep' => 'CXX',
 756                    'flags' => ['CXXFLAGS', 'CPPFLAGS'],
 757                    'compile' => '$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)',
 758                    'ccer' => 'CXX',
 759                    'compiler' => 'CXXCOMPILE',
 760                    'compile_flag' => '-c',
 761                    'output_flag' => '-o',
 762                    'libtool_tag' => 'CXX',
 763                    'lder' => 'CXXLD',
 764                    'ld' => '$(CXX)',
 765                    'pure' => 1,
 766                    'extensions' => ['.c++', '.cc', '.cpp', '.cxx', '.C']);
 767
 768 # Objective C.
 769 register_language ('name' => 'objc',
 770                    'Name' => 'Objective C',
 771                    'config_vars' => ['OBJC'],
 772                    'linker' => 'OBJCLINK',
 773                    'link' => '$(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 774                    'autodep' => 'OBJC',
 775                    'flags' => ['OBJCFLAGS', 'CPPFLAGS'],
 776                    'compile' => '$(OBJC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_OBJCFLAGS) $(OBJCFLAGS)',
 777                    'ccer' => 'OBJC',
 778                    'compiler' => 'OBJCCOMPILE',
 779                    'compile_flag' => '-c',
 780                    'output_flag' => '-o',
 781                    'lder' => 'OBJCLD',
 782                    'ld' => '$(OBJC)',
 783                    'pure' => 1,
 784                    'extensions' => ['.m']);
 785
 786 # Unified Parallel C.
 787 register_language ('name' => 'upc',
 788                    'Name' => 'Unified Parallel C',
 789                    'config_vars' => ['UPC'],
 790                    'linker' => 'UPCLINK',
 791                    'link' => '$(UPCLD) $(AM_UPCFLAGS) $(UPCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 792                    'autodep' => 'UPC',
 793                    'flags' => ['UPCFLAGS', 'CPPFLAGS'],
 794                    'compile' => '$(UPC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_UPCFLAGS) $(UPCFLAGS)',
 795                    'ccer' => 'UPC',
 796                    'compiler' => 'UPCCOMPILE',
 797                    'compile_flag' => '-c',
 798                    'output_flag' => '-o',
 799                    'lder' => 'UPCLD',
 800                    'ld' => '$(UPC)',
 801                    'pure' => 1,
 802                    'extensions' => ['.upc']);
 803
 804 # Headers.
 805 register_language ('name' => 'header',
 806                    'Name' => 'Header',
 807                    'extensions' => ['.h', '.H', '.hxx', '.h++', '.hh',
 808                                     '.hpp', '.inc'],
 809                    # No output.
 810                    'output_extensions' => sub { return () },
 811                    # Nothing to do.
 812                    '_finish' => sub { });
 813
 814 # Vala
 815 register_language ('name' => 'vala',
 816                    'Name' => 'Vala',
 817                    'config_vars' => ['VALAC'],
 818                    'flags' => [],
 819                    'compile' => '$(VALAC) $(AM_VALAFLAGS) $(VALAFLAGS)',
 820                    'ccer' => 'VALAC',
 821                    'compiler' => 'VALACOMPILE',
 822                    'extensions' => ['.vala'],
 823                    'output_extensions' => sub { (my $ext = $_[0]) =~ s/vala$/c/;
 824                                                 return ($ext,) },
 825                    'rule_file' => 'vala',
 826                    '_finish' => \&lang_vala_finish,
 827                    '_target_hook' => \&lang_vala_target_hook,
 828                    'nodist_specific' => 1);
 829
 830 # Yacc (C & C++).
 831 register_language ('name' => 'yacc',
 832                    'Name' => 'Yacc',
 833                    'config_vars' => ['YACC'],
 834                    'flags' => ['YFLAGS'],
 835                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
 836                    'ccer' => 'YACC',
 837                    'compiler' => 'YACCCOMPILE',
 838                    'extensions' => ['.y'],
 839                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
 840                                                 return ($ext,) },
 841                    'rule_file' => 'yacc',
 842                    '_finish' => \&lang_yacc_finish,
 843                    '_target_hook' => \&lang_yacc_target_hook,
 844                    'nodist_specific' => 1);
 845 register_language ('name' => 'yaccxx',
 846                    'Name' => 'Yacc (C++)',
 847                    'config_vars' => ['YACC'],
 848                    'rule_file' => 'yacc',
 849                    'flags' => ['YFLAGS'],
 850                    'ccer' => 'YACC',
 851                    'compiler' => 'YACCCOMPILE',
 852                    'compile' => '$(YACC) $(AM_YFLAGS) $(YFLAGS)',
 853                    'extensions' => ['.y++', '.yy', '.yxx', '.ypp'],
 854                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/y/c/;
 855                                                 return ($ext,) },
 856                    '_finish' => \&lang_yacc_finish,
 857                    '_target_hook' => \&lang_yacc_target_hook,
 858                    'nodist_specific' => 1);
 859
 860 # Lex (C & C++).
 861 register_language ('name' => 'lex',
 862                    'Name' => 'Lex',
 863                    'config_vars' => ['LEX'],
 864                    'rule_file' => 'lex',
 865                    'flags' => ['LFLAGS'],
 866                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
 867                    'ccer' => 'LEX',
 868                    'compiler' => 'LEXCOMPILE',
 869                    'extensions' => ['.l'],
 870                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
 871                                                 return ($ext,) },
 872                    '_finish' => \&lang_lex_finish,
 873                    '_target_hook' => \&lang_lex_target_hook,
 874                    'nodist_specific' => 1);
 875 register_language ('name' => 'lexxx',
 876                    'Name' => 'Lex (C++)',
 877                    'config_vars' => ['LEX'],
 878                    'rule_file' => 'lex',
 879                    'flags' => ['LFLAGS'],
 880                    'compile' => '$(LEX) $(AM_LFLAGS) $(LFLAGS)',
 881                    'ccer' => 'LEX',
 882                    'compiler' => 'LEXCOMPILE',
 883                    'extensions' => ['.l++', '.ll', '.lxx', '.lpp'],
 884                    'output_extensions' => sub { (my $ext = $_[0]) =~ tr/l/c/;
 885                                                 return ($ext,) },
 886                    '_finish' => \&lang_lex_finish,
 887                    '_target_hook' => \&lang_lex_target_hook,
 888                    'nodist_specific' => 1);
 889
 890 # Assembler.
 891 register_language ('name' => 'asm',
 892                    'Name' => 'Assembler',
 893                    'config_vars' => ['CCAS', 'CCASFLAGS'],
 894
 895                    'flags' => ['CCASFLAGS'],
 896                    # Users can set AM_CCASFLAGS to include DEFS, INCLUDES,
 897                    # or anything else required.  They can also set CCAS.
 898                    # Or simply use Preprocessed Assembler.
 899                    'compile' => '$(CCAS) $(AM_CCASFLAGS) $(CCASFLAGS)',
 900                    'ccer' => 'CCAS',
 901                    'compiler' => 'CCASCOMPILE',
 902                    'compile_flag' => '-c',
 903                    'output_flag' => '-o',
 904                    'extensions' => ['.s'],
 905
 906                    # With assembly we still use the C linker.
 907                    '_finish' => \&lang_c_finish);
 908
 909 # Preprocessed Assembler.
 910 register_language ('name' => 'cppasm',
 911                    'Name' => 'Preprocessed Assembler',
 912                    'config_vars' => ['CCAS', 'CCASFLAGS'],
 913
 914                    'autodep' => 'CCAS',
 915                    'flags' => ['CCASFLAGS', 'CPPFLAGS'],
 916                    'compile' => '$(CCAS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CCASFLAGS) $(CCASFLAGS)',
 917                    'ccer' => 'CPPAS',
 918                    'compiler' => 'CPPASCOMPILE',
 919                    'compile_flag' => '-c',
 920                    'output_flag' => '-o',
 921                    'extensions' => ['.S', '.sx'],
 922
 923                    # With assembly we still use the C linker.
 924                    '_finish' => \&lang_c_finish);
 925
 926 # Fortran 77
 927 register_language ('name' => 'f77',
 928                    'Name' => 'Fortran 77',
 929                    'config_vars' => ['F77'],
 930                    'linker' => 'F77LINK',
 931                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 932                    'flags' => ['FFLAGS'],
 933                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS)',
 934                    'ccer' => 'F77',
 935                    'compiler' => 'F77COMPILE',
 936                    'compile_flag' => '-c',
 937                    'output_flag' => '-o',
 938                    'libtool_tag' => 'F77',
 939                    'lder' => 'F77LD',
 940                    'ld' => '$(F77)',
 941                    'pure' => 1,
 942                    'extensions' => ['.f', '.for']);
 943
 944 # Fortran
 945 register_language ('name' => 'fc',
 946                    'Name' => 'Fortran',
 947                    'config_vars' => ['FC'],
 948                    'linker' => 'FCLINK',
 949                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 950                    'flags' => ['FCFLAGS'],
 951                    'compile' => '$(FC) $(AM_FCFLAGS) $(FCFLAGS)',
 952                    'ccer' => 'FC',
 953                    'compiler' => 'FCCOMPILE',
 954                    'compile_flag' => '-c',
 955                    'output_flag' => '-o',
 956                    'libtool_tag' => 'FC',
 957                    'lder' => 'FCLD',
 958                    'ld' => '$(FC)',
 959                    'pure' => 1,
 960                    'extensions' => ['.f90', '.f95', '.f03', '.f08']);
 961
 962 # Preprocessed Fortran
 963 register_language ('name' => 'ppfc',
 964                    'Name' => 'Preprocessed Fortran',
 965                    'config_vars' => ['FC'],
 966                    'linker' => 'FCLINK',
 967                    'link' => '$(FCLD) $(AM_FCFLAGS) $(FCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
 968                    'lder' => 'FCLD',
 969                    'ld' => '$(FC)',
 970                    'flags' => ['FCFLAGS', 'CPPFLAGS'],
 971                    'ccer' => 'PPFC',
 972                    'compiler' => 'PPFCCOMPILE',
 973                    'compile' => '$(FC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_FCFLAGS) $(FCFLAGS)',
 974                    'compile_flag' => '-c',
 975                    'output_flag' => '-o',
 976                    'libtool_tag' => 'FC',
 977                    'pure' => 1,
 978                    'extensions' => ['.F90','.F95', '.F03', '.F08']);
 979
 980 # Preprocessed Fortran 77
 981 #
 982 # The current support for preprocessing Fortran 77 just involves
 983 # passing `$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS)
 984 # $(CPPFLAGS)' as additional flags to the Fortran 77 compiler, since
 985 # this is how GNU Make does it; see the `GNU Make Manual, Edition 0.51
 986 # for `make' Version 3.76 Beta' (specifically, from info file
 987 # `(make)Catalogue of Rules').
 988 #
 989 # A better approach would be to write an Autoconf test
 990 # (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
 991 # Fortran 77 compilers know how to do preprocessing.  The Autoconf
 992 # macro AC_PROG_FPP should test the Fortran 77 compiler first for
 993 # preprocessing capabilities, and then fall back on cpp (if cpp were
 994 # available).
 995 register_language ('name' => 'ppf77',
 996                    'Name' => 'Preprocessed Fortran 77',
 997                    'config_vars' => ['F77'],
 998                    'linker' => 'F77LINK',
 999                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1000                    'lder' => 'F77LD',
1001                    'ld' => '$(F77)',
1002                    'flags' => ['FFLAGS', 'CPPFLAGS'],
1003                    'ccer' => 'PPF77',
1004                    'compiler' => 'PPF77COMPILE',
1005                    'compile' => '$(F77) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_FFLAGS) $(FFLAGS)',
1006                    'compile_flag' => '-c',
1007                    'output_flag' => '-o',
1008                    'libtool_tag' => 'F77',
1009                    'pure' => 1,
1010                    'extensions' => ['.F']);
1011
1012 # Ratfor.
1013 register_language ('name' => 'ratfor',
1014                    'Name' => 'Ratfor',
1015                    'config_vars' => ['F77'],
1016                    'linker' => 'F77LINK',
1017                    'link' => '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1018                    'lder' => 'F77LD',
1019                    'ld' => '$(F77)',
1020                    'flags' => ['RFLAGS', 'FFLAGS'],
1021                    # FIXME also FFLAGS.
1022                    'compile' => '$(F77) $(AM_FFLAGS) $(FFLAGS) $(AM_RFLAGS) $(RFLAGS)',
1023                    'ccer' => 'F77',
1024                    'compiler' => 'RCOMPILE',
1025                    'compile_flag' => '-c',
1026                    'output_flag' => '-o',
1027                    'libtool_tag' => 'F77',
1028                    'pure' => 1,
1029                    'extensions' => ['.r']);
1030
1031 # Java via gcj.
1032 register_language ('name' => 'java',
1033                    'Name' => 'Java',
1034                    'config_vars' => ['GCJ'],
1035                    'linker' => 'GCJLINK',
1036                    'link' => '$(GCJLD) $(AM_GCJFLAGS) $(GCJFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
1037                    'autodep' => 'GCJ',
1038                    'flags' => ['GCJFLAGS'],
1039                    'compile' => '$(GCJ) $(AM_GCJFLAGS) $(GCJFLAGS)',
1040                    'ccer' => 'GCJ',
1041                    'compiler' => 'GCJCOMPILE',
1042                    'compile_flag' => '-c',
1043                    'output_flag' => '-o',
1044                    'libtool_tag' => 'GCJ',
1045                    'lder' => 'GCJLD',
1046                    'ld' => '$(GCJ)',
1047                    'pure' => 1,
1048                    'extensions' => ['.java', '.class', '.zip', '.jar']);
1049
1050 ################################################################
1051
1052 # Error reporting functions.
1053
1054 # err_am ($MESSAGE, [%OPTIONS])
1055 # -----------------------------
1056 # Uncategorized errors about the current Makefile.am.
1057 sub err_am ($;%)
1058 {
1059   msg_am ('error', @_);
1060 }
1061
1062 # err_ac ($MESSAGE, [%OPTIONS])
1063 # -----------------------------
1064 # Uncategorized errors about configure.ac.
1065 sub err_ac ($;%)
1066 {
1067   msg_ac ('error', @_);
1068 }
1069
1070 # msg_am ($CHANNEL, $MESSAGE, [%OPTIONS])
1071 # ---------------------------------------
1072 # Messages about about the current Makefile.am.
1073 sub msg_am ($$;%)
1074 {
1075   my ($channel, $msg, %opts) = @_;
1076   msg $channel, "${am_file}.am", $msg, %opts;
1077 }
1078
1079 # msg_ac ($CHANNEL, $MESSAGE, [%OPTIONS])
1080 # ---------------------------------------
1081 # Messages about about configure.ac.
1082 sub msg_ac ($$;%)
1083 {
1084   my ($channel, $msg, %opts) = @_;
1085   msg $channel, $configure_ac, $msg, %opts;
1086 }
1087
1088 ################################################################
1089
1090 # subst ($TEXT)
1091 # -------------
1092 # Return a configure-style substitution using the indicated text.
1093 # We do this to avoid having the substitutions directly in automake.in;
1094 # when we do that they are sometimes removed and this causes confusion
1095 # and bugs.
1096 sub subst ($)
1097 {
1098     my ($text) = @_;
1099     return '@' . $text . '@';
1100 }
1101
1102 ################################################################
1103
1104
1105 # $BACKPATH
1106 # &backname ($REL-DIR)
1107 # --------------------
1108 # If I `cd $REL-DIR', then to come back, I should `cd $BACKPATH'.
1109 # For instance `src/foo' => `../..'.
1110 # Works with non strictly increasing paths, i.e., `src/../lib' => `..'.
1111 sub backname ($)
1112 {
1113     my ($file) = @_;
1114     my @res;
1115     foreach (split (/\//, $file))
1116     {
1117         next if $_ eq '.' || $_ eq '';
1118         if ($_ eq '..')
1119         {
1120             pop @res
1121               or prog_error ("trying to reverse path `$file' pointing outside tree");
1122         }
1123         else
1124         {
1125             push (@res, '..');
1126         }
1127     }
1128     return join ('/', @res) || '.';
1129 }
1130
1131 ################################################################
1132
1133 # `silent-rules' mode handling functions.
1134
1135 # verbose_var (NAME)
1136 # ------------------
1137 # The public variable stem used to implement `silent-rules'.
1138 sub verbose_var ($)
1139 {
1140     my ($name) = @_;
1141     return 'AM_V_' . $name;
1142 }
1143
1144 # verbose_private_var (NAME)
1145 # --------------------------
1146 # The naming policy for the private variables for `silent-rules'.
1147 sub verbose_private_var ($)
1148 {
1149     my ($name) = @_;
1150     return 'am__v_' . $name;
1151 }
1152
1153 # define_verbose_var (NAME, VAL)
1154 # ------------------------------
1155 # For `silent-rules' mode, setup VAR and dispatcher, to expand to VAL if silent.
1156 sub define_verbose_var ($$)
1157 {
1158     my ($name, $val) = @_;
1159     my $var = verbose_var ($name);
1160     my $pvar = verbose_private_var ($name);
1161     my $silent_var = $pvar . '_0';
1162     if (option 'silent-rules')
1163       {
1164         # For typical `make's, `configure' replaces AM_V (inside @@) with $(V)
1165         # and AM_DEFAULT_V (inside @@) with $(AM_DEFAULT_VERBOSITY).
1166         # For strict POSIX 2008 `make's, it replaces them with 0 or 1 instead.
1167         # See AM_SILENT_RULES in m4/silent.m4.
1168         define_variable ($var, '$(' . $pvar . '_@'.'AM_V'.'@)', INTERNAL);
1169         define_variable ($pvar . '_', '$(' . $pvar . '_@'.'AM_DEFAULT_V'.'@)', 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 ('EXTRA_' . $xname . '_DEPENDENCIES');
2682       set_seen ($xname . '_LDFLAGS');
2683
2684       # Determine program to use for link.
2685       my($xlink, $vlink) = &define_per_target_linker_variable ($linker, $xname);
2686       $vlink = verbose_flag ($vlink || 'GEN');
2687
2688       # If the resulting program lies into a subdirectory,
2689       # make sure this directory will exist.
2690       my $dirstamp = require_build_directory_maybe ($one_file);
2691
2692       $libtool_clean_directories{dirname ($one_file)} = 1;
2693
2694       $output_rules .= &file_contents ('program',
2695                                        $where,
2696                                        PROGRAM  => $one_file,
2697                                        XPROGRAM => $xname,
2698                                        XLINK    => $xlink,
2699                                        VERBOSE  => $vlink,
2700                                        DIRSTAMP => $dirstamp,
2701                                        EXEEXT   => '$(EXEEXT)');
2702
2703       if ($seen_libobjs || $seen_global_libobjs)
2704         {
2705           if (var ($xname . '_LDADD'))
2706             {
2707               &check_libobjs_sources ($xname, $xname . '_LDADD');
2708             }
2709           elsif (var ('LDADD'))
2710             {
2711               &check_libobjs_sources ($xname, 'LDADD');
2712             }
2713         }
2714     }
2715 }
2716
2717
2718 # handle_libraries ()
2719 # -------------------
2720 # Handle libraries.
2721 sub handle_libraries
2722 {
2723   my @liblist = &am_install_var ('libs', 'LIBRARIES',
2724                                  'lib', 'pkglib', 'noinst', 'check');
2725   return if ! @liblist;
2726
2727   my @prefix = am_primary_prefixes ('LIBRARIES', 0, 'lib', 'pkglib',
2728                                     'noinst', 'check');
2729
2730   if (@prefix)
2731     {
2732       my $var = rvar ($prefix[0] . '_LIBRARIES');
2733       $var->requires_variables ('library used', 'RANLIB');
2734     }
2735
2736   &define_variable ('AR', 'ar', INTERNAL);
2737   &define_variable ('ARFLAGS', 'cru', INTERNAL);
2738   &define_verbose_tagvar ('AR');
2739
2740   foreach my $pair (@liblist)
2741     {
2742       my ($where, $onelib) = @$pair;
2743
2744       my $seen_libobjs = 0;
2745       # Check that the library fits the standard naming convention.
2746       my $bn = basename ($onelib);
2747       if ($bn !~ /^lib.*\.a$/)
2748         {
2749           $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.a/;
2750           my $suggestion = dirname ($onelib) . "/$bn";
2751           $suggestion =~ s|^\./||g;
2752           msg ('error-gnu/warn', $where,
2753                "`$onelib' is not a standard library name\n"
2754                . "did you mean `$suggestion'?")
2755         }
2756
2757       ($known_libraries{$onelib} = $bn) =~ s/\.a$//;
2758
2759       $where->push_context ("while processing library `$onelib'");
2760       $where->set (INTERNAL->get);
2761
2762       my $obj = get_object_extension '.$(OBJEXT)';
2763
2764       # Canonicalize names and check for misspellings.
2765       my $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
2766                                             '_OBJECTS', '_DEPENDENCIES',
2767                                             '_AR');
2768
2769       if (! var ($xlib . '_AR'))
2770         {
2771           &define_variable ($xlib . '_AR', '$(AR) $(ARFLAGS)', $where);
2772         }
2773
2774       # Generate support for conditional object inclusion in
2775       # libraries.
2776       if (var ($xlib . '_LIBADD'))
2777         {
2778           if (&handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2779             {
2780               $seen_libobjs = 1;
2781             }
2782         }
2783       else
2784         {
2785           &define_variable ($xlib . "_LIBADD", '', $where);
2786         }
2787
2788       reject_var ($xlib . '_LDADD',
2789                   "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
2790
2791       # Make sure we at look at this.
2792       set_seen ($xlib . '_DEPENDENCIES');
2793       set_seen ('EXTRA_' . $xlib . '_DEPENDENCIES');
2794
2795       &handle_source_transform ($xlib, $onelib, $obj, $where,
2796                                 NONLIBTOOL => 1, LIBTOOL => 0);
2797
2798       # If the resulting library lies into a subdirectory,
2799       # make sure this directory will exist.
2800       my $dirstamp = require_build_directory_maybe ($onelib);
2801       my $verbose = verbose_flag ('AR');
2802       my $silent = silent_flag ();
2803
2804       $output_rules .= &file_contents ('library',
2805                                        $where,
2806                                        VERBOSE  => $verbose,
2807                                        SILENT   => $silent,
2808                                        LIBRARY  => $onelib,
2809                                        XLIBRARY => $xlib,
2810                                        DIRSTAMP => $dirstamp);
2811
2812       if ($seen_libobjs)
2813         {
2814           if (var ($xlib . '_LIBADD'))
2815             {
2816               &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
2817             }
2818         }
2819     }
2820 }
2821
2822
2823 # handle_ltlibraries ()
2824 # ---------------------
2825 # Handle shared libraries.
2826 sub handle_ltlibraries
2827 {
2828   my @liblist = &am_install_var ('ltlib', 'LTLIBRARIES',
2829                                  'noinst', 'lib', 'pkglib', 'check');
2830   return if ! @liblist;
2831
2832   my @prefix = am_primary_prefixes ('LTLIBRARIES', 0, 'lib', 'pkglib',
2833                                     'noinst', 'check');
2834
2835   if (@prefix)
2836     {
2837       my $var = rvar ($prefix[0] . '_LTLIBRARIES');
2838       $var->requires_variables ('Libtool library used', 'LIBTOOL');
2839     }
2840
2841   my %instdirs = ();
2842   my %instsubdirs = ();
2843   my %instconds = ();
2844   my %liblocations = ();        # Location (in Makefile.am) of each library.
2845
2846   foreach my $key (@prefix)
2847     {
2848       # Get the installation directory of each library.
2849       my $dir = $key;
2850       my $strip_subdir = 1;
2851       if ($dir =~ /^nobase_/)
2852         {
2853           $dir =~ s/^nobase_//;
2854           $strip_subdir = 0;
2855         }
2856       my $var = rvar ($key . '_LTLIBRARIES');
2857
2858       # We reject libraries which are installed in several places
2859       # in the same condition, because we can only specify one
2860       # `-rpath' option.
2861       $var->traverse_recursively
2862         (sub
2863          {
2864            my ($var, $val, $cond, $full_cond) = @_;
2865            my $hcond = $full_cond->human;
2866            my $where = $var->rdef ($cond)->location;
2867            my $ldir = '';
2868            $ldir = '/' . dirname ($val)
2869              if (!$strip_subdir);
2870            # A library cannot be installed in different directories
2871            # in overlapping conditions.
2872            if (exists $instconds{$val})
2873              {
2874                my ($msg, $acond) =
2875                  $instconds{$val}->ambiguous_p ($val, $full_cond);
2876
2877                if ($msg)
2878                  {
2879                    error ($where, $msg, partial => 1);
2880                    my $dirtxt = "installed " . ($strip_subdir ? "in" : "below") . " `$dir'";
2881                    $dirtxt = "built for `$dir'"
2882                      if $dir eq 'EXTRA' || $dir eq 'noinst' || $dir eq 'check';
2883                    my $dircond =
2884                      $full_cond->true ? "" : " in condition $hcond";
2885
2886                    error ($where, "`$val' should be $dirtxt$dircond ...",
2887                           partial => 1);
2888
2889                    my $hacond = $acond->human;
2890                    my $adir = $instdirs{$val}{$acond};
2891                    my $adirtxt = "installed in `$adir'";
2892                    $adirtxt = "built for `$adir'"
2893                      if ($adir eq 'EXTRA' || $adir eq 'noinst'
2894                          || $adir eq 'check');
2895                    my $adircond = $acond->true ? "" : " in condition $hacond";
2896
2897                    my $onlyone = ($dir ne $adir) ?
2898                      ("\nLibtool libraries can be built for only one "
2899                       . "destination.") : "";
2900
2901                    error ($liblocations{$val}{$acond},
2902                           "... and should also be $adirtxt$adircond.$onlyone");
2903                    return;
2904                  }
2905              }
2906            else
2907              {
2908                $instconds{$val} = new Automake::DisjConditions;
2909              }
2910            $instdirs{$val}{$full_cond} = $dir;
2911            $instsubdirs{$val}{$full_cond} = $ldir;
2912            $liblocations{$val}{$full_cond} = $where;
2913            $instconds{$val} = $instconds{$val}->merge ($full_cond);
2914          },
2915          sub
2916          {
2917            return ();
2918          },
2919          skip_ac_subst => 1);
2920     }
2921
2922   foreach my $pair (@liblist)
2923     {
2924       my ($where, $onelib) = @$pair;
2925
2926       my $seen_libobjs = 0;
2927       my $obj = get_object_extension '.lo';
2928
2929       # Canonicalize names and check for misspellings.
2930       my $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
2931                                             '_SOURCES', '_OBJECTS',
2932                                             '_DEPENDENCIES');
2933
2934       # Check that the library fits the standard naming convention.
2935       my $libname_rx = '^lib.*\.la';
2936       my $ldvar = var ("${xlib}_LDFLAGS") || var ('AM_LDFLAGS');
2937       my $ldvar2 = var ('LDFLAGS');
2938       if (($ldvar && grep (/-module/, $ldvar->value_as_list_recursive))
2939           || ($ldvar2 && grep (/-module/, $ldvar2->value_as_list_recursive)))
2940         {
2941           # Relax name checking for libtool modules.
2942           $libname_rx = '\.la';
2943         }
2944
2945       my $bn = basename ($onelib);
2946       if ($bn !~ /$libname_rx$/)
2947         {
2948           my $type = 'library';
2949           if ($libname_rx eq '\.la')
2950             {
2951               $bn =~ s/^(lib|)(.*?)(?:\.[^.]*)?$/$1$2.la/;
2952               $type = 'module';
2953             }
2954           else
2955             {
2956               $bn =~ s/^(?:lib)?(.*?)(?:\.[^.]*)?$/lib$1.la/;
2957             }
2958           my $suggestion = dirname ($onelib) . "/$bn";
2959           $suggestion =~ s|^\./||g;
2960           msg ('error-gnu/warn', $where,
2961                "`$onelib' is not a standard libtool $type name\n"
2962                . "did you mean `$suggestion'?")
2963         }
2964
2965       ($known_libraries{$onelib} = $bn) =~ s/\.la$//;
2966
2967       $where->push_context ("while processing Libtool library `$onelib'");
2968       $where->set (INTERNAL->get);
2969
2970       # Make sure we look at these.
2971       set_seen ($xlib . '_LDFLAGS');
2972       set_seen ($xlib . '_DEPENDENCIES');
2973       set_seen ('EXTRA_' . $xlib . '_DEPENDENCIES');
2974
2975       # Generate support for conditional object inclusion in
2976       # libraries.
2977       if (var ($xlib . '_LIBADD'))
2978         {
2979           if (&handle_lib_objects ($xlib, $xlib . '_LIBADD'))
2980             {
2981               $seen_libobjs = 1;
2982             }
2983         }
2984       else
2985         {
2986           &define_variable ($xlib . "_LIBADD", '', $where);
2987         }
2988
2989       reject_var ("${xlib}_LDADD",
2990                   "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
2991
2992
2993       my $linker = &handle_source_transform ($xlib, $onelib, $obj, $where,
2994                                              NONLIBTOOL => 0, LIBTOOL => 1);
2995
2996       # Determine program to use for link.
2997       my($xlink, $vlink) = &define_per_target_linker_variable ($linker, $xlib);
2998       $vlink = verbose_flag ($vlink || 'GEN');
2999
3000       my $rpathvar = "am_${xlib}_rpath";
3001       my $rpath = "\$($rpathvar)";
3002       foreach my $rcond ($instconds{$onelib}->conds)
3003         {
3004           my $val;
3005           if ($instdirs{$onelib}{$rcond} eq 'EXTRA'
3006               || $instdirs{$onelib}{$rcond} eq 'noinst'
3007               || $instdirs{$onelib}{$rcond} eq 'check')
3008             {
3009               # It's an EXTRA_ library, so we can't specify -rpath,
3010               # because we don't know where the library will end up.
3011               # The user probably knows, but generally speaking automake
3012               # doesn't -- and in fact configure could decide
3013               # dynamically between two different locations.
3014               $val = '';
3015             }
3016           else
3017             {
3018               $val = ('-rpath $(' . $instdirs{$onelib}{$rcond} . 'dir)');
3019               $val .= $instsubdirs{$onelib}{$rcond}
3020                 if defined $instsubdirs{$onelib}{$rcond};
3021             }
3022           if ($rcond->true)
3023             {
3024               # If $rcond is true there is only one condition and
3025               # there is no point defining an helper variable.
3026               $rpath = $val;
3027             }
3028           else
3029             {
3030               define_pretty_variable ($rpathvar, $rcond, INTERNAL, $val);
3031             }
3032         }
3033
3034       # If the resulting library lies into a subdirectory,
3035       # make sure this directory will exist.
3036       my $dirstamp = require_build_directory_maybe ($onelib);
3037
3038       # Remember to cleanup .libs/ in this directory.
3039       my $dirname = dirname $onelib;
3040       $libtool_clean_directories{$dirname} = 1;
3041
3042       $output_rules .= &file_contents ('ltlibrary',
3043                                        $where,
3044                                        LTLIBRARY  => $onelib,
3045                                        XLTLIBRARY => $xlib,
3046                                        RPATH      => $rpath,
3047                                        XLINK      => $xlink,
3048                                        VERBOSE    => $vlink,
3049                                        DIRSTAMP   => $dirstamp);
3050       if ($seen_libobjs)
3051         {
3052           if (var ($xlib . '_LIBADD'))
3053             {
3054               &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
3055             }
3056         }
3057     }
3058 }
3059
3060 # See if any _SOURCES variable were misspelled.
3061 sub check_typos ()
3062 {
3063   # It is ok if the user sets this particular variable.
3064   set_seen 'AM_LDFLAGS';
3065
3066   foreach my $primary ('SOURCES', 'LIBADD', 'LDADD', 'LDFLAGS', 'DEPENDENCIES')
3067     {
3068       foreach my $var (variables $primary)
3069         {
3070           my $varname = $var->name;
3071           # A configure variable is always legitimate.
3072           next if exists $configure_vars{$varname};
3073
3074           for my $cond ($var->conditions->conds)
3075             {
3076               $varname =~ /^(?:nobase_)?(?:dist_|nodist_)?(.*)_[[:alnum:]]+$/;
3077               msg_var ('syntax', $var, "variable `$varname' is defined but no"
3078                        . " program or\nlibrary has `$1' as canonical name"
3079                        . " (possible typo)")
3080                 unless $var->rdef ($cond)->seen;
3081             }
3082         }
3083     }
3084 }
3085
3086
3087 # Handle scripts.
3088 sub handle_scripts
3089 {
3090     # NOTE we no longer automatically clean SCRIPTS, because it is
3091     # useful to sometimes distribute scripts verbatim.  This happens
3092     # e.g. in Automake itself.
3093     &am_install_var ('-candist', 'scripts', 'SCRIPTS',
3094                      'bin', 'sbin', 'libexec', 'pkglibexec', 'pkgdata',
3095                      'noinst', 'check');
3096 }
3097
3098
3099
3100
3101 ## ------------------------ ##
3102 ## Handling Texinfo files.  ##
3103 ## ------------------------ ##
3104
3105 # ($OUTFILE, $VFILE, @CLEAN_FILES)
3106 # &scan_texinfo_file ($FILENAME)
3107 # ------------------------------
3108 # $OUTFILE     - name of the info file produced by $FILENAME.
3109 # $VFILE       - name of the version.texi file used (undef if none).
3110 # @CLEAN_FILES - list of byproducts (indexes etc.)
3111 sub scan_texinfo_file ($)
3112 {
3113   my ($filename) = @_;
3114
3115   # Some of the following extensions are always created, no matter
3116   # whether indexes are used or not.  Other (like cps, fns, ... pgs)
3117   # are only created when they are used.  We used to scan $FILENAME
3118   # for their use, but that is not enough: they could be used in
3119   # included files.  We can't scan included files because we don't
3120   # know the include path.  Therefore we always erase these files, no
3121   # matter whether they are used or not.
3122   #
3123   # (tmp is only created if an @macro is used and a certain e-TeX
3124   # feature is not available.)
3125   my %clean_suffixes =
3126     map { $_ => 1 } (qw(aux log toc tmp
3127                         cp cps
3128                         fn fns
3129                         ky kys
3130                         vr vrs
3131                         tp tps
3132                         pg pgs)); # grep 'new.*index' texinfo.tex
3133
3134   my $texi = new Automake::XFile "< $filename";
3135   verb "reading $filename";
3136
3137   my ($outfile, $vfile);
3138   while ($_ = $texi->getline)
3139     {
3140       if (/^\@setfilename +(\S+)/)
3141         {
3142           # Honor only the first @setfilename.  (It's possible to have
3143           # more occurrences later if the manual shows examples of how
3144           # to use @setfilename...)
3145           next if $outfile;
3146
3147           $outfile = $1;
3148           if ($outfile =~ /\.([^.]+)$/ && $1 ne 'info')
3149             {
3150               error ("$filename:$.",
3151                      "output `$outfile' has unrecognized extension");
3152               return;
3153             }
3154         }
3155       # A "version.texi" file is actually any file whose name matches
3156       # "vers*.texi".
3157       elsif (/^\@include\s+(vers[^.]*\.texi)\s*$/)
3158         {
3159           $vfile = $1;
3160         }
3161
3162       # Try to find new or unused indexes.
3163
3164       # Creating a new category of index.
3165       elsif (/^\@def(code)?index (\w+)/)
3166         {
3167           $clean_suffixes{$2} = 1;
3168           $clean_suffixes{"$2s"} = 1;
3169         }
3170
3171       # Merging an index into an another.
3172       elsif (/^\@syn(code)?index (\w+) (\w+)/)
3173         {
3174           delete $clean_suffixes{"$2s"};
3175           $clean_suffixes{"$3s"} = 1;
3176         }
3177
3178     }
3179
3180   if (! $outfile)
3181     {
3182       err_am "`$filename' missing \@setfilename";
3183       return;
3184     }
3185
3186   my $infobase = basename ($filename);
3187   $infobase =~ s/\.te?xi(nfo)?$//;
3188   return ($outfile, $vfile,
3189           map { "$infobase.$_" } (sort keys %clean_suffixes));
3190 }
3191
3192
3193 # ($DIRSTAMP, @CLEAN_FILES)
3194 # output_texinfo_build_rules ($SOURCE, $DEST, $INSRC, @DEPENDENCIES)
3195 # ------------------------------------------------------------------
3196 # SOURCE - the source Texinfo file
3197 # DEST - the destination Info file
3198 # INSRC - whether DEST should be built in the source tree
3199 # DEPENDENCIES - known dependencies
3200 sub output_texinfo_build_rules ($$$@)
3201 {
3202   my ($source, $dest, $insrc, @deps) = @_;
3203
3204   # Split `a.texi' into `a' and `.texi'.
3205   my ($spfx, $ssfx) = ($source =~ /^(.*?)(\.[^.]*)?$/);
3206   my ($dpfx, $dsfx) = ($dest =~ /^(.*?)(\.[^.]*)?$/);
3207
3208   $ssfx ||= "";
3209   $dsfx ||= "";
3210
3211   # We can output two kinds of rules: the "generic" rules use Make
3212   # suffix rules and are appropriate when $source and $dest do not lie
3213   # in a sub-directory; the "specific" rules are needed in the other
3214   # case.
3215   #
3216   # The former are output only once (this is not really apparent here,
3217   # but just remember that some logic deeper in Automake will not
3218   # output the same rule twice); while the later need to be output for
3219   # each Texinfo source.
3220   my $generic;
3221   my $makeinfoflags;
3222   my $sdir = dirname $source;
3223   if ($sdir eq '.' && dirname ($dest) eq '.')
3224     {
3225       $generic = 1;
3226       $makeinfoflags = '-I $(srcdir)';
3227     }
3228   else
3229     {
3230       $generic = 0;
3231       $makeinfoflags = "-I $sdir -I \$(srcdir)/$sdir";
3232     }
3233
3234   # A directory can contain two kinds of info files: some built in the
3235   # source tree, and some built in the build tree.  The rules are
3236   # different in each case.  However we cannot output two different
3237   # set of generic rules.  Because in-source builds are more usual, we
3238   # use generic rules in this case and fall back to "specific" rules
3239   # for build-dir builds.  (It should not be a problem to invert this
3240   # if needed.)
3241   $generic = 0 unless $insrc;
3242
3243   # We cannot use a suffix rule to build info files with an empty
3244   # extension.  Otherwise we would output a single suffix inference
3245   # rule, with separate dependencies, as in
3246   #
3247   #    .texi:
3248   #             $(MAKEINFO) ...
3249   #    foo.info: foo.texi
3250   #
3251   # which confuse Solaris make.  (See the Autoconf manual for
3252   # details.)  Therefore we use a specific rule in this case.  This
3253   # applies to info files only (dvi and pdf files always have an
3254   # extension).
3255   my $generic_info = ($generic && $dsfx) ? 1 : 0;
3256
3257   # If the resulting file lie into a subdirectory,
3258   # make sure this directory will exist.
3259   my $dirstamp = require_build_directory_maybe ($dest);
3260
3261   my $dipfx = ($insrc ? '$(srcdir)/' : '') . $dpfx;
3262
3263   $output_rules .= file_contents ('texibuild',
3264                                   new Automake::Location,
3265                                   DEPS             => "@deps",
3266                                   DEST_PREFIX      => $dpfx,
3267                                   DEST_INFO_PREFIX => $dipfx,
3268                                   DEST_SUFFIX      => $dsfx,
3269                                   DIRSTAMP         => $dirstamp,
3270                                   GENERIC          => $generic,
3271                                   GENERIC_INFO     => $generic_info,
3272                                   INSRC            => $insrc,
3273                                   MAKEINFOFLAGS    => $makeinfoflags,
3274                                   SOURCE           => ($generic
3275                                                        ? '$<' : $source),
3276                                   SOURCE_INFO      => ($generic_info
3277                                                        ? '$<' : $source),
3278                                   SOURCE_REAL      => $source,
3279                                   SOURCE_SUFFIX    => $ssfx,
3280                                   );
3281   return ($dirstamp, "$dpfx.dvi", "$dpfx.pdf", "$dpfx.ps", "$dpfx.html");
3282 }
3283
3284
3285 # ($MOSTLYCLEAN, $TEXICLEAN, $MAINTCLEAN)
3286 # handle_texinfo_helper ($info_texinfos)
3287 # --------------------------------------
3288 # Handle all Texinfo source; helper for handle_texinfo.
3289 sub handle_texinfo_helper ($)
3290 {
3291   my ($info_texinfos) = @_;
3292   my (@infobase, @info_deps_list, @texi_deps);
3293   my %versions;
3294   my $done = 0;
3295   my (@mostly_cleans, @texi_cleans, @maint_cleans) = ('', '', '');
3296
3297   # Build a regex matching user-cleaned files.
3298   my $d = var 'DISTCLEANFILES';
3299   my $c = var 'CLEANFILES';
3300   my @f = ();
3301   push @f, $d->value_as_list_recursive (inner_expand => 1) if $d;
3302   push @f, $c->value_as_list_recursive (inner_expand => 1) if $c;
3303   @f = map { s|[^A-Za-z_0-9*\[\]\-]|\\$&|g; s|\*|[^/]*|g; $_; } @f;
3304   my $user_cleaned_files = '^(?:' . join ('|', @f) . ')$';
3305
3306   foreach my $texi
3307       ($info_texinfos->value_as_list_recursive (inner_expand => 1))
3308     {
3309       my $infobase = $texi;
3310       $infobase =~ s/\.(txi|texinfo|texi)$//;
3311
3312       if ($infobase eq $texi)
3313         {
3314           # FIXME: report line number.
3315           err_am "texinfo file `$texi' has unrecognized extension";
3316           next;
3317         }
3318
3319       push @infobase, $infobase;
3320
3321       # If 'version.texi' is referenced by input file, then include
3322       # automatic versioning capability.
3323       my ($out_file, $vtexi, @clean_files) =
3324         scan_texinfo_file ("$relative_dir/$texi")
3325         or next;
3326       push (@mostly_cleans, @clean_files);
3327
3328       # If the Texinfo source is in a subdirectory, create the
3329       # resulting info in this subdirectory.  If it is in the current
3330       # directory, try hard to not prefix "./" because it breaks the
3331       # generic rules.
3332       my $outdir = dirname ($texi) . '/';
3333       $outdir = "" if $outdir eq './';
3334       $out_file =  $outdir . $out_file;
3335
3336       # Until Automake 1.6.3, .info files were built in the
3337       # source tree.  This was an obstacle to the support of
3338       # non-distributed .info files, and non-distributed .texi
3339       # files.
3340       #
3341       # * Non-distributed .texi files is important in some packages
3342       #   where .texi files are built at make time, probably using
3343       #   other binaries built in the package itself, maybe using
3344       #   tools or information found on the build host.  Because
3345       #   these files are not distributed they are always rebuilt
3346       #   at make time; they should therefore not lie in the source
3347       #   directory.  One plan was to support this using
3348       #   nodist_info_TEXINFOS or something similar.  (Doing this
3349       #   requires some sanity checks.  For instance Automake should
3350       #   not allow:
3351       #      dist_info_TEXINFOS = foo.texi
3352       #      nodist_foo_TEXINFOS = included.texi
3353       #   because a distributed file should never depend on a
3354       #   non-distributed file.)
3355       #
3356       # * If .texi files are not distributed, then .info files should
3357       #   not be distributed either.  There are also cases where one
3358       #   wants to distribute .texi files, but does not want to
3359       #   distribute the .info files.  For instance the Texinfo package
3360       #   distributes the tool used to build these files; it would
3361       #   be a waste of space to distribute them.  It's not clear
3362       #   which syntax we should use to indicate that .info files should
3363       #   not be distributed.  Akim Demaille suggested that eventually
3364       #   we switch to a new syntax:
3365       #   |  Maybe we should take some inspiration from what's already
3366       #   |  done in the rest of Automake.  Maybe there is too much
3367       #   |  syntactic sugar here, and you want
3368       #   |     nodist_INFO = bar.info
3369       #   |     dist_bar_info_SOURCES = bar.texi
3370       #   |     bar_texi_DEPENDENCIES = foo.texi
3371       #   |  with a bit of magic to have bar.info represent the whole
3372       #   |  bar*info set.  That's a lot more verbose that the current
3373       #   |  situation, but it is # not new, hence the user has less
3374       #   |  to learn.
3375       #   |
3376       #   |  But there is still too much room for meaningless specs:
3377       #   |     nodist_INFO = bar.info
3378       #   |     dist_bar_info_SOURCES = bar.texi
3379       #   |     dist_PS = bar.ps something-written-by-hand.ps
3380       #   |     nodist_bar_ps_SOURCES = bar.texi
3381       #   |     bar_texi_DEPENDENCIES = foo.texi
3382       #   |  here bar.texi is dist_ in line 2, and nodist_ in 4.
3383       #
3384       # Back to the point, it should be clear that in order to support
3385       # non-distributed .info files, we need to build them in the
3386       # build tree, not in the source tree (non-distributed .texi
3387       # files are less of a problem, because we do not output build
3388       # rules for them).  In Automake 1.7 .info build rules have been
3389       # largely cleaned up so that .info files get always build in the
3390       # build tree, even when distributed.  The idea was that
3391       #   (1) if during a VPATH build the .info file was found to be
3392       #       absent or out-of-date (in the source tree or in the
3393       #       build tree), Make would rebuild it in the build tree.
3394       #       If an up-to-date source-tree of the .info file existed,
3395       #       make would not rebuild it in the build tree.
3396       #   (2) having two copies of .info files, one in the source tree
3397       #       and one (newer) in the build tree is not a problem
3398       #       because `make dist' always pick files in the build tree
3399       #       first.
3400       # However it turned out the be a bad idea for several reasons:
3401       #   * Tru64, OpenBSD, and FreeBSD (not NetBSD) Make do not behave
3402       #     like GNU Make on point (1) above.  These implementations
3403       #     of Make would always rebuild .info files in the build
3404       #     tree, even if such files were up to date in the source
3405       #     tree.  Consequently, it was impossible to perform a VPATH
3406       #     build of a package containing Texinfo files using these
3407       #     Make implementations.
3408       #     (Refer to the Autoconf Manual, section "Limitation of
3409       #     Make", paragraph "VPATH", item "target lookup", for
3410       #     an account of the differences between these
3411       #     implementations.)
3412       #   * The GNU Coding Standards require these files to be built
3413       #     in the source-tree (when they are distributed, that is).
3414       #   * Keeping a fresher copy of distributed files in the
3415       #     build tree can be annoying during development because
3416       #     - if the files is kept under CVS, you really want it
3417       #       to be updated in the source tree
3418       #     - it is confusing that `make distclean' does not erase
3419       #       all files in the build tree.
3420       #
3421       # Consequently, starting with Automake 1.8, .info files are
3422       # built in the source tree again.  Because we still plan to
3423       # support non-distributed .info files at some point, we
3424       # have a single variable ($INSRC) that controls whether
3425       # the current .info file must be built in the source tree
3426       # or in the build tree.  Actually this variable is switched
3427       # off for .info files that appear to be cleaned; this is
3428       # for backward compatibility with package such as Texinfo,
3429       # which do things like
3430       #   info_TEXINFOS = texinfo.txi info-stnd.texi info.texi
3431       #   DISTCLEANFILES = texinfo texinfo-* info*.info*
3432       #   # Do not create info files for distribution.
3433       #   dist-info:
3434       # in order not to distribute .info files.
3435       my $insrc = ($out_file =~ $user_cleaned_files) ? 0 : 1;
3436
3437       my $soutdir = '$(srcdir)/' . $outdir;
3438       $outdir = $soutdir if $insrc;
3439
3440       # If user specified file_TEXINFOS, then use that as explicit
3441       # dependency list.
3442       @texi_deps = ();
3443       push (@texi_deps, "$soutdir$vtexi") if $vtexi;
3444
3445       my $canonical = canonicalize ($infobase);
3446       if (var ($canonical . "_TEXINFOS"))
3447         {
3448           push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
3449           push_dist_common ('$(' . $canonical . '_TEXINFOS)');
3450         }
3451
3452       my ($dirstamp, @cfiles) =
3453         output_texinfo_build_rules ($texi, $out_file, $insrc, @texi_deps);
3454       push (@texi_cleans, @cfiles);
3455
3456       push (@info_deps_list, $out_file);
3457
3458       # If a vers*.texi file is needed, emit the rule.
3459       if ($vtexi)
3460         {
3461           err_am ("`$vtexi', included in `$texi', "
3462                   . "also included in `$versions{$vtexi}'")
3463             if defined $versions{$vtexi};
3464           $versions{$vtexi} = $texi;
3465
3466           # We number the stamp-vti files.  This is doable since the
3467           # actual names don't matter much.  We only number starting
3468           # with the second one, so that the common case looks nice.
3469           my $vti = ($done ? $done : 'vti');
3470           ++$done;
3471
3472           # This is ugly, but it is our historical practice.
3473           if ($config_aux_dir_set_in_configure_ac)
3474             {
3475               require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3476                                             'mdate-sh');
3477             }
3478           else
3479             {
3480               require_file_with_macro (TRUE, 'info_TEXINFOS',
3481                                        FOREIGN, 'mdate-sh');
3482             }
3483
3484           my $conf_dir;
3485           if ($config_aux_dir_set_in_configure_ac)
3486             {
3487               $conf_dir = "$am_config_aux_dir/";
3488             }
3489           else
3490             {
3491               $conf_dir = '$(srcdir)/';
3492             }
3493           $output_rules .= file_contents ('texi-vers',
3494                                           new Automake::Location,
3495                                           TEXI     => $texi,
3496                                           VTI      => $vti,
3497                                           STAMPVTI => "${soutdir}stamp-$vti",
3498                                           VTEXI    => "$soutdir$vtexi",
3499                                           MDDIR    => $conf_dir,
3500                                           DIRSTAMP => $dirstamp);
3501         }
3502     }
3503
3504   # Handle location of texinfo.tex.
3505   my $need_texi_file = 0;
3506   my $texinfodir;
3507   if (var ('TEXINFO_TEX'))
3508     {
3509       # The user defined TEXINFO_TEX so assume he knows what he is
3510       # doing.
3511       $texinfodir = ('$(srcdir)/'
3512                      . dirname (variable_value ('TEXINFO_TEX')));
3513     }
3514   elsif (option 'cygnus')
3515     {
3516       $texinfodir = '$(top_srcdir)/../texinfo';
3517       define_variable ('TEXINFO_TEX', "$texinfodir/texinfo.tex", INTERNAL);
3518     }
3519   elsif ($config_aux_dir_set_in_configure_ac)
3520     {
3521       $texinfodir = $am_config_aux_dir;
3522       define_variable ('TEXINFO_TEX', "$texinfodir/texinfo.tex", INTERNAL);
3523       $need_texi_file = 2; # so that we require_conf_file later
3524     }
3525   else
3526     {
3527       $texinfodir = '$(srcdir)';
3528       $need_texi_file = 1;
3529     }
3530   define_variable ('am__TEXINFO_TEX_DIR', $texinfodir, INTERNAL);
3531
3532   push (@dist_targets, 'dist-info');
3533
3534   if (! option 'no-installinfo')
3535     {
3536       # Make sure documentation is made and installed first.  Use
3537       # $(INFO_DEPS), not 'info', because otherwise recursive makes
3538       # get run twice during "make all".
3539       unshift (@all, '$(INFO_DEPS)');
3540     }
3541
3542   define_files_variable ("DVIS", @infobase, 'dvi', INTERNAL);
3543   define_files_variable ("PDFS", @infobase, 'pdf', INTERNAL);
3544   define_files_variable ("PSS", @infobase, 'ps', INTERNAL);
3545   define_files_variable ("HTMLS", @infobase, 'html', INTERNAL);
3546
3547   # This next isn't strictly needed now -- the places that look here
3548   # could easily be changed to look in info_TEXINFOS.  But this is
3549   # probably better, in case noinst_TEXINFOS is ever supported.
3550   define_variable ("TEXINFOS", variable_value ('info_TEXINFOS'), INTERNAL);
3551
3552   # Do some error checking.  Note that this file is not required
3553   # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
3554   # up above.
3555   if ($need_texi_file && ! option 'no-texinfo.tex')
3556     {
3557       if ($need_texi_file > 1)
3558         {
3559           require_conf_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3560                                         'texinfo.tex');
3561         }
3562       else
3563         {
3564           require_file_with_macro (TRUE, 'info_TEXINFOS', FOREIGN,
3565                                    'texinfo.tex');
3566         }
3567     }
3568
3569   return (makefile_wrap ("", "\t  ", @mostly_cleans),
3570           makefile_wrap ("", "\t  ", @texi_cleans),
3571           makefile_wrap ("", "\t  ", @maint_cleans));
3572 }
3573
3574
3575 # handle_texinfo ()
3576 # -----------------
3577 # Handle all Texinfo source.
3578 sub handle_texinfo ()
3579 {
3580   reject_var 'TEXINFOS', "`TEXINFOS' is an anachronism; use `info_TEXINFOS'";
3581   # FIXME: I think this is an obsolete future feature name.
3582   reject_var 'html_TEXINFOS', "HTML generation not yet supported";
3583
3584   my $info_texinfos = var ('info_TEXINFOS');
3585   my ($mostlyclean, $clean, $maintclean) = ('', '', '');
3586   if ($info_texinfos)
3587     {
3588       ($mostlyclean, $clean, $maintclean) = handle_texinfo_helper ($info_texinfos);
3589       chomp $mostlyclean;
3590       chomp $clean;
3591       chomp $maintclean;
3592     }
3593
3594   $output_rules .=  file_contents ('texinfos',
3595                                    new Automake::Location,
3596                                    MOSTLYCLEAN   => $mostlyclean,
3597                                    TEXICLEAN     => $clean,
3598                                    MAINTCLEAN    => $maintclean,
3599                                    'LOCAL-TEXIS' => !!$info_texinfos);
3600 }
3601
3602
3603 # Handle any man pages.
3604 sub handle_man_pages
3605 {
3606   reject_var 'MANS', "`MANS' is an anachronism; use `man_MANS'";
3607
3608   # Find all the sections in use.  We do this by first looking for
3609   # "standard" sections, and then looking for any additional
3610   # sections used in man_MANS.
3611   my (%sections, %notrans_sections, %trans_sections,
3612       %notrans_vars, %trans_vars, %notrans_sect_vars, %trans_sect_vars);
3613   # We handle nodist_ for uniformity.  man pages aren't distributed
3614   # by default so it isn't actually very important.
3615   foreach my $npfx ('', 'notrans_')
3616     {
3617       foreach my $pfx ('', 'dist_', 'nodist_')
3618         {
3619           # Add more sections as needed.
3620           foreach my $section ('0'..'9', 'n', 'l')
3621             {
3622               my $varname = $npfx . $pfx . 'man' . $section . '_MANS';
3623               if (var ($varname))
3624                 {
3625                   $sections{$section} = 1;
3626                   $varname = '$(' . $varname . ')';
3627                   if ($npfx eq 'notrans_')
3628                     {
3629                       $notrans_sections{$section} = 1;
3630                       $notrans_sect_vars{$varname} = 1;
3631                     }
3632                   else
3633                     {
3634                       $trans_sections{$section} = 1;
3635                       $trans_sect_vars{$varname} = 1;
3636                     }
3637
3638                   &push_dist_common ($varname)
3639                     if $pfx eq 'dist_';
3640                 }
3641             }
3642
3643           my $varname = $npfx . $pfx . 'man_MANS';
3644           my $var = var ($varname);
3645           if ($var)
3646             {
3647               foreach ($var->value_as_list_recursive)
3648                 {
3649                   # A page like `foo.1c' goes into man1dir.
3650                   if (/\.([0-9a-z])([a-z]*)$/)
3651                     {
3652                       $sections{$1} = 1;
3653                       if ($npfx eq 'notrans_')
3654                         {
3655                           $notrans_sections{$1} = 1;
3656                         }
3657                       else
3658                         {
3659                           $trans_sections{$1} = 1;
3660                         }
3661                     }
3662                 }
3663
3664               $varname = '$(' . $varname . ')';
3665               if ($npfx eq 'notrans_')
3666                 {
3667                   $notrans_vars{$varname} = 1;
3668                 }
3669               else
3670                 {
3671                   $trans_vars{$varname} = 1;
3672                 }
3673               &push_dist_common ($varname)
3674                 if $pfx eq 'dist_';
3675             }
3676         }
3677     }
3678
3679   return unless %sections;
3680
3681   my @unsorted_deps;
3682
3683   # Build section independent variables.
3684   my $have_notrans = %notrans_vars;
3685   my @notrans_list = sort keys %notrans_vars;
3686   my $have_trans = %trans_vars;
3687   my @trans_list = sort keys %trans_vars;
3688
3689   # Now for each section, generate an install and uninstall rule.
3690   # Sort sections so output is deterministic.
3691   foreach my $section (sort keys %sections)
3692     {
3693       # Build section dependent variables.
3694       my $notrans_mans = $have_notrans || exists $notrans_sections{$section};
3695       my $trans_mans = $have_trans || exists $trans_sections{$section};
3696       my (%notrans_this_sect, %trans_this_sect);
3697       my $expr = 'man' . $section . '_MANS';
3698       foreach my $varname (keys %notrans_sect_vars)
3699         {
3700           if ($varname =~ /$expr/)
3701             {
3702               $notrans_this_sect{$varname} = 1;
3703             }
3704         }
3705       foreach my $varname (keys %trans_sect_vars)
3706         {
3707           if ($varname =~ /$expr/)
3708             {
3709               $trans_this_sect{$varname} = 1;
3710             }
3711         }
3712       my @notrans_sect_list = sort keys %notrans_this_sect;
3713       my @trans_sect_list = sort keys %trans_this_sect;
3714       @unsorted_deps = (keys %notrans_vars, keys %trans_vars,
3715                         keys %notrans_this_sect, keys %trans_this_sect);
3716       my @deps = sort @unsorted_deps;
3717       $output_rules .= &file_contents ('mans',
3718                                        new Automake::Location,
3719                                        SECTION           => $section,
3720                                        DEPS              => "@deps",
3721                                        NOTRANS_MANS      => $notrans_mans,
3722                                        NOTRANS_SECT_LIST => "@notrans_sect_list",
3723                                        HAVE_NOTRANS      => $have_notrans,
3724                                        NOTRANS_LIST      => "@notrans_list",
3725                                        TRANS_MANS        => $trans_mans,
3726                                        TRANS_SECT_LIST   => "@trans_sect_list",
3727                                        HAVE_TRANS        => $have_trans,
3728                                        TRANS_LIST        => "@trans_list");
3729     }
3730
3731   @unsorted_deps  = (keys %notrans_vars, keys %trans_vars,
3732                      keys %notrans_sect_vars, keys %trans_sect_vars);
3733   my @mans = sort @unsorted_deps;
3734   $output_vars .= file_contents ('mans-vars',
3735                                  new Automake::Location,
3736                                  MANS => "@mans");
3737
3738   push (@all, '$(MANS)')
3739     unless option 'no-installman';
3740 }
3741
3742 # Handle DATA variables.
3743 sub handle_data
3744 {
3745     &am_install_var ('-noextra', '-candist', 'data', 'DATA',
3746                      'data', 'dataroot', 'doc', 'dvi', 'html', 'pdf',
3747                      'ps', 'sysconf', 'sharedstate', 'localstate',
3748                      'pkgdata', 'lisp', 'noinst', 'check');
3749 }
3750
3751 # Handle TAGS.
3752 sub handle_tags
3753 {
3754     my @tag_deps = ();
3755     my @ctag_deps = ();
3756     if (var ('SUBDIRS'))
3757     {
3758         $output_rules .= ("tags-recursive:\n"
3759                           . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
3760                           # Never fail here if a subdir fails; it
3761                           # isn't important.
3762                           . "\t  test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
3763                           . " && \$(MAKE) \$(AM_MAKEFLAGS) tags); \\\n"
3764                           . "\tdone\n");
3765         push (@tag_deps, 'tags-recursive');
3766         &depend ('.PHONY', 'tags-recursive');
3767         &depend ('.MAKE', 'tags-recursive');
3768
3769         $output_rules .= ("ctags-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) ctags); \\\n"
3775                           . "\tdone\n");
3776         push (@ctag_deps, 'ctags-recursive');
3777         &depend ('.PHONY', 'ctags-recursive');
3778         &depend ('.MAKE', 'ctags-recursive');
3779     }
3780
3781     if (&saw_sources_p (1)
3782         || var ('ETAGS_ARGS')
3783         || @tag_deps)
3784     {
3785         my @config;
3786         foreach my $spec (@config_headers)
3787         {
3788             my ($out, @ins) = split_config_file_spec ($spec);
3789             foreach my $in (@ins)
3790               {
3791                 # If the config header source is in this directory,
3792                 # require it.
3793                 push @config, basename ($in)
3794                   if $relative_dir eq dirname ($in);
3795               }
3796         }
3797         $output_rules .= &file_contents ('tags',
3798                                          new Automake::Location,
3799                                          CONFIG    => "@config",
3800                                          TAGSDIRS  => "@tag_deps",
3801                                          CTAGSDIRS => "@ctag_deps");
3802
3803         set_seen 'TAGS_DEPENDENCIES';
3804     }
3805     elsif (reject_var ('TAGS_DEPENDENCIES',
3806                        "doesn't make sense to define `TAGS_DEPENDENCIES'"
3807                        . "without\nsources or `ETAGS_ARGS'"))
3808     {
3809     }
3810     else
3811     {
3812         # Every Makefile must define some sort of TAGS rule.
3813         # Otherwise, it would be possible for a top-level "make TAGS"
3814         # to fail because some subdirectory failed.
3815         $output_rules .= "tags: TAGS\nTAGS:\n\n";
3816         # Ditto ctags.
3817         $output_rules .= "ctags: CTAGS\nCTAGS:\n\n";
3818     }
3819 }
3820
3821 # Handle multilib support.
3822 sub handle_multilib
3823 {
3824   if ($seen_multilib && $relative_dir eq '.')
3825     {
3826       $output_rules .= &file_contents ('multilib', new Automake::Location);
3827       push (@all, 'all-multi');
3828     }
3829 }
3830
3831
3832 # user_phony_rule ($NAME)
3833 # -----------------------
3834 # Return false if rule $NAME does not exist.  Otherwise,
3835 # declare it as phony, complete its definition (in case it is
3836 # conditional), and return its Automake::Rule instance.
3837 sub user_phony_rule ($)
3838 {
3839   my ($name) = @_;
3840   my $rule = rule $name;
3841   if ($rule)
3842     {
3843       depend ('.PHONY', $name);
3844       # Define $NAME in all condition where it is not already defined,
3845       # so that it is always OK to depend on $NAME.
3846       for my $c ($rule->not_always_defined_in_cond (TRUE)->conds)
3847         {
3848           Automake::Rule::define ($name, 'internal', RULE_AUTOMAKE,
3849                                   $c, INTERNAL);
3850           $output_rules .= $c->subst_string . "$name:\n";
3851         }
3852     }
3853   return $rule;
3854 }
3855
3856
3857 # $BOOLEAN
3858 # &for_dist_common ($A, $B)
3859 # -------------------------
3860 # Subroutine for &handle_dist: sort files to dist.
3861 #
3862 # We put README first because it then becomes easier to make a
3863 # Usenet-compliant shar file (in these, README must be first).
3864 #
3865 # FIXME: do more ordering of files here.
3866 sub for_dist_common
3867 {
3868     return 0
3869         if $a eq $b;
3870     return -1
3871         if $a eq 'README';
3872     return 1
3873         if $b eq 'README';
3874     return $a cmp $b;
3875 }
3876
3877 # handle_dist
3878 # -----------
3879 # Handle 'dist' target.
3880 sub handle_dist ()
3881 {
3882   # Substitutions for distdir.am
3883   my %transform;
3884
3885   # Define DIST_SUBDIRS.  This must always be done, regardless of the
3886   # no-dist setting: target like `distclean' or `maintainer-clean' use it.
3887   my $subdirs = var ('SUBDIRS');
3888   if ($subdirs)
3889     {
3890       # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
3891       # to all possible directories, and use it.  If DIST_SUBDIRS is
3892       # defined, just use it.
3893
3894       # Note that we check DIST_SUBDIRS first on purpose, so that
3895       # we don't call has_conditional_contents for now reason.
3896       # (In the past one project used so many conditional subdirectories
3897       # that calling has_conditional_contents on SUBDIRS caused
3898       # automake to grow to 150Mb -- this should not happen with
3899       # the current implementation of has_conditional_contents,
3900       # but it's more efficient to avoid the call anyway.)
3901       if (var ('DIST_SUBDIRS'))
3902         {
3903         }
3904       elsif ($subdirs->has_conditional_contents)
3905         {
3906           define_pretty_variable
3907             ('DIST_SUBDIRS', TRUE, INTERNAL,
3908              uniq ($subdirs->value_as_list_recursive));
3909         }
3910       else
3911         {
3912           # We always define this because that is what `distclean'
3913           # wants.
3914           define_pretty_variable ('DIST_SUBDIRS', TRUE, INTERNAL,
3915                                   '$(SUBDIRS)');
3916         }
3917     }
3918
3919   # The remaining definitions are only required when a dist target is used.
3920   return if option 'no-dist';
3921
3922   # At least one of the archive formats must be enabled.
3923   if ($relative_dir eq '.')
3924     {
3925       my $archive_defined = option 'no-dist-gzip' ? 0 : 1;
3926       $archive_defined ||=
3927         grep { option "dist-$_" } qw(shar zip tarZ bzip2 lzip lzma xz);
3928       error (option 'no-dist-gzip',
3929              "no-dist-gzip specified but no dist-* specified, "
3930              . "at least one archive format must be enabled")
3931         unless $archive_defined;
3932     }
3933
3934   # Look for common files that should be included in distribution.
3935   # If the aux dir is set, and it does not have a Makefile.am, then
3936   # we check for these files there as well.
3937   my $check_aux = 0;
3938   if ($relative_dir eq '.'
3939       && $config_aux_dir_set_in_configure_ac)
3940     {
3941       if (! &is_make_dir ($config_aux_dir))
3942         {
3943           $check_aux = 1;
3944         }
3945     }
3946   foreach my $cfile (@common_files)
3947     {
3948       if (dir_has_case_matching_file ($relative_dir, $cfile)
3949           # The file might be absent, but if it can be built it's ok.
3950           || rule $cfile)
3951         {
3952           &push_dist_common ($cfile);
3953         }
3954
3955       # Don't use `elsif' here because a file might meaningfully
3956       # appear in both directories.
3957       if ($check_aux && dir_has_case_matching_file ($config_aux_dir, $cfile))
3958         {
3959           &push_dist_common ("$config_aux_dir/$cfile")
3960         }
3961     }
3962
3963   # We might copy elements from $configure_dist_common to
3964   # %dist_common if we think we need to.  If the file appears in our
3965   # directory, we would have discovered it already, so we don't
3966   # check that.  But if the file is in a subdir without a Makefile,
3967   # we want to distribute it here if we are doing `.'.  Ugly!
3968   if ($relative_dir eq '.')
3969     {
3970       foreach my $file (split (' ' , $configure_dist_common))
3971         {
3972           push_dist_common ($file)
3973             unless is_make_dir (dirname ($file));
3974         }
3975     }
3976
3977   # Files to distributed.  Don't use ->value_as_list_recursive
3978   # as it recursively expands `$(dist_pkgdata_DATA)' etc.
3979   my @dist_common = split (' ', rvar ('DIST_COMMON')->variable_value);
3980   @dist_common = uniq (sort for_dist_common (@dist_common));
3981   variable_delete 'DIST_COMMON';
3982   define_pretty_variable ('DIST_COMMON', TRUE, INTERNAL, @dist_common);
3983
3984   # Now that we've processed DIST_COMMON, disallow further attempts
3985   # to set it.
3986   $handle_dist_run = 1;
3987
3988   # Scan EXTRA_DIST to see if we need to distribute anything from a
3989   # subdir.  If so, add it to the list.  I didn't want to do this
3990   # originally, but there were so many requests that I finally
3991   # relented.
3992   my $extra_dist = var ('EXTRA_DIST');
3993
3994   $transform{'DISTCHECK-HOOK'} = !! rule 'distcheck-hook';
3995   $transform{'GETTEXT'} = $seen_gettext && !$seen_gettext_external;
3996
3997   # If the target `dist-hook' exists, make sure it is run.  This
3998   # allows users to do random weird things to the distribution
3999   # before it is packaged up.
4000   push (@dist_targets, 'dist-hook')
4001     if user_phony_rule 'dist-hook';
4002   $transform{'DIST-TARGETS'} = join (' ', @dist_targets);
4003
4004   my $flm = option ('filename-length-max');
4005   my $filename_filter = $flm ? '.' x $flm->[1] : '';
4006
4007   $output_rules .= &file_contents ('distdir',
4008                                    new Automake::Location,
4009                                    %transform,
4010                                    FILENAME_FILTER => $filename_filter);
4011 }
4012
4013
4014 # check_directory ($NAME, $WHERE)
4015 # -------------------------------
4016 # Ensure $NAME is a directory, and that it uses a sane name.
4017 # Use $WHERE as a location in the diagnostic, if any.
4018 sub check_directory ($$)
4019 {
4020   my ($dir, $where) = @_;
4021
4022   error $where, "required directory $relative_dir/$dir does not exist"
4023     unless -d "$relative_dir/$dir";
4024
4025   # If an `obj/' directory exists, BSD make will enter it before
4026   # reading `Makefile'.  Hence the `Makefile' in the current directory
4027   # will not be read.
4028   #
4029   #  % cat Makefile
4030   #  all:
4031   #          echo Hello
4032   #  % cat obj/Makefile
4033   #  all:
4034   #          echo World
4035   #  % make      # GNU make
4036   #  echo Hello
4037   #  Hello
4038   #  % pmake     # BSD make
4039   #  echo World
4040   #  World
4041   msg ('portability', $where,
4042        "naming a subdirectory `obj' causes troubles with BSD make")
4043     if $dir eq 'obj';
4044
4045   # `aux' is probably the most important of the following forbidden name,
4046   # since it's tempting to use it as an AC_CONFIG_AUX_DIR.
4047   msg ('portability', $where,
4048        "name `$dir' is reserved on W32 and DOS platforms")
4049     if grep (/^\Q$dir\E$/i, qw/aux lpt1 lpt2 lpt3 com1 com2 com3 com4 con prn/);
4050 }
4051
4052 # check_directories_in_var ($VARIABLE)
4053 # ------------------------------------
4054 # Recursively check all items in variables $VARIABLE as directories
4055 sub check_directories_in_var ($)
4056 {
4057   my ($var) = @_;
4058   $var->traverse_recursively
4059     (sub
4060      {
4061        my ($var, $val, $cond, $full_cond) = @_;
4062        check_directory ($val, $var->rdef ($cond)->location);
4063        return ();
4064      },
4065      undef,
4066      skip_ac_subst => 1);
4067 }
4068
4069 # &handle_subdirs ()
4070 # ------------------
4071 # Handle subdirectories.
4072 sub handle_subdirs ()
4073 {
4074   my $subdirs = var ('SUBDIRS');
4075   return
4076     unless $subdirs;
4077
4078   check_directories_in_var $subdirs;
4079
4080   my $dsubdirs = var ('DIST_SUBDIRS');
4081   check_directories_in_var $dsubdirs
4082     if $dsubdirs;
4083
4084   $output_rules .= &file_contents ('subdirs', new Automake::Location);
4085   rvar ('RECURSIVE_TARGETS')->rdef (TRUE)->{'pretty'} = VAR_SORTED; # Gross!
4086 }
4087
4088
4089 # ($REGEN, @DEPENDENCIES)
4090 # &scan_aclocal_m4
4091 # ----------------
4092 # If aclocal.m4 creation is automated, return the list of its dependencies.
4093 sub scan_aclocal_m4 ()
4094 {
4095   my $regen_aclocal = 0;
4096
4097   set_seen 'CONFIG_STATUS_DEPENDENCIES';
4098   set_seen 'CONFIGURE_DEPENDENCIES';
4099
4100   if (-f 'aclocal.m4')
4101     {
4102       &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4', INTERNAL);
4103
4104       my $aclocal = new Automake::XFile "< aclocal.m4";
4105       my $line = $aclocal->getline;
4106       $regen_aclocal = $line =~ 'generated automatically by aclocal';
4107     }
4108
4109   my @ac_deps = ();
4110
4111   if (set_seen ('ACLOCAL_M4_SOURCES'))
4112     {
4113       push (@ac_deps, '$(ACLOCAL_M4_SOURCES)');
4114       msg_var ('obsolete', 'ACLOCAL_M4_SOURCES',
4115                "`ACLOCAL_M4_SOURCES' is obsolete.\n"
4116                . "It should be safe to simply remove it.");
4117     }
4118
4119   # Note that it might be possible that aclocal.m4 doesn't exist but
4120   # should be auto-generated.  This case probably isn't very
4121   # important.
4122
4123   return ($regen_aclocal, @ac_deps);
4124 }
4125
4126
4127 # Helper function for substitute_ac_subst_variables.
4128 sub substitute_ac_subst_variables_worker($)
4129 {
4130   my ($token) = @_;
4131   return "\@$token\@" if var $token;
4132   return "\${$token\}";
4133 }
4134
4135 # substitute_ac_subst_variables ($TEXT)
4136 # -------------------------------------
4137 # Replace any occurrence of ${FOO} in $TEXT by @FOO@ if FOO is an AC_SUBST
4138 # variable.
4139 sub substitute_ac_subst_variables ($)
4140 {
4141   my ($text) = @_;
4142   $text =~ s/\${([^ \t=:+{}]+)}/&substitute_ac_subst_variables_worker ($1)/ge;
4143   return $text;
4144 }
4145
4146 # @DEPENDENCIES
4147 # &prepend_srcdir (@INPUTS)
4148 # -------------------------
4149 # Prepend $(srcdir) or $(top_srcdir) to all @INPUTS.  The idea is that
4150 # if an input file has a directory part the same as the current
4151 # directory, then the directory part is simply replaced by $(srcdir).
4152 # But if the directory part is different, then $(top_srcdir) is
4153 # prepended.
4154 sub prepend_srcdir (@)
4155 {
4156   my (@inputs) = @_;
4157   my @newinputs;
4158
4159   foreach my $single (@inputs)
4160     {
4161       if (dirname ($single) eq $relative_dir)
4162         {
4163           push (@newinputs, '$(srcdir)/' . basename ($single));
4164         }
4165       else
4166         {
4167           push (@newinputs, '$(top_srcdir)/' . $single);
4168         }
4169     }
4170   return @newinputs;
4171 }
4172
4173 # @DEPENDENCIES
4174 # rewrite_inputs_into_dependencies ($OUTPUT, @INPUTS)
4175 # ---------------------------------------------------
4176 # Compute a list of dependencies appropriate for the rebuild
4177 # rule of
4178 #   AC_CONFIG_FILES($OUTPUT:$INPUT[0]:$INPUTS[1]:...)
4179 # Also distribute $INPUTs which are not built by another AC_CONFIG_FOOs.
4180 sub rewrite_inputs_into_dependencies ($@)
4181 {
4182   my ($file, @inputs) = @_;
4183   my @res = ();
4184
4185   for my $i (@inputs)
4186     {
4187       # We cannot create dependencies on shell variables.
4188       next if (substitute_ac_subst_variables $i) =~ /\$/;
4189
4190       if (exists $ac_config_files_location{$i} && $i ne $file)
4191         {
4192           my $di = dirname $i;
4193           if ($di eq $relative_dir)
4194             {
4195               $i = basename $i;
4196             }
4197           # In the top-level Makefile we do not use $(top_builddir), because
4198           # we are already there, and since the targets are built without
4199           # a $(top_builddir), it helps BSD Make to match them with
4200           # dependencies.
4201           elsif ($relative_dir ne '.')
4202             {
4203               $i = '$(top_builddir)/' . $i;
4204             }
4205         }
4206       else
4207         {
4208           msg ('error', $ac_config_files_location{$file},
4209                "required file `$i' not found")
4210             unless $i =~ /\$/ || exists $output_files{$i} || -f $i;
4211           ($i) = prepend_srcdir ($i);
4212           push_dist_common ($i);
4213         }
4214       push @res, $i;
4215     }
4216   return @res;
4217 }
4218
4219
4220
4221 # &handle_configure ($MAKEFILE_AM, $MAKEFILE_IN, $MAKEFILE, @INPUTS)
4222 # ------------------------------------------------------------------
4223 # Handle remaking and configure stuff.
4224 # We need the name of the input file, to do proper remaking rules.
4225 sub handle_configure ($$$@)
4226 {
4227   my ($makefile_am, $makefile_in, $makefile, @inputs) = @_;
4228
4229   prog_error 'empty @inputs'
4230     unless @inputs;
4231
4232   my ($rel_makefile_am, $rel_makefile_in) = prepend_srcdir ($makefile_am,
4233                                                             $makefile_in);
4234   my $rel_makefile = basename $makefile;
4235
4236   my $colon_infile = ':' . join (':', @inputs);
4237   $colon_infile = '' if $colon_infile eq ":$makefile.in";
4238   my @rewritten = rewrite_inputs_into_dependencies ($makefile, @inputs);
4239   my ($regen_aclocal_m4, @aclocal_m4_deps) = scan_aclocal_m4;
4240   define_pretty_variable ('am__aclocal_m4_deps', TRUE, INTERNAL,
4241                           @configure_deps, @aclocal_m4_deps,
4242                           '$(top_srcdir)/' . $configure_ac);
4243   my @configuredeps = ('$(am__aclocal_m4_deps)', '$(CONFIGURE_DEPENDENCIES)');
4244   push @configuredeps, '$(ACLOCAL_M4)' if -f 'aclocal.m4';
4245   define_pretty_variable ('am__configure_deps', TRUE, INTERNAL,
4246                           @configuredeps);
4247
4248   my $automake_options = '--' . (global_option 'cygnus' ? 'cygnus' : $strictness_name)
4249                          . (global_option 'no-dependencies' ? ' --ignore-deps' : '');
4250
4251   $output_rules .= file_contents
4252     ('configure',
4253      new Automake::Location,
4254      MAKEFILE              => $rel_makefile,
4255      'MAKEFILE-DEPS'       => "@rewritten",
4256      'CONFIG-MAKEFILE'     => ($relative_dir eq '.') ? '$@' : '$(subdir)/$@',
4257      'MAKEFILE-IN'         => $rel_makefile_in,
4258      'HAVE-MAKEFILE-IN-DEPS' => (@include_stack > 0),
4259      'MAKEFILE-IN-DEPS'    => "@include_stack",
4260      'MAKEFILE-AM'         => $rel_makefile_am,
4261      'AUTOMAKE-OPTIONS'    => $automake_options,
4262      'MAKEFILE-AM-SOURCES' => "$makefile$colon_infile",
4263      'REGEN-ACLOCAL-M4'    => $regen_aclocal_m4,
4264      VERBOSE               => verbose_flag ('GEN'));
4265
4266   if ($relative_dir eq '.')
4267     {
4268       &push_dist_common ('acconfig.h')
4269         if -f 'acconfig.h';
4270     }
4271
4272   # If we have a configure header, require it.
4273   my $hdr_index = 0;
4274   my @distclean_config;
4275   foreach my $spec (@config_headers)
4276     {
4277       $hdr_index += 1;
4278       # $CONFIG_H_PATH: config.h from top level.
4279       my ($config_h_path, @ins) = split_config_file_spec ($spec);
4280       my $config_h_dir = dirname ($config_h_path);
4281
4282       # If the header is in the current directory we want to build
4283       # the header here.  Otherwise, if we're at the topmost
4284       # directory and the header's directory doesn't have a
4285       # Makefile, then we also want to build the header.
4286       if ($relative_dir eq $config_h_dir
4287           || ($relative_dir eq '.' && ! &is_make_dir ($config_h_dir)))
4288         {
4289           my ($cn_sans_dir, $stamp_dir);
4290           if ($relative_dir eq $config_h_dir)
4291             {
4292               $cn_sans_dir = basename ($config_h_path);
4293               $stamp_dir = '';
4294             }
4295           else
4296             {
4297               $cn_sans_dir = $config_h_path;
4298               if ($config_h_dir eq '.')
4299                 {
4300                   $stamp_dir = '';
4301                 }
4302               else
4303                 {
4304                   $stamp_dir = $config_h_dir . '/';
4305                 }
4306             }
4307
4308           # This will also distribute all inputs.
4309           @ins = rewrite_inputs_into_dependencies ($config_h_path, @ins);
4310
4311           # Cannot define rebuild rules for filenames with shell variables.
4312           next if (substitute_ac_subst_variables $config_h_path) =~ /\$/;
4313
4314           # Header defined in this directory.
4315           my @files;
4316           if (-f $config_h_path . '.top')
4317             {
4318               push (@files, "$cn_sans_dir.top");
4319             }
4320           if (-f $config_h_path . '.bot')
4321             {
4322               push (@files, "$cn_sans_dir.bot");
4323             }
4324
4325           push_dist_common (@files);
4326
4327           # For now, acconfig.h can only appear in the top srcdir.
4328           if (-f 'acconfig.h')
4329             {
4330               push (@files, '$(top_srcdir)/acconfig.h');
4331             }
4332
4333           my $stamp = "${stamp_dir}stamp-h${hdr_index}";
4334           $output_rules .=
4335             file_contents ('remake-hdr',
4336                            new Automake::Location,
4337                            FILES            => "@files",
4338                            CONFIG_H         => $cn_sans_dir,
4339                            CONFIG_HIN       => $ins[0],
4340                            CONFIG_H_DEPS    => "@ins",
4341                            CONFIG_H_PATH    => $config_h_path,
4342                            STAMP            => "$stamp");
4343
4344           push @distclean_config, $cn_sans_dir, $stamp;
4345         }
4346     }
4347
4348   $output_rules .= file_contents ('clean-hdr',
4349                                   new Automake::Location,
4350                                   FILES => "@distclean_config")
4351     if @distclean_config;
4352
4353   # Distribute and define mkinstalldirs only if it is already present
4354   # in the package, for backward compatibility (some people may still
4355   # use $(mkinstalldirs)).
4356   my $mkidpath = "$config_aux_dir/mkinstalldirs";
4357   if (-f $mkidpath)
4358     {
4359       # Use require_file so that any existing script gets updated
4360       # by --force-missing.
4361       require_conf_file ($mkidpath, FOREIGN, 'mkinstalldirs');
4362       define_variable ('mkinstalldirs',
4363                        "\$(SHELL) $am_config_aux_dir/mkinstalldirs", INTERNAL);
4364     }
4365   else
4366     {
4367       # Use $(install_sh), not $(MKDIR_P) because the latter requires
4368       # at least one argument, and $(mkinstalldirs) used to work
4369       # even without arguments (e.g. $(mkinstalldirs) $(conditional_dir)).
4370       define_variable ('mkinstalldirs', '$(install_sh) -d', INTERNAL);
4371     }
4372
4373   reject_var ('CONFIG_HEADER',
4374               "`CONFIG_HEADER' is an anachronism; now determined "
4375               . "automatically\nfrom `$configure_ac'");
4376
4377   my @config_h;
4378   foreach my $spec (@config_headers)
4379     {
4380       my ($out, @ins) = split_config_file_spec ($spec);
4381       # Generate CONFIG_HEADER define.
4382       if ($relative_dir eq dirname ($out))
4383         {
4384           push @config_h, basename ($out);
4385         }
4386       else
4387         {
4388           push @config_h, "\$(top_builddir)/$out";
4389         }
4390     }
4391   define_variable ("CONFIG_HEADER", "@config_h", INTERNAL)
4392     if @config_h;
4393
4394   # Now look for other files in this directory which must be remade
4395   # by config.status, and generate rules for them.
4396   my @actual_other_files = ();
4397   # These get cleaned only in a VPATH build.
4398   my @actual_other_vpath_files = ();
4399   foreach my $lfile (@other_input_files)
4400     {
4401       my $file;
4402       my @inputs;
4403       if ($lfile =~ /^([^:]*):(.*)$/)
4404         {
4405           # This is the ":" syntax of AC_OUTPUT.
4406           $file = $1;
4407           @inputs = split (':', $2);
4408         }
4409       else
4410         {
4411           # Normal usage.
4412           $file = $lfile;
4413           @inputs = $file . '.in';
4414         }
4415
4416       # Automake files should not be stored in here, but in %MAKE_LIST.
4417       prog_error ("$lfile in \@other_input_files\n"
4418                   . "\@other_input_files = (@other_input_files)")
4419         if -f $file . '.am';
4420
4421       my $local = basename ($file);
4422
4423       # We skip files that aren't in this directory.  However, if
4424       # the file's directory does not have a Makefile, and we are
4425       # currently doing `.', then we create a rule to rebuild the
4426       # file in the subdir.
4427       my $fd = dirname ($file);
4428       if ($fd ne $relative_dir)
4429         {
4430           if ($relative_dir eq '.' && ! &is_make_dir ($fd))
4431             {
4432               $local = $file;
4433             }
4434           else
4435             {
4436               next;
4437             }
4438         }
4439
4440       my @rewritten_inputs = rewrite_inputs_into_dependencies ($file, @inputs);
4441
4442       # Cannot output rules for shell variables.
4443       next if (substitute_ac_subst_variables $local) =~ /\$/;
4444
4445       my $condstr = '';
4446       my $cond = $ac_config_files_condition{$lfile};
4447       if (defined $cond)
4448         {
4449           $condstr = $cond->subst_string;
4450           Automake::Rule::define ($local, $configure_ac, RULE_AUTOMAKE, $cond,
4451                                   $ac_config_files_location{$file});
4452         }
4453       $output_rules .= ($condstr . $local . ': '
4454                         . '$(top_builddir)/config.status '
4455                         . "@rewritten_inputs\n"
4456                         . $condstr . "\t"
4457                         . 'cd $(top_builddir) && '
4458                         . '$(SHELL) ./config.status '
4459                         . ($relative_dir eq '.' ? '' : '$(subdir)/')
4460                         . '$@'
4461                         . "\n");
4462       push (@actual_other_files, $local);
4463     }
4464
4465   # For links we should clean destinations and distribute sources.
4466   foreach my $spec (@config_links)
4467     {
4468       my ($link, $file) = split /:/, $spec;
4469       # Some people do AC_CONFIG_LINKS($computed).  We only handle
4470       # the DEST:SRC form.
4471       next unless $file;
4472       my $where = $ac_config_files_location{$link};
4473
4474       # Skip destinations that contain shell variables.
4475       if ((substitute_ac_subst_variables $link) !~ /\$/)
4476         {
4477           # We skip links that aren't in this directory.  However, if
4478           # the link's directory does not have a Makefile, and we are
4479           # currently doing `.', then we add the link to CONFIG_CLEAN_FILES
4480           # in `.'s Makefile.in.
4481           my $local = basename ($link);
4482           my $fd = dirname ($link);
4483           if ($fd ne $relative_dir)
4484             {
4485               if ($relative_dir eq '.' && ! &is_make_dir ($fd))
4486                 {
4487                   $local = $link;
4488                 }
4489               else
4490                 {
4491                   $local = undef;
4492                 }
4493             }
4494           if ($file ne $link)
4495             {
4496               push @actual_other_files, $local if $local;
4497             }
4498           else
4499             {
4500               push @actual_other_vpath_files, $local if $local;
4501             }
4502         }
4503
4504       # Do not process sources that contain shell variables.
4505       if ((substitute_ac_subst_variables $file) !~ /\$/)
4506         {
4507           my $fd = dirname ($file);
4508
4509           # We distribute files that are in this directory.
4510           # At the top-level (`.') we also distribute files whose
4511           # directory does not have a Makefile.
4512           if (($fd eq $relative_dir)
4513               || ($relative_dir eq '.' && ! &is_make_dir ($fd)))
4514             {
4515               # The following will distribute $file as a side-effect when
4516               # it is appropriate (i.e., when $file is not already an output).
4517               # We do not need the result, just the side-effect.
4518               rewrite_inputs_into_dependencies ($link, $file);
4519             }
4520         }
4521     }
4522
4523   # These files get removed by "make distclean".
4524   define_pretty_variable ('CONFIG_CLEAN_FILES', TRUE, INTERNAL,
4525                           @actual_other_files);
4526   define_pretty_variable ('CONFIG_CLEAN_VPATH_FILES', TRUE, INTERNAL,
4527                           @actual_other_vpath_files);
4528 }
4529
4530 # Handle C headers.
4531 sub handle_headers
4532 {
4533     my @r = &am_install_var ('-defaultdist', 'header', 'HEADERS', 'include',
4534                              'oldinclude', 'pkginclude',
4535                              'noinst', 'check');
4536     foreach (@r)
4537     {
4538       next unless $_->[1] =~ /\..*$/;
4539       &saw_extension ($&);
4540     }
4541 }
4542
4543 sub handle_gettext
4544 {
4545   return if ! $seen_gettext || $relative_dir ne '.';
4546
4547   my $subdirs = var 'SUBDIRS';
4548
4549   if (! $subdirs)
4550     {
4551       err_ac "AM_GNU_GETTEXT used but SUBDIRS not defined";
4552       return;
4553     }
4554
4555   # Perform some sanity checks to help users get the right setup.
4556   # We disable these tests when po/ doesn't exist in order not to disallow
4557   # unusual gettext setups.
4558   #
4559   # Bruno Haible:
4560   # | The idea is:
4561   # |
4562   # |  1) If a package doesn't have a directory po/ at top level, it
4563   # |     will likely have multiple po/ directories in subpackages.
4564   # |
4565   # |  2) It is useful to warn for the absence of intl/ if AM_GNU_GETTEXT
4566   # |     is used without 'external'. It is also useful to warn for the
4567   # |     presence of intl/ if AM_GNU_GETTEXT([external]) is used. Both
4568   # |     warnings apply only to the usual layout of packages, therefore
4569   # |     they should both be disabled if no po/ directory is found at
4570   # |     top level.
4571
4572   if (-d 'po')
4573     {
4574       my @subdirs = $subdirs->value_as_list_recursive;
4575
4576       msg_var ('syntax', $subdirs,
4577                "AM_GNU_GETTEXT used but `po' not in SUBDIRS")
4578         if ! grep ($_ eq 'po', @subdirs);
4579
4580       # intl/ is not required when AM_GNU_GETTEXT is called with the
4581       # `external' option and AM_GNU_GETTEXT_INTL_SUBDIR is not called.
4582       msg_var ('syntax', $subdirs,
4583                "AM_GNU_GETTEXT used but `intl' not in SUBDIRS")
4584         if (! ($seen_gettext_external && ! $seen_gettext_intl)
4585             && ! grep ($_ eq 'intl', @subdirs));
4586
4587       # intl/ should not be used with AM_GNU_GETTEXT([external]), except
4588       # if AM_GNU_GETTEXT_INTL_SUBDIR is called.
4589       msg_var ('syntax', $subdirs,
4590                "`intl' should not be in SUBDIRS when "
4591                . "AM_GNU_GETTEXT([external]) is used")
4592         if ($seen_gettext_external && ! $seen_gettext_intl
4593             && grep ($_ eq 'intl', @subdirs));
4594     }
4595
4596   require_file ($ac_gettext_location, GNU, 'ABOUT-NLS');
4597 }
4598
4599 # Handle footer elements.
4600 sub handle_footer
4601 {
4602     reject_rule ('.SUFFIXES',
4603                  "use variable `SUFFIXES', not target `.SUFFIXES'");
4604
4605     # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
4606     # before .SUFFIXES.  So we make sure that .SUFFIXES appears before
4607     # anything else, by sticking it right after the default: target.
4608     $output_header .= ".SUFFIXES:\n";
4609     my $suffixes = var 'SUFFIXES';
4610     my @suffixes = Automake::Rule::suffixes;
4611     if (@suffixes || $suffixes)
4612     {
4613         # Make sure SUFFIXES has unique elements.  Sort them to ensure
4614         # the output remains consistent.  However, $(SUFFIXES) is
4615         # always at the start of the list, unsorted.  This is done
4616         # because make will choose rules depending on the ordering of
4617         # suffixes, and this lets the user have some control.  Push
4618         # actual suffixes, and not $(SUFFIXES).  Some versions of make
4619         # do not like variable substitutions on the .SUFFIXES line.
4620         my @user_suffixes = ($suffixes
4621                              ? $suffixes->value_as_list_recursive : ());
4622
4623         my %suffixes = map { $_ => 1 } @suffixes;
4624         delete @suffixes{@user_suffixes};
4625
4626         $output_header .= (".SUFFIXES: "
4627                            . join (' ', @user_suffixes, sort keys %suffixes)
4628                            . "\n");
4629     }
4630
4631     $output_trailer .= file_contents ('footer', new Automake::Location);
4632 }
4633
4634
4635 # Generate `make install' rules.
4636 sub handle_install ()
4637 {
4638   $output_rules .= &file_contents
4639     ('install',
4640      new Automake::Location,
4641      maybe_BUILT_SOURCES => (set_seen ('BUILT_SOURCES')
4642                              ? (" \$(BUILT_SOURCES)\n"
4643                                 . "\t\$(MAKE) \$(AM_MAKEFLAGS)")
4644                              : ''),
4645      'installdirs-local' => (user_phony_rule 'installdirs-local'
4646                              ? ' installdirs-local' : ''),
4647      am__installdirs => variable_value ('am__installdirs') || '');
4648 }
4649
4650
4651 # Deal with all and all-am.
4652 sub handle_all ($)
4653 {
4654     my ($makefile) = @_;
4655
4656     # Output `all-am'.
4657
4658     # Put this at the beginning for the sake of non-GNU makes.  This
4659     # is still wrong if these makes can run parallel jobs.  But it is
4660     # right enough.
4661     unshift (@all, basename ($makefile));
4662
4663     foreach my $spec (@config_headers)
4664       {
4665         my ($out, @ins) = split_config_file_spec ($spec);
4666         push (@all, basename ($out))
4667           if dirname ($out) eq $relative_dir;
4668       }
4669
4670     # Install `all' hooks.
4671     push (@all, "all-local")
4672       if user_phony_rule "all-local";
4673
4674     &pretty_print_rule ("all-am:", "\t\t", @all);
4675     &depend ('.PHONY', 'all-am', 'all');
4676
4677
4678     # Output `all'.
4679
4680     my @local_headers = ();
4681     push @local_headers, '$(BUILT_SOURCES)'
4682       if var ('BUILT_SOURCES');
4683     foreach my $spec (@config_headers)
4684       {
4685         my ($out, @ins) = split_config_file_spec ($spec);
4686         push @local_headers, basename ($out)
4687           if dirname ($out) eq $relative_dir;
4688       }
4689
4690     if (@local_headers)
4691       {
4692         # We need to make sure config.h is built before we recurse.
4693         # We also want to make sure that built sources are built
4694         # before any ordinary `all' targets are run.  We can't do this
4695         # by changing the order of dependencies to the "all" because
4696         # that breaks when using parallel makes.  Instead we handle
4697         # things explicitly.
4698         $output_all .= ("all: @local_headers"
4699                         . "\n\t"
4700                         . '$(MAKE) $(AM_MAKEFLAGS) '
4701                         . (var ('SUBDIRS') ? 'all-recursive' : 'all-am')
4702                         . "\n\n");
4703         depend ('.MAKE', 'all');
4704       }
4705     else
4706       {
4707         $output_all .= "all: " . (var ('SUBDIRS')
4708                                   ? 'all-recursive' : 'all-am') . "\n\n";
4709       }
4710 }
4711
4712
4713 # &do_check_merge_target ()
4714 # -------------------------
4715 # Handle check merge target specially.
4716 sub do_check_merge_target ()
4717 {
4718   # Include user-defined local form of target.
4719   push @check_tests, 'check-local'
4720     if user_phony_rule 'check-local';
4721
4722   # In --cygnus mode, check doesn't depend on all.
4723   if (option 'cygnus')
4724     {
4725       # Just run the local check rules.
4726       pretty_print_rule ('check-am:', "\t\t", @check);
4727     }
4728   else
4729     {
4730       # The check target must depend on the local equivalent of
4731       # `all', to ensure all the primary targets are built.  Then it
4732       # must build the local check rules.
4733       $output_rules .= "check-am: all-am\n";
4734       if (@check)
4735         {
4736           pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ",
4737                              @check);
4738           depend ('.MAKE', 'check-am');
4739         }
4740     }
4741   if (@check_tests)
4742     {
4743       pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t  ",
4744                          @check_tests);
4745       depend ('.MAKE', 'check-am');
4746     }
4747
4748   depend '.PHONY', 'check', 'check-am';
4749   # Handle recursion.  We have to honor BUILT_SOURCES like for `all:'.
4750   $output_rules .= ("check: "
4751                     . (var ('BUILT_SOURCES')
4752                        ? "\$(BUILT_SOURCES)\n\t\$(MAKE) \$(AM_MAKEFLAGS) "
4753                        : '')
4754                     . (var ('SUBDIRS') ? 'check-recursive' : 'check-am')
4755                     . "\n");
4756   depend ('.MAKE', 'check')
4757     if var ('BUILT_SOURCES');
4758 }
4759
4760 # handle_clean ($MAKEFILE)
4761 # ------------------------
4762 # Handle all 'clean' targets.
4763 sub handle_clean ($)
4764 {
4765   my ($makefile) = @_;
4766
4767   # Clean the files listed in user variables if they exist.
4768   $clean_files{'$(MOSTLYCLEANFILES)'} = MOSTLY_CLEAN
4769     if var ('MOSTLYCLEANFILES');
4770   $clean_files{'$(CLEANFILES)'} = CLEAN
4771     if var ('CLEANFILES');
4772   $clean_files{'$(DISTCLEANFILES)'} = DIST_CLEAN
4773     if var ('DISTCLEANFILES');
4774   $clean_files{'$(MAINTAINERCLEANFILES)'} = MAINTAINER_CLEAN
4775     if var ('MAINTAINERCLEANFILES');
4776
4777   # Built sources are automatically removed by maintainer-clean.
4778   $clean_files{'$(BUILT_SOURCES)'} = MAINTAINER_CLEAN
4779     if var ('BUILT_SOURCES');
4780
4781   # Compute a list of "rm"s to run for each target.
4782   my %rms = (MOSTLY_CLEAN, [],
4783              CLEAN, [],
4784              DIST_CLEAN, [],
4785              MAINTAINER_CLEAN, []);
4786
4787   foreach my $file (keys %clean_files)
4788     {
4789       my $when = $clean_files{$file};
4790       prog_error 'invalid entry in %clean_files'
4791         unless exists $rms{$when};
4792
4793       my $rm = "rm -f $file";
4794       # If file is a variable, make sure when don't call `rm -f' without args.
4795       $rm ="test -z \"$file\" || $rm"
4796         if ($file =~ /^\s*\$(\(.*\)|\{.*\})\s*$/);
4797
4798       push @{$rms{$when}}, "\t-$rm\n";
4799     }
4800
4801   $output_rules .= &file_contents
4802     ('clean',
4803      new Automake::Location,
4804      MOSTLYCLEAN_RMS      => join ('', sort @{$rms{&MOSTLY_CLEAN}}),
4805      CLEAN_RMS            => join ('', sort @{$rms{&CLEAN}}),
4806      DISTCLEAN_RMS        => join ('', sort @{$rms{&DIST_CLEAN}}),
4807      MAINTAINER_CLEAN_RMS => join ('', sort @{$rms{&MAINTAINER_CLEAN}}),
4808      MAKEFILE             => basename $makefile,
4809      );
4810 }
4811
4812
4813 # &target_cmp ($A, $B)
4814 # --------------------
4815 # Subroutine for &handle_factored_dependencies to let `.PHONY' and
4816 # other `.TARGETS' be last.
4817 sub target_cmp
4818 {
4819   return 0 if $a eq $b;
4820
4821   my $a1 = substr ($a, 0, 1);
4822   my $b1 = substr ($b, 0, 1);
4823   if ($a1 ne $b1)
4824     {
4825       return -1 if $b1 eq '.';
4826       return 1 if $a1 eq '.';
4827     }
4828   return $a cmp $b;
4829 }
4830
4831
4832 # &handle_factored_dependencies ()
4833 # --------------------------------
4834 # Handle everything related to gathered targets.
4835 sub handle_factored_dependencies
4836 {
4837   # Reject bad hooks.
4838   foreach my $utarg ('uninstall-data-local', 'uninstall-data-hook',
4839                      'uninstall-exec-local', 'uninstall-exec-hook',
4840                      'uninstall-dvi-local',
4841                      'uninstall-html-local',
4842                      'uninstall-info-local',
4843                      'uninstall-pdf-local',
4844                      'uninstall-ps-local')
4845     {
4846       my $x = $utarg;
4847       $x =~ s/-.*-/-/;
4848       reject_rule ($utarg, "use `$x', not `$utarg'");
4849     }
4850
4851   reject_rule ('install-local',
4852                "use `install-data-local' or `install-exec-local', "
4853                . "not `install-local'");
4854
4855   reject_rule ('install-hook',
4856                "use `install-data-hook' or `install-exec-hook', "
4857                . "not `install-hook'");
4858
4859   # Install the -local hooks.
4860   foreach (keys %dependencies)
4861     {
4862       # Hooks are installed on the -am targets.
4863       s/-am$// or next;
4864       depend ("$_-am", "$_-local")
4865         if user_phony_rule "$_-local";
4866     }
4867
4868   # Install the -hook hooks.
4869   # FIXME: Why not be as liberal as we are with -local hooks?
4870   foreach ('install-exec', 'install-data', 'uninstall')
4871     {
4872       if (user_phony_rule "$_-hook")
4873         {
4874           depend ('.MAKE', "$_-am");
4875           register_action("$_-am",
4876                           ("\t\@\$(NORMAL_INSTALL)\n"
4877                            . "\t\$(MAKE) \$(AM_MAKEFLAGS) $_-hook"));
4878         }
4879     }
4880
4881   # All the required targets are phony.
4882   depend ('.PHONY', keys %required_targets);
4883
4884   # Actually output gathered targets.
4885   foreach (sort target_cmp keys %dependencies)
4886     {
4887       # If there is nothing about this guy, skip it.
4888       next
4889         unless (@{$dependencies{$_}}
4890                 || $actions{$_}
4891                 || $required_targets{$_});
4892
4893       # Define gathered targets in undefined conditions.
4894       # FIXME: Right now we must handle .PHONY as an exception,
4895       # because people write things like
4896       #    .PHONY: myphonytarget
4897       # to append dependencies.  This would not work if Automake
4898       # refrained from defining its own .PHONY target as it does
4899       # with other overridden targets.
4900       # Likewise for `.MAKE'.
4901       my @undefined_conds = (TRUE,);
4902       if ($_ ne '.PHONY' && $_ ne '.MAKE')
4903         {
4904           @undefined_conds =
4905             Automake::Rule::define ($_, 'internal',
4906                                     RULE_AUTOMAKE, TRUE, INTERNAL);
4907         }
4908       my @uniq_deps = uniq (sort @{$dependencies{$_}});
4909       foreach my $cond (@undefined_conds)
4910         {
4911           my $condstr = $cond->subst_string;
4912           &pretty_print_rule ("$condstr$_:", "$condstr\t", @uniq_deps);
4913           $output_rules .= $actions{$_} if defined $actions{$_};
4914           $output_rules .= "\n";
4915         }
4916     }
4917 }
4918
4919
4920 # &handle_tests_dejagnu ()
4921 # ------------------------
4922 sub handle_tests_dejagnu
4923 {
4924     push (@check_tests, 'check-DEJAGNU');
4925     $output_rules .= file_contents ('dejagnu', new Automake::Location);
4926 }
4927
4928 # is_valid_test_extension ($EXT)
4929 # ------------------------------
4930 # Return true if $EXT can appear in $(TEST_EXTENSIONS), return false
4931 # otherwise.
4932 sub is_valid_test_extension ($)
4933 {
4934   my $ext = shift;
4935   return 1
4936     if ($ext =~ /^\.[a-zA-Z_][a-zA-Z0-9_]*$/);
4937   return 1
4938     if (exists $configure_vars{'EXEEXT'} && $ext eq subst ('EXEEXT'));
4939   return 0;
4940 }
4941
4942 # Handle TESTS variable and other checks.
4943 sub handle_tests
4944 {
4945   if (option 'dejagnu')
4946     {
4947       &handle_tests_dejagnu;
4948     }
4949   else
4950     {
4951       foreach my $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
4952         {
4953           reject_var ($c, "`$c' defined but `dejagnu' not in "
4954                       . "`AUTOMAKE_OPTIONS'");
4955         }
4956     }
4957
4958   if (var ('TESTS'))
4959     {
4960       push (@check_tests, 'check-TESTS');
4961       my $check_deps = "@check";
4962       $output_rules .= &file_contents ('check', new Automake::Location,
4963                                        COLOR => !! option 'color-tests',
4964                                        PARALLEL_TESTS => !! option 'parallel-tests',
4965                                        CHECK_DEPS => $check_deps);
4966
4967       # Tests that are known programs should have $(EXEEXT) appended.
4968       # For matching purposes, we need to adjust XFAIL_TESTS as well.
4969       append_exeext { exists $known_programs{$_[0]} } 'TESTS';
4970       append_exeext { exists $known_programs{$_[0]} } 'XFAIL_TESTS'
4971         if (var ('XFAIL_TESTS'));
4972
4973       if (option 'parallel-tests')
4974         {
4975           define_variable ('TEST_SUITE_LOG', 'test-suite.log', INTERNAL);
4976           my $suff = '.test';
4977           my $at_exeext = '';
4978           my $handle_exeext = exists $configure_vars{'EXEEXT'};
4979           if ($handle_exeext)
4980             {
4981               $at_exeext = subst ('EXEEXT');
4982               $suff = $at_exeext  . ' ' . $suff;
4983             }
4984           if (! var 'TEST_EXTENSIONS')
4985             {
4986               define_variable ('TEST_EXTENSIONS', $suff, INTERNAL);
4987             }
4988           my $var = var 'TEST_EXTENSIONS';
4989           # Currently, we are not able to deal with conditional contents
4990           # in TEST_EXTENSIONS.
4991           if ($var->has_conditional_contents)
4992            {
4993              msg_var 'unsupported', $var,
4994                      "`TEST_EXTENSIONS' cannot have conditional contents";
4995            }
4996           my @test_suffixes = $var->value_as_list_recursive;
4997           if ((my @invalid_test_suffixes =
4998                   grep { !is_valid_test_extension $_ } @test_suffixes) > 0)
4999             {
5000               error $var->rdef (TRUE)->location,
5001                     "invalid test extensions: @invalid_test_suffixes";
5002             }
5003           @test_suffixes = grep { is_valid_test_extension $_ } @test_suffixes;
5004           if ($handle_exeext)
5005             {
5006               unshift (@test_suffixes, $at_exeext)
5007                 unless $test_suffixes[0] eq $at_exeext;
5008             }
5009           unshift (@test_suffixes, '');
5010
5011           transform_variable_recursively
5012             ('TESTS', 'TEST_LOGS', 'am__testlogs', 1, INTERNAL,
5013               sub {
5014                 my ($subvar, $val, $cond, $full_cond) = @_;
5015                 my $obj = $val;
5016                 return $obj
5017                   if $val =~ /^\@.*\@$/;
5018                 $obj =~ s/\$\(EXEEXT\)$//o;
5019
5020                 if ($val =~ /(\$\((top_)?srcdir\))\//o)
5021                   {
5022                     msg ('error', $subvar->rdef ($cond)->location,
5023                          "parallel-tests: using `$1' in TESTS is currently broken: `$val'");
5024                   }
5025
5026                 foreach my $test_suffix (@test_suffixes)
5027                   {
5028                     next
5029                       if $test_suffix eq $at_exeext || $test_suffix eq '';
5030                     return substr ($obj, 0, length ($obj) - length ($test_suffix)) . '.log'
5031                       if substr ($obj, - length ($test_suffix)) eq $test_suffix;
5032                   }
5033                 $obj .= '.log';
5034                 my $compile = 'LOG_COMPILE';
5035                 define_variable ($compile,
5036                                  '$(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)', INTERNAL);
5037                 $output_rules .= file_contents ('check2', new Automake::Location,
5038                                                 GENERIC => 0,
5039                                                 OBJ => $obj,
5040                                                 SOURCE => $val,
5041                                                 COMPILE =>'$(' . $compile . ')',
5042                                                 EXT => '',
5043                                                 am__EXEEXT => 'FALSE');
5044                 return $obj;
5045               });
5046
5047           my $nhelper=1;
5048           my $prev = 'TESTS';
5049           my $post = '';
5050           my $last_suffix = $test_suffixes[$#test_suffixes];
5051           my $cur = '';
5052           foreach my $test_suffix (@test_suffixes)
5053             {
5054               if ($test_suffix eq $last_suffix)
5055                 {
5056                   $cur = 'TEST_LOGS';
5057                 }
5058               else
5059                 {
5060                   $cur = 'am__test_logs' . $nhelper;
5061                 }
5062               define_variable ($cur,
5063                 '$(' . $prev . ':' . $test_suffix . $post . '=.log)', INTERNAL);
5064               $post = '.log';
5065               $prev = $cur;
5066               $nhelper++;
5067               if ($test_suffix ne $at_exeext && $test_suffix ne '')
5068                 {
5069                   (my $ext = $test_suffix) =~ s/^\.//;
5070                   $ext = uc $ext;
5071                   my $compile = $ext . '_LOG_COMPILE';
5072                   define_variable ($compile,
5073                                    '$(' . $ext . '_LOG_COMPILER) $(AM_' .  $ext . '_LOG_FLAGS)'
5074                                    . ' $(' . $ext . '_LOG_FLAGS)', INTERNAL);
5075                   my $am_exeext = $handle_exeext ? 'am__EXEEXT' : 'FALSE';
5076                   $output_rules .= file_contents ('check2', new Automake::Location,
5077                                                   GENERIC => 1,
5078                                                   OBJ => '',
5079                                                   SOURCE => '$<',
5080                                                   COMPILE => '$(' . $compile . ')',
5081                                                   EXT => $test_suffix,
5082                                                   am__EXEEXT => $am_exeext);
5083                 }
5084             }
5085
5086           define_variable ('TEST_LOGS_TMP', '$(TEST_LOGS:.log=.log-t)', INTERNAL);
5087
5088           $clean_files{'$(TEST_LOGS_TMP)'} = MOSTLY_CLEAN;
5089           $clean_files{'$(TEST_LOGS)'} = MOSTLY_CLEAN;
5090           $clean_files{'$(TEST_SUITE_LOG)'} = MOSTLY_CLEAN;
5091         }
5092     }
5093 }
5094
5095 # Handle Emacs Lisp.
5096 sub handle_emacs_lisp
5097 {
5098   my @elfiles = &am_install_var ('-candist', 'lisp', 'LISP',
5099                                  'lisp', 'noinst');
5100
5101   return if ! @elfiles;
5102
5103   define_pretty_variable ('am__ELFILES', TRUE, INTERNAL,
5104                           map { $_->[1] } @elfiles);
5105   define_pretty_variable ('am__ELCFILES', TRUE, INTERNAL,
5106                           '$(am__ELFILES:.el=.elc)');
5107   # This one can be overridden by users.
5108   define_pretty_variable ('ELCFILES', TRUE, INTERNAL, '$(LISP:.el=.elc)');
5109
5110   push @all, '$(ELCFILES)';
5111
5112   require_variables ($elfiles[0][0], "Emacs Lisp sources seen", TRUE,
5113                      'EMACS', 'lispdir');
5114   require_conf_file ($elfiles[0][0], FOREIGN, 'elisp-comp');
5115   &define_variable ('elisp_comp', "$am_config_aux_dir/elisp-comp", INTERNAL);
5116 }
5117
5118 # Handle Python
5119 sub handle_python
5120 {
5121   my @pyfiles = &am_install_var ('-defaultdist', 'python', 'PYTHON',
5122                                  'noinst');
5123   return if ! @pyfiles;
5124
5125   require_variables ($pyfiles[0][0], "Python sources seen", TRUE, 'PYTHON');
5126   require_conf_file ($pyfiles[0][0], FOREIGN, 'py-compile');
5127   &define_variable ('py_compile', "$am_config_aux_dir/py-compile", INTERNAL);
5128 }
5129
5130 # Handle Java.
5131 sub handle_java
5132 {
5133     my @sourcelist = &am_install_var ('-candist',
5134                                       'java', 'JAVA',
5135                                       'noinst', 'check');
5136     return if ! @sourcelist;
5137
5138     my @prefixes = am_primary_prefixes ('JAVA', 1,
5139                                         'noinst', 'check');
5140
5141     my $dir;
5142     my @java_sources = ();
5143     foreach my $prefix (@prefixes)
5144       {
5145         (my $curs = $prefix) =~ s/^(?:nobase_)?(?:dist_|nodist_)?//;
5146
5147         next
5148           if $curs eq 'EXTRA';
5149
5150         push @java_sources, '$(' . $prefix . '_JAVA' . ')';
5151
5152         if (defined $dir)
5153           {
5154             err_var "${curs}_JAVA", "multiple _JAVA primaries in use"
5155              unless $curs eq $dir;
5156           }
5157
5158         $dir = $curs;
5159       }
5160
5161     define_pretty_variable ('am__java_sources', TRUE, INTERNAL,
5162                             "@java_sources");
5163
5164     if ($dir eq 'check')
5165       {
5166         push (@check, "class$dir.stamp");
5167       }
5168     else
5169       {
5170         push (@all, "class$dir.stamp");
5171       }
5172 }
5173
5174
5175 # Handle some of the minor options.
5176 sub handle_minor_options
5177 {
5178   if (option 'readme-alpha')
5179     {
5180       if ($relative_dir eq '.')
5181         {
5182           if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
5183             {
5184               msg ('error-gnits', $package_version_location,
5185                    "version `$package_version' doesn't follow " .
5186                    "Gnits standards");
5187             }
5188           if (defined $1 && -f 'README-alpha')
5189             {
5190               # This means we have an alpha release.  See
5191               # GNITS_VERSION_PATTERN for details.
5192               push_dist_common ('README-alpha');
5193             }
5194         }
5195     }
5196 }
5197
5198 ################################################################
5199
5200 # ($OUTPUT, @INPUTS)
5201 # &split_config_file_spec ($SPEC)
5202 # -------------------------------
5203 # Decode the Autoconf syntax for config files (files, headers, links
5204 # etc.).
5205 sub split_config_file_spec ($)
5206 {
5207   my ($spec) = @_;
5208   my ($output, @inputs) = split (/:/, $spec);
5209
5210   push @inputs, "$output.in"
5211     unless @inputs;
5212
5213   return ($output, @inputs);
5214 }
5215
5216 # $input
5217 # locate_am (@POSSIBLE_SOURCES)
5218 # -----------------------------
5219 # AC_CONFIG_FILES allow specifications such as Makefile:top.in:mid.in:bot.in
5220 # This functions returns the first *.in file for which a *.am exists.
5221 # It returns undef otherwise.
5222 sub locate_am (@)
5223 {
5224   my (@rest) = @_;
5225   my $input;
5226   foreach my $file (@rest)
5227     {
5228       if (($file =~ /^(.*)\.in$/) && -f "$1.am")
5229         {
5230           $input = $file;
5231           last;
5232         }
5233     }
5234   return $input;
5235 }
5236
5237 my %make_list;
5238
5239 # &scan_autoconf_config_files ($WHERE, $CONFIG-FILES)
5240 # ---------------------------------------------------
5241 # Study $CONFIG-FILES which is the first argument to AC_CONFIG_FILES
5242 # (or AC_OUTPUT).
5243 sub scan_autoconf_config_files ($$)
5244 {
5245   my ($where, $config_files) = @_;
5246
5247   # Look at potential Makefile.am's.
5248   foreach (split ' ', $config_files)
5249     {
5250       # Must skip empty string for Perl 4.
5251       next if $_ eq "\\" || $_ eq '';
5252
5253       # Handle $local:$input syntax.
5254       my ($local, @rest) = split (/:/);
5255       @rest = ("$local.in",) unless @rest;
5256       # Keep in sync with 'conffile-leading-dot.test'.
5257       msg ('unsupported', $where,
5258            "omit leading './' from config file names such as '$local';"
5259            . "\nremake rules might be subtly broken otherwise")
5260         if ($local =~ /^\.\//);
5261       my $input = locate_am @rest;
5262       if ($input)
5263         {
5264           # We have a file that automake should generate.
5265           $make_list{$input} = join (':', ($local, @rest));
5266         }
5267       else
5268         {
5269           # We have a file that automake should cause to be
5270           # rebuilt, but shouldn't generate itself.
5271           push (@other_input_files, $_);
5272         }
5273       $ac_config_files_location{$local} = $where;
5274       $ac_config_files_condition{$local} =
5275         new Automake::Condition (@cond_stack)
5276           if (@cond_stack);
5277     }
5278 }
5279
5280
5281 # &scan_autoconf_traces ($FILENAME)
5282 # ---------------------------------
5283 sub scan_autoconf_traces ($)
5284 {
5285   my ($filename) = @_;
5286
5287   # Macros to trace, with their minimal number of arguments.
5288   #
5289   # IMPORTANT: If you add a macro here, you should also add this macro
5290   # =========  to Automake-preselection in autoconf/lib/autom4te.in.
5291   my %traced = (
5292                 AC_CANONICAL_BUILD => 0,
5293                 AC_CANONICAL_HOST => 0,
5294                 AC_CANONICAL_TARGET => 0,
5295                 AC_CONFIG_AUX_DIR => 1,
5296                 AC_CONFIG_FILES => 1,
5297                 AC_CONFIG_HEADERS => 1,
5298                 AC_CONFIG_LIBOBJ_DIR => 1,
5299                 AC_CONFIG_LINKS => 1,
5300                 AC_FC_SRCEXT => 1,
5301                 AC_INIT => 0,
5302                 AC_LIBSOURCE => 1,
5303                 AC_REQUIRE_AUX_FILE => 1,
5304                 AC_SUBST_TRACE => 1,
5305                 AM_AUTOMAKE_VERSION => 1,
5306                 AM_CONDITIONAL => 2,
5307                 AM_ENABLE_MULTILIB => 0,
5308                 AM_GNU_GETTEXT => 0,
5309                 AM_GNU_GETTEXT_INTL_SUBDIR => 0,
5310                 AM_INIT_AUTOMAKE => 0,
5311                 AM_MAINTAINER_MODE => 0,
5312                 AM_PROG_CC_C_O => 0,
5313                 AM_SILENT_RULES => 0,
5314                 _AM_SUBST_NOTMAKE => 1,
5315                 _AM_COND_IF => 1,
5316                 _AM_COND_ELSE => 1,
5317                 _AM_COND_ENDIF => 1,
5318                 LT_SUPPORTED_TAG => 1,
5319                 _LT_AC_TAGCONFIG => 0,
5320                 m4_include => 1,
5321                 m4_sinclude => 1,
5322                 sinclude => 1,
5323               );
5324
5325   my $traces = ($ENV{AUTOCONF} || '@am_AUTOCONF@') . " ";
5326
5327   # Use a separator unlikely to be used, not `:', the default, which
5328   # has a precise meaning for AC_CONFIG_FILES and so on.
5329   $traces .= join (' ',
5330                    map { "--trace=$_" . ':\$f:\$l::\$d::\$n::\${::}%' }
5331                    (keys %traced));
5332
5333   my $tracefh = new Automake::XFile ("$traces $filename |");
5334   verb "reading $traces";
5335
5336   @cond_stack = ();
5337   my $where;
5338
5339   while ($_ = $tracefh->getline)
5340     {
5341       chomp;
5342       my ($here, $depth, @args) = split (/::/);
5343       $where = new Automake::Location $here;
5344       my $macro = $args[0];
5345
5346       prog_error ("unrequested trace `$macro'")
5347         unless exists $traced{$macro};
5348
5349       # Skip and diagnose malformed calls.
5350       if ($#args < $traced{$macro})
5351         {
5352           msg ('syntax', $where, "not enough arguments for $macro");
5353           next;
5354         }
5355
5356       # Alphabetical ordering please.
5357       if ($macro eq 'AC_CANONICAL_BUILD')
5358         {
5359           if ($seen_canonical <= AC_CANONICAL_BUILD)
5360             {
5361               $seen_canonical = AC_CANONICAL_BUILD;
5362               $canonical_location = $where;
5363             }
5364         }
5365       elsif ($macro eq 'AC_CANONICAL_HOST')
5366         {
5367           if ($seen_canonical <= AC_CANONICAL_HOST)
5368             {
5369               $seen_canonical = AC_CANONICAL_HOST;
5370               $canonical_location = $where;
5371             }
5372         }
5373       elsif ($macro eq 'AC_CANONICAL_TARGET')
5374         {
5375           $seen_canonical = AC_CANONICAL_TARGET;
5376           $canonical_location = $where;
5377         }
5378       elsif ($macro eq 'AC_CONFIG_AUX_DIR')
5379         {
5380           if ($seen_init_automake)
5381             {
5382               error ($where, "AC_CONFIG_AUX_DIR must be called before "
5383                      . "AM_INIT_AUTOMAKE...", partial => 1);
5384               error ($seen_init_automake, "... AM_INIT_AUTOMAKE called here");
5385             }
5386           $config_aux_dir = $args[1];
5387           $config_aux_dir_set_in_configure_ac = 1;
5388           $relative_dir = '.';
5389           check_directory ($config_aux_dir, $where);
5390         }
5391       elsif ($macro eq 'AC_CONFIG_FILES')
5392         {
5393           # Look at potential Makefile.am's.
5394           scan_autoconf_config_files ($where, $args[1]);
5395         }
5396       elsif ($macro eq 'AC_CONFIG_HEADERS')
5397         {
5398           foreach my $spec (split (' ', $args[1]))
5399             {
5400               my ($dest, @src) = split (':', $spec);
5401               $ac_config_files_location{$dest} = $where;
5402               push @config_headers, $spec;
5403             }
5404         }
5405       elsif ($macro eq 'AC_CONFIG_LIBOBJ_DIR')
5406         {
5407           $config_libobj_dir = $args[1];
5408           $relative_dir = '.';
5409           check_directory ($config_libobj_dir, $where);
5410         }
5411       elsif ($macro eq 'AC_CONFIG_LINKS')
5412         {
5413           foreach my $spec (split (' ', $args[1]))
5414             {
5415               my ($dest, $src) = split (':', $spec);
5416               $ac_config_files_location{$dest} = $where;
5417               push @config_links, $spec;
5418             }
5419         }
5420       elsif ($macro eq 'AC_FC_SRCEXT')
5421         {
5422           my $suffix = $args[1];
5423           # These flags are used as %SOURCEFLAG% in depend2.am,
5424           # where the trailing space is important.
5425           $sourceflags{'.' . $suffix} = '$(FCFLAGS_' . $suffix . ') '
5426             if ($suffix eq 'f90' || $suffix eq 'f95' || $suffix eq 'f03' || $suffix eq 'f08');
5427         }
5428       elsif ($macro eq 'AC_INIT')
5429         {
5430           if (defined $args[2])
5431             {
5432               $package_version = $args[2];
5433               $package_version_location = $where;
5434             }
5435         }
5436       elsif ($macro eq 'AC_LIBSOURCE')
5437         {
5438           $libsources{$args[1]} = $here;
5439         }
5440       elsif ($macro eq 'AC_REQUIRE_AUX_FILE')
5441         {
5442           # Only remember the first time a file is required.
5443           $required_aux_file{$args[1]} = $where
5444             unless exists $required_aux_file{$args[1]};
5445         }
5446       elsif ($macro eq 'AC_SUBST_TRACE')
5447         {
5448           # Just check for alphanumeric in AC_SUBST_TRACE.  If you do
5449           # AC_SUBST(5), then too bad.
5450           $configure_vars{$args[1]} = $where
5451             if $args[1] =~ /^\w+$/;
5452         }
5453       elsif ($macro eq 'AM_AUTOMAKE_VERSION')
5454         {
5455           error ($where,
5456                  "version mismatch.  This is Automake $VERSION,\n" .
5457                  "but the definition used by this AM_INIT_AUTOMAKE\n" .
5458                  "comes from Automake $args[1].  You should recreate\n" .
5459                  "aclocal.m4 with aclocal and run automake again.\n",
5460                  # $? = 63 is used to indicate version mismatch to missing.
5461                  exit_code => 63)
5462             if $VERSION ne $args[1];
5463
5464           $seen_automake_version = 1;
5465         }
5466       elsif ($macro eq 'AM_CONDITIONAL')
5467         {
5468           $configure_cond{$args[1]} = $where;
5469         }
5470       elsif ($macro eq 'AM_ENABLE_MULTILIB')
5471         {
5472           $seen_multilib = $where;
5473         }
5474       elsif ($macro eq 'AM_GNU_GETTEXT')
5475         {
5476           $seen_gettext = $where;
5477           $ac_gettext_location = $where;
5478           $seen_gettext_external = grep ($_ eq 'external', @args);
5479         }
5480       elsif ($macro eq 'AM_GNU_GETTEXT_INTL_SUBDIR')
5481         {
5482           $seen_gettext_intl = $where;
5483         }
5484       elsif ($macro eq 'AM_INIT_AUTOMAKE')
5485         {
5486           $seen_init_automake = $where;
5487           if (defined $args[2])
5488             {
5489               $package_version = $args[2];
5490               $package_version_location = $where;
5491             }
5492           elsif (defined $args[1])
5493             {
5494               exit $exit_code
5495                 if (process_global_option_list ($where,
5496                                                 split (' ', $args[1])));
5497             }
5498         }
5499       elsif ($macro eq 'AM_MAINTAINER_MODE')
5500         {
5501           $seen_maint_mode = $where;
5502         }
5503       elsif ($macro eq 'AM_PROG_CC_C_O')
5504         {
5505           $seen_cc_c_o = $where;
5506         }
5507       elsif ($macro eq 'AM_SILENT_RULES')
5508         {
5509           set_global_option ('silent-rules', $where);
5510         }
5511       elsif ($macro eq '_AM_COND_IF')
5512         {
5513           cond_stack_if ('', $args[1], $where);
5514           error ($where, "missing m4 quoting, macro depth $depth")
5515             if ($depth != 1);
5516         }
5517       elsif ($macro eq '_AM_COND_ELSE')
5518         {
5519           cond_stack_else ('!', $args[1], $where);
5520           error ($where, "missing m4 quoting, macro depth $depth")
5521             if ($depth != 1);
5522         }
5523       elsif ($macro eq '_AM_COND_ENDIF')
5524         {
5525           cond_stack_endif (undef, undef, $where);
5526           error ($where, "missing m4 quoting, macro depth $depth")
5527             if ($depth != 1);
5528         }
5529       elsif ($macro eq '_AM_SUBST_NOTMAKE')
5530         {
5531           $ignored_configure_vars{$args[1]} = $where;
5532         }
5533       elsif ($macro eq 'm4_include'
5534              || $macro eq 'm4_sinclude'
5535              || $macro eq 'sinclude')
5536         {
5537           # Skip missing `sinclude'd files.
5538           next if $macro ne 'm4_include' && ! -f $args[1];
5539
5540           # Some modified versions of Autoconf don't use
5541           # frozen files.  Consequently it's possible that we see all
5542           # m4_include's performed during Autoconf's startup.
5543           # Obviously we don't want to distribute Autoconf's files
5544           # so we skip absolute filenames here.
5545           push @configure_deps, '$(top_srcdir)/' . $args[1]
5546             unless $here =~ m,^(?:\w:)?[\\/],;
5547           # Keep track of the greatest timestamp.
5548           if (-e $args[1])
5549             {
5550               my $mtime = mtime $args[1];
5551               $configure_deps_greatest_timestamp = $mtime
5552                 if $mtime > $configure_deps_greatest_timestamp;
5553             }
5554         }
5555       elsif ($macro eq 'LT_SUPPORTED_TAG')
5556         {
5557           $libtool_tags{$args[1]} = 1;
5558           $libtool_new_api = 1;
5559         }
5560       elsif ($macro eq '_LT_AC_TAGCONFIG')
5561         {
5562           # _LT_AC_TAGCONFIG is an old macro present in Libtool 1.5.
5563           # We use it to detect whether tags are supported.  Our
5564           # preferred interface is LT_SUPPORTED_TAG, but it was
5565           # introduced in Libtool 1.6.
5566           if (0 == keys %libtool_tags)
5567             {
5568               # Hardcode the tags supported by Libtool 1.5.
5569               %libtool_tags = (CC => 1, CXX => 1, GCJ => 1, F77 => 1);
5570             }
5571         }
5572     }
5573
5574   error ($where, "condition stack not properly closed")
5575     if (@cond_stack);
5576
5577   $tracefh->close;
5578 }
5579
5580
5581 # &scan_autoconf_files ()
5582 # -----------------------
5583 # Check whether we use `configure.ac' or `configure.in'.
5584 # Scan it (and possibly `aclocal.m4') for interesting things.
5585 # We must scan aclocal.m4 because there might be AC_SUBSTs and such there.
5586 sub scan_autoconf_files ()
5587 {
5588   # Reinitialize libsources here.  This isn't really necessary,
5589   # since we currently assume there is only one configure.ac.  But
5590   # that won't always be the case.
5591   %libsources = ();
5592
5593   # Keep track of the youngest configure dependency.
5594   $configure_deps_greatest_timestamp = mtime $configure_ac;
5595   if (-e 'aclocal.m4')
5596     {
5597       my $mtime = mtime 'aclocal.m4';
5598       $configure_deps_greatest_timestamp = $mtime
5599         if $mtime > $configure_deps_greatest_timestamp;
5600     }
5601
5602   scan_autoconf_traces ($configure_ac);
5603
5604   @configure_input_files = sort keys %make_list;
5605   # Set input and output files if not specified by user.
5606   if (! @input_files)
5607     {
5608       @input_files = @configure_input_files;
5609       %output_files = %make_list;
5610     }
5611
5612
5613   if (! $seen_init_automake)
5614     {
5615       err_ac ("no proper invocation of AM_INIT_AUTOMAKE was found.\nYou "
5616               . "should verify that $configure_ac invokes AM_INIT_AUTOMAKE,"
5617               . "\nthat aclocal.m4 is present in the top-level directory,\n"
5618               . "and that aclocal.m4 was recently regenerated "
5619               . "(using aclocal).");
5620     }
5621   else
5622     {
5623       if (! $seen_automake_version)
5624         {
5625           if (-f 'aclocal.m4')
5626             {
5627               error ($seen_init_automake,
5628                      "your implementation of AM_INIT_AUTOMAKE comes from " .
5629                      "an\nold Automake version.  You should recreate " .
5630                      "aclocal.m4\nwith aclocal and run automake again.\n",
5631                      # $? = 63 is used to indicate version mismatch to missing.
5632                      exit_code => 63);
5633             }
5634           else
5635             {
5636               error ($seen_init_automake,
5637                      "no proper implementation of AM_INIT_AUTOMAKE was " .
5638                      "found,\nprobably because aclocal.m4 is missing...\n" .
5639                      "You should run aclocal to create this file, then\n" .
5640                      "run automake again.\n");
5641             }
5642         }
5643     }
5644
5645   locate_aux_dir ();
5646
5647   # Reorder @input_files so that the Makefile that distributes aux
5648   # files is processed last.  This is important because each directory
5649   # can require auxiliary scripts and we should wait until they have
5650   # been installed before distributing them.
5651
5652   # The Makefile.in that distribute the aux files is the one in
5653   # $config_aux_dir or the top-level Makefile.
5654   my $auxdirdist = is_make_dir ($config_aux_dir) ? $config_aux_dir : '.';
5655   my @new_input_files = ();
5656   while (@input_files)
5657     {
5658       my $in = pop @input_files;
5659       my @ins = split (/:/, $output_files{$in});
5660       if (dirname ($ins[0]) eq $auxdirdist)
5661         {
5662           push @new_input_files, $in;
5663           $automake_will_process_aux_dir = 1;
5664         }
5665       else
5666         {
5667           unshift @new_input_files, $in;
5668         }
5669     }
5670   @input_files = @new_input_files;
5671
5672   # If neither the auxdir/Makefile nor the ./Makefile are generated
5673   # by Automake, we won't distribute the aux files anyway.  Assume
5674   # the user know what (s)he does, and pretend we will distribute
5675   # them to disable the error in require_file_internal.
5676   $automake_will_process_aux_dir = 1 if ! is_make_dir ($auxdirdist);
5677
5678   # Look for some files we need.  Always check for these.  This
5679   # check must be done for every run, even those where we are only
5680   # looking at a subdir Makefile.  We must set relative_dir for
5681   # maybe_push_required_file to work.
5682   # Sort the files for stable verbose output.
5683   $relative_dir = '.';
5684   foreach my $file (sort keys %required_aux_file)
5685     {
5686       require_conf_file ($required_aux_file{$file}->get, FOREIGN, $file)
5687     }
5688   err_am "`install.sh' is an anachronism; use `install-sh' instead"
5689     if -f $config_aux_dir . '/install.sh';
5690
5691   # Preserve dist_common for later.
5692   $configure_dist_common = variable_value ('DIST_COMMON') || '';
5693
5694 }
5695
5696 ################################################################
5697
5698 # Set up for Cygnus mode.
5699 sub check_cygnus
5700 {
5701   my $cygnus = option 'cygnus';
5702   return unless $cygnus;
5703
5704   set_strictness ('foreign');
5705   set_option ('no-installinfo', $cygnus);
5706   set_option ('no-dependencies', $cygnus);
5707   set_option ('no-dist', $cygnus);
5708
5709   err_ac "`AM_MAINTAINER_MODE' required when --cygnus specified"
5710     if !$seen_maint_mode;
5711 }
5712
5713 # Do any extra checking for GNU standards.
5714 sub check_gnu_standards
5715 {
5716   if ($relative_dir eq '.')
5717     {
5718       # In top level (or only) directory.
5719       require_file ("$am_file.am", GNU,
5720                     qw/INSTALL NEWS README AUTHORS ChangeLog/);
5721
5722       # Accept one of these three licenses; default to COPYING.
5723       # Make sure we do not overwrite an existing license.
5724       my $license;
5725       foreach (qw /COPYING COPYING.LIB COPYING.LESSER/)
5726         {
5727           if (-f $_)
5728             {
5729               $license = $_;
5730               last;
5731             }
5732         }
5733       require_file ("$am_file.am", GNU, 'COPYING')
5734         unless $license;
5735     }
5736
5737   for my $opt ('no-installman', 'no-installinfo')
5738     {
5739       msg ('error-gnu', option $opt,
5740            "option `$opt' disallowed by GNU standards")
5741         if option $opt;
5742     }
5743 }
5744
5745 # Do any extra checking for GNITS standards.
5746 sub check_gnits_standards
5747 {
5748   if ($relative_dir eq '.')
5749     {
5750       # In top level (or only) directory.
5751       require_file ("$am_file.am", GNITS, 'THANKS');
5752     }
5753 }
5754
5755 ################################################################
5756 #
5757 # Functions to handle files of each language.
5758
5759 # Each `lang_X_rewrite($DIRECTORY, $BASE, $EXT)' function follows a
5760 # simple formula: Return value is LANG_SUBDIR if the resulting object
5761 # file should be in a subdir if the source file is, LANG_PROCESS if
5762 # file is to be dealt with, LANG_IGNORE otherwise.
5763
5764 # Much of the actual processing is handled in
5765 # handle_single_transform.  These functions exist so that
5766 # auxiliary information can be recorded for a later cleanup pass.
5767 # Note that the calls to these functions are computed, so don't bother
5768 # searching for their precise names in the source.
5769
5770 # This is just a convenience function that can be used to determine
5771 # when a subdir object should be used.
5772 sub lang_sub_obj
5773 {
5774     return option 'subdir-objects' ? LANG_SUBDIR : LANG_PROCESS;
5775 }
5776
5777 # Rewrite a single C source file.
5778 sub lang_c_rewrite
5779 {
5780   my ($directory, $base, $ext, $nonansi_obj, $have_per_exec_flags, $var) = @_;
5781
5782   if (option 'ansi2knr' && $base =~ /_$/)
5783     {
5784       # FIXME: include line number in error.
5785       err_am "C source file `$base.c' would be deleted by ansi2knr rules";
5786     }
5787
5788   my $r = LANG_PROCESS;
5789   if (option 'subdir-objects')
5790     {
5791       $r = LANG_SUBDIR;
5792       if ($directory && $directory ne '.')
5793         {
5794           $base = $directory . '/' . $base;
5795
5796           # libtool is always able to put the object at the proper place,
5797           # so we do not have to require AM_PROG_CC_C_O when building .lo files.
5798           msg_var ('portability', $var,
5799                    "compiling `$base.c' in subdir requires "
5800                    . "`AM_PROG_CC_C_O' in `$configure_ac'",
5801                    uniq_scope => US_GLOBAL,
5802                    uniq_part => 'AM_PROG_CC_C_O subdir')
5803             unless $seen_cc_c_o || $nonansi_obj eq '.lo';
5804         }
5805
5806       # In this case we already have the directory information, so
5807       # don't add it again.
5808       $de_ansi_files{$base} = '';
5809     }
5810   else
5811     {
5812       $de_ansi_files{$base} = (($directory eq '.' || $directory eq '')
5813                                ? ''
5814                                : "$directory/");
5815     }
5816
5817   if (! $seen_cc_c_o
5818       && $have_per_exec_flags
5819       && ! option 'subdir-objects'
5820       && $nonansi_obj ne '.lo')
5821     {
5822       msg_var ('portability',
5823                $var, "compiling `$base.c' with per-target flags requires "
5824                . "`AM_PROG_CC_C_O' in `$configure_ac'",
5825                uniq_scope => US_GLOBAL,
5826                uniq_part => 'AM_PROG_CC_C_O per-target')
5827     }
5828
5829     return $r;
5830 }
5831
5832 # Rewrite a single C++ source file.
5833 sub lang_cxx_rewrite
5834 {
5835     return &lang_sub_obj;
5836 }
5837
5838 # Rewrite a single header file.
5839 sub lang_header_rewrite
5840 {
5841     # Header files are simply ignored.
5842     return LANG_IGNORE;
5843 }
5844
5845 # Rewrite a single Vala source file.
5846 sub lang_vala_rewrite
5847 {
5848     my ($directory, $base, $ext) = @_;
5849
5850     (my $newext = $ext) =~ s/vala$/c/;
5851     return (LANG_SUBDIR, $newext);
5852 }
5853
5854 # Rewrite a single yacc file.
5855 sub lang_yacc_rewrite
5856 {
5857     my ($directory, $base, $ext) = @_;
5858
5859     my $r = &lang_sub_obj;
5860     (my $newext = $ext) =~ tr/y/c/;
5861     return ($r, $newext);
5862 }
5863
5864 # Rewrite a single yacc++ file.
5865 sub lang_yaccxx_rewrite
5866 {
5867     my ($directory, $base, $ext) = @_;
5868
5869     my $r = &lang_sub_obj;
5870     (my $newext = $ext) =~ tr/y/c/;
5871     return ($r, $newext);
5872 }
5873
5874 # Rewrite a single lex file.
5875 sub lang_lex_rewrite
5876 {
5877     my ($directory, $base, $ext) = @_;
5878
5879     my $r = &lang_sub_obj;
5880     (my $newext = $ext) =~ tr/l/c/;
5881     return ($r, $newext);
5882 }
5883
5884 # Rewrite a single lex++ file.
5885 sub lang_lexxx_rewrite
5886 {
5887     my ($directory, $base, $ext) = @_;
5888
5889     my $r = &lang_sub_obj;
5890     (my $newext = $ext) =~ tr/l/c/;
5891     return ($r, $newext);
5892 }
5893
5894 # Rewrite a single assembly file.
5895 sub lang_asm_rewrite
5896 {
5897     return &lang_sub_obj;
5898 }
5899
5900 # Rewrite a single preprocessed assembly file.
5901 sub lang_cppasm_rewrite
5902 {
5903     return &lang_sub_obj;
5904 }
5905
5906 # Rewrite a single Fortran 77 file.
5907 sub lang_f77_rewrite
5908 {
5909     return &lang_sub_obj;
5910 }
5911
5912 # Rewrite a single Fortran file.
5913 sub lang_fc_rewrite
5914 {
5915     return &lang_sub_obj;
5916 }
5917
5918 # Rewrite a single preprocessed Fortran file.
5919 sub lang_ppfc_rewrite
5920 {
5921     return &lang_sub_obj;
5922 }
5923
5924 # Rewrite a single preprocessed Fortran 77 file.
5925 sub lang_ppf77_rewrite
5926 {
5927     return &lang_sub_obj;
5928 }
5929
5930 # Rewrite a single ratfor file.
5931 sub lang_ratfor_rewrite
5932 {
5933     return &lang_sub_obj;
5934 }
5935
5936 # Rewrite a single Objective C file.
5937 sub lang_objc_rewrite
5938 {
5939     return &lang_sub_obj;
5940 }
5941
5942 # Rewrite a single Unified Parallel C file.
5943 sub lang_upc_rewrite
5944 {
5945     return &lang_sub_obj;
5946 }
5947
5948 # Rewrite a single Java file.
5949 sub lang_java_rewrite
5950 {
5951     return LANG_SUBDIR;
5952 }
5953
5954 # The lang_X_finish functions are called after all source file
5955 # processing is done.  Each should handle defining rules for the
5956 # language, etc.  A finish function is only called if a source file of
5957 # the appropriate type has been seen.
5958
5959 sub lang_c_finish
5960 {
5961     # Push all libobjs files onto de_ansi_files.  We actually only
5962     # push files which exist in the current directory, and which are
5963     # genuine source files.
5964     foreach my $file (keys %libsources)
5965     {
5966         if ($file =~ /^(.*)\.[cly]$/ && -f "$relative_dir/$file")
5967         {
5968             $de_ansi_files{$1} = ''
5969         }
5970     }
5971
5972     if (option 'ansi2knr' && keys %de_ansi_files)
5973     {
5974         # Make all _.c files depend on their corresponding .c files.
5975         my @objects;
5976         foreach my $base (sort keys %de_ansi_files)
5977         {
5978             # Each _.c file must depend on ansi2knr; otherwise it
5979             # might be used in a parallel build before it is built.
5980             # We need to support files in the srcdir and in the build
5981             # dir (because these files might be auto-generated.  But
5982             # we can't use $< -- some makes only define $< during a
5983             # suffix rule.
5984             my $ansfile = $de_ansi_files{$base} . $base . '.c';
5985             $output_rules .= ($base . "_.c: $ansfile \$(ANSI2KNR)\n\t"
5986                               . '$(CPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) '
5987                               . '`if test -f $(srcdir)/' . $ansfile
5988                               . '; then echo $(srcdir)/' . $ansfile
5989                               . '; else echo ' . $ansfile . '; fi` '
5990                               . "| sed 's/^# \\([0-9]\\)/#line \\1/' "
5991                               . '| $(ANSI2KNR) > $@'
5992                               # If ansi2knr fails then we shouldn't
5993                               # create the _.c file
5994                               . " || rm -f \$\@\n");
5995             push (@objects, $base . '_.$(OBJEXT)');
5996             push (@objects, $base . '_.lo')
5997               if var ('LIBTOOL');
5998
5999             # Explicitly clean the _.c files if they are in a
6000             # subdirectory. (In the current directory they get erased
6001             # by a `rm -f *_.c' rule.)
6002             $clean_files{$base . '_.c'} = MOSTLY_CLEAN
6003               if dirname ($base) ne '.';
6004         }
6005
6006         # Make all _.o (and _.lo) files depend on ansi2knr.
6007         # Use a sneaky little hack to make it print nicely.
6008         &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
6009     }
6010 }
6011
6012 sub lang_vala_finish_target ($$)
6013 {
6014   my ($self, $name) = @_;
6015
6016   my $derived = canonicalize ($name);
6017   my $varname = $derived . '_SOURCES';
6018   my $var = var ($varname);
6019
6020   if ($var)
6021     {
6022       foreach my $file ($var->value_as_list_recursive)
6023         {
6024           $output_rules .= "\$(srcdir)/$file: \$(srcdir)/${derived}_vala.stamp\n"
6025             . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6026             . "\t\@if test -f \$@; then :; else \\\n"
6027             . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
6028             . "\tfi\n"
6029             if $file =~ s/(.*)\.vala$/$1.c/;
6030         }
6031     }
6032
6033   # Add rebuild rules for generated header and vapi files
6034   my $flags = var ($derived . '_VALAFLAGS');
6035   if ($flags)
6036     {
6037       my $lastflag = '';
6038       foreach my $flag ($flags->value_as_list_recursive)
6039         {
6040           if (grep (/$lastflag/, ('-H', '-h', '--header', '--internal-header',
6041                                   '--vapi', '--internal-vapi', '--gir')))
6042             {
6043               my $headerfile = $flag;
6044               $output_rules .= "\$(srcdir)/$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
6045                 . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6046                 . "\t\@if test -f \$@; then :; else \\\n"
6047                 . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
6048                 . "\tfi\n";
6049
6050               # valac is not used when building from dist tarballs
6051               # distribute the generated files
6052               push_dist_common ($headerfile);
6053               $clean_files{$headerfile} = MAINTAINER_CLEAN;
6054             }
6055           $lastflag = $flag;
6056         }
6057     }
6058
6059   my $compile = $self->compile;
6060
6061   # Rewrite each occurrence of `AM_VALAFLAGS' in the compile
6062   # rule into `${derived}_VALAFLAGS' if it exists.
6063   my $val = "${derived}_VALAFLAGS";
6064   $compile =~ s/\(AM_VALAFLAGS\)/\($val\)/
6065     if set_seen ($val);
6066
6067   # VALAFLAGS is a user variable (per GNU Standards),
6068   # it should not be overridden in the Makefile...
6069   check_user_variables ['VALAFLAGS'];
6070
6071   my $dirname = dirname ($name);
6072
6073   # Only generate C code, do not run C compiler
6074   $compile .= " -C";
6075
6076   my $verbose = verbose_flag ('VALAC');
6077   my $silent = silent_flag ();
6078
6079   $output_rules .=
6080     "\$(srcdir)/${derived}_vala.stamp: \$(${derived}_SOURCES)\n".
6081 # Since the C files generated from the vala sources depend on the
6082 # ${derived}_vala.stamp file, we must ensure its timestamp is older than
6083 # those of the C files generated by the valac invocation below (this is
6084 # especially important on systems with sub-second timestamp resolution).
6085 # Thus we need to create the stamp file *before* invoking valac, and to
6086 # move it to its final location only after valac has been invoked.
6087     "\t${silent}rm -f \$\@ && echo stamp > \$\@-t\n".
6088     "\t${verbose}\$(am__cd) \$(srcdir) && ${compile} \$(${derived}_SOURCES)\n".
6089     "\t${silent}mv -f \$\@-t \$\@\n";
6090
6091   push_dist_common ("${derived}_vala.stamp");
6092
6093   $clean_files{"${derived}_vala.stamp"} = MAINTAINER_CLEAN;
6094 }
6095
6096 # Add output rules to invoke valac and create stamp file as a witness
6097 # to handle multiple outputs. This function is called after all source
6098 # file processing is done.
6099 sub lang_vala_finish
6100 {
6101   my ($self) = @_;
6102
6103   foreach my $prog (keys %known_programs)
6104     {
6105       lang_vala_finish_target ($self, $prog);
6106     }
6107
6108   while (my ($name) = each %known_libraries)
6109     {
6110       lang_vala_finish_target ($self, $name);
6111     }
6112 }
6113
6114 # The built .c files should be cleaned only on maintainer-clean
6115 # as the .c files are distributed. This function is called for each
6116 # .vala source file.
6117 sub lang_vala_target_hook
6118 {
6119   my ($self, $aggregate, $output, $input, %transform) = @_;
6120
6121   $clean_files{$output} = MAINTAINER_CLEAN;
6122 }
6123
6124 # This is a yacc helper which is called whenever we have decided to
6125 # compile a yacc file.
6126 sub lang_yacc_target_hook
6127 {
6128     my ($self, $aggregate, $output, $input, %transform) = @_;
6129
6130     my $flag = $aggregate . "_YFLAGS";
6131     my $flagvar = var $flag;
6132     my $YFLAGSvar = var 'YFLAGS';
6133     if (($flagvar && $flagvar->variable_value =~ /$DASH_D_PATTERN/o)
6134         || ($YFLAGSvar && $YFLAGSvar->variable_value =~ /$DASH_D_PATTERN/o))
6135     {
6136         (my $output_base = $output) =~ s/$KNOWN_EXTENSIONS_PATTERN$//;
6137         my $header = $output_base . '.h';
6138
6139         # Found a `-d' that applies to the compilation of this file.
6140         # Add a dependency for the generated header file, and arrange
6141         # for that file to be included in the distribution.
6142         foreach my $cond (Automake::Rule::define (${header}, 'internal',
6143                                                   RULE_AUTOMAKE, TRUE,
6144                                                   INTERNAL))
6145           {
6146             my $condstr = $cond->subst_string;
6147             $output_rules .=
6148               "$condstr${header}: $output\n"
6149               # Recover from removal of $header
6150               . "$condstr\t\@if test ! -f \$@; then rm -f $output; else :; fi\n"
6151               . "$condstr\t\@if test ! -f \$@; then \$(MAKE) \$(AM_MAKEFLAGS) $output; else :; fi\n";
6152           }
6153         # Distribute the generated file, unless its .y source was
6154         # listed in a nodist_ variable.  (&handle_source_transform
6155         # will set DIST_SOURCE.)
6156         &push_dist_common ($header)
6157           if $transform{'DIST_SOURCE'};
6158
6159         # If the files are built in the build directory, then we want
6160         # to remove them with `make clean'.  If they are in srcdir
6161         # they shouldn't be touched.  However, we can't determine this
6162         # statically, and the GNU rules say that yacc/lex output files
6163         # should be removed by maintainer-clean.  So that's what we
6164         # do.
6165         $clean_files{$header} = MAINTAINER_CLEAN;
6166     }
6167     # Erase $OUTPUT on `make maintainer-clean' (by GNU standards).
6168     # See the comment above for $HEADER.
6169     $clean_files{$output} = MAINTAINER_CLEAN;
6170 }
6171
6172 # This is a lex helper which is called whenever we have decided to
6173 # compile a lex file.
6174 sub lang_lex_target_hook
6175 {
6176     my ($self, $aggregate, $output, $input) = @_;
6177     # If the files are built in the build directory, then we want to
6178     # remove them with `make clean'.  If they are in srcdir they
6179     # shouldn't be touched.  However, we can't determine this
6180     # statically, and the GNU rules say that yacc/lex output files
6181     # should be removed by maintainer-clean.  So that's what we do.
6182     $clean_files{$output} = MAINTAINER_CLEAN;
6183 }
6184
6185 # This is a helper for both lex and yacc.
6186 sub yacc_lex_finish_helper
6187 {
6188   return if defined $language_scratch{'lex-yacc-done'};
6189   $language_scratch{'lex-yacc-done'} = 1;
6190
6191   # FIXME: for now, no line number.
6192   require_conf_file ($configure_ac, FOREIGN, 'ylwrap');
6193   &define_variable ('YLWRAP', "$am_config_aux_dir/ylwrap", INTERNAL);
6194 }
6195
6196 sub lang_yacc_finish
6197 {
6198   return if defined $language_scratch{'yacc-done'};
6199   $language_scratch{'yacc-done'} = 1;
6200
6201   reject_var 'YACCFLAGS', "`YACCFLAGS' obsolete; use `YFLAGS' instead";
6202
6203   yacc_lex_finish_helper;
6204 }
6205
6206
6207 sub lang_lex_finish
6208 {
6209   return if defined $language_scratch{'lex-done'};
6210   $language_scratch{'lex-done'} = 1;
6211
6212   yacc_lex_finish_helper;
6213 }
6214
6215
6216 # Given a hash table of linker names, pick the name that has the most
6217 # precedence.  This is lame, but something has to have global
6218 # knowledge in order to eliminate the conflict.  Add more linkers as
6219 # required.
6220 sub resolve_linker
6221 {
6222     my (%linkers) = @_;
6223
6224     foreach my $l (qw(GCJLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
6225     {
6226         return $l if defined $linkers{$l};
6227     }
6228     return 'LINK';
6229 }
6230
6231 # Called to indicate that an extension was used.
6232 sub saw_extension
6233 {
6234     my ($ext) = @_;
6235     if (! defined $extension_seen{$ext})
6236     {
6237         $extension_seen{$ext} = 1;
6238     }
6239     else
6240     {
6241         ++$extension_seen{$ext};
6242     }
6243 }
6244
6245 # Return the number of files seen for a given language.  Knows about
6246 # special cases we care about.  FIXME: this is hideous.  We need
6247 # something that involves real language objects.  For instance yacc
6248 # and yaccxx could both derive from a common yacc class which would
6249 # know about the strange ylwrap requirement.  (Or better yet we could
6250 # just not support legacy yacc!)
6251 sub count_files_for_language
6252 {
6253     my ($name) = @_;
6254
6255     my @names;
6256     if ($name eq 'yacc' || $name eq 'yaccxx')
6257     {
6258         @names = ('yacc', 'yaccxx');
6259     }
6260     elsif ($name eq 'lex' || $name eq 'lexxx')
6261     {
6262         @names = ('lex', 'lexxx');
6263     }
6264     else
6265     {
6266         @names = ($name);
6267     }
6268
6269     my $r = 0;
6270     foreach $name (@names)
6271     {
6272         my $lang = $languages{$name};
6273         foreach my $ext (@{$lang->extensions})
6274         {
6275             $r += $extension_seen{$ext}
6276                 if defined $extension_seen{$ext};
6277         }
6278     }
6279
6280     return $r
6281 }
6282
6283 # Called to ask whether source files have been seen . If HEADERS is 1,
6284 # headers can be included.
6285 sub saw_sources_p
6286 {
6287     my ($headers) = @_;
6288
6289     # count all the sources
6290     my $count = 0;
6291     foreach my $val (values %extension_seen)
6292     {
6293         $count += $val;
6294     }
6295
6296     if (!$headers)
6297     {
6298         $count -= count_files_for_language ('header');
6299     }
6300
6301     return $count > 0;
6302 }
6303
6304
6305 # register_language (%ATTRIBUTE)
6306 # ------------------------------
6307 # Register a single language.
6308 # Each %ATTRIBUTE is of the form ATTRIBUTE => VALUE.
6309 sub register_language (%)
6310 {
6311   my (%option) = @_;
6312
6313   # Set the defaults.
6314   $option{'ansi'} = 0
6315     unless defined $option{'ansi'};
6316   $option{'autodep'} = 'no'
6317     unless defined $option{'autodep'};
6318   $option{'linker'} = ''
6319     unless defined $option{'linker'};
6320   $option{'flags'} = []
6321     unless defined $option{'flags'};
6322   $option{'output_extensions'} = sub { return ( '.$(OBJEXT)', '.lo' ) }
6323     unless defined $option{'output_extensions'};
6324   $option{'nodist_specific'} = 0
6325     unless defined $option{'nodist_specific'};
6326
6327   my $lang = new Language (%option);
6328
6329   # Fill indexes.
6330   $extension_map{$_} = $lang->name foreach @{$lang->extensions};
6331   $languages{$lang->name} = $lang;
6332   my $link = $lang->linker;
6333   if ($link)
6334     {
6335       if (exists $link_languages{$link})
6336         {
6337           prog_error ("`$link' has different definitions in "
6338                       . $lang->name . " and " . $link_languages{$link}->name)
6339             if $lang->link ne $link_languages{$link}->link;
6340         }
6341       else
6342         {
6343           $link_languages{$link} = $lang;
6344         }
6345     }
6346
6347   # Update the pattern of known extensions.
6348   accept_extensions (@{$lang->extensions});
6349
6350   # Upate the $suffix_rule map.
6351   foreach my $suffix (@{$lang->extensions})
6352     {
6353       foreach my $dest (&{$lang->output_extensions} ($suffix))
6354         {
6355           register_suffix_rule (INTERNAL, $suffix, $dest);
6356         }
6357     }
6358 }
6359
6360 # derive_suffix ($EXT, $OBJ)
6361 # --------------------------
6362 # This function is used to find a path from a user-specified suffix $EXT
6363 # to $OBJ or to some other suffix we recognize internally, e.g. `cc'.
6364 sub derive_suffix ($$)
6365 {
6366   my ($source_ext, $obj) = @_;
6367
6368   while (! $extension_map{$source_ext}
6369          && $source_ext ne $obj
6370          && exists $suffix_rules->{$source_ext}
6371          && exists $suffix_rules->{$source_ext}{$obj})
6372     {
6373       $source_ext = $suffix_rules->{$source_ext}{$obj}[0];
6374     }
6375
6376   return $source_ext;
6377 }
6378
6379
6380 ################################################################
6381
6382 # Pretty-print something and append to output_rules.
6383 sub pretty_print_rule
6384 {
6385     $output_rules .= &makefile_wrap (@_);
6386 }
6387
6388
6389 ################################################################
6390
6391
6392 ## -------------------------------- ##
6393 ## Handling the conditional stack.  ##
6394 ## -------------------------------- ##
6395
6396
6397 # $STRING
6398 # make_conditional_string ($NEGATE, $COND)
6399 # ----------------------------------------
6400 sub make_conditional_string ($$)
6401 {
6402   my ($negate, $cond) = @_;
6403   $cond = "${cond}_TRUE"
6404     unless $cond =~ /^TRUE|FALSE$/;
6405   $cond = Automake::Condition::conditional_negate ($cond)
6406     if $negate;
6407   return $cond;
6408 }
6409
6410
6411 my %_am_macro_for_cond =
6412   (
6413   AMDEP => "one of the compiler tests\n"
6414            . "    AC_PROG_CC, AC_PROG_CXX, AC_PROG_CXX, AC_PROG_OBJC,\n"
6415            . "    AM_PROG_AS, AM_PROG_GCJ, AM_PROG_UPC",
6416   am__fastdepCC => 'AC_PROG_CC',
6417   am__fastdepCCAS => 'AM_PROG_AS',
6418   am__fastdepCXX => 'AC_PROG_CXX',
6419   am__fastdepGCJ => 'AM_PROG_GCJ',
6420   am__fastdepOBJC => 'AC_PROG_OBJC',
6421   am__fastdepUPC => 'AM_PROG_UPC'
6422   );
6423
6424 # $COND
6425 # cond_stack_if ($NEGATE, $COND, $WHERE)
6426 # --------------------------------------
6427 sub cond_stack_if ($$$)
6428 {
6429   my ($negate, $cond, $where) = @_;
6430
6431   if (! $configure_cond{$cond} && $cond !~ /^TRUE|FALSE$/)
6432     {
6433       my $text = "$cond does not appear in AM_CONDITIONAL";
6434       my $scope = US_LOCAL;
6435       if (exists $_am_macro_for_cond{$cond})
6436         {
6437           my $mac = $_am_macro_for_cond{$cond};
6438           $text .= "\n  The usual way to define `$cond' is to add ";
6439           $text .= ($mac =~ / /) ? $mac : "`$mac'";
6440           $text .= "\n  to `$configure_ac' and run `aclocal' and `autoconf' again.";
6441           # These warnings appear in Automake files (depend2.am),
6442           # so there is no need to display them more than once:
6443           $scope = US_GLOBAL;
6444         }
6445       error $where, $text, uniq_scope => $scope;
6446     }
6447
6448   push (@cond_stack, make_conditional_string ($negate, $cond));
6449
6450   return new Automake::Condition (@cond_stack);
6451 }
6452
6453
6454 # $COND
6455 # cond_stack_else ($NEGATE, $COND, $WHERE)
6456 # ----------------------------------------
6457 sub cond_stack_else ($$$)
6458 {
6459   my ($negate, $cond, $where) = @_;
6460
6461   if (! @cond_stack)
6462     {
6463       error $where, "else without if";
6464       return FALSE;
6465     }
6466
6467   $cond_stack[$#cond_stack] =
6468     Automake::Condition::conditional_negate ($cond_stack[$#cond_stack]);
6469
6470   # If $COND is given, check against it.
6471   if (defined $cond)
6472     {
6473       $cond = make_conditional_string ($negate, $cond);
6474
6475       error ($where, "else reminder ($negate$cond) incompatible with "
6476              . "current conditional: $cond_stack[$#cond_stack]")
6477         if $cond_stack[$#cond_stack] ne $cond;
6478     }
6479
6480   return new Automake::Condition (@cond_stack);
6481 }
6482
6483
6484 # $COND
6485 # cond_stack_endif ($NEGATE, $COND, $WHERE)
6486 # -----------------------------------------
6487 sub cond_stack_endif ($$$)
6488 {
6489   my ($negate, $cond, $where) = @_;
6490   my $old_cond;
6491
6492   if (! @cond_stack)
6493     {
6494       error $where, "endif without if";
6495       return TRUE;
6496     }
6497
6498   # If $COND is given, check against it.
6499   if (defined $cond)
6500     {
6501       $cond = make_conditional_string ($negate, $cond);
6502
6503       error ($where, "endif reminder ($negate$cond) incompatible with "
6504              . "current conditional: $cond_stack[$#cond_stack]")
6505         if $cond_stack[$#cond_stack] ne $cond;
6506     }
6507
6508   pop @cond_stack;
6509
6510   return new Automake::Condition (@cond_stack);
6511 }
6512
6513
6514
6515
6516
6517 ## ------------------------ ##
6518 ## Handling the variables.  ##
6519 ## ------------------------ ##
6520
6521
6522 # &define_pretty_variable ($VAR, $COND, $WHERE, @VALUE)
6523 # -----------------------------------------------------
6524 # Like define_variable, but the value is a list, and the variable may
6525 # be defined conditionally.  The second argument is the condition
6526 # under which the value should be defined; this should be the empty
6527 # string to define the variable unconditionally.  The third argument
6528 # is a list holding the values to use for the variable.  The value is
6529 # pretty printed in the output file.
6530 sub define_pretty_variable ($$$@)
6531 {
6532     my ($var, $cond, $where, @value) = @_;
6533
6534     if (! vardef ($var, $cond))
6535     {
6536         Automake::Variable::define ($var, VAR_AUTOMAKE, '', $cond, "@value",
6537                                     '', $where, VAR_PRETTY);
6538         rvar ($var)->rdef ($cond)->set_seen;
6539     }
6540 }
6541
6542
6543 # define_variable ($VAR, $VALUE, $WHERE)
6544 # --------------------------------------
6545 # Define a new Automake Makefile variable VAR to VALUE, but only if
6546 # not already defined.
6547 sub define_variable ($$$)
6548 {
6549     my ($var, $value, $where) = @_;
6550     define_pretty_variable ($var, TRUE, $where, $value);
6551 }
6552
6553
6554 # define_files_variable ($VAR, \@BASENAME, $EXTENSION, $WHERE)
6555 # ------------------------------------------------------------
6556 # Define the $VAR which content is the list of file names composed of
6557 # a @BASENAME and the $EXTENSION.
6558 sub define_files_variable ($\@$$)
6559 {
6560   my ($var, $basename, $extension, $where) = @_;
6561   define_variable ($var,
6562                    join (' ', map { "$_.$extension" } @$basename),
6563                    $where);
6564 }
6565
6566
6567 # Like define_variable, but define a variable to be the configure
6568 # substitution by the same name.
6569 sub define_configure_variable ($)
6570 {
6571   my ($var) = @_;
6572
6573   my $pretty = VAR_ASIS;
6574   my $owner = VAR_CONFIGURE;
6575
6576   # Some variables we do not want to output.  For instance it
6577   # would be a bad idea to output `U = @U@` when `@U@` can be
6578   # substituted as `\`.
6579   $pretty = VAR_SILENT if exists $ignored_configure_vars{$var};
6580
6581   # ANSI2KNR is a variable that Automake wants to redefine, so
6582   # it must be owned by Automake.  (It is also used as a proof
6583   # that AM_C_PROTOTYPES has been run, that's why we do not simply
6584   # omit the AC_SUBST.)
6585   $owner = VAR_AUTOMAKE if $var eq 'ANSI2KNR';
6586
6587   Automake::Variable::define ($var, $owner, '', TRUE, subst $var,
6588                               '', $configure_vars{$var}, $pretty);
6589 }
6590
6591
6592 # define_compiler_variable ($LANG)
6593 # --------------------------------
6594 # Define a compiler variable.  We also handle defining the `LT'
6595 # version of the command when using libtool.
6596 sub define_compiler_variable ($)
6597 {
6598     my ($lang) = @_;
6599
6600     my ($var, $value) = ($lang->compiler, $lang->compile);
6601     my $libtool_tag = '';
6602     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6603       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6604     &define_variable ($var, $value, INTERNAL);
6605     if (var ('LIBTOOL'))
6606       {
6607         my $verbose = define_verbose_libtool ();
6608         &define_variable ("LT$var",
6609                           "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6610                           . "\$(LIBTOOLFLAGS) --mode=compile $value",
6611                           INTERNAL);
6612       }
6613     define_verbose_tagvar ($lang->ccer || 'GEN');
6614 }
6615
6616
6617 # define_linker_variable ($LANG)
6618 # ------------------------------
6619 # Define linker variables.
6620 sub define_linker_variable ($)
6621 {
6622     my ($lang) = @_;
6623
6624     my $libtool_tag = '';
6625     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6626       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6627     # CCLD = $(CC).
6628     &define_variable ($lang->lder, $lang->ld, INTERNAL);
6629     # CCLINK = $(CCLD) blah blah...
6630     my $link = '';
6631     if (var ('LIBTOOL'))
6632       {
6633         my $verbose = define_verbose_libtool ();
6634         $link = "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6635                 . "\$(LIBTOOLFLAGS) --mode=link ";
6636       }
6637     &define_variable ($lang->linker, $link . $lang->link, INTERNAL);
6638     &define_variable ($lang->compiler,  $lang);
6639     &define_verbose_tagvar ($lang->lder || 'GEN');
6640 }
6641
6642 sub define_per_target_linker_variable ($$)
6643 {
6644   my ($linker, $target) = @_;
6645
6646   # If the user wrote a custom link command, we don't define ours.
6647   return "${target}_LINK"
6648     if set_seen "${target}_LINK";
6649
6650   my $xlink = $linker ? $linker : 'LINK';
6651
6652   my $lang = $link_languages{$xlink};
6653   prog_error "Unknown language for linker variable `$xlink'"
6654     unless $lang;
6655
6656   my $link_command = $lang->link;
6657   if (var 'LIBTOOL')
6658     {
6659       my $libtool_tag = '';
6660       $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6661         if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6662
6663       my $verbose = define_verbose_libtool ();
6664       $link_command =
6665         "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) \$(LIBTOOLFLAGS) "
6666         . "--mode=link " . $link_command;
6667     }
6668
6669   # Rewrite each occurrence of `AM_$flag' in the link
6670   # command into `${derived}_$flag' if it exists.
6671   my $orig_command = $link_command;
6672   my @flags = (@{$lang->flags}, 'LDFLAGS');
6673   push @flags, 'LIBTOOLFLAGS' if var 'LIBTOOL';
6674   for my $flag (@flags)
6675     {
6676       my $val = "${target}_$flag";
6677       $link_command =~ s/\(AM_$flag\)/\($val\)/
6678         if set_seen ($val);
6679     }
6680
6681   # If the computed command is the same as the generic command, use
6682   # the command linker variable.
6683   return ($lang->linker, $lang->lder)
6684     if $link_command eq $orig_command;
6685
6686   &define_variable ("${target}_LINK", $link_command, INTERNAL);
6687   return ("${target}_LINK", $lang->lder);
6688 }
6689
6690 ################################################################
6691
6692 # &check_trailing_slash ($WHERE, $LINE)
6693 # -------------------------------------
6694 # Return 1 iff $LINE ends with a slash.
6695 # Might modify $LINE.
6696 sub check_trailing_slash ($\$)
6697 {
6698   my ($where, $line) = @_;
6699
6700   # Ignore `##' lines.
6701   return 0 if $$line =~ /$IGNORE_PATTERN/o;
6702
6703   # Catch and fix a common error.
6704   msg "syntax", $where, "whitespace following trailing backslash"
6705     if $$line =~ s/\\\s+\n$/\\\n/;
6706
6707   return $$line =~ /\\$/;
6708 }
6709
6710
6711 # &read_am_file ($AMFILE, $WHERE)
6712 # -------------------------------
6713 # Read Makefile.am and set up %contents.  Simultaneously copy lines
6714 # from Makefile.am into $output_trailer, or define variables as
6715 # appropriate.  NOTE we put rules in the trailer section.  We want
6716 # user rules to come after our generated stuff.
6717 sub read_am_file ($$)
6718 {
6719     my ($amfile, $where) = @_;
6720
6721     my $am_file = new Automake::XFile ("< $amfile");
6722     verb "reading $amfile";
6723
6724     # Keep track of the youngest output dependency.
6725     my $mtime = mtime $amfile;
6726     $output_deps_greatest_timestamp = $mtime
6727       if $mtime > $output_deps_greatest_timestamp;
6728
6729     my $spacing = '';
6730     my $comment = '';
6731     my $blank = 0;
6732     my $saw_bk = 0;
6733     my $var_look = VAR_ASIS;
6734
6735     use constant IN_VAR_DEF => 0;
6736     use constant IN_RULE_DEF => 1;
6737     use constant IN_COMMENT => 2;
6738     my $prev_state = IN_RULE_DEF;
6739
6740     while ($_ = $am_file->getline)
6741     {
6742         $where->set ("$amfile:$.");
6743         if (/$IGNORE_PATTERN/o)
6744         {
6745             # Merely delete comments beginning with two hashes.
6746         }
6747         elsif (/$WHITE_PATTERN/o)
6748         {
6749             error $where, "blank line following trailing backslash"
6750               if $saw_bk;
6751             # Stick a single white line before the incoming macro or rule.
6752             $spacing = "\n";
6753             $blank = 1;
6754             # Flush all comments seen so far.
6755             if ($comment ne '')
6756             {
6757                 $output_vars .= $comment;
6758                 $comment = '';
6759             }
6760         }
6761         elsif (/$COMMENT_PATTERN/o)
6762         {
6763             # Stick comments before the incoming macro or rule.  Make
6764             # sure a blank line precedes the first block of comments.
6765             $spacing = "\n" unless $blank;
6766             $blank = 1;
6767             $comment .= $spacing . $_;
6768             $spacing = '';
6769             $prev_state = IN_COMMENT;
6770         }
6771         else
6772         {
6773             last;
6774         }
6775         $saw_bk = check_trailing_slash ($where, $_);
6776     }
6777
6778     # We save the conditional stack on entry, and then check to make
6779     # sure it is the same on exit.  This lets us conditionally include
6780     # other files.
6781     my @saved_cond_stack = @cond_stack;
6782     my $cond = new Automake::Condition (@cond_stack);
6783
6784     my $last_var_name = '';
6785     my $last_var_type = '';
6786     my $last_var_value = '';
6787     my $last_where;
6788     # FIXME: shouldn't use $_ in this loop; it is too big.
6789     while ($_)
6790     {
6791         $where->set ("$amfile:$.");
6792
6793         # Make sure the line is \n-terminated.
6794         chomp;
6795         $_ .= "\n";
6796
6797         # Don't look at MAINTAINER_MODE_TRUE here.  That shouldn't be
6798         # used by users.  @MAINT@ is an anachronism now.
6799         $_ =~ s/\@MAINT\@//g
6800             unless $seen_maint_mode;
6801
6802         my $new_saw_bk = check_trailing_slash ($where, $_);
6803
6804         if (/$IGNORE_PATTERN/o)
6805         {
6806             # Merely delete comments beginning with two hashes.
6807
6808             # Keep any backslash from the previous line.
6809             $new_saw_bk = $saw_bk;
6810         }
6811         elsif (/$WHITE_PATTERN/o)
6812         {
6813             # Stick a single white line before the incoming macro or rule.
6814             $spacing = "\n";
6815             error $where, "blank line following trailing backslash"
6816               if $saw_bk;
6817         }
6818         elsif (/$COMMENT_PATTERN/o)
6819         {
6820             error $where, "comment following trailing backslash"
6821               if $saw_bk && $prev_state != IN_COMMENT;
6822
6823             # Stick comments before the incoming macro or rule.
6824             $comment .= $spacing . $_;
6825             $spacing = '';
6826             $prev_state = IN_COMMENT;
6827         }
6828         elsif ($saw_bk)
6829         {
6830             if ($prev_state == IN_RULE_DEF)
6831             {
6832               my $cond = new Automake::Condition @cond_stack;
6833               $output_trailer .= $cond->subst_string;
6834               $output_trailer .= $_;
6835             }
6836             elsif ($prev_state == IN_COMMENT)
6837             {
6838                 # If the line doesn't start with a `#', add it.
6839                 # We do this because a continued comment like
6840                 #   # A = foo \
6841                 #         bar \
6842                 #         baz
6843                 # is not portable.  BSD make doesn't honor
6844                 # escaped newlines in comments.
6845                 s/^#?/#/;
6846                 $comment .= $spacing . $_;
6847             }
6848             else # $prev_state == IN_VAR_DEF
6849             {
6850               $last_var_value .= ' '
6851                 unless $last_var_value =~ /\s$/;
6852               $last_var_value .= $_;
6853
6854               if (!/\\$/)
6855                 {
6856                   Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6857                                               $last_var_type, $cond,
6858                                               $last_var_value, $comment,
6859                                               $last_where, VAR_ASIS)
6860                     if $cond != FALSE;
6861                   $comment = $spacing = '';
6862                 }
6863             }
6864         }
6865
6866         elsif (/$IF_PATTERN/o)
6867           {
6868             $cond = cond_stack_if ($1, $2, $where);
6869           }
6870         elsif (/$ELSE_PATTERN/o)
6871           {
6872             $cond = cond_stack_else ($1, $2, $where);
6873           }
6874         elsif (/$ENDIF_PATTERN/o)
6875           {
6876             $cond = cond_stack_endif ($1, $2, $where);
6877           }
6878
6879         elsif (/$RULE_PATTERN/o)
6880         {
6881             # Found a rule.
6882             $prev_state = IN_RULE_DEF;
6883
6884             # For now we have to output all definitions of user rules
6885             # and can't diagnose duplicates (see the comment in
6886             # Automake::Rule::define). So we go on and ignore the return value.
6887             Automake::Rule::define ($1, $amfile, RULE_USER, $cond, $where);
6888
6889             check_variable_expansions ($_, $where);
6890
6891             $output_trailer .= $comment . $spacing;
6892             my $cond = new Automake::Condition @cond_stack;
6893             $output_trailer .= $cond->subst_string;
6894             $output_trailer .= $_;
6895             $comment = $spacing = '';
6896         }
6897         elsif (/$ASSIGNMENT_PATTERN/o)
6898         {
6899             # Found a macro definition.
6900             $prev_state = IN_VAR_DEF;
6901             $last_var_name = $1;
6902             $last_var_type = $2;
6903             $last_var_value = $3;
6904             $last_where = $where->clone;
6905             if ($3 ne '' && substr ($3, -1) eq "\\")
6906               {
6907                 # We preserve the `\' because otherwise the long lines
6908                 # that are generated will be truncated by broken
6909                 # `sed's.
6910                 $last_var_value = $3 . "\n";
6911               }
6912             # Normally we try to output variable definitions in the
6913             # same format they were input.  However, POSIX compliant
6914             # systems are not required to support lines longer than
6915             # 2048 bytes (most notably, some sed implementation are
6916             # limited to 4000 bytes, and sed is used by config.status
6917             # to rewrite Makefile.in into Makefile).  Moreover nobody
6918             # would really write such long lines by hand since it is
6919             # hardly maintainable.  So if a line is longer that 1000
6920             # bytes (an arbitrary limit), assume it has been
6921             # automatically generated by some tools, and flatten the
6922             # variable definition.  Otherwise, keep the variable as it
6923             # as been input.
6924             $var_look = VAR_PRETTY if length ($last_var_value) >= 1000;
6925
6926             if (!/\\$/)
6927               {
6928                 Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6929                                             $last_var_type, $cond,
6930                                             $last_var_value, $comment,
6931                                             $last_where, $var_look)
6932                   if $cond != FALSE;
6933                 $comment = $spacing = '';
6934                 $var_look = VAR_ASIS;
6935               }
6936         }
6937         elsif (/$INCLUDE_PATTERN/o)
6938         {
6939             my $path = $1;
6940
6941             if ($path =~ s/^\$\(top_srcdir\)\///)
6942               {
6943                 push (@include_stack, "\$\(top_srcdir\)/$path");
6944                 # Distribute any included file.
6945
6946                 # Always use the $(top_srcdir) prefix in DIST_COMMON,
6947                 # otherwise OSF make will implicitly copy the included
6948                 # file in the build tree during `make distdir' to satisfy
6949                 # the dependency.
6950                 # (subdircond2.test and subdircond3.test will fail.)
6951                 push_dist_common ("\$\(top_srcdir\)/$path");
6952               }
6953             else
6954               {
6955                 $path =~ s/\$\(srcdir\)\///;
6956                 push (@include_stack, "\$\(srcdir\)/$path");
6957                 # Always use the $(srcdir) prefix in DIST_COMMON,
6958                 # otherwise OSF make will implicitly copy the included
6959                 # file in the build tree during `make distdir' to satisfy
6960                 # the dependency.
6961                 # (subdircond2.test and subdircond3.test will fail.)
6962                 push_dist_common ("\$\(srcdir\)/$path");
6963                 $path = $relative_dir . "/" . $path if $relative_dir ne '.';
6964               }
6965             $where->push_context ("`$path' included from here");
6966             &read_am_file ($path, $where);
6967             $where->pop_context;
6968         }
6969         else
6970         {
6971             # This isn't an error; it is probably a continued rule.
6972             # In fact, this is what we assume.
6973             $prev_state = IN_RULE_DEF;
6974             check_variable_expansions ($_, $where);
6975             $output_trailer .= $comment . $spacing;
6976             my $cond = new Automake::Condition @cond_stack;
6977             $output_trailer .= $cond->subst_string;
6978             $output_trailer .= $_;
6979             $comment = $spacing = '';
6980             error $where, "`#' comment at start of rule is unportable"
6981               if $_ =~ /^\t\s*\#/;
6982         }
6983
6984         $saw_bk = $new_saw_bk;
6985         $_ = $am_file->getline;
6986     }
6987
6988     $output_trailer .= $comment;
6989
6990     error ($where, "trailing backslash on last line")
6991       if $saw_bk;
6992
6993     error ($where, (@cond_stack ? "unterminated conditionals: @cond_stack"
6994                     : "too many conditionals closed in include file"))
6995       if "@saved_cond_stack" ne "@cond_stack";
6996 }
6997
6998
6999 # define_standard_variables ()
7000 # ----------------------------
7001 # A helper for read_main_am_file which initializes configure variables
7002 # and variables from header-vars.am.
7003 sub define_standard_variables
7004 {
7005   my $saved_output_vars = $output_vars;
7006   my ($comments, undef, $rules) =
7007     file_contents_internal (1, "$libdir/am/header-vars.am",
7008                             new Automake::Location);
7009
7010   foreach my $var (sort keys %configure_vars)
7011     {
7012       &define_configure_variable ($var);
7013     }
7014
7015   $output_vars .= $comments . $rules;
7016 }
7017
7018 # Read main am file.
7019 sub read_main_am_file
7020 {
7021     my ($amfile) = @_;
7022
7023     # This supports the strange variable tricks we are about to play.
7024     prog_error ("variable defined before read_main_am_file\n" . variables_dump ())
7025       if (scalar (variables) > 0);
7026
7027     # Generate copyright header for generated Makefile.in.
7028     # We do discard the output of predefined variables, handled below.
7029     $output_vars = ("# $in_file_name generated by automake "
7030                    . $VERSION . " from $am_file_name.\n");
7031     $output_vars .= '# ' . subst ('configure_input') . "\n";
7032     $output_vars .= $gen_copyright;
7033
7034     # We want to predefine as many variables as possible.  This lets
7035     # the user set them with `+=' in Makefile.am.
7036     &define_standard_variables;
7037
7038     # Read user file, which might override some of our values.
7039     &read_am_file ($amfile, new Automake::Location);
7040 }
7041
7042
7043
7044 ################################################################
7045
7046 # $FLATTENED
7047 # &flatten ($STRING)
7048 # ------------------
7049 # Flatten the $STRING and return the result.
7050 sub flatten
7051 {
7052   $_ = shift;
7053
7054   s/\\\n//somg;
7055   s/\s+/ /g;
7056   s/^ //;
7057   s/ $//;
7058
7059   return $_;
7060 }
7061
7062
7063 # transform_token ($TOKEN, \%PAIRS, $KEY)
7064 # =======================================
7065 # Return the value associated to $KEY in %PAIRS, as used on $TOKEN
7066 # (which should be ?KEY? or any of the special %% requests)..
7067 sub transform_token ($$$)
7068 {
7069   my ($token, $transform, $key) = @_;
7070   my $res = $transform->{$key};
7071   prog_error "Unknown key `$key' in `$token'" unless defined $res;
7072   return $res;
7073 }
7074
7075
7076 # transform ($TOKEN, \%PAIRS)
7077 # ===========================
7078 # If ($TOKEN, $VAL) is in %PAIRS:
7079 #   - replaces %KEY% with $VAL,
7080 #   - enables/disables ?KEY? and ?!KEY?,
7081 #   - replaces %?KEY% with TRUE or FALSE.
7082 #   - replaces %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE% with
7083 #     IFTRUE / IFFALSE, as appropriate.
7084 sub transform ($$)
7085 {
7086   my ($token, $transform) = @_;
7087
7088   # %KEY%.
7089   # Must be before the following pattern to exclude the case
7090   # when there is neither IFTRUE nor IFFALSE.
7091   if ($token =~ /^%([\w\-]+)%$/)
7092     {
7093       return transform_token ($token, $transform, $1);
7094     }
7095   # %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE%.
7096   elsif ($token =~ /^%([\w\-]+)(?:\?([^?:%]+))?(?::([^?:%]+))?%$/)
7097     {
7098       return transform_token ($token, $transform, $1) ? ($2 || '') : ($3 || '');
7099     }
7100   # %?KEY%.
7101   elsif ($token =~ /^%\?([\w\-]+)%$/)
7102     {
7103       return transform_token ($token, $transform, $1) ? 'TRUE' : 'FALSE';
7104     }
7105   # ?KEY? and ?!KEY?.
7106   elsif ($token =~ /^ \? (!?) ([\w\-]+) \? $/x)
7107     {
7108       my $neg = ($1 eq '!') ? 1 : 0;
7109       my $val = transform_token ($token, $transform, $2);
7110       return (!!$val == $neg) ? '##%' : '';
7111     }
7112   else
7113     {
7114       prog_error "Unknown request format: $token";
7115     }
7116 }
7117
7118
7119 # @PARAGRAPHS
7120 # &make_paragraphs ($MAKEFILE, [%TRANSFORM])
7121 # ------------------------------------------
7122 # Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
7123 # paragraphs.
7124 sub make_paragraphs ($%)
7125 {
7126   my ($file, %transform) = @_;
7127
7128   # Complete %transform with global options.
7129   # Note that %transform goes last, so it overrides global options.
7130   %transform = ('CYGNUS'      => !! option 'cygnus',
7131                  'MAINTAINER-MODE'
7132                  => $seen_maint_mode ? subst ('MAINTAINER_MODE_TRUE') : '',
7133
7134                  'XZ'          => !! option 'dist-xz',
7135                  'LZMA'        => !! option 'dist-lzma',
7136                  'LZIP'        => !! option 'dist-lzip',
7137                  'BZIP2'       => !! option 'dist-bzip2',
7138                  'COMPRESS'    => !! option 'dist-tarZ',
7139                  'GZIP'        =>  ! option 'no-dist-gzip',
7140                  'SHAR'        => !! option 'dist-shar',
7141                  'ZIP'         => !! option 'dist-zip',
7142
7143                  'INSTALL-INFO' =>  ! option 'no-installinfo',
7144                  'INSTALL-MAN'  =>  ! option 'no-installman',
7145                  'HAVE-MANS'    => !! var ('MANS'),
7146                  'CK-NEWS'      => !! option 'check-news',
7147
7148                  'SUBDIRS'      => !! var ('SUBDIRS'),
7149                  'TOPDIR_P'     => $relative_dir eq '.',
7150
7151                  'BUILD'    => ($seen_canonical >= AC_CANONICAL_BUILD),
7152                  'HOST'     => ($seen_canonical >= AC_CANONICAL_HOST),
7153                  'TARGET'   => ($seen_canonical >= AC_CANONICAL_TARGET),
7154
7155                  'LIBTOOL'      => !! var ('LIBTOOL'),
7156                  'NONLIBTOOL'   => 1,
7157                  'FIRST'        => ! $transformed_files{$file},
7158                 %transform);
7159
7160   $transformed_files{$file} = 1;
7161   $_ = $am_file_cache{$file};
7162
7163   if (! defined $_)
7164     {
7165       verb "reading $file";
7166       # Swallow the whole file.
7167       my $fc_file = new Automake::XFile "< $file";
7168       my $saved_dollar_slash = $/;
7169       undef $/;
7170       $_ = $fc_file->getline;
7171       $/ = $saved_dollar_slash;
7172       $fc_file->close;
7173
7174       # Remove ##-comments.
7175       # Besides we don't need more than two consecutive new-lines.
7176       s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
7177
7178       $am_file_cache{$file} = $_;
7179     }
7180
7181   # Substitute Automake template tokens.
7182   s/(?: % \?? [\w\-]+ %
7183       | % [\w\-]+ (?:\?[^?:%]+)? (?::[^?:%]+)? %
7184       | \? !? [\w\-]+ \?
7185     )/transform($&, \%transform)/gex;
7186   # transform() may have added some ##%-comments to strip.
7187   # (we use `##%' instead of `##' so we can distinguish ##%##%##% from
7188   # ####### and do not remove the latter.)
7189   s/^[ \t]*(?:##%)+.*\n//gm;
7190
7191   # Split at unescaped new lines.
7192   my @lines = split (/(?<!\\)\n/, $_);
7193   my @res;
7194
7195   while (defined ($_ = shift @lines))
7196     {
7197       my $paragraph = $_;
7198       # If we are a rule, eat as long as we start with a tab.
7199       if (/$RULE_PATTERN/smo)
7200         {
7201           while (defined ($_ = shift @lines) && $_ =~ /^\t/)
7202             {
7203               $paragraph .= "\n$_";
7204             }
7205           unshift (@lines, $_);
7206         }
7207
7208       # If we are a comments, eat as much comments as you can.
7209       elsif (/$COMMENT_PATTERN/smo)
7210         {
7211           while (defined ($_ = shift @lines)
7212                  && $_ =~ /$COMMENT_PATTERN/smo)
7213             {
7214               $paragraph .= "\n$_";
7215             }
7216           unshift (@lines, $_);
7217         }
7218
7219       push @res, $paragraph;
7220     }
7221
7222   return @res;
7223 }
7224
7225
7226
7227 # ($COMMENT, $VARIABLES, $RULES)
7228 # &file_contents_internal ($IS_AM, $FILE, $WHERE, [%TRANSFORM])
7229 # -------------------------------------------------------------
7230 # Return contents of a file from $libdir/am, automatically skipping
7231 # macros or rules which are already known. $IS_AM iff the caller is
7232 # reading an Automake file (as opposed to the user's Makefile.am).
7233 sub file_contents_internal ($$$%)
7234 {
7235     my ($is_am, $file, $where, %transform) = @_;
7236
7237     $where->set ($file);
7238
7239     my $result_vars = '';
7240     my $result_rules = '';
7241     my $comment = '';
7242     my $spacing = '';
7243
7244     # The following flags are used to track rules spanning across
7245     # multiple paragraphs.
7246     my $is_rule = 0;            # 1 if we are processing a rule.
7247     my $discard_rule = 0;       # 1 if the current rule should not be output.
7248
7249     # We save the conditional stack on entry, and then check to make
7250     # sure it is the same on exit.  This lets us conditionally include
7251     # other files.
7252     my @saved_cond_stack = @cond_stack;
7253     my $cond = new Automake::Condition (@cond_stack);
7254
7255     foreach (make_paragraphs ($file, %transform))
7256     {
7257         # FIXME: no line number available.
7258         $where->set ($file);
7259
7260         # Sanity checks.
7261         error $where, "blank line following trailing backslash:\n$_"
7262           if /\\$/;
7263         error $where, "comment following trailing backslash:\n$_"
7264           if /\\#/;
7265
7266         if (/^$/)
7267         {
7268             $is_rule = 0;
7269             # Stick empty line before the incoming macro or rule.
7270             $spacing = "\n";
7271         }
7272         elsif (/$COMMENT_PATTERN/mso)
7273         {
7274             $is_rule = 0;
7275             # Stick comments before the incoming macro or rule.
7276             $comment = "$_\n";
7277         }
7278
7279         # Handle inclusion of other files.
7280         elsif (/$INCLUDE_PATTERN/o)
7281         {
7282             if ($cond != FALSE)
7283               {
7284                 my $file = ($is_am ? "$libdir/am/" : '') . $1;
7285                 $where->push_context ("`$file' included from here");
7286                 # N-ary `.=' fails.
7287                 my ($com, $vars, $rules)
7288                   = file_contents_internal ($is_am, $file, $where, %transform);
7289                 $where->pop_context;
7290                 $comment .= $com;
7291                 $result_vars .= $vars;
7292                 $result_rules .= $rules;
7293               }
7294         }
7295
7296         # Handling the conditionals.
7297         elsif (/$IF_PATTERN/o)
7298           {
7299             $cond = cond_stack_if ($1, $2, $file);
7300           }
7301         elsif (/$ELSE_PATTERN/o)
7302           {
7303             $cond = cond_stack_else ($1, $2, $file);
7304           }
7305         elsif (/$ENDIF_PATTERN/o)
7306           {
7307             $cond = cond_stack_endif ($1, $2, $file);
7308           }
7309
7310         # Handling rules.
7311         elsif (/$RULE_PATTERN/mso)
7312         {
7313           $is_rule = 1;
7314           $discard_rule = 0;
7315           # Separate relationship from optional actions: the first
7316           # `new-line tab" not preceded by backslash (continuation
7317           # line).
7318           my $paragraph = $_;
7319           /^(.*?)(?:(?<!\\)\n(\t.*))?$/s;
7320           my ($relationship, $actions) = ($1, $2 || '');
7321
7322           # Separate targets from dependencies: the first colon.
7323           $relationship =~ /^([^:]+\S+) *: *(.*)$/som;
7324           my ($targets, $dependencies) = ($1, $2);
7325           # Remove the escaped new lines.
7326           # I don't know why, but I have to use a tmp $flat_deps.
7327           my $flat_deps = &flatten ($dependencies);
7328           my @deps = split (' ', $flat_deps);
7329
7330           foreach (split (' ', $targets))
7331             {
7332               # FIXME: 1. We are not robust to people defining several targets
7333               # at once, only some of them being in %dependencies.  The
7334               # actions from the targets in %dependencies are usually generated
7335               # from the content of %actions, but if some targets in $targets
7336               # are not in %dependencies the ELSE branch will output
7337               # a rule for all $targets (i.e. the targets which are both
7338               # in %dependencies and $targets will have two rules).
7339
7340               # FIXME: 2. The logic here is not able to output a
7341               # multi-paragraph rule several time (e.g. for each condition
7342               # it is defined for) because it only knows the first paragraph.
7343
7344               # FIXME: 3. We are not robust to people defining a subset
7345               # of a previously defined "multiple-target" rule.  E.g.
7346               # `foo:' after `foo bar:'.
7347
7348               # Output only if not in FALSE.
7349               if (defined $dependencies{$_} && $cond != FALSE)
7350                 {
7351                   &depend ($_, @deps);
7352                   register_action ($_, $actions);
7353                 }
7354               else
7355                 {
7356                   # Free-lance dependency.  Output the rule for all the
7357                   # targets instead of one by one.
7358                   my @undefined_conds =
7359                     Automake::Rule::define ($targets, $file,
7360                                             $is_am ? RULE_AUTOMAKE : RULE_USER,
7361                                             $cond, $where);
7362                   for my $undefined_cond (@undefined_conds)
7363                     {
7364                       my $condparagraph = $paragraph;
7365                       $condparagraph =~ s/^/$undefined_cond->subst_string/gme;
7366                       $result_rules .= "$spacing$comment$condparagraph\n";
7367                     }
7368                   if (scalar @undefined_conds == 0)
7369                     {
7370                       # Remember to discard next paragraphs
7371                       # if they belong to this rule.
7372                       # (but see also FIXME: #2 above.)
7373                       $discard_rule = 1;
7374                     }
7375                   $comment = $spacing = '';
7376                   last;
7377                 }
7378             }
7379         }
7380
7381         elsif (/$ASSIGNMENT_PATTERN/mso)
7382         {
7383             my ($var, $type, $val) = ($1, $2, $3);
7384             error $where, "variable `$var' with trailing backslash"
7385               if /\\$/;
7386
7387             $is_rule = 0;
7388
7389             Automake::Variable::define ($var,
7390                                         $is_am ? VAR_AUTOMAKE : VAR_MAKEFILE,
7391                                         $type, $cond, $val, $comment, $where,
7392                                         VAR_ASIS)
7393               if $cond != FALSE;
7394
7395             $comment = $spacing = '';
7396         }
7397         else
7398         {
7399             # This isn't an error; it is probably some tokens which
7400             # configure is supposed to replace, such as `@SET-MAKE@',
7401             # or some part of a rule cut by an if/endif.
7402             if (! $cond->false && ! ($is_rule && $discard_rule))
7403               {
7404                 s/^/$cond->subst_string/gme;
7405                 $result_rules .= "$spacing$comment$_\n";
7406               }
7407             $comment = $spacing = '';
7408         }
7409     }
7410
7411     error ($where, @cond_stack ?
7412            "unterminated conditionals: @cond_stack" :
7413            "too many conditionals closed in include file")
7414       if "@saved_cond_stack" ne "@cond_stack";
7415
7416     return ($comment, $result_vars, $result_rules);
7417 }
7418
7419
7420 # $CONTENTS
7421 # &file_contents ($BASENAME, $WHERE, [%TRANSFORM])
7422 # ------------------------------------------------
7423 # Return contents of a file from $libdir/am, automatically skipping
7424 # macros or rules which are already known.
7425 sub file_contents ($$%)
7426 {
7427     my ($basename, $where, %transform) = @_;
7428     my ($comments, $variables, $rules) =
7429       file_contents_internal (1, "$libdir/am/$basename.am", $where,
7430                               %transform);
7431     return "$comments$variables$rules";
7432 }
7433
7434
7435 # @PREFIX
7436 # &am_primary_prefixes ($PRIMARY, $CAN_DIST, @PREFIXES)
7437 # -----------------------------------------------------
7438 # Find all variable prefixes that are used for install directories.  A
7439 # prefix `zar' qualifies iff:
7440 #
7441 # * `zardir' is a variable.
7442 # * `zar_PRIMARY' is a variable.
7443 #
7444 # As a side effect, it looks for misspellings.  It is an error to have
7445 # a variable ending in a "reserved" suffix whose prefix is unknown, e.g.
7446 # "bni_PROGRAMS".  However, unusual prefixes are allowed if a variable
7447 # of the same name (with "dir" appended) exists.  For instance, if the
7448 # variable "zardir" is defined, then "zar_PROGRAMS" becomes valid.
7449 # This is to provide a little extra flexibility in those cases which
7450 # need it.
7451 sub am_primary_prefixes ($$@)
7452 {
7453   my ($primary, $can_dist, @prefixes) = @_;
7454
7455   local $_;
7456   my %valid = map { $_ => 0 } @prefixes;
7457   $valid{'EXTRA'} = 0;
7458   foreach my $var (variables $primary)
7459     {
7460       # Automake is allowed to define variables that look like primaries
7461       # but which aren't.  E.g. INSTALL_sh_DATA.
7462       # Autoconf can also define variables like INSTALL_DATA, so
7463       # ignore all configure variables (at least those which are not
7464       # redefined in Makefile.am).
7465       # FIXME: We should make sure that these variables are not
7466       # conditionally defined (or else adjust the condition below).
7467       my $def = $var->def (TRUE);
7468       next if $def && $def->owner != VAR_MAKEFILE;
7469
7470       my $varname = $var->name;
7471
7472       if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_[[:alnum:]]+$/)
7473         {
7474           my ($base, $dist, $X) = ($1 || '', $2 || '', $3 || '');
7475           if ($dist ne '' && ! $can_dist)
7476             {
7477               err_var ($var,
7478                        "invalid variable `$varname': `dist' is forbidden");
7479             }
7480           # Standard directories must be explicitly allowed.
7481           elsif (! defined $valid{$X} && exists $standard_prefix{$X})
7482             {
7483               err_var ($var,
7484                        "`${X}dir' is not a legitimate directory " .
7485                        "for `$primary'");
7486             }
7487           # A not explicitly valid directory is allowed if Xdir is defined.
7488           elsif (! defined $valid{$X} &&
7489                  $var->requires_variables ("`$varname' is used", "${X}dir"))
7490             {
7491               # Nothing to do.  Any error message has been output
7492               # by $var->requires_variables.
7493             }
7494           else
7495             {
7496               # Ensure all extended prefixes are actually used.
7497               $valid{"$base$dist$X"} = 1;
7498             }
7499         }
7500       else
7501         {
7502           prog_error "unexpected variable name: $varname";
7503         }
7504     }
7505
7506   # Return only those which are actually defined.
7507   return sort grep { var ($_ . '_' . $primary) } keys %valid;
7508 }
7509
7510
7511 # Handle `where_HOW' variable magic.  Does all lookups, generates
7512 # install code, and possibly generates code to define the primary
7513 # variable.  The first argument is the name of the .am file to munge,
7514 # the second argument is the primary variable (e.g. HEADERS), and all
7515 # subsequent arguments are possible installation locations.
7516 #
7517 # Returns list of [$location, $value] pairs, where
7518 # $value's are the values in all where_HOW variable, and $location
7519 # there associated location (the place here their parent variables were
7520 # defined).
7521 #
7522 # FIXME: this should be rewritten to be cleaner.  It should be broken
7523 # up into multiple functions.
7524 #
7525 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7526 sub am_install_var
7527 {
7528   my (@args) = @_;
7529
7530   my $do_require = 1;
7531   my $can_dist = 0;
7532   my $default_dist = 0;
7533   while (@args)
7534     {
7535       if ($args[0] eq '-noextra')
7536         {
7537           $do_require = 0;
7538         }
7539       elsif ($args[0] eq '-candist')
7540         {
7541           $can_dist = 1;
7542         }
7543       elsif ($args[0] eq '-defaultdist')
7544         {
7545           $default_dist = 1;
7546           $can_dist = 1;
7547         }
7548       elsif ($args[0] !~ /^-/)
7549         {
7550           last;
7551         }
7552       shift (@args);
7553     }
7554
7555   my ($file, $primary, @prefix) = @args;
7556
7557   # Now that configure substitutions are allowed in where_HOW
7558   # variables, it is an error to actually define the primary.  We
7559   # allow `JAVA', as it is customarily used to mean the Java
7560   # interpreter.  This is but one of several Java hacks.  Similarly,
7561   # `PYTHON' is customarily used to mean the Python interpreter.
7562   reject_var $primary, "`$primary' is an anachronism"
7563     unless $primary eq 'JAVA' || $primary eq 'PYTHON';
7564
7565   # Get the prefixes which are valid and actually used.
7566   @prefix = am_primary_prefixes ($primary, $can_dist, @prefix);
7567
7568   # If a primary includes a configure substitution, then the EXTRA_
7569   # form is required.  Otherwise we can't properly do our job.
7570   my $require_extra;
7571
7572   my @used = ();
7573   my @result = ();
7574
7575   foreach my $X (@prefix)
7576     {
7577       my $nodir_name = $X;
7578       my $one_name = $X . '_' . $primary;
7579       my $one_var = var $one_name;
7580
7581       my $strip_subdir = 1;
7582       # If subdir prefix should be preserved, do so.
7583       if ($nodir_name =~ /^nobase_/)
7584         {
7585           $strip_subdir = 0;
7586           $nodir_name =~ s/^nobase_//;
7587         }
7588
7589       # If files should be distributed, do so.
7590       my $dist_p = 0;
7591       if ($can_dist)
7592         {
7593           $dist_p = (($default_dist && $nodir_name !~ /^nodist_/)
7594                      || (! $default_dist && $nodir_name =~ /^dist_/));
7595           $nodir_name =~ s/^(dist|nodist)_//;
7596         }
7597
7598
7599       # Use the location of the currently processed variable.
7600       # We are not processing a particular condition, so pick the first
7601       # available.
7602       my $tmpcond = $one_var->conditions->one_cond;
7603       my $where = $one_var->rdef ($tmpcond)->location->clone;
7604
7605       # Append actual contents of where_PRIMARY variable to
7606       # @result, skipping @substitutions@.
7607       foreach my $locvals ($one_var->value_as_list_recursive (location => 1))
7608         {
7609           my ($loc, $value) = @$locvals;
7610           # Skip configure substitutions.
7611           if ($value =~ /^\@.*\@$/)
7612             {
7613               if ($nodir_name eq 'EXTRA')
7614                 {
7615                   error ($where,
7616                          "`$one_name' contains configure substitution, "
7617                          . "but shouldn't");
7618                 }
7619               # Check here to make sure variables defined in
7620               # configure.ac do not imply that EXTRA_PRIMARY
7621               # must be defined.
7622               elsif (! defined $configure_vars{$one_name})
7623                 {
7624                   $require_extra = $one_name
7625                     if $do_require;
7626                 }
7627             }
7628           else
7629             {
7630               # Strip any $(EXEEXT) suffix the user might have added, or this
7631               # will confuse &handle_source_transform and &check_canonical_spelling.
7632               # We'll add $(EXEEXT) back later anyway.
7633               # Do it here rather than in handle_programs so the uniquifying at the
7634               # end of this function works.
7635               ${$locvals}[1] =~ s/\$\(EXEEXT\)$//
7636                 if $primary eq 'PROGRAMS';
7637
7638               push (@result, $locvals);
7639             }
7640         }
7641       # A blatant hack: we rewrite each _PROGRAMS primary to include
7642       # EXEEXT.
7643       append_exeext { 1 } $one_name
7644         if $primary eq 'PROGRAMS';
7645       # "EXTRA" shouldn't be used when generating clean targets,
7646       # all, or install targets.  We used to warn if EXTRA_FOO was
7647       # defined uselessly, but this was annoying.
7648       next
7649         if $nodir_name eq 'EXTRA';
7650
7651       if ($nodir_name eq 'check')
7652         {
7653           push (@check, '$(' . $one_name . ')');
7654         }
7655       else
7656         {
7657           push (@used, '$(' . $one_name . ')');
7658         }
7659
7660       # Is this to be installed?
7661       my $install_p = $nodir_name ne 'noinst' && $nodir_name ne 'check';
7662
7663       # If so, with install-exec? (or install-data?).
7664       my $exec_p = ($nodir_name =~ /$EXEC_DIR_PATTERN/o);
7665
7666       my $check_options_p = $install_p && !! option 'std-options';
7667
7668       # Use the location of the currently processed variable as context.
7669       $where->push_context ("while processing `$one_name'");
7670
7671       # The variable containing all files to distribute.
7672       my $distvar = "\$($one_name)";
7673       $distvar = shadow_unconditionally ($one_name, $where)
7674         if ($dist_p && $one_var->has_conditional_contents);
7675
7676       # Singular form of $PRIMARY.
7677       (my $one_primary = $primary) =~ s/S$//;
7678       $output_rules .= &file_contents ($file, $where,
7679                                        PRIMARY     => $primary,
7680                                        ONE_PRIMARY => $one_primary,
7681                                        DIR         => $X,
7682                                        NDIR        => $nodir_name,
7683                                        BASE        => $strip_subdir,
7684
7685                                        EXEC      => $exec_p,
7686                                        INSTALL   => $install_p,
7687                                        DIST      => $dist_p,
7688                                        DISTVAR   => $distvar,
7689                                        'CK-OPTS' => $check_options_p);
7690     }
7691
7692   # The JAVA variable is used as the name of the Java interpreter.
7693   # The PYTHON variable is used as the name of the Python interpreter.
7694   if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7695     {
7696       # Define it.
7697       define_pretty_variable ($primary, TRUE, INTERNAL, @used);
7698       $output_vars .= "\n";
7699     }
7700
7701   err_var ($require_extra,
7702            "`$require_extra' contains configure substitution,\n"
7703            . "but `EXTRA_$primary' not defined")
7704     if ($require_extra && ! var ('EXTRA_' . $primary));
7705
7706   # Push here because PRIMARY might be configure time determined.
7707   push (@all, '$(' . $primary . ')')
7708     if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7709
7710   # Make the result unique.  This lets the user use conditionals in
7711   # a natural way, but still lets us program lazily -- we don't have
7712   # to worry about handling a particular object more than once.
7713   # We will keep only one location per object.
7714   my %result = ();
7715   for my $pair (@result)
7716     {
7717       my ($loc, $val) = @$pair;
7718       $result{$val} = $loc;
7719     }
7720   my @l = sort keys %result;
7721   return map { [$result{$_}->clone, $_] } @l;
7722 }
7723
7724
7725 ################################################################
7726
7727 # Each key in this hash is the name of a directory holding a
7728 # Makefile.in.  These variables are local to `is_make_dir'.
7729 my %make_dirs = ();
7730 my $make_dirs_set = 0;
7731
7732 sub is_make_dir
7733 {
7734     my ($dir) = @_;
7735     if (! $make_dirs_set)
7736     {
7737         foreach my $iter (@configure_input_files)
7738         {
7739             $make_dirs{dirname ($iter)} = 1;
7740         }
7741         # We also want to notice Makefile.in's.
7742         foreach my $iter (@other_input_files)
7743         {
7744             if ($iter =~ /Makefile\.in$/)
7745             {
7746                 $make_dirs{dirname ($iter)} = 1;
7747             }
7748         }
7749         $make_dirs_set = 1;
7750     }
7751     return defined $make_dirs{$dir};
7752 }
7753
7754 ################################################################
7755
7756 # Find the aux dir.  This should match the algorithm used by
7757 # ./configure. (See the Autoconf documentation for for
7758 # AC_CONFIG_AUX_DIR.)
7759 sub locate_aux_dir ()
7760 {
7761   if (! $config_aux_dir_set_in_configure_ac)
7762     {
7763       # The default auxiliary directory is the first
7764       # of ., .., or ../.. that contains install-sh.
7765       # Assume . if install-sh doesn't exist yet.
7766       for my $dir (qw (. .. ../..))
7767         {
7768           if (-f "$dir/install-sh")
7769             {
7770               $config_aux_dir = $dir;
7771               last;
7772             }
7773         }
7774       $config_aux_dir = '.' unless $config_aux_dir;
7775     }
7776   # Avoid unsightly '/.'s.
7777   $am_config_aux_dir =
7778     '$(top_srcdir)' . ($config_aux_dir eq '.' ? "" : "/$config_aux_dir");
7779   $am_config_aux_dir =~ s,/*$,,;
7780 }
7781
7782
7783 # &maybe_push_required_file ($DIR, $FILE, $FULLFILE)
7784 # --------------------------------------------------
7785 # See if we want to push this file onto dist_common.  This function
7786 # encodes the rules for deciding when to do so.
7787 sub maybe_push_required_file
7788 {
7789   my ($dir, $file, $fullfile) = @_;
7790
7791   if ($dir eq $relative_dir)
7792     {
7793       push_dist_common ($file);
7794       return 1;
7795     }
7796   elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7797     {
7798       # If we are doing the topmost directory, and the file is in a
7799       # subdir which does not have a Makefile, then we distribute it
7800       # here.
7801
7802       # If a required file is above the source tree, it is important
7803       # to prefix it with `$(srcdir)' so that no VPATH search is
7804       # performed.  Otherwise problems occur with Make implementations
7805       # that rewrite and simplify rules whose dependencies are found in a
7806       # VPATH location.  Here is an example with OSF1/Tru64 Make.
7807       #
7808       #   % cat Makefile
7809       #   VPATH = sub
7810       #   distdir: ../a
7811       #           echo ../a
7812       #   % ls
7813       #   Makefile a
7814       #   % make
7815       #   echo a
7816       #   a
7817       #
7818       # Dependency `../a' was found in `sub/../a', but this make
7819       # implementation simplified it as `a'.  (Note that the sub/
7820       # directory does not even exist.)
7821       #
7822       # This kind of VPATH rewriting seems hard to cancel.  The
7823       # distdir.am hack against VPATH rewriting works only when no
7824       # simplification is done, i.e., for dependencies which are in
7825       # subdirectories, not in enclosing directories.  Hence, in
7826       # the latter case we use a full path to make sure no VPATH
7827       # search occurs.
7828       $fullfile = '$(srcdir)/' . $fullfile
7829         if $dir =~ m,^\.\.(?:$|/),;
7830
7831       push_dist_common ($fullfile);
7832       return 1;
7833     }
7834   return 0;
7835 }
7836
7837
7838 # If a file name appears as a key in this hash, then it has already
7839 # been checked for.  This allows us not to report the same error more
7840 # than once.
7841 my %required_file_not_found = ();
7842
7843 # &require_file_internal ($WHERE, $MYSTRICT, $DIRECTORY, @FILES)
7844 # --------------------------------------------------------------
7845 # Verify that the file must exist in $DIRECTORY, or install it.
7846 # $MYSTRICT is the strictness level at which this file becomes required.
7847 sub require_file_internal ($$$@)
7848 {
7849   my ($where, $mystrict, $dir, @files) = @_;
7850
7851   foreach my $file (@files)
7852     {
7853       my $fullfile = "$dir/$file";
7854       my $found_it = 0;
7855       my $dangling_sym = 0;
7856
7857       if (-l $fullfile && ! -f $fullfile)
7858         {
7859           $dangling_sym = 1;
7860         }
7861       elsif (dir_has_case_matching_file ($dir, $file))
7862         {
7863           $found_it = 1;
7864           maybe_push_required_file ($dir, $file, $fullfile);
7865         }
7866
7867       # `--force-missing' only has an effect if `--add-missing' is
7868       # specified.
7869       if ($found_it && (! $add_missing || ! $force_missing))
7870         {
7871           next;
7872         }
7873       else
7874         {
7875           # If we've already looked for it, we're done.  You might
7876           # wonder why we don't do this before searching for the
7877           # file.  If we do that, then something like
7878           # AC_OUTPUT(subdir/foo foo) will fail to put foo.in into
7879           # DIST_COMMON.
7880           if (! $found_it)
7881             {
7882               next if defined $required_file_not_found{$fullfile};
7883               $required_file_not_found{$fullfile} = 1;
7884             }
7885
7886           if ($strictness >= $mystrict)
7887             {
7888               if ($dangling_sym && $add_missing)
7889                 {
7890                   unlink ($fullfile);
7891                 }
7892
7893               my $trailer = '';
7894               my $trailer2 = '';
7895               my $suppress = 0;
7896
7897               # Only install missing files according to our desired
7898               # strictness level.
7899               my $message = "required file `$fullfile' not found";
7900               if ($add_missing)
7901                 {
7902                   if (-f "$libdir/$file")
7903                     {
7904                       $suppress = 1;
7905
7906                       # Install the missing file.  Symlink if we
7907                       # can, copy if we must.  Note: delete the file
7908                       # first, in case it is a dangling symlink.
7909                       $message = "installing `$fullfile'";
7910
7911                       # The license file should not be volatile.
7912                       if ($file eq "COPYING")
7913                         {
7914                           $message .= " using GNU General Public License v3 file";
7915                           $trailer2 = "\n    Consider adding the COPYING file"
7916                                     . " to the version control system"
7917                                     . "\n    for your code, to avoid questions"
7918                                     . " about which license your project uses.";
7919                         }
7920
7921                       # Windows Perl will hang if we try to delete a
7922                       # file that doesn't exist.
7923                       unlink ($fullfile) if -f $fullfile;
7924                       if ($symlink_exists && ! $copy_missing)
7925                         {
7926                           if (! symlink ("$libdir/$file", $fullfile)
7927                               || ! -e $fullfile)
7928                             {
7929                               $suppress = 0;
7930                               $trailer = "; error while making link: $!";
7931                             }
7932                         }
7933                       elsif (system ('cp', "$libdir/$file", $fullfile))
7934                         {
7935                           $suppress = 0;
7936                           $trailer = "\n    error while copying";
7937                         }
7938                       set_dir_cache_file ($dir, $file);
7939                     }
7940
7941                   if (! maybe_push_required_file (dirname ($fullfile),
7942                                                   $file, $fullfile))
7943                     {
7944                       if (! $found_it && ! $automake_will_process_aux_dir)
7945                         {
7946                           # We have added the file but could not push it
7947                           # into DIST_COMMON, probably because this is
7948                           # an auxiliary file and we are not processing
7949                           # the top level Makefile.  Furthermore Automake
7950                           # hasn't been asked to create the Makefile.in
7951                           # that distributes the aux dir files.
7952                           error ($where, 'Please make a full run of automake'
7953                                  . " so $fullfile gets distributed.");
7954                         }
7955                     }
7956                 }
7957               else
7958                 {
7959                   $trailer = "\n  `automake --add-missing' can install `$file'"
7960                     if -f "$libdir/$file";
7961                 }
7962
7963               # If --force-missing was specified, and we have
7964               # actually found the file, then do nothing.
7965               next
7966                 if $found_it && $force_missing;
7967
7968               # If we couldn't install the file, but it is a target in
7969               # the Makefile, don't print anything.  This allows files
7970               # like README, AUTHORS, or THANKS to be generated.
7971               next
7972                 if !$suppress && rule $file;
7973
7974               msg ($suppress ? 'note' : 'error', $where, "$message$trailer$trailer2");
7975             }
7976         }
7977     }
7978 }
7979
7980 # &require_file ($WHERE, $MYSTRICT, @FILES)
7981 # -----------------------------------------
7982 sub require_file ($$@)
7983 {
7984     my ($where, $mystrict, @files) = @_;
7985     require_file_internal ($where, $mystrict, $relative_dir, @files);
7986 }
7987
7988 # &require_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7989 # -----------------------------------------------------------
7990 sub require_file_with_macro ($$$@)
7991 {
7992     my ($cond, $macro, $mystrict, @files) = @_;
7993     $macro = rvar ($macro) unless ref $macro;
7994     require_file ($macro->rdef ($cond)->location, $mystrict, @files);
7995 }
7996
7997 # &require_libsource_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7998 # ----------------------------------------------------------------
7999 # Require an AC_LIBSOURCEd file.  If AC_CONFIG_LIBOBJ_DIR was called, it
8000 # must be in that directory.  Otherwise expect it in the current directory.
8001 sub require_libsource_with_macro ($$$@)
8002 {
8003     my ($cond, $macro, $mystrict, @files) = @_;
8004     $macro = rvar ($macro) unless ref $macro;
8005     if ($config_libobj_dir)
8006       {
8007         require_file_internal ($macro->rdef ($cond)->location, $mystrict,
8008                                $config_libobj_dir, @files);
8009       }
8010     else
8011       {
8012         require_file ($macro->rdef ($cond)->location, $mystrict, @files);
8013       }
8014 }
8015
8016 # Queue to push require_conf_file requirements to.
8017 my $required_conf_file_queue;
8018
8019 # &queue_required_conf_file ($QUEUE, $KEY, $DIR, $WHERE, $MYSTRICT, @FILES)
8020 # -------------------------------------------------------------------------
8021 sub queue_required_conf_file ($$$$@)
8022 {
8023     my ($queue, $key, $dir, $where, $mystrict, @files) = @_;
8024     my @serial_loc;
8025     if (ref $where)
8026       {
8027         @serial_loc = (QUEUE_LOCATION, $where->serialize ());
8028       }
8029     else
8030       {
8031         @serial_loc = (QUEUE_STRING, $where);
8032       }
8033     $queue->enqueue ($key, $dir, @serial_loc, $mystrict, 0 + @files, @files);
8034 }
8035
8036 # &require_queued_conf_file ($QUEUE)
8037 # ----------------------------------
8038 sub require_queued_conf_file ($)
8039 {
8040     my ($queue) = @_;
8041     my $where;
8042     my $dir = $queue->dequeue ();
8043     my $loc_key = $queue->dequeue ();
8044     if ($loc_key eq QUEUE_LOCATION)
8045       {
8046         $where = Automake::Location::deserialize ($queue);
8047       }
8048     elsif ($loc_key eq QUEUE_STRING)
8049       {
8050         $where = $queue->dequeue ();
8051       }
8052     else
8053       {
8054         prog_error "unexpected key $loc_key";
8055       }
8056     my $mystrict = $queue->dequeue ();
8057     my $nfiles = $queue->dequeue ();
8058     my @files;
8059     push @files, $queue->dequeue ()
8060       foreach (1 .. $nfiles);
8061
8062     # Dequeuing happens outside of per-makefile context, so we have to
8063     # set the variables used by require_file_internal and the functions
8064     # it calls.  Gross!
8065     $relative_dir = $dir;
8066     require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8067 }
8068
8069 # &require_conf_file ($WHERE, $MYSTRICT, @FILES)
8070 # ----------------------------------------------
8071 # Looks in configuration path, as specified by AC_CONFIG_AUX_DIR;
8072 # worker threads may queue up the action to be serialized by the master.
8073 #
8074 # FIXME: this seriously relies on the semantics of require_file_internal
8075 # and maybe_push_required_file, in that we exploit the fact that only the
8076 # contents of the last handled output file may be impacted (which in turn
8077 # is dealt with by the master thread).
8078 sub require_conf_file ($$@)
8079 {
8080     my ($where, $mystrict, @files) = @_;
8081     if (defined $required_conf_file_queue)
8082       {
8083         queue_required_conf_file ($required_conf_file_queue, QUEUE_CONF_FILE,
8084                                   $relative_dir, $where, $mystrict, @files);
8085       }
8086     else
8087       {
8088         require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8089       }
8090 }
8091
8092
8093 # &require_conf_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
8094 # ----------------------------------------------------------------
8095 sub require_conf_file_with_macro ($$$@)
8096 {
8097     my ($cond, $macro, $mystrict, @files) = @_;
8098     require_conf_file (rvar ($macro)->rdef ($cond)->location,
8099                        $mystrict, @files);
8100 }
8101
8102 ################################################################
8103
8104 # &require_build_directory ($DIRECTORY)
8105 # -------------------------------------
8106 # Emit rules to create $DIRECTORY if needed, and return
8107 # the file that any target requiring this directory should be made
8108 # dependent upon.
8109 # We don't want to emit the rule twice, and want to reuse it
8110 # for directories with equivalent names (e.g., `foo/bar' and `./foo//bar').
8111 sub require_build_directory ($)
8112 {
8113   my $directory = shift;
8114
8115   return $directory_map{$directory} if exists $directory_map{$directory};
8116
8117   my $cdir = File::Spec->canonpath ($directory);
8118
8119   if (exists $directory_map{$cdir})
8120     {
8121       my $stamp = $directory_map{$cdir};
8122       $directory_map{$directory} = $stamp;
8123       return $stamp;
8124     }
8125
8126   my $dirstamp = "$cdir/\$(am__dirstamp)";
8127
8128   $directory_map{$directory} = $dirstamp;
8129   $directory_map{$cdir} = $dirstamp;
8130
8131   # Set a variable for the dirstamp basename.
8132   define_pretty_variable ('am__dirstamp', TRUE, INTERNAL,
8133                           '$(am__leading_dot)dirstamp');
8134
8135   # Directory must be removed by `make distclean'.
8136   $clean_files{$dirstamp} = DIST_CLEAN;
8137
8138   $output_rules .= ("$dirstamp:\n"
8139                     . "\t\@\$(MKDIR_P) $directory\n"
8140                     . "\t\@: > $dirstamp\n");
8141
8142   return $dirstamp;
8143 }
8144
8145 # &require_build_directory_maybe ($FILE)
8146 # --------------------------------------
8147 # If $FILE lies in a subdirectory, emit a rule to create this
8148 # directory and return the file that $FILE should be made
8149 # dependent upon.  Otherwise, just return the empty string.
8150 sub require_build_directory_maybe ($)
8151 {
8152     my $file = shift;
8153     my $directory = dirname ($file);
8154
8155     if ($directory ne '.')
8156     {
8157         return require_build_directory ($directory);
8158     }
8159     else
8160     {
8161         return '';
8162     }
8163 }
8164
8165 ################################################################
8166
8167 # Push a list of files onto dist_common.
8168 sub push_dist_common
8169 {
8170   prog_error "push_dist_common run after handle_dist"
8171     if $handle_dist_run;
8172   Automake::Variable::define ('DIST_COMMON', VAR_AUTOMAKE, '+', TRUE, "@_",
8173                               '', INTERNAL, VAR_PRETTY);
8174 }
8175
8176
8177 ################################################################
8178
8179 # generate_makefile ($MAKEFILE_AM, $MAKEFILE_IN)
8180 # ----------------------------------------------
8181 # Generate a Makefile.in given the name of the corresponding Makefile and
8182 # the name of the file output by config.status.
8183 sub generate_makefile ($$)
8184 {
8185   my ($makefile_am, $makefile_in) = @_;
8186
8187   # Reset all the Makefile.am related variables.
8188   initialize_per_input;
8189
8190   # AUTOMAKE_OPTIONS can contains -W flags to disable or enable
8191   # warnings for this file.  So hold any warning issued before
8192   # we have processed AUTOMAKE_OPTIONS.
8193   buffer_messages ('warning');
8194
8195   # Name of input file ("Makefile.am") and output file
8196   # ("Makefile.in").  These have no directory components.
8197   $am_file_name = basename ($makefile_am);
8198   $in_file_name = basename ($makefile_in);
8199
8200   # $OUTPUT is encoded.  If it contains a ":" then the first element
8201   # is the real output file, and all remaining elements are input
8202   # files.  We don't scan or otherwise deal with these input files,
8203   # other than to mark them as dependencies.  See
8204   # &scan_autoconf_files for details.
8205   my ($makefile, @inputs) = split (/:/, $output_files{$makefile_in});
8206
8207   $relative_dir = dirname ($makefile);
8208   $am_relative_dir = dirname ($makefile_am);
8209   $topsrcdir = backname ($relative_dir);
8210
8211   read_main_am_file ($makefile_am);
8212   if (handle_options)
8213     {
8214       # Process buffered warnings.
8215       flush_messages;
8216       # Fatal error.  Just return, so we can continue with next file.
8217       return;
8218     }
8219   # Process buffered warnings.
8220   flush_messages;
8221
8222   # There are a few install-related variables that you should not define.
8223   foreach my $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
8224     {
8225       my $v = var $var;
8226       if ($v)
8227         {
8228           my $def = $v->def (TRUE);
8229           prog_error "$var not defined in condition TRUE"
8230             unless $def;
8231           reject_var $var, "`$var' should not be defined"
8232             if $def->owner != VAR_AUTOMAKE;
8233         }
8234     }
8235
8236   # Catch some obsolete variables.
8237   msg_var ('obsolete', 'INCLUDES',
8238            "`INCLUDES' is the old name for `AM_CPPFLAGS' (or `*_CPPFLAGS')")
8239     if var ('INCLUDES');
8240
8241   # Must do this after reading .am file.
8242   define_variable ('subdir', $relative_dir, INTERNAL);
8243
8244   # If DIST_SUBDIRS is defined, make sure SUBDIRS is, so that
8245   # recursive rules are enabled.
8246   define_pretty_variable ('SUBDIRS', TRUE, INTERNAL, '')
8247     if var 'DIST_SUBDIRS' && ! var 'SUBDIRS';
8248
8249   # Check first, because we might modify some state.
8250   check_cygnus;
8251   check_gnu_standards;
8252   check_gnits_standards;
8253
8254   handle_configure ($makefile_am, $makefile_in, $makefile, @inputs);
8255   handle_gettext;
8256   handle_libraries;
8257   handle_ltlibraries;
8258   handle_programs;
8259   handle_scripts;
8260
8261   # These must be run after all the sources are scanned.  They
8262   # use variables defined by &handle_libraries, &handle_ltlibraries,
8263   # or &handle_programs.
8264   handle_compile;
8265   handle_languages;
8266   handle_libtool;
8267
8268   # Variables used by distdir.am and tags.am.
8269   define_pretty_variable ('SOURCES', TRUE, INTERNAL, @sources);
8270   if (! option 'no-dist')
8271     {
8272       define_pretty_variable ('DIST_SOURCES', TRUE, INTERNAL, @dist_sources);
8273     }
8274
8275   handle_multilib;
8276   handle_texinfo;
8277   handle_emacs_lisp;
8278   handle_python;
8279   handle_java;
8280   handle_man_pages;
8281   handle_data;
8282   handle_headers;
8283   handle_subdirs;
8284   handle_tags;
8285   handle_minor_options;
8286   # Must come after handle_programs so that %known_programs is up-to-date.
8287   handle_tests;
8288
8289   # This must come after most other rules.
8290   handle_dist;
8291
8292   handle_footer;
8293   do_check_merge_target;
8294   handle_all ($makefile);
8295
8296   # FIXME: Gross!
8297   if (var ('lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8298     {
8299       $output_rules .= "install-binPROGRAMS: install-libLTLIBRARIES\n\n";
8300     }
8301   if (var ('nobase_lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8302     {
8303       $output_rules .= "install-binPROGRAMS: install-nobase_libLTLIBRARIES\n\n";
8304     }
8305
8306   handle_install;
8307   handle_clean ($makefile);
8308   handle_factored_dependencies;
8309
8310   # Comes last, because all the above procedures may have
8311   # defined or overridden variables.
8312   $output_vars .= output_variables;
8313
8314   check_typos;
8315
8316   my ($out_file) = $output_directory . '/' . $makefile_in;
8317
8318   if ($exit_code != 0)
8319     {
8320       verb "not writing $out_file because of earlier errors";
8321       return;
8322     }
8323
8324   if (! -d ($output_directory . '/' . $am_relative_dir))
8325     {
8326       mkdir ($output_directory . '/' . $am_relative_dir, 0755);
8327     }
8328
8329   # We make sure that `all:' is the first target.
8330   my $output =
8331     "$output_vars$output_all$output_header$output_rules$output_trailer";
8332
8333   # Decide whether we must update the output file or not.
8334   # We have to update in the following situations.
8335   #  * $force_generation is set.
8336   #  * any of the output dependencies is younger than the output
8337   #  * the contents of the output is different (this can happen
8338   #    if the project has been populated with a file listed in
8339   #    @common_files since the last run).
8340   # Output's dependencies are split in two sets:
8341   #  * dependencies which are also configure dependencies
8342   #    These do not change between each Makefile.am
8343   #  * other dependencies, specific to the Makefile.am being processed
8344   #    (such as the Makefile.am itself, or any Makefile fragment
8345   #    it includes).
8346   my $timestamp = mtime $out_file;
8347   if (! $force_generation
8348       && $configure_deps_greatest_timestamp < $timestamp
8349       && $output_deps_greatest_timestamp < $timestamp
8350       && $output eq contents ($out_file))
8351     {
8352       verb "$out_file unchanged";
8353       # No need to update.
8354       return;
8355     }
8356
8357   if (-e $out_file)
8358     {
8359       unlink ($out_file)
8360         or fatal "cannot remove $out_file: $!\n";
8361     }
8362
8363   my $gm_file = new Automake::XFile "> $out_file";
8364   verb "creating $out_file";
8365   print $gm_file $output;
8366 }
8367
8368 ################################################################
8369
8370
8371
8372
8373 ################################################################
8374
8375 # Helper function for usage().
8376 sub print_autodist_files (@)
8377 {
8378   my @lcomm = sort (&uniq (@_));
8379
8380   my @four;
8381   format USAGE_FORMAT =
8382   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
8383   $four[0],           $four[1],           $four[2],           $four[3]
8384 .
8385   local $~ = "USAGE_FORMAT";
8386
8387   my $cols = 4;
8388   my $rows = int(@lcomm / $cols);
8389   my $rest = @lcomm % $cols;
8390
8391   if ($rest)
8392     {
8393       $rows++;
8394     }
8395   else
8396     {
8397       $rest = $cols;
8398     }
8399
8400   for (my $y = 0; $y < $rows; $y++)
8401     {
8402       @four = ("", "", "", "");
8403       for (my $x = 0; $x < $cols; $x++)
8404         {
8405           last if $y + 1 == $rows && $x == $rest;
8406
8407           my $idx = (($x > $rest)
8408                ?  ($rows * $rest + ($rows - 1) * ($x - $rest))
8409                : ($rows * $x));
8410
8411           $idx += $y;
8412           $four[$x] = $lcomm[$idx];
8413         }
8414       write;
8415     }
8416 }
8417
8418
8419 # Print usage information.
8420 sub usage ()
8421 {
8422     print "Usage: $0 [OPTION] ... [Makefile]...
8423
8424 Generate Makefile.in for configure from Makefile.am.
8425
8426 Operation modes:
8427       --help               print this help, then exit
8428       --version            print version number, then exit
8429   -v, --verbose            verbosely list files processed
8430       --no-force           only update Makefile.in's that are out of date
8431   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY
8432
8433 Dependency tracking:
8434   -i, --ignore-deps      disable dependency tracking code
8435       --include-deps     enable dependency tracking code
8436
8437 Flavors:
8438       --cygnus           assume program is part of Cygnus-style tree
8439       --foreign          set strictness to foreign
8440       --gnits            set strictness to gnits
8441       --gnu              set strictness to gnu
8442
8443 Library files:
8444   -a, --add-missing      add missing standard files to package
8445       --libdir=DIR       directory storing library files
8446   -c, --copy             with -a, copy missing files (default is symlink)
8447   -f, --force-missing    force update of standard files
8448
8449 ";
8450     Automake::ChannelDefs::usage;
8451
8452     print "\nFiles automatically distributed if found " .
8453           "(always):\n";
8454     print_autodist_files @common_files;
8455     print "\nFiles automatically distributed if found " .
8456           "(under certain conditions):\n";
8457     print_autodist_files @common_sometimes;
8458
8459     print '
8460 Report bugs to <@PACKAGE_BUGREPORT@>.
8461 GNU Automake home page: <@PACKAGE_URL@>.
8462 General help using GNU software: <http://www.gnu.org/gethelp/>.
8463 ';
8464
8465     # --help always returns 0 per GNU standards.
8466     exit 0;
8467 }
8468
8469
8470 # &version ()
8471 # -----------
8472 # Print version information
8473 sub version ()
8474 {
8475   print <<EOF;
8476 automake (GNU $PACKAGE) $VERSION
8477 Copyright (C) 2011 Free Software Foundation, Inc.
8478 License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
8479 This is free software: you are free to change and redistribute it.
8480 There is NO WARRANTY, to the extent permitted by law.
8481
8482 Written by Tom Tromey <tromey\@redhat.com>
8483        and Alexandre Duret-Lutz <adl\@gnu.org>.
8484 EOF
8485   # --version always returns 0 per GNU standards.
8486   exit 0;
8487 }
8488
8489 ################################################################
8490
8491 # Parse command line.
8492 sub parse_arguments ()
8493 {
8494   # Start off as gnu.
8495   set_strictness ('gnu');
8496
8497   my $cli_where = new Automake::Location;
8498   my %cli_options =
8499     (
8500      'version' => \&version,
8501      'help'    => \&usage,
8502      'libdir=s' => \$libdir,
8503      'gnu'              => sub { set_strictness ('gnu'); },
8504      'gnits'            => sub { set_strictness ('gnits'); },
8505      'cygnus'           => sub { set_global_option ('cygnus', $cli_where); },
8506      'foreign'          => sub { set_strictness ('foreign'); },
8507      'include-deps'     => sub { unset_global_option ('no-dependencies'); },
8508      'i|ignore-deps'    => sub { set_global_option ('no-dependencies',
8509                                                     $cli_where); },
8510      'no-force' => sub { $force_generation = 0; },
8511      'f|force-missing'  => \$force_missing,
8512      'o|output-dir=s'   => \$output_directory,
8513      'a|add-missing'    => \$add_missing,
8514      'c|copy'           => \$copy_missing,
8515      'v|verbose'        => sub { setup_channel 'verb', silent => 0; },
8516      'W|warnings=s'     => \&parse_warnings,
8517      # These long options (--Werror and --Wno-error) for backward
8518      # compatibility.  Use -Werror and -Wno-error today.
8519      'Werror'           => sub { parse_warnings 'W', 'error'; },
8520      'Wno-error'        => sub { parse_warnings 'W', 'no-error'; },
8521      );
8522
8523   use Automake::Getopt ();
8524   Automake::Getopt::parse_options %cli_options;
8525
8526   if (defined $output_directory)
8527     {
8528       msg 'obsolete', "`--output-dir' is deprecated\n";
8529     }
8530   else
8531     {
8532       # In the next release we'll remove this entirely.
8533       $output_directory = '.';
8534     }
8535
8536   return unless @ARGV;
8537
8538   my $errspec = 0;
8539   foreach my $arg (@ARGV)
8540     {
8541       fatal ("empty argument\nTry `$0 --help' for more information.")
8542         if ($arg eq '');
8543
8544       # Handle $local:$input syntax.
8545       my ($local, @rest) = split (/:/, $arg);
8546       @rest = ("$local.in",) unless @rest;
8547       my $input = locate_am @rest;
8548       if ($input)
8549         {
8550           push @input_files, $input;
8551           $output_files{$input} = join (':', ($local, @rest));
8552         }
8553       else
8554         {
8555           error "no Automake input file found for `$arg'";
8556           $errspec = 1;
8557         }
8558     }
8559   fatal "no input file found among supplied arguments"
8560     if $errspec && ! @input_files;
8561 }
8562
8563
8564 # handle_makefile ($MAKEFILE_IN)
8565 # ------------------------------
8566 # Deal with $MAKEFILE_IN.
8567 sub handle_makefile ($)
8568 {
8569   my ($file) =  @_;
8570   ($am_file = $file) =~ s/\.in$//;
8571   if (! -f ($am_file . '.am'))
8572     {
8573       error "`$am_file.am' does not exist";
8574     }
8575   else
8576     {
8577       # Any warning setting now local to this Makefile.am.
8578       dup_channel_setup;
8579
8580       generate_makefile ($am_file . '.am', $file);
8581
8582       # Back out any warning setting.
8583       drop_channel_setup;
8584     }
8585 }
8586
8587 # handle_makefiles_serial ()
8588 # --------------------------
8589 # Deal with all makefiles, without threads.
8590 sub handle_makefiles_serial ()
8591 {
8592   foreach my $file (@input_files)
8593     {
8594       handle_makefile ($file);
8595     }
8596 }
8597
8598 # get_number_of_threads ()
8599 # ------------------------
8600 # Logic for deciding how many worker threads to use.
8601 sub get_number_of_threads
8602 {
8603   my $nthreads = $ENV{'AUTOMAKE_JOBS'} || 0;
8604
8605   $nthreads = 0
8606     unless $nthreads =~ /^[0-9]+$/;
8607
8608   # It doesn't make sense to use more threads than makefiles,
8609   my $max_threads = @input_files;
8610
8611   # but a single worker thread is helpful for exposing bugs.
8612   if ($automake_will_process_aux_dir && $max_threads > 1)
8613     {
8614       $max_threads--;
8615     }
8616   if ($nthreads > $max_threads)
8617     {
8618       $nthreads = $max_threads;
8619     }
8620   return $nthreads;
8621 }
8622
8623 # handle_makefiles_threaded ($NTHREADS)
8624 # -------------------------------------
8625 # Deal with all makefiles, using threads.  The general strategy is to
8626 # spawn NTHREADS worker threads, dispatch makefiles to them, and let the
8627 # worker threads push back everything that needs serialization:
8628 # * warning and (normal) error messages, for stable stderr output
8629 #   order and content (avoiding duplicates, for example),
8630 # * races when installing aux files (and respective messages),
8631 # * races when collecting aux files for distribution.
8632 #
8633 # The latter requires that the makefile that deals with the aux dir
8634 # files be handled last, done by the master thread.
8635 sub handle_makefiles_threaded ($)
8636 {
8637   my ($nthreads) = @_;
8638
8639   my @queued_input_files = @input_files;
8640   my $last_input_file = undef;
8641   if ($automake_will_process_aux_dir)
8642     {
8643       $last_input_file = pop @queued_input_files;
8644     }
8645
8646   # The file queue distributes all makefiles, the message queues
8647   # collect all serializations needed for respective files.
8648   my $file_queue = Thread::Queue->new;
8649   my %msg_queues;
8650   foreach my $file (@queued_input_files)
8651     {
8652       $msg_queues{$file} = Thread::Queue->new;
8653     }
8654
8655   verb "spawning $nthreads worker threads";
8656   my @threads = (1 .. $nthreads);
8657   foreach my $t (@threads)
8658     {
8659       $t = threads->new (sub
8660         {
8661           while (my $file = $file_queue->dequeue)
8662             {
8663               verb "handling $file";
8664               my $queue = $msg_queues{$file};
8665               setup_channel_queue ($queue, QUEUE_MESSAGE);
8666               $required_conf_file_queue = $queue;
8667               handle_makefile ($file);
8668               $queue->enqueue (undef);
8669               setup_channel_queue (undef, undef);
8670               $required_conf_file_queue = undef;
8671             }
8672           return $exit_code;
8673         });
8674     }
8675
8676   # Queue all normal makefiles.
8677   verb "queuing " . @queued_input_files . " input files";
8678   $file_queue->enqueue (@queued_input_files, (undef) x @threads);
8679
8680   # Collect and process serializations.
8681   foreach my $file (@queued_input_files)
8682     {
8683       verb "dequeuing messages for " . $file;
8684       reset_local_duplicates ();
8685       my $queue = $msg_queues{$file};
8686       while (my $key = $queue->dequeue)
8687         {
8688           if ($key eq QUEUE_MESSAGE)
8689             {
8690               pop_channel_queue ($queue);
8691             }
8692           elsif ($key eq QUEUE_CONF_FILE)
8693             {
8694               require_queued_conf_file ($queue);
8695             }
8696           else
8697             {
8698               prog_error "unexpected key $key";
8699             }
8700         }
8701     }
8702
8703   foreach my $t (@threads)
8704     {
8705       my @exit_thread = $t->join;
8706       $exit_code = $exit_thread[0]
8707         if ($exit_thread[0] > $exit_code);
8708     }
8709
8710   # The master processes the last file.
8711   if ($automake_will_process_aux_dir)
8712     {
8713       verb "processing last input file";
8714       handle_makefile ($last_input_file);
8715     }
8716 }
8717
8718 ################################################################
8719
8720 # Parse the WARNINGS environment variable.
8721 parse_WARNINGS;
8722
8723 # Parse command line.
8724 parse_arguments;
8725
8726 $configure_ac = require_configure_ac;
8727
8728 # Do configure.ac scan only once.
8729 scan_autoconf_files;
8730
8731 if (! @input_files)
8732   {
8733     my $msg = '';
8734     $msg = "\nDid you forget AC_CONFIG_FILES([Makefile]) in $configure_ac?"
8735       if -f 'Makefile.am';
8736     fatal ("no `Makefile.am' found for any configure output$msg");
8737   }
8738
8739 my $nthreads = get_number_of_threads ();
8740
8741 if ($perl_threads && $nthreads >= 1)
8742   {
8743     handle_makefiles_threaded ($nthreads);
8744   }
8745 else
8746   {
8747     handle_makefiles_serial ();
8748   }
8749
8750 exit $exit_code;
8751
8752
8753 ### Setup "GNU" style for perl-mode and cperl-mode.
8754 ## Local Variables:
8755 ## perl-indent-level: 2
8756 ## perl-continued-statement-offset: 2
8757 ## perl-continued-brace-offset: 0
8758 ## perl-brace-offset: 0
8759 ## perl-brace-imaginary-offset: 0
8760 ## perl-label-offset: -2
8761 ## cperl-indent-level: 2
8762 ## cperl-brace-offset: 0
8763 ## cperl-continued-brace-offset: 0
8764 ## cperl-label-offset: -2
8765 ## cperl-extra-newline-before-brace: t
8766 ## cperl-merge-trailing-else: nil
8767 ## cperl-continued-statement-offset: 2
8768 ## End: