automake.in

   1 #!@PERL@
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
   6     if $running_under_some_shell;
   7
   8 # automake - create Makefile.in from Makefile.am
   9 # Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
  10
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2, or (at your option)
  14 # any later version.
  15
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  24 # 02111-1307, USA.
  25
  26 # Originally written by David Mackenzie <djm@gnu.ai.mit.edu>.
  27 # Perl reimplementation by Tom Tromey <tromey@drip.colorado.edu>.
  28
  29
  30 # Parameters set by configure.  Not to be changed.  NOTE: assign
  31 # VERSION as string so that eg version 0.30 will print correctly.
  32 $VERSION = "@VERSION@";
  33 $prefix = "@prefix@";
  34 $am_dir = "@datadir@/@PACKAGE@";
  35
  36 # String constants.
  37 $IGNORE_PATTERN = "^##([^#].*)?\$";
  38 $WHITE_PATTERN = "^[ \t]*\$";
  39 $COMMENT_PATTERN = "^#";
  40 $RULE_PATTERN = "^([a-zA-Z_.][-.a-zA-Z0-9_.]*) *:";
  41 $MACRO_PATTERN = "^([A-Za-z][A-Za-z0-9_]*)[ \t]*=[ \t]*(.*)\$";
  42
  43
  44 # Constants to define the "strictness" level.
  45 $NORMAL = 0;
  46 $GNU = 1;
  47 $GNITS = 2;
  48
  49 \f
  50
  51 # Variables global to entire run.
  52
  53 # Strictness level as set on command line.
  54 $default_strictness = $NORMAL;
  55
  56 # Name of strictness level, as set on command line.
  57 $default_strictness_name = 'normal';
  58
  59 # This is TRUE if GNU make specific automatic dependency generation
  60 # code should be included in generated Makefile.in.
  61 $cmdline_use_dependencies = 1;
  62
  63 # This holds our (eventual) exit status.  We don't actually exit until
  64 # we have processed all input files.
  65 $exit_status = 0;
  66
  67 # From the Perl manual.
  68 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
  69
  70 # TRUE if missing standard files should be installed.
  71 $install_missing = 0;
  72
  73 # Files found by scanning configure.in for LIBOBJS.
  74 %libsources = ();
  75
  76 # True if fp_C_PROTOTYPES appears in configure.in.
  77 $fp_c_prototypes = 0;
  78
  79 # Names used in AC_CONFIG_HEADER call.  $config_name is the actual
  80 # (first) argument.  $config_header is the '.in' file.  Ordinarily the
  81 # second is derived from the first, but they can be different if the
  82 # weird "NAME:FILE" syntax is used.
  83 $config_name = '';
  84 $config_header = '';
  85
  86 # Relative location of top build directory.
  87 $top_builddir = '';
  88
  89 # List of Makefile.am's to process.
  90 @input_files = ();
  91
  92 # List of files in AC_OUTPUT without Makefile.am.
  93 @other_input_files = ();
  94
  95 # Whether AC_PROG_MAKE_SET has been seen in configure.in.
  96 $seen_make_set = 0;
  97
  98 # Whether ud_GNU_GETTEXT has been seen in configure.in.
  99 $seen_gettext = 0;
 100
 101 # 1 if AC_PROG_INSTALL seen, 2 if fp_PROG_INSTALL seen.
 102 $seen_prog_install = 0;
 103
 104 # 1 if any scripts installed, 0 otherwise.
 105 $scripts_installed = 0;
 106
 107 # Whether AC_PATH_XTRA has been seen in configure.in
 108 $seen_path_xtra = 0;
 109
 110 # Charsets used by maintainer and in distribution.  MAINT_CHARSET is
 111 # handled in a funny way: if seen in the top-level Makefile.am, it is
 112 # used for every directory which does not specify a different value.
 113 # The rationale here is that some directories (eg gettext) might be
 114 # distributions of other packages, and thus require their own charset
 115 # info.  However, the DIST_CHARSET must be the same for the entire
 116 # package; it can only be set at top-level.
 117 # FIXME this yields bugs when rebuilding.  What to do?  Always
 118 # read (and sometimes discard) top-level Makefile.am?
 119 $maint_charset = '';
 120 $dist_charset = 'utf8';         # recode doesn't support this yet.
 121
 122 \f
 123
 124 &initialize_global_constants;
 125
 126 # Parse command line.
 127 &parse_arguments (@ARGV);
 128
 129 # Do configure.in scan only once.
 130 &scan_configure;
 131
 132 die "automake: no \`Makefile.am' found or specified\n"
 133     if ! @input_files;
 134
 135 # Now do all the work on each file.
 136 foreach $am_file (@input_files)
 137 {
 138     # FIXME should support the AC_OUTPUT ":" syntax here.
 139     if (! -f ($am_file . '.am'))
 140     {
 141         &am_error ('no such file');
 142     }
 143     else
 144     {
 145         &generate_makefile ($am_file);
 146     }
 147 }
 148
 149 &am_conf_error (($scripts_installed ? 'fp_PROG_INSTALL' : 'AC_PROG_INSTALL')
 150                 . " must be used in configure.in")
 151     unless $seen_prog_install > $scripts_installed;
 152
 153 exit $exit_status;
 154
 155
 156 ################################################################
 157
 158 # Parse command line.
 159 sub parse_arguments
 160 {
 161     local (@arglist) = @_;
 162
 163     # Start off as normal.
 164     &set_strictness ('normal');
 165
 166     while (@arglist)
 167     {
 168         if ($arglist[0] eq "--version")
 169         {
 170             print "Automake version $VERSION\n";
 171             exit 0;
 172         }
 173         elsif ($arglist[0] eq "--help")
 174         {
 175             &usage;
 176         }
 177         elsif ($arglist[0] =~ /^--amdir=(.+)$/)
 178         {
 179             $am_dir = $1;
 180         }
 181         elsif ($arglist[0] eq '--amdir')
 182         {
 183             &require_argument (@arglist);
 184             shift (@arglist);
 185             $am_dir = $arglist[0];
 186         }
 187         elsif ($arglist[0] =~ /^--strictness=(.+)$/)
 188         {
 189             &set_strictness ($1);
 190         }
 191         elsif ($arglist[0] eq '--gnu')
 192         {
 193             &set_strictness ('gnu');
 194         }
 195         elsif ($arglist[0] eq '--gnits')
 196         {
 197             &set_strictness ('gnits');
 198         }
 199         elsif ($arglist[0] eq '--strictness')
 200         {
 201             &require_argument (@arglist);
 202             shift (@arglist);
 203             &set_strictness ($arglist[0]);
 204         }
 205         elsif ($arglist[0] eq '--include-deps')
 206         {
 207             $cmdline_use_dependencies = 0;
 208         }
 209         elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
 210         {
 211             # Set output directory.
 212             $output_directory = $1;
 213         }
 214         elsif ($arglist[0] eq '--output-dir')
 215         {
 216             &require_argument (@arglist);
 217             shift (@arglist);
 218             $output_directory = $arglist[0];
 219         }
 220         elsif ($arglist[0] eq '--install-missing')
 221         {
 222             $install_missing = 1;
 223         }
 224         elsif ($arglist[0] eq '--')
 225         {
 226             # Stop option processing.
 227             shift (@arglist);
 228             push (@input_files, @arglist);
 229             last;
 230         }
 231         elsif ($arglist[0] =~ /^-/)
 232         {
 233             die "automake: unrecognized option -- \`$arglist[0]'\n";
 234         }
 235         else
 236         {
 237             push (@input_files, $arglist[0]);
 238         }
 239
 240         shift (@arglist);
 241     }
 242
 243     # Take global strictness from whatever we currently have set.
 244     $default_strictness = $strictness;
 245     $default_strictness_name = $strictness_name;
 246 }
 247
 248 # Ensure argument exists, or die.
 249 sub require_argument
 250 {
 251     local ($arg, @arglist) = @_;
 252     die "automake: no argument given for option \`$arg'\n"
 253         if ! @arglist;
 254 }
 255
 256 ################################################################
 257
 258 # Generate a Makefile.in given the name of the corresponding Makefile.
 259 sub generate_makefile
 260 {
 261     local ($makefile) = @_;
 262
 263     # print "creating ", $makefile, ".in\n";
 264
 265     &initialize_per_input;
 266     $relative_dir = &dirname ($makefile);
 267     # FIXME with new 'dist' target, don't need Makefile.in.  Probably
 268     # should remove it here.
 269     &push_dist_common ('Makefile.in', 'Makefile.am');
 270     push (@sources, '$(SOURCES)') if defined $contents{'SOURCES'};
 271     push (@objects, '$(OBJECTS)') if defined $contents{'OBJECTS'};
 272
 273     # This is always the default target.  This gives us freedom to do
 274     # things in whatever order is convenient.
 275     $output_rules .= "default: all\n\n";
 276     push (@phony, 'default');
 277
 278     &read_am_file ($makefile . '.am');
 279     &handle_options;
 280
 281     # Check first, because we might modify some state.
 282     &check_gnu_standards;
 283     &check_gnits_standards;
 284
 285     &handle_configure;
 286     &handle_libraries;
 287     &handle_programs;
 288     &handle_scripts;
 289
 290     # Re-init SOURCES and OBJECTS.  FIXME other code shouldn't depend
 291     # on this (but currently does).
 292     $contents{'SOURCES'} = join (' ', @sources);
 293     $contents{'OBJECTS'} = join (' ', @objects);
 294
 295     &handle_texinfo;
 296     &handle_man_pages;
 297     &handle_data;
 298     &handle_headers;
 299     &handle_subdirs;
 300     &handle_tags;
 301     &handle_dist;
 302     &handle_dependencies;
 303     &handle_footer;
 304     &handle_merge_targets;
 305     &handle_installdirs;
 306     &handle_clean;
 307     &handle_phony;
 308
 309     if (! -d ($output_directory . '/' . $relative_dir))
 310     {
 311         &mkdir ($output_directory . '/' . $relative_dir);
 312     }
 313     if (! open (GM_FILE, "> " . $output_directory . '/' . $makefile . ".in"))
 314     {
 315         warn "automake: ${am_file}.in: cannot open: $!\n";
 316         $exit_status = 1;
 317         return;
 318     }
 319
 320     print GM_FILE $output_vars;
 321     print GM_FILE $output_rules;
 322     print GM_FILE $output_trailer;
 323
 324     close (GM_FILE);
 325 }
 326
 327 ################################################################
 328
 329 # Handle AUTOMAKE_OPTIONS variable.
 330 sub handle_options
 331 {
 332     return if ! defined $contents{'AUTOMAKE_OPTIONS'};
 333
 334     foreach (split (/\s+/, $contents{'AUTOMAKE_OPTIONS'}))
 335     {
 336         $options{$_} = 1;
 337         if ($_ eq 'gnits' || $_ eq 'gnu' || $_ eq 'normal')
 338         {
 339             &set_strictness ($_);
 340         }
 341         elsif ($_ eq 'no-installman' || $_ eq 'ansi2knr' || $_ eq 'dist-shar')
 342         {
 343             # Explicitly recognize these.
 344         }
 345         elsif ($_ eq 'no-dependencies')
 346         {
 347             $use_dependencies = 0;
 348         }
 349         elsif (/[0-9]+\.?[0-9]+/)
 350         {
 351             # Got a version number.  Is the syntax too strict?
 352             if ($VERSION < $_)
 353             {
 354                 &am_error ("require version $_, only have $VERSION");
 355                 # FIXME -- what else to do?
 356                 exit 1;
 357             }
 358         }
 359         else
 360         {
 361             &am_error ('option ', $_, 'not recognized');
 362         }
 363     }
 364 }
 365
 366 # Return object extension.  Just once, put some code into the output.
 367 sub get_object_extension
 368 {
 369     if (! $dir_holds_sources)
 370     {
 371         # Boilerplate.
 372         local ($xform) = '';
 373         if (defined $contents{'CONFIG_HEADER'})
 374         {
 375             ($xform = &dirname ($contents{'CONFIG_HEADER'}))
 376                 =~ s/(\W)/\\$1/g;
 377             $xform = 's/\@CONFIG_INCLUDE_SPEC\@/-I' . $xform . '/go';
 378         }
 379         $output_vars .= &file_contents_with_transform ($xform,
 380                                                        'compile-vars');
 381         $output_rules .= &file_contents ('compile');
 382         &push_phony_cleaners ('compile');
 383
 384         # If using X, include some extra variable definitions.  NOTE
 385         # we don't want to force these into CFLAGS or anything,
 386         # because not all programs will necessarily use X.
 387         if ($seen_path_xtra)
 388         {
 389             $output_vars .= ("X_CFLAGS = \@X_CFLAGS\@\n"
 390                              . "X_LIBS = \@X_LIBS\@\n"
 391                              . "X_EXTRA_LIBS = \@X_EXTRA_LIBS\@\n"
 392                              . "X_PRE_LIBS = \@X_PRE_LIBS\@\n");
 393         }
 394
 395         # Check for automatic de-ANSI-fication.
 396         $dir_holds_sources = '.o';
 397         push (@suffixes, '.c', '.o');
 398         push (@clean, 'compile');
 399
 400         if (defined $options{'ansi2knr'} || defined $contents{'@kr@'})
 401         {
 402             &am_error ("option \`ansi2knr' in use but \`fp_C_PROTOTYPES' not in configure.in")
 403                 if ! $fp_c_prototypes;
 404
 405             $dir_holds_sources = '$o';
 406             push (@suffixes, '._c', '._o');
 407
 408             &require_file ($NORMAL, 'ansi2knr.c', 'ansi2knr.1');
 409
 410             $output_vars .= &file_contents ('kr-vars');
 411             $output_rules .= &file_contents ('compile-kr');
 412             $output_rules .= &file_contents ('clean-kr');
 413
 414             push (@clean, 'kr');
 415             &push_phony_cleaners ('kr');
 416         }
 417     }
 418     return $dir_holds_sources;
 419 }
 420
 421 # Handle SOURCE->OBJECT transform for one program or library.
 422 sub handle_source_transform
 423 {
 424     local ($one_file, $obj) = @_;
 425     local ($objpat) = $obj;
 426     $objpat =~ s/(\W)/\\$1/g;
 427
 428     # Look for file_SOURCES and file_OBJECTS.
 429     if (defined $contents{$one_file . "_SOURCES"})
 430     {
 431         if (! defined $contents{$one_file . "_OBJECTS"})
 432         {
 433             # Turn sources into objects.
 434             local (@files) = split (/\s+/, $contents{$one_file . "_SOURCES"});
 435             local (@result) = ();
 436             foreach (@files)
 437             {
 438                 # Skip header files.
 439                 next if /\.h$/;
 440                 # Skip things that look like macro references.
 441                 next if /^\$\(.*\)$/;
 442                 next if /^\$\{.*\}$/;
 443
 444                 if (/^(.*)\.[yl]$/)
 445                 {
 446                     # Automatically include generated .c file in
 447                     # distribution.
 448                     &push_dist_common ($1 . '.c');
 449                 }
 450
 451                 # Transform source files into .o files.
 452                 s/\.cc$/$obj/g;
 453                 s/\.[cCmylfs]$/$obj/g;
 454                 push (@result, $_);
 455
 456                 # Transform .o or $o file into .P file (for automatic
 457                 # dependency code).
 458                 s/$objpat$/.P/g;
 459                 $dep_files{'$(srcdir)/.deps/' . $_} = 1;
 460             }
 461
 462             &pretty_print ($one_file . "_OBJECTS =", "    ", @result);
 463         }
 464         else
 465         {
 466             &am_error ($one_file . '_OBJECTS', 'should not be defined');
 467         }
 468
 469         push (@sources, '$(' . $one_file . "_SOURCES)");
 470         push (@objects, '$(' . $one_file . "_OBJECTS)");
 471     }
 472     else
 473     {
 474         $output_vars .= ($one_file . "_SOURCES = " . $one_file . ".c\n"
 475                          . $one_file . "_OBJECTS = ". $one_file
 476                          . $obj . "\n");
 477         push (@sources, $one_file . '.c');
 478         push (@objects, $one_file . $obj);
 479         $dep_files{'$(srcdir)/.deps/' . $one_file . '.P'} = 1;
 480     }
 481
 482     if (defined $contents{'CONFIG_HEADER'})
 483     {
 484         $output_rules .= ('$(' . $one_file . "_OBJECTS): "
 485                           . $contents{'CONFIG_HEADER'} . "\n");
 486     }
 487
 488     return @result;
 489 }
 490
 491 # Handle C programs.
 492 sub handle_programs
 493 {
 494     local (@proglist) = &am_install_var ('-clean',
 495                                          'programs', 'PROGRAMS',
 496                                          'bin', 'sbin', 'libexec', 'pkglib',
 497                                          'noinst');
 498     # FIXME error if PROGRAMS defined but no blah_PROGRAMS defined.
 499     return if ! @proglist;
 500
 501     local ($obj) = &get_object_extension;
 502     local ($one_file, $munge);
 503
 504     foreach $one_file (@proglist)
 505     {
 506         &handle_source_transform ($one_file, $obj);
 507
 508         if (! defined $contents{$one_file . "_LDADD"})
 509         {
 510             # User didn't define prog_LDADD override.  So do it.
 511             $output_vars .= $one_file . '_LDADD = $(LDADD)' . "\n";
 512         }
 513
 514         $output_rules .=
 515             &file_contents_with_transform ('s/\@PROGRAM\@/' . $one_file
 516                                            . '/go', 'program');
 517     }
 518 }
 519
 520 # Handle libraries.
 521 sub handle_libraries
 522 {
 523     local (@liblist) = &am_install_var ('-no-all', '-clean',
 524                                         'libraries', 'LIBRARIES',
 525                                         'lib', 'pkglib', 'noinst');
 526     # FIXME error if LIBRARIES defined but no blah_LIBRARIES defined.
 527     return if ! @liblist;
 528
 529     # Generate _LIBFILES variables.  Too bad we can't do this in
 530     # am_install_var.
 531     local ($onedir, $onelib);
 532     local (@outlist);
 533     foreach $onedir ('lib', 'pkglib', 'noinst')
 534     {
 535         if (defined $contents{$onedir . '_LIBRARIES'})
 536         {
 537             @outlist = ();
 538             foreach $onelib (split (/\s+/, $contents{$onedir . '_LIBRARIES'}))
 539             {
 540                 push (@outlist, 'lib' . $onelib . '.a');
 541             }
 542             &pretty_print ($onedir . '_LIBFILES =', "    ", @outlist);
 543         }
 544     }
 545     push (@all, '$(LIBFILES)');
 546
 547     local ($obj) = &get_object_extension;
 548     local ($munge);
 549     foreach $onelib (@liblist)
 550     {
 551         if (defined $contents{$onelib . '_LIBADD'})
 552         {
 553             # We recognize certain things that are commonly put in
 554             # LIBADD.
 555             local ($lsearch);
 556
 557             foreach $lsearch (split (/\s+/, $contents{$onelib . '_LIBADD'}))
 558             {
 559                 # Automatically handle @LIBOBJS@ and @ALLOCA@.
 560                 # Basically this means adding entries to dep_files.
 561                 if ($lsearch eq '@LIBOBJS@')
 562                 {
 563                     local ($iter, $rewrite);
 564                     foreach $iter (keys %libsources)
 565                     {
 566                         if ($iter ne 'alloca.c')
 567                         {
 568                             ($rewrite = $iter) =~ s/\.c$/.P/;
 569                             $dep_files{'$(srcdir)/.deps/' . $rewrite} = 1;
 570                             &require_file ($NORMAL, $iter);
 571                         }
 572                     }
 573                 }
 574                 elsif ($lsearch eq '@ALLOCA@')
 575                 {
 576                     &am_error ("\@ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
 577                         if ! defined $libsources{'alloca.c'};
 578                     $dep_files{'$(srcdir)/.deps/alloca.P'} = 1;
 579                     &require_file ($NORMAL, 'alloca.c');
 580                 }
 581             }
 582         }
 583         else
 584         {
 585             # Generate support for conditional object inclusion in
 586             # libraries.
 587             $output_vars .= $onelib . "_LIBADD =\n";
 588         }
 589
 590         &handle_source_transform ($onelib, $obj);
 591
 592         $output_rules .=
 593             &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go',
 594                                            'library');
 595     }
 596
 597     # Turn "foo" into "libfoo.a" and include macro definition.
 598     grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
 599
 600     if (! defined $contents{'LIBFILES'})
 601     {
 602         &pretty_print ('LIBFILES = ', "    ", @liblist);
 603     }
 604     $output_vars .= &file_contents ('libraries-vars');
 605 }
 606
 607 # Handle scripts.
 608 sub handle_scripts
 609 {
 610     # FIXME can't determine if these scripts are really being
 611     # installed or not.
 612     $scripts_installed = &am_install_var ('-clean',
 613                                           'scripts', 'SCRIPTS',
 614                                           'bin', 'sbin', 'libexec', 'noinst');
 615 }
 616
 617 # Search a file for a "version.texi" Texinfo include.  Return the name
 618 # of the include file if found, or the empty string if not.  A
 619 # "version.texi" file is actually any file whose name matches
 620 # "vers*.texi".
 621 sub grep_for_vers_texi
 622 {
 623     local ($filename) = @_;
 624
 625     if (! open (TEXI, $filename))
 626     {
 627         &am_error ("couldn't open \`$filename': $!");
 628         return '';
 629     }
 630
 631     while (<TEXI>)
 632     {
 633         if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
 634         {
 635             # Found it.
 636             close (TEXI);
 637             return $1;
 638         }
 639     }
 640
 641     close (TEXI);
 642     return '';
 643 }
 644
 645 # Handle all Texinfo source.
 646 sub handle_texinfo
 647 {
 648     # FIXME can this really be right?  Might want to have configure
 649     # determine list of texinfos.  Fix this when someone complains.
 650     &am_error ("\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
 651         if defined $contents{'TEXINFOS'};
 652     return if (! defined $contents{'info_TEXINFOS'}
 653                && ! defined $contents{'html_TEXINFOS'});
 654
 655     local (@texis) = split (/\s+/, $contents{'info_TEXINFOS'});
 656
 657     local (@infos_list, @info_deps_list, @dvis_list, @texi_deps);
 658     local ($infobase, $info_cursor);
 659     local (%versions);
 660     local ($done) = 0;
 661     local ($vti);
 662     local ($tc_cursor, @texi_cleans);
 663
 664     foreach $info_cursor (@texis)
 665     {
 666         ($infobase = $info_cursor) =~ s/\.texi$//;
 667
 668         # If 'version.texi' is referenced by input file, then include
 669         # automatic versioning capability.
 670         local ($vtexi)
 671             = &grep_for_vers_texi ($relative_dir . "/" . $info_cursor);
 672         if ($vtexi)
 673         {
 674             &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
 675                 if (defined $versions{$vtexi});
 676             $versions{$vtexi} = $info_cursor;
 677
 678             # Got a hit.
 679             push (@texis, $vtexi);
 680             # We number the stamp-vti files.  This is doable since the
 681             # actual names don't matter much.  We only number starting
 682             # with the second one, so that the common case looks nice.
 683             $vti = 'vti' . ($done ? $done : '');
 684             &push_dist_common ($vtexi, 'stamp-' . $vti);
 685             push (@clean, $vti);
 686
 687             $output_rules .=
 688                 &file_contents_with_transform
 689                     ('s/\@TEXI\@/' . $info_cursor . '/g; '
 690                      . 's/\@VTI\@/' . $vti . '/g; '
 691                      . 's/\@VTEXI\@/' . $vtexi . '/g',
 692                      'texi-version');
 693
 694             &push_phony_cleaners ($vti);
 695
 696             # Only require once.
 697             &require_file ($NORMAL, 'mdate-sh') if ! $done;
 698             ++$done;
 699         }
 700
 701         # If user specified file_TEXINFOS, then use that as explicit
 702         # dependency list.
 703         @texi_deps = ();
 704         push (@texi_deps, $info_cursor, $vtexi);
 705         if (defined $contents{$infobase . "_TEXINFOS"})
 706         {
 707             push (@texi_deps, "\$" . $infobase . '_TEXINFOS');
 708             &push_dist_common ("\$" . $infobase . '_TEXINFOS');
 709         }
 710
 711         $output_rules .= ("\n" . $infobase . ".info: "
 712                           . join (' ', @texi_deps) . "\n\n");
 713
 714         push (@infos_list, $infobase . '.info*');
 715         push (@info_deps_list, $infobase . '.info');
 716         push (@dvis_list, $infobase . '.dvi');
 717
 718         # Generate list of things to clean for this target.  We do
 719         # this explicitly because otherwise too many things could be
 720         # removed.  In particular the ".log" extension might
 721         # reasonably be used in other contexts by the user.
 722         foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns',
 723                             'ky', 'log', 'pg', 'toc', 'tp', 'vr', 'op')
 724         {
 725             push (@texi_cleans, $infobase . '.' . $tc_cursor);
 726         }
 727     }
 728
 729     # Some boilerplate.
 730     $output_vars .= &file_contents ('texinfos-vars');
 731     $output_rules .= &file_contents ('texinfos');
 732     push (@phony, 'install-info', 'uninstall-info');
 733
 734     # How to clean.
 735     $output_rules .= "\nmostlyclean-info:\n";
 736     &pretty_print_rule ("\trm -f", "\t  ", @texi_cleans);
 737     $output_rules .= ("\nclean-info:\n\ndistclean-info:\n\n"
 738                       . "maintainer-clean-info:\n\t"
 739                       . 'rm -f $(INFOS)' . "\n");
 740     &push_phony_cleaners ('info');
 741
 742     push (@suffixes, '.texi', '.info', '.dvi');
 743     push (@uninstall, 'uninstall-info');
 744     push (@clean, 'info');
 745     push (@info, '$(INFO_DEPS)');
 746     push (@dvi, '$(DVIS)');
 747     push (@installdirs, '$(infodir)');
 748     unshift (@install_data, 'install-info');
 749
 750     # Make sure documentation is made and installed first.  Use
 751     # $(INFO_DEPS), not 'info', because otherwise recursive makes get
 752     # run twice during "make all".  FIXME add test case.
 753     unshift (@all, '$(INFO_DEPS)');
 754
 755     $output_vars .= ("INFOS = " . join (' ', @infos_list) . "\n"
 756                      . "INFO_DEPS = " . join (' ', @info_deps_list)  . "\n"
 757                      . "DVIS = " . join (' ', @dvis_list) . "\n"
 758                      # This next isn't strictly needed now -- the
 759                      # places that look here could easily be changed
 760                      # to look in info_TEXINFOS.  But this is probably
 761                      # better, in case noinst_TEXINFOS is ever
 762                      # supported.
 763                      . "TEXINFOS = " . $contents{'info_TEXINFOS'} . "\n\n");
 764
 765     # Do some error checking.
 766     &require_file ($NORMAL, 'texinfo.tex');
 767 }
 768
 769 # Handle any man pages.
 770 sub handle_man_pages
 771 {
 772     &am_error ("\`MANS' is an anachronism; use \`man_MANS'")
 773         if defined $contents{'MANS'};
 774     return if ! defined $contents{'man_MANS'};
 775
 776     # We generate the manpage install code by hand to avoid the use of
 777     # basename in the generated Makefile.
 778     local (@mans) = split (/\s+/, $contents{'man_MANS'});
 779     local (%sections, %inames, %secmap, %fullsecmap);
 780     foreach (@mans)
 781     {
 782         # FIXME: statement without effect:
 783         /^(.*)\.([0-9])([a-z]*)$/;
 784         $sections{$2} = 1;
 785         $inames{$1} = $_;
 786         $secmap{$1} = $2;
 787         $fullsecmap{$1} = $2 . $3;
 788     }
 789
 790     # We don't really need this, but we use it in case we ever want to
 791     # support noinst_MANS.
 792     $output_vars .= "MANS = " . $contents{'man_MANS'} . "\n";
 793
 794     # Generate list of install dirs.
 795     $output_rules .= "install-man: \$(MANS)\n";
 796     foreach (keys %sections)
 797     {
 798         push (@installdirs, '$(mandir)/man' . $_);
 799         $output_rules .= ("\t" . '$(top_srcdir)/mkinstalldirs $(mandir)/man'
 800                           . $_ . "\n");
 801     }
 802     push (@phony, 'install-man');
 803
 804     # Generate install target.
 805     local ($key);
 806     foreach $key (keys %inames)
 807     {
 808         $_ = $install_man_format;
 809         s/\@SECTION\@/$secmap{$key}/g;
 810         s/\@MAN\@/$inames{$key}/g;
 811         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 812         s/\@MANBASE\@/$key/g;
 813         $output_rules .= $_;
 814     }
 815     $output_rules .= "\n";
 816
 817     $output_rules .= "uninstall-man:\n";
 818     foreach $key (keys %inames)
 819     {
 820         $_ = $uninstall_man_format;
 821         s/\@SECTION\@/$secmap{$key}/g;
 822         s/\@MAN\@/$inames{$key}/g;
 823         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 824         s/\@MANBASE\@/$key/g;
 825         $output_rules .= $_;
 826     }
 827     $output_rules .= "\n";
 828     push (@phony, 'uninstall-man');
 829
 830     $output_vars .= &file_contents ('mans-vars');
 831
 832     if (! defined $options{'no-installman'})
 833     {
 834         push (@install_data, 'install-man');
 835         push (@uninstall, 'uninstall-man');
 836         push (@all, '$(MANS)');
 837     }
 838 }
 839
 840 # Handle DATA variables.
 841 sub handle_data
 842 {
 843     &am_install_var ('data', 'DATA', 'data', 'sysconf',
 844                      'sharedstate', 'localstate', 'pkgdata',
 845                      'noinst');
 846 }
 847
 848 # Handle TAGS.
 849 sub handle_tags
 850 {
 851     local ($tagging) = 0;
 852
 853     push (@phony, 'tags');
 854     if (defined $contents{'SUBDIRS'})
 855     {
 856         $output_rules .= &file_contents ('tags');
 857         $tagging = 1;
 858     }
 859     elsif ($dir_holds_sources || defined $contents{'ETAGS_ARGS'})
 860     {
 861         $output_rules .= &file_contents ('tags-subd');
 862         $tagging = 1;
 863     }
 864
 865     if ($tagging)
 866     {
 867         $output_rules .= &file_contents ('tags-clean');
 868         push (@clean, 'tags');
 869         &push_phony_cleaners ('tags');
 870     }
 871     else
 872     {
 873         # Every Makefile must define some sort of TAGS rule.
 874         # Otherwise, it would be possible for a top-level "make TAGS"
 875         # to fail because some subdirectory failed.
 876         $output_rules .= "tags: TAGS\nTAGS:\n\n";
 877     }
 878 }
 879
 880 # Generate actual 'dist' (or dist-shar) rule.
 881 sub handle_dist_worker
 882 {
 883     local ($distshar) = @_;
 884     local ($target) = $distshar ? 'dist-shar' : 'dist';
 885
 886     $output_rules .= $target . ': $(DEP_DISTFILES)' . "\n";
 887
 888     # Initialization; only at top level.
 889     if ($relative_dir eq '.')
 890     {
 891         if ($strictness >= $GNITS)
 892         {
 893             # For Gnits users, this is pretty handy.  Look at 15 lines
 894             # in case some explanatory text is desirable.
 895             $output_rules .= '  @if sed 15q NEWS | grep -e "$(VERSION)" > /dev/null; then :; else \\
 896           echo "NEWS not updated; not releasing" 1>&2; \\
 897           exit 1;                               \\
 898         fi
 899 ';
 900         }
 901
 902
 903         $output_rules .=
 904             (
 905              # Create dist directory.
 906              '  rm -rf $(distdir)
 907         mkdir $(distdir)
 908         chmod 777 $(distdir)
 909 '
 910              # We need an absolute path for --output-dir.  Thus the
 911              # weirdness.
 912              . '        distdir=`cd $(distdir) && pwd` \\
 913           && cd $(srcdir) \\
 914           && automake --include-deps --output-dir=$$distdir --strictness='
 915              # Set strictness of output.
 916              . $strictness_name . "\n"
 917              );
 918     }
 919
 920     # In loop, test for file existence because sometimes a file gets
 921     # included in DISTFILES twice.  For example this happens when a
 922     # single source file is used in building more than one program.
 923     # Also, there are situations in which "ln" can fail.  For instance
 924     # a file to distribute could actually be a cross-filesystem
 925     # symlink -- this can easily happen if "gettextize" was run on the
 926     # distribution.  Note that DISTFILES can contain a wildcard (for
 927     # info files, sigh), so we must use the echo trick.
 928
 929     $output_rules .= '  @for file in `cd $(srcdir) && echo $(DISTFILES)`; do \\
 930           test -f $(distdir)/$$file \\
 931           || ln $(srcdir)/$$file $(distdir)/$$file 2> /dev/null \\
 932           || cp -p $(srcdir)/$$file $(distdir)/$$file; \\
 933         done
 934 ';
 935
 936     # If we have SUBDIRS, create all dist subdirectories and do
 937     # recursive build.
 938     if (defined $contents{'SUBDIRS'})
 939     {
 940         # Test for directory existence here because previous automake
 941         # invocation might have created some directories.
 942         $output_rules .= '      for subdir in $(SUBDIRS); do            \\
 943           test -d $(distdir)/$$subdir           \\
 944           || mkdir $(distdir)/$$subdir          \\
 945           || exit 1;                            \\
 946           chmod 777 $(distdir)/$$subdir;        \\
 947           (cd $$subdir && $(MAKE) dist) || exit 1; \\
 948         done
 949 ';
 950     }
 951
 952     # Make verbatim copies of some subdirectories if required.  This
 953     # is a hack which might go away.
 954     if (defined $contents{'DIST_SUBDIRS'})
 955     {
 956         $output_rules .= '      @for dir in $(DIST_SUBDIRS); do         \\
 957           echo copying directory $$dir;         \\
 958           tar chf - $$dir | (cd $(distdir) && tar xBpf -); \\
 959         done
 960 ';
 961     }
 962
 963     # Finalize.
 964     if ($relative_dir eq '.')
 965     {
 966         $output_rules .= '      chmod -R a+r $(distdir)' . "\n\t";
 967         if ($distshar)
 968         {
 969             $output_rules .= 'shar $(distdir) | gzip > $(distdir).shar.gz';
 970         }
 971         else
 972         {
 973             $output_rules .= 'tar chozf $(distdir).tar.gz $(distdir)';
 974         }
 975         $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
 976     }
 977
 978     push (@phony, $target);
 979 }
 980
 981 # Handle 'dist' target.
 982 sub handle_dist
 983 {
 984     # Set up maint_charset.
 985     $local_maint_charset = $contents{'MAINT_CHARSET'}
 986         if defined $contents{'MAINT_CHARSET'};
 987     $maint_charset = $local_maint_charset
 988         if $relative_dir eq '.';
 989
 990     if (defined $contents{'DIST_CHARSET'})
 991     {
 992         &am_error ("DIST_CHARSET defined but no MAINT_CHARSET defined")
 993             if ! $local_maint_charset;
 994         if ($relative_dir eq '.')
 995         {
 996             $dist_charset = $contents{'DIST_CHARSET'}
 997         }
 998         else
 999         {
1000             &am_error ("DIST_CHARSET can only be defined at top level");
1001         }
1002     }
1003
1004     # Look for common files that should be included in distribution.
1005     local ($cfile);
1006     foreach $cfile (@common_files)
1007     {
1008         if (-f ($relative_dir . "/" . $cfile))
1009         {
1010             &push_dist_common ($cfile);
1011         }
1012     }
1013
1014     # Keys of %dist_common are names of files to distributed.  We put
1015     # README first because it then becomes easier to make a
1016     # Usenet-compliant shar file (in these, README must be first).
1017     # FIXME do more ordering of files here.
1018     local (@coms);
1019     if (defined $dist_common{'README'})
1020     {
1021         push (@coms, 'README');
1022         undef $dist_common{'README'};
1023     }
1024     push (@coms, sort keys %dist_common);
1025
1026     &pretty_print ("DIST_COMMON =", "    ", @coms);
1027     $output_vars .= "\n";
1028
1029     # Some boilerplate.
1030     $output_vars .= &file_contents ('dist-vars');
1031
1032     # Put these things in rules section so it is easier for whoever
1033     # reads Makefile.in.
1034     if ($relative_dir eq '.')
1035     {
1036         $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
1037     }
1038     else
1039     {
1040         $output_rules .= ("\nsubdir = " . $relative_dir . "\n"
1041                           . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
1042                           . "\n");
1043     }
1044
1045     # Generate 'dist' target, and maybe dist-shar.
1046     &handle_dist_worker (0);
1047     &handle_dist_worker (1) if defined $options{'dist-shar'};
1048 }
1049
1050 # Handle auto-dependency code.
1051 sub handle_dependencies
1052 {
1053     if ($use_dependencies)
1054     {
1055         # Include GNU-make-specific auto-dep code.
1056         if ($dir_holds_sources)
1057         {
1058             &pretty_print ('DEP_FILES =', "    ", sort keys %dep_files);
1059             $output_rules .= &file_contents ('depend');
1060         }
1061     }
1062     else
1063     {
1064         # Include any auto-generated deps that are present.
1065         if (-d ($relative_dir . "/.deps") && -f ($relative_dir . "/.deps/.P"))
1066         {
1067             local ($depfile);
1068             local ($gpat) = $relative_dir . "/.deps/*.P";
1069
1070             foreach $depfile (<${gpat}>)
1071             {
1072                 if (! open (DEP_FILE, $depfile))
1073                 {
1074                     &am_error ("couldn't open $depfile", $!);
1075                     next;
1076                 }
1077
1078                 # Slurp entire file.
1079                 $output_rules .= join ('', <DEP_FILE>);
1080
1081                 close (DEP_FILE);
1082             }
1083
1084             $output_rules .= "\n";
1085         }
1086     }
1087 }
1088
1089 # Handle subdirectories.
1090 sub handle_subdirs
1091 {
1092     if (! defined $contents{'SUBDIRS'})
1093     {
1094         &am_conf_error
1095             ("ud_GNU_GETTEXT in configure.in but SUBDIRS not defined")
1096                 if $seen_gettext && $relative_dir eq '.';
1097         return;
1098     }
1099
1100     &require_file ($NORMAL, 'ABOUT-NLS') if $seen_gettext;
1101
1102     return if ! defined $contents{'SUBDIRS'};
1103
1104     # Make sure each directory mentioned in SUBDIRS actually exists.
1105     local ($dir);
1106     foreach $dir (split (/\s+/, $contents{'SUBDIRS'}))
1107     {
1108         &am_error ("required directory $relative_dir/$dir does not exist")
1109             if ! -d $relative_dir . '/' . $dir;
1110     }
1111
1112     $output_rules .= &file_contents ('subdirs');
1113
1114     # Push a bunch of phony targets.
1115     local ($phonies);
1116     foreach $phonies ('-data', '-exec', 'dirs')
1117     {
1118         push (@phony, 'install' . $phonies . '-recursive');
1119         push (@phony, 'uninstall' . $phonies . '-recursive');
1120     }
1121     foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
1122     {
1123         push (@phony, $phonies . '-recursive');
1124     }
1125     &push_phony_cleaners ('recursive');
1126
1127     push (@all, "all-recursive");
1128     push (@check, "check-recursive");
1129     push (@installcheck, "installcheck-recursive");
1130     push (@info, "info-recursive");
1131     push (@dvi, "dvi-recursive");
1132
1133     $recursive_install = 1;
1134 }
1135
1136 # Handle remaking and configure stuff.
1137 sub handle_configure
1138 {
1139     # If SUBDIRS defined, require AC_PROG_MAKE_SET.
1140     &am_error ("AC_PROG_MAKE_SET must be used in configure.in")
1141         if defined $contents{'SUBDIRS'} && ! $seen_make_set;
1142
1143     local ($top_reldir);
1144     if ($relative_dir ne '.')
1145     {
1146         # In subdirectory.
1147         $output_rules .= &file_contents ('remake-subd');
1148         $top_reldir = '../';
1149     }
1150     else
1151     {
1152         if (-f 'aclocal.m4')
1153         {
1154             $output_vars .= "ACLOCAL = aclocal.m4\n";
1155             &push_dist_common ('aclocal.m4');
1156         }
1157         $output_rules .= &file_contents ('remake');
1158
1159         # Look for some files we need.
1160         &require_file ($NORMAL, 'install-sh', 'mkinstalldirs');
1161
1162         &am_error
1163             ("\`install.sh' is an anachronism; use \`install-sh' instead")
1164                 if -f $relative_dir . '/install.sh';
1165
1166         # If we have a configure header, require it.
1167         if ($config_header)
1168         {
1169             # FIXME this restriction should be lifted.
1170             # FIXME first see if it is even needed as-is.
1171             &am_error ("argument to AC_CONFIG_HEADER contains \`/'\n")
1172                 if ($config_header =~ /\//);
1173
1174             &require_file ($NORMAL, $config_header);
1175
1176             # Header defined and in this directory.
1177             if (-f 'acconfig.h')
1178             {
1179                 $output_vars .= "ACCONFIG = acconfig.h\n";
1180                 &push_dist_common ('acconfig.h');
1181             }
1182             if (-f $config_name . '.top')
1183             {
1184                 $output_vars .= "CONFIG_TOP = ${config_name}.top\n";
1185                 &push_dist_common ($config_name . '.top');
1186             }
1187             if (-f $config_name . '.bot')
1188             {
1189                 $output_vars .= "CONFIG_BOT = ${config_name}.bot\n";
1190                 &push_dist_common ($config_name . '.bot');
1191             }
1192
1193             &push_dist_common ('stamp-h.in');
1194
1195             $output_rules .= &file_contents ('remake-hdr');
1196             $output_vars .= "CONFIG_HEADER_IN = ${config_header}\n";
1197         }
1198
1199         $top_reldir = '';
1200     }
1201
1202     &am_error ("\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
1203         if defined $contents{'CONFIG_HEADER'};
1204
1205     # Generate CONFIG_HEADER define, and define interally.
1206     $output_vars .= "CONFIG_HEADER = ${top_builddir}/${config_name}\n"
1207         if $config_name;
1208     $contents{'CONFIG_HEADER'} = "${top_builddir}/${config_name}"
1209         if $config_name;
1210
1211     # Now look for other files in this directory which must be remade
1212     # by config.status, and generate rules for them.
1213     local ($file, $local, $input);
1214     foreach $file (@other_input_files)
1215     {
1216         # Skip files not in this directory, any Makefile, and the
1217         # config header.  These last two must be handled specially.
1218         next unless &dirname ($file) eq $relative_dir;
1219         next if $file eq $top_builddir . '/' . $config_name;
1220         ($local = $file) =~ s/^.*\///;
1221         next if $local eq 'Makefile';
1222
1223         if ($local =~ /^(.*):(.*)$/)
1224         {
1225             # This is the ":" syntax of AC_OUTPUT.
1226             $input = $2;
1227             $local = $1;
1228         }
1229         else
1230         {
1231             # Normal usage.
1232             $input = $local . '.in';
1233         }
1234         # FIXME when using autoconf ":" syntax, should we set CONFIG_FILES
1235         # to $local:$input?
1236         $output_rules .= ($local . ': '
1237                           . '$(top_builddir)/config.status ' . $input . "\n"
1238                           . "\t"
1239                           . 'cd $(top_srcdir) && CONFIG_FILES='
1240                           . ($relative_dir eq '.' ? '' : '$(subdir)/')
1241                           . '$@ CONFIG_HEADERS= ./config.status'
1242                           . "\n");
1243         &require_file ($NORMAL, $local . '.in');
1244     }
1245 }
1246
1247 # Handle C headers.
1248 sub handle_headers
1249 {
1250     &am_install_var ('header', 'HEADERS', 'include',
1251                      'oldinclude', 'pkginclude',
1252                      'noinst');
1253 }
1254
1255 # Handle footer elements.
1256 sub handle_footer
1257 {
1258     if ($contents{'SOURCES'})
1259     {
1260         &pretty_print ('SOURCES =', "    ",
1261                        split (/\s+/, $contents{'SOURCES'}));
1262     }
1263     if ($contents{'OBJECTS'})
1264     {
1265         &pretty_print ('OBJECTS =', "    ",
1266                        split (/\s+/, $contents{'OBJECTS'}));
1267     }
1268     if ($contents{'SOURCES'} || $contents{'OBJECTS'})
1269     {
1270         $output_vars .= "\n";
1271     }
1272
1273     if (defined $contents{'SUFFIXES'})
1274     {
1275         push (@suffixes, '$(SUFFIXES)');
1276     }
1277
1278     $output_trailer .= ".SUFFIXES:\n";
1279     if (@suffixes)
1280     {
1281         $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
1282     }
1283     $output_trailer .= &file_contents ('footer');
1284 }
1285
1286 # Deal with installdirs target.
1287 sub handle_installdirs
1288 {
1289     # GNU Makefile standards recommend this.
1290     $output_rules .= ("installdirs:"
1291                       . ($recursive_install
1292                          ? " installdirs-recursive\n"
1293                          : "\n"));
1294     push (@phony, 'installdirs');
1295     if (@installdirs)
1296     {
1297         &pretty_print_rule ("\t\$(top_srcdir)/mkinstalldirs ", "\t\t",
1298                             @installdirs);
1299     }
1300     $output_rules .= "\n";
1301 }
1302
1303 # There are several targets which need to be merged.  This is because
1304 # their complete definition is compiled from many parts.  Note that we
1305 # avoid double colon rules, otherwise we'd use them instead.
1306 sub handle_merge_targets
1307 {
1308     &do_one_merge_target ('all', @all);
1309     &do_one_merge_target ('info', @info);
1310     &do_one_merge_target ('dvi', @dvi);
1311
1312     if (! defined $contents{'SUBDIRS'} || $relative_dir ne '.')
1313     {
1314         # 'check' must depend on 'all', but not at top level.
1315         unshift (@check, 'all');
1316     }
1317     &do_one_merge_target ('check', @check);
1318     &do_one_merge_target ('installcheck', @installcheck);
1319
1320     # Handle the various install targets specially.  We do this so
1321     # that (eg) "make install-exec" will run "install-exec-recursive"
1322     # if required, but "make install" won't run it twice.  Step one is
1323     # to see if the user specified local versions of any of the
1324     # targets we handle.
1325     if (defined $contents{'install-exec-local'})
1326     {
1327         push (@install_exec, 'install-exec-local');
1328     }
1329     if (defined $contents{'install-data-local'})
1330     {
1331         push (@install_data, 'install-data-local');
1332     }
1333     if (defined $contents{'uninstall-local'})
1334     {
1335         push (@uninstall, 'uninstall-local');
1336     }
1337
1338     if (defined $contents{'install-local'})
1339     {
1340         &am_error ("use \`install-data' or \`install-exec', not \`install'");
1341     }
1342
1343     # Step two: if we are doing recursive makes, write out the
1344     # appropriate rules.
1345     local (@install);
1346     if ($recursive_install)
1347     {
1348         push (@install, 'install-recursive');
1349         push (@uninstall, 'uninstall-recursive');
1350
1351         if (@install_exec)
1352         {
1353             $output_rules .= ('install-exec-am: '
1354                               . join (' ', @install_exec)
1355                               . "\n\n");
1356             @install_exec = ('install-exec-recursive', 'install-exec-am');
1357             push (@install, 'install-exec-am');
1358             push (@phony, 'install-exec-am');
1359         }
1360         if (@install_data)
1361         {
1362             $output_rules .= ('install-data-am: '
1363                               . join (' ', @install_data)
1364                               . "\n\n");
1365             @install_data = ('install-data-recursive', 'install-data-am');
1366             push (@install, 'install-data-am');
1367             push (@phony, 'install-data-am');
1368         }
1369         if (@uninstall)
1370         {
1371             $output_rules .= ('uninstall-am: '
1372                               . join (' ', @uninstall)
1373                               . "\n\n");
1374             @uninstall = ('uninstall-recursive', 'uninstall-am');
1375             push (@phony, 'uninstall-am');
1376         }
1377     }
1378
1379     # Step three: print definitions users can use.
1380     $output_rules .= ("install-exec: "
1381                       . join (' ', @install_exec)
1382                       . "\n\n");
1383     push (@install, 'install-exec') if !$recursive_install;
1384     push (@phony, 'install-exec');
1385
1386     $output_rules .= ("install-data: "
1387                       . join (' ', @install_data)
1388                       . "\n\n");
1389     push (@install, 'install-data') if !$recursive_install;
1390     push (@phony, 'install-data');
1391
1392     # If no dependencies for 'install', add 'all'.  Why?  That way
1393     # "make install" at top level of distclean'd distribution won't
1394     # fail because stuff in 'lib' fails to build.
1395     push (@install, 'all') if ! @install;
1396     $output_rules .= ('install: '
1397                       . join (' ', @install)
1398                       # Use "@:" as empty command so nothing prints.
1399                       . "\n\t\@:"
1400                       . "\n\n"
1401                       . 'uninstall: '
1402                       . join (' ', @uninstall)
1403                       . "\n\n");
1404     push (@phony, 'install', 'uninstall');
1405 }
1406
1407 # Helper for handle_merge_targets.
1408 sub do_one_merge_target
1409 {
1410     local ($name, @values) = @_;
1411
1412     if (defined $contents{$name . '-local'})
1413     {
1414         # User defined local form of target.  So include it.
1415         push (@values, $name . '-local');
1416         push (@phony, $name . '-local');
1417     }
1418
1419     $output_rules .= $name . ":";
1420     if (@values)
1421     {
1422         $output_rules .= ' ' . join (' ', @values);
1423     }
1424     $output_rules .= "\n\n";
1425     push (@phony, $name);
1426 }
1427
1428 # Handle all 'clean' targets.
1429 sub handle_clean
1430 {
1431     push (@clean, 'generic');
1432     $output_rules .= &file_contents ('clean');
1433     &push_phony_cleaners ('generic');
1434
1435     local ($target) = $recursive_install ? 'clean-am' : 'clean';
1436     &do_one_clean_target ($target, 'mostly', '', @clean);
1437     &do_one_clean_target ($target, '', 'mostly', @clean);
1438     &do_one_clean_target ($target, 'dist', '', @clean);
1439     &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
1440
1441     push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
1442
1443     local (@deps);
1444     if ($recursive_install)
1445     {
1446         @deps = ('am', 'recursive');
1447         &do_one_clean_target ('', 'mostly', '', @deps);
1448         &do_one_clean_target ('', '', '', @deps);
1449         &do_one_clean_target ('', 'dist', '', @deps);
1450         &do_one_clean_target ('', 'maintainer-', '', @deps);
1451     }
1452 }
1453
1454 # Helper for handle_clean.
1455 sub do_one_clean_target
1456 {
1457     local ($target, $name, $last_name, @deps) = @_;
1458
1459     # Special case: if target not passed, then don't generate
1460     # dependency on next "lower" clean target (eg no
1461     # clean<-mostlyclean derivation).  In this case the target is
1462     # implicitly known to be 'clean'.
1463     local ($flag) = $target;
1464     $target = 'clean' if ! $flag;
1465
1466     grep (($_ = $name . 'clean-' . $_) && 0, @deps);
1467     if ($flag)
1468     {
1469         if ($last_name || $name ne 'mostly')
1470         {
1471             push (@deps, $last_name . $target . " ");
1472         }
1473     }
1474     # FIXME not sure if I like the tabs here.
1475     &pretty_print_rule ($name . $target . ": ", "\t\t", @deps);
1476
1477     # FIXME shouldn't we really print these messages before running
1478     # the dependencies?
1479     if ($name . $target eq 'maintainer-clean')
1480     {
1481         # Print a special warning.
1482         $output_rules .=
1483             ("\t\@echo \"This command is intended for maintainers to use;\"\n"
1484              . "\t\@echo \"it deletes files that may require special "
1485              . "tools to rebuild.\"\n");
1486
1487         $output_rules .= "\trm -f config.status\n"
1488             if $relative_dir eq '.';
1489     }
1490     elsif ($name . $target eq 'distclean')
1491     {
1492         $output_rules .= "\trm -f config.status\n";
1493     }
1494     $output_rules .= "\n";
1495 }
1496
1497 # Handle .PHONY target.
1498 sub handle_phony
1499 {
1500     &pretty_print_rule ('.PHONY:', "    ", @phony);
1501     $output_rules .= "\n";
1502 }
1503
1504 ################################################################
1505
1506 # Scan configure.in for interesting things.
1507 # FIXME ensure VERSION, PACKAGE are set.
1508 sub scan_configure
1509 {
1510     open (CONFIGURE, 'configure.in')
1511         || die "automake: couldn't open configure.in: $!\n";
1512
1513     # Reinitialize libsources here.  This isn't really necessary,
1514     # since we currently assume there is only one configure.in.  But
1515     # that won't always be the case.
1516     %libsources = ();
1517
1518     local ($in_ac_output, @make_list) = 0;
1519     local ($seen_arg_prog) = 0;
1520     local ($seen_canonical) = 0;
1521     while (<CONFIGURE>)
1522     {
1523         # Remove comments from current line.
1524         s/\bdnl\b.*$//;
1525         s/\#.*$//;
1526
1527         # Populate libobjs array.
1528         if (/AC_FUNC_ALLOCA/)
1529         {
1530             $libsources{'alloca.c'} = 1;
1531         }
1532         elsif (/AC_FUNC_GETLOADAVG/)
1533         {
1534             $libsources{'getloadavg.c'} = 1;
1535         }
1536         elsif (/AC_FUNC_MEMCMP/)
1537         {
1538             $libsources{'memcmp.c'} = 1;
1539         }
1540         elsif (/AC_STRUCT_ST_BLOCKS/)
1541         {
1542             $libsources{'fileblocks.c'} = 1;
1543         }
1544         elsif (/AC_REPLACE_FUNCS\s*\((.*)\)/)
1545         {
1546             foreach (split (/\s+/, $1))
1547             {
1548                 $libsources{$_ . '.c'} = 1;
1549             }
1550         }
1551         elsif (/LIBOBJS="(.*)\.o\s+\$LIBOBJS"/)
1552         {
1553             $libsources{$1 . '.c'} = 1;
1554         }
1555         elsif (/LIBOBJS="\$LIBOBJS\s+(.*)\.o"/)
1556         {
1557             $libsources{$1 . '.c'} = 1;
1558         }
1559
1560         # Process the AC_OUTPUT macro.
1561         if (! $in_ac_output && s/AC_OUTPUT\s*\(\[?//)
1562         {
1563             $in_ac_output = 1;
1564         }
1565         if ($in_ac_output)
1566         {
1567             s/\].*$//;
1568             $in_ac_output = 0 if s/[\),].*$//;
1569
1570             # Look at potential Makefile.am's.
1571             foreach (split)
1572             {
1573                 next if $_ eq "\\";
1574                 if (-f $_ . '.am')
1575                 {
1576                     push (@make_list, $_);
1577                 }
1578                 else
1579                 {
1580                     push (@other_input_files, $_);
1581                 }
1582             }
1583         }
1584
1585         # Check for ansi2knr.
1586         $fp_c_prototypes = 1 if /fp_C_PROTOTYPES/;
1587
1588         # Check for NLS support.
1589         if (/ud_GNU_GETTEXT/)
1590         {
1591             $seen_gettext = 1;
1592         }
1593
1594         # Handle configuration headers.
1595         if (/AC_CONFIG_HEADER\s*\((.*)\)/)
1596         {
1597             $config_name = $1;
1598             if ($config_name =~ /^([^:]+):(.+)$/)
1599             {
1600                 $config_name = $1;
1601                 $config_header = $2;
1602             }
1603             else
1604             {
1605                 $config_header = $config_name . '.in';
1606             }
1607         }
1608
1609         $seen_canonical = 1 if /AC_CANONICAL_(HOST|SYSTEM)/;
1610         $seen_path_xtra = 1 if /AC_PATH_XTRA/;
1611
1612         # Some things required by Automake.  FIXME we only really
1613         # require fp_PROG_INSTALL if some scripts are installed.  And
1614         # we only really require AC_ARG_PROGRAM if any program is
1615         # installed.
1616         $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
1617         $seen_prog_install = 1 if ! $seen_prog_install && /AC_PROG_INSTALL/;
1618         $seen_prog_install = 2 if ! $seen_prog_install && /fp_PROG_INSTALL/;
1619         $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
1620     }
1621
1622     # Set input files if not specified by user.
1623     @input_files = @make_list if (! @input_files);
1624
1625     # AC_CANONICAL_HOST and AC_CANONICAL_SYSTEM need config.guess and
1626     # config.sub.
1627     &require_file ($NORMAL, 'config.guess', 'config.sub')
1628         if $seen_canonical;
1629
1630     &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1631         unless $seen_arg_prog;
1632
1633     close (CONFIGURE);
1634 }
1635
1636 ################################################################
1637
1638 # Do any extra checking for GNU standards.
1639 sub check_gnu_standards
1640 {
1641     &require_file ($GNU, 'ChangeLog');
1642
1643     if ($relative_dir eq '.')
1644     {
1645         # In top level (or only) directory.
1646         &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
1647                        'AUTHORS');
1648     }
1649 }
1650
1651 # Do any extra checking for GNITS standards.
1652 sub check_gnits_standards
1653 {
1654     if ($strictness >= $GNITS && -f $relative_dir . '/COPYING.LIB')
1655     {
1656         &am_error
1657             ("\`${relative_dir}/COPYING.LIB' disallowed by Gnits standards");
1658     }
1659
1660     if ($relative_dir eq '.')
1661     {
1662         # In top level (or only) directory.
1663         &require_file ($GNITS, 'THANKS');
1664     }
1665 }
1666
1667 ################################################################
1668
1669 # Pretty-print something.  HEAD is what should be printed at the
1670 # beginning of the first line, FILL is what should be printed at the
1671 # beginning of every subsequent line.
1672 sub pretty_print_internal
1673 {
1674     local ($head, $fill, @values) = @_;
1675
1676     local ($column) = length ($head);
1677     local ($result) = $head;
1678
1679     # Fill length is number of characters.  However, each Tab
1680     # character counts for eight.  So we count the number of Tabs and
1681     # multiply by 7.
1682     local ($fill_length) = length ($fill);
1683     $fill_length += 7 * ($fill =~ tr/\t/\t/d);
1684
1685     local ($bol) = 0;
1686     foreach (@values)
1687     {
1688         # "71" because we also print a space.
1689         if ($column + length ($_) > 71)
1690         {
1691             $result .= " \\\n" . $fill;
1692             $column = $fill_length;
1693             $bol = 1;
1694         }
1695
1696         $result .= ' ' unless ($bol);
1697         $result .= $_;
1698         $column += length ($_) + 1;
1699         $bol = 0;
1700     }
1701
1702     $result .= "\n";
1703     return $result;
1704 }
1705
1706 # Pretty-print something and append to output_vars.
1707 sub pretty_print
1708 {
1709     $output_vars .= &pretty_print_internal (@_);
1710 }
1711
1712 # Pretty-print something and append to output_rules.
1713 sub pretty_print_rule
1714 {
1715     $output_rules .= &pretty_print_internal (@_);
1716 }
1717
1718
1719 ################################################################
1720
1721 # Read Makefile.am and set up %contents.  Simultaneously copy lines
1722 # from Makefile.am into $output_trailer or $output_vars as
1723 # appropriate.  NOTE we put rules in the trailer section.  We want
1724 # user rules to come after our generated stuff.
1725 sub read_am_file
1726 {
1727     local ($amfile) = @_;
1728
1729     # Compute relative location of the top object directory.
1730     local (@topdir) = ();
1731     foreach (split (/\//, $relative_dir))
1732     {
1733         next if $_ eq '.' || $_ eq '';
1734         if ($_ eq '..')
1735         {
1736             pop @topdir;
1737         }
1738         else
1739         {
1740             push (@topdir, '..');
1741         }
1742     }
1743     @topdir = ('.') if ! @topdir;
1744
1745     $top_builddir = join ('/', @topdir);
1746     local ($build_rx);
1747     ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
1748     local ($header_vars) =
1749         &file_contents_with_transform
1750             ('s/\@top_builddir\@/' . $build_rx . '/g',
1751              'header-vars');
1752
1753     open (AM_FILE, $amfile) || die "automake: couldn't open $amfile: $!\n";
1754
1755     $output_vars .= ("# Makefile.in generated automatically by automake "
1756                      . $VERSION . " from Makefile.am\n");
1757
1758     # Generate copyright for generated Makefile.in.
1759     $output_vars .= $gen_copyright;
1760
1761     local ($saw_bk) = 0;
1762     local ($was_rule) = 0;
1763     local ($spacing) = '';
1764     local ($comment) = '';
1765     local ($last_var_name) = '';
1766
1767     while (<AM_FILE>)
1768     {
1769         if (/$IGNORE_PATTERN/o)
1770         {
1771             # Merely delete comments beginning with two hashes.
1772         }
1773         elsif (/$WHITE_PATTERN/o)
1774         {
1775             # Stick a single white line before the incoming macro or rule.
1776             $spacing = "\n";
1777         }
1778         elsif (/$COMMENT_PATTERN/o)
1779         {
1780             # Stick comments before the incoming macro or rule.
1781             $comment .= $spacing . $_;
1782             $spacing = '';
1783         }
1784         else
1785         {
1786             last;
1787         }
1788     }
1789
1790     $output_vars .= $comment . "\n" . $header_vars;
1791     $comment = '';
1792     $spacing = "\n";
1793
1794     while ($_)
1795     {
1796         if (/$IGNORE_PATTERN/o)
1797         {
1798             # Merely delete comments beginning with two hashes.
1799         }
1800         elsif (/$WHITE_PATTERN/o)
1801         {
1802             # Stick a single white line before the incoming macro or rule.
1803             $spacing = "\n";
1804         }
1805         elsif (/$COMMENT_PATTERN/o)
1806         {
1807             # Stick comments before the incoming macro or rule.
1808             $comment .= $spacing . $_;
1809             $spacing = '';
1810         }
1811         elsif ($saw_bk)
1812         {
1813             if ($was_rule)
1814             {
1815                 $output_trailer .= $_;
1816                 $saw_bk = /\\$/;
1817             }
1818             else
1819             {
1820                 $output_vars .= $_;
1821                 $saw_bk = /\\$/;
1822                 # Chop newline and backslash if this line is
1823                 # continued.  FIXME maybe ensure trailing whitespace
1824                 # exists?
1825                 chop if $saw_bk;
1826                 chop if $saw_bk;
1827                 $contents{$last_var_name} .= $_;
1828             }
1829         }
1830         elsif (/$RULE_PATTERN/o)
1831         {
1832             # warn "** Saw rule .$1.\n";
1833             # Found a rule.
1834             $was_rule = 1;
1835             # Value here doesn't matter; for targets we only note
1836             # existence.
1837             $contents{$1} = 1;
1838             $output_trailer .= $comment . $spacing . $_;
1839             $comment = $spacing = '';
1840             $saw_bk = /\\$/;
1841         }
1842         elsif (/$MACRO_PATTERN/o)
1843         {
1844             # warn "** Saw macro .$1.\n";
1845             # Found a macro definition.
1846             $was_rule = 0;
1847             $last_var_name = $1;
1848             if (substr ($2, -1) eq "\\")
1849             {
1850                 $contents{$1} = substr ($2, 0, length ($2) - 1);
1851             }
1852             else
1853             {
1854                 $contents{$1} = $2;
1855             }
1856             $output_vars .= $comment . $spacing . $_;
1857             $comment = $spacing = '';
1858             $saw_bk = /\\$/;
1859         }
1860         elsif ($_ eq "\@kr\@\n")
1861         {
1862             # Special case: this means we want automatic
1863             # de-ANSI-fication.  This is deprecated.  Remove in the
1864             # future.
1865             $contents{'@kr@'} = 1;
1866             &am_error ('`@kr@\' is deprecated; put `ansi2knr\' in AUTOMAKE_OPTIONS instead');
1867         }
1868         else
1869         {
1870             # This isn't an error; it is probably a continued rule.
1871             # In fact, this is what we assume.
1872             $was_rule = 1;
1873             $output_trailer .= $comment . $spacing . $_;
1874             $comment = $spacing = '';
1875             $saw_bk = /\\$/;
1876         }
1877
1878         $_ = <AM_FILE>;
1879     }
1880
1881     $output_trailer .= $comment;
1882 }
1883
1884 ################################################################
1885
1886 sub initialize_global_constants
1887 {
1888     # Associative array of standard directory names.  Entry is TRUE if
1889     # corresponding directory should be installed during
1890     # 'install-exec' phase.
1891     %exec_dir_p =
1892         ('bin', 1,
1893          'sbin', 1,
1894          'libexec', 1,
1895          'data', 0,
1896          'sysconf', 1,
1897          'localstate', 1,
1898          'lib', 1,
1899          'info', 0,
1900          'man', 0,
1901          'include', 0,
1902          'oldinclude', 0,
1903          'pkgdata', 0,
1904          'pkglib', 1,
1905          'pkginclude', 0
1906          );
1907
1908     # Helper text for dealing with man pages.
1909     $install_man_format =
1910     '   @sect=@SECTION@;                                \\
1911         inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1912         echo installing @MAN@ as $(mandir)/man$$sect/$$inst; \\
1913         $(INSTALL_DATA) $(srcdir)/@MAN@ $(mandir)/man$$sect/$$inst
1914 ';
1915
1916     $uninstall_man_format =
1917     '   inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1918         rm -f $(mandir)/man@SECTION@/$$inst
1919 ';
1920
1921     # Commonly found files we look for and automatically include in
1922     # DISTFILES.
1923     @common_files =
1924         (
1925          "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
1926          "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
1927          "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU"
1928          );
1929
1930     # Commonly used files we auto-include, but only sometimes.
1931     @common_sometimes =
1932         (
1933          "version.texi", "aclocal.m4", "acconfig.h", "config.h.top",
1934          "config.h.bot", "stamp-h.in", "mdate-sh", "ansi2knr.c",
1935          "ansi2knr.1", 'stamp-vti', "mkinstalldirs", "install-sh"
1936          );
1937
1938     $USAGE = "\
1939   --amdir=DIR           directory storing config files
1940   --gnits               same as --strictness=gnits
1941   --gnu                 same as --strictness=gnu
1942   --help                print this help, then exit
1943   --include-deps        include generated dependencies in Makefile.in
1944   --install-missing     install missing standard files
1945   --output-dir=DIR      put generated Makefile.in's into DIR
1946   --strictness=LEVEL    set strictness level.  LEVEL is normal, gnu, gnits
1947   --version             print version number, then exit\n";
1948
1949     # Copyright on generated Makefile.ins.
1950     $gen_copyright = "\
1951 # Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
1952 # This Makefile.in is free software; the Free Software Foundation
1953 # gives unlimited permission to copy, distribute and modify it.
1954 "
1955 }
1956
1957 # (Re)-Initialize per-Makefile.am variables.
1958 sub initialize_per_input
1959 {
1960     # These two variables are used when generating each Makefile.in.
1961     # They hold the Makefile.in until it is ready to be printed.
1962     $output_rules = '';
1963     $output_vars = '';
1964     $output_trailer = '';
1965
1966     # Suffixes found during a run.
1967     @suffixes = ();
1968
1969     # This holds the contents of a Makefile.am, as parsed by
1970     # read_am_file.
1971     %contents = ();
1972
1973     # This holds the "relative directory" of the current Makefile.in.
1974     # Eg for src/Makefile.in, this is "src".
1975     $relative_dir = '';
1976
1977     # Directory where output files go.  Actually, output files are
1978     # relative to this directory.
1979     $output_directory = '.';
1980
1981     # This holds a list of files that are included in the
1982     # distribution.
1983     %dist_common = ();
1984
1985     # List of dependencies for the obvious targets.
1986     @install_data = ();
1987     @install_exec = ();
1988     @uninstall = ();
1989     @installdirs = ();
1990
1991     @info = ();
1992     @dvi = ();
1993     @all = ();
1994     @check = ();
1995     @installcheck = ();
1996     @clean = ();
1997
1998     @phony = ();
1999
2000     # These are pretty obvious, too.  They are used to define the
2001     # SOURCES and OBJECTS variables.
2002     @sources = ();
2003     @objects = ();
2004
2005     # TRUE if current directory holds any C source files.  (Actually
2006     # holds object extension, but this information is encapsulated in
2007     # the function get_object_extension).
2008     $dir_holds_sources = '';
2009
2010     # TRUE if install targets should work recursively.
2011     $recursive_install = 0;
2012
2013     # All .P files.
2014     %dep_files = ();
2015
2016     # Strictness levels.
2017     $strictness = $default_strictness;
2018     $strictness_name = $default_strictness_name;
2019
2020     # Options from AUTOMAKE_OPTIONS.
2021     %options = ();
2022
2023     # Whether or not dependencies are handled.  Can be further changed
2024     # in handle_options.
2025     $use_dependencies = $cmdline_use_dependencies;
2026
2027     # Per Makefile.am.
2028     $local_maint_charset = $maint_charset;
2029 }
2030
2031
2032 ################################################################
2033
2034 # Return contents of a file from $am_dir, automatically skipping
2035 # macros or rules which are already known.  Runs command on each line
2036 # as it is read; this command can modify $_.
2037 sub file_contents_with_transform
2038 {
2039     local ($command, $basename) = @_;
2040     local ($file) = $am_dir . '/' . $basename . '.am';
2041
2042     open (FC_FILE, $file)
2043         || die "automake: installation error: cannot open \`$file'\n";
2044
2045     local ($was_rule) = 0;
2046     local ($result_vars) = '';
2047     local ($result_rules) = '';
2048     local ($comment) = '';
2049     local ($spacing) = "\n";
2050     local ($skipping) = 0;
2051
2052     while (<FC_FILE>)
2053     {
2054         eval $command;
2055
2056         if (/$IGNORE_PATTERN/o)
2057         {
2058             # Merely delete comments beginning with two hashes.
2059         }
2060         elsif (/$WHITE_PATTERN/o)
2061         {
2062             # Stick a single white line before the incoming macro or rule.
2063             $spacing = "\n";
2064         }
2065         elsif (/$COMMENT_PATTERN/o)
2066         {
2067             # Stick comments before the incoming macro or rule.
2068             $comment .= $spacing . $_;
2069             $spacing = '';
2070         }
2071         elsif ($saw_bk)
2072         {
2073             if ($was_rule)
2074             {
2075                 $result_rules .= $_ if ! $skipping;
2076             }
2077             else
2078             {
2079                 $result_vars .= $_ if ! $skipping;
2080             }
2081             $saw_bk = /\\$/;
2082         }
2083         elsif (/$RULE_PATTERN/o)
2084         {
2085             # warn "** Found rule .$1.\n";
2086             # Found a rule.
2087             $was_rule = 1;
2088             $skipping = defined $contents{$1};
2089             # warn "** Skip $skipping\n" if $skipping;
2090             $result_rules .= $comment . $spacing . $_ if ! $skipping;
2091             $comment = $spacing = '';
2092             $saw_bk = /\\$/;
2093         }
2094         elsif (/$MACRO_PATTERN/o)
2095         {
2096             # warn "** Found macro .$1.\n";
2097             # Found a variable reference.
2098             $was_rule = 0;
2099             $skipping = defined $contents{$1};
2100             # warn "** Skip $skipping\n" if $skipping;
2101             $result_vars .= $comment . $spacing . $_ if ! $skipping;
2102             $comment = $spacing = '';
2103             $saw_bk = /\\$/;
2104         }
2105         else
2106         {
2107             # This isn't an error; it is probably a continued rule.
2108             # In fact, this is what we assume.
2109             $was_rule = 1;
2110             $result_rules .= $comment . $spacing . $_ if ! $skipping;
2111             $comment = $spacing = '';
2112             $saw_bk = /\\$/;
2113         }
2114     }
2115
2116     close (FC_FILE);
2117     return $result_vars . $result_rules . $comment;
2118 }
2119
2120 # Like file_contents_with_transform, but no transform.
2121 sub file_contents
2122 {
2123     return &file_contents_with_transform ('', @_);
2124 }
2125
2126 # Handle `where_HOW' variable magic.  Does all lookups, generates
2127 # install code,and possibly generates code to define the primary
2128 # variable.  The first argument is the name of the .am file to munge,
2129 # the second argument is the primary variable (eg HEADERS), and all
2130 # subsequent arguments are possible installation locations.  Returns
2131 # list of all values of all _HOW targets.
2132 #
2133 # FIXME this should be rewritten to be cleaner.  It should be broken
2134 # up into multiple functions.
2135 #
2136 # Usage is: am_install_var (OPTION..., file, HOW, where...)
2137 sub am_install_var
2138 {
2139     local (@args) = @_;
2140
2141     local ($do_all, $do_clean) = (1, 0);
2142     while (@args)
2143     {
2144         if ($args[0] eq '-clean')
2145         {
2146             $do_clean = 1;
2147         }
2148         elsif ($args[0] eq '-no-all')
2149         {
2150             $do_all = 0;
2151         }
2152         elsif ($args[0] !~ /^-/)
2153         {
2154             last;
2155         }
2156         shift (@args);
2157     }
2158     local ($file, $primary, @prefixes) = @args;
2159
2160     local (@used) = ();
2161     local (@result) = ();
2162
2163     local ($clean_file) = $file . '-clean';
2164     local ($one_name);
2165     local ($X);
2166     foreach $X (@prefixes)
2167     {
2168         $one_name = $X . '_' . $primary;
2169         if (defined $contents{$one_name})
2170         {
2171             # Append actual contents to result.
2172             push (@result, split (/\s+/, $contents{$one_name}));
2173
2174             if ($do_clean)
2175             {
2176                 $output_rules .=
2177                     &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
2178                                                    $clean_file);
2179
2180                 push (@clean, $X . $primary);
2181                 &push_phony_cleaners ($X . $primary);
2182             }
2183
2184             push (@used, '$(' . $one_name . ')');
2185             if ($X eq 'noinst')
2186             {
2187                 # Objects in noinst_FOO never get installed.
2188                 next;
2189             }
2190
2191             $output_rules .=
2192                 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
2193                                                $file);
2194
2195             push (@uninstall, 'uninstall-' . $X . $primary);
2196             push (@phony, 'uninstall-' . $X . $primary);
2197             push (@installdirs, '$(' . $X . 'dir)');
2198             if ($exec_dir_p{$X})
2199             {
2200                 push (@install_exec, 'install-' . $X . $primary);
2201             }
2202             else
2203             {
2204                 push (@install_data, 'install-' . $X . $primary);
2205             }
2206         }
2207     }
2208
2209     if (! defined $contents{$primary} && @used)
2210     {
2211         # Define it.
2212         &pretty_print ($primary . ' =', '', @used);
2213         $output_vars .= "\n";
2214     }
2215
2216     # Push here because PRIMARY might be configure time determined.
2217     push (@all, '$(' . $primary . ')') if ($do_all && @used);
2218
2219     # Look for misspellings.  It is an error to have a variable ending
2220     # in a "reserved" suffix whose prefix is unknown, eg
2221     # "bni_PROGRAMS".
2222     local (%valid, $varname);
2223     grep ($valid{$_} = 0, @prefixes);
2224     foreach $varname (keys %contents)
2225     {
2226         if ($varname =~ /^(.*)_$primary$/ && ! defined $valid{$1})
2227         {
2228             &am_error ("invalid variable \"$varname\"");
2229         }
2230     }
2231
2232     return (@result);
2233 }
2234
2235
2236 ################################################################
2237
2238 # Verify that the file must exist in the current directory.
2239 # Usage: require_file (strictness, file)
2240 # strictness is the strictness level at which this file becomes
2241 # required.
2242 sub require_file
2243 {
2244     local ($mystrict, @files) = @_;
2245     local ($file, $fullfile);
2246
2247     foreach $file (@files)
2248     {
2249         $fullfile = $relative_dir . "/" . $file;
2250
2251         if (-f $fullfile)
2252         {
2253             &push_dist_common ($file);
2254         }
2255         elsif ($strictness >= $mystrict)
2256         {
2257             # Only install missing files according to our desired
2258             # strictness level.
2259             if ($install_missing && -f ($am_dir . '/' . $file))
2260             {
2261                 # Install the missing file.  Symlink if we can, copy
2262                 # if we must.
2263                 if ($symlink_exists)
2264                 {
2265                     symlink ($am_dir . '/' . $file, $fullfile);
2266                 }
2267                 else
2268                 {
2269                     system ('cp', $am_dir . '/' . $file, $fullfile);
2270                 }
2271                 &am_error
2272                     ("required file \"$fullfile\" not found; installing");
2273             }
2274             else
2275             {
2276                 # Only an error if strictness constraint violated.
2277                 &am_error ("required file \"$fullfile\" not found");
2278             }
2279         }
2280     }
2281 }
2282
2283 # Push a list of files onto dist_common.
2284 sub push_dist_common
2285 {
2286     local (@files) = @_;
2287     local ($file);
2288
2289     foreach $file (@files)
2290     {
2291         $dist_common{$file} = 1;
2292     }
2293 }
2294
2295 # Push a list of clean targets onto phony.
2296 sub push_phony_cleaners
2297 {
2298     local ($base) = @_;
2299     local ($target);
2300     foreach $target ('mostly', 'dist', '', 'maintainer-')
2301     {
2302         push (@phony, $target . 'clean-' . $base);
2303     }
2304 }
2305
2306 # Set strictness.
2307 sub set_strictness
2308 {
2309     $strictness_name = $_[0];
2310     if ($strictness_name eq 'gnu')
2311     {
2312         $strictness = $GNU;
2313     }
2314     elsif ($strictness_name eq 'gnits')
2315     {
2316         $strictness = $GNITS;
2317     }
2318     elsif ($strictness_name eq 'normal')
2319     {
2320         $strictness = $NORMAL;
2321     }
2322     else
2323     {
2324         die "automake: level \`$strictness_name' not recognized\n";
2325     }
2326 }
2327
2328
2329 ################################################################
2330
2331 # Return directory name of file.
2332 sub dirname
2333 {
2334     local ($file) = @_;
2335     local ($sub);
2336
2337     ($sub = $file) =~ s,/+[^/]+$,,g;
2338     $sub = '.' if $sub eq $file;
2339     return $sub;
2340 }
2341
2342 # Make a directory.
2343 sub mkdir
2344 {
2345     local ($dirname) = @_;
2346     system ("mkdir", $dirname);
2347 }
2348
2349 ################################################################
2350
2351 # Print an error message and set exit status.
2352 sub am_error
2353 {
2354     warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
2355     $exit_status = 1;
2356 }
2357
2358 # The same, but while scanning configure.in.
2359 sub am_conf_error
2360 {
2361     # FIXME can run in subdirs.
2362     warn "automake: configure.in: ", join (' ', @_), "\n";
2363     $exit_status = 1;
2364 }
2365
2366 # Print usage information.
2367 sub usage
2368 {
2369     print "Usage: automake [OPTION] ... [Makefile]...\n";
2370     print $USAGE;
2371     print "\nFiles which are automatically distributed, if found:\n";
2372     $~ = "USAGE_FORMAT";
2373     local (@lcomm) = sort ((@common_files, @common_sometimes));
2374     local ($one, $two, $three, $four);
2375     while (@lcomm > 0)
2376     {
2377         $one = shift @lcomm;
2378         $two = @lcomm ? shift @lcomm : '';
2379         $three = @lcomm ? shift @lcomm : '';
2380         $four = @lcomm ? shift @lcomm : '';
2381         write;
2382     }
2383
2384     exit 0;
2385 }
2386
2387 format USAGE_FORMAT =
2388   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
2389   $one,               $two,               $three,             $four
2390 .