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