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