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