automake.in

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