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