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 $var = var "${derived}_SOURCES";
6018   return unless $var;
6019
6020   my @vala_sources = grep { /\.vala$/ } ($var->value_as_list_recursive);
6021
6022   foreach my $vala_file (@vala_sources)
6023     {
6024       (my $c_file = $vala_file) =~ s/(.*)\.vala$/$1.c/;
6025       $output_rules .= "\$(srcdir)/$c_file: \$(srcdir)/${derived}_vala.stamp\n"
6026         . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6027         . "\t\@if test -f \$@; then :; else \\\n"
6028         . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
6029         . "\tfi\n"
6030     }
6031
6032   # Add rebuild rules for generated header and vapi files
6033   my $flags = var ($derived . '_VALAFLAGS');
6034   if ($flags)
6035     {
6036       my $lastflag = '';
6037       foreach my $flag ($flags->value_as_list_recursive)
6038         {
6039           if (grep (/$lastflag/, ('-H', '-h', '--header', '--internal-header',
6040                                   '--vapi', '--internal-vapi', '--gir')))
6041             {
6042               my $headerfile = $flag;
6043               $output_rules .= "\$(srcdir)/$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
6044                 . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
6045                 . "\t\@if test -f \$@; then :; else \\\n"
6046                 . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
6047                 . "\tfi\n";
6048
6049               # valac is not used when building from dist tarballs
6050               # distribute the generated files
6051               push_dist_common ($headerfile);
6052               $clean_files{$headerfile} = MAINTAINER_CLEAN;
6053             }
6054           $lastflag = $flag;
6055         }
6056     }
6057
6058   my $compile = $self->compile;
6059
6060   # Rewrite each occurrence of `AM_VALAFLAGS' in the compile
6061   # rule into `${derived}_VALAFLAGS' if it exists.
6062   my $val = "${derived}_VALAFLAGS";
6063   $compile =~ s/\(AM_VALAFLAGS\)/\($val\)/
6064     if set_seen ($val);
6065
6066   # VALAFLAGS is a user variable (per GNU Standards),
6067   # it should not be overridden in the Makefile...
6068   check_user_variables ['VALAFLAGS'];
6069
6070   my $dirname = dirname ($name);
6071
6072   # Only generate C code, do not run C compiler
6073   $compile .= " -C";
6074
6075   my $verbose = verbose_flag ('VALAC');
6076   my $silent = silent_flag ();
6077
6078   $output_rules .=
6079     "\$(srcdir)/${derived}_vala.stamp: @vala_sources\n".
6080 # Since the C files generated from the vala sources depend on the
6081 # ${derived}_vala.stamp file, we must ensure its timestamp is older than
6082 # those of the C files generated by the valac invocation below (this is
6083 # especially important on systems with sub-second timestamp resolution).
6084 # Thus we need to create the stamp file *before* invoking valac, and to
6085 # move it to its final location only after valac has been invoked.
6086     "\t${silent}rm -f \$\@ && echo stamp > \$\@-t\n".
6087     "\t${verbose}\$(am__cd) \$(srcdir) && $compile @vala_sources\n".
6088     "\t${silent}mv -f \$\@-t \$\@\n";
6089
6090   push_dist_common ("${derived}_vala.stamp");
6091
6092   $clean_files{"${derived}_vala.stamp"} = MAINTAINER_CLEAN;
6093 }
6094
6095 # Add output rules to invoke valac and create stamp file as a witness
6096 # to handle multiple outputs. This function is called after all source
6097 # file processing is done.
6098 sub lang_vala_finish
6099 {
6100   my ($self) = @_;
6101
6102   foreach my $prog (keys %known_programs)
6103     {
6104       lang_vala_finish_target ($self, $prog);
6105     }
6106
6107   while (my ($name) = each %known_libraries)
6108     {
6109       lang_vala_finish_target ($self, $name);
6110     }
6111 }
6112
6113 # The built .c files should be cleaned only on maintainer-clean
6114 # as the .c files are distributed. This function is called for each
6115 # .vala source file.
6116 sub lang_vala_target_hook
6117 {
6118   my ($self, $aggregate, $output, $input, %transform) = @_;
6119
6120   $clean_files{$output} = MAINTAINER_CLEAN;
6121 }
6122
6123 # This is a yacc helper which is called whenever we have decided to
6124 # compile a yacc file.
6125 sub lang_yacc_target_hook
6126 {
6127     my ($self, $aggregate, $output, $input, %transform) = @_;
6128
6129     my $flag = $aggregate . "_YFLAGS";
6130     my $flagvar = var $flag;
6131     my $YFLAGSvar = var 'YFLAGS';
6132     if (($flagvar && $flagvar->variable_value =~ /$DASH_D_PATTERN/o)
6133         || ($YFLAGSvar && $YFLAGSvar->variable_value =~ /$DASH_D_PATTERN/o))
6134     {
6135         (my $output_base = $output) =~ s/$KNOWN_EXTENSIONS_PATTERN$//;
6136         my $header = $output_base . '.h';
6137
6138         # Found a `-d' that applies to the compilation of this file.
6139         # Add a dependency for the generated header file, and arrange
6140         # for that file to be included in the distribution.
6141         foreach my $cond (Automake::Rule::define (${header}, 'internal',
6142                                                   RULE_AUTOMAKE, TRUE,
6143                                                   INTERNAL))
6144           {
6145             my $condstr = $cond->subst_string;
6146             $output_rules .=
6147               "$condstr${header}: $output\n"
6148               # Recover from removal of $header
6149               . "$condstr\t\@if test ! -f \$@; then rm -f $output; else :; fi\n"
6150               . "$condstr\t\@if test ! -f \$@; then \$(MAKE) \$(AM_MAKEFLAGS) $output; else :; fi\n";
6151           }
6152         # Distribute the generated file, unless its .y source was
6153         # listed in a nodist_ variable.  (&handle_source_transform
6154         # will set DIST_SOURCE.)
6155         &push_dist_common ($header)
6156           if $transform{'DIST_SOURCE'};
6157
6158         # If the files are built in the build directory, then we want
6159         # to remove them with `make clean'.  If they are in srcdir
6160         # they shouldn't be touched.  However, we can't determine this
6161         # statically, and the GNU rules say that yacc/lex output files
6162         # should be removed by maintainer-clean.  So that's what we
6163         # do.
6164         $clean_files{$header} = MAINTAINER_CLEAN;
6165     }
6166     # Erase $OUTPUT on `make maintainer-clean' (by GNU standards).
6167     # See the comment above for $HEADER.
6168     $clean_files{$output} = MAINTAINER_CLEAN;
6169 }
6170
6171 # This is a lex helper which is called whenever we have decided to
6172 # compile a lex file.
6173 sub lang_lex_target_hook
6174 {
6175     my ($self, $aggregate, $output, $input) = @_;
6176     # If the files are built in the build directory, then we want to
6177     # remove them with `make clean'.  If they are in srcdir they
6178     # shouldn't be touched.  However, we can't determine this
6179     # statically, and the GNU rules say that yacc/lex output files
6180     # should be removed by maintainer-clean.  So that's what we do.
6181     $clean_files{$output} = MAINTAINER_CLEAN;
6182 }
6183
6184 # This is a helper for both lex and yacc.
6185 sub yacc_lex_finish_helper
6186 {
6187   return if defined $language_scratch{'lex-yacc-done'};
6188   $language_scratch{'lex-yacc-done'} = 1;
6189
6190   # FIXME: for now, no line number.
6191   require_conf_file ($configure_ac, FOREIGN, 'ylwrap');
6192   &define_variable ('YLWRAP', "$am_config_aux_dir/ylwrap", INTERNAL);
6193 }
6194
6195 sub lang_yacc_finish
6196 {
6197   return if defined $language_scratch{'yacc-done'};
6198   $language_scratch{'yacc-done'} = 1;
6199
6200   reject_var 'YACCFLAGS', "`YACCFLAGS' obsolete; use `YFLAGS' instead";
6201
6202   yacc_lex_finish_helper;
6203 }
6204
6205
6206 sub lang_lex_finish
6207 {
6208   return if defined $language_scratch{'lex-done'};
6209   $language_scratch{'lex-done'} = 1;
6210
6211   yacc_lex_finish_helper;
6212 }
6213
6214
6215 # Given a hash table of linker names, pick the name that has the most
6216 # precedence.  This is lame, but something has to have global
6217 # knowledge in order to eliminate the conflict.  Add more linkers as
6218 # required.
6219 sub resolve_linker
6220 {
6221     my (%linkers) = @_;
6222
6223     foreach my $l (qw(GCJLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
6224     {
6225         return $l if defined $linkers{$l};
6226     }
6227     return 'LINK';
6228 }
6229
6230 # Called to indicate that an extension was used.
6231 sub saw_extension
6232 {
6233     my ($ext) = @_;
6234     if (! defined $extension_seen{$ext})
6235     {
6236         $extension_seen{$ext} = 1;
6237     }
6238     else
6239     {
6240         ++$extension_seen{$ext};
6241     }
6242 }
6243
6244 # Return the number of files seen for a given language.  Knows about
6245 # special cases we care about.  FIXME: this is hideous.  We need
6246 # something that involves real language objects.  For instance yacc
6247 # and yaccxx could both derive from a common yacc class which would
6248 # know about the strange ylwrap requirement.  (Or better yet we could
6249 # just not support legacy yacc!)
6250 sub count_files_for_language
6251 {
6252     my ($name) = @_;
6253
6254     my @names;
6255     if ($name eq 'yacc' || $name eq 'yaccxx')
6256     {
6257         @names = ('yacc', 'yaccxx');
6258     }
6259     elsif ($name eq 'lex' || $name eq 'lexxx')
6260     {
6261         @names = ('lex', 'lexxx');
6262     }
6263     else
6264     {
6265         @names = ($name);
6266     }
6267
6268     my $r = 0;
6269     foreach $name (@names)
6270     {
6271         my $lang = $languages{$name};
6272         foreach my $ext (@{$lang->extensions})
6273         {
6274             $r += $extension_seen{$ext}
6275                 if defined $extension_seen{$ext};
6276         }
6277     }
6278
6279     return $r
6280 }
6281
6282 # Called to ask whether source files have been seen . If HEADERS is 1,
6283 # headers can be included.
6284 sub saw_sources_p
6285 {
6286     my ($headers) = @_;
6287
6288     # count all the sources
6289     my $count = 0;
6290     foreach my $val (values %extension_seen)
6291     {
6292         $count += $val;
6293     }
6294
6295     if (!$headers)
6296     {
6297         $count -= count_files_for_language ('header');
6298     }
6299
6300     return $count > 0;
6301 }
6302
6303
6304 # register_language (%ATTRIBUTE)
6305 # ------------------------------
6306 # Register a single language.
6307 # Each %ATTRIBUTE is of the form ATTRIBUTE => VALUE.
6308 sub register_language (%)
6309 {
6310   my (%option) = @_;
6311
6312   # Set the defaults.
6313   $option{'ansi'} = 0
6314     unless defined $option{'ansi'};
6315   $option{'autodep'} = 'no'
6316     unless defined $option{'autodep'};
6317   $option{'linker'} = ''
6318     unless defined $option{'linker'};
6319   $option{'flags'} = []
6320     unless defined $option{'flags'};
6321   $option{'output_extensions'} = sub { return ( '.$(OBJEXT)', '.lo' ) }
6322     unless defined $option{'output_extensions'};
6323   $option{'nodist_specific'} = 0
6324     unless defined $option{'nodist_specific'};
6325
6326   my $lang = new Language (%option);
6327
6328   # Fill indexes.
6329   $extension_map{$_} = $lang->name foreach @{$lang->extensions};
6330   $languages{$lang->name} = $lang;
6331   my $link = $lang->linker;
6332   if ($link)
6333     {
6334       if (exists $link_languages{$link})
6335         {
6336           prog_error ("`$link' has different definitions in "
6337                       . $lang->name . " and " . $link_languages{$link}->name)
6338             if $lang->link ne $link_languages{$link}->link;
6339         }
6340       else
6341         {
6342           $link_languages{$link} = $lang;
6343         }
6344     }
6345
6346   # Update the pattern of known extensions.
6347   accept_extensions (@{$lang->extensions});
6348
6349   # Upate the $suffix_rule map.
6350   foreach my $suffix (@{$lang->extensions})
6351     {
6352       foreach my $dest (&{$lang->output_extensions} ($suffix))
6353         {
6354           register_suffix_rule (INTERNAL, $suffix, $dest);
6355         }
6356     }
6357 }
6358
6359 # derive_suffix ($EXT, $OBJ)
6360 # --------------------------
6361 # This function is used to find a path from a user-specified suffix $EXT
6362 # to $OBJ or to some other suffix we recognize internally, e.g. `cc'.
6363 sub derive_suffix ($$)
6364 {
6365   my ($source_ext, $obj) = @_;
6366
6367   while (! $extension_map{$source_ext}
6368          && $source_ext ne $obj
6369          && exists $suffix_rules->{$source_ext}
6370          && exists $suffix_rules->{$source_ext}{$obj})
6371     {
6372       $source_ext = $suffix_rules->{$source_ext}{$obj}[0];
6373     }
6374
6375   return $source_ext;
6376 }
6377
6378
6379 ################################################################
6380
6381 # Pretty-print something and append to output_rules.
6382 sub pretty_print_rule
6383 {
6384     $output_rules .= &makefile_wrap (@_);
6385 }
6386
6387
6388 ################################################################
6389
6390
6391 ## -------------------------------- ##
6392 ## Handling the conditional stack.  ##
6393 ## -------------------------------- ##
6394
6395
6396 # $STRING
6397 # make_conditional_string ($NEGATE, $COND)
6398 # ----------------------------------------
6399 sub make_conditional_string ($$)
6400 {
6401   my ($negate, $cond) = @_;
6402   $cond = "${cond}_TRUE"
6403     unless $cond =~ /^TRUE|FALSE$/;
6404   $cond = Automake::Condition::conditional_negate ($cond)
6405     if $negate;
6406   return $cond;
6407 }
6408
6409
6410 my %_am_macro_for_cond =
6411   (
6412   AMDEP => "one of the compiler tests\n"
6413            . "    AC_PROG_CC, AC_PROG_CXX, AC_PROG_CXX, AC_PROG_OBJC,\n"
6414            . "    AM_PROG_AS, AM_PROG_GCJ, AM_PROG_UPC",
6415   am__fastdepCC => 'AC_PROG_CC',
6416   am__fastdepCCAS => 'AM_PROG_AS',
6417   am__fastdepCXX => 'AC_PROG_CXX',
6418   am__fastdepGCJ => 'AM_PROG_GCJ',
6419   am__fastdepOBJC => 'AC_PROG_OBJC',
6420   am__fastdepUPC => 'AM_PROG_UPC'
6421   );
6422
6423 # $COND
6424 # cond_stack_if ($NEGATE, $COND, $WHERE)
6425 # --------------------------------------
6426 sub cond_stack_if ($$$)
6427 {
6428   my ($negate, $cond, $where) = @_;
6429
6430   if (! $configure_cond{$cond} && $cond !~ /^TRUE|FALSE$/)
6431     {
6432       my $text = "$cond does not appear in AM_CONDITIONAL";
6433       my $scope = US_LOCAL;
6434       if (exists $_am_macro_for_cond{$cond})
6435         {
6436           my $mac = $_am_macro_for_cond{$cond};
6437           $text .= "\n  The usual way to define `$cond' is to add ";
6438           $text .= ($mac =~ / /) ? $mac : "`$mac'";
6439           $text .= "\n  to `$configure_ac' and run `aclocal' and `autoconf' again.";
6440           # These warnings appear in Automake files (depend2.am),
6441           # so there is no need to display them more than once:
6442           $scope = US_GLOBAL;
6443         }
6444       error $where, $text, uniq_scope => $scope;
6445     }
6446
6447   push (@cond_stack, make_conditional_string ($negate, $cond));
6448
6449   return new Automake::Condition (@cond_stack);
6450 }
6451
6452
6453 # $COND
6454 # cond_stack_else ($NEGATE, $COND, $WHERE)
6455 # ----------------------------------------
6456 sub cond_stack_else ($$$)
6457 {
6458   my ($negate, $cond, $where) = @_;
6459
6460   if (! @cond_stack)
6461     {
6462       error $where, "else without if";
6463       return FALSE;
6464     }
6465
6466   $cond_stack[$#cond_stack] =
6467     Automake::Condition::conditional_negate ($cond_stack[$#cond_stack]);
6468
6469   # If $COND is given, check against it.
6470   if (defined $cond)
6471     {
6472       $cond = make_conditional_string ($negate, $cond);
6473
6474       error ($where, "else reminder ($negate$cond) incompatible with "
6475              . "current conditional: $cond_stack[$#cond_stack]")
6476         if $cond_stack[$#cond_stack] ne $cond;
6477     }
6478
6479   return new Automake::Condition (@cond_stack);
6480 }
6481
6482
6483 # $COND
6484 # cond_stack_endif ($NEGATE, $COND, $WHERE)
6485 # -----------------------------------------
6486 sub cond_stack_endif ($$$)
6487 {
6488   my ($negate, $cond, $where) = @_;
6489   my $old_cond;
6490
6491   if (! @cond_stack)
6492     {
6493       error $where, "endif without if";
6494       return TRUE;
6495     }
6496
6497   # If $COND is given, check against it.
6498   if (defined $cond)
6499     {
6500       $cond = make_conditional_string ($negate, $cond);
6501
6502       error ($where, "endif reminder ($negate$cond) incompatible with "
6503              . "current conditional: $cond_stack[$#cond_stack]")
6504         if $cond_stack[$#cond_stack] ne $cond;
6505     }
6506
6507   pop @cond_stack;
6508
6509   return new Automake::Condition (@cond_stack);
6510 }
6511
6512
6513
6514
6515
6516 ## ------------------------ ##
6517 ## Handling the variables.  ##
6518 ## ------------------------ ##
6519
6520
6521 # &define_pretty_variable ($VAR, $COND, $WHERE, @VALUE)
6522 # -----------------------------------------------------
6523 # Like define_variable, but the value is a list, and the variable may
6524 # be defined conditionally.  The second argument is the condition
6525 # under which the value should be defined; this should be the empty
6526 # string to define the variable unconditionally.  The third argument
6527 # is a list holding the values to use for the variable.  The value is
6528 # pretty printed in the output file.
6529 sub define_pretty_variable ($$$@)
6530 {
6531     my ($var, $cond, $where, @value) = @_;
6532
6533     if (! vardef ($var, $cond))
6534     {
6535         Automake::Variable::define ($var, VAR_AUTOMAKE, '', $cond, "@value",
6536                                     '', $where, VAR_PRETTY);
6537         rvar ($var)->rdef ($cond)->set_seen;
6538     }
6539 }
6540
6541
6542 # define_variable ($VAR, $VALUE, $WHERE)
6543 # --------------------------------------
6544 # Define a new Automake Makefile variable VAR to VALUE, but only if
6545 # not already defined.
6546 sub define_variable ($$$)
6547 {
6548     my ($var, $value, $where) = @_;
6549     define_pretty_variable ($var, TRUE, $where, $value);
6550 }
6551
6552
6553 # define_files_variable ($VAR, \@BASENAME, $EXTENSION, $WHERE)
6554 # ------------------------------------------------------------
6555 # Define the $VAR which content is the list of file names composed of
6556 # a @BASENAME and the $EXTENSION.
6557 sub define_files_variable ($\@$$)
6558 {
6559   my ($var, $basename, $extension, $where) = @_;
6560   define_variable ($var,
6561                    join (' ', map { "$_.$extension" } @$basename),
6562                    $where);
6563 }
6564
6565
6566 # Like define_variable, but define a variable to be the configure
6567 # substitution by the same name.
6568 sub define_configure_variable ($)
6569 {
6570   my ($var) = @_;
6571
6572   my $pretty = VAR_ASIS;
6573   my $owner = VAR_CONFIGURE;
6574
6575   # Some variables we do not want to output.  For instance it
6576   # would be a bad idea to output `U = @U@` when `@U@` can be
6577   # substituted as `\`.
6578   $pretty = VAR_SILENT if exists $ignored_configure_vars{$var};
6579
6580   # ANSI2KNR is a variable that Automake wants to redefine, so
6581   # it must be owned by Automake.  (It is also used as a proof
6582   # that AM_C_PROTOTYPES has been run, that's why we do not simply
6583   # omit the AC_SUBST.)
6584   $owner = VAR_AUTOMAKE if $var eq 'ANSI2KNR';
6585
6586   Automake::Variable::define ($var, $owner, '', TRUE, subst $var,
6587                               '', $configure_vars{$var}, $pretty);
6588 }
6589
6590
6591 # define_compiler_variable ($LANG)
6592 # --------------------------------
6593 # Define a compiler variable.  We also handle defining the `LT'
6594 # version of the command when using libtool.
6595 sub define_compiler_variable ($)
6596 {
6597     my ($lang) = @_;
6598
6599     my ($var, $value) = ($lang->compiler, $lang->compile);
6600     my $libtool_tag = '';
6601     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6602       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6603     &define_variable ($var, $value, INTERNAL);
6604     if (var ('LIBTOOL'))
6605       {
6606         my $verbose = define_verbose_libtool ();
6607         &define_variable ("LT$var",
6608                           "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6609                           . "\$(LIBTOOLFLAGS) --mode=compile $value",
6610                           INTERNAL);
6611       }
6612     define_verbose_tagvar ($lang->ccer || 'GEN');
6613 }
6614
6615
6616 # define_linker_variable ($LANG)
6617 # ------------------------------
6618 # Define linker variables.
6619 sub define_linker_variable ($)
6620 {
6621     my ($lang) = @_;
6622
6623     my $libtool_tag = '';
6624     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6625       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6626     # CCLD = $(CC).
6627     &define_variable ($lang->lder, $lang->ld, INTERNAL);
6628     # CCLINK = $(CCLD) blah blah...
6629     my $link = '';
6630     if (var ('LIBTOOL'))
6631       {
6632         my $verbose = define_verbose_libtool ();
6633         $link = "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6634                 . "\$(LIBTOOLFLAGS) --mode=link ";
6635       }
6636     &define_variable ($lang->linker, $link . $lang->link, INTERNAL);
6637     &define_variable ($lang->compiler,  $lang);
6638     &define_verbose_tagvar ($lang->lder || 'GEN');
6639 }
6640
6641 sub define_per_target_linker_variable ($$)
6642 {
6643   my ($linker, $target) = @_;
6644
6645   # If the user wrote a custom link command, we don't define ours.
6646   return "${target}_LINK"
6647     if set_seen "${target}_LINK";
6648
6649   my $xlink = $linker ? $linker : 'LINK';
6650
6651   my $lang = $link_languages{$xlink};
6652   prog_error "Unknown language for linker variable `$xlink'"
6653     unless $lang;
6654
6655   my $link_command = $lang->link;
6656   if (var 'LIBTOOL')
6657     {
6658       my $libtool_tag = '';
6659       $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6660         if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6661
6662       my $verbose = define_verbose_libtool ();
6663       $link_command =
6664         "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) \$(LIBTOOLFLAGS) "
6665         . "--mode=link " . $link_command;
6666     }
6667
6668   # Rewrite each occurrence of `AM_$flag' in the link
6669   # command into `${derived}_$flag' if it exists.
6670   my $orig_command = $link_command;
6671   my @flags = (@{$lang->flags}, 'LDFLAGS');
6672   push @flags, 'LIBTOOLFLAGS' if var 'LIBTOOL';
6673   for my $flag (@flags)
6674     {
6675       my $val = "${target}_$flag";
6676       $link_command =~ s/\(AM_$flag\)/\($val\)/
6677         if set_seen ($val);
6678     }
6679
6680   # If the computed command is the same as the generic command, use
6681   # the command linker variable.
6682   return ($lang->linker, $lang->lder)
6683     if $link_command eq $orig_command;
6684
6685   &define_variable ("${target}_LINK", $link_command, INTERNAL);
6686   return ("${target}_LINK", $lang->lder);
6687 }
6688
6689 ################################################################
6690
6691 # &check_trailing_slash ($WHERE, $LINE)
6692 # -------------------------------------
6693 # Return 1 iff $LINE ends with a slash.
6694 # Might modify $LINE.
6695 sub check_trailing_slash ($\$)
6696 {
6697   my ($where, $line) = @_;
6698
6699   # Ignore `##' lines.
6700   return 0 if $$line =~ /$IGNORE_PATTERN/o;
6701
6702   # Catch and fix a common error.
6703   msg "syntax", $where, "whitespace following trailing backslash"
6704     if $$line =~ s/\\\s+\n$/\\\n/;
6705
6706   return $$line =~ /\\$/;
6707 }
6708
6709
6710 # &read_am_file ($AMFILE, $WHERE)
6711 # -------------------------------
6712 # Read Makefile.am and set up %contents.  Simultaneously copy lines
6713 # from Makefile.am into $output_trailer, or define variables as
6714 # appropriate.  NOTE we put rules in the trailer section.  We want
6715 # user rules to come after our generated stuff.
6716 sub read_am_file ($$)
6717 {
6718     my ($amfile, $where) = @_;
6719
6720     my $am_file = new Automake::XFile ("< $amfile");
6721     verb "reading $amfile";
6722
6723     # Keep track of the youngest output dependency.
6724     my $mtime = mtime $amfile;
6725     $output_deps_greatest_timestamp = $mtime
6726       if $mtime > $output_deps_greatest_timestamp;
6727
6728     my $spacing = '';
6729     my $comment = '';
6730     my $blank = 0;
6731     my $saw_bk = 0;
6732     my $var_look = VAR_ASIS;
6733
6734     use constant IN_VAR_DEF => 0;
6735     use constant IN_RULE_DEF => 1;
6736     use constant IN_COMMENT => 2;
6737     my $prev_state = IN_RULE_DEF;
6738
6739     while ($_ = $am_file->getline)
6740     {
6741         $where->set ("$amfile:$.");
6742         if (/$IGNORE_PATTERN/o)
6743         {
6744             # Merely delete comments beginning with two hashes.
6745         }
6746         elsif (/$WHITE_PATTERN/o)
6747         {
6748             error $where, "blank line following trailing backslash"
6749               if $saw_bk;
6750             # Stick a single white line before the incoming macro or rule.
6751             $spacing = "\n";
6752             $blank = 1;
6753             # Flush all comments seen so far.
6754             if ($comment ne '')
6755             {
6756                 $output_vars .= $comment;
6757                 $comment = '';
6758             }
6759         }
6760         elsif (/$COMMENT_PATTERN/o)
6761         {
6762             # Stick comments before the incoming macro or rule.  Make
6763             # sure a blank line precedes the first block of comments.
6764             $spacing = "\n" unless $blank;
6765             $blank = 1;
6766             $comment .= $spacing . $_;
6767             $spacing = '';
6768             $prev_state = IN_COMMENT;
6769         }
6770         else
6771         {
6772             last;
6773         }
6774         $saw_bk = check_trailing_slash ($where, $_);
6775     }
6776
6777     # We save the conditional stack on entry, and then check to make
6778     # sure it is the same on exit.  This lets us conditionally include
6779     # other files.
6780     my @saved_cond_stack = @cond_stack;
6781     my $cond = new Automake::Condition (@cond_stack);
6782
6783     my $last_var_name = '';
6784     my $last_var_type = '';
6785     my $last_var_value = '';
6786     my $last_where;
6787     # FIXME: shouldn't use $_ in this loop; it is too big.
6788     while ($_)
6789     {
6790         $where->set ("$amfile:$.");
6791
6792         # Make sure the line is \n-terminated.
6793         chomp;
6794         $_ .= "\n";
6795
6796         # Don't look at MAINTAINER_MODE_TRUE here.  That shouldn't be
6797         # used by users.  @MAINT@ is an anachronism now.
6798         $_ =~ s/\@MAINT\@//g
6799             unless $seen_maint_mode;
6800
6801         my $new_saw_bk = check_trailing_slash ($where, $_);
6802
6803         if (/$IGNORE_PATTERN/o)
6804         {
6805             # Merely delete comments beginning with two hashes.
6806
6807             # Keep any backslash from the previous line.
6808             $new_saw_bk = $saw_bk;
6809         }
6810         elsif (/$WHITE_PATTERN/o)
6811         {
6812             # Stick a single white line before the incoming macro or rule.
6813             $spacing = "\n";
6814             error $where, "blank line following trailing backslash"
6815               if $saw_bk;
6816         }
6817         elsif (/$COMMENT_PATTERN/o)
6818         {
6819             error $where, "comment following trailing backslash"
6820               if $saw_bk && $prev_state != IN_COMMENT;
6821
6822             # Stick comments before the incoming macro or rule.
6823             $comment .= $spacing . $_;
6824             $spacing = '';
6825             $prev_state = IN_COMMENT;
6826         }
6827         elsif ($saw_bk)
6828         {
6829             if ($prev_state == IN_RULE_DEF)
6830             {
6831               my $cond = new Automake::Condition @cond_stack;
6832               $output_trailer .= $cond->subst_string;
6833               $output_trailer .= $_;
6834             }
6835             elsif ($prev_state == IN_COMMENT)
6836             {
6837                 # If the line doesn't start with a `#', add it.
6838                 # We do this because a continued comment like
6839                 #   # A = foo \
6840                 #         bar \
6841                 #         baz
6842                 # is not portable.  BSD make doesn't honor
6843                 # escaped newlines in comments.
6844                 s/^#?/#/;
6845                 $comment .= $spacing . $_;
6846             }
6847             else # $prev_state == IN_VAR_DEF
6848             {
6849               $last_var_value .= ' '
6850                 unless $last_var_value =~ /\s$/;
6851               $last_var_value .= $_;
6852
6853               if (!/\\$/)
6854                 {
6855                   Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6856                                               $last_var_type, $cond,
6857                                               $last_var_value, $comment,
6858                                               $last_where, VAR_ASIS)
6859                     if $cond != FALSE;
6860                   $comment = $spacing = '';
6861                 }
6862             }
6863         }
6864
6865         elsif (/$IF_PATTERN/o)
6866           {
6867             $cond = cond_stack_if ($1, $2, $where);
6868           }
6869         elsif (/$ELSE_PATTERN/o)
6870           {
6871             $cond = cond_stack_else ($1, $2, $where);
6872           }
6873         elsif (/$ENDIF_PATTERN/o)
6874           {
6875             $cond = cond_stack_endif ($1, $2, $where);
6876           }
6877
6878         elsif (/$RULE_PATTERN/o)
6879         {
6880             # Found a rule.
6881             $prev_state = IN_RULE_DEF;
6882
6883             # For now we have to output all definitions of user rules
6884             # and can't diagnose duplicates (see the comment in
6885             # Automake::Rule::define). So we go on and ignore the return value.
6886             Automake::Rule::define ($1, $amfile, RULE_USER, $cond, $where);
6887
6888             check_variable_expansions ($_, $where);
6889
6890             $output_trailer .= $comment . $spacing;
6891             my $cond = new Automake::Condition @cond_stack;
6892             $output_trailer .= $cond->subst_string;
6893             $output_trailer .= $_;
6894             $comment = $spacing = '';
6895         }
6896         elsif (/$ASSIGNMENT_PATTERN/o)
6897         {
6898             # Found a macro definition.
6899             $prev_state = IN_VAR_DEF;
6900             $last_var_name = $1;
6901             $last_var_type = $2;
6902             $last_var_value = $3;
6903             $last_where = $where->clone;
6904             if ($3 ne '' && substr ($3, -1) eq "\\")
6905               {
6906                 # We preserve the `\' because otherwise the long lines
6907                 # that are generated will be truncated by broken
6908                 # `sed's.
6909                 $last_var_value = $3 . "\n";
6910               }
6911             # Normally we try to output variable definitions in the
6912             # same format they were input.  However, POSIX compliant
6913             # systems are not required to support lines longer than
6914             # 2048 bytes (most notably, some sed implementation are
6915             # limited to 4000 bytes, and sed is used by config.status
6916             # to rewrite Makefile.in into Makefile).  Moreover nobody
6917             # would really write such long lines by hand since it is
6918             # hardly maintainable.  So if a line is longer that 1000
6919             # bytes (an arbitrary limit), assume it has been
6920             # automatically generated by some tools, and flatten the
6921             # variable definition.  Otherwise, keep the variable as it
6922             # as been input.
6923             $var_look = VAR_PRETTY if length ($last_var_value) >= 1000;
6924
6925             if (!/\\$/)
6926               {
6927                 Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6928                                             $last_var_type, $cond,
6929                                             $last_var_value, $comment,
6930                                             $last_where, $var_look)
6931                   if $cond != FALSE;
6932                 $comment = $spacing = '';
6933                 $var_look = VAR_ASIS;
6934               }
6935         }
6936         elsif (/$INCLUDE_PATTERN/o)
6937         {
6938             my $path = $1;
6939
6940             if ($path =~ s/^\$\(top_srcdir\)\///)
6941               {
6942                 push (@include_stack, "\$\(top_srcdir\)/$path");
6943                 # Distribute any included file.
6944
6945                 # Always use the $(top_srcdir) prefix in DIST_COMMON,
6946                 # otherwise OSF make will implicitly copy the included
6947                 # file in the build tree during `make distdir' to satisfy
6948                 # the dependency.
6949                 # (subdircond2.test and subdircond3.test will fail.)
6950                 push_dist_common ("\$\(top_srcdir\)/$path");
6951               }
6952             else
6953               {
6954                 $path =~ s/\$\(srcdir\)\///;
6955                 push (@include_stack, "\$\(srcdir\)/$path");
6956                 # Always use the $(srcdir) prefix in DIST_COMMON,
6957                 # otherwise OSF make will implicitly copy the included
6958                 # file in the build tree during `make distdir' to satisfy
6959                 # the dependency.
6960                 # (subdircond2.test and subdircond3.test will fail.)
6961                 push_dist_common ("\$\(srcdir\)/$path");
6962                 $path = $relative_dir . "/" . $path if $relative_dir ne '.';
6963               }
6964             $where->push_context ("`$path' included from here");
6965             &read_am_file ($path, $where);
6966             $where->pop_context;
6967         }
6968         else
6969         {
6970             # This isn't an error; it is probably a continued rule.
6971             # In fact, this is what we assume.
6972             $prev_state = IN_RULE_DEF;
6973             check_variable_expansions ($_, $where);
6974             $output_trailer .= $comment . $spacing;
6975             my $cond = new Automake::Condition @cond_stack;
6976             $output_trailer .= $cond->subst_string;
6977             $output_trailer .= $_;
6978             $comment = $spacing = '';
6979             error $where, "`#' comment at start of rule is unportable"
6980               if $_ =~ /^\t\s*\#/;
6981         }
6982
6983         $saw_bk = $new_saw_bk;
6984         $_ = $am_file->getline;
6985     }
6986
6987     $output_trailer .= $comment;
6988
6989     error ($where, "trailing backslash on last line")
6990       if $saw_bk;
6991
6992     error ($where, (@cond_stack ? "unterminated conditionals: @cond_stack"
6993                     : "too many conditionals closed in include file"))
6994       if "@saved_cond_stack" ne "@cond_stack";
6995 }
6996
6997
6998 # define_standard_variables ()
6999 # ----------------------------
7000 # A helper for read_main_am_file which initializes configure variables
7001 # and variables from header-vars.am.
7002 sub define_standard_variables
7003 {
7004   my $saved_output_vars = $output_vars;
7005   my ($comments, undef, $rules) =
7006     file_contents_internal (1, "$libdir/am/header-vars.am",
7007                             new Automake::Location);
7008
7009   foreach my $var (sort keys %configure_vars)
7010     {
7011       &define_configure_variable ($var);
7012     }
7013
7014   $output_vars .= $comments . $rules;
7015 }
7016
7017 # Read main am file.
7018 sub read_main_am_file
7019 {
7020     my ($amfile) = @_;
7021
7022     # This supports the strange variable tricks we are about to play.
7023     prog_error ("variable defined before read_main_am_file\n" . variables_dump ())
7024       if (scalar (variables) > 0);
7025
7026     # Generate copyright header for generated Makefile.in.
7027     # We do discard the output of predefined variables, handled below.
7028     $output_vars = ("# $in_file_name generated by automake "
7029                    . $VERSION . " from $am_file_name.\n");
7030     $output_vars .= '# ' . subst ('configure_input') . "\n";
7031     $output_vars .= $gen_copyright;
7032
7033     # We want to predefine as many variables as possible.  This lets
7034     # the user set them with `+=' in Makefile.am.
7035     &define_standard_variables;
7036
7037     # Read user file, which might override some of our values.
7038     &read_am_file ($amfile, new Automake::Location);
7039 }
7040
7041
7042
7043 ################################################################
7044
7045 # $FLATTENED
7046 # &flatten ($STRING)
7047 # ------------------
7048 # Flatten the $STRING and return the result.
7049 sub flatten
7050 {
7051   $_ = shift;
7052
7053   s/\\\n//somg;
7054   s/\s+/ /g;
7055   s/^ //;
7056   s/ $//;
7057
7058   return $_;
7059 }
7060
7061
7062 # transform_token ($TOKEN, \%PAIRS, $KEY)
7063 # =======================================
7064 # Return the value associated to $KEY in %PAIRS, as used on $TOKEN
7065 # (which should be ?KEY? or any of the special %% requests)..
7066 sub transform_token ($$$)
7067 {
7068   my ($token, $transform, $key) = @_;
7069   my $res = $transform->{$key};
7070   prog_error "Unknown key `$key' in `$token'" unless defined $res;
7071   return $res;
7072 }
7073
7074
7075 # transform ($TOKEN, \%PAIRS)
7076 # ===========================
7077 # If ($TOKEN, $VAL) is in %PAIRS:
7078 #   - replaces %KEY% with $VAL,
7079 #   - enables/disables ?KEY? and ?!KEY?,
7080 #   - replaces %?KEY% with TRUE or FALSE.
7081 #   - replaces %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE% with
7082 #     IFTRUE / IFFALSE, as appropriate.
7083 sub transform ($$)
7084 {
7085   my ($token, $transform) = @_;
7086
7087   # %KEY%.
7088   # Must be before the following pattern to exclude the case
7089   # when there is neither IFTRUE nor IFFALSE.
7090   if ($token =~ /^%([\w\-]+)%$/)
7091     {
7092       return transform_token ($token, $transform, $1);
7093     }
7094   # %KEY?IFTRUE%, %KEY:IFFALSE%, and %KEY?IFTRUE:IFFALSE%.
7095   elsif ($token =~ /^%([\w\-]+)(?:\?([^?:%]+))?(?::([^?:%]+))?%$/)
7096     {
7097       return transform_token ($token, $transform, $1) ? ($2 || '') : ($3 || '');
7098     }
7099   # %?KEY%.
7100   elsif ($token =~ /^%\?([\w\-]+)%$/)
7101     {
7102       return transform_token ($token, $transform, $1) ? 'TRUE' : 'FALSE';
7103     }
7104   # ?KEY? and ?!KEY?.
7105   elsif ($token =~ /^ \? (!?) ([\w\-]+) \? $/x)
7106     {
7107       my $neg = ($1 eq '!') ? 1 : 0;
7108       my $val = transform_token ($token, $transform, $2);
7109       return (!!$val == $neg) ? '##%' : '';
7110     }
7111   else
7112     {
7113       prog_error "Unknown request format: $token";
7114     }
7115 }
7116
7117
7118 # @PARAGRAPHS
7119 # &make_paragraphs ($MAKEFILE, [%TRANSFORM])
7120 # ------------------------------------------
7121 # Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
7122 # paragraphs.
7123 sub make_paragraphs ($%)
7124 {
7125   my ($file, %transform) = @_;
7126
7127   # Complete %transform with global options.
7128   # Note that %transform goes last, so it overrides global options.
7129   %transform = ('CYGNUS'      => !! option 'cygnus',
7130                  'MAINTAINER-MODE'
7131                  => $seen_maint_mode ? subst ('MAINTAINER_MODE_TRUE') : '',
7132
7133                  'XZ'          => !! option 'dist-xz',
7134                  'LZMA'        => !! option 'dist-lzma',
7135                  'LZIP'        => !! option 'dist-lzip',
7136                  'BZIP2'       => !! option 'dist-bzip2',
7137                  'COMPRESS'    => !! option 'dist-tarZ',
7138                  'GZIP'        =>  ! option 'no-dist-gzip',
7139                  'SHAR'        => !! option 'dist-shar',
7140                  'ZIP'         => !! option 'dist-zip',
7141
7142                  'INSTALL-INFO' =>  ! option 'no-installinfo',
7143                  'INSTALL-MAN'  =>  ! option 'no-installman',
7144                  'HAVE-MANS'    => !! var ('MANS'),
7145                  'CK-NEWS'      => !! option 'check-news',
7146
7147                  'SUBDIRS'      => !! var ('SUBDIRS'),
7148                  'TOPDIR_P'     => $relative_dir eq '.',
7149
7150                  'BUILD'    => ($seen_canonical >= AC_CANONICAL_BUILD),
7151                  'HOST'     => ($seen_canonical >= AC_CANONICAL_HOST),
7152                  'TARGET'   => ($seen_canonical >= AC_CANONICAL_TARGET),
7153
7154                  'LIBTOOL'      => !! var ('LIBTOOL'),
7155                  'NONLIBTOOL'   => 1,
7156                  'FIRST'        => ! $transformed_files{$file},
7157                 %transform);
7158
7159   $transformed_files{$file} = 1;
7160   $_ = $am_file_cache{$file};
7161
7162   if (! defined $_)
7163     {
7164       verb "reading $file";
7165       # Swallow the whole file.
7166       my $fc_file = new Automake::XFile "< $file";
7167       my $saved_dollar_slash = $/;
7168       undef $/;
7169       $_ = $fc_file->getline;
7170       $/ = $saved_dollar_slash;
7171       $fc_file->close;
7172
7173       # Remove ##-comments.
7174       # Besides we don't need more than two consecutive new-lines.
7175       s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
7176
7177       $am_file_cache{$file} = $_;
7178     }
7179
7180   # Substitute Automake template tokens.
7181   s/(?: % \?? [\w\-]+ %
7182       | % [\w\-]+ (?:\?[^?:%]+)? (?::[^?:%]+)? %
7183       | \? !? [\w\-]+ \?
7184     )/transform($&, \%transform)/gex;
7185   # transform() may have added some ##%-comments to strip.
7186   # (we use `##%' instead of `##' so we can distinguish ##%##%##% from
7187   # ####### and do not remove the latter.)
7188   s/^[ \t]*(?:##%)+.*\n//gm;
7189
7190   # Split at unescaped new lines.
7191   my @lines = split (/(?<!\\)\n/, $_);
7192   my @res;
7193
7194   while (defined ($_ = shift @lines))
7195     {
7196       my $paragraph = $_;
7197       # If we are a rule, eat as long as we start with a tab.
7198       if (/$RULE_PATTERN/smo)
7199         {
7200           while (defined ($_ = shift @lines) && $_ =~ /^\t/)
7201             {
7202               $paragraph .= "\n$_";
7203             }
7204           unshift (@lines, $_);
7205         }
7206
7207       # If we are a comments, eat as much comments as you can.
7208       elsif (/$COMMENT_PATTERN/smo)
7209         {
7210           while (defined ($_ = shift @lines)
7211                  && $_ =~ /$COMMENT_PATTERN/smo)
7212             {
7213               $paragraph .= "\n$_";
7214             }
7215           unshift (@lines, $_);
7216         }
7217
7218       push @res, $paragraph;
7219     }
7220
7221   return @res;
7222 }
7223
7224
7225
7226 # ($COMMENT, $VARIABLES, $RULES)
7227 # &file_contents_internal ($IS_AM, $FILE, $WHERE, [%TRANSFORM])
7228 # -------------------------------------------------------------
7229 # Return contents of a file from $libdir/am, automatically skipping
7230 # macros or rules which are already known. $IS_AM iff the caller is
7231 # reading an Automake file (as opposed to the user's Makefile.am).
7232 sub file_contents_internal ($$$%)
7233 {
7234     my ($is_am, $file, $where, %transform) = @_;
7235
7236     $where->set ($file);
7237
7238     my $result_vars = '';
7239     my $result_rules = '';
7240     my $comment = '';
7241     my $spacing = '';
7242
7243     # The following flags are used to track rules spanning across
7244     # multiple paragraphs.
7245     my $is_rule = 0;            # 1 if we are processing a rule.
7246     my $discard_rule = 0;       # 1 if the current rule should not be output.
7247
7248     # We save the conditional stack on entry, and then check to make
7249     # sure it is the same on exit.  This lets us conditionally include
7250     # other files.
7251     my @saved_cond_stack = @cond_stack;
7252     my $cond = new Automake::Condition (@cond_stack);
7253
7254     foreach (make_paragraphs ($file, %transform))
7255     {
7256         # FIXME: no line number available.
7257         $where->set ($file);
7258
7259         # Sanity checks.
7260         error $where, "blank line following trailing backslash:\n$_"
7261           if /\\$/;
7262         error $where, "comment following trailing backslash:\n$_"
7263           if /\\#/;
7264
7265         if (/^$/)
7266         {
7267             $is_rule = 0;
7268             # Stick empty line before the incoming macro or rule.
7269             $spacing = "\n";
7270         }
7271         elsif (/$COMMENT_PATTERN/mso)
7272         {
7273             $is_rule = 0;
7274             # Stick comments before the incoming macro or rule.
7275             $comment = "$_\n";
7276         }
7277
7278         # Handle inclusion of other files.
7279         elsif (/$INCLUDE_PATTERN/o)
7280         {
7281             if ($cond != FALSE)
7282               {
7283                 my $file = ($is_am ? "$libdir/am/" : '') . $1;
7284                 $where->push_context ("`$file' included from here");
7285                 # N-ary `.=' fails.
7286                 my ($com, $vars, $rules)
7287                   = file_contents_internal ($is_am, $file, $where, %transform);
7288                 $where->pop_context;
7289                 $comment .= $com;
7290                 $result_vars .= $vars;
7291                 $result_rules .= $rules;
7292               }
7293         }
7294
7295         # Handling the conditionals.
7296         elsif (/$IF_PATTERN/o)
7297           {
7298             $cond = cond_stack_if ($1, $2, $file);
7299           }
7300         elsif (/$ELSE_PATTERN/o)
7301           {
7302             $cond = cond_stack_else ($1, $2, $file);
7303           }
7304         elsif (/$ENDIF_PATTERN/o)
7305           {
7306             $cond = cond_stack_endif ($1, $2, $file);
7307           }
7308
7309         # Handling rules.
7310         elsif (/$RULE_PATTERN/mso)
7311         {
7312           $is_rule = 1;
7313           $discard_rule = 0;
7314           # Separate relationship from optional actions: the first
7315           # `new-line tab" not preceded by backslash (continuation
7316           # line).
7317           my $paragraph = $_;
7318           /^(.*?)(?:(?<!\\)\n(\t.*))?$/s;
7319           my ($relationship, $actions) = ($1, $2 || '');
7320
7321           # Separate targets from dependencies: the first colon.
7322           $relationship =~ /^([^:]+\S+) *: *(.*)$/som;
7323           my ($targets, $dependencies) = ($1, $2);
7324           # Remove the escaped new lines.
7325           # I don't know why, but I have to use a tmp $flat_deps.
7326           my $flat_deps = &flatten ($dependencies);
7327           my @deps = split (' ', $flat_deps);
7328
7329           foreach (split (' ', $targets))
7330             {
7331               # FIXME: 1. We are not robust to people defining several targets
7332               # at once, only some of them being in %dependencies.  The
7333               # actions from the targets in %dependencies are usually generated
7334               # from the content of %actions, but if some targets in $targets
7335               # are not in %dependencies the ELSE branch will output
7336               # a rule for all $targets (i.e. the targets which are both
7337               # in %dependencies and $targets will have two rules).
7338
7339               # FIXME: 2. The logic here is not able to output a
7340               # multi-paragraph rule several time (e.g. for each condition
7341               # it is defined for) because it only knows the first paragraph.
7342
7343               # FIXME: 3. We are not robust to people defining a subset
7344               # of a previously defined "multiple-target" rule.  E.g.
7345               # `foo:' after `foo bar:'.
7346
7347               # Output only if not in FALSE.
7348               if (defined $dependencies{$_} && $cond != FALSE)
7349                 {
7350                   &depend ($_, @deps);
7351                   register_action ($_, $actions);
7352                 }
7353               else
7354                 {
7355                   # Free-lance dependency.  Output the rule for all the
7356                   # targets instead of one by one.
7357                   my @undefined_conds =
7358                     Automake::Rule::define ($targets, $file,
7359                                             $is_am ? RULE_AUTOMAKE : RULE_USER,
7360                                             $cond, $where);
7361                   for my $undefined_cond (@undefined_conds)
7362                     {
7363                       my $condparagraph = $paragraph;
7364                       $condparagraph =~ s/^/$undefined_cond->subst_string/gme;
7365                       $result_rules .= "$spacing$comment$condparagraph\n";
7366                     }
7367                   if (scalar @undefined_conds == 0)
7368                     {
7369                       # Remember to discard next paragraphs
7370                       # if they belong to this rule.
7371                       # (but see also FIXME: #2 above.)
7372                       $discard_rule = 1;
7373                     }
7374                   $comment = $spacing = '';
7375                   last;
7376                 }
7377             }
7378         }
7379
7380         elsif (/$ASSIGNMENT_PATTERN/mso)
7381         {
7382             my ($var, $type, $val) = ($1, $2, $3);
7383             error $where, "variable `$var' with trailing backslash"
7384               if /\\$/;
7385
7386             $is_rule = 0;
7387
7388             Automake::Variable::define ($var,
7389                                         $is_am ? VAR_AUTOMAKE : VAR_MAKEFILE,
7390                                         $type, $cond, $val, $comment, $where,
7391                                         VAR_ASIS)
7392               if $cond != FALSE;
7393
7394             $comment = $spacing = '';
7395         }
7396         else
7397         {
7398             # This isn't an error; it is probably some tokens which
7399             # configure is supposed to replace, such as `@SET-MAKE@',
7400             # or some part of a rule cut by an if/endif.
7401             if (! $cond->false && ! ($is_rule && $discard_rule))
7402               {
7403                 s/^/$cond->subst_string/gme;
7404                 $result_rules .= "$spacing$comment$_\n";
7405               }
7406             $comment = $spacing = '';
7407         }
7408     }
7409
7410     error ($where, @cond_stack ?
7411            "unterminated conditionals: @cond_stack" :
7412            "too many conditionals closed in include file")
7413       if "@saved_cond_stack" ne "@cond_stack";
7414
7415     return ($comment, $result_vars, $result_rules);
7416 }
7417
7418
7419 # $CONTENTS
7420 # &file_contents ($BASENAME, $WHERE, [%TRANSFORM])
7421 # ------------------------------------------------
7422 # Return contents of a file from $libdir/am, automatically skipping
7423 # macros or rules which are already known.
7424 sub file_contents ($$%)
7425 {
7426     my ($basename, $where, %transform) = @_;
7427     my ($comments, $variables, $rules) =
7428       file_contents_internal (1, "$libdir/am/$basename.am", $where,
7429                               %transform);
7430     return "$comments$variables$rules";
7431 }
7432
7433
7434 # @PREFIX
7435 # &am_primary_prefixes ($PRIMARY, $CAN_DIST, @PREFIXES)
7436 # -----------------------------------------------------
7437 # Find all variable prefixes that are used for install directories.  A
7438 # prefix `zar' qualifies iff:
7439 #
7440 # * `zardir' is a variable.
7441 # * `zar_PRIMARY' is a variable.
7442 #
7443 # As a side effect, it looks for misspellings.  It is an error to have
7444 # a variable ending in a "reserved" suffix whose prefix is unknown, e.g.
7445 # "bni_PROGRAMS".  However, unusual prefixes are allowed if a variable
7446 # of the same name (with "dir" appended) exists.  For instance, if the
7447 # variable "zardir" is defined, then "zar_PROGRAMS" becomes valid.
7448 # This is to provide a little extra flexibility in those cases which
7449 # need it.
7450 sub am_primary_prefixes ($$@)
7451 {
7452   my ($primary, $can_dist, @prefixes) = @_;
7453
7454   local $_;
7455   my %valid = map { $_ => 0 } @prefixes;
7456   $valid{'EXTRA'} = 0;
7457   foreach my $var (variables $primary)
7458     {
7459       # Automake is allowed to define variables that look like primaries
7460       # but which aren't.  E.g. INSTALL_sh_DATA.
7461       # Autoconf can also define variables like INSTALL_DATA, so
7462       # ignore all configure variables (at least those which are not
7463       # redefined in Makefile.am).
7464       # FIXME: We should make sure that these variables are not
7465       # conditionally defined (or else adjust the condition below).
7466       my $def = $var->def (TRUE);
7467       next if $def && $def->owner != VAR_MAKEFILE;
7468
7469       my $varname = $var->name;
7470
7471       if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_[[:alnum:]]+$/)
7472         {
7473           my ($base, $dist, $X) = ($1 || '', $2 || '', $3 || '');
7474           if ($dist ne '' && ! $can_dist)
7475             {
7476               err_var ($var,
7477                        "invalid variable `$varname': `dist' is forbidden");
7478             }
7479           # Standard directories must be explicitly allowed.
7480           elsif (! defined $valid{$X} && exists $standard_prefix{$X})
7481             {
7482               err_var ($var,
7483                        "`${X}dir' is not a legitimate directory " .
7484                        "for `$primary'");
7485             }
7486           # A not explicitly valid directory is allowed if Xdir is defined.
7487           elsif (! defined $valid{$X} &&
7488                  $var->requires_variables ("`$varname' is used", "${X}dir"))
7489             {
7490               # Nothing to do.  Any error message has been output
7491               # by $var->requires_variables.
7492             }
7493           else
7494             {
7495               # Ensure all extended prefixes are actually used.
7496               $valid{"$base$dist$X"} = 1;
7497             }
7498         }
7499       else
7500         {
7501           prog_error "unexpected variable name: $varname";
7502         }
7503     }
7504
7505   # Return only those which are actually defined.
7506   return sort grep { var ($_ . '_' . $primary) } keys %valid;
7507 }
7508
7509
7510 # Handle `where_HOW' variable magic.  Does all lookups, generates
7511 # install code, and possibly generates code to define the primary
7512 # variable.  The first argument is the name of the .am file to munge,
7513 # the second argument is the primary variable (e.g. HEADERS), and all
7514 # subsequent arguments are possible installation locations.
7515 #
7516 # Returns list of [$location, $value] pairs, where
7517 # $value's are the values in all where_HOW variable, and $location
7518 # there associated location (the place here their parent variables were
7519 # defined).
7520 #
7521 # FIXME: this should be rewritten to be cleaner.  It should be broken
7522 # up into multiple functions.
7523 #
7524 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7525 sub am_install_var
7526 {
7527   my (@args) = @_;
7528
7529   my $do_require = 1;
7530   my $can_dist = 0;
7531   my $default_dist = 0;
7532   while (@args)
7533     {
7534       if ($args[0] eq '-noextra')
7535         {
7536           $do_require = 0;
7537         }
7538       elsif ($args[0] eq '-candist')
7539         {
7540           $can_dist = 1;
7541         }
7542       elsif ($args[0] eq '-defaultdist')
7543         {
7544           $default_dist = 1;
7545           $can_dist = 1;
7546         }
7547       elsif ($args[0] !~ /^-/)
7548         {
7549           last;
7550         }
7551       shift (@args);
7552     }
7553
7554   my ($file, $primary, @prefix) = @args;
7555
7556   # Now that configure substitutions are allowed in where_HOW
7557   # variables, it is an error to actually define the primary.  We
7558   # allow `JAVA', as it is customarily used to mean the Java
7559   # interpreter.  This is but one of several Java hacks.  Similarly,
7560   # `PYTHON' is customarily used to mean the Python interpreter.
7561   reject_var $primary, "`$primary' is an anachronism"
7562     unless $primary eq 'JAVA' || $primary eq 'PYTHON';
7563
7564   # Get the prefixes which are valid and actually used.
7565   @prefix = am_primary_prefixes ($primary, $can_dist, @prefix);
7566
7567   # If a primary includes a configure substitution, then the EXTRA_
7568   # form is required.  Otherwise we can't properly do our job.
7569   my $require_extra;
7570
7571   my @used = ();
7572   my @result = ();
7573
7574   foreach my $X (@prefix)
7575     {
7576       my $nodir_name = $X;
7577       my $one_name = $X . '_' . $primary;
7578       my $one_var = var $one_name;
7579
7580       my $strip_subdir = 1;
7581       # If subdir prefix should be preserved, do so.
7582       if ($nodir_name =~ /^nobase_/)
7583         {
7584           $strip_subdir = 0;
7585           $nodir_name =~ s/^nobase_//;
7586         }
7587
7588       # If files should be distributed, do so.
7589       my $dist_p = 0;
7590       if ($can_dist)
7591         {
7592           $dist_p = (($default_dist && $nodir_name !~ /^nodist_/)
7593                      || (! $default_dist && $nodir_name =~ /^dist_/));
7594           $nodir_name =~ s/^(dist|nodist)_//;
7595         }
7596
7597
7598       # Use the location of the currently processed variable.
7599       # We are not processing a particular condition, so pick the first
7600       # available.
7601       my $tmpcond = $one_var->conditions->one_cond;
7602       my $where = $one_var->rdef ($tmpcond)->location->clone;
7603
7604       # Append actual contents of where_PRIMARY variable to
7605       # @result, skipping @substitutions@.
7606       foreach my $locvals ($one_var->value_as_list_recursive (location => 1))
7607         {
7608           my ($loc, $value) = @$locvals;
7609           # Skip configure substitutions.
7610           if ($value =~ /^\@.*\@$/)
7611             {
7612               if ($nodir_name eq 'EXTRA')
7613                 {
7614                   error ($where,
7615                          "`$one_name' contains configure substitution, "
7616                          . "but shouldn't");
7617                 }
7618               # Check here to make sure variables defined in
7619               # configure.ac do not imply that EXTRA_PRIMARY
7620               # must be defined.
7621               elsif (! defined $configure_vars{$one_name})
7622                 {
7623                   $require_extra = $one_name
7624                     if $do_require;
7625                 }
7626             }
7627           else
7628             {
7629               # Strip any $(EXEEXT) suffix the user might have added, or this
7630               # will confuse &handle_source_transform and &check_canonical_spelling.
7631               # We'll add $(EXEEXT) back later anyway.
7632               # Do it here rather than in handle_programs so the uniquifying at the
7633               # end of this function works.
7634               ${$locvals}[1] =~ s/\$\(EXEEXT\)$//
7635                 if $primary eq 'PROGRAMS';
7636
7637               push (@result, $locvals);
7638             }
7639         }
7640       # A blatant hack: we rewrite each _PROGRAMS primary to include
7641       # EXEEXT.
7642       append_exeext { 1 } $one_name
7643         if $primary eq 'PROGRAMS';
7644       # "EXTRA" shouldn't be used when generating clean targets,
7645       # all, or install targets.  We used to warn if EXTRA_FOO was
7646       # defined uselessly, but this was annoying.
7647       next
7648         if $nodir_name eq 'EXTRA';
7649
7650       if ($nodir_name eq 'check')
7651         {
7652           push (@check, '$(' . $one_name . ')');
7653         }
7654       else
7655         {
7656           push (@used, '$(' . $one_name . ')');
7657         }
7658
7659       # Is this to be installed?
7660       my $install_p = $nodir_name ne 'noinst' && $nodir_name ne 'check';
7661
7662       # If so, with install-exec? (or install-data?).
7663       my $exec_p = ($nodir_name =~ /$EXEC_DIR_PATTERN/o);
7664
7665       my $check_options_p = $install_p && !! option 'std-options';
7666
7667       # Use the location of the currently processed variable as context.
7668       $where->push_context ("while processing `$one_name'");
7669
7670       # The variable containing all files to distribute.
7671       my $distvar = "\$($one_name)";
7672       $distvar = shadow_unconditionally ($one_name, $where)
7673         if ($dist_p && $one_var->has_conditional_contents);
7674
7675       # Singular form of $PRIMARY.
7676       (my $one_primary = $primary) =~ s/S$//;
7677       $output_rules .= &file_contents ($file, $where,
7678                                        PRIMARY     => $primary,
7679                                        ONE_PRIMARY => $one_primary,
7680                                        DIR         => $X,
7681                                        NDIR        => $nodir_name,
7682                                        BASE        => $strip_subdir,
7683
7684                                        EXEC      => $exec_p,
7685                                        INSTALL   => $install_p,
7686                                        DIST      => $dist_p,
7687                                        DISTVAR   => $distvar,
7688                                        'CK-OPTS' => $check_options_p);
7689     }
7690
7691   # The JAVA variable is used as the name of the Java interpreter.
7692   # The PYTHON variable is used as the name of the Python interpreter.
7693   if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7694     {
7695       # Define it.
7696       define_pretty_variable ($primary, TRUE, INTERNAL, @used);
7697       $output_vars .= "\n";
7698     }
7699
7700   err_var ($require_extra,
7701            "`$require_extra' contains configure substitution,\n"
7702            . "but `EXTRA_$primary' not defined")
7703     if ($require_extra && ! var ('EXTRA_' . $primary));
7704
7705   # Push here because PRIMARY might be configure time determined.
7706   push (@all, '$(' . $primary . ')')
7707     if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7708
7709   # Make the result unique.  This lets the user use conditionals in
7710   # a natural way, but still lets us program lazily -- we don't have
7711   # to worry about handling a particular object more than once.
7712   # We will keep only one location per object.
7713   my %result = ();
7714   for my $pair (@result)
7715     {
7716       my ($loc, $val) = @$pair;
7717       $result{$val} = $loc;
7718     }
7719   my @l = sort keys %result;
7720   return map { [$result{$_}->clone, $_] } @l;
7721 }
7722
7723
7724 ################################################################
7725
7726 # Each key in this hash is the name of a directory holding a
7727 # Makefile.in.  These variables are local to `is_make_dir'.
7728 my %make_dirs = ();
7729 my $make_dirs_set = 0;
7730
7731 sub is_make_dir
7732 {
7733     my ($dir) = @_;
7734     if (! $make_dirs_set)
7735     {
7736         foreach my $iter (@configure_input_files)
7737         {
7738             $make_dirs{dirname ($iter)} = 1;
7739         }
7740         # We also want to notice Makefile.in's.
7741         foreach my $iter (@other_input_files)
7742         {
7743             if ($iter =~ /Makefile\.in$/)
7744             {
7745                 $make_dirs{dirname ($iter)} = 1;
7746             }
7747         }
7748         $make_dirs_set = 1;
7749     }
7750     return defined $make_dirs{$dir};
7751 }
7752
7753 ################################################################
7754
7755 # Find the aux dir.  This should match the algorithm used by
7756 # ./configure. (See the Autoconf documentation for for
7757 # AC_CONFIG_AUX_DIR.)
7758 sub locate_aux_dir ()
7759 {
7760   if (! $config_aux_dir_set_in_configure_ac)
7761     {
7762       # The default auxiliary directory is the first
7763       # of ., .., or ../.. that contains install-sh.
7764       # Assume . if install-sh doesn't exist yet.
7765       for my $dir (qw (. .. ../..))
7766         {
7767           if (-f "$dir/install-sh")
7768             {
7769               $config_aux_dir = $dir;
7770               last;
7771             }
7772         }
7773       $config_aux_dir = '.' unless $config_aux_dir;
7774     }
7775   # Avoid unsightly '/.'s.
7776   $am_config_aux_dir =
7777     '$(top_srcdir)' . ($config_aux_dir eq '.' ? "" : "/$config_aux_dir");
7778   $am_config_aux_dir =~ s,/*$,,;
7779 }
7780
7781
7782 # &maybe_push_required_file ($DIR, $FILE, $FULLFILE)
7783 # --------------------------------------------------
7784 # See if we want to push this file onto dist_common.  This function
7785 # encodes the rules for deciding when to do so.
7786 sub maybe_push_required_file
7787 {
7788   my ($dir, $file, $fullfile) = @_;
7789
7790   if ($dir eq $relative_dir)
7791     {
7792       push_dist_common ($file);
7793       return 1;
7794     }
7795   elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7796     {
7797       # If we are doing the topmost directory, and the file is in a
7798       # subdir which does not have a Makefile, then we distribute it
7799       # here.
7800
7801       # If a required file is above the source tree, it is important
7802       # to prefix it with `$(srcdir)' so that no VPATH search is
7803       # performed.  Otherwise problems occur with Make implementations
7804       # that rewrite and simplify rules whose dependencies are found in a
7805       # VPATH location.  Here is an example with OSF1/Tru64 Make.
7806       #
7807       #   % cat Makefile
7808       #   VPATH = sub
7809       #   distdir: ../a
7810       #           echo ../a
7811       #   % ls
7812       #   Makefile a
7813       #   % make
7814       #   echo a
7815       #   a
7816       #
7817       # Dependency `../a' was found in `sub/../a', but this make
7818       # implementation simplified it as `a'.  (Note that the sub/
7819       # directory does not even exist.)
7820       #
7821       # This kind of VPATH rewriting seems hard to cancel.  The
7822       # distdir.am hack against VPATH rewriting works only when no
7823       # simplification is done, i.e., for dependencies which are in
7824       # subdirectories, not in enclosing directories.  Hence, in
7825       # the latter case we use a full path to make sure no VPATH
7826       # search occurs.
7827       $fullfile = '$(srcdir)/' . $fullfile
7828         if $dir =~ m,^\.\.(?:$|/),;
7829
7830       push_dist_common ($fullfile);
7831       return 1;
7832     }
7833   return 0;
7834 }
7835
7836
7837 # If a file name appears as a key in this hash, then it has already
7838 # been checked for.  This allows us not to report the same error more
7839 # than once.
7840 my %required_file_not_found = ();
7841
7842 # &require_file_internal ($WHERE, $MYSTRICT, $DIRECTORY, @FILES)
7843 # --------------------------------------------------------------
7844 # Verify that the file must exist in $DIRECTORY, or install it.
7845 # $MYSTRICT is the strictness level at which this file becomes required.
7846 sub require_file_internal ($$$@)
7847 {
7848   my ($where, $mystrict, $dir, @files) = @_;
7849
7850   foreach my $file (@files)
7851     {
7852       my $fullfile = "$dir/$file";
7853       my $found_it = 0;
7854       my $dangling_sym = 0;
7855
7856       if (-l $fullfile && ! -f $fullfile)
7857         {
7858           $dangling_sym = 1;
7859         }
7860       elsif (dir_has_case_matching_file ($dir, $file))
7861         {
7862           $found_it = 1;
7863           maybe_push_required_file ($dir, $file, $fullfile);
7864         }
7865
7866       # `--force-missing' only has an effect if `--add-missing' is
7867       # specified.
7868       if ($found_it && (! $add_missing || ! $force_missing))
7869         {
7870           next;
7871         }
7872       else
7873         {
7874           # If we've already looked for it, we're done.  You might
7875           # wonder why we don't do this before searching for the
7876           # file.  If we do that, then something like
7877           # AC_OUTPUT(subdir/foo foo) will fail to put foo.in into
7878           # DIST_COMMON.
7879           if (! $found_it)
7880             {
7881               next if defined $required_file_not_found{$fullfile};
7882               $required_file_not_found{$fullfile} = 1;
7883             }
7884
7885           if ($strictness >= $mystrict)
7886             {
7887               if ($dangling_sym && $add_missing)
7888                 {
7889                   unlink ($fullfile);
7890                 }
7891
7892               my $trailer = '';
7893               my $trailer2 = '';
7894               my $suppress = 0;
7895
7896               # Only install missing files according to our desired
7897               # strictness level.
7898               my $message = "required file `$fullfile' not found";
7899               if ($add_missing)
7900                 {
7901                   if (-f "$libdir/$file")
7902                     {
7903                       $suppress = 1;
7904
7905                       # Install the missing file.  Symlink if we
7906                       # can, copy if we must.  Note: delete the file
7907                       # first, in case it is a dangling symlink.
7908                       $message = "installing `$fullfile'";
7909
7910                       # The license file should not be volatile.
7911                       if ($file eq "COPYING")
7912                         {
7913                           $message .= " using GNU General Public License v3 file";
7914                           $trailer2 = "\n    Consider adding the COPYING file"
7915                                     . " to the version control system"
7916                                     . "\n    for your code, to avoid questions"
7917                                     . " about which license your project uses.";
7918                         }
7919
7920                       # Windows Perl will hang if we try to delete a
7921                       # file that doesn't exist.
7922                       unlink ($fullfile) if -f $fullfile;
7923                       if ($symlink_exists && ! $copy_missing)
7924                         {
7925                           if (! symlink ("$libdir/$file", $fullfile)
7926                               || ! -e $fullfile)
7927                             {
7928                               $suppress = 0;
7929                               $trailer = "; error while making link: $!";
7930                             }
7931                         }
7932                       elsif (system ('cp', "$libdir/$file", $fullfile))
7933                         {
7934                           $suppress = 0;
7935                           $trailer = "\n    error while copying";
7936                         }
7937                       set_dir_cache_file ($dir, $file);
7938                     }
7939
7940                   if (! maybe_push_required_file (dirname ($fullfile),
7941                                                   $file, $fullfile))
7942                     {
7943                       if (! $found_it && ! $automake_will_process_aux_dir)
7944                         {
7945                           # We have added the file but could not push it
7946                           # into DIST_COMMON, probably because this is
7947                           # an auxiliary file and we are not processing
7948                           # the top level Makefile.  Furthermore Automake
7949                           # hasn't been asked to create the Makefile.in
7950                           # that distributes the aux dir files.
7951                           error ($where, 'Please make a full run of automake'
7952                                  . " so $fullfile gets distributed.");
7953                         }
7954                     }
7955                 }
7956               else
7957                 {
7958                   $trailer = "\n  `automake --add-missing' can install `$file'"
7959                     if -f "$libdir/$file";
7960                 }
7961
7962               # If --force-missing was specified, and we have
7963               # actually found the file, then do nothing.
7964               next
7965                 if $found_it && $force_missing;
7966
7967               # If we couldn't install the file, but it is a target in
7968               # the Makefile, don't print anything.  This allows files
7969               # like README, AUTHORS, or THANKS to be generated.
7970               next
7971                 if !$suppress && rule $file;
7972
7973               msg ($suppress ? 'note' : 'error', $where, "$message$trailer$trailer2");
7974             }
7975         }
7976     }
7977 }
7978
7979 # &require_file ($WHERE, $MYSTRICT, @FILES)
7980 # -----------------------------------------
7981 sub require_file ($$@)
7982 {
7983     my ($where, $mystrict, @files) = @_;
7984     require_file_internal ($where, $mystrict, $relative_dir, @files);
7985 }
7986
7987 # &require_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7988 # -----------------------------------------------------------
7989 sub require_file_with_macro ($$$@)
7990 {
7991     my ($cond, $macro, $mystrict, @files) = @_;
7992     $macro = rvar ($macro) unless ref $macro;
7993     require_file ($macro->rdef ($cond)->location, $mystrict, @files);
7994 }
7995
7996 # &require_libsource_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7997 # ----------------------------------------------------------------
7998 # Require an AC_LIBSOURCEd file.  If AC_CONFIG_LIBOBJ_DIR was called, it
7999 # must be in that directory.  Otherwise expect it in the current directory.
8000 sub require_libsource_with_macro ($$$@)
8001 {
8002     my ($cond, $macro, $mystrict, @files) = @_;
8003     $macro = rvar ($macro) unless ref $macro;
8004     if ($config_libobj_dir)
8005       {
8006         require_file_internal ($macro->rdef ($cond)->location, $mystrict,
8007                                $config_libobj_dir, @files);
8008       }
8009     else
8010       {
8011         require_file ($macro->rdef ($cond)->location, $mystrict, @files);
8012       }
8013 }
8014
8015 # Queue to push require_conf_file requirements to.
8016 my $required_conf_file_queue;
8017
8018 # &queue_required_conf_file ($QUEUE, $KEY, $DIR, $WHERE, $MYSTRICT, @FILES)
8019 # -------------------------------------------------------------------------
8020 sub queue_required_conf_file ($$$$@)
8021 {
8022     my ($queue, $key, $dir, $where, $mystrict, @files) = @_;
8023     my @serial_loc;
8024     if (ref $where)
8025       {
8026         @serial_loc = (QUEUE_LOCATION, $where->serialize ());
8027       }
8028     else
8029       {
8030         @serial_loc = (QUEUE_STRING, $where);
8031       }
8032     $queue->enqueue ($key, $dir, @serial_loc, $mystrict, 0 + @files, @files);
8033 }
8034
8035 # &require_queued_conf_file ($QUEUE)
8036 # ----------------------------------
8037 sub require_queued_conf_file ($)
8038 {
8039     my ($queue) = @_;
8040     my $where;
8041     my $dir = $queue->dequeue ();
8042     my $loc_key = $queue->dequeue ();
8043     if ($loc_key eq QUEUE_LOCATION)
8044       {
8045         $where = Automake::Location::deserialize ($queue);
8046       }
8047     elsif ($loc_key eq QUEUE_STRING)
8048       {
8049         $where = $queue->dequeue ();
8050       }
8051     else
8052       {
8053         prog_error "unexpected key $loc_key";
8054       }
8055     my $mystrict = $queue->dequeue ();
8056     my $nfiles = $queue->dequeue ();
8057     my @files;
8058     push @files, $queue->dequeue ()
8059       foreach (1 .. $nfiles);
8060
8061     # Dequeuing happens outside of per-makefile context, so we have to
8062     # set the variables used by require_file_internal and the functions
8063     # it calls.  Gross!
8064     $relative_dir = $dir;
8065     require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8066 }
8067
8068 # &require_conf_file ($WHERE, $MYSTRICT, @FILES)
8069 # ----------------------------------------------
8070 # Looks in configuration path, as specified by AC_CONFIG_AUX_DIR;
8071 # worker threads may queue up the action to be serialized by the master.
8072 #
8073 # FIXME: this seriously relies on the semantics of require_file_internal
8074 # and maybe_push_required_file, in that we exploit the fact that only the
8075 # contents of the last handled output file may be impacted (which in turn
8076 # is dealt with by the master thread).
8077 sub require_conf_file ($$@)
8078 {
8079     my ($where, $mystrict, @files) = @_;
8080     if (defined $required_conf_file_queue)
8081       {
8082         queue_required_conf_file ($required_conf_file_queue, QUEUE_CONF_FILE,
8083                                   $relative_dir, $where, $mystrict, @files);
8084       }
8085     else
8086       {
8087         require_file_internal ($where, $mystrict, $config_aux_dir, @files);
8088       }
8089 }
8090
8091
8092 # &require_conf_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
8093 # ----------------------------------------------------------------
8094 sub require_conf_file_with_macro ($$$@)
8095 {
8096     my ($cond, $macro, $mystrict, @files) = @_;
8097     require_conf_file (rvar ($macro)->rdef ($cond)->location,
8098                        $mystrict, @files);
8099 }
8100
8101 ################################################################
8102
8103 # &require_build_directory ($DIRECTORY)
8104 # -------------------------------------
8105 # Emit rules to create $DIRECTORY if needed, and return
8106 # the file that any target requiring this directory should be made
8107 # dependent upon.
8108 # We don't want to emit the rule twice, and want to reuse it
8109 # for directories with equivalent names (e.g., `foo/bar' and `./foo//bar').
8110 sub require_build_directory ($)
8111 {
8112   my $directory = shift;
8113
8114   return $directory_map{$directory} if exists $directory_map{$directory};
8115
8116   my $cdir = File::Spec->canonpath ($directory);
8117
8118   if (exists $directory_map{$cdir})
8119     {
8120       my $stamp = $directory_map{$cdir};
8121       $directory_map{$directory} = $stamp;
8122       return $stamp;
8123     }
8124
8125   my $dirstamp = "$cdir/\$(am__dirstamp)";
8126
8127   $directory_map{$directory} = $dirstamp;
8128   $directory_map{$cdir} = $dirstamp;
8129
8130   # Set a variable for the dirstamp basename.
8131   define_pretty_variable ('am__dirstamp', TRUE, INTERNAL,
8132                           '$(am__leading_dot)dirstamp');
8133
8134   # Directory must be removed by `make distclean'.
8135   $clean_files{$dirstamp} = DIST_CLEAN;
8136
8137   $output_rules .= ("$dirstamp:\n"
8138                     . "\t\@\$(MKDIR_P) $directory\n"
8139                     . "\t\@: > $dirstamp\n");
8140
8141   return $dirstamp;
8142 }
8143
8144 # &require_build_directory_maybe ($FILE)
8145 # --------------------------------------
8146 # If $FILE lies in a subdirectory, emit a rule to create this
8147 # directory and return the file that $FILE should be made
8148 # dependent upon.  Otherwise, just return the empty string.
8149 sub require_build_directory_maybe ($)
8150 {
8151     my $file = shift;
8152     my $directory = dirname ($file);
8153
8154     if ($directory ne '.')
8155     {
8156         return require_build_directory ($directory);
8157     }
8158     else
8159     {
8160         return '';
8161     }
8162 }
8163
8164 ################################################################
8165
8166 # Push a list of files onto dist_common.
8167 sub push_dist_common
8168 {
8169   prog_error "push_dist_common run after handle_dist"
8170     if $handle_dist_run;
8171   Automake::Variable::define ('DIST_COMMON', VAR_AUTOMAKE, '+', TRUE, "@_",
8172                               '', INTERNAL, VAR_PRETTY);
8173 }
8174
8175
8176 ################################################################
8177
8178 # generate_makefile ($MAKEFILE_AM, $MAKEFILE_IN)
8179 # ----------------------------------------------
8180 # Generate a Makefile.in given the name of the corresponding Makefile and
8181 # the name of the file output by config.status.
8182 sub generate_makefile ($$)
8183 {
8184   my ($makefile_am, $makefile_in) = @_;
8185
8186   # Reset all the Makefile.am related variables.
8187   initialize_per_input;
8188
8189   # AUTOMAKE_OPTIONS can contains -W flags to disable or enable
8190   # warnings for this file.  So hold any warning issued before
8191   # we have processed AUTOMAKE_OPTIONS.
8192   buffer_messages ('warning');
8193
8194   # Name of input file ("Makefile.am") and output file
8195   # ("Makefile.in").  These have no directory components.
8196   $am_file_name = basename ($makefile_am);
8197   $in_file_name = basename ($makefile_in);
8198
8199   # $OUTPUT is encoded.  If it contains a ":" then the first element
8200   # is the real output file, and all remaining elements are input
8201   # files.  We don't scan or otherwise deal with these input files,
8202   # other than to mark them as dependencies.  See
8203   # &scan_autoconf_files for details.
8204   my ($makefile, @inputs) = split (/:/, $output_files{$makefile_in});
8205
8206   $relative_dir = dirname ($makefile);
8207   $am_relative_dir = dirname ($makefile_am);
8208   $topsrcdir = backname ($relative_dir);
8209
8210   read_main_am_file ($makefile_am);
8211   if (handle_options)
8212     {
8213       # Process buffered warnings.
8214       flush_messages;
8215       # Fatal error.  Just return, so we can continue with next file.
8216       return;
8217     }
8218   # Process buffered warnings.
8219   flush_messages;
8220
8221   # There are a few install-related variables that you should not define.
8222   foreach my $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
8223     {
8224       my $v = var $var;
8225       if ($v)
8226         {
8227           my $def = $v->def (TRUE);
8228           prog_error "$var not defined in condition TRUE"
8229             unless $def;
8230           reject_var $var, "`$var' should not be defined"
8231             if $def->owner != VAR_AUTOMAKE;
8232         }
8233     }
8234
8235   # Catch some obsolete variables.
8236   msg_var ('obsolete', 'INCLUDES',
8237            "`INCLUDES' is the old name for `AM_CPPFLAGS' (or `*_CPPFLAGS')")
8238     if var ('INCLUDES');
8239
8240   # Must do this after reading .am file.
8241   define_variable ('subdir', $relative_dir, INTERNAL);
8242
8243   # If DIST_SUBDIRS is defined, make sure SUBDIRS is, so that
8244   # recursive rules are enabled.
8245   define_pretty_variable ('SUBDIRS', TRUE, INTERNAL, '')
8246     if var 'DIST_SUBDIRS' && ! var 'SUBDIRS';
8247
8248   # Check first, because we might modify some state.
8249   check_cygnus;
8250   check_gnu_standards;
8251   check_gnits_standards;
8252
8253   handle_configure ($makefile_am, $makefile_in, $makefile, @inputs);
8254   handle_gettext;
8255   handle_libraries;
8256   handle_ltlibraries;
8257   handle_programs;
8258   handle_scripts;
8259
8260   # These must be run after all the sources are scanned.  They
8261   # use variables defined by &handle_libraries, &handle_ltlibraries,
8262   # or &handle_programs.
8263   handle_compile;
8264   handle_languages;
8265   handle_libtool;
8266
8267   # Variables used by distdir.am and tags.am.
8268   define_pretty_variable ('SOURCES', TRUE, INTERNAL, @sources);
8269   if (! option 'no-dist')
8270     {
8271       define_pretty_variable ('DIST_SOURCES', TRUE, INTERNAL, @dist_sources);
8272     }
8273
8274   handle_multilib;
8275   handle_texinfo;
8276   handle_emacs_lisp;
8277   handle_python;
8278   handle_java;
8279   handle_man_pages;
8280   handle_data;
8281   handle_headers;
8282   handle_subdirs;
8283   handle_tags;
8284   handle_minor_options;
8285   # Must come after handle_programs so that %known_programs is up-to-date.
8286   handle_tests;
8287
8288   # This must come after most other rules.
8289   handle_dist;
8290
8291   handle_footer;
8292   do_check_merge_target;
8293   handle_all ($makefile);
8294
8295   # FIXME: Gross!
8296   if (var ('lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8297     {
8298       $output_rules .= "install-binPROGRAMS: install-libLTLIBRARIES\n\n";
8299     }
8300   if (var ('nobase_lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8301     {
8302       $output_rules .= "install-binPROGRAMS: install-nobase_libLTLIBRARIES\n\n";
8303     }
8304
8305   handle_install;
8306   handle_clean ($makefile);
8307   handle_factored_dependencies;
8308
8309   # Comes last, because all the above procedures may have
8310   # defined or overridden variables.
8311   $output_vars .= output_variables;
8312
8313   check_typos;
8314
8315   my ($out_file) = $output_directory . '/' . $makefile_in;
8316
8317   if ($exit_code != 0)
8318     {
8319       verb "not writing $out_file because of earlier errors";
8320       return;
8321     }
8322
8323   if (! -d ($output_directory . '/' . $am_relative_dir))
8324     {
8325       mkdir ($output_directory . '/' . $am_relative_dir, 0755);
8326     }
8327
8328   # We make sure that `all:' is the first target.
8329   my $output =
8330     "$output_vars$output_all$output_header$output_rules$output_trailer";
8331
8332   # Decide whether we must update the output file or not.
8333   # We have to update in the following situations.
8334   #  * $force_generation is set.
8335   #  * any of the output dependencies is younger than the output
8336   #  * the contents of the output is different (this can happen
8337   #    if the project has been populated with a file listed in
8338   #    @common_files since the last run).
8339   # Output's dependencies are split in two sets:
8340   #  * dependencies which are also configure dependencies
8341   #    These do not change between each Makefile.am
8342   #  * other dependencies, specific to the Makefile.am being processed
8343   #    (such as the Makefile.am itself, or any Makefile fragment
8344   #    it includes).
8345   my $timestamp = mtime $out_file;
8346   if (! $force_generation
8347       && $configure_deps_greatest_timestamp < $timestamp
8348       && $output_deps_greatest_timestamp < $timestamp
8349       && $output eq contents ($out_file))
8350     {
8351       verb "$out_file unchanged";
8352       # No need to update.
8353       return;
8354     }
8355
8356   if (-e $out_file)
8357     {
8358       unlink ($out_file)
8359         or fatal "cannot remove $out_file: $!\n";
8360     }
8361
8362   my $gm_file = new Automake::XFile "> $out_file";
8363   verb "creating $out_file";
8364   print $gm_file $output;
8365 }
8366
8367 ################################################################
8368
8369
8370
8371
8372 ################################################################
8373
8374 # Helper function for usage().
8375 sub print_autodist_files (@)
8376 {
8377   my @lcomm = sort (&uniq (@_));
8378
8379   my @four;
8380   format USAGE_FORMAT =
8381   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
8382   $four[0],           $four[1],           $four[2],           $four[3]
8383 .
8384   local $~ = "USAGE_FORMAT";
8385
8386   my $cols = 4;
8387   my $rows = int(@lcomm / $cols);
8388   my $rest = @lcomm % $cols;
8389
8390   if ($rest)
8391     {
8392       $rows++;
8393     }
8394   else
8395     {
8396       $rest = $cols;
8397     }
8398
8399   for (my $y = 0; $y < $rows; $y++)
8400     {
8401       @four = ("", "", "", "");
8402       for (my $x = 0; $x < $cols; $x++)
8403         {
8404           last if $y + 1 == $rows && $x == $rest;
8405
8406           my $idx = (($x > $rest)
8407                ?  ($rows * $rest + ($rows - 1) * ($x - $rest))
8408                : ($rows * $x));
8409
8410           $idx += $y;
8411           $four[$x] = $lcomm[$idx];
8412         }
8413       write;
8414     }
8415 }
8416
8417
8418 # Print usage information.
8419 sub usage ()
8420 {
8421     print "Usage: $0 [OPTION] ... [Makefile]...
8422
8423 Generate Makefile.in for configure from Makefile.am.
8424
8425 Operation modes:
8426       --help               print this help, then exit
8427       --version            print version number, then exit
8428   -v, --verbose            verbosely list files processed
8429       --no-force           only update Makefile.in's that are out of date
8430   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY
8431
8432 Dependency tracking:
8433   -i, --ignore-deps      disable dependency tracking code
8434       --include-deps     enable dependency tracking code
8435
8436 Flavors:
8437       --cygnus           assume program is part of Cygnus-style tree
8438       --foreign          set strictness to foreign
8439       --gnits            set strictness to gnits
8440       --gnu              set strictness to gnu
8441
8442 Library files:
8443   -a, --add-missing      add missing standard files to package
8444       --libdir=DIR       directory storing library files
8445   -c, --copy             with -a, copy missing files (default is symlink)
8446   -f, --force-missing    force update of standard files
8447
8448 ";
8449     Automake::ChannelDefs::usage;
8450
8451     print "\nFiles automatically distributed if found " .
8452           "(always):\n";
8453     print_autodist_files @common_files;
8454     print "\nFiles automatically distributed if found " .
8455           "(under certain conditions):\n";
8456     print_autodist_files @common_sometimes;
8457
8458     print '
8459 Report bugs to <@PACKAGE_BUGREPORT@>.
8460 GNU Automake home page: <@PACKAGE_URL@>.
8461 General help using GNU software: <http://www.gnu.org/gethelp/>.
8462 ';
8463
8464     # --help always returns 0 per GNU standards.
8465     exit 0;
8466 }
8467
8468
8469 # &version ()
8470 # -----------
8471 # Print version information
8472 sub version ()
8473 {
8474   print <<EOF;
8475 automake (GNU $PACKAGE) $VERSION
8476 Copyright (C) 2011 Free Software Foundation, Inc.
8477 License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
8478 This is free software: you are free to change and redistribute it.
8479 There is NO WARRANTY, to the extent permitted by law.
8480
8481 Written by Tom Tromey <tromey\@redhat.com>
8482        and Alexandre Duret-Lutz <adl\@gnu.org>.
8483 EOF
8484   # --version always returns 0 per GNU standards.
8485   exit 0;
8486 }
8487
8488 ################################################################
8489
8490 # Parse command line.
8491 sub parse_arguments ()
8492 {
8493   # Start off as gnu.
8494   set_strictness ('gnu');
8495
8496   my $cli_where = new Automake::Location;
8497   my %cli_options =
8498     (
8499      'version' => \&version,
8500      'help'    => \&usage,
8501      'libdir=s' => \$libdir,
8502      'gnu'              => sub { set_strictness ('gnu'); },
8503      'gnits'            => sub { set_strictness ('gnits'); },
8504      'cygnus'           => sub { set_global_option ('cygnus', $cli_where); },
8505      'foreign'          => sub { set_strictness ('foreign'); },
8506      'include-deps'     => sub { unset_global_option ('no-dependencies'); },
8507      'i|ignore-deps'    => sub { set_global_option ('no-dependencies',
8508                                                     $cli_where); },
8509      'no-force' => sub { $force_generation = 0; },
8510      'f|force-missing'  => \$force_missing,
8511      'o|output-dir=s'   => \$output_directory,
8512      'a|add-missing'    => \$add_missing,
8513      'c|copy'           => \$copy_missing,
8514      'v|verbose'        => sub { setup_channel 'verb', silent => 0; },
8515      'W|warnings=s'     => \&parse_warnings,
8516      # These long options (--Werror and --Wno-error) for backward
8517      # compatibility.  Use -Werror and -Wno-error today.
8518      'Werror'           => sub { parse_warnings 'W', 'error'; },
8519      'Wno-error'        => sub { parse_warnings 'W', 'no-error'; },
8520      );
8521
8522   use Automake::Getopt ();
8523   Automake::Getopt::parse_options %cli_options;
8524
8525   if (defined $output_directory)
8526     {
8527       msg 'obsolete', "`--output-dir' is deprecated\n";
8528     }
8529   else
8530     {
8531       # In the next release we'll remove this entirely.
8532       $output_directory = '.';
8533     }
8534
8535   return unless @ARGV;
8536
8537   my $errspec = 0;
8538   foreach my $arg (@ARGV)
8539     {
8540       fatal ("empty argument\nTry `$0 --help' for more information.")
8541         if ($arg eq '');
8542
8543       # Handle $local:$input syntax.
8544       my ($local, @rest) = split (/:/, $arg);
8545       @rest = ("$local.in",) unless @rest;
8546       my $input = locate_am @rest;
8547       if ($input)
8548         {
8549           push @input_files, $input;
8550           $output_files{$input} = join (':', ($local, @rest));
8551         }
8552       else
8553         {
8554           error "no Automake input file found for `$arg'";
8555           $errspec = 1;
8556         }
8557     }
8558   fatal "no input file found among supplied arguments"
8559     if $errspec && ! @input_files;
8560 }
8561
8562
8563 # handle_makefile ($MAKEFILE_IN)
8564 # ------------------------------
8565 # Deal with $MAKEFILE_IN.
8566 sub handle_makefile ($)
8567 {
8568   my ($file) =  @_;
8569   ($am_file = $file) =~ s/\.in$//;
8570   if (! -f ($am_file . '.am'))
8571     {
8572       error "`$am_file.am' does not exist";
8573     }
8574   else
8575     {
8576       # Any warning setting now local to this Makefile.am.
8577       dup_channel_setup;
8578
8579       generate_makefile ($am_file . '.am', $file);
8580
8581       # Back out any warning setting.
8582       drop_channel_setup;
8583     }
8584 }
8585
8586 # handle_makefiles_serial ()
8587 # --------------------------
8588 # Deal with all makefiles, without threads.
8589 sub handle_makefiles_serial ()
8590 {
8591   foreach my $file (@input_files)
8592     {
8593       handle_makefile ($file);
8594     }
8595 }
8596
8597 # get_number_of_threads ()
8598 # ------------------------
8599 # Logic for deciding how many worker threads to use.
8600 sub get_number_of_threads
8601 {
8602   my $nthreads = $ENV{'AUTOMAKE_JOBS'} || 0;
8603
8604   $nthreads = 0
8605     unless $nthreads =~ /^[0-9]+$/;
8606
8607   # It doesn't make sense to use more threads than makefiles,
8608   my $max_threads = @input_files;
8609
8610   # but a single worker thread is helpful for exposing bugs.
8611   if ($automake_will_process_aux_dir && $max_threads > 1)
8612     {
8613       $max_threads--;
8614     }
8615   if ($nthreads > $max_threads)
8616     {
8617       $nthreads = $max_threads;
8618     }
8619   return $nthreads;
8620 }
8621
8622 # handle_makefiles_threaded ($NTHREADS)
8623 # -------------------------------------
8624 # Deal with all makefiles, using threads.  The general strategy is to
8625 # spawn NTHREADS worker threads, dispatch makefiles to them, and let the
8626 # worker threads push back everything that needs serialization:
8627 # * warning and (normal) error messages, for stable stderr output
8628 #   order and content (avoiding duplicates, for example),
8629 # * races when installing aux files (and respective messages),
8630 # * races when collecting aux files for distribution.
8631 #
8632 # The latter requires that the makefile that deals with the aux dir
8633 # files be handled last, done by the master thread.
8634 sub handle_makefiles_threaded ($)
8635 {
8636   my ($nthreads) = @_;
8637
8638   my @queued_input_files = @input_files;
8639   my $last_input_file = undef;
8640   if ($automake_will_process_aux_dir)
8641     {
8642       $last_input_file = pop @queued_input_files;
8643     }
8644
8645   # The file queue distributes all makefiles, the message queues
8646   # collect all serializations needed for respective files.
8647   my $file_queue = Thread::Queue->new;
8648   my %msg_queues;
8649   foreach my $file (@queued_input_files)
8650     {
8651       $msg_queues{$file} = Thread::Queue->new;
8652     }
8653
8654   verb "spawning $nthreads worker threads";
8655   my @threads = (1 .. $nthreads);
8656   foreach my $t (@threads)
8657     {
8658       $t = threads->new (sub
8659         {
8660           while (my $file = $file_queue->dequeue)
8661             {
8662               verb "handling $file";
8663               my $queue = $msg_queues{$file};
8664               setup_channel_queue ($queue, QUEUE_MESSAGE);
8665               $required_conf_file_queue = $queue;
8666               handle_makefile ($file);
8667               $queue->enqueue (undef);
8668               setup_channel_queue (undef, undef);
8669               $required_conf_file_queue = undef;
8670             }
8671           return $exit_code;
8672         });
8673     }
8674
8675   # Queue all normal makefiles.
8676   verb "queuing " . @queued_input_files . " input files";
8677   $file_queue->enqueue (@queued_input_files, (undef) x @threads);
8678
8679   # Collect and process serializations.
8680   foreach my $file (@queued_input_files)
8681     {
8682       verb "dequeuing messages for " . $file;
8683       reset_local_duplicates ();
8684       my $queue = $msg_queues{$file};
8685       while (my $key = $queue->dequeue)
8686         {
8687           if ($key eq QUEUE_MESSAGE)
8688             {
8689               pop_channel_queue ($queue);
8690             }
8691           elsif ($key eq QUEUE_CONF_FILE)
8692             {
8693               require_queued_conf_file ($queue);
8694             }
8695           else
8696             {
8697               prog_error "unexpected key $key";
8698             }
8699         }
8700     }
8701
8702   foreach my $t (@threads)
8703     {
8704       my @exit_thread = $t->join;
8705       $exit_code = $exit_thread[0]
8706         if ($exit_thread[0] > $exit_code);
8707     }
8708
8709   # The master processes the last file.
8710   if ($automake_will_process_aux_dir)
8711     {
8712       verb "processing last input file";
8713       handle_makefile ($last_input_file);
8714     }
8715 }
8716
8717 ################################################################
8718
8719 # Parse the WARNINGS environment variable.
8720 parse_WARNINGS;
8721
8722 # Parse command line.
8723 parse_arguments;
8724
8725 $configure_ac = require_configure_ac;
8726
8727 # Do configure.ac scan only once.
8728 scan_autoconf_files;
8729
8730 if (! @input_files)
8731   {
8732     my $msg = '';
8733     $msg = "\nDid you forget AC_CONFIG_FILES([Makefile]) in $configure_ac?"
8734       if -f 'Makefile.am';
8735     fatal ("no `Makefile.am' found for any configure output$msg");
8736   }
8737
8738 my $nthreads = get_number_of_threads ();
8739
8740 if ($perl_threads && $nthreads >= 1)
8741   {
8742     handle_makefiles_threaded ($nthreads);
8743   }
8744 else
8745   {
8746     handle_makefiles_serial ();
8747   }
8748
8749 exit $exit_code;
8750
8751
8752 ### Setup "GNU" style for perl-mode and cperl-mode.
8753 ## Local Variables:
8754 ## perl-indent-level: 2
8755 ## perl-continued-statement-offset: 2
8756 ## perl-continued-brace-offset: 0
8757 ## perl-brace-offset: 0
8758 ## perl-brace-imaginary-offset: 0
8759 ## perl-label-offset: -2
8760 ## cperl-indent-level: 2
8761 ## cperl-brace-offset: 0
8762 ## cperl-continued-brace-offset: 0
8763 ## cperl-label-offset: -2
8764 ## cperl-extra-newline-before-brace: t
8765 ## cperl-merge-trailing-else: nil
8766 ## cperl-continued-statement-offset: 2
8767 ## End: