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