automake.in

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