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