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