automake.in

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