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 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                                        SERIAL_TESTS => !! option 'serial-tests',
4827                                        CHECK_DEPS => $check_deps);
4828
4829       # Tests that are known programs should have $(EXEEXT) appended.
4830       # For matching purposes, we need to adjust XFAIL_TESTS as well.
4831       append_exeext { exists $known_programs{$_[0]} } 'TESTS';
4832       append_exeext { exists $known_programs{$_[0]} } 'XFAIL_TESTS'
4833         if (var ('XFAIL_TESTS'));
4834
4835       if (! option 'serial-tests')
4836         {
4837           define_variable ('TEST_SUITE_LOG', 'test-suite.log', INTERNAL);
4838           my $suff = '.test';
4839           my $at_exeext = '';
4840           my $handle_exeext = exists $configure_vars{'EXEEXT'};
4841           if ($handle_exeext)
4842             {
4843               $at_exeext = subst ('EXEEXT');
4844               $suff = $at_exeext  . ' ' . $suff;
4845             }
4846           if (! var 'TEST_EXTENSIONS')
4847             {
4848               define_variable ('TEST_EXTENSIONS', $suff, INTERNAL);
4849             }
4850           my $var = var 'TEST_EXTENSIONS';
4851           # Currently, we are not able to deal with conditional contents
4852           # in TEST_EXTENSIONS.
4853           if ($var->has_conditional_contents)
4854            {
4855              msg_var 'unsupported', $var,
4856                      "'TEST_EXTENSIONS' cannot have conditional contents";
4857            }
4858           my @test_suffixes = $var->value_as_list_recursive;
4859           if ((my @invalid_test_suffixes =
4860                   grep { !is_valid_test_extension $_ } @test_suffixes) > 0)
4861             {
4862               error $var->rdef (TRUE)->location,
4863                     "invalid test extensions: @invalid_test_suffixes";
4864             }
4865           @test_suffixes = grep { is_valid_test_extension $_ } @test_suffixes;
4866           if ($handle_exeext)
4867             {
4868               unshift (@test_suffixes, $at_exeext)
4869                 unless $test_suffixes[0] eq $at_exeext;
4870             }
4871           unshift (@test_suffixes, '');
4872
4873           transform_variable_recursively
4874             ('TESTS', 'TEST_LOGS', 'am__testlogs', 1, INTERNAL,
4875               sub {
4876                 my ($subvar, $val, $cond, $full_cond) = @_;
4877                 my $obj = $val;
4878                 return $obj
4879                   if $val =~ /^\@.*\@$/;
4880                 $obj =~ s/\$\(EXEEXT\)$//o;
4881
4882                 if ($val =~ /(\$\((top_)?srcdir\))\//o)
4883                   {
4884                     msg ('error', $subvar->rdef ($cond)->location,
4885                          "using '$1' in TESTS is currently broken: '$val'");
4886                   }
4887
4888                 foreach my $test_suffix (@test_suffixes)
4889                   {
4890                     next
4891                       if $test_suffix eq $at_exeext || $test_suffix eq '';
4892                     return substr ($obj, 0, length ($obj) - length ($test_suffix)) . '.log'
4893                       if substr ($obj, - length ($test_suffix)) eq $test_suffix;
4894                   }
4895                 my $base = $obj;
4896                 $obj .= '.log';
4897                 handle_per_suffix_test ('',
4898                                         OBJ => $obj,
4899                                         BASE => $base,
4900                                         SOURCE => $val);
4901                 return $obj;
4902               });
4903
4904           my $nhelper=1;
4905           my $prev = 'TESTS';
4906           my $post = '';
4907           my $last_suffix = $test_suffixes[$#test_suffixes];
4908           my $cur = '';
4909           foreach my $test_suffix (@test_suffixes)
4910             {
4911               if ($test_suffix eq $last_suffix)
4912                 {
4913                   $cur = 'TEST_LOGS';
4914                 }
4915               else
4916                 {
4917                   $cur = 'am__test_logs' . $nhelper;
4918                 }
4919               define_variable ($cur,
4920                 '$(' . $prev . ':' . $test_suffix . $post . '=.log)', INTERNAL);
4921               $post = '.log';
4922               $prev = $cur;
4923               $nhelper++;
4924               if ($test_suffix ne $at_exeext && $test_suffix ne '')
4925                 {
4926                   handle_per_suffix_test ($test_suffix,
4927                                           OBJ => '',
4928                                           BASE => '$*',
4929                                           SOURCE => '$<');
4930                 }
4931             }
4932           $clean_files{'$(TEST_LOGS)'} = MOSTLY_CLEAN;
4933           $clean_files{'$(TEST_LOGS:.log=.trs)'} = MOSTLY_CLEAN;
4934           $clean_files{'$(TEST_SUITE_LOG)'} = MOSTLY_CLEAN;
4935         }
4936     }
4937 }
4938
4939 # Handle Emacs Lisp.
4940 sub handle_emacs_lisp
4941 {
4942   my @elfiles = &am_install_var ('-candist', 'lisp', 'LISP',
4943                                  'lisp', 'noinst');
4944
4945   return if ! @elfiles;
4946
4947   define_pretty_variable ('am__ELFILES', TRUE, INTERNAL,
4948                           map { $_->[1] } @elfiles);
4949   define_pretty_variable ('am__ELCFILES', TRUE, INTERNAL,
4950                           '$(am__ELFILES:.el=.elc)');
4951   # This one can be overridden by users.
4952   define_pretty_variable ('ELCFILES', TRUE, INTERNAL, '$(LISP:.el=.elc)');
4953
4954   push @all, '$(ELCFILES)';
4955
4956   require_variables ($elfiles[0][0], "Emacs Lisp sources seen", TRUE,
4957                      'EMACS', 'lispdir');
4958 }
4959
4960 # Handle Python
4961 sub handle_python
4962 {
4963   my @pyfiles = &am_install_var ('-defaultdist', 'python', 'PYTHON',
4964                                  'noinst');
4965   return if ! @pyfiles;
4966
4967   require_variables ($pyfiles[0][0], "Python sources seen", TRUE, 'PYTHON');
4968   require_conf_file ($pyfiles[0][0], FOREIGN, 'py-compile');
4969   &define_variable ('py_compile', "$am_config_aux_dir/py-compile", INTERNAL);
4970 }
4971
4972 # Handle Java.
4973 sub handle_java
4974 {
4975     my @sourcelist = &am_install_var ('-candist',
4976                                       'java', 'JAVA',
4977                                       'noinst', 'check');
4978     return if ! @sourcelist;
4979
4980     my @prefixes = am_primary_prefixes ('JAVA', 1,
4981                                         'noinst', 'check');
4982
4983     my $dir;
4984     my @java_sources = ();
4985     foreach my $prefix (@prefixes)
4986       {
4987         (my $curs = $prefix) =~ s/^(?:nobase_)?(?:dist_|nodist_)?//;
4988
4989         next
4990           if $curs eq 'EXTRA';
4991
4992         push @java_sources, '$(' . $prefix . '_JAVA' . ')';
4993
4994         if (defined $dir)
4995           {
4996             err_var "${curs}_JAVA", "multiple _JAVA primaries in use"
4997              unless $curs eq $dir;
4998           }
4999
5000         $dir = $curs;
5001       }
5002
5003     define_pretty_variable ('am__java_sources', TRUE, INTERNAL,
5004                             "@java_sources");
5005
5006     if ($dir eq 'check')
5007       {
5008         push (@check, "class$dir.stamp");
5009       }
5010     else
5011       {
5012         push (@all, "class$dir.stamp");
5013       }
5014 }
5015
5016
5017 # Handle some of the minor options.
5018 sub handle_minor_options
5019 {
5020   if (option 'readme-alpha')
5021     {
5022       if ($relative_dir eq '.')
5023         {
5024           if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
5025             {
5026               msg ('error-gnits', $package_version_location,
5027                    "version '$package_version' doesn't follow " .
5028                    "Gnits standards");
5029             }
5030           if (defined $1 && -f 'README-alpha')
5031             {
5032               # This means we have an alpha release.  See
5033               # GNITS_VERSION_PATTERN for details.
5034               push_dist_common ('README-alpha');
5035             }
5036         }
5037     }
5038 }
5039
5040 ################################################################
5041
5042 # ($OUTPUT, @INPUTS)
5043 # &split_config_file_spec ($SPEC)
5044 # -------------------------------
5045 # Decode the Autoconf syntax for config files (files, headers, links
5046 # etc.).
5047 sub split_config_file_spec ($)
5048 {
5049   my ($spec) = @_;
5050   my ($output, @inputs) = split (/:/, $spec);
5051
5052   push @inputs, "$output.in"
5053     unless @inputs;
5054
5055   return ($output, @inputs);
5056 }
5057
5058 # $input
5059 # locate_am (@POSSIBLE_SOURCES)
5060 # -----------------------------
5061 # AC_CONFIG_FILES allow specifications such as Makefile:top.in:mid.in:bot.in
5062 # This functions returns the first *.in file for which a *.am exists.
5063 # It returns undef otherwise.
5064 sub locate_am (@)
5065 {
5066   my (@rest) = @_;
5067   my $input;
5068   foreach my $file (@rest)
5069     {
5070       if (($file =~ /^(.*)\.in$/) && -f "$1.am")
5071         {
5072           $input = $file;
5073           last;
5074         }
5075     }
5076   return $input;
5077 }
5078
5079 my %make_list;
5080
5081 # &scan_autoconf_config_files ($WHERE, $CONFIG-FILES)
5082 # ---------------------------------------------------
5083 # Study $CONFIG-FILES which is the first argument to AC_CONFIG_FILES
5084 # (or AC_OUTPUT).
5085 sub scan_autoconf_config_files ($$)
5086 {
5087   my ($where, $config_files) = @_;
5088
5089   # Look at potential Makefile.am's.
5090   foreach (split ' ', $config_files)
5091     {
5092       # Must skip empty string for Perl 4.
5093       next if $_ eq "\\" || $_ eq '';
5094
5095       # Handle $local:$input syntax.
5096       my ($local, @rest) = split (/:/);
5097       @rest = ("$local.in",) unless @rest;
5098       # Keep in sync with 'conffile-leading-dot.test'.
5099       msg ('unsupported', $where,
5100            "omit leading './' from config file names such as '$local';"
5101            . "\nremake rules might be subtly broken otherwise")
5102         if ($local =~ /^\.\//);
5103       my $input = locate_am @rest;
5104       if ($input)
5105         {
5106           # We have a file that automake should generate.
5107           $make_list{$input} = join (':', ($local, @rest));
5108         }
5109       else
5110         {
5111           # We have a file that automake should cause to be
5112           # rebuilt, but shouldn't generate itself.
5113           push (@other_input_files, $_);
5114         }
5115       $ac_config_files_location{$local} = $where;
5116       $ac_config_files_condition{$local} =
5117         new Automake::Condition (@cond_stack)
5118           if (@cond_stack);
5119     }
5120 }
5121
5122
5123 # &scan_autoconf_traces ($FILENAME)
5124 # ---------------------------------
5125 sub scan_autoconf_traces ($)
5126 {
5127   my ($filename) = @_;
5128
5129   # Macros to trace, with their minimal number of arguments.
5130   #
5131   # IMPORTANT: If you add a macro here, you should also add this macro
5132   # =========  to Automake-preselection in autoconf/lib/autom4te.in.
5133   my %traced = (
5134                 AC_CANONICAL_BUILD => 0,
5135                 AC_CANONICAL_HOST => 0,
5136                 AC_CANONICAL_TARGET => 0,
5137                 AC_CONFIG_AUX_DIR => 1,
5138                 AC_CONFIG_FILES => 1,
5139                 AC_CONFIG_HEADERS => 1,
5140                 AC_CONFIG_LIBOBJ_DIR => 1,
5141                 AC_CONFIG_LINKS => 1,
5142                 AC_FC_SRCEXT => 1,
5143                 AC_INIT => 0,
5144                 AC_LIBSOURCE => 1,
5145                 AC_REQUIRE_AUX_FILE => 1,
5146                 AC_SUBST_TRACE => 1,
5147                 AM_AUTOMAKE_VERSION => 1,
5148                 AM_CONDITIONAL => 2,
5149                 _AM_EXTRA_RECURSIVE_TARGETS => 1,
5150                 AM_GNU_GETTEXT => 0,
5151                 AM_GNU_GETTEXT_INTL_SUBDIR => 0,
5152                 AM_INIT_AUTOMAKE => 0,
5153                 AM_MAINTAINER_MODE => 0,
5154                 AM_PROG_AR => 0,
5155                 AM_PROG_CC_C_O => 0,
5156                 _AM_SUBST_NOTMAKE => 1,
5157                 _AM_COND_IF => 1,
5158                 _AM_COND_ELSE => 1,
5159                 _AM_COND_ENDIF => 1,
5160                 LT_SUPPORTED_TAG => 1,
5161                 _LT_AC_TAGCONFIG => 0,
5162                 m4_include => 1,
5163                 m4_sinclude => 1,
5164                 sinclude => 1,
5165               );
5166
5167   my $traces = ($ENV{AUTOCONF} || '@am_AUTOCONF@') . " ";
5168
5169   # Use a separator unlikely to be used, not ':', the default, which
5170   # has a precise meaning for AC_CONFIG_FILES and so on.
5171   $traces .= join (' ',
5172                    map { "--trace=$_" . ':\$f:\$l::\$d::\$n::\${::}%' }
5173                    (keys %traced));
5174
5175   my $tracefh = new Automake::XFile ("$traces $filename |");
5176   verb "reading $traces";
5177
5178   @cond_stack = ();
5179   my $where;
5180
5181   while ($_ = $tracefh->getline)
5182     {
5183       chomp;
5184       my ($here, $depth, @args) = split (/::/);
5185       $where = new Automake::Location $here;
5186       my $macro = $args[0];
5187
5188       prog_error ("unrequested trace '$macro'")
5189         unless exists $traced{$macro};
5190
5191       # Skip and diagnose malformed calls.
5192       if ($#args < $traced{$macro})
5193         {
5194           msg ('syntax', $where, "not enough arguments for $macro");
5195           next;
5196         }
5197
5198       # Alphabetical ordering please.
5199       if ($macro eq 'AC_CANONICAL_BUILD')
5200         {
5201           if ($seen_canonical <= AC_CANONICAL_BUILD)
5202             {
5203               $seen_canonical = AC_CANONICAL_BUILD;
5204               $canonical_location = $where;
5205             }
5206         }
5207       elsif ($macro eq 'AC_CANONICAL_HOST')
5208         {
5209           if ($seen_canonical <= AC_CANONICAL_HOST)
5210             {
5211               $seen_canonical = AC_CANONICAL_HOST;
5212               $canonical_location = $where;
5213             }
5214         }
5215       elsif ($macro eq 'AC_CANONICAL_TARGET')
5216         {
5217           $seen_canonical = AC_CANONICAL_TARGET;
5218           $canonical_location = $where;
5219         }
5220       elsif ($macro eq 'AC_CONFIG_AUX_DIR')
5221         {
5222           if ($seen_init_automake)
5223             {
5224               error ($where, "AC_CONFIG_AUX_DIR must be called before "
5225                      . "AM_INIT_AUTOMAKE ...", partial => 1);
5226               error ($seen_init_automake, "... AM_INIT_AUTOMAKE called here");
5227             }
5228           $config_aux_dir = $args[1];
5229           $config_aux_dir_set_in_configure_ac = 1;
5230           check_directory ($config_aux_dir, $where);
5231         }
5232       elsif ($macro eq 'AC_CONFIG_FILES')
5233         {
5234           # Look at potential Makefile.am's.
5235           scan_autoconf_config_files ($where, $args[1]);
5236         }
5237       elsif ($macro eq 'AC_CONFIG_HEADERS')
5238         {
5239           foreach my $spec (split (' ', $args[1]))
5240             {
5241               my ($dest, @src) = split (':', $spec);
5242               $ac_config_files_location{$dest} = $where;
5243               push @config_headers, $spec;
5244             }
5245         }
5246       elsif ($macro eq 'AC_CONFIG_LIBOBJ_DIR')
5247         {
5248           $config_libobj_dir = $args[1];
5249           check_directory ($config_libobj_dir, $where);
5250         }
5251       elsif ($macro eq 'AC_CONFIG_LINKS')
5252         {
5253           foreach my $spec (split (' ', $args[1]))
5254             {
5255               my ($dest, $src) = split (':', $spec);
5256               $ac_config_files_location{$dest} = $where;
5257               push @config_links, $spec;
5258             }
5259         }
5260       elsif ($macro eq 'AC_FC_SRCEXT')
5261         {
5262           my $suffix = $args[1];
5263           # These flags are used as %SOURCEFLAG% in depend2.am,
5264           # where the trailing space is important.
5265           $sourceflags{'.' . $suffix} = '$(FCFLAGS_' . $suffix . ') '
5266             if ($suffix eq 'f90' || $suffix eq 'f95' || $suffix eq 'f03' || $suffix eq 'f08');
5267         }
5268       elsif ($macro eq 'AC_INIT')
5269         {
5270           if (defined $args[2])
5271             {
5272               $package_version = $args[2];
5273               $package_version_location = $where;
5274             }
5275         }
5276       elsif ($macro eq 'AC_LIBSOURCE')
5277         {
5278           $libsources{$args[1]} = $here;
5279         }
5280       elsif ($macro eq 'AC_REQUIRE_AUX_FILE')
5281         {
5282           # Only remember the first time a file is required.
5283           $required_aux_file{$args[1]} = $where
5284             unless exists $required_aux_file{$args[1]};
5285         }
5286       elsif ($macro eq 'AC_SUBST_TRACE')
5287         {
5288           # Just check for alphanumeric in AC_SUBST_TRACE.  If you do
5289           # AC_SUBST(5), then too bad.
5290           $configure_vars{$args[1]} = $where
5291             if $args[1] =~ /^\w+$/;
5292         }
5293       elsif ($macro eq 'AM_AUTOMAKE_VERSION')
5294         {
5295           error ($where,
5296                  "version mismatch.  This is Automake $VERSION,\n" .
5297                  "but the definition used by this AM_INIT_AUTOMAKE\n" .
5298                  "comes from Automake $args[1].  You should recreate\n" .
5299                  "aclocal.m4 with aclocal and run automake again.\n",
5300                  # $? = 63 is used to indicate version mismatch to missing.
5301                  exit_code => 63)
5302             if $VERSION ne $args[1];
5303
5304           $seen_automake_version = 1;
5305         }
5306       elsif ($macro eq 'AM_CONDITIONAL')
5307         {
5308           $configure_cond{$args[1]} = $where;
5309         }
5310       elsif ($macro eq '_AM_EXTRA_RECURSIVE_TARGETS')
5311         {
5312           push @extra_recursive_targets, split (' ', $args[1]);
5313         }
5314       elsif ($macro eq 'AM_GNU_GETTEXT')
5315         {
5316           $seen_gettext = $where;
5317           $ac_gettext_location = $where;
5318           $seen_gettext_external = grep ($_ eq 'external', @args);
5319         }
5320       elsif ($macro eq 'AM_GNU_GETTEXT_INTL_SUBDIR')
5321         {
5322           $seen_gettext_intl = $where;
5323         }
5324       elsif ($macro eq 'AM_INIT_AUTOMAKE')
5325         {
5326           $seen_init_automake = $where;
5327           if (defined $args[2])
5328             {
5329               msg 'obsolete', $where, <<'EOF';
5330 AM_INIT_AUTOMAKE: two- and three-arguments forms are deprecated.  For more info, see:
5331 http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation
5332 EOF
5333               $package_version = $args[2];
5334               $package_version_location = $where;
5335             }
5336           elsif (defined $args[1])
5337             {
5338               my @opts = split (' ', $args[1]);
5339               @opts = map { { option => $_, where => $where } } @opts;
5340               exit $exit_code if process_global_option_list (@opts);
5341             }
5342         }
5343       elsif ($macro eq 'AM_MAINTAINER_MODE')
5344         {
5345           $seen_maint_mode = $where;
5346         }
5347       elsif ($macro eq 'AM_PROG_AR')
5348         {
5349           $seen_ar = $where;
5350         }
5351       elsif ($macro eq 'AM_PROG_CC_C_O')
5352         {
5353           $seen_cc_c_o = $where;
5354         }
5355       elsif ($macro eq '_AM_COND_IF')
5356         {
5357           cond_stack_if ('', $args[1], $where);
5358           error ($where, "missing m4 quoting, macro depth $depth")
5359             if ($depth != 1);
5360         }
5361       elsif ($macro eq '_AM_COND_ELSE')
5362         {
5363           cond_stack_else ('!', $args[1], $where);
5364           error ($where, "missing m4 quoting, macro depth $depth")
5365             if ($depth != 1);
5366         }
5367       elsif ($macro eq '_AM_COND_ENDIF')
5368         {
5369           cond_stack_endif (undef, undef, $where);
5370           error ($where, "missing m4 quoting, macro depth $depth")
5371             if ($depth != 1);
5372         }
5373       elsif ($macro eq '_AM_SUBST_NOTMAKE')
5374         {
5375           $ignored_configure_vars{$args[1]} = $where;
5376         }
5377       elsif ($macro eq 'm4_include'
5378              || $macro eq 'm4_sinclude'
5379              || $macro eq 'sinclude')
5380         {
5381           # Skip missing 'sinclude'd files.
5382           next if $macro ne 'm4_include' && ! -f $args[1];
5383
5384           # Some modified versions of Autoconf don't use
5385           # frozen files.  Consequently it's possible that we see all
5386           # m4_include's performed during Autoconf's startup.
5387           # Obviously we don't want to distribute Autoconf's files
5388           # so we skip absolute filenames here.
5389           push @configure_deps, '$(top_srcdir)/' . $args[1]
5390             unless $here =~ m,^(?:\w:)?[\\/],;
5391           # Keep track of the greatest timestamp.
5392           if (-e $args[1])
5393             {
5394               my $mtime = mtime $args[1];
5395               $configure_deps_greatest_timestamp = $mtime
5396                 if $mtime > $configure_deps_greatest_timestamp;
5397             }
5398         }
5399       elsif ($macro eq 'LT_SUPPORTED_TAG')
5400         {
5401           $libtool_tags{$args[1]} = 1;
5402           $libtool_new_api = 1;
5403         }
5404       elsif ($macro eq '_LT_AC_TAGCONFIG')
5405         {
5406           # _LT_AC_TAGCONFIG is an old macro present in Libtool 1.5.
5407           # We use it to detect whether tags are supported.  Our
5408           # preferred interface is LT_SUPPORTED_TAG, but it was
5409           # introduced in Libtool 1.6.
5410           if (0 == keys %libtool_tags)
5411             {
5412               # Hardcode the tags supported by Libtool 1.5.
5413               %libtool_tags = (CC => 1, CXX => 1, GCJ => 1, F77 => 1);
5414             }
5415         }
5416     }
5417
5418   error ($where, "condition stack not properly closed")
5419     if (@cond_stack);
5420
5421   $tracefh->close;
5422 }
5423
5424
5425 # &scan_autoconf_files ()
5426 # -----------------------
5427 # Check whether we use 'configure.ac' or 'configure.in'.
5428 # Scan it (and possibly 'aclocal.m4') for interesting things.
5429 # We must scan aclocal.m4 because there might be AC_SUBSTs and such there.
5430 sub scan_autoconf_files ()
5431 {
5432   # Reinitialize libsources here.  This isn't really necessary,
5433   # since we currently assume there is only one configure.ac.  But
5434   # that won't always be the case.
5435   %libsources = ();
5436
5437   # Keep track of the youngest configure dependency.
5438   $configure_deps_greatest_timestamp = mtime $configure_ac;
5439   if (-e 'aclocal.m4')
5440     {
5441       my $mtime = mtime 'aclocal.m4';
5442       $configure_deps_greatest_timestamp = $mtime
5443         if $mtime > $configure_deps_greatest_timestamp;
5444     }
5445
5446   scan_autoconf_traces ($configure_ac);
5447
5448   @configure_input_files = sort keys %make_list;
5449   # Set input and output files if not specified by user.
5450   if (! @input_files)
5451     {
5452       @input_files = @configure_input_files;
5453       %output_files = %make_list;
5454     }
5455
5456
5457   if (! $seen_init_automake)
5458     {
5459       err_ac ("no proper invocation of AM_INIT_AUTOMAKE was found.\nYou "
5460               . "should verify that $configure_ac invokes AM_INIT_AUTOMAKE,"
5461               . "\nthat aclocal.m4 is present in the top-level directory,\n"
5462               . "and that aclocal.m4 was recently regenerated "
5463               . "(using aclocal)");
5464     }
5465   else
5466     {
5467       if (! $seen_automake_version)
5468         {
5469           if (-f 'aclocal.m4')
5470             {
5471               error ($seen_init_automake,
5472                      "your implementation of AM_INIT_AUTOMAKE comes from " .
5473                      "an\nold Automake version.  You should recreate " .
5474                      "aclocal.m4\nwith aclocal and run automake again",
5475                      # $? = 63 is used to indicate version mismatch to missing.
5476                      exit_code => 63);
5477             }
5478           else
5479             {
5480               error ($seen_init_automake,
5481                      "no proper implementation of AM_INIT_AUTOMAKE was " .
5482                      "found,\nprobably because aclocal.m4 is missing.\n" .
5483                      "You should run aclocal to create this file, then\n" .
5484                      "run automake again");
5485             }
5486         }
5487     }
5488
5489   locate_aux_dir ();
5490
5491   # Look for some files we need.  Always check for these.  This
5492   # check must be done for every run, even those where we are only
5493   # looking at a subdir Makefile.  We must set relative_dir for
5494   # push_required_file to work.
5495   # Sort the files for stable verbose output.
5496   $relative_dir = '.';
5497   foreach my $file (sort keys %required_aux_file)
5498     {
5499       require_conf_file ($required_aux_file{$file}->get, FOREIGN, $file)
5500     }
5501   err_am "'install.sh' is an anachronism; use 'install-sh' instead"
5502     if -f $config_aux_dir . '/install.sh';
5503
5504   # Preserve dist_common for later.
5505   $configure_dist_common = variable_value ('DIST_COMMON') || '';
5506
5507 }
5508
5509 ################################################################
5510
5511 # Do any extra checking for GNU standards.
5512 sub check_gnu_standards
5513 {
5514   if ($relative_dir eq '.')
5515     {
5516       # In top level (or only) directory.
5517       require_file ("$am_file.am", GNU,
5518                     qw/INSTALL NEWS README AUTHORS ChangeLog/);
5519
5520       # Accept one of these three licenses; default to COPYING.
5521       # Make sure we do not overwrite an existing license.
5522       my $license;
5523       foreach (qw /COPYING COPYING.LIB COPYING.LESSER/)
5524         {
5525           if (-f $_)
5526             {
5527               $license = $_;
5528               last;
5529             }
5530         }
5531       require_file ("$am_file.am", GNU, 'COPYING')
5532         unless $license;
5533     }
5534
5535   for my $opt ('no-installman', 'no-installinfo')
5536     {
5537       msg ('error-gnu', option $opt,
5538            "option '$opt' disallowed by GNU standards")
5539         if option $opt;
5540     }
5541 }
5542
5543 # Do any extra checking for GNITS standards.
5544 sub check_gnits_standards
5545 {
5546   if ($relative_dir eq '.')
5547     {
5548       # In top level (or only) directory.
5549       require_file ("$am_file.am", GNITS, 'THANKS');
5550     }
5551 }
5552
5553 ################################################################
5554 #
5555 # Functions to handle files of each language.
5556
5557 # Each 'lang_X_rewrite($DIRECTORY, $BASE, $EXT)' function follows a
5558 # simple formula: Return value is LANG_SUBDIR if the resulting object
5559 # file should be in a subdir if the source file is, LANG_PROCESS if
5560 # file is to be dealt with, LANG_IGNORE otherwise.
5561
5562 # Much of the actual processing is handled in
5563 # handle_single_transform.  These functions exist so that
5564 # auxiliary information can be recorded for a later cleanup pass.
5565 # Note that the calls to these functions are computed, so don't bother
5566 # searching for their precise names in the source.
5567
5568 # This is just a convenience function that can be used to determine
5569 # when a subdir object should be used.
5570 sub lang_sub_obj
5571 {
5572     return option 'subdir-objects' ? LANG_SUBDIR : LANG_PROCESS;
5573 }
5574
5575 # Rewrite a single C source file.
5576 sub lang_c_rewrite
5577 {
5578   my ($directory, $base, $ext, $obj, $have_per_exec_flags, $var) = @_;
5579
5580   my $r = LANG_PROCESS;
5581   if (option 'subdir-objects')
5582     {
5583       $r = LANG_SUBDIR;
5584       if ($directory && $directory ne '.')
5585         {
5586           $base = $directory . '/' . $base;
5587
5588           # libtool is always able to put the object at the proper place,
5589           # so we do not have to require AM_PROG_CC_C_O when building .lo files.
5590           msg_var ('portability', $var,
5591                    "compiling '$base.c' in subdir requires "
5592                    . "'AM_PROG_CC_C_O' in '$configure_ac'",
5593                    uniq_scope => US_GLOBAL,
5594                    uniq_part => 'AM_PROG_CC_C_O subdir')
5595             unless $seen_cc_c_o || $obj eq '.lo';
5596         }
5597     }
5598
5599   if (! $seen_cc_c_o
5600       && $have_per_exec_flags
5601       && ! option 'subdir-objects'
5602       && $obj ne '.lo')
5603     {
5604       msg_var ('portability',
5605                $var, "compiling '$base.c' with per-target flags requires "
5606                . "'AM_PROG_CC_C_O' in '$configure_ac'",
5607                uniq_scope => US_GLOBAL,
5608                uniq_part => 'AM_PROG_CC_C_O per-target')
5609     }
5610
5611     return $r;
5612 }
5613
5614 # Rewrite a single C++ source file.
5615 sub lang_cxx_rewrite
5616 {
5617     return &lang_sub_obj;
5618 }
5619
5620 # Rewrite a single header file.
5621 sub lang_header_rewrite
5622 {
5623     # Header files are simply ignored.
5624     return LANG_IGNORE;
5625 }
5626
5627 # Rewrite a single Vala source file.
5628 sub lang_vala_rewrite
5629 {
5630     my ($directory, $base, $ext) = @_;
5631
5632     (my $newext = $ext) =~ s/vala$/c/;
5633     return (LANG_SUBDIR, $newext);
5634 }
5635
5636 # Rewrite a single yacc file.
5637 sub lang_yacc_rewrite
5638 {
5639     my ($directory, $base, $ext) = @_;
5640
5641     my $r = &lang_sub_obj;
5642     (my $newext = $ext) =~ tr/y/c/;
5643     return ($r, $newext);
5644 }
5645
5646 # Rewrite a single yacc++ file.
5647 sub lang_yaccxx_rewrite
5648 {
5649     my ($directory, $base, $ext) = @_;
5650
5651     my $r = &lang_sub_obj;
5652     (my $newext = $ext) =~ tr/y/c/;
5653     return ($r, $newext);
5654 }
5655
5656 # Rewrite a single lex file.
5657 sub lang_lex_rewrite
5658 {
5659     my ($directory, $base, $ext) = @_;
5660
5661     my $r = &lang_sub_obj;
5662     (my $newext = $ext) =~ tr/l/c/;
5663     return ($r, $newext);
5664 }
5665
5666 # Rewrite a single lex++ file.
5667 sub lang_lexxx_rewrite
5668 {
5669     my ($directory, $base, $ext) = @_;
5670
5671     my $r = &lang_sub_obj;
5672     (my $newext = $ext) =~ tr/l/c/;
5673     return ($r, $newext);
5674 }
5675
5676 # Rewrite a single assembly file.
5677 sub lang_asm_rewrite
5678 {
5679     return &lang_sub_obj;
5680 }
5681
5682 # Rewrite a single preprocessed assembly file.
5683 sub lang_cppasm_rewrite
5684 {
5685     return &lang_sub_obj;
5686 }
5687
5688 # Rewrite a single Fortran 77 file.
5689 sub lang_f77_rewrite
5690 {
5691     return &lang_sub_obj;
5692 }
5693
5694 # Rewrite a single Fortran file.
5695 sub lang_fc_rewrite
5696 {
5697     return &lang_sub_obj;
5698 }
5699
5700 # Rewrite a single preprocessed Fortran file.
5701 sub lang_ppfc_rewrite
5702 {
5703     return &lang_sub_obj;
5704 }
5705
5706 # Rewrite a single preprocessed Fortran 77 file.
5707 sub lang_ppf77_rewrite
5708 {
5709     return &lang_sub_obj;
5710 }
5711
5712 # Rewrite a single ratfor file.
5713 sub lang_ratfor_rewrite
5714 {
5715     return &lang_sub_obj;
5716 }
5717
5718 # Rewrite a single Objective C file.
5719 sub lang_objc_rewrite
5720 {
5721     return &lang_sub_obj;
5722 }
5723
5724 # Rewrite a single Objective C++ file.
5725 sub lang_objcxx_rewrite
5726 {
5727     return &lang_sub_obj;
5728 }
5729
5730 # Rewrite a single Unified Parallel C file.
5731 sub lang_upc_rewrite
5732 {
5733     return &lang_sub_obj;
5734 }
5735
5736 # Rewrite a single Java file.
5737 sub lang_java_rewrite
5738 {
5739     return LANG_SUBDIR;
5740 }
5741
5742 # The lang_X_finish functions are called after all source file
5743 # processing is done.  Each should handle defining rules for the
5744 # language, etc.  A finish function is only called if a source file of
5745 # the appropriate type has been seen.
5746
5747 sub lang_vala_finish_target ($$)
5748 {
5749   my ($self, $name) = @_;
5750
5751   my $derived = canonicalize ($name);
5752   my $var = var "${derived}_SOURCES";
5753   return unless $var;
5754
5755   my @vala_sources = grep { /\.(vala|vapi)$/ } ($var->value_as_list_recursive);
5756
5757   # For automake bug#11229.
5758   return unless @vala_sources;
5759
5760   foreach my $vala_file (@vala_sources)
5761     {
5762       my $c_file = $vala_file;
5763       if ($c_file =~ s/(.*)\.vala$/$1.c/)
5764         {
5765           $c_file = "\$(srcdir)/$c_file";
5766           $output_rules .= "$c_file: \$(srcdir)/${derived}_vala.stamp\n"
5767             . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
5768             . "\t\@if test -f \$@; then :; else \\\n"
5769             . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
5770             . "\tfi\n";
5771           $clean_files{$c_file} = MAINTAINER_CLEAN;
5772         }
5773     }
5774
5775   # Add rebuild rules for generated header and vapi files
5776   my $flags = var ($derived . '_VALAFLAGS');
5777   if ($flags)
5778     {
5779       my $lastflag = '';
5780       foreach my $flag ($flags->value_as_list_recursive)
5781         {
5782           if (grep (/$lastflag/, ('-H', '-h', '--header', '--internal-header',
5783                                   '--vapi', '--internal-vapi', '--gir')))
5784             {
5785               my $headerfile = "\$(srcdir)/$flag";
5786               $output_rules .= "$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
5787                 . "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
5788                 . "\t\@if test -f \$@; then :; else \\\n"
5789                 . "\t  \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
5790                 . "\tfi\n";
5791
5792               # valac is not used when building from dist tarballs
5793               # distribute the generated files
5794               push_dist_common ($headerfile);
5795               $clean_files{$headerfile} = MAINTAINER_CLEAN;
5796             }
5797           $lastflag = $flag;
5798         }
5799     }
5800
5801   my $compile = $self->compile;
5802
5803   # Rewrite each occurrence of 'AM_VALAFLAGS' in the compile
5804   # rule into '${derived}_VALAFLAGS' if it exists.
5805   my $val = "${derived}_VALAFLAGS";
5806   $compile =~ s/\(AM_VALAFLAGS\)/\($val\)/
5807     if set_seen ($val);
5808
5809   # VALAFLAGS is a user variable (per GNU Standards),
5810   # it should not be overridden in the Makefile...
5811   check_user_variables 'VALAFLAGS';
5812
5813   my $dirname = dirname ($name);
5814
5815   # Only generate C code, do not run C compiler
5816   $compile .= " -C";
5817
5818   my $verbose = verbose_flag ('VALAC');
5819   my $silent = silent_flag ();
5820   my $stampfile = "\$(srcdir)/${derived}_vala.stamp";
5821
5822   $output_rules .=
5823     "\$(srcdir)/${derived}_vala.stamp: @vala_sources\n".
5824 # Since the C files generated from the vala sources depend on the
5825 # ${derived}_vala.stamp file, we must ensure its timestamp is older than
5826 # those of the C files generated by the valac invocation below (this is
5827 # especially important on systems with sub-second timestamp resolution).
5828 # Thus we need to create the stamp file *before* invoking valac, and to
5829 # move it to its final location only after valac has been invoked.
5830     "\t${silent}rm -f \$\@ && echo stamp > \$\@-t\n".
5831     "\t${verbose}\$(am__cd) \$(srcdir) && $compile @vala_sources\n".
5832     "\t${silent}mv -f \$\@-t \$\@\n";
5833
5834   push_dist_common ($stampfile);
5835
5836   $clean_files{$stampfile} = MAINTAINER_CLEAN;
5837 }
5838
5839 # Add output rules to invoke valac and create stamp file as a witness
5840 # to handle multiple outputs. This function is called after all source
5841 # file processing is done.
5842 sub lang_vala_finish
5843 {
5844   my ($self) = @_;
5845
5846   foreach my $prog (keys %known_programs)
5847     {
5848       lang_vala_finish_target ($self, $prog);
5849     }
5850
5851   while (my ($name) = each %known_libraries)
5852     {
5853       lang_vala_finish_target ($self, $name);
5854     }
5855 }
5856
5857 # The built .c files should be cleaned only on maintainer-clean
5858 # as the .c files are distributed. This function is called for each
5859 # .vala source file.
5860 sub lang_vala_target_hook
5861 {
5862   my ($self, $aggregate, $output, $input, %transform) = @_;
5863
5864   $clean_files{$output} = MAINTAINER_CLEAN;
5865 }
5866
5867 # This is a yacc helper which is called whenever we have decided to
5868 # compile a yacc file.
5869 sub lang_yacc_target_hook
5870 {
5871     my ($self, $aggregate, $output, $input, %transform) = @_;
5872
5873     # If some relevant *YFLAGS variable contains the '-d' flag, we'll
5874     # have to to generate special code.
5875     my $yflags_contains_minus_d = 0;
5876
5877     foreach my $pfx ("", "${aggregate}_")
5878       {
5879         my $yflagsvar = var ("${pfx}YFLAGS");
5880         next unless $yflagsvar;
5881         # We cannot work reliably with conditionally-defined YFLAGS.
5882         if ($yflagsvar->has_conditional_contents)
5883           {
5884             msg_var ('unsupported', $yflagsvar,
5885                      "'${pfx}YFLAGS' cannot have conditional contents");
5886           }
5887         else
5888           {
5889             $yflags_contains_minus_d = 1
5890               if grep (/^-d$/, $yflagsvar->value_as_list_recursive);
5891           }
5892       }
5893
5894     if ($yflags_contains_minus_d)
5895       {
5896         # Found a '-d' that applies to the compilation of this file.
5897         # Add a dependency for the generated header file, and arrange
5898         # for that file to be included in the distribution.
5899
5900         # The extension of the output file (e.g., '.c' or '.cxx').
5901         # We'll need it to compute the name of the generated header file.
5902         (my $output_ext = basename ($output)) =~ s/.*(\.[^.]+)$/$1/;
5903
5904         # We know that a yacc input should be turned into either a C or
5905         # C++ output file.  We depend on this fact (here and in yacc.am),
5906         # so check that it really holds.
5907         my $lang = $languages{$extension_map{$output_ext}};
5908         prog_error "invalid output name '$output' for yacc file '$input'"
5909           if (!$lang || ($lang->name ne 'c' && $lang->name ne 'cxx'));
5910
5911         (my $header_ext = $output_ext) =~ s/c/h/g;
5912         # Quote $output_ext in the regexp, so that dots in it are taken
5913         # as literal dots, not as metacharacters.
5914         (my $header = $output) =~ s/\Q$output_ext\E$/$header_ext/;
5915
5916         foreach my $cond (Automake::Rule::define (${header}, 'internal',
5917                                                   RULE_AUTOMAKE, TRUE,
5918                                                   INTERNAL))
5919           {
5920             my $condstr = $cond->subst_string;
5921             $output_rules .=
5922               "$condstr${header}: $output\n"
5923               # Recover from removal of $header
5924               . "$condstr\t\@if test ! -f \$@; then rm -f $output; else :; fi\n"
5925               . "$condstr\t\@if test ! -f \$@; then \$(MAKE) \$(AM_MAKEFLAGS) $output; else :; fi\n";
5926           }
5927         # Distribute the generated file, unless its .y source was
5928         # listed in a nodist_ variable.  (&handle_source_transform
5929         # will set DIST_SOURCE.)
5930         &push_dist_common ($header)
5931           if $transform{'DIST_SOURCE'};
5932
5933         # The GNU rules say that yacc/lex output files should be removed
5934         # by maintainer-clean.  However, if the files are not distributed,
5935         # then we want to remove them with "make clean"; otherwise,
5936         # "make distcheck" will fail.
5937         $clean_files{$header} = $transform{'DIST_SOURCE'} ? MAINTAINER_CLEAN : CLEAN;
5938       }
5939     # See the comment above for $HEADER.
5940     $clean_files{$output} = $transform{'DIST_SOURCE'} ? MAINTAINER_CLEAN : CLEAN;
5941 }
5942
5943 # This is a lex helper which is called whenever we have decided to
5944 # compile a lex file.
5945 sub lang_lex_target_hook
5946 {
5947     my ($self, $aggregate, $output, $input, %transform) = @_;
5948     # The GNU rules say that yacc/lex output files should be removed
5949     # by maintainer-clean.  However, if the files are not distributed,
5950     # then we want to remove them with "make clean"; otherwise,
5951     # "make distcheck" will fail.
5952     $clean_files{$output} = $transform{'DIST_SOURCE'} ? MAINTAINER_CLEAN : CLEAN;
5953 }
5954
5955 # This is a helper for both lex and yacc.
5956 sub yacc_lex_finish_helper
5957 {
5958   return if defined $language_scratch{'lex-yacc-done'};
5959   $language_scratch{'lex-yacc-done'} = 1;
5960
5961   # FIXME: for now, no line number.
5962   require_conf_file ($configure_ac, FOREIGN, 'ylwrap');
5963   &define_variable ('YLWRAP', "$am_config_aux_dir/ylwrap", INTERNAL);
5964 }
5965
5966 sub lang_yacc_finish
5967 {
5968   return if defined $language_scratch{'yacc-done'};
5969   $language_scratch{'yacc-done'} = 1;
5970
5971   reject_var 'YACCFLAGS', "'YACCFLAGS' obsolete; use 'YFLAGS' instead";
5972
5973   yacc_lex_finish_helper;
5974 }
5975
5976
5977 sub lang_lex_finish
5978 {
5979   return if defined $language_scratch{'lex-done'};
5980   $language_scratch{'lex-done'} = 1;
5981
5982   yacc_lex_finish_helper;
5983 }
5984
5985
5986 # Given a hash table of linker names, pick the name that has the most
5987 # precedence.  This is lame, but something has to have global
5988 # knowledge in order to eliminate the conflict.  Add more linkers as
5989 # required.
5990 sub resolve_linker
5991 {
5992     my (%linkers) = @_;
5993
5994     foreach my $l (qw(GCJLINK OBJCXXLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
5995     {
5996         return $l if defined $linkers{$l};
5997     }
5998     return 'LINK';
5999 }
6000
6001 # Called to indicate that an extension was used.
6002 sub saw_extension
6003 {
6004     my ($ext) = @_;
6005     $extension_seen{$ext} = 1;
6006 }
6007
6008 # register_language (%ATTRIBUTE)
6009 # ------------------------------
6010 # Register a single language.
6011 # Each %ATTRIBUTE is of the form ATTRIBUTE => VALUE.
6012 sub register_language (%)
6013 {
6014   my (%option) = @_;
6015
6016   # Set the defaults.
6017   $option{'autodep'} = 'no'
6018     unless defined $option{'autodep'};
6019   $option{'linker'} = ''
6020     unless defined $option{'linker'};
6021   $option{'flags'} = []
6022     unless defined $option{'flags'};
6023   $option{'output_extensions'} = sub { return ( '.$(OBJEXT)', '.lo' ) }
6024     unless defined $option{'output_extensions'};
6025   $option{'nodist_specific'} = 0
6026     unless defined $option{'nodist_specific'};
6027
6028   my $lang = new Language (%option);
6029
6030   # Fill indexes.
6031   $extension_map{$_} = $lang->name foreach @{$lang->extensions};
6032   $languages{$lang->name} = $lang;
6033   my $link = $lang->linker;
6034   if ($link)
6035     {
6036       if (exists $link_languages{$link})
6037         {
6038           prog_error ("'$link' has different definitions in "
6039                       . $lang->name . " and " . $link_languages{$link}->name)
6040             if $lang->link ne $link_languages{$link}->link;
6041         }
6042       else
6043         {
6044           $link_languages{$link} = $lang;
6045         }
6046     }
6047
6048   # Update the pattern of known extensions.
6049   accept_extensions (@{$lang->extensions});
6050
6051   # Upate the $suffix_rule map.
6052   foreach my $suffix (@{$lang->extensions})
6053     {
6054       foreach my $dest (&{$lang->output_extensions} ($suffix))
6055         {
6056           register_suffix_rule (INTERNAL, $suffix, $dest);
6057         }
6058     }
6059 }
6060
6061 # derive_suffix ($EXT, $OBJ)
6062 # --------------------------
6063 # This function is used to find a path from a user-specified suffix $EXT
6064 # to $OBJ or to some other suffix we recognize internally, e.g. 'cc'.
6065 sub derive_suffix ($$)
6066 {
6067   my ($source_ext, $obj) = @_;
6068
6069   while (! $extension_map{$source_ext}
6070          && $source_ext ne $obj
6071          && exists $suffix_rules->{$source_ext}
6072          && exists $suffix_rules->{$source_ext}{$obj})
6073     {
6074       $source_ext = $suffix_rules->{$source_ext}{$obj}[0];
6075     }
6076
6077   return $source_ext;
6078 }
6079
6080
6081 ################################################################
6082
6083 # Pretty-print something and append to output_rules.
6084 sub pretty_print_rule
6085 {
6086     $output_rules .= &makefile_wrap (@_);
6087 }
6088
6089
6090 ################################################################
6091
6092
6093 ## -------------------------------- ##
6094 ## Handling the conditional stack.  ##
6095 ## -------------------------------- ##
6096
6097
6098 # $STRING
6099 # make_conditional_string ($NEGATE, $COND)
6100 # ----------------------------------------
6101 sub make_conditional_string ($$)
6102 {
6103   my ($negate, $cond) = @_;
6104   $cond = "${cond}_TRUE"
6105     unless $cond =~ /^TRUE|FALSE$/;
6106   $cond = Automake::Condition::conditional_negate ($cond)
6107     if $negate;
6108   return $cond;
6109 }
6110
6111
6112 my %_am_macro_for_cond =
6113   (
6114   AMDEP => "one of the compiler tests\n"
6115            . "    AC_PROG_CC, AC_PROG_CXX, AC_PROG_OBJC, AC_PROG_OBJCXX,\n"
6116            . "    AM_PROG_AS, AM_PROG_GCJ, AM_PROG_UPC",
6117   am__fastdepCC => 'AC_PROG_CC',
6118   am__fastdepCCAS => 'AM_PROG_AS',
6119   am__fastdepCXX => 'AC_PROG_CXX',
6120   am__fastdepGCJ => 'AM_PROG_GCJ',
6121   am__fastdepOBJC => 'AC_PROG_OBJC',
6122   am__fastdepOBJCXX => 'AC_PROG_OBJCXX',
6123   am__fastdepUPC => 'AM_PROG_UPC'
6124   );
6125
6126 # $COND
6127 # cond_stack_if ($NEGATE, $COND, $WHERE)
6128 # --------------------------------------
6129 sub cond_stack_if ($$$)
6130 {
6131   my ($negate, $cond, $where) = @_;
6132
6133   if (! $configure_cond{$cond} && $cond !~ /^TRUE|FALSE$/)
6134     {
6135       my $text = "$cond does not appear in AM_CONDITIONAL";
6136       my $scope = US_LOCAL;
6137       if (exists $_am_macro_for_cond{$cond})
6138         {
6139           my $mac = $_am_macro_for_cond{$cond};
6140           $text .= "\n  The usual way to define '$cond' is to add ";
6141           $text .= ($mac =~ / /) ? $mac : "'$mac'";
6142           $text .= "\n  to '$configure_ac' and run 'aclocal' and 'autoconf' again";
6143           # These warnings appear in Automake files (depend2.am),
6144           # so there is no need to display them more than once:
6145           $scope = US_GLOBAL;
6146         }
6147       error $where, $text, uniq_scope => $scope;
6148     }
6149
6150   push (@cond_stack, make_conditional_string ($negate, $cond));
6151
6152   return new Automake::Condition (@cond_stack);
6153 }
6154
6155
6156 # $COND
6157 # cond_stack_else ($NEGATE, $COND, $WHERE)
6158 # ----------------------------------------
6159 sub cond_stack_else ($$$)
6160 {
6161   my ($negate, $cond, $where) = @_;
6162
6163   if (! @cond_stack)
6164     {
6165       error $where, "else without if";
6166       return FALSE;
6167     }
6168
6169   $cond_stack[$#cond_stack] =
6170     Automake::Condition::conditional_negate ($cond_stack[$#cond_stack]);
6171
6172   # If $COND is given, check against it.
6173   if (defined $cond)
6174     {
6175       $cond = make_conditional_string ($negate, $cond);
6176
6177       error ($where, "else reminder ($negate$cond) incompatible with "
6178              . "current conditional: $cond_stack[$#cond_stack]")
6179         if $cond_stack[$#cond_stack] ne $cond;
6180     }
6181
6182   return new Automake::Condition (@cond_stack);
6183 }
6184
6185
6186 # $COND
6187 # cond_stack_endif ($NEGATE, $COND, $WHERE)
6188 # -----------------------------------------
6189 sub cond_stack_endif ($$$)
6190 {
6191   my ($negate, $cond, $where) = @_;
6192   my $old_cond;
6193
6194   if (! @cond_stack)
6195     {
6196       error $where, "endif without if";
6197       return TRUE;
6198     }
6199
6200   # If $COND is given, check against it.
6201   if (defined $cond)
6202     {
6203       $cond = make_conditional_string ($negate, $cond);
6204
6205       error ($where, "endif reminder ($negate$cond) incompatible with "
6206              . "current conditional: $cond_stack[$#cond_stack]")
6207         if $cond_stack[$#cond_stack] ne $cond;
6208     }
6209
6210   pop @cond_stack;
6211
6212   return new Automake::Condition (@cond_stack);
6213 }
6214
6215
6216
6217
6218
6219 ## ------------------------ ##
6220 ## Handling the variables.  ##
6221 ## ------------------------ ##
6222
6223
6224 # &define_pretty_variable ($VAR, $COND, $WHERE, @VALUE)
6225 # -----------------------------------------------------
6226 # Like define_variable, but the value is a list, and the variable may
6227 # be defined conditionally.  The second argument is the condition
6228 # under which the value should be defined; this should be the empty
6229 # string to define the variable unconditionally.  The third argument
6230 # is a list holding the values to use for the variable.  The value is
6231 # pretty printed in the output file.
6232 sub define_pretty_variable ($$$@)
6233 {
6234     my ($var, $cond, $where, @value) = @_;
6235
6236     if (! vardef ($var, $cond))
6237     {
6238         Automake::Variable::define ($var, VAR_AUTOMAKE, '', $cond, "@value",
6239                                     '', $where, VAR_PRETTY);
6240         rvar ($var)->rdef ($cond)->set_seen;
6241     }
6242 }
6243
6244
6245 # define_variable ($VAR, $VALUE, $WHERE)
6246 # --------------------------------------
6247 # Define a new Automake Makefile variable VAR to VALUE, but only if
6248 # not already defined.
6249 sub define_variable ($$$)
6250 {
6251     my ($var, $value, $where) = @_;
6252     define_pretty_variable ($var, TRUE, $where, $value);
6253 }
6254
6255
6256 # define_files_variable ($VAR, \@BASENAME, $EXTENSION, $WHERE)
6257 # ------------------------------------------------------------
6258 # Define the $VAR which content is the list of file names composed of
6259 # a @BASENAME and the $EXTENSION.
6260 sub define_files_variable ($\@$$)
6261 {
6262   my ($var, $basename, $extension, $where) = @_;
6263   define_variable ($var,
6264                    join (' ', map { "$_.$extension" } @$basename),
6265                    $where);
6266 }
6267
6268
6269 # Like define_variable, but define a variable to be the configure
6270 # substitution by the same name.
6271 sub define_configure_variable ($)
6272 {
6273   my ($var) = @_;
6274   # Some variables we do not want to output.  For instance it
6275   # would be a bad idea to output `U = @U@` when `@U@` can be
6276   # substituted as `\`.
6277   my $pretty = exists $ignored_configure_vars{$var} ? VAR_SILENT : VAR_ASIS;
6278   Automake::Variable::define ($var, VAR_CONFIGURE, '', TRUE, subst $var,
6279                               '', $configure_vars{$var}, $pretty);
6280 }
6281
6282
6283 # define_compiler_variable ($LANG)
6284 # --------------------------------
6285 # Define a compiler variable.  We also handle defining the 'LT'
6286 # version of the command when using libtool.
6287 sub define_compiler_variable ($)
6288 {
6289     my ($lang) = @_;
6290
6291     my ($var, $value) = ($lang->compiler, $lang->compile);
6292     my $libtool_tag = '';
6293     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6294       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6295     &define_variable ($var, $value, INTERNAL);
6296     if (var ('LIBTOOL'))
6297       {
6298         my $verbose = define_verbose_libtool ();
6299         &define_variable ("LT$var",
6300                           "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6301                           . "\$(LIBTOOLFLAGS) --mode=compile $value",
6302                           INTERNAL);
6303       }
6304     define_verbose_tagvar ($lang->ccer || 'GEN');
6305 }
6306
6307
6308 # define_linker_variable ($LANG)
6309 # ------------------------------
6310 # Define linker variables.
6311 sub define_linker_variable ($)
6312 {
6313     my ($lang) = @_;
6314
6315     my $libtool_tag = '';
6316     $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6317       if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6318     # CCLD = $(CC).
6319     &define_variable ($lang->lder, $lang->ld, INTERNAL);
6320     # CCLINK = $(CCLD) blah blah...
6321     my $link = '';
6322     if (var ('LIBTOOL'))
6323       {
6324         my $verbose = define_verbose_libtool ();
6325         $link = "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) "
6326                 . "\$(LIBTOOLFLAGS) --mode=link ";
6327       }
6328     &define_variable ($lang->linker, $link . $lang->link, INTERNAL);
6329     &define_variable ($lang->compiler,  $lang);
6330     &define_verbose_tagvar ($lang->lder || 'GEN');
6331 }
6332
6333 sub define_per_target_linker_variable ($$)
6334 {
6335   my ($linker, $target) = @_;
6336
6337   # If the user wrote a custom link command, we don't define ours.
6338   return "${target}_LINK"
6339     if set_seen "${target}_LINK";
6340
6341   my $xlink = $linker ? $linker : 'LINK';
6342
6343   my $lang = $link_languages{$xlink};
6344   prog_error "Unknown language for linker variable '$xlink'"
6345     unless $lang;
6346
6347   my $link_command = $lang->link;
6348   if (var 'LIBTOOL')
6349     {
6350       my $libtool_tag = '';
6351       $libtool_tag = '--tag=' . $lang->libtool_tag . ' '
6352         if $lang->libtool_tag && exists $libtool_tags{$lang->libtool_tag};
6353
6354       my $verbose = define_verbose_libtool ();
6355       $link_command =
6356         "\$(LIBTOOL) $verbose $libtool_tag\$(AM_LIBTOOLFLAGS) \$(LIBTOOLFLAGS) "
6357         . "--mode=link " . $link_command;
6358     }
6359
6360   # Rewrite each occurrence of 'AM_$flag' in the link
6361   # command into '${derived}_$flag' if it exists.
6362   my $orig_command = $link_command;
6363   my @flags = (@{$lang->flags}, 'LDFLAGS');
6364   push @flags, 'LIBTOOLFLAGS' if var 'LIBTOOL';
6365   for my $flag (@flags)
6366     {
6367       my $val = "${target}_$flag";
6368       $link_command =~ s/\(AM_$flag\)/\($val\)/
6369         if set_seen ($val);
6370     }
6371
6372   # If the computed command is the same as the generic command, use
6373   # the command linker variable.
6374   return ($lang->linker, $lang->lder)
6375     if $link_command eq $orig_command;
6376
6377   &define_variable ("${target}_LINK", $link_command, INTERNAL);
6378   return ("${target}_LINK", $lang->lder);
6379 }
6380
6381 ################################################################
6382
6383 # &check_trailing_slash ($WHERE, $LINE)
6384 # -------------------------------------
6385 # Return 1 iff $LINE ends with a slash.
6386 # Might modify $LINE.
6387 sub check_trailing_slash ($\$)
6388 {
6389   my ($where, $line) = @_;
6390
6391   # Ignore '##' lines.
6392   return 0 if $$line =~ /$IGNORE_PATTERN/o;
6393
6394   # Catch and fix a common error.
6395   msg "syntax", $where, "whitespace following trailing backslash"
6396     if $$line =~ s/\\\s+\n$/\\\n/;
6397
6398   return $$line =~ /\\$/;
6399 }
6400
6401
6402 # &read_am_file ($AMFILE, $WHERE)
6403 # -------------------------------
6404 # Read Makefile.am and set up %contents.  Simultaneously copy lines
6405 # from Makefile.am into $output_trailer, or define variables as
6406 # appropriate.  NOTE we put rules in the trailer section.  We want
6407 # user rules to come after our generated stuff.
6408 sub read_am_file ($$)
6409 {
6410     my ($amfile, $where) = @_;
6411
6412     my $am_file = new Automake::XFile ("< $amfile");
6413     verb "reading $amfile";
6414
6415     # Keep track of the youngest output dependency.
6416     my $mtime = mtime $amfile;
6417     $output_deps_greatest_timestamp = $mtime
6418       if $mtime > $output_deps_greatest_timestamp;
6419
6420     my $spacing = '';
6421     my $comment = '';
6422     my $blank = 0;
6423     my $saw_bk = 0;
6424     my $var_look = VAR_ASIS;
6425
6426     use constant IN_VAR_DEF => 0;
6427     use constant IN_RULE_DEF => 1;
6428     use constant IN_COMMENT => 2;
6429     my $prev_state = IN_RULE_DEF;
6430
6431     while ($_ = $am_file->getline)
6432     {
6433         $where->set ("$amfile:$.");
6434         if (/$IGNORE_PATTERN/o)
6435         {
6436             # Merely delete comments beginning with two hashes.
6437         }
6438         elsif (/$WHITE_PATTERN/o)
6439         {
6440             error $where, "blank line following trailing backslash"
6441               if $saw_bk;
6442             # Stick a single white line before the incoming macro or rule.
6443             $spacing = "\n";
6444             $blank = 1;
6445             # Flush all comments seen so far.
6446             if ($comment ne '')
6447             {
6448                 $output_vars .= $comment;
6449                 $comment = '';
6450             }
6451         }
6452         elsif (/$COMMENT_PATTERN/o)
6453         {
6454             # Stick comments before the incoming macro or rule.  Make
6455             # sure a blank line precedes the first block of comments.
6456             $spacing = "\n" unless $blank;
6457             $blank = 1;
6458             $comment .= $spacing . $_;
6459             $spacing = '';
6460             $prev_state = IN_COMMENT;
6461         }
6462         else
6463         {
6464             last;
6465         }
6466         $saw_bk = check_trailing_slash ($where, $_);
6467     }
6468
6469     # We save the conditional stack on entry, and then check to make
6470     # sure it is the same on exit.  This lets us conditionally include
6471     # other files.
6472     my @saved_cond_stack = @cond_stack;
6473     my $cond = new Automake::Condition (@cond_stack);
6474
6475     my $last_var_name = '';
6476     my $last_var_type = '';
6477     my $last_var_value = '';
6478     my $last_where;
6479     # FIXME: shouldn't use $_ in this loop; it is too big.
6480     while ($_)
6481     {
6482         $where->set ("$amfile:$.");
6483
6484         # Make sure the line is \n-terminated.
6485         chomp;
6486         $_ .= "\n";
6487
6488         # Don't look at MAINTAINER_MODE_TRUE here.  That shouldn't be
6489         # used by users.  @MAINT@ is an anachronism now.
6490         $_ =~ s/\@MAINT\@//g
6491             unless $seen_maint_mode;
6492
6493         my $new_saw_bk = check_trailing_slash ($where, $_);
6494
6495         if (/$IGNORE_PATTERN/o)
6496         {
6497             # Merely delete comments beginning with two hashes.
6498
6499             # Keep any backslash from the previous line.
6500             $new_saw_bk = $saw_bk;
6501         }
6502         elsif (/$WHITE_PATTERN/o)
6503         {
6504             # Stick a single white line before the incoming macro or rule.
6505             $spacing = "\n";
6506             error $where, "blank line following trailing backslash"
6507               if $saw_bk;
6508         }
6509         elsif (/$COMMENT_PATTERN/o)
6510         {
6511             error $where, "comment following trailing backslash"
6512               if $saw_bk && $prev_state != IN_COMMENT;
6513
6514             # Stick comments before the incoming macro or rule.
6515             $comment .= $spacing . $_;
6516             $spacing = '';
6517             $prev_state = IN_COMMENT;
6518         }
6519         elsif ($saw_bk)
6520         {
6521             if ($prev_state == IN_RULE_DEF)
6522             {
6523               my $cond = new Automake::Condition @cond_stack;
6524               $output_trailer .= $cond->subst_string;
6525               $output_trailer .= $_;
6526             }
6527             elsif ($prev_state == IN_COMMENT)
6528             {
6529                 # If the line doesn't start with a '#', add it.
6530                 # We do this because a continued comment like
6531                 #   # A = foo \
6532                 #         bar \
6533                 #         baz
6534                 # is not portable.  BSD make doesn't honor
6535                 # escaped newlines in comments.
6536                 s/^#?/#/;
6537                 $comment .= $spacing . $_;
6538             }
6539             else # $prev_state == IN_VAR_DEF
6540             {
6541               $last_var_value .= ' '
6542                 unless $last_var_value =~ /\s$/;
6543               $last_var_value .= $_;
6544
6545               if (!/\\$/)
6546                 {
6547                   Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6548                                               $last_var_type, $cond,
6549                                               $last_var_value, $comment,
6550                                               $last_where, VAR_ASIS)
6551                     if $cond != FALSE;
6552                   $comment = $spacing = '';
6553                 }
6554             }
6555         }
6556
6557         elsif (/$IF_PATTERN/o)
6558           {
6559             $cond = cond_stack_if ($1, $2, $where);
6560           }
6561         elsif (/$ELSE_PATTERN/o)
6562           {
6563             $cond = cond_stack_else ($1, $2, $where);
6564           }
6565         elsif (/$ENDIF_PATTERN/o)
6566           {
6567             $cond = cond_stack_endif ($1, $2, $where);
6568           }
6569
6570         elsif (/$RULE_PATTERN/o)
6571         {
6572             # Found a rule.
6573             $prev_state = IN_RULE_DEF;
6574
6575             # For now we have to output all definitions of user rules
6576             # and can't diagnose duplicates (see the comment in
6577             # Automake::Rule::define). So we go on and ignore the return value.
6578             Automake::Rule::define ($1, $amfile, RULE_USER, $cond, $where);
6579
6580             check_variable_expansions ($_, $where);
6581
6582             $output_trailer .= $comment . $spacing;
6583             my $cond = new Automake::Condition @cond_stack;
6584             $output_trailer .= $cond->subst_string;
6585             $output_trailer .= $_;
6586             $comment = $spacing = '';
6587         }
6588         elsif (/$ASSIGNMENT_PATTERN/o)
6589         {
6590             # Found a macro definition.
6591             $prev_state = IN_VAR_DEF;
6592             $last_var_name = $1;
6593             $last_var_type = $2;
6594             $last_var_value = $3;
6595             $last_where = $where->clone;
6596             if ($3 ne '' && substr ($3, -1) eq "\\")
6597               {
6598                 # We preserve the '\' because otherwise the long lines
6599                 # that are generated will be truncated by broken
6600                 # 'sed's.
6601                 $last_var_value = $3 . "\n";
6602               }
6603             # Normally we try to output variable definitions in the
6604             # same format they were input.  However, POSIX compliant
6605             # systems are not required to support lines longer than
6606             # 2048 bytes (most notably, some sed implementation are
6607             # limited to 4000 bytes, and sed is used by config.status
6608             # to rewrite Makefile.in into Makefile).  Moreover nobody
6609             # would really write such long lines by hand since it is
6610             # hardly maintainable.  So if a line is longer that 1000
6611             # bytes (an arbitrary limit), assume it has been
6612             # automatically generated by some tools, and flatten the
6613             # variable definition.  Otherwise, keep the variable as it
6614             # as been input.
6615             $var_look = VAR_PRETTY if length ($last_var_value) >= 1000;
6616
6617             if (!/\\$/)
6618               {
6619                 Automake::Variable::define ($last_var_name, VAR_MAKEFILE,
6620                                             $last_var_type, $cond,
6621                                             $last_var_value, $comment,
6622                                             $last_where, $var_look)
6623                   if $cond != FALSE;
6624                 $comment = $spacing = '';
6625                 $var_look = VAR_ASIS;
6626               }
6627         }
6628         elsif (/$INCLUDE_PATTERN/o)
6629         {
6630             my $path = $1;
6631
6632             if ($path =~ s/^\$\(top_srcdir\)\///)
6633               {
6634                 push (@include_stack, "\$\(top_srcdir\)/$path");
6635                 # Distribute any included file.
6636
6637                 # Always use the $(top_srcdir) prefix in DIST_COMMON,
6638                 # otherwise OSF make will implicitly copy the included
6639                 # file in the build tree during "make distdir" to satisfy
6640                 # the dependency.
6641                 # (subdircond2.test and subdircond3.test will fail.)
6642                 push_dist_common ("\$\(top_srcdir\)/$path");
6643               }
6644             else
6645               {
6646                 $path =~ s/\$\(srcdir\)\///;
6647                 push (@include_stack, "\$\(srcdir\)/$path");
6648                 # Always use the $(srcdir) prefix in DIST_COMMON,
6649                 # otherwise OSF make will implicitly copy the included
6650                 # file in the build tree during "make distdir" to satisfy
6651                 # the dependency.
6652                 # (subdircond2.test and subdircond3.test will fail.)
6653                 push_dist_common ("\$\(srcdir\)/$path");
6654                 $path = $relative_dir . "/" . $path if $relative_dir ne '.';
6655               }
6656             $where->push_context ("'$path' included from here");
6657             &read_am_file ($path, $where);
6658             $where->pop_context;
6659         }
6660         else
6661         {
6662             # This isn't an error; it is probably a continued rule.
6663             # In fact, this is what we assume.
6664             $prev_state = IN_RULE_DEF;
6665             check_variable_expansions ($_, $where);
6666             $output_trailer .= $comment . $spacing;
6667             my $cond = new Automake::Condition @cond_stack;
6668             $output_trailer .= $cond->subst_string;
6669             $output_trailer .= $_;
6670             $comment = $spacing = '';
6671             error $where, "'#' comment at start of rule is unportable"
6672               if $_ =~ /^\t\s*\#/;
6673         }
6674
6675         $saw_bk = $new_saw_bk;
6676         $_ = $am_file->getline;
6677     }
6678
6679     $output_trailer .= $comment;
6680
6681     error ($where, "trailing backslash on last line")
6682       if $saw_bk;
6683
6684     error ($where, (@cond_stack ? "unterminated conditionals: @cond_stack"
6685                     : "too many conditionals closed in include file"))
6686       if "@saved_cond_stack" ne "@cond_stack";
6687 }
6688
6689
6690 # define_standard_variables ()
6691 # ----------------------------
6692 # A helper for read_main_am_file which initializes configure variables
6693 # and variables from header-vars.am.
6694 sub define_standard_variables
6695 {
6696   my $saved_output_vars = $output_vars;
6697   my ($comments, undef, $rules) =
6698     file_contents_internal (1, "$libdir/am/header-vars.am",
6699                             new Automake::Location);
6700
6701   foreach my $var (sort keys %configure_vars)
6702     {
6703       &define_configure_variable ($var);
6704     }
6705
6706   $output_vars .= $comments . $rules;
6707 }
6708
6709 # Read main am file.
6710 sub read_main_am_file
6711 {
6712     my ($amfile) = @_;
6713
6714     # This supports the strange variable tricks we are about to play.
6715     prog_error ("variable defined before read_main_am_file\n" . variables_dump ())
6716       if (scalar (variables) > 0);
6717
6718     # Generate copyright header for generated Makefile.in.
6719     # We do discard the output of predefined variables, handled below.
6720     $output_vars = ("# $in_file_name generated by automake "
6721                    . $VERSION . " from $am_file_name.\n");
6722     $output_vars .= '# ' . subst ('configure_input') . "\n";
6723     $output_vars .= $gen_copyright;
6724
6725     # We want to predefine as many variables as possible.  This lets
6726     # the user set them with '+=' in Makefile.am.
6727     &define_standard_variables;
6728
6729     # Read user file, which might override some of our values.
6730     &read_am_file ($amfile, new Automake::Location);
6731 }
6732
6733
6734
6735 ################################################################
6736
6737 # $FLATTENED
6738 # &flatten ($STRING)
6739 # ------------------
6740 # Flatten the $STRING and return the result.
6741 sub flatten
6742 {
6743   $_ = shift;
6744
6745   s/\\\n//somg;
6746   s/\s+/ /g;
6747   s/^ //;
6748   s/ $//;
6749
6750   return $_;
6751 }
6752
6753
6754 # transform_token ($TOKEN, \%PAIRS, $KEY)
6755 # =======================================
6756 # Return the value associated to $KEY in %PAIRS, as used on $TOKEN
6757 # (which should be ?KEY? or any of the special %% requests)..
6758 sub transform_token ($$$)
6759 {
6760   my ($token, $transform, $key) = @_;
6761   my $res = $transform->{$key};
6762   prog_error "Unknown key '$key' in '$token'" unless defined $res;
6763   return $res;
6764 }
6765
6766
6767 # transform ($TOKEN, \%PAIRS)
6768 # ===========================
6769 # If ($TOKEN, $VAL) is in %PAIRS:
6770 #   - replaces %KEY% with $VAL,
6771 #   - enables/disables ?KEY? and ?!KEY?,
6772 #   - replaces %?KEY% with TRUE or FALSE.
6773 sub transform ($$)
6774 {
6775   my ($token, $transform) = @_;
6776
6777   # %KEY%.
6778   # Must be before the following pattern to exclude the case
6779   # when there is neither IFTRUE nor IFFALSE.
6780   if ($token =~ /^%([\w\-]+)%$/)
6781     {
6782       return transform_token ($token, $transform, $1);
6783     }
6784   # %?KEY%.
6785   elsif ($token =~ /^%\?([\w\-]+)%$/)
6786     {
6787       return transform_token ($token, $transform, $1) ? 'TRUE' : 'FALSE';
6788     }
6789   # ?KEY? and ?!KEY?.
6790   elsif ($token =~ /^ \? (!?) ([\w\-]+) \? $/x)
6791     {
6792       my $neg = ($1 eq '!') ? 1 : 0;
6793       my $val = transform_token ($token, $transform, $2);
6794       return (!!$val == $neg) ? '##%' : '';
6795     }
6796   else
6797     {
6798       prog_error "Unknown request format: $token";
6799     }
6800 }
6801
6802 # $TEXT
6803 # preprocess_file ($MAKEFILE, [%TRANSFORM])
6804 # -----------------------------------------
6805 # Load a $MAKEFILE, apply the %TRANSFORM, and return the result.
6806 # No extra parsing or post-processing is done (i.e., recognition of
6807 # rules declaration or of make variables definitions).
6808 sub preprocess_file ($%)
6809 {
6810   my ($file, %transform) = @_;
6811
6812   # Complete %transform with global options.
6813   # Note that %transform goes last, so it overrides global options.
6814   %transform = ( 'MAINTAINER-MODE'
6815                  => $seen_maint_mode ? subst ('MAINTAINER_MODE_TRUE') : '',
6816
6817                  'XZ'          => !! option 'dist-xz',
6818                  'LZMA'        => !! option 'dist-lzma',
6819                  'LZIP'        => !! option 'dist-lzip',
6820                  'BZIP2'       => !! option 'dist-bzip2',
6821                  'COMPRESS'    => !! option 'dist-tarZ',
6822                  'GZIP'        =>  ! option 'no-dist-gzip',
6823                  'SHAR'        => !! option 'dist-shar',
6824                  'ZIP'         => !! option 'dist-zip',
6825
6826                  'INSTALL-INFO' =>  ! option 'no-installinfo',
6827                  'INSTALL-MAN'  =>  ! option 'no-installman',
6828                  'HAVE-MANS'    => !! var ('MANS'),
6829                  'CK-NEWS'      => !! option 'check-news',
6830
6831                  'SUBDIRS'      => !! var ('SUBDIRS'),
6832                  'TOPDIR_P'     => $relative_dir eq '.',
6833
6834                  'BUILD'    => ($seen_canonical >= AC_CANONICAL_BUILD),
6835                  'HOST'     => ($seen_canonical >= AC_CANONICAL_HOST),
6836                  'TARGET'   => ($seen_canonical >= AC_CANONICAL_TARGET),
6837
6838                  'LIBTOOL'      => !! var ('LIBTOOL'),
6839                  'NONLIBTOOL'   => 1,
6840                 %transform);
6841
6842   if (! defined ($_ = $am_file_cache{$file}))
6843     {
6844       verb "reading $file";
6845       # Swallow the whole file.
6846       my $fc_file = new Automake::XFile "< $file";
6847       my $saved_dollar_slash = $/;
6848       undef $/;
6849       $_ = $fc_file->getline;
6850       $/ = $saved_dollar_slash;
6851       $fc_file->close;
6852       # Remove ##-comments.
6853       # Besides we don't need more than two consecutive new-lines.
6854       s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
6855       # Remember the contents of the just-read file.
6856       $am_file_cache{$file} = $_;
6857     }
6858
6859   # Substitute Automake template tokens.
6860   s/(?: % \?? [\w\-]+ %
6861       | \? !? [\w\-]+ \?
6862     )/transform($&, \%transform)/gex;
6863   # transform() may have added some ##%-comments to strip.
6864   # (we use '##%' instead of '##' so we can distinguish ##%##%##% from
6865   # ####### and do not remove the latter.)
6866   s/^[ \t]*(?:##%)+.*\n//gm;
6867
6868   return $_;
6869 }
6870
6871
6872 # @PARAGRAPHS
6873 # &make_paragraphs ($MAKEFILE, [%TRANSFORM])
6874 # ------------------------------------------
6875 # Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
6876 # paragraphs.
6877 sub make_paragraphs ($%)
6878 {
6879   my ($file, %transform) = @_;
6880   $transform{FIRST} = !$transformed_files{$file};
6881   $transformed_files{$file} = 1;
6882
6883   my @lines = split /(?<!\\)\n/, preprocess_file ($file, %transform);
6884   my @res;
6885
6886   while (defined ($_ = shift @lines))
6887     {
6888       my $paragraph = $_;
6889       # If we are a rule, eat as long as we start with a tab.
6890       if (/$RULE_PATTERN/smo)
6891         {
6892           while (defined ($_ = shift @lines) && $_ =~ /^\t/)
6893             {
6894               $paragraph .= "\n$_";
6895             }
6896           unshift (@lines, $_);
6897         }
6898
6899       # If we are a comments, eat as much comments as you can.
6900       elsif (/$COMMENT_PATTERN/smo)
6901         {
6902           while (defined ($_ = shift @lines)
6903                  && $_ =~ /$COMMENT_PATTERN/smo)
6904             {
6905               $paragraph .= "\n$_";
6906             }
6907           unshift (@lines, $_);
6908         }
6909
6910       push @res, $paragraph;
6911     }
6912
6913   return @res;
6914 }
6915
6916
6917
6918 # ($COMMENT, $VARIABLES, $RULES)
6919 # &file_contents_internal ($IS_AM, $FILE, $WHERE, [%TRANSFORM])
6920 # -------------------------------------------------------------
6921 # Return contents of a file from $libdir/am, automatically skipping
6922 # macros or rules which are already known. $IS_AM iff the caller is
6923 # reading an Automake file (as opposed to the user's Makefile.am).
6924 sub file_contents_internal ($$$%)
6925 {
6926     my ($is_am, $file, $where, %transform) = @_;
6927
6928     $where->set ($file);
6929
6930     my $result_vars = '';
6931     my $result_rules = '';
6932     my $comment = '';
6933     my $spacing = '';
6934
6935     # The following flags are used to track rules spanning across
6936     # multiple paragraphs.
6937     my $is_rule = 0;            # 1 if we are processing a rule.
6938     my $discard_rule = 0;       # 1 if the current rule should not be output.
6939
6940     # We save the conditional stack on entry, and then check to make
6941     # sure it is the same on exit.  This lets us conditionally include
6942     # other files.
6943     my @saved_cond_stack = @cond_stack;
6944     my $cond = new Automake::Condition (@cond_stack);
6945
6946     foreach (make_paragraphs ($file, %transform))
6947     {
6948         # FIXME: no line number available.
6949         $where->set ($file);
6950
6951         # Sanity checks.
6952         error $where, "blank line following trailing backslash:\n$_"
6953           if /\\$/;
6954         error $where, "comment following trailing backslash:\n$_"
6955           if /\\#/;
6956
6957         if (/^$/)
6958         {
6959             $is_rule = 0;
6960             # Stick empty line before the incoming macro or rule.
6961             $spacing = "\n";
6962         }
6963         elsif (/$COMMENT_PATTERN/mso)
6964         {
6965             $is_rule = 0;
6966             # Stick comments before the incoming macro or rule.
6967             $comment = "$_\n";
6968         }
6969
6970         # Handle inclusion of other files.
6971         elsif (/$INCLUDE_PATTERN/o)
6972         {
6973             if ($cond != FALSE)
6974               {
6975                 my $file = ($is_am ? "$libdir/am/" : '') . $1;
6976                 $where->push_context ("'$file' included from here");
6977                 # N-ary '.=' fails.
6978                 my ($com, $vars, $rules)
6979                   = file_contents_internal ($is_am, $file, $where, %transform);
6980                 $where->pop_context;
6981                 $comment .= $com;
6982                 $result_vars .= $vars;
6983                 $result_rules .= $rules;
6984               }
6985         }
6986
6987         # Handling the conditionals.
6988         elsif (/$IF_PATTERN/o)
6989           {
6990             $cond = cond_stack_if ($1, $2, $file);
6991           }
6992         elsif (/$ELSE_PATTERN/o)
6993           {
6994             $cond = cond_stack_else ($1, $2, $file);
6995           }
6996         elsif (/$ENDIF_PATTERN/o)
6997           {
6998             $cond = cond_stack_endif ($1, $2, $file);
6999           }
7000
7001         # Handling rules.
7002         elsif (/$RULE_PATTERN/mso)
7003         {
7004           $is_rule = 1;
7005           $discard_rule = 0;
7006           # Separate relationship from optional actions: the first
7007           # `new-line tab" not preceded by backslash (continuation
7008           # line).
7009           my $paragraph = $_;
7010           /^(.*?)(?:(?<!\\)\n(\t.*))?$/s;
7011           my ($relationship, $actions) = ($1, $2 || '');
7012
7013           # Separate targets from dependencies: the first colon.
7014           $relationship =~ /^([^:]+\S+) *: *(.*)$/som;
7015           my ($targets, $dependencies) = ($1, $2);
7016           # Remove the escaped new lines.
7017           # I don't know why, but I have to use a tmp $flat_deps.
7018           my $flat_deps = &flatten ($dependencies);
7019           my @deps = split (' ', $flat_deps);
7020
7021           foreach (split (' ', $targets))
7022             {
7023               # FIXME: 1. We are not robust to people defining several targets
7024               # at once, only some of them being in %dependencies.  The
7025               # actions from the targets in %dependencies are usually generated
7026               # from the content of %actions, but if some targets in $targets
7027               # are not in %dependencies the ELSE branch will output
7028               # a rule for all $targets (i.e. the targets which are both
7029               # in %dependencies and $targets will have two rules).
7030
7031               # FIXME: 2. The logic here is not able to output a
7032               # multi-paragraph rule several time (e.g. for each condition
7033               # it is defined for) because it only knows the first paragraph.
7034
7035               # FIXME: 3. We are not robust to people defining a subset
7036               # of a previously defined "multiple-target" rule.  E.g.
7037               # 'foo:' after 'foo bar:'.
7038
7039               # Output only if not in FALSE.
7040               if (defined $dependencies{$_} && $cond != FALSE)
7041                 {
7042                   &depend ($_, @deps);
7043                   register_action ($_, $actions);
7044                 }
7045               else
7046                 {
7047                   # Free-lance dependency.  Output the rule for all the
7048                   # targets instead of one by one.
7049                   my @undefined_conds =
7050                     Automake::Rule::define ($targets, $file,
7051                                             $is_am ? RULE_AUTOMAKE : RULE_USER,
7052                                             $cond, $where);
7053                   for my $undefined_cond (@undefined_conds)
7054                     {
7055                       my $condparagraph = $paragraph;
7056                       $condparagraph =~ s/^/$undefined_cond->subst_string/gme;
7057                       $result_rules .= "$spacing$comment$condparagraph\n";
7058                     }
7059                   if (scalar @undefined_conds == 0)
7060                     {
7061                       # Remember to discard next paragraphs
7062                       # if they belong to this rule.
7063                       # (but see also FIXME: #2 above.)
7064                       $discard_rule = 1;
7065                     }
7066                   $comment = $spacing = '';
7067                   last;
7068                 }
7069             }
7070         }
7071
7072         elsif (/$ASSIGNMENT_PATTERN/mso)
7073         {
7074             my ($var, $type, $val) = ($1, $2, $3);
7075             error $where, "variable '$var' with trailing backslash"
7076               if /\\$/;
7077
7078             $is_rule = 0;
7079
7080             Automake::Variable::define ($var,
7081                                         $is_am ? VAR_AUTOMAKE : VAR_MAKEFILE,
7082                                         $type, $cond, $val, $comment, $where,
7083                                         VAR_ASIS)
7084               if $cond != FALSE;
7085
7086             $comment = $spacing = '';
7087         }
7088         else
7089         {
7090             # This isn't an error; it is probably some tokens which
7091             # configure is supposed to replace, such as '@SET-MAKE@',
7092             # or some part of a rule cut by an if/endif.
7093             if (! $cond->false && ! ($is_rule && $discard_rule))
7094               {
7095                 s/^/$cond->subst_string/gme;
7096                 $result_rules .= "$spacing$comment$_\n";
7097               }
7098             $comment = $spacing = '';
7099         }
7100     }
7101
7102     error ($where, @cond_stack ?
7103            "unterminated conditionals: @cond_stack" :
7104            "too many conditionals closed in include file")
7105       if "@saved_cond_stack" ne "@cond_stack";
7106
7107     return ($comment, $result_vars, $result_rules);
7108 }
7109
7110
7111 # $CONTENTS
7112 # &file_contents ($BASENAME, $WHERE, [%TRANSFORM])
7113 # ------------------------------------------------
7114 # Return contents of a file from $libdir/am, automatically skipping
7115 # macros or rules which are already known.
7116 sub file_contents ($$%)
7117 {
7118     my ($basename, $where, %transform) = @_;
7119     my ($comments, $variables, $rules) =
7120       file_contents_internal (1, "$libdir/am/$basename.am", $where,
7121                               %transform);
7122     return "$comments$variables$rules";
7123 }
7124
7125
7126 # @PREFIX
7127 # &am_primary_prefixes ($PRIMARY, $CAN_DIST, @PREFIXES)
7128 # -----------------------------------------------------
7129 # Find all variable prefixes that are used for install directories.  A
7130 # prefix 'zar' qualifies iff:
7131 #
7132 # * 'zardir' is a variable.
7133 # * 'zar_PRIMARY' is a variable.
7134 #
7135 # As a side effect, it looks for misspellings.  It is an error to have
7136 # a variable ending in a "reserved" suffix whose prefix is unknown, e.g.
7137 # "bni_PROGRAMS".  However, unusual prefixes are allowed if a variable
7138 # of the same name (with "dir" appended) exists.  For instance, if the
7139 # variable "zardir" is defined, then "zar_PROGRAMS" becomes valid.
7140 # This is to provide a little extra flexibility in those cases which
7141 # need it.
7142 sub am_primary_prefixes ($$@)
7143 {
7144   my ($primary, $can_dist, @prefixes) = @_;
7145
7146   local $_;
7147   my %valid = map { $_ => 0 } @prefixes;
7148   $valid{'EXTRA'} = 0;
7149   foreach my $var (variables $primary)
7150     {
7151       # Automake is allowed to define variables that look like primaries
7152       # but which aren't.  E.g. INSTALL_sh_DATA.
7153       # Autoconf can also define variables like INSTALL_DATA, so
7154       # ignore all configure variables (at least those which are not
7155       # redefined in Makefile.am).
7156       # FIXME: We should make sure that these variables are not
7157       # conditionally defined (or else adjust the condition below).
7158       my $def = $var->def (TRUE);
7159       next if $def && $def->owner != VAR_MAKEFILE;
7160
7161       my $varname = $var->name;
7162
7163       if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_[[:alnum:]]+$/)
7164         {
7165           my ($base, $dist, $X) = ($1 || '', $2 || '', $3 || '');
7166           if ($dist ne '' && ! $can_dist)
7167             {
7168               err_var ($var,
7169                        "invalid variable '$varname': 'dist' is forbidden");
7170             }
7171           # Standard directories must be explicitly allowed.
7172           elsif (! defined $valid{$X} && exists $standard_prefix{$X})
7173             {
7174               err_var ($var,
7175                        "'${X}dir' is not a legitimate directory " .
7176                        "for '$primary'");
7177             }
7178           # A not explicitly valid directory is allowed if Xdir is defined.
7179           elsif (! defined $valid{$X} &&
7180                  $var->requires_variables ("'$varname' is used", "${X}dir"))
7181             {
7182               # Nothing to do.  Any error message has been output
7183               # by $var->requires_variables.
7184             }
7185           else
7186             {
7187               # Ensure all extended prefixes are actually used.
7188               $valid{"$base$dist$X"} = 1;
7189             }
7190         }
7191       else
7192         {
7193           prog_error "unexpected variable name: $varname";
7194         }
7195     }
7196
7197   # Return only those which are actually defined.
7198   return sort grep { var ($_ . '_' . $primary) } keys %valid;
7199 }
7200
7201
7202 # Handle 'where_HOW' variable magic.  Does all lookups, generates
7203 # install code, and possibly generates code to define the primary
7204 # variable.  The first argument is the name of the .am file to munge,
7205 # the second argument is the primary variable (e.g. HEADERS), and all
7206 # subsequent arguments are possible installation locations.
7207 #
7208 # Returns list of [$location, $value] pairs, where
7209 # $value's are the values in all where_HOW variable, and $location
7210 # there associated location (the place here their parent variables were
7211 # defined).
7212 #
7213 # FIXME: this should be rewritten to be cleaner.  It should be broken
7214 # up into multiple functions.
7215 #
7216 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7217 sub am_install_var
7218 {
7219   my (@args) = @_;
7220
7221   my $do_require = 1;
7222   my $can_dist = 0;
7223   my $default_dist = 0;
7224   while (@args)
7225     {
7226       if ($args[0] eq '-noextra')
7227         {
7228           $do_require = 0;
7229         }
7230       elsif ($args[0] eq '-candist')
7231         {
7232           $can_dist = 1;
7233         }
7234       elsif ($args[0] eq '-defaultdist')
7235         {
7236           $default_dist = 1;
7237           $can_dist = 1;
7238         }
7239       elsif ($args[0] !~ /^-/)
7240         {
7241           last;
7242         }
7243       shift (@args);
7244     }
7245
7246   my ($file, $primary, @prefix) = @args;
7247
7248   # Now that configure substitutions are allowed in where_HOW
7249   # variables, it is an error to actually define the primary.  We
7250   # allow 'JAVA', as it is customarily used to mean the Java
7251   # interpreter.  This is but one of several Java hacks.  Similarly,
7252   # 'PYTHON' is customarily used to mean the Python interpreter.
7253   reject_var $primary, "'$primary' is an anachronism"
7254     unless $primary eq 'JAVA' || $primary eq 'PYTHON';
7255
7256   # Get the prefixes which are valid and actually used.
7257   @prefix = am_primary_prefixes ($primary, $can_dist, @prefix);
7258
7259   # If a primary includes a configure substitution, then the EXTRA_
7260   # form is required.  Otherwise we can't properly do our job.
7261   my $require_extra;
7262
7263   my @used = ();
7264   my @result = ();
7265
7266   foreach my $X (@prefix)
7267     {
7268       my $nodir_name = $X;
7269       my $one_name = $X . '_' . $primary;
7270       my $one_var = var $one_name;
7271
7272       my $strip_subdir = 1;
7273       # If subdir prefix should be preserved, do so.
7274       if ($nodir_name =~ /^nobase_/)
7275         {
7276           $strip_subdir = 0;
7277           $nodir_name =~ s/^nobase_//;
7278         }
7279
7280       # If files should be distributed, do so.
7281       my $dist_p = 0;
7282       if ($can_dist)
7283         {
7284           $dist_p = (($default_dist && $nodir_name !~ /^nodist_/)
7285                      || (! $default_dist && $nodir_name =~ /^dist_/));
7286           $nodir_name =~ s/^(dist|nodist)_//;
7287         }
7288
7289
7290       # Use the location of the currently processed variable.
7291       # We are not processing a particular condition, so pick the first
7292       # available.
7293       my $tmpcond = $one_var->conditions->one_cond;
7294       my $where = $one_var->rdef ($tmpcond)->location->clone;
7295
7296       # Append actual contents of where_PRIMARY variable to
7297       # @result, skipping @substitutions@.
7298       foreach my $locvals ($one_var->value_as_list_recursive (location => 1))
7299         {
7300           my ($loc, $value) = @$locvals;
7301           # Skip configure substitutions.
7302           if ($value =~ /^\@.*\@$/)
7303             {
7304               if ($nodir_name eq 'EXTRA')
7305                 {
7306                   error ($where,
7307                          "'$one_name' contains configure substitution, "
7308                          . "but shouldn't");
7309                 }
7310               # Check here to make sure variables defined in
7311               # configure.ac do not imply that EXTRA_PRIMARY
7312               # must be defined.
7313               elsif (! defined $configure_vars{$one_name})
7314                 {
7315                   $require_extra = $one_name
7316                     if $do_require;
7317                 }
7318             }
7319           else
7320             {
7321               # Strip any $(EXEEXT) suffix the user might have added, or this
7322               # will confuse &handle_source_transform and &check_canonical_spelling.
7323               # We'll add $(EXEEXT) back later anyway.
7324               # Do it here rather than in handle_programs so the uniquifying at the
7325               # end of this function works.
7326               ${$locvals}[1] =~ s/\$\(EXEEXT\)$//
7327                 if $primary eq 'PROGRAMS';
7328
7329               push (@result, $locvals);
7330             }
7331         }
7332       # A blatant hack: we rewrite each _PROGRAMS primary to include
7333       # EXEEXT.
7334       append_exeext { 1 } $one_name
7335         if $primary eq 'PROGRAMS';
7336       # "EXTRA" shouldn't be used when generating clean targets,
7337       # all, or install targets.  We used to warn if EXTRA_FOO was
7338       # defined uselessly, but this was annoying.
7339       next
7340         if $nodir_name eq 'EXTRA';
7341
7342       if ($nodir_name eq 'check')
7343         {
7344           push (@check, '$(' . $one_name . ')');
7345         }
7346       else
7347         {
7348           push (@used, '$(' . $one_name . ')');
7349         }
7350
7351       # Is this to be installed?
7352       my $install_p = $nodir_name ne 'noinst' && $nodir_name ne 'check';
7353
7354       # If so, with install-exec? (or install-data?).
7355       my $exec_p = ($nodir_name =~ /$EXEC_DIR_PATTERN/o);
7356
7357       my $check_options_p = $install_p && !! option 'std-options';
7358
7359       # Use the location of the currently processed variable as context.
7360       $where->push_context ("while processing '$one_name'");
7361
7362       # The variable containing all files to distribute.
7363       my $distvar = "\$($one_name)";
7364       $distvar = shadow_unconditionally ($one_name, $where)
7365         if ($dist_p && $one_var->has_conditional_contents);
7366
7367       # Singular form of $PRIMARY.
7368       (my $one_primary = $primary) =~ s/S$//;
7369       $output_rules .= &file_contents ($file, $where,
7370                                        PRIMARY     => $primary,
7371                                        ONE_PRIMARY => $one_primary,
7372                                        DIR         => $X,
7373                                        NDIR        => $nodir_name,
7374                                        BASE        => $strip_subdir,
7375
7376                                        EXEC      => $exec_p,
7377                                        INSTALL   => $install_p,
7378                                        DIST      => $dist_p,
7379                                        DISTVAR   => $distvar,
7380                                        'CK-OPTS' => $check_options_p);
7381     }
7382
7383   # The JAVA variable is used as the name of the Java interpreter.
7384   # The PYTHON variable is used as the name of the Python interpreter.
7385   if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7386     {
7387       # Define it.
7388       define_pretty_variable ($primary, TRUE, INTERNAL, @used);
7389       $output_vars .= "\n";
7390     }
7391
7392   err_var ($require_extra,
7393            "'$require_extra' contains configure substitution,\n"
7394            . "but 'EXTRA_$primary' not defined")
7395     if ($require_extra && ! var ('EXTRA_' . $primary));
7396
7397   # Push here because PRIMARY might be configure time determined.
7398   push (@all, '$(' . $primary . ')')
7399     if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7400
7401   # Make the result unique.  This lets the user use conditionals in
7402   # a natural way, but still lets us program lazily -- we don't have
7403   # to worry about handling a particular object more than once.
7404   # We will keep only one location per object.
7405   my %result = ();
7406   for my $pair (@result)
7407     {
7408       my ($loc, $val) = @$pair;
7409       $result{$val} = $loc;
7410     }
7411   my @l = sort keys %result;
7412   return map { [$result{$_}->clone, $_] } @l;
7413 }
7414
7415
7416 ################################################################
7417
7418 # Each key in this hash is the name of a directory holding a
7419 # Makefile.in.  These variables are local to 'is_make_dir'.
7420 my %make_dirs = ();
7421 my $make_dirs_set = 0;
7422
7423 sub is_make_dir
7424 {
7425     my ($dir) = @_;
7426     if (! $make_dirs_set)
7427     {
7428         foreach my $iter (@configure_input_files)
7429         {
7430             $make_dirs{dirname ($iter)} = 1;
7431         }
7432         # We also want to notice Makefile.in's.
7433         foreach my $iter (@other_input_files)
7434         {
7435             if ($iter =~ /Makefile\.in$/)
7436             {
7437                 $make_dirs{dirname ($iter)} = 1;
7438             }
7439         }
7440         $make_dirs_set = 1;
7441     }
7442     return defined $make_dirs{$dir};
7443 }
7444
7445 ################################################################
7446
7447 # Find the aux dir.  This should match the algorithm used by
7448 # ./configure. (See the Autoconf documentation for for
7449 # AC_CONFIG_AUX_DIR.)
7450 sub locate_aux_dir ()
7451 {
7452   if (! $config_aux_dir_set_in_configure_ac)
7453     {
7454       # The default auxiliary directory is the first
7455       # of ., .., or ../.. that contains install-sh.
7456       # Assume . if install-sh doesn't exist yet.
7457       for my $dir (qw (. .. ../..))
7458         {
7459           if (-f "$dir/install-sh")
7460             {
7461               $config_aux_dir = $dir;
7462               last;
7463             }
7464         }
7465       $config_aux_dir = '.' unless $config_aux_dir;
7466     }
7467   # Avoid unsightly '/.'s.
7468   $am_config_aux_dir =
7469     '$(top_srcdir)' . ($config_aux_dir eq '.' ? "" : "/$config_aux_dir");
7470   $am_config_aux_dir =~ s,/*$,,;
7471 }
7472
7473
7474 # &push_required_file ($DIR, $FILE, $FULLFILE)
7475 # --------------------------------------------------
7476 # Push the given file onto DIST_COMMON.
7477 sub push_required_file
7478 {
7479   my ($dir, $file, $fullfile) = @_;
7480
7481   # If the file to be distributed is in the same directory of the
7482   # currently processed Makefile.am, then we want to distribute it
7483   # from this same Makefile.am.
7484   if ($dir eq $relative_dir)
7485     {
7486       push_dist_common ($file);
7487     }
7488   # This is needed to allow a construct in a non-top-level Makefile.am
7489   # to require a file in the build-aux directory (see at least the test
7490   # script 'test-driver-is-distributed.test').  This is related to the
7491   # automake bug#9546.  Note that the use of $config_aux_dir instead
7492   # of $am_config_aux_dir here is deliberate and necessary.
7493   elsif ($dir eq $config_aux_dir)
7494     {
7495       push_dist_common ("$am_config_aux_dir/$file");
7496     }
7497   # FIXME: another spacial case, for AC_LIBOBJ/AC_LIBSOURCE support.
7498   # We probably need some refactoring of this function and its callers,
7499   # to have a more explicit and systematic handling of all the special
7500   # cases; but, since there are only two of them, this is low-priority
7501   # ATM.
7502   elsif ($config_libobj_dir && $dir eq $config_libobj_dir)
7503     {
7504       # Avoid unsightly '/.'s.
7505       my $am_config_libobj_dir =
7506         '$(top_srcdir)' .
7507         ($config_libobj_dir eq '.' ? "" : "/$config_libobj_dir");
7508       $am_config_libobj_dir =~ s|/*$||;
7509       push_dist_common ("$am_config_libobj_dir/$file");
7510     }
7511   elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7512     {
7513       # If we are doing the topmost directory, and the file is in a
7514       # subdir which does not have a Makefile, then we distribute it
7515       # here.
7516
7517       # If a required file is above the source tree, it is important
7518       # to prefix it with '$(srcdir)' so that no VPATH search is
7519       # performed.  Otherwise problems occur with Make implementations
7520       # that rewrite and simplify rules whose dependencies are found in a
7521       # VPATH location.  Here is an example with OSF1/Tru64 Make.
7522       #
7523       #   % cat Makefile
7524       #   VPATH = sub
7525       #   distdir: ../a
7526       #           echo ../a
7527       #   % ls
7528       #   Makefile a
7529       #   % make
7530       #   echo a
7531       #   a
7532       #
7533       # Dependency '../a' was found in 'sub/../a', but this make
7534       # implementation simplified it as 'a'.  (Note that the sub/
7535       # directory does not even exist.)
7536       #
7537       # This kind of VPATH rewriting seems hard to cancel.  The
7538       # distdir.am hack against VPATH rewriting works only when no
7539       # simplification is done, i.e., for dependencies which are in
7540       # subdirectories, not in enclosing directories.  Hence, in
7541       # the latter case we use a full path to make sure no VPATH
7542       # search occurs.
7543       $fullfile = '$(srcdir)/' . $fullfile
7544         if $dir =~ m,^\.\.(?:$|/),;
7545
7546       push_dist_common ($fullfile);
7547     }
7548   else
7549     {
7550       prog_error "a Makefile in relative directory $relative_dir " .
7551                  "can't add files in directory $dir to DIST_COMMON";
7552     }
7553 }
7554
7555
7556 # If a file name appears as a key in this hash, then it has already
7557 # been checked for.  This allows us not to report the same error more
7558 # than once.
7559 my %required_file_not_found = ();
7560
7561 # &required_file_check_or_copy ($WHERE, $DIRECTORY, $FILE)
7562 # --------------------------------------------------------
7563 # Verify that the file must exist in $DIRECTORY, or install it.
7564 sub required_file_check_or_copy ($$$)
7565 {
7566   my ($where, $dir, $file) = @_;
7567
7568   my $fullfile = "$dir/$file";
7569   my $found_it = 0;
7570   my $dangling_sym = 0;
7571
7572   if (-l $fullfile && ! -f $fullfile)
7573     {
7574       $dangling_sym = 1;
7575     }
7576   elsif (dir_has_case_matching_file ($dir, $file))
7577     {
7578       $found_it = 1;
7579     }
7580
7581   # '--force-missing' only has an effect if '--add-missing' is
7582   # specified.
7583   return
7584     if $found_it && (! $add_missing || ! $force_missing);
7585
7586   # If we've already looked for it, we're done.  You might
7587   # wonder why we don't do this before searching for the
7588   # file.  If we do that, then something like
7589   # AC_OUTPUT(subdir/foo foo) will fail to put foo.in into
7590   # DIST_COMMON.
7591   if (! $found_it)
7592     {
7593       return if defined $required_file_not_found{$fullfile};
7594       $required_file_not_found{$fullfile} = 1;
7595     }
7596   if ($dangling_sym && $add_missing)
7597     {
7598       unlink ($fullfile);
7599     }
7600
7601   my $trailer = '';
7602   my $trailer2 = '';
7603   my $suppress = 0;
7604
7605   # Only install missing files according to our desired
7606   # strictness level.
7607   my $message = "required file '$fullfile' not found";
7608   if ($add_missing)
7609     {
7610       if (-f "$libdir/$file")
7611         {
7612           $suppress = 1;
7613
7614           # Install the missing file.  Symlink if we
7615           # can, copy if we must.  Note: delete the file
7616           # first, in case it is a dangling symlink.
7617           $message = "installing '$fullfile'";
7618
7619           # The license file should not be volatile.
7620           if ($file eq "COPYING")
7621             {
7622               $message .= " using GNU General Public License v3 file";
7623               $trailer2 = "\n    Consider adding the COPYING file"
7624                         . " to the version control system"
7625                         . "\n    for your code, to avoid questions"
7626                         . " about which license your project uses";
7627             }
7628
7629           # Windows Perl will hang if we try to delete a
7630           # file that doesn't exist.
7631           unlink ($fullfile) if -f $fullfile;
7632           if ($symlink_exists && ! $copy_missing)
7633             {
7634               if (! symlink ("$libdir/$file", $fullfile)
7635                   || ! -e $fullfile)
7636                 {
7637                   $suppress = 0;
7638                   $trailer = "; error while making link: $!";
7639                 }
7640             }
7641           elsif (system ('cp', "$libdir/$file", $fullfile))
7642             {
7643               $suppress = 0;
7644               $trailer = "\n    error while copying";
7645             }
7646           set_dir_cache_file ($dir, $file);
7647         }
7648     }
7649   else
7650     {
7651       $trailer = "\n  'automake --add-missing' can install '$file'"
7652         if -f "$libdir/$file";
7653     }
7654
7655   # If --force-missing was specified, and we have
7656   # actually found the file, then do nothing.
7657   return
7658     if $found_it && $force_missing;
7659
7660   # If we couldn't install the file, but it is a target in
7661   # the Makefile, don't print anything.  This allows files
7662   # like README, AUTHORS, or THANKS to be generated.
7663   return
7664     if !$suppress && rule $file;
7665
7666   msg ($suppress ? 'note' : 'error', $where, "$message$trailer$trailer2");
7667 }
7668
7669
7670 # &require_file_internal ($WHERE, $MYSTRICT, $DIRECTORY, $QUEUE, @FILES)
7671 # ----------------------------------------------------------------------
7672 # Verify that the file must exist in $DIRECTORY, or install it.
7673 # $MYSTRICT is the strictness level at which this file becomes required.
7674 # Worker threads may queue up the action to be serialized by the master,
7675 # if $QUEUE is true
7676 sub require_file_internal ($$$@)
7677 {
7678   my ($where, $mystrict, $dir, $queue, @files) = @_;
7679
7680   return
7681     unless $strictness >= $mystrict;
7682
7683   foreach my $file (@files)
7684     {
7685       push_required_file ($dir, $file, "$dir/$file");
7686       if ($queue)
7687         {
7688           queue_required_file_check_or_copy ($required_conf_file_queue,
7689                                              QUEUE_CONF_FILE, $relative_dir,
7690                                              $where, $mystrict, @files);
7691         }
7692       else
7693         {
7694           required_file_check_or_copy ($where, $dir, $file);
7695         }
7696     }
7697 }
7698
7699 # &require_file ($WHERE, $MYSTRICT, @FILES)
7700 # -----------------------------------------
7701 sub require_file ($$@)
7702 {
7703     my ($where, $mystrict, @files) = @_;
7704     require_file_internal ($where, $mystrict, $relative_dir, 0, @files);
7705 }
7706
7707 # &require_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7708 # -----------------------------------------------------------
7709 sub require_file_with_macro ($$$@)
7710 {
7711     my ($cond, $macro, $mystrict, @files) = @_;
7712     $macro = rvar ($macro) unless ref $macro;
7713     require_file ($macro->rdef ($cond)->location, $mystrict, @files);
7714 }
7715
7716 # &require_libsource_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7717 # ----------------------------------------------------------------
7718 # Require an AC_LIBSOURCEd file.  If AC_CONFIG_LIBOBJ_DIR was called, it
7719 # must be in that directory.  Otherwise expect it in the current directory.
7720 sub require_libsource_with_macro ($$$@)
7721 {
7722     my ($cond, $macro, $mystrict, @files) = @_;
7723     $macro = rvar ($macro) unless ref $macro;
7724     if ($config_libobj_dir)
7725       {
7726         require_file_internal ($macro->rdef ($cond)->location, $mystrict,
7727                                $config_libobj_dir, 0, @files);
7728       }
7729     else
7730       {
7731         require_file ($macro->rdef ($cond)->location, $mystrict, @files);
7732       }
7733 }
7734
7735 # &queue_required_file_check_or_copy ($QUEUE, $KEY, $DIR, $WHERE,
7736 #                                     $MYSTRICT, @FILES)
7737 # ---------------------------------------------------------------
7738 sub queue_required_file_check_or_copy ($$$$@)
7739 {
7740     my ($queue, $key, $dir, $where, $mystrict, @files) = @_;
7741     my @serial_loc;
7742     if (ref $where)
7743       {
7744         @serial_loc = (QUEUE_LOCATION, $where->serialize ());
7745       }
7746     else
7747       {
7748         @serial_loc = (QUEUE_STRING, $where);
7749       }
7750     $queue->enqueue ($key, $dir, @serial_loc, $mystrict, 0 + @files, @files);
7751 }
7752
7753 # &require_queued_file_check_or_copy ($QUEUE)
7754 # -------------------------------------------
7755 sub require_queued_file_check_or_copy ($)
7756 {
7757     my ($queue) = @_;
7758     my $where;
7759     my $dir = $queue->dequeue ();
7760     my $loc_key = $queue->dequeue ();
7761     if ($loc_key eq QUEUE_LOCATION)
7762       {
7763         $where = Automake::Location::deserialize ($queue);
7764       }
7765     elsif ($loc_key eq QUEUE_STRING)
7766       {
7767         $where = $queue->dequeue ();
7768       }
7769     else
7770       {
7771         prog_error "unexpected key $loc_key";
7772       }
7773     my $mystrict = $queue->dequeue ();
7774     my $nfiles = $queue->dequeue ();
7775     my @files;
7776     push @files, $queue->dequeue ()
7777       foreach (1 .. $nfiles);
7778     return
7779       unless $strictness >= $mystrict;
7780     foreach my $file (@files)
7781       {
7782         required_file_check_or_copy ($where, $config_aux_dir, $file);
7783       }
7784 }
7785
7786 # &require_conf_file ($WHERE, $MYSTRICT, @FILES)
7787 # ----------------------------------------------
7788 # Looks in configuration path, as specified by AC_CONFIG_AUX_DIR.
7789 sub require_conf_file ($$@)
7790 {
7791     my ($where, $mystrict, @files) = @_;
7792     my $queue = defined $required_conf_file_queue ? 1 : 0;
7793     require_file_internal ($where, $mystrict, $config_aux_dir,
7794                            $queue, @files);
7795 }
7796
7797
7798 # &require_conf_file_with_macro ($COND, $MACRO, $MYSTRICT, @FILES)
7799 # ----------------------------------------------------------------
7800 sub require_conf_file_with_macro ($$$@)
7801 {
7802     my ($cond, $macro, $mystrict, @files) = @_;
7803     require_conf_file (rvar ($macro)->rdef ($cond)->location,
7804                        $mystrict, @files);
7805 }
7806
7807 ################################################################
7808
7809 # &require_build_directory ($DIRECTORY)
7810 # -------------------------------------
7811 # Emit rules to create $DIRECTORY if needed, and return
7812 # the file that any target requiring this directory should be made
7813 # dependent upon.
7814 # We don't want to emit the rule twice, and want to reuse it
7815 # for directories with equivalent names (e.g., 'foo/bar' and './foo//bar').
7816 sub require_build_directory ($)
7817 {
7818   my $directory = shift;
7819
7820   return $directory_map{$directory} if exists $directory_map{$directory};
7821
7822   my $cdir = File::Spec->canonpath ($directory);
7823
7824   if (exists $directory_map{$cdir})
7825     {
7826       my $stamp = $directory_map{$cdir};
7827       $directory_map{$directory} = $stamp;
7828       return $stamp;
7829     }
7830
7831   my $dirstamp = "$cdir/\$(am__dirstamp)";
7832
7833   $directory_map{$directory} = $dirstamp;
7834   $directory_map{$cdir} = $dirstamp;
7835
7836   # Set a variable for the dirstamp basename.
7837   define_pretty_variable ('am__dirstamp', TRUE, INTERNAL,
7838                           '$(am__leading_dot)dirstamp');
7839
7840   # Directory must be removed by 'make distclean'.
7841   $clean_files{$dirstamp} = DIST_CLEAN;
7842
7843   $output_rules .= ("$dirstamp:\n"
7844                     . "\t\@\$(MKDIR_P) $directory\n"
7845                     . "\t\@: > $dirstamp\n");
7846
7847   return $dirstamp;
7848 }
7849
7850 # &require_build_directory_maybe ($FILE)
7851 # --------------------------------------
7852 # If $FILE lies in a subdirectory, emit a rule to create this
7853 # directory and return the file that $FILE should be made
7854 # dependent upon.  Otherwise, just return the empty string.
7855 sub require_build_directory_maybe ($)
7856 {
7857     my $file = shift;
7858     my $directory = dirname ($file);
7859
7860     if ($directory ne '.')
7861     {
7862         return require_build_directory ($directory);
7863     }
7864     else
7865     {
7866         return '';
7867     }
7868 }
7869
7870 ################################################################
7871
7872 # Push a list of files onto dist_common.
7873 sub push_dist_common
7874 {
7875   prog_error "push_dist_common run after handle_dist"
7876     if $handle_dist_run;
7877   Automake::Variable::define ('DIST_COMMON', VAR_AUTOMAKE, '+', TRUE, "@_",
7878                               '', INTERNAL, VAR_PRETTY);
7879 }
7880
7881
7882 ################################################################
7883
7884 # generate_makefile ($MAKEFILE_AM, $MAKEFILE_IN)
7885 # ----------------------------------------------
7886 # Generate a Makefile.in given the name of the corresponding Makefile and
7887 # the name of the file output by config.status.
7888 sub generate_makefile ($$)
7889 {
7890   my ($makefile_am, $makefile_in) = @_;
7891
7892   # Reset all the Makefile.am related variables.
7893   initialize_per_input;
7894
7895   # AUTOMAKE_OPTIONS can contains -W flags to disable or enable
7896   # warnings for this file.  So hold any warning issued before
7897   # we have processed AUTOMAKE_OPTIONS.
7898   buffer_messages ('warning');
7899
7900   # Name of input file ("Makefile.am") and output file
7901   # ("Makefile.in").  These have no directory components.
7902   $am_file_name = basename ($makefile_am);
7903   $in_file_name = basename ($makefile_in);
7904
7905   # $OUTPUT is encoded.  If it contains a ":" then the first element
7906   # is the real output file, and all remaining elements are input
7907   # files.  We don't scan or otherwise deal with these input files,
7908   # other than to mark them as dependencies.  See
7909   # &scan_autoconf_files for details.
7910   my ($makefile, @inputs) = split (/:/, $output_files{$makefile_in});
7911
7912   $relative_dir = dirname ($makefile);
7913   $am_relative_dir = dirname ($makefile_am);
7914   $topsrcdir = backname ($relative_dir);
7915
7916   read_main_am_file ($makefile_am);
7917   if (handle_options)
7918     {
7919       # Process buffered warnings.
7920       flush_messages;
7921       # Fatal error.  Just return, so we can continue with next file.
7922       return;
7923     }
7924   # Process buffered warnings.
7925   flush_messages;
7926
7927   # There are a few install-related variables that you should not define.
7928   foreach my $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
7929     {
7930       my $v = var $var;
7931       if ($v)
7932         {
7933           my $def = $v->def (TRUE);
7934           prog_error "$var not defined in condition TRUE"
7935             unless $def;
7936           reject_var $var, "'$var' should not be defined"
7937             if $def->owner != VAR_AUTOMAKE;
7938         }
7939     }
7940
7941   # Catch some obsolete variables.
7942   msg_var ('obsolete', 'INCLUDES',
7943            "'INCLUDES' is the old name for 'AM_CPPFLAGS' (or '*_CPPFLAGS')")
7944     if var ('INCLUDES');
7945
7946   # Must do this after reading .am file.
7947   define_variable ('subdir', $relative_dir, INTERNAL);
7948
7949   # If DIST_SUBDIRS is defined, make sure SUBDIRS is, so that
7950   # recursive rules are enabled.
7951   define_pretty_variable ('SUBDIRS', TRUE, INTERNAL, '')
7952     if var 'DIST_SUBDIRS' && ! var 'SUBDIRS';
7953
7954   # Check first, because we might modify some state.
7955   check_gnu_standards;
7956   check_gnits_standards;
7957
7958   handle_configure ($makefile_am, $makefile_in, $makefile, @inputs);
7959   handle_gettext;
7960   handle_libraries;
7961   handle_ltlibraries;
7962   handle_programs;
7963   handle_scripts;
7964
7965   handle_silent;
7966
7967   # These must be run after all the sources are scanned.  They
7968   # use variables defined by &handle_libraries, &handle_ltlibraries,
7969   # or &handle_programs.
7970   handle_compile;
7971   handle_languages;
7972   handle_libtool;
7973
7974   # Variables used by distdir.am and tags.am.
7975   define_pretty_variable ('SOURCES', TRUE, INTERNAL, @sources);
7976   if (! option 'no-dist')
7977     {
7978       define_pretty_variable ('DIST_SOURCES', TRUE, INTERNAL, @dist_sources);
7979     }
7980
7981   handle_texinfo;
7982   handle_emacs_lisp;
7983   handle_python;
7984   handle_java;
7985   handle_man_pages;
7986   handle_data;
7987   handle_headers;
7988   handle_subdirs;
7989   handle_user_recursion;
7990   handle_tags;
7991   handle_minor_options;
7992   # Must come after handle_programs so that %known_programs is up-to-date.
7993   handle_tests;
7994
7995   # This must come after most other rules.
7996   handle_dist;
7997
7998   handle_footer;
7999   do_check_merge_target;
8000   handle_all ($makefile);
8001
8002   # FIXME: Gross!
8003   if (var ('lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8004     {
8005       $output_rules .= "install-binPROGRAMS: install-libLTLIBRARIES\n\n";
8006     }
8007   if (var ('nobase_lib_LTLIBRARIES') && var ('bin_PROGRAMS'))
8008     {
8009       $output_rules .= "install-binPROGRAMS: install-nobase_libLTLIBRARIES\n\n";
8010     }
8011
8012   handle_install;
8013   handle_clean ($makefile);
8014   handle_factored_dependencies;
8015
8016   # Comes last, because all the above procedures may have
8017   # defined or overridden variables.
8018   $output_vars .= output_variables;
8019
8020   check_typos;
8021
8022   if ($exit_code != 0)
8023     {
8024       verb "not writing $makefile_in because of earlier errors";
8025       return;
8026     }
8027
8028   mkdir ($am_relative_dir, 0755) if ! -d $am_relative_dir;
8029
8030   # We make sure that 'all:' is the first target.
8031   my $output =
8032     "$output_vars$output_all$output_header$output_rules$output_trailer";
8033
8034   # Decide whether we must update the output file or not.
8035   # We have to update in the following situations.
8036   #  * $force_generation is set.
8037   #  * any of the output dependencies is younger than the output
8038   #  * the contents of the output is different (this can happen
8039   #    if the project has been populated with a file listed in
8040   #    @common_files since the last run).
8041   # Output's dependencies are split in two sets:
8042   #  * dependencies which are also configure dependencies
8043   #    These do not change between each Makefile.am
8044   #  * other dependencies, specific to the Makefile.am being processed
8045   #    (such as the Makefile.am itself, or any Makefile fragment
8046   #    it includes).
8047   my $timestamp = mtime $makefile_in;
8048   if (! $force_generation
8049       && $configure_deps_greatest_timestamp < $timestamp
8050       && $output_deps_greatest_timestamp < $timestamp
8051       && $output eq contents ($makefile_in))
8052     {
8053       verb "$makefile_in unchanged";
8054       # No need to update.
8055       return;
8056     }
8057
8058   if (-e $makefile_in)
8059     {
8060       unlink ($makefile_in)
8061         or fatal "cannot remove $makefile_in: $!";
8062     }
8063
8064   my $gm_file = new Automake::XFile "> $makefile_in";
8065   verb "creating $makefile_in";
8066   print $gm_file $output;
8067 }
8068
8069 ################################################################
8070
8071
8072
8073
8074 ################################################################
8075
8076 # Helper function for usage().
8077 sub print_autodist_files (@)
8078 {
8079   my @lcomm = sort (&uniq (@_));
8080
8081   my @four;
8082   format USAGE_FORMAT =
8083   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
8084   $four[0],           $four[1],           $four[2],           $four[3]
8085 .
8086   local $~ = "USAGE_FORMAT";
8087
8088   my $cols = 4;
8089   my $rows = int(@lcomm / $cols);
8090   my $rest = @lcomm % $cols;
8091
8092   if ($rest)
8093     {
8094       $rows++;
8095     }
8096   else
8097     {
8098       $rest = $cols;
8099     }
8100
8101   for (my $y = 0; $y < $rows; $y++)
8102     {
8103       @four = ("", "", "", "");
8104       for (my $x = 0; $x < $cols; $x++)
8105         {
8106           last if $y + 1 == $rows && $x == $rest;
8107
8108           my $idx = (($x > $rest)
8109                ?  ($rows * $rest + ($rows - 1) * ($x - $rest))
8110                : ($rows * $x));
8111
8112           $idx += $y;
8113           $four[$x] = $lcomm[$idx];
8114         }
8115       write;
8116     }
8117 }
8118
8119
8120 # Print usage information.
8121 sub usage ()
8122 {
8123     print "Usage: $0 [OPTION]... [Makefile]...
8124
8125 Generate Makefile.in for configure from Makefile.am.
8126
8127 Operation modes:
8128       --help               print this help, then exit
8129       --version            print version number, then exit
8130   -v, --verbose            verbosely list files processed
8131       --no-force           only update Makefile.in's that are out of date
8132   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY
8133
8134 Dependency tracking:
8135   -i, --ignore-deps      disable dependency tracking code
8136       --include-deps     enable dependency tracking code
8137
8138 Flavors:
8139       --foreign          set strictness to foreign
8140       --gnits            set strictness to gnits
8141       --gnu              set strictness to gnu
8142
8143 Library files:
8144   -a, --add-missing      add missing standard files to package
8145       --libdir=DIR       set directory storing library files
8146       --print-libdir     print directory storing library files
8147   -c, --copy             with -a, copy missing files (default is symlink)
8148   -f, --force-missing    force update of standard files
8149
8150 ";
8151     Automake::ChannelDefs::usage;
8152
8153     print "\nFiles automatically distributed if found " .
8154           "(always):\n";
8155     print_autodist_files @common_files;
8156     print "\nFiles automatically distributed if found " .
8157           "(under certain conditions):\n";
8158     print_autodist_files @common_sometimes;
8159
8160     print '
8161 Report bugs to <@PACKAGE_BUGREPORT@>.
8162 GNU Automake home page: <@PACKAGE_URL@>.
8163 General help using GNU software: <http://www.gnu.org/gethelp/>.
8164 ';
8165
8166     # --help always returns 0 per GNU standards.
8167     exit 0;
8168 }
8169
8170
8171 # &version ()
8172 # -----------
8173 # Print version information
8174 sub version ()
8175 {
8176   print <<EOF;
8177 automake (GNU $PACKAGE) $VERSION
8178 Copyright (C) $RELEASE_YEAR Free Software Foundation, Inc.
8179 License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
8180 This is free software: you are free to change and redistribute it.
8181 There is NO WARRANTY, to the extent permitted by law.
8182
8183 Written by Tom Tromey <tromey\@redhat.com>
8184        and Alexandre Duret-Lutz <adl\@gnu.org>.
8185 EOF
8186   # --version always returns 0 per GNU standards.
8187   exit 0;
8188 }
8189
8190 ################################################################
8191
8192 # Parse command line.
8193 sub parse_arguments ()
8194 {
8195   my $strict = 'gnu';
8196   my $ignore_deps = 0;
8197   my @warnings = ();
8198
8199   my %cli_options =
8200     (
8201      'version' => \&version,
8202      'help'    => \&usage,
8203      'libdir=s' => \$libdir,
8204      'print-libdir'     => sub { print "$libdir\n"; exit 0; },
8205      'gnu'              => sub { $strict = 'gnu'; },
8206      'gnits'            => sub { $strict = 'gnits'; },
8207      'foreign'          => sub { $strict = 'foreign'; },
8208      'include-deps'     => sub { $ignore_deps = 0; },
8209      'i|ignore-deps'    => sub { $ignore_deps = 1; },
8210      'no-force' => sub { $force_generation = 0; },
8211      'f|force-missing'  => \$force_missing,
8212      'a|add-missing'    => \$add_missing,
8213      'c|copy'           => \$copy_missing,
8214      'v|verbose'        => sub { setup_channel 'verb', silent => 0; },
8215      'W|warnings=s'     => \@warnings,
8216      );
8217
8218   use Automake::Getopt ();
8219   Automake::Getopt::parse_options %cli_options;
8220
8221   set_strictness ($strict);
8222   my $cli_where = new Automake::Location;
8223   set_global_option ('no-dependencies', $cli_where) if $ignore_deps;
8224   for my $warning (@warnings)
8225     {
8226       &parse_warnings ('-W', $warning);
8227     }
8228
8229   return unless @ARGV;
8230
8231   my $errspec = 0;
8232   foreach my $arg (@ARGV)
8233     {
8234       fatal ("empty argument\nTry '$0 --help' for more information")
8235         if ($arg eq '');
8236
8237       # Handle $local:$input syntax.
8238       my ($local, @rest) = split (/:/, $arg);
8239       @rest = ("$local.in",) unless @rest;
8240       my $input = locate_am @rest;
8241       if ($input)
8242         {
8243           push @input_files, $input;
8244           $output_files{$input} = join (':', ($local, @rest));
8245         }
8246       else
8247         {
8248           error "no Automake input file found for '$arg'";
8249           $errspec = 1;
8250         }
8251     }
8252   fatal "no input file found among supplied arguments"
8253     if $errspec && ! @input_files;
8254 }
8255
8256
8257 # handle_makefile ($MAKEFILE_IN)
8258 # ------------------------------
8259 # Deal with $MAKEFILE_IN.
8260 sub handle_makefile ($)
8261 {
8262   my ($file) =  @_;
8263   ($am_file = $file) =~ s/\.in$//;
8264   if (! -f ($am_file . '.am'))
8265     {
8266       error "'$am_file.am' does not exist";
8267     }
8268   else
8269     {
8270       # Any warning setting now local to this Makefile.am.
8271       dup_channel_setup;
8272
8273       generate_makefile ($am_file . '.am', $file);
8274
8275       # Back out any warning setting.
8276       drop_channel_setup;
8277     }
8278 }
8279
8280 # handle_makefiles_serial ()
8281 # --------------------------
8282 # Deal with all makefiles, without threads.
8283 sub handle_makefiles_serial ()
8284 {
8285   foreach my $file (@input_files)
8286     {
8287       handle_makefile ($file);
8288     }
8289 }
8290
8291 # get_number_of_threads ()
8292 # ------------------------
8293 # Logic for deciding how many worker threads to use.
8294 sub get_number_of_threads
8295 {
8296   my $nthreads = $ENV{'AUTOMAKE_JOBS'} || 0;
8297
8298   $nthreads = 0
8299     unless $nthreads =~ /^[0-9]+$/;
8300
8301   # It doesn't make sense to use more threads than makefiles,
8302   my $max_threads = @input_files;
8303
8304   if ($nthreads > $max_threads)
8305     {
8306       $nthreads = $max_threads;
8307     }
8308   return $nthreads;
8309 }
8310
8311 # handle_makefiles_threaded ($NTHREADS)
8312 # -------------------------------------
8313 # Deal with all makefiles, using threads.  The general strategy is to
8314 # spawn NTHREADS worker threads, dispatch makefiles to them, and let the
8315 # worker threads push back everything that needs serialization:
8316 # * warning and (normal) error messages, for stable stderr output
8317 #   order and content (avoiding duplicates, for example),
8318 # * races when installing aux files (and respective messages),
8319 # * races when collecting aux files for distribution.
8320 #
8321 # The latter requires that the makefile that deals with the aux dir
8322 # files be handled last, done by the master thread.
8323 sub handle_makefiles_threaded ($)
8324 {
8325   my ($nthreads) = @_;
8326
8327   # The file queue distributes all makefiles, the message queues
8328   # collect all serializations needed for respective files.
8329   my $file_queue = Thread::Queue->new;
8330   my %msg_queues;
8331   foreach my $file (@input_files)
8332     {
8333       $msg_queues{$file} = Thread::Queue->new;
8334     }
8335
8336   verb "spawning $nthreads worker threads";
8337   my @threads = (1 .. $nthreads);
8338   foreach my $t (@threads)
8339     {
8340       $t = threads->new (sub
8341         {
8342           while (my $file = $file_queue->dequeue)
8343             {
8344               verb "handling $file";
8345               my $queue = $msg_queues{$file};
8346               setup_channel_queue ($queue, QUEUE_MESSAGE);
8347               $required_conf_file_queue = $queue;
8348               handle_makefile ($file);
8349               $queue->enqueue (undef);
8350               setup_channel_queue (undef, undef);
8351               $required_conf_file_queue = undef;
8352             }
8353           return $exit_code;
8354         });
8355     }
8356
8357   # Queue all makefiles.
8358   verb "queuing " . @input_files . " input files";
8359   $file_queue->enqueue (@input_files, (undef) x @threads);
8360
8361   # Collect and process serializations.
8362   foreach my $file (@input_files)
8363     {
8364       verb "dequeuing messages for " . $file;
8365       reset_local_duplicates ();
8366       my $queue = $msg_queues{$file};
8367       while (my $key = $queue->dequeue)
8368         {
8369           if ($key eq QUEUE_MESSAGE)
8370             {
8371               pop_channel_queue ($queue);
8372             }
8373           elsif ($key eq QUEUE_CONF_FILE)
8374             {
8375               require_queued_file_check_or_copy ($queue);
8376             }
8377           else
8378             {
8379               prog_error "unexpected key $key";
8380             }
8381         }
8382     }
8383
8384   foreach my $t (@threads)
8385     {
8386       my @exit_thread = $t->join;
8387       $exit_code = $exit_thread[0]
8388         if ($exit_thread[0] > $exit_code);
8389     }
8390 }
8391
8392 ################################################################
8393
8394 # Parse the WARNINGS environment variable.
8395 parse_WARNINGS;
8396
8397 # Parse command line.
8398 parse_arguments;
8399
8400 $configure_ac = require_configure_ac;
8401
8402 # Do configure.ac scan only once.
8403 scan_autoconf_files;
8404
8405 if (! @input_files)
8406   {
8407     my $msg = '';
8408     $msg = "\nDid you forget AC_CONFIG_FILES([Makefile]) in $configure_ac?"
8409       if -f 'Makefile.am';
8410     fatal ("no 'Makefile.am' found for any configure output$msg");
8411   }
8412
8413 my $nthreads = get_number_of_threads ();
8414
8415 if ($perl_threads && $nthreads >= 1)
8416   {
8417     handle_makefiles_threaded ($nthreads);
8418   }
8419 else
8420   {
8421     handle_makefiles_serial ();
8422   }
8423
8424 exit $exit_code;
8425
8426
8427 ### Setup "GNU" style for perl-mode and cperl-mode.
8428 ## Local Variables:
8429 ## perl-indent-level: 2
8430 ## perl-continued-statement-offset: 2
8431 ## perl-continued-brace-offset: 0
8432 ## perl-brace-offset: 0
8433 ## perl-brace-imaginary-offset: 0
8434 ## perl-label-offset: -2
8435 ## cperl-indent-level: 2
8436 ## cperl-brace-offset: 0
8437 ## cperl-continued-brace-offset: 0
8438 ## cperl-label-offset: -2
8439 ## cperl-extra-newline-before-brace: t
8440 ## cperl-merge-trailing-else: nil
8441 ## cperl-continued-statement-offset: 2
8442 ## End: