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