automake.in

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