automake.in

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