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