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