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