automake.in

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