automake.in

   1 #!@PERL@
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval 'exec @PERL@ -S $0 ${1+"$@"}'
   6     if 0;
   7
   8 # automake - create Makefile.in from Makefile.am
   9 # Copyright (C) 1994, 1995, 1996 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 $PACKAGE = "@PACKAGE@";
  34 $prefix = "@prefix@";
  35 $am_dir = "@datadir@/@PACKAGE@";
  36
  37 # String constants.
  38 $IGNORE_PATTERN = "^##([^#].*)?\$";
  39 $WHITE_PATTERN = "^[ \t]*\$";
  40 $COMMENT_PATTERN = "^#";
  41 $RULE_PATTERN = "^([\$a-zA-Z_.][-.a-zA-Z0-9_(){}/]*) *:";
  42 $MACRO_PATTERN = "^([A-Za-z][A-Za-z0-9_]*)[ \t]*=[ \t]*(.*)\$";
  43 $BOGUS_MACRO_PATTERN = "^([^ \t]*)[ \t]*=[ \t]*(.*)\$";
  44
  45 # Constants to define the "strictness" level.
  46 $FOREIGN = 0;
  47 $GNU = 1;
  48 $GNITS = 2;
  49
  50 \f
  51
  52 # Variables global to entire run.
  53
  54 # TRUE if we should always generate Makefile.in.
  55 $force_generation = 1;
  56
  57 # Strictness level as set on command line.
  58 $default_strictness = $GNU;
  59
  60 # Name of strictness level, as set on command line.
  61 $default_strictness_name = 'gnu';
  62
  63 # This is TRUE if GNU make specific automatic dependency generation
  64 # code should be included in generated Makefile.in.
  65 $cmdline_use_dependencies = 1;
  66
  67 # TRUE if in verbose mode.
  68 $verbose = 0;
  69
  70 # This holds our (eventual) exit status.  We don't actually exit until
  71 # we have processed all input files.
  72 $exit_status = 0;
  73
  74 # From the Perl manual.
  75 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
  76
  77 # TRUE if missing standard files should be installed.
  78 $add_missing = 0;
  79
  80 # Files found by scanning configure.in for LIBOBJS.
  81 %libsources = ();
  82
  83 # True if AM_C_PROTOTYPES appears in configure.in.
  84 $am_c_prototypes = 0;
  85
  86 # Names used in AC_CONFIG_HEADER call.  $config_name is the actual
  87 # (first) argument.  $config_header is the '.in' file.  Ordinarily the
  88 # second is derived from the first, but they can be different if the
  89 # weird "NAME:FILE" syntax is used.
  90 $config_name = '';
  91 $config_header = '';
  92 # Line number at which AC_CONFIG_HEADER appears in configure.in.
  93 $config_header_line = 0;
  94
  95 # Directory where output files go.  Actually, output files are
  96 # relative to this directory.
  97 $output_directory = '.';
  98
  99 # Relative location of top build directory.
 100 $top_builddir = '';
 101
 102 # List of Makefile.am's to process.
 103 @input_files = ();
 104
 105 # List of files in AC_OUTPUT without Makefile.am.
 106 @other_input_files = ();
 107 # Line number at which AC_OUTPUT seen.
 108 $ac_output_line = 0;
 109
 110 # List of directories to search for configure-required files.  This
 111 # can be set by AC_CONFIG_AUX_DIR.
 112 @config_aux_path = ('.', '..', '../..');
 113 $config_aux_dir = '';
 114
 115 # Whether AC_PROG_MAKE_SET has been seen in configure.in.
 116 $seen_make_set = 0;
 117
 118 # Whether ud_GNU_GETTEXT has been seen in configure.in.
 119 $seen_gettext = 0;
 120 # Line number at which ud_GNU_GETTEXT seen.
 121 $ac_gettext_line = 0;
 122
 123 # Whether ALL_LINGUAS has been seen.
 124 $seen_linguas = '';
 125 # The actual text.
 126 $all_linguas = '';
 127 # Line number at which it appears.
 128 $all_linguas_line = 0;
 129
 130 # 1 if AC_PROG_INSTALL seen, 2 if AM_PROG_INSTALL seen.
 131 $seen_prog_install = 0;
 132
 133 # 1 if any scripts installed, 0 otherwise.
 134 $scripts_installed = 0;
 135
 136 # Whether AC_PATH_XTRA has been seen in configure.in.
 137 $seen_path_xtra = 0;
 138
 139 # Whether YACC variable has been seen in configure.in.
 140 $seen_prog_yacc = 0;
 141
 142 # TRUE if we've seen AC_CANONICAL_(HOST|SYSTEM).  The presence of
 143 # AC_CHECK_TOOL also sets this.
 144 $seen_canonical = 0;
 145
 146 # TRUE if we've seen AC_PROG_RANLIB.
 147 $seen_ranlib = 0;
 148
 149 # TRUE if we've seen AC_ARG_PROGRAM.
 150 $seen_arg_prog = 0;
 151
 152 # TRUE if we've seen AM_PROG_LIBTOOL.
 153 $seen_libtool = 0;
 154 $libtool_line = 0;
 155
 156 # TRUE if we've seen AM_MAINTAINER_MODE.
 157 $seen_maint_mode = 0;
 158
 159 # TRUE if we've seen PACKAGE and VERSION.
 160 $seen_package = 0;
 161 $seen_version = 0;
 162
 163 # TRUE if we've seen ud_PATH_LISPDIR.
 164 $seen_lispdir = 0;
 165
 166
 167 # Charsets used by maintainer and in distribution.  MAINT_CHARSET is
 168 # handled in a funny way: if seen in the top-level Makefile.am, it is
 169 # used for every directory which does not specify a different value.
 170 # The rationale here is that some directories (eg gettext) might be
 171 # distributions of other packages, and thus require their own charset
 172 # info.  However, the DIST_CHARSET must be the same for the entire
 173 # package; it can only be set at top-level.
 174 # FIXME this yields bugs when rebuilding.  What to do?  Always
 175 # read (and sometimes discard) top-level Makefile.am?
 176 $maint_charset = '';
 177 $dist_charset = 'utf8';         # recode doesn't support this yet.
 178
 179 # Name of input file ("Makefile.in") and output file ("Makefile.am").
 180 # These have no directory components.
 181 $am_file_name = '';
 182 $in_file_name = '';
 183
 184 \f
 185
 186 &initialize_global_constants;
 187
 188 # Parse command line.
 189 &parse_arguments (@ARGV);
 190
 191 # Do configure.in scan only once.
 192 &scan_configure;
 193
 194 die "automake: no \`Makefile.am' found or specified\n"
 195     if ! @input_files;
 196
 197 # Now do all the work on each file.
 198 foreach $am_file (@input_files)
 199 {
 200     # FIXME should support the AC_OUTPUT ":" syntax here.
 201     if (! -f ($am_file . '.am'))
 202     {
 203         &am_error ('no such file');
 204     }
 205     else
 206     {
 207         &generate_makefile ($am_file);
 208     }
 209 }
 210
 211 if ($seen_prog_install <= $scripts_installed)
 212 {
 213     &am_conf_error (($scripts_installed ? 'AM_PROG_INSTALL' : 'AC_PROG_INSTALL')
 214                     . " must be used in configure.in");
 215     &keyed_aclocal_warning ('AM_PROG_INSTALL')
 216         if $scripts_installed;
 217 }
 218
 219 exit $exit_status;
 220
 221
 222 ################################################################
 223
 224 # Parse command line.
 225 sub parse_arguments
 226 {
 227     local (@arglist) = @_;
 228
 229     # Start off as gnu.
 230     &set_strictness ('gnu');
 231
 232     while (@arglist)
 233     {
 234         if ($arglist[0] eq "--version")
 235         {
 236             print "automake - $PACKAGE $VERSION\n";
 237             exit 0;
 238         }
 239         elsif ($arglist[0] eq "--help")
 240         {
 241             &usage;
 242         }
 243         elsif ($arglist[0] =~ /^--amdir=(.+)$/)
 244         {
 245             $am_dir = $1;
 246         }
 247         elsif ($arglist[0] eq '--amdir')
 248         {
 249             &require_argument (@arglist);
 250             shift (@arglist);
 251             $am_dir = $arglist[0];
 252         }
 253         elsif ($arglist[0] =~ /^--strictness=(.+)$/)
 254         {
 255             &set_strictness ($1);
 256         }
 257         elsif ($arglist[0] eq '--gnu')
 258         {
 259             &set_strictness ('gnu');
 260         }
 261         elsif ($arglist[0] eq '--gnits')
 262         {
 263             &set_strictness ('gnits');
 264         }
 265         elsif ($arglist[0] eq '--foreign')
 266         {
 267             &set_strictness ('foreign');
 268         }
 269         elsif ($arglist[0] eq '--strictness' || $arglist[0] eq '-s')
 270         {
 271             &require_argument (@arglist);
 272             shift (@arglist);
 273             &set_strictness ($arglist[0]);
 274         }
 275         elsif ($arglist[0] eq '--include-deps' || $arglist[0] eq '-i')
 276         {
 277             $cmdline_use_dependencies = 0;
 278         }
 279         elsif ($arglist[0] eq '--no-force')
 280         {
 281             $force_generation = 0;
 282         }
 283         elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
 284         {
 285             # Set output directory.
 286             $output_directory = $1;
 287         }
 288         elsif ($arglist[0] eq '--output-dir' || $arglist[0] eq '-o')
 289         {
 290             &require_argument (@arglist);
 291             shift (@arglist);
 292             $output_directory = $arglist[0];
 293         }
 294         elsif ($arglist[0] eq '--add-missing' || $arglist[0] eq '-a')
 295         {
 296             $add_missing = 1;
 297         }
 298         elsif ($arglist[0] eq '--verbose' || $arglist[0] eq '-v')
 299         {
 300             $verbose = 1;
 301         }
 302         elsif ($arglist[0] eq '--')
 303         {
 304             # Stop option processing.
 305             shift (@arglist);
 306             push (@input_files, @arglist);
 307             last;
 308         }
 309         elsif ($arglist[0] =~ /^-/)
 310         {
 311             die "automake: unrecognized option -- \`$arglist[0]'\n";
 312         }
 313         else
 314         {
 315             push (@input_files, $arglist[0]);
 316         }
 317
 318         shift (@arglist);
 319     }
 320
 321     # Take global strictness from whatever we currently have set.
 322     $default_strictness = $strictness;
 323     $default_strictness_name = $strictness_name;
 324 }
 325
 326 # Ensure argument exists, or die.
 327 sub require_argument
 328 {
 329     local ($arg, @arglist) = @_;
 330     die "automake: no argument given for option \`$arg'\n"
 331         if ! @arglist;
 332 }
 333
 334 ################################################################
 335
 336 # Generate a Makefile.in given the name of the corresponding Makefile.
 337 sub generate_makefile
 338 {
 339     local ($makefile) = @_;
 340
 341     ($am_file_name = $makefile) =~ s/^.*\///;
 342     $in_file_name = $am_file_name . '.in';
 343     $am_file_name .= '.am';
 344
 345     &initialize_per_input;
 346     $relative_dir = &dirname ($makefile);
 347
 348     # At the toplevel directory, we might need config.guess, config.sub
 349     # or libtool.
 350     if ($relative_dir eq '.')
 351     {
 352         # libtool requires some files.
 353         &require_conf_file_with_conf_line ($libtool_line, $FOREIGN,
 354                                            'config.sub', 'config.guess',
 355                                            'libtool') if $seen_libtool;
 356
 357         # AC_CANONICAL_HOST and AC_CANONICAL_SYSTEM need config.guess and
 358         # config.sub.
 359         &require_config_file ($FOREIGN, 'config.guess', 'config.sub')
 360             if $seen_canonical;
 361     }
 362
 363     # We still need Makefile.in here, because sometimes the `dist'
 364     # target doesn't re-run automake.
 365     &push_dist_common ($in_file_name, $am_file_name);
 366     push (@sources, '$(SOURCES)')
 367         if &variable_defined ('SOURCES');
 368     push (@objects, '$(OBJECTS)')
 369         if &variable_defined ('OBJECTS');
 370
 371     # This is always the default target.  This gives us freedom to do
 372     # things in whatever order is convenient.
 373     $output_rules .= "default: all\n\n";
 374     push (@phony, 'default');
 375
 376     &read_am_file ($makefile . '.am');
 377     &handle_options;
 378
 379     # Check first, because we might modify some state.
 380     &check_gnu_standards;
 381     &check_gnits_standards;
 382
 383     &handle_configure;
 384     &handle_gettext;
 385     &handle_libraries;
 386     &handle_programs;
 387     &handle_scripts;
 388
 389     # Re-init SOURCES and OBJECTS.  FIXME other code shouldn't depend
 390     # on this (but currently does).
 391     $contents{'SOURCES'} = join (' ', @sources);
 392     $contents{'OBJECTS'} = join (' ', @objects);
 393
 394     &handle_texinfo;
 395     &handle_emacs_lisp;
 396     &handle_man_pages;
 397     &handle_data;
 398     &handle_headers;
 399     &handle_subdirs;
 400     &handle_tags;
 401     &handle_dist;
 402     &handle_dependencies;
 403     &handle_tests;
 404     &handle_footer;
 405     &handle_merge_targets;
 406     &handle_installdirs;
 407     &handle_clean;
 408     &handle_phony;
 409
 410     if (! -d ($output_directory . '/' . $relative_dir))
 411     {
 412         &mkdir ($output_directory . '/' . $relative_dir);
 413     }
 414
 415     local ($out_file) = $output_directory . '/' . $makefile . ".in";
 416     if (! $force_generation && -e $out_file)
 417     {
 418         local ($am_time) = (stat ($makefile . '.am'))[9];
 419         local ($in_time) = (stat ($out_file))[9];
 420         # FIXME how to do unsigned comparison?
 421         if ($am_time < $in_time)
 422         {
 423             # No need to update.
 424             return;
 425         }
 426     }
 427
 428     if (! open (GM_FILE, "> " . $out_file))
 429     {
 430         warn "automake: ${am_file}.in: cannot open: $!\n";
 431         $exit_status = 1;
 432         return;
 433     }
 434     print "automake: creating ", $makefile, ".in\n" if $verbose;
 435
 436     print GM_FILE $output_vars;
 437     print GM_FILE $output_rules;
 438     print GM_FILE $output_trailer;
 439
 440     close (GM_FILE);
 441 }
 442
 443 ################################################################
 444
 445 # Handle AUTOMAKE_OPTIONS variable.
 446 sub handle_options
 447 {
 448     return if ! &variable_defined ('AUTOMAKE_OPTIONS');
 449
 450     foreach (split (' ', $contents{'AUTOMAKE_OPTIONS'}))
 451     {
 452         last if /^#/;
 453
 454         $options{$_} = 1;
 455         if ($_ eq 'gnits' || $_ eq 'gnu' || $_ eq 'foreign')
 456         {
 457             &set_strictness ($_);
 458         }
 459         elsif ($_ eq 'no-installman' || $_ eq 'ansi2knr'
 460                || $_ eq 'dist-shar' || $_ eq 'dist-zip'
 461                || $_ eq 'dist-tarZ' || $_ eq 'dejagnu'
 462                || $_ eq 'no-installinfo')
 463         {
 464             # Explicitly recognize these.
 465         }
 466         elsif ($_ eq 'no-dependencies')
 467         {
 468             $use_dependencies = 0;
 469         }
 470         elsif (/[0-9]+\.?[0-9]+/)
 471         {
 472             # Got a version number.  Is the syntax too strict?
 473             local ($num_version);
 474             ($num_version = $VERSION) =~ tr/0-9//cd;
 475             if ($num_version < $_)
 476             {
 477                 &am_line_error ('AUTOMAKE_OPTIONS',
 478                                 "require version $_, only have $VERSION");
 479                 exit 1;
 480             }
 481         }
 482         else
 483         {
 484             &am_line_error ('AUTOMAKE_OPTIONS',
 485                             'option ', $_, 'not recognized');
 486         }
 487     }
 488 }
 489
 490 # Return object extension.  Just once, put some code into the output.
 491 sub get_object_extension
 492 {
 493     if (! $dir_holds_sources)
 494     {
 495         # Boilerplate.
 496         local ($xform) = '';
 497         if (&variable_defined ('CONFIG_HEADER'))
 498         {
 499             ($xform = &dirname ($contents{'CONFIG_HEADER'}))
 500                 =~ s/(\W)/\\$1/g;
 501             $xform = '-I' . $xform;
 502         }
 503         $xform = 's/\@CONFIG_INCLUDE_SPEC\@/' . $xform . '/go';
 504         $output_vars .= &file_contents_with_transform ($xform,
 505                                                        'compile-vars');
 506         $output_rules .= &file_contents ('compile');
 507         &push_phony_cleaners ('compile');
 508
 509         # If using X, include some extra variable definitions.  NOTE
 510         # we don't want to force these into CFLAGS or anything,
 511         # because not all programs will necessarily use X.
 512         if ($seen_path_xtra)
 513         {
 514             $output_vars .= ("X_CFLAGS = \@X_CFLAGS\@\n"
 515                              . "X_LIBS = \@X_LIBS\@\n"
 516                              . "X_EXTRA_LIBS = \@X_EXTRA_LIBS\@\n"
 517                              . "X_PRE_LIBS = \@X_PRE_LIBS\@\n");
 518         }
 519
 520         # Check for automatic de-ANSI-fication.
 521         $dir_holds_sources = '.o';
 522         push (@suffixes, '.c', '.o');
 523         push (@clean, 'compile');
 524
 525         if (defined $options{'ansi2knr'})
 526         {
 527             if (! $am_c_prototypes)
 528             {
 529                 &am_line_error ('AUTOMAKE_OPTIONS',
 530                                 "option \`ansi2knr' in use but \`AM_C_PROTOTYPES' not in configure.in");
 531                 &keyed_aclocal_warning ('AM_C_PROTOTYPES');
 532                 # Only give this error once.
 533                 $am_c_prototypes = 1;
 534             }
 535
 536             $dir_holds_sources = '$o';
 537             push (@suffixes, '._c', '._o');
 538
 539             &require_file_with_line ('AUTOMAKE_OPTIONS', $FOREIGN,
 540                                      'ansi2knr.c', 'ansi2knr.1');
 541
 542             $output_vars .= &file_contents ('kr-vars');
 543             $output_rules .= &file_contents ('compile-kr');
 544             $output_rules .= &file_contents ('clean-kr');
 545
 546             push (@clean, 'kr');
 547             &push_phony_cleaners ('kr');
 548         }
 549     }
 550     return $dir_holds_sources;
 551 }
 552
 553 # Handle SOURCE->OBJECT transform for one program or library.
 554 sub handle_source_transform
 555 {
 556     # one_file is canonical name.  unxformed is given name.  obj is
 557     # object extension.
 558     local ($one_file, $unxformed, $obj) = @_;
 559     local ($objpat) = $obj;
 560     $objpat =~ s/(\W)/\\$1/g;
 561
 562     if (&variable_defined ($one_file . "_OBJECTS"))
 563     {
 564         &am_line_error ($one_file . '_OBJECTS',
 565                         $one_file . '_OBJECTS', 'should not be defined');
 566         # No point in continuing.
 567         return;
 568     }
 569
 570     local ($source_list);
 571     local ($prefix);
 572     foreach $prefix ('', 'EXTRA_')
 573     {
 574         $source_list = '';
 575         if (&variable_defined ($prefix . $one_file . "_SOURCES"))
 576         {
 577             push (@sources, '$(' . $prefix . $one_file . "_SOURCES)");
 578             push (@objects, '$(' . $prefix . $one_file . "_OBJECTS)")
 579                 unless $prefix eq 'EXTRA_';
 580             $source_list = $contents{$prefix . $one_file . "_SOURCES"};
 581         }
 582         elsif ($prefix eq '')
 583         {
 584             $output_vars .= $one_file . "_SOURCES = " . $unxformed . ".c\n";
 585             push (@sources, $unxformed . '.c');
 586             push (@objects, $unxformed . $obj);
 587             $source_list = $unxformed . ".c ";
 588         }
 589         else
 590         {
 591             $output_vars .= "EXTRA_" . $one_file . "_SOURCES =\n";
 592         }
 593
 594         if ($source_list)
 595         {
 596             # Turn sources into objects.
 597             local (@files) = split (' ', $source_list);
 598             local (@result) = ();
 599             foreach (@files)
 600             {
 601                 # Skip header files, including C++-ish ones.
 602                 next if /\.[hH]$/;
 603                 next if /\.hxx$/;
 604                 # Skip things that look like macro references.
 605                 next if /^\$\(.*\)$/;
 606                 next if /^\$\{.*\}$/;
 607                 # Skip things that look like configure substitutions.
 608                 next if /^\@.*\@$/;
 609
 610                 # Include .c file for lex or yacc source in distribution.
 611                 if (/^(.*)\.[yl]$/)
 612                 {
 613                     # Yacc source.
 614                     &push_dist_common ($1 . '.c');
 615                     if (! defined $targets{$1 . '.c'})
 616                     {
 617                         # Generate a target.
 618                         $output_rules .= ($1 . '.c: ' . $_ . "\n"
 619                                           . "\t"
 620                                           . 'cd $(srcdir) && $(YACC) $(YFLAGS) $< && mv y.tab.c '
 621                                           . $1 . '.c' . "\n");
 622                     }
 623                 }
 624                 elsif (/^(.*)\.l$/)
 625                 {
 626                     # Lex source.
 627                     &push_dist_common ($1 . '.c');
 628                     if (! defined $targets{$1 . '.c'})
 629                     {
 630                         $output_rules .= ($1 . '.c: ' . $_ . "\n"
 631                                           . "\t"
 632                                           . 'cd $(srcdir) && $(LEX) $(LFLAGS) $< && mv lex.yy.c '
 633                                           . $1 . '.c' . "\n");
 634                     }
 635                 }
 636
 637                 # Transform source files into .o files.
 638                 s/\.cc$/$obj/g;
 639                 s/\.cxx$/$obj/g;
 640                 s/\.[cCmylfs]$/$obj/g;
 641                 push (@result, $_)
 642                     unless $prefix eq 'EXTRA_';
 643
 644                 # Transform .o or $o file into .P file (for automatic
 645                 # dependency code).
 646                 s/$objpat$/.P/g;
 647                 $dep_files{'$(srcdir)/.deps/' . $_} = 1;
 648             }
 649
 650             &pretty_print ($one_file . "_OBJECTS =", "", @result)
 651                 unless $prefix eq 'EXTRA_';
 652         }
 653     }
 654
 655     if (&variable_defined ('CONFIG_HEADER'))
 656     {
 657         $output_rules .= ('$(' . $one_file . "_OBJECTS): "
 658                           . $contents{'CONFIG_HEADER'} . "\n");
 659     }
 660
 661     return @result;
 662 }
 663
 664 # Special-case @ALLOCA@ and @LIBOBJS@ in _LDADD or _LIBADD variables.
 665 sub handle_lib_objects
 666 {
 667     local ($var) = @_;
 668
 669     die "programming error in handle_lib_objects"
 670         if ! &variable_defined ($var);
 671
 672     # We recognize certain things that are commonly put in LIBADD or
 673     # LDADD.
 674     local ($lsearch);
 675
 676     foreach $lsearch (split (' ', $contents{$var}))
 677     {
 678         # Automatically handle @LIBOBJS@ and @ALLOCA@.  Basically this
 679         # means adding entries to dep_files.
 680         if ($lsearch eq '@LIBOBJS@')
 681         {
 682             local ($iter, $rewrite);
 683             foreach $iter (keys %libsources)
 684             {
 685                 if ($iter ne 'alloca.c')
 686                 {
 687                     ($rewrite = $iter) =~ s/\.c$/.P/;
 688                     $dep_files{'$(srcdir)/.deps/' . $rewrite} = 1;
 689                     &require_file_with_line ($var, $FOREIGN, $iter);
 690                 }
 691             }
 692         }
 693         elsif ($lsearch eq '@ALLOCA@')
 694         {
 695             &am_line_error ($var,
 696                             "\@ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
 697                 if ! defined $libsources{'alloca.c'};
 698             $dep_files{'$(srcdir)/.deps/alloca.P'} = 1;
 699             &require_file_with_line ($var, $FOREIGN, 'alloca.c');
 700         }
 701     }
 702 }
 703
 704 # Handle C programs.
 705 sub handle_programs
 706 {
 707     local (@proglist) = &am_install_var ('-clean',
 708                                          'programs', 'PROGRAMS',
 709                                          'bin', 'sbin', 'libexec', 'pkglib',
 710                                          'noinst', 'check');
 711     return if ! @proglist;
 712
 713     # If a program is installed, this is required.  We only want this
 714     # error to appear once.
 715     &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
 716         unless $seen_arg_prog;
 717     $seen_arg_prog = 1;
 718
 719     local ($obj) = &get_object_extension;
 720     local ($one_file, $xname, $munge);
 721
 722     foreach $one_file (@proglist)
 723     {
 724         # Canonicalize names.
 725         ($xname = $one_file) =~ tr/A-Za-z0-9_/_/c;
 726         if ($xname ne $one_file)
 727         {
 728             local ($xt);
 729             foreach $xt ('_LDADD', '_SOURCES', '_OBJECTS', '_DEPENDENCIES')
 730             {
 731                 &am_line_error ($one_file . $xt,
 732                                 "invalid variable \`" . $one_file . $xt
 733                                 . "'; should be \`" . $xname . $xt . "'")
 734                     if &variable_defined ($one_file . $xt);
 735             }
 736         }
 737
 738         &handle_source_transform ($xname, $one_file, $obj);
 739
 740         if (&variable_defined ($xname . "_LDADD"))
 741         {
 742             &handle_lib_objects ($xname . '_LDADD');
 743         }
 744         else
 745         {
 746             # User didn't define prog_LDADD override.  So do it.
 747             $output_vars .= $xname . '_LDADD = $(LDADD)' . "\n";
 748         }
 749
 750         $output_rules .=
 751             &file_contents_with_transform
 752                 ('s/\@PROGRAM\@/' . $one_file . '/go;'
 753                  . 's/\@XPROGRAM\@/' . $xname . '/go;',
 754                  'program');
 755     }
 756
 757     &handle_lib_objects ('LDADD')
 758         if &variable_defined ('LDADD');
 759 }
 760
 761 # Handle libraries.
 762 sub handle_libraries
 763 {
 764     local (@liblist) = &am_install_var ('-no-all', '-clean',
 765                                         'libraries', 'LIBRARIES',
 766                                         'lib', 'pkglib', 'noinst', 'check');
 767     return if ! @liblist;
 768
 769     if (! $seen_ranlib)
 770     {
 771         # FIXME need am_line_error here.  But we don't know which
 772         # variable exists.  Must add a loop...  No.  Must have
 773         # am_install_var return a hash.  Otherwise the user could add
 774         # install directories that we'd never find.
 775         &am_error ("library requires either \`AC_PROG_RANLIB' or `AM_PROG_LIBTOOL' in configure.in");
 776         # Only get this error once.
 777         $seen_ranlib = 1;
 778     }
 779
 780     # Generate _LIBFILES variables.  Too bad we can't do this in
 781     # am_install_var.
 782     local ($onedir, $onelib);
 783     local (@outlist);
 784     foreach $onedir (&am_primary_prefixes ('LIBRARIES', 'lib', 'pkglib',
 785                                            'noinst', 'check'))
 786     {
 787         if (&variable_defined ($onedir . '_LIBRARIES'))
 788         {
 789             @outlist = ();
 790             foreach $onelib (split (' ', $contents{$onedir . '_LIBRARIES'}))
 791             {
 792                 push (@outlist, 'lib' . $onelib . '.a');
 793             }
 794             &pretty_print ($onedir . '_LIBFILES =', "", @outlist);
 795         }
 796     }
 797     push (@all, '$(LIBFILES)');
 798
 799     local ($obj) = &get_object_extension;
 800     local ($munge);
 801     foreach $onelib (@liblist)
 802     {
 803         if (&variable_defined ($onelib . '_LIBADD'))
 804         {
 805             &handle_lib_objects ($onelib . '_LIBADD');
 806         }
 807         else
 808         {
 809             # Generate support for conditional object inclusion in
 810             # libraries.
 811             $output_vars .= $onelib . "_LIBADD =\n";
 812         }
 813
 814         &handle_source_transform ($onelib, $onelib, $obj);
 815
 816         $output_rules .=
 817             &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go',
 818                                            'library');
 819     }
 820
 821     # Turn "foo" into "libfoo.a" and include macro definition.
 822     grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
 823
 824     if (! &variable_defined ('LIBFILES'))
 825     {
 826         &pretty_print ('LIBFILES = ', "", @liblist);
 827     }
 828
 829     if ($seen_libtool)
 830     {
 831         $output_vars .= ('AR = $(LIBTOOL) archive' . "\n"
 832                          . 'RANLIB = $(LIBTOOL) ranlib' . "\n"
 833                          . 'LCOMPILE = $(LIBTOOL) compile $(DEFS) $(INCLUDES)'
 834                          . ' $(CPPFLAGS) $(CFLAGS)' . "\n");
 835     }
 836     else
 837     {
 838         $output_vars .= ('AR = ar' . "\n"
 839                          . 'RANLIB = @RANLIB@' . "\n");
 840     }
 841 }
 842
 843 # Handle scripts.
 844 sub handle_scripts
 845 {
 846     # NOTE we no longer automatically clean SCRIPTS, because it is
 847     # useful to sometimes distribute scripts verbatim.  This happens
 848     # eg in Automake itself.
 849     local ($msi);
 850     $msi = &am_install_var ('scripts', 'SCRIPTS',
 851                             'bin', 'sbin', 'libexec', 'pkgdata',
 852                             'noinst', 'check');
 853
 854     # We really only want a boolean value.
 855     $scripts_installed = 1 if $msi;
 856
 857     if ($scripts_installed)
 858     {
 859         # If a program is installed, this is required.  We only want this
 860         # error to appear once.
 861         &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
 862             unless $seen_arg_prog;
 863         $seen_arg_prog = 1;
 864     }
 865 }
 866
 867 # Search a file for a "version.texi" Texinfo include.  Return the name
 868 # of the include file if found, or the empty string if not.  A
 869 # "version.texi" file is actually any file whose name matches
 870 # "vers*.texi".
 871 sub grep_for_vers_texi
 872 {
 873     local ($filename) = @_;
 874
 875     if (! open (TEXI, $filename))
 876     {
 877         &am_error ("couldn't open \`$filename': $!");
 878         return '';
 879     }
 880     print "automake: reading $filename\n" if $verbose;
 881
 882     while (<TEXI>)
 883     {
 884         if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
 885         {
 886             # Found it.
 887             close (TEXI);
 888             return $1;
 889         }
 890     }
 891
 892     close (TEXI);
 893     return '';
 894 }
 895
 896 # Handle all Texinfo source.
 897 sub handle_texinfo
 898 {
 899     &am_line_error ('TEXINFOS',
 900                     "\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
 901         if &variable_defined ('TEXINFOS');
 902     return if (! &variable_defined ('info_TEXINFOS')
 903                && ! &variable_defined ('html_TEXINFOS'));
 904
 905     local (@texis) = split (' ', $contents{'info_TEXINFOS'});
 906
 907     local (@infos_list, @info_deps_list, @dvis_list, @texi_deps);
 908     local ($infobase, $info_cursor);
 909     local (%versions);
 910     local ($done) = 0;
 911     local ($vti);
 912     local ($tc_cursor, @texi_cleans);
 913     local ($canonical);
 914
 915     foreach $info_cursor (@texis)
 916     {
 917         ($infobase = $info_cursor) =~ s/\.texi$//;
 918
 919         # If 'version.texi' is referenced by input file, then include
 920         # automatic versioning capability.
 921         local ($vtexi)
 922             = &grep_for_vers_texi ($relative_dir . "/" . $info_cursor);
 923         if ($vtexi)
 924         {
 925             &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
 926                 if (defined $versions{$vtexi});
 927             $versions{$vtexi} = $info_cursor;
 928
 929             # We number the stamp-vti files.  This is doable since the
 930             # actual names don't matter much.  We only number starting
 931             # with the second one, so that the common case looks nice.
 932             $vti = 'vti' . ($done ? $done : '');
 933             &push_dist_common ($vtexi, 'stamp-' . $vti);
 934             push (@clean, $vti);
 935
 936             # Only require once.
 937             &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
 938                                           'mdate-sh')
 939                 if ! $done;
 940             ++$done;
 941
 942             local ($conf_pat);
 943             ($conf_pat = $config_aux_dir) =~ s/(\W)/\\$1/g;
 944             $output_rules .=
 945                 &file_contents_with_transform
 946                     ('s/\@TEXI\@/' . $info_cursor . '/g; '
 947                      . 's/\@VTI\@/' . $vti . '/g; '
 948                      . 's/\@VTEXI\@/' . $vtexi . '/g;'
 949                      . 's,\@MDDIR\@,' . $conf_pat . ',g;',
 950                      'texi-version');
 951
 952             &push_phony_cleaners ($vti);
 953         }
 954
 955         # If user specified file_TEXINFOS, then use that as explicit
 956         # dependency list.
 957         @texi_deps = ();
 958         push (@texi_deps, $info_cursor);
 959         push (@texi_deps, $vtexi) if $vtexi;
 960
 961         # Canonicalize name first.
 962         ($canonical = $infobase) =~ tr/A-Za-z0-9_/_/c;
 963         if (&variable_defined ($canonical . "_TEXINFOS"))
 964         {
 965             push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
 966             &push_dist_common ('$(' . $canonical . '_TEXINFOS)');
 967         }
 968
 969         $output_rules .= ("\n" . $infobase . ".info: "
 970                           . join (' ', @texi_deps)
 971                           . "\n" . $infobase . ".dvi: "
 972                           . join (' ', @texi_deps)
 973                           . "\n\n");
 974
 975         push (@infos_list, $infobase . '.info', $infobase . '.info-[0-9]',
 976               $infobase . '.info-[0-9][0-9]');
 977         push (@info_deps_list, $infobase . '.info');
 978         push (@dvis_list, $infobase . '.dvi');
 979
 980         # Generate list of things to clean for this target.  We do
 981         # this explicitly because otherwise too many things could be
 982         # removed.  In particular the ".log" extension might
 983         # reasonably be used in other contexts by the user.
 984         foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns',
 985                             'ky', 'log', 'pg', 'toc', 'tp', 'vr', 'op')
 986         {
 987             push (@texi_cleans, $infobase . '.' . $tc_cursor);
 988         }
 989     }
 990
 991     # Some boilerplate.
 992     $output_vars .= &file_contents ('texinfos-vars');
 993     $output_rules .= &file_contents ('texinfos');
 994     push (@phony, 'install-info', 'uninstall-info');
 995
 996     # How to clean.
 997     $output_rules .= "\nmostlyclean-info:\n";
 998     &pretty_print_rule ("\trm -f", "\t  ", @texi_cleans);
 999     $output_rules .= ("\nclean-info:\n\ndistclean-info:\n\n"
1000                       . "maintainer-clean-info:\n\t"
1001                       . 'rm -f $(INFOS)' . "\n");
1002     &push_phony_cleaners ('info');
1003
1004     push (@suffixes, '.texi', '.info', '.dvi');
1005
1006     if (! defined $options{'no-installinfo'})
1007     {
1008         push (@uninstall, 'uninstall-info');
1009         push (@installdirs, '$(infodir)');
1010         unshift (@install_data, 'install-info');
1011
1012         # Make sure documentation is made and installed first.  Use
1013         # $(INFO_DEPS), not 'info', because otherwise recursive makes
1014         # get run twice during "make all".
1015         unshift (@all, '$(INFO_DEPS)');
1016     }
1017     push (@clean, 'info');
1018     push (@info, '$(INFO_DEPS)');
1019     push (@dvi, '$(DVIS)');
1020
1021     $output_vars .= ("INFOS = " . join (' ', @infos_list) . "\n"
1022                      . "INFO_DEPS = " . join (' ', @info_deps_list)  . "\n"
1023                      . "DVIS = " . join (' ', @dvis_list) . "\n"
1024                      # This next isn't strictly needed now -- the
1025                      # places that look here could easily be changed
1026                      # to look in info_TEXINFOS.  But this is probably
1027                      # better, in case noinst_TEXINFOS is ever
1028                      # supported.
1029                      . "TEXINFOS = " . $contents{'info_TEXINFOS'} . "\n\n");
1030
1031     # Do some error checking.
1032     &require_file_with_line ('info_TEXINFOS', $FOREIGN, 'texinfo.tex');
1033 }
1034
1035 # Handle any man pages.
1036 sub handle_man_pages
1037 {
1038     &am_line_error ('MANS', "\`MANS' is an anachronism; use \`man_MANS'")
1039         if &variable_defined ('MANS');
1040     return if ! &variable_defined ('man_MANS');
1041
1042     # We generate the manpage install code by hand to avoid the use of
1043     # basename in the generated Makefile.
1044     local (@mans) = split (' ', $contents{'man_MANS'});
1045     local (%sections, %inames, %mbases, %secmap, %fullsecmap);
1046     local ($i) = 1;
1047     foreach (@mans)
1048     {
1049         # FIXME: statement without effect:
1050         /^(.*)\.([0-9])([a-z]*)$/;
1051         $sections{$2} = 1;
1052         $inames{$i} = $_;
1053         $mbases{$i} = $1;
1054         $secmap{$i} = $2;
1055         $fullsecmap{$i} = $2 . $3;
1056         $i++;
1057     }
1058
1059     # We don't really need this, but we use it in case we ever want to
1060     # support noinst_MANS.
1061     $output_vars .= "MANS = " . $contents{'man_MANS'} . "\n";
1062
1063     # Generate list of install dirs.
1064     $output_rules .= "install-man: \$(MANS)\n";
1065     foreach (keys %sections)
1066     {
1067         push (@installdirs, '$(mandir)/man' . $_)
1068             unless defined $options{'no-installman'};
1069         $output_rules .= ("\t" . '$(mkinstalldirs) $(mandir)/man'
1070                           . $_ . "\n");
1071     }
1072     push (@phony, 'install-man');
1073
1074     # Generate install target.
1075     local ($key);
1076     foreach $key (keys %inames)
1077     {
1078         $_ = $install_man_format;
1079         s/\@SECTION\@/$secmap{$key}/g;
1080         s/\@MAN\@/$inames{$key}/g;
1081         s/\@FULLSECT\@/$fullsecmap{$key}/g;
1082         s/\@MANBASE\@/$mbases{$key}/g;
1083         $output_rules .= $_;
1084     }
1085     $output_rules .= "\n";
1086
1087     $output_rules .= "uninstall-man:\n";
1088     foreach $key (keys %inames)
1089     {
1090         $_ = $uninstall_man_format;
1091         s/\@SECTION\@/$secmap{$key}/g;
1092         s/\@MAN\@/$inames{$key}/g;
1093         s/\@FULLSECT\@/$fullsecmap{$key}/g;
1094         s/\@MANBASE\@/$mbases{$key}/g;
1095         $output_rules .= $_;
1096     }
1097     $output_rules .= "\n";
1098     push (@phony, 'uninstall-man');
1099
1100     $output_vars .= &file_contents ('mans-vars');
1101
1102     if (! defined $options{'no-installman'})
1103     {
1104         push (@install_data, 'install-man');
1105         push (@uninstall, 'uninstall-man');
1106         push (@all, '$(MANS)');
1107     }
1108 }
1109
1110 # Handle DATA variables.
1111 sub handle_data
1112 {
1113     &am_install_var ('data', 'DATA', 'data', 'sysconf',
1114                      'sharedstate', 'localstate', 'pkgdata',
1115                      'noinst', 'check');
1116 }
1117
1118 # Handle TAGS.
1119 sub handle_tags
1120 {
1121     local ($tagging) = 0;
1122
1123     push (@phony, 'tags');
1124     if (&variable_defined ('SUBDIRS'))
1125     {
1126         $output_rules .= &file_contents ('tags');
1127         push (@phony, 'tags-recursive');
1128         $tagging = 1;
1129     }
1130     elsif ($dir_holds_sources
1131            || $dir_holds_headers
1132            || &variable_defined ('ETAGS_ARGS'))
1133     {
1134         $output_rules .= &file_contents ('tags-subd');
1135         $tagging = 1;
1136     }
1137
1138     if ($tagging)
1139     {
1140         $output_rules .= &file_contents ('tags-clean');
1141         push (@clean, 'tags');
1142         &push_phony_cleaners ('tags');
1143     }
1144     else
1145     {
1146         # Every Makefile must define some sort of TAGS rule.
1147         # Otherwise, it would be possible for a top-level "make TAGS"
1148         # to fail because some subdirectory failed.
1149         $output_rules .= "tags: TAGS\nTAGS:\n\n";
1150     }
1151 }
1152
1153 # Worker for handle_dist.
1154 sub handle_dist_worker
1155 {
1156     $output_rules .= 'distdir: $(DEP_DISTFILES)' . "\n";
1157
1158     # Initialization; only at top level.
1159     if ($relative_dir eq '.')
1160     {
1161         if ($strictness >= $GNITS)
1162         {
1163             # For Gnits users, this is pretty handy.  Look at 15 lines
1164             # in case some explanatory text is desirable.
1165             $output_rules .= '  @if sed 15q $(srcdir)/NEWS | fgrep -e "$(VERSION)" > /dev/null; then :; else \\
1166           echo "NEWS not updated; not releasing" 1>&2; \\
1167           exit 1;                               \\
1168         fi
1169 ';
1170         }
1171
1172
1173         $output_rules .=
1174             # Create dist directory.
1175             '   rm -rf $(distdir)
1176         mkdir $(distdir)
1177         -chmod 755 $(distdir)
1178 ';
1179
1180         # Only run automake in `dist' target if --include-deps not
1181         # specified.  That way the recipient of a distribution can run
1182         # "make dist" and not need Automake.
1183         if ($cmdline_use_dependencies)
1184         {
1185             $output_rules .=
1186                 (
1187                  # We need an absolute path for --output-dir.  Thus the
1188                  # weirdness.
1189                  '      distdir=`cd $(distdir) && pwd` \\
1190           && cd $(srcdir) \\
1191           && automake --include-deps --output-dir=$$distdir --strictness='
1192                  # Set strictness of output.
1193                  . $strictness_name . "\n"
1194                  );
1195         }
1196     }
1197
1198     # In loop, test for file existence because sometimes a file gets
1199     # included in DISTFILES twice.  For example this happens when a
1200     # single source file is used in building more than one program.
1201     # Also, there are situations in which "ln" can fail.  For instance
1202     # a file to distribute could actually be a cross-filesystem
1203     # symlink -- this can easily happen if "gettextize" was run on the
1204     # distribution.  Note that DISTFILES can contain a wildcard (for
1205     # info files, sigh), so we must use the echo trick.
1206     $output_rules .= '  @for file in `cd $(srcdir) && echo $(DISTFILES)`; do \\
1207           test -f $(distdir)/$$file \\
1208           || ln $(srcdir)/$$file $(distdir)/$$file 2> /dev/null \\
1209           || cp -p $(srcdir)/$$file $(distdir)/$$file; \\
1210         done
1211 ';
1212
1213     # If we have SUBDIRS, create all dist subdirectories and do
1214     # recursive build.
1215     if (&variable_defined ('SUBDIRS'))
1216     {
1217         # Test for directory existence here because previous automake
1218         # invocation might have created some directories.  Note that
1219         # we explicitly set distdir for the subdir make; that lets us
1220         # mix-n-match many automake-using packages into one large
1221         # package, and have "dist" at the top level do the right
1222         # thing.
1223         $output_rules .= '      for subdir in $(SUBDIRS); do            \\
1224           test -d $(distdir)/$$subdir           \\
1225           || mkdir $(distdir)/$$subdir          \\
1226           || exit 1;                            \\
1227           chmod 755 $(distdir)/$$subdir;        \\
1228           (cd $$subdir && $(MAKE) distdir=../$(distdir)/$$subdir distdir) \\
1229             || exit 1; \\
1230         done
1231 ';
1232     }
1233
1234     # If the target `dist-hook' exists, run it now.  This allows
1235     # users to do random weird things to the distribution before it is
1236     # packaged up.
1237     if (defined $contents{'dist-hook'})
1238     {
1239         $output_rules .= "\t\$(MAKE) dist-hook\n";
1240     }
1241
1242     push (@phony, 'distdir');
1243 }
1244
1245 # Handle 'dist' target.
1246 sub handle_dist
1247 {
1248     # Set up maint_charset.
1249     $local_maint_charset = $contents{'MAINT_CHARSET'}
1250         if &variable_defined ('MAINT_CHARSET');
1251     $maint_charset = $local_maint_charset
1252         if $relative_dir eq '.';
1253
1254     if (&variable_defined ('DIST_CHARSET'))
1255     {
1256         &am_line_error ('DIST_CHARSET',
1257                         "DIST_CHARSET defined but no MAINT_CHARSET defined")
1258             if ! $local_maint_charset;
1259         if ($relative_dir eq '.')
1260         {
1261             $dist_charset = $contents{'DIST_CHARSET'}
1262         }
1263         else
1264         {
1265             &am_line_error ('DIST_CHARSET',
1266                             "DIST_CHARSET can only be defined at top level");
1267         }
1268     }
1269
1270     # Look for common files that should be included in distribution.
1271     local ($cfile);
1272     foreach $cfile (@common_files)
1273     {
1274         if (-f ($relative_dir . "/" . $cfile))
1275         {
1276             &push_dist_common ($cfile);
1277         }
1278     }
1279
1280     # Keys of %dist_common are names of files to distributed.  We put
1281     # README first because it then becomes easier to make a
1282     # Usenet-compliant shar file (in these, README must be first).
1283     # FIXME do more ordering of files here.
1284     local (@coms);
1285     if (defined $dist_common{'README'})
1286     {
1287         push (@coms, 'README');
1288         undef $dist_common{'README'};
1289     }
1290     push (@coms, sort keys %dist_common);
1291
1292     &pretty_print ("DIST_COMMON =", "", @coms);
1293     $output_vars .= "\n";
1294
1295     # Some boilerplate.
1296     $output_vars .= &file_contents ('dist-vars');
1297
1298     # Put these things in rules section so it is easier for whoever
1299     # reads Makefile.in.
1300     if (! &variable_defined ('distdir'))
1301     {
1302         if ($relative_dir eq '.')
1303         {
1304             $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
1305         }
1306         else
1307         {
1308             $output_rules .= ("\n"
1309                               . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
1310                               . "\n");
1311         }
1312     }
1313     if ($relative_dir ne '.')
1314     {
1315         $output_rules .= "\nsubdir = " . $relative_dir . "\n";
1316     }
1317
1318     # Generate 'dist' target, and maybe dist-shar / dist-zip / dist-tarZ.
1319     if ($relative_dir eq '.')
1320     {
1321         # Rule to check whether a distribution is viable.
1322         $output_rules .= ('# This target untars the dist file and tries a VPATH configuration.  Then
1323 # it guarantees that the distribution is self-contained by making another
1324 # tarfile.
1325 distcheck: dist
1326         rm -rf $(distdir)
1327         $(TAR) zxf $(distdir).tar.gz
1328         mkdir $(distdir)/=build
1329         mkdir $(distdir)/=inst
1330         dc_install_base=`cd $(distdir)/=inst && pwd`; \\
1331         cd $(distdir)/=build \\
1332           && ../configure '
1333
1334                           . ($seen_gettext ? '--with-included-gettext ' : '')
1335                           . '--srcdir=.. --prefix=$$dc_install_base \\
1336           && $(MAKE) \\
1337           && $(MAKE) dvi \\
1338           && $(MAKE) check \\
1339           && $(MAKE) install \\
1340           && $(MAKE) installcheck \\
1341           && $(MAKE) dist
1342         rm -rf $(distdir)
1343         @echo "========================"; \\
1344         echo "$(distdir).tar.gz is ready for distribution"; \\
1345         echo "========================"
1346 ');
1347
1348         $output_rules .= 'dist: distdir' . "\n\t";
1349         # Ignore return result from chmod, because it might give an
1350         # error if we chmod a symlink.
1351         $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1352         $output_rules .= '$(TAR) chozf $(distdir).tar.gz $(distdir)';
1353         $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1354
1355         if (defined $options{'dist-shar'})
1356         {
1357             $output_rules .= 'dist-shar: distdir' . "\n\t";
1358             # Ignore return result from chmod, because it might give
1359             # an error if we chmod a symlink.
1360             $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1361             $output_rules .= 'shar $(distdir) | gzip > $(distdir).shar.gz';
1362             $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1363         }
1364
1365         if (defined $options{'dist-zip'})
1366         {
1367             $output_rules .= 'dist-zip: distdir' . "\n\t";
1368             $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1369             $output_rules .= 'zip -rq $(distdir).zip $(distdir)';
1370             $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1371         }
1372
1373         if (defined $options{'dist-tarZ'})
1374         {
1375             $output_rules .= 'dist-tarZ: distdir' . "\n\t";
1376             $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1377             $output_rules .= '$(TAR) chf - $(distdir) | compress -c > $(distdir).tar.Z';
1378             $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1379         }
1380     }
1381
1382     # Generate distdir target.
1383     &handle_dist_worker;
1384 }
1385
1386 # Handle auto-dependency code.
1387 sub handle_dependencies
1388 {
1389     if ($use_dependencies)
1390     {
1391         # Include GNU-make-specific auto-dep code.
1392         if ($dir_holds_sources)
1393         {
1394             &pretty_print ('DEP_FILES =', "", sort keys %dep_files);
1395             $output_rules .= &file_contents ('depend');
1396         }
1397     }
1398     else
1399     {
1400         # Include any auto-generated deps that are present.
1401         if (-d ($relative_dir . "/.deps") && -f ($relative_dir . "/.deps/.P"))
1402         {
1403             local ($depfile);
1404             local ($gpat) = $relative_dir . "/.deps/*.P";
1405
1406             foreach $depfile (<${gpat}>)
1407             {
1408                 if (! open (DEP_FILE, $depfile))
1409                 {
1410                     &am_error ("couldn't open \`$depfile': $!");
1411                     next;
1412                 }
1413                 print "automake: reading $depfile\n" if $verbose;
1414
1415                 # Slurp entire file.
1416                 $output_rules .= join ('', <DEP_FILE>);
1417
1418                 close (DEP_FILE);
1419             }
1420
1421             $output_rules .= "\n";
1422         }
1423     }
1424 }
1425
1426 # Handle subdirectories.
1427 sub handle_subdirs
1428 {
1429     if (! &variable_defined ('SUBDIRS'))
1430     {
1431         &am_conf_error
1432             ("ud_GNU_GETTEXT in configure.in but SUBDIRS not defined")
1433                 if $seen_gettext && $relative_dir eq '.';
1434         return;
1435     }
1436
1437     &require_file_with_conf_line ($ac_gettext_line, $FOREIGN, 'ABOUT-NLS')
1438         if $seen_gettext;
1439
1440     return if ! &variable_defined ('SUBDIRS');
1441
1442     # Make sure each directory mentioned in SUBDIRS actually exists.
1443     local ($dir);
1444     foreach $dir (split (' ', $contents{'SUBDIRS'}))
1445     {
1446         # Skip directories substituted by configure.
1447         next if $dir =~ /^\@.*\@$/;
1448         &am_line_error ('SUBDIRS',
1449                         "required directory $relative_dir/$dir does not exist")
1450             if ! -d $relative_dir . '/' . $dir;
1451     }
1452
1453     $output_rules .= &file_contents ('subdirs');
1454
1455     # Push a bunch of phony targets.
1456     local ($phonies);
1457     foreach $phonies ('-data', '-exec', 'dirs')
1458     {
1459         push (@phony, 'install' . $phonies . '-recursive');
1460         push (@phony, 'uninstall' . $phonies . '-recursive');
1461     }
1462     foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
1463     {
1464         push (@phony, $phonies . '-recursive');
1465     }
1466     &push_phony_cleaners ('recursive');
1467
1468     push (@check, "check-recursive");
1469     push (@installcheck, "installcheck-recursive");
1470     push (@info, "info-recursive");
1471     push (@dvi, "dvi-recursive");
1472
1473     $recursive_install = 1;
1474 }
1475
1476 # Handle aclocal.m4.
1477 sub handle_aclocal_m4
1478 {
1479     local ($regen_aclocal) = 0;
1480     if (-f 'aclocal.m4')
1481     {
1482         $output_vars .= "ACLOCAL = aclocal.m4\n";
1483         &push_dist_common ('aclocal.m4');
1484
1485         if (open (ACLOCAL, '< aclocal.m4'))
1486         {
1487             local ($line);
1488             $line = <ACLOCAL>;
1489             close (ACLOCAL);
1490
1491             if ($line =~ 'generated automatically by aclocal')
1492             {
1493                 $regen_aclocal = 1;
1494             }
1495         }
1496     }
1497
1498     local ($acinclude) = 0;
1499     if (-f 'acinclude.m4')
1500     {
1501         $regen_aclocal = 1;
1502         $acinclude = 1;
1503     }
1504     else
1505     {
1506         # FIXME how to tell if aclocal.m4 should be automatically
1507         # regenerated?
1508     }
1509
1510     if ($regen_aclocal)
1511     {
1512         $output_rules .= ("aclocal.m4: configure.in"
1513                           . ($acinclude ? ' acinclude.m4' : '')
1514                           . "\n\t"
1515                           . 'cd $(srcdir) && aclocal'
1516                           . "\n");
1517     }
1518 }
1519
1520 # Handle remaking and configure stuff.
1521 sub handle_configure
1522 {
1523     # If SUBDIRS defined, require AC_PROG_MAKE_SET.
1524     &am_line_error ('SUBDIRS', "AC_PROG_MAKE_SET must be used in configure.in")
1525         if &variable_defined ('SUBDIRS') && ! $seen_make_set;
1526
1527     local ($top_reldir);
1528     if ($relative_dir ne '.')
1529     {
1530         # In subdirectory.
1531         $output_rules .= &file_contents ('remake-subd');
1532         $top_reldir = '../';
1533     }
1534     else
1535     {
1536         &handle_aclocal_m4;
1537         $output_rules .= &file_contents_with_transform ('s/\@STRICTNESS\@/'
1538                                                         . $strictness_name
1539                                                         . '/g',
1540                                                         'remake');
1541
1542         &am_error
1543             ("\`install.sh' is an anachronism; use \`install-sh' instead")
1544                 if -f $relative_dir . '/install.sh';
1545
1546         # If we have a configure header, require it.
1547         if ($config_header)
1548         {
1549             # FIXME this restriction should be lifted.
1550             # FIXME first see if it is even needed as-is.
1551             &am_conf_line_error ($config_header_line,
1552                                  "argument to AC_CONFIG_HEADER contains \`/'\n")
1553                 if ($config_header =~ /\//);
1554
1555             &require_file_with_conf_line ($config_header_line,
1556                                           $FOREIGN, $config_header);
1557
1558             # Header defined and in this directory.
1559             if (-f 'acconfig.h')
1560             {
1561                 $output_vars .= "ACCONFIG = acconfig.h\n";
1562                 &push_dist_common ('acconfig.h');
1563             }
1564             if (-f $config_name . '.top')
1565             {
1566                 $output_vars .= "CONFIG_TOP = ${config_name}.top\n";
1567                 &push_dist_common ($config_name . '.top');
1568             }
1569             if (-f $config_name . '.bot')
1570             {
1571                 $output_vars .= "CONFIG_BOT = ${config_name}.bot\n";
1572                 &push_dist_common ($config_name . '.bot');
1573             }
1574
1575             &require_file_with_conf_line ($config_header_line, $FOREIGN,
1576                                           'stamp-h.in');
1577
1578             $output_rules .= &file_contents ('remake-hdr');
1579             $output_vars .= "CONFIG_HEADER_IN = ${config_header}\n";
1580         }
1581
1582         $top_reldir = '';
1583     }
1584
1585     # Set location of mkinstalldirs.
1586     if ($config_aux_dir ne '.' && $config_aux_dir ne '')
1587     {
1588         $output_vars .= 'mkinstalldirs = ' . $config_aux_dir;
1589     }
1590     else
1591     {
1592         $output_vars .= 'mkinstalldirs = $(top_srcdir)';
1593     }
1594     $output_vars .= '/mkinstalldirs' . "\n";
1595
1596     &am_line_error ('CONFIG_HEADER',
1597                     "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
1598         if &variable_defined ('CONFIG_HEADER');
1599
1600     # Generate CONFIG_HEADER define, and define interally.
1601     $output_vars .= "CONFIG_HEADER = ${top_builddir}/${config_name}\n"
1602         if $config_name;
1603     $contents{'CONFIG_HEADER'} = "${top_builddir}/${config_name}"
1604         if $config_name;
1605
1606     # Now look for other files in this directory which must be remade
1607     # by config.status, and generate rules for them.
1608     local ($file, $local, $input);
1609     foreach $file (@other_input_files)
1610     {
1611         # Skip files not in this directory, any Makefile, and the
1612         # config header.  These last two must be handled specially.
1613         next unless &dirname ($file) eq $relative_dir;
1614         next if $file eq $top_builddir . '/' . $config_name;
1615         ($local = $file) =~ s/^.*\///;
1616         next if $local eq 'Makefile';
1617
1618         if ($local =~ /^(.*):(.*)$/)
1619         {
1620             # This is the ":" syntax of AC_OUTPUT.
1621             $input = $2;
1622             $local = $1;
1623         }
1624         else
1625         {
1626             # Normal usage.
1627             $input = $local . '.in';
1628         }
1629         # FIXME when using autoconf ":" syntax, should we set CONFIG_FILES
1630         # to $local:$input?
1631         $output_rules .= ($local . ': '
1632                           . '$(top_builddir)/config.status ' . $input . "\n"
1633                           . "\t"
1634                           . 'cd $(top_builddir) && CONFIG_FILES='
1635                           . ($relative_dir eq '.' ? '' : '$(subdir)/')
1636                           . '$@ CONFIG_HEADERS= ./config.status'
1637                           . "\n");
1638
1639         &require_file_with_conf_line ($ac_output_line, $FOREIGN,
1640                                       $input);
1641     }
1642 }
1643
1644 # Handle C headers.
1645 sub handle_headers
1646 {
1647     $dir_holds_headers = &am_install_var ('header', 'HEADERS', 'include',
1648                                           'oldinclude', 'pkginclude',
1649                                           'noinst', 'check');
1650 }
1651
1652 sub handle_gettext
1653 {
1654     return if ! $seen_gettext || $relative_dir ne '.';
1655
1656     if (&variable_defined ('SUBDIRS'))
1657     {
1658         &am_line_error
1659             ('SUBDIRS',
1660              "ud_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
1661                 if $contents{'SUBDIRS'} !~ /\bpo\b/;
1662         &am_line_error
1663             ('SUBDIRS',
1664              "ud_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
1665                 if $contents{'SUBDIRS'} !~ /\bintl\b/;
1666     }
1667
1668     # Ensure that each language in ALL_LINGUAS has a .po file, and
1669     # each po file is mentioned in ALL_LINGUAS.
1670     if ($seen_linguas)
1671     {
1672         local (%linguas) = ();
1673         grep ($linguas{$_} = 1, split (' ', $all_linguas));
1674
1675         foreach (<po/*.po>)
1676         {
1677             s/^po\///;
1678             s/\.po$//;
1679
1680             &am_line_error ($all_linguas_line,
1681                             ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
1682                 if ! $linguas{$_};
1683         }
1684
1685         foreach (keys %linguas)
1686         {
1687             &am_line_error ($all_linguas_line,
1688                             "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
1689                 if ! -f "po/$_.po";
1690         }
1691     }
1692     else
1693     {
1694         &am_error ("ud_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
1695     }
1696 }
1697
1698 # Handle footer elements.
1699 sub handle_footer
1700 {
1701     if ($contents{'SOURCES'})
1702     {
1703         &pretty_print ('SOURCES =', "",
1704                        split (' ', $contents{'SOURCES'}));
1705     }
1706     if ($contents{'OBJECTS'})
1707     {
1708         &pretty_print ('OBJECTS =', "",
1709                        split (' ', $contents{'OBJECTS'}));
1710     }
1711     if ($contents{'SOURCES'} || $contents{'OBJECTS'})
1712     {
1713         $output_vars .= "\n";
1714     }
1715
1716     if (defined $contents{'SUFFIXES'})
1717     {
1718         # Push actual suffixes, and not $(SUFFIXES).  Some versions of
1719         # make do not like variable substitutions on the .SUFFIXES
1720         # line.
1721         push (@suffixes, split (' ', $contents{'SUFFIXES'}));
1722     }
1723
1724     $output_trailer .= ".SUFFIXES:\n";
1725     if (@suffixes)
1726     {
1727         $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
1728     }
1729     $output_trailer .= &file_contents ('footer');
1730 }
1731
1732 # Deal with installdirs target.
1733 sub handle_installdirs
1734 {
1735     # GNU Makefile standards recommend this.
1736     $output_rules .= ("installdirs:"
1737                       . ($recursive_install
1738                          ? " installdirs-recursive\n"
1739                          : "\n"));
1740     push (@phony, 'installdirs');
1741     if (@installdirs)
1742     {
1743         &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
1744                             @installdirs);
1745     }
1746     $output_rules .= "\n";
1747 }
1748
1749 # There are several targets which need to be merged.  This is because
1750 # their complete definition is compiled from many parts.  Note that we
1751 # avoid double colon rules, otherwise we'd use them instead.
1752 sub handle_merge_targets
1753 {
1754     push (@all, 'Makefile');
1755     push (@all, $config_name)
1756         if $config_name && &dirname ($config_name) eq $relative_dir;
1757
1758     &do_one_merge_target ('info', @info);
1759     &do_one_merge_target ('dvi', @dvi);
1760
1761     if (! &variable_defined ('SUBDIRS') || $relative_dir ne '.')
1762     {
1763         # 'check' must depend on 'all', but not at top level.
1764         # Ditto install.
1765         unshift (@check, 'all');
1766         unshift (@install, 'all');
1767     }
1768     &do_one_merge_target ('check', @check);
1769     &do_one_merge_target ('installcheck', @installcheck);
1770
1771     # Handle the various install targets specially.  We do this so
1772     # that (eg) "make install-exec" will run "install-exec-recursive"
1773     # if required, but "make install" won't run it twice.  Step one is
1774     # to see if the user specified local versions of any of the
1775     # targets we handle.  "all" is treated as one of these since
1776     # "install" can run it.
1777     push (@install_exec, 'install-exec-local')
1778         if defined $contents{'install-exec-local'};
1779     push (@install_data, 'install-data-local')
1780         if defined $contents{'install-data-local'};
1781     push (@uninstall, 'uninstall-local')
1782         if defined $contents{'uninstall-local'};
1783     push (@all, 'all-local')
1784         if defined $contents{'all-local'};
1785
1786     if (defined $contents{'install-local'})
1787     {
1788         &am_line_error ('install-local',
1789                         "use \`install-data' or \`install-exec', not \`install'");
1790     }
1791
1792     # Step two: if we are doing recursive makes, write out the
1793     # appropriate rules.
1794     local (@install);
1795     if ($recursive_install)
1796     {
1797         push (@install, 'install-recursive');
1798
1799         if (@all)
1800         {
1801             local (@hackall) = ();
1802             if ($config_name && &dirname ($config_name) eq $relative_dir)
1803             {
1804
1805                 # This is kind of a hack, but I couldn't see a better
1806                 # way to handle it.  In this particular case, we need
1807                 # to make sure config.h is built before we recurse.
1808                 # We can't do this by changing the order of
1809                 # dependencies to the "all" because that breaks when
1810                 # using parallel makes.  Instead we handle things
1811                 # explicitly.
1812                 $output_rules .= ('all-recursive-hack: $(CONFIG_HEADER)'
1813                                   . "\n\t" . '$(MAKE) all-recursive'
1814                                   . "\n\n");
1815                 push (@hackall, 'all-recursive-hack');
1816                 push (@phony, 'all-recursive-hack');
1817             }
1818             else
1819             {
1820                 push (@hackall, 'all-recursive');
1821             }
1822
1823             $output_rules .= ('all-am: '
1824                               . join (' ', @all)
1825                               . "\n\n");
1826             @all = @hackall;
1827             push (@all, 'all-am');
1828             push (@phony, 'all-am');
1829         }
1830         else
1831         {
1832             @all = ('all-recursive');
1833         }
1834         if (@install_exec)
1835         {
1836             $output_rules .= ('install-exec-am: '
1837                               . join (' ', @install_exec)
1838                               . "\n\n");
1839             @install_exec = ('install-exec-recursive', 'install-exec-am');
1840             push (@install, 'install-exec-am');
1841             push (@phony, 'install-exec-am');
1842         }
1843         else
1844         {
1845             @install_exec = ('install-exec-recursive');
1846         }
1847         if (@install_data)
1848         {
1849             $output_rules .= ('install-data-am: '
1850                               . join (' ', @install_data)
1851                               . "\n\n");
1852             @install_data = ('install-data-recursive', 'install-data-am');
1853             push (@install, 'install-data-am');
1854             push (@phony, 'install-data-am');
1855         }
1856         else
1857         {
1858             @install_data = ('install-data-recursive');
1859         }
1860         if (@uninstall)
1861         {
1862             $output_rules .= ('uninstall-am: '
1863                               . join (' ', @uninstall)
1864                               . "\n\n");
1865             @uninstall = ('uninstall-recursive', 'uninstall-am');
1866             push (@phony, 'uninstall-am');
1867         }
1868         else
1869         {
1870             @uninstall = ('uninstall-recursive');
1871         }
1872     }
1873
1874     # Step three: print definitions users can use.  Code below knows
1875     # that install-exec is done before install-data, beware.
1876     $output_rules .= ("install-exec: "
1877                       . join (' ', @install_exec)
1878                       . "\n");
1879     if (defined $contents{'install-exec-hook'})
1880     {
1881         $output_rules .= "\t" . '$(MAKE) install-exec-hook' . "\n";
1882     }
1883     $output_rules .= "\n";
1884     push (@install, 'install-exec') if !$recursive_install;
1885     push (@phony, 'install-exec');
1886
1887     $output_rules .= ("install-data: "
1888                       . join (' ', @install_data)
1889                       . "\n");
1890     if (defined $contents{'install-data-hook'})
1891     {
1892         $output_rules .= "\t" . '$(MAKE) install-data-hook' . "\n";
1893     }
1894     $output_rules .= "\n";
1895     push (@install, 'install-data') if !$recursive_install;
1896     push (@phony, 'install-data');
1897
1898     # If no dependencies for 'install', add 'all'.  Why?  That way
1899     # "make install" at top level of distclean'd distribution won't
1900     # fail because stuff in 'lib' fails to build.
1901     if (! @install || ($#install == 1
1902                        && $install[0] eq 'install-exec'
1903                        && $install[1] eq 'install-data'))
1904     {
1905         push (@install, 'all');
1906     }
1907     $output_rules .= ('install: '
1908                       . join (' ', @install)
1909                       # Use "@:" as empty command so nothing prints.
1910                       . "\n\t\@:"
1911                       . "\n\n"
1912                       . 'uninstall: '
1913                       . join (' ', @uninstall)
1914                       . "\n\n");
1915     push (@phony, 'install', 'uninstall');
1916
1917     $output_rules .= ('all: '
1918                       . join (' ', @all)
1919                       . "\n\n");
1920     push (@phony, 'all');
1921
1922     # Generate the new 'install-strip' target.
1923     $output_rules .= ("install-strip:\n\t"
1924                       . '$(MAKE) INSTALL_PROGRAM=\'$(INSTALL_PROGRAM) -s\' install'
1925                       . "\n");
1926 }
1927
1928 # Helper for handle_merge_targets.
1929 sub do_one_merge_target
1930 {
1931     local ($name, @values) = @_;
1932
1933     if (defined $contents{$name . '-local'})
1934     {
1935         # User defined local form of target.  So include it.
1936         push (@values, $name . '-local');
1937         push (@phony, $name . '-local');
1938     }
1939
1940     $output_rules .= $name . ":";
1941     if (@values)
1942     {
1943         $output_rules .= ' ' . join (' ', @values);
1944     }
1945     $output_rules .= "\n\n";
1946     push (@phony, $name);
1947 }
1948
1949 # Handle all 'clean' targets.
1950 sub handle_clean
1951 {
1952     push (@clean, 'generic');
1953     $output_rules .= &file_contents ('clean');
1954     &push_phony_cleaners ('generic');
1955
1956     local ($target) = $recursive_install ? 'clean-am' : 'clean';
1957     &do_one_clean_target ($target, 'mostly', '', @clean);
1958     &do_one_clean_target ($target, '', 'mostly', @clean);
1959     &do_one_clean_target ($target, 'dist', '', @clean);
1960     &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
1961
1962     push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
1963
1964     local (@deps);
1965     if ($recursive_install)
1966     {
1967         @deps = ('am', 'recursive');
1968         &do_one_clean_target ('', 'mostly', '', @deps);
1969         &do_one_clean_target ('', '', '', @deps);
1970         &do_one_clean_target ('', 'dist', '', @deps);
1971         &do_one_clean_target ('', 'maintainer-', '', @deps);
1972     }
1973 }
1974
1975 # Helper for handle_clean.
1976 sub do_one_clean_target
1977 {
1978     local ($target, $name, $last_name, @deps) = @_;
1979
1980     # Special case: if target not passed, then don't generate
1981     # dependency on next "lower" clean target (eg no
1982     # clean<-mostlyclean derivation).  In this case the target is
1983     # implicitly known to be 'clean'.
1984     local ($flag) = $target;
1985     $target = 'clean' if ! $flag;
1986
1987     grep (($_ = $name . 'clean-' . $_) && 0, @deps);
1988     if ($flag)
1989     {
1990         if ($last_name || $name ne 'mostly')
1991         {
1992             push (@deps, $last_name . $target . " ");
1993         }
1994     }
1995     # FIXME not sure if I like the tabs here.
1996     &pretty_print_rule ($name . $target . ": ", "\t\t", @deps);
1997
1998     # FIXME shouldn't we really print these messages before running
1999     # the dependencies?
2000     if ($name . $target eq 'maintainer-clean')
2001     {
2002         # Print a special warning.
2003         $output_rules .=
2004             ("\t\@echo \"This command is intended for maintainers to use;\"\n"
2005              . "\t\@echo \"it deletes files that may require special "
2006              . "tools to rebuild.\"\n");
2007
2008         $output_rules .= "\trm -f config.status\n"
2009             if $relative_dir eq '.';
2010     }
2011     elsif ($name . $target eq 'distclean')
2012     {
2013         $output_rules .= "\trm -f config.status\n";
2014     }
2015     $output_rules .= "\n";
2016 }
2017
2018 # Handle .PHONY target.
2019 sub handle_phony
2020 {
2021     &pretty_print_rule ('.PHONY:', "", @phony);
2022     $output_rules .= "\n";
2023 }
2024
2025 # Handle TESTS variable and other checks.
2026 sub handle_tests
2027 {
2028     if (defined $options{'dejagnu'})
2029     {
2030         push (@check, 'check-DEJAGNU');
2031         push (@phony, 'check-DEJAGNU');
2032         $output_rules .= &file_contents ('dejagnu') . "\n";
2033         # Note that in the rule we don't directly generate site.exp to
2034         # avoid the possibility of a corrupted site.exp if make is
2035         # interrupted.  Jim Meyering has some useful text on this
2036         # topic.
2037         $output_rules .= ("site.exp: Makefile\n"
2038                           . "\t\@echo 'Making a new site.exp file...'\n"
2039                           . "\t-\@rm -f site.bak\n"
2040                           . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
2041                           . "\t\@echo '# Do not edit here.  If you wish to override these values' >> \$\@-t\n"
2042                           . "\t\@echo '# edit the last section' >> \$\@-t\n"
2043                           . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
2044                           . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
2045                           . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
2046
2047         # Extra stuff for AC_CANONICAL_*
2048         local (@whatlist) = ();
2049         if ($seen_canonical)
2050         {
2051             push (@whatlist, 'host')
2052         }
2053
2054         # Extra stuff only for AC_CANONICAL_SYSTEM.
2055         if ($seen_canonical == $AC_CANONICAL_SYSTEM)
2056         {
2057             push (@whatlist, 'target', 'build');
2058         }
2059
2060         local ($c1, $c2);
2061         foreach $c1 (@whatlist)
2062         {
2063             foreach $c2 ('alias', 'triplet')
2064             {
2065                 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
2066             }
2067         }
2068
2069         $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
2070                           . "\t-\@sed '1,/^## All variables above are.*##/ d' site.bak >> \$\@-t\n"
2071                           . "\t-\@mv site.exp site.bak\n"
2072                           . "\t\@mv \$\@-t site.exp\n");
2073     }
2074     else
2075     {
2076         local ($c);
2077         foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
2078         {
2079             if (&variable_defined ($c))
2080             {
2081                 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
2082             }
2083         }
2084     }
2085
2086     if (&variable_defined ('TESTS'))
2087     {
2088         push (@check, 'check-TESTS');
2089         push (@phony, 'check-TESTS');
2090         # FIXME use $(SHELL) here?  That is what Ulrich suggests.
2091         # Maybe a new macro, $(TEST_SHELL), a la $(CONFIG_SHELL)?  For
2092         # now we just execute the file directly; this allows test
2093         # files which are compiled -- a possibly useful feature.
2094         $output_rules .= 'check-TESTS: $(TESTS)
2095         @failed=0; all=0; \\
2096         srcdir=$(srcdir); export srcdir; \\
2097         for tst in $(TESTS); do \\
2098           all=`expr $$all + 1`; \\
2099           if test -f $$tst; then dir=.; \\
2100           else dir="$(srcdir)"; fi; \\
2101           if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \\
2102             echo "PASS: $$tst"; \\
2103           else \\
2104             failed=`expr $$failed + 1`; \\
2105             echo "FAIL: $$tst"; \\
2106           fi; \\
2107         done; \\
2108         if test "$$failed" -eq 0; then \\
2109           echo "========================"; \\
2110           echo "All $$all tests passed"; \\
2111           echo "========================"; \\
2112         else \\
2113           echo "$$failed of $$all tests failed"; \\
2114         fi
2115 ';
2116     }
2117 }
2118
2119 # Handle Emacs Lisp.
2120 sub handle_emacs_lisp
2121 {
2122     local (@elfiles) = &am_install_var ('lisp', 'LISP', 'lisp', 'noinst');
2123
2124     if (@elfiles)
2125     {
2126         # Found some lisp.
2127         $output_vars .= "lispdir = \@lispdir\@\n";
2128         $output_rules .= (".el.elc:\n"
2129                           . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
2130                           . "\t\$(SHELL) \$(srcdir)/elisp-comp \$<\n");
2131         push (@suffixes, '.el', '.elc');
2132
2133         # Generate .elc files.
2134         grep ($_ .= 'c', @elfiles);
2135         &pretty_print ('ELCFILES =', '', @elfiles);
2136
2137         push (@clean, 'lisp');
2138         &push_phony_cleaners ('lisp');
2139
2140         local ($varname);
2141         if (&variable_defined ('lisp_LISP'))
2142         {
2143             $varname = 'lisp_LISP';
2144             &am_error ("\`lisp_LISP' defined but \`ud_PATH_LISPDIR' not in \`configure.in'")
2145                 if ! $seen_lispdir;
2146         }
2147         else
2148         {
2149             $varname = 'noinst_LISP';
2150         }
2151
2152         &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
2153     }
2154 }
2155
2156 ################################################################
2157
2158 # Scan configure.in for interesting things.
2159 # FIXME ensure VERSION, PACKAGE are set.
2160 sub scan_configure
2161 {
2162     open (CONFIGURE, 'configure.in')
2163         || die "automake: couldn't open \`configure.in': $!\n";
2164     print "automake: reading configure.in\n" if $verbose;
2165
2166     # Reinitialize libsources here.  This isn't really necessary,
2167     # since we currently assume there is only one configure.in.  But
2168     # that won't always be the case.
2169     %libsources = ();
2170
2171     local ($in_ac_output, @make_list) = 0;
2172     local ($libobj_iter);
2173     while (<CONFIGURE>)
2174     {
2175         # Remove comments from current line.
2176         s/\bdnl\b.*$//;
2177         s/\#.*$//;
2178
2179         # Populate libobjs array.
2180         if (/AC_FUNC_ALLOCA/)
2181         {
2182             $libsources{'alloca.c'} = 1;
2183         }
2184         elsif (/AC_FUNC_GETLOADAVG/)
2185         {
2186             $libsources{'getloadavg.c'} = 1;
2187         }
2188         elsif (/AC_FUNC_MEMCMP/)
2189         {
2190             $libsources{'memcmp.c'} = 1;
2191         }
2192         elsif (/AC_STRUCT_ST_BLOCKS/)
2193         {
2194             $libsources{'fileblocks.c'} = 1;
2195         }
2196         elsif (/(AC|fp)_FUNC_FNMATCH/)
2197         {
2198             # AC_FUNC_FNMATCH is just wishful thinking at this point.
2199             $libsources{'fnmatch.c'} = 1;
2200         }
2201         elsif (/AC_REPLACE_FUNCS\s*\((.*)\)/)
2202         {
2203             foreach (split (' ', $1))
2204             {
2205                 $libsources{$_ . '.c'} = 1;
2206             }
2207         }
2208         elsif (/AC_REPLACE_GNU_GETOPT/)
2209         {
2210             $libsources{'getopt.c'} = 1;
2211             $libsources{'getopt1.c'} = 1;
2212         }
2213         elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
2214                || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
2215         {
2216             foreach $libobj_iter (split (' ', $1))
2217             {
2218                 if ($libobj_iter =~ /^(.*)\.o$/)
2219                 {
2220                     $libsources{$1 . '.c'} = 1;
2221                 }
2222             }
2223         }
2224
2225         if (/(fp_PROG_INSTALL|fp_C_PROTOTYPES|jm_MAINTAINER_MODE)/)
2226         {
2227             &am_conf_line_error ($., "\`$1' is obsolete; use corresponding \`AM_' macro");
2228         }
2229
2230         # Process the AC_OUTPUT macro.
2231         if (! $in_ac_output && s/AC_OUTPUT\s*\(\[?//)
2232         {
2233             $in_ac_output = 1;
2234             $ac_output_line = $.;
2235         }
2236         if ($in_ac_output)
2237         {
2238             $in_ac_output = 0 if s/[\]\),].*$//;
2239
2240             # Look at potential Makefile.am's.
2241             foreach (split)
2242             {
2243                 next if $_ eq "\\";
2244                 if (-f $_ . '.am')
2245                 {
2246                     push (@make_list, $_);
2247                 }
2248                 else
2249                 {
2250                     push (@other_input_files, $_);
2251                 }
2252             }
2253         }
2254
2255         if (/AC_CONFIG_AUX_DIR\(([^)]+)\)/)
2256         {
2257             @config_aux_path = $1;
2258         }
2259
2260         # Check for ansi2knr.
2261         $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
2262
2263         # Check for NLS support.
2264         if (/ud_GNU_GETTEXT/)
2265         {
2266             $seen_gettext = 1;
2267             $ac_gettext_line = $.;
2268         }
2269
2270         # Look for ALL_LINGUAS.
2271         if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
2272         {
2273             $seen_linguas = 1;
2274             $all_linguas = $1;
2275             $all_linguas_line = $.;
2276         }
2277
2278         # Handle configuration headers.
2279         if (/AC_CONFIG_HEADER\s*\((.*)\)/)
2280         {
2281             $config_header_line = $.;
2282             $config_name = $1;
2283             if ($config_name =~ /^([^:]+):(.+)$/)
2284             {
2285                 $config_name = $1;
2286                 $config_header = $2;
2287             }
2288             else
2289             {
2290                 $config_header = $config_name . '.in';
2291             }
2292         }
2293
2294         # Handle AC_CANONICAL_*.  Always allow upgrading to
2295         # AC_CANONICAL_SYSTEM, but never downgrading.
2296         $seen_canonical = $AC_CANONICAL_HOST
2297             if ! $seen_canonical && /AC_CANONICAL_HOST/;
2298         $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
2299
2300         $seen_canonical = 1 if /AC_CHECK_TOOL/;
2301         $seen_path_xtra = 1 if /AC_PATH_XTRA/;
2302
2303         # Sometimes it is desirable to explicitly set YACC.  For
2304         # instance some people don't want to use bison.
2305         $seen_prog_yacc = 1 if (/AC_PROG_YACC/
2306                                 || /AC_SUBST\(YACC\)/
2307                                 || /AC_(PATH|CHECK)_PROGS?\(YACC/);
2308
2309         # This macro handles several different things.
2310         if (/AM_INIT_AUTOMAKE/)
2311         {
2312             $seen_make_set = 1;
2313             $seen_package = 1;
2314             $seen_version = 1;
2315             $seen_arg_prog = 1;
2316             $seen_prog_install = 2;
2317         }
2318
2319         # Some things required by Automake.
2320         $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
2321         $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
2322         $seen_ranlib = 1 if /AC_PROG_RANLIB/;
2323         $seen_maint_mode = 1 if /AM_MAINTAINER_MODE/;
2324         $seen_package = 1 if /PACKAGE=/;
2325         $seen_version = 1 if /VERSION=/;
2326
2327         # Weird conditionals here because it is always allowed to
2328         # upgrade to AM_PROG_INSTALL but never to downgrade to
2329         # AC_PROG_INSTALL.
2330         $seen_prog_install = 1 if ! $seen_prog_install && /AC_PROG_INSTALL/;
2331         $seen_prog_install = 2 if /AM_PROG_INSTALL/;
2332
2333         $seen_lispdir = 1 if /ud_PATH_LISPDIR/;
2334
2335         if (/AM_PROG_LIBTOOL/)
2336         {
2337             $seen_libtool = 1;
2338             $seen_ranlib = 2;
2339             $libtool_line = $.;
2340         }
2341     }
2342
2343     # Set input files if not specified by user.
2344     @input_files = @make_list if (! @input_files);
2345
2346     close (CONFIGURE);
2347
2348     &am_conf_error ("\`PACKAGE' not defined in configure.in")
2349         if ! $seen_package;
2350     &am_conf_error ("\`VERSION' not defined in configure.in")
2351         if ! $seen_version;
2352
2353     # Look for some files we need.  Always check for these.  This
2354     # check must be done for every run, even those where we are only
2355     # looking at a subdir Makefile.  We must set relative_dir so that
2356     # the file-finding machinery works.
2357     local ($relative_dir) = '.';
2358     &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs');
2359 }
2360
2361 ################################################################
2362
2363 # Do any extra checking for GNU standards.
2364 sub check_gnu_standards
2365 {
2366     if ($relative_dir eq '.')
2367     {
2368         # In top level (or only) directory.
2369         &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
2370                        'AUTHORS', 'ChangeLog');
2371     }
2372 }
2373
2374 # Do any extra checking for GNITS standards.
2375 sub check_gnits_standards
2376 {
2377     if ($strictness >= $GNITS && -f $relative_dir . '/COPYING.LIB')
2378     {
2379         &am_error
2380             ("\`${relative_dir}/COPYING.LIB' disallowed by Gnits standards");
2381     }
2382
2383     if ($relative_dir eq '.')
2384     {
2385         # In top level (or only) directory.
2386         &require_file ($GNITS, 'THANKS');
2387     }
2388 }
2389
2390 ################################################################
2391
2392 # Pretty-print something.  HEAD is what should be printed at the
2393 # beginning of the first line, FILL is what should be printed at the
2394 # beginning of every subsequent line.
2395 sub pretty_print_internal
2396 {
2397     local ($head, $fill, @values) = @_;
2398
2399     local ($column) = length ($head);
2400     local ($result) = $head;
2401
2402     # Fill length is number of characters.  However, each Tab
2403     # character counts for eight.  So we count the number of Tabs and
2404     # multiply by 7.
2405     local ($fill_length) = length ($fill);
2406     $fill_length += 7 * ($fill =~ tr/\t/\t/d);
2407
2408     local ($bol) = 0;
2409     foreach (@values)
2410     {
2411         # "71" because we also print a space.
2412         if ($column + length ($_) > 71)
2413         {
2414             $result .= " \\\n" . $fill;
2415             $column = $fill_length;
2416             $bol = 1;
2417         }
2418
2419         $result .= ' ' unless ($bol);
2420         $result .= $_;
2421         $column += length ($_) + 1;
2422         $bol = 0;
2423     }
2424
2425     $result .= "\n";
2426     return $result;
2427 }
2428
2429 # Pretty-print something and append to output_vars.
2430 sub pretty_print
2431 {
2432     $output_vars .= &pretty_print_internal (@_);
2433 }
2434
2435 # Pretty-print something and append to output_rules.
2436 sub pretty_print_rule
2437 {
2438     $output_rules .= &pretty_print_internal (@_);
2439 }
2440
2441
2442 ################################################################
2443
2444 # See if a variable exists.
2445 sub variable_defined
2446 {
2447     local ($var) = @_;
2448     if (defined $targets{$var})
2449     {
2450         &am_line_error ($var, "\`$var' is target; expected variable");
2451     }
2452     return (defined $contents{$var} && ! defined $targets{$var});
2453 }
2454
2455 # Read Makefile.am and set up %contents.  Simultaneously copy lines
2456 # from Makefile.am into $output_trailer or $output_vars as
2457 # appropriate.  NOTE we put rules in the trailer section.  We want
2458 # user rules to come after our generated stuff.
2459 sub read_am_file
2460 {
2461     local ($amfile) = @_;
2462
2463     # Compute relative location of the top object directory.
2464     local (@topdir) = ();
2465     foreach (split (/\//, $relative_dir))
2466     {
2467         next if $_ eq '.' || $_ eq '';
2468         if ($_ eq '..')
2469         {
2470             pop @topdir;
2471         }
2472         else
2473         {
2474             push (@topdir, '..');
2475         }
2476     }
2477     @topdir = ('.') if ! @topdir;
2478
2479     $top_builddir = join ('/', @topdir);
2480     local ($build_rx);
2481     ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
2482     local ($header_vars) =
2483         &file_contents_with_transform
2484             ('s/\@top_builddir\@/' . $build_rx . '/g',
2485              'header-vars');
2486
2487     # Generate some useful variables when AC_CANONICAL_* used.
2488     if ($seen_canonical)
2489     {
2490         $header_vars .= ('host_alias = @host_alias@' . "\n"
2491                          . 'host_triplet = @host@' . "\n");
2492         if ($seen_canonical == $AC_CANONICAL_SYSTEM)
2493         {
2494             $header_vars .= ('build_alias = @build_alias@' . "\n"
2495                              . 'build_triplet = @build@' . "\n");
2496             $header_vars .= ('target_alias = @target_alias@' . "\n"
2497                              . 'target_triplet = @target@' . "\n");
2498         }
2499     }
2500
2501     open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
2502     print "automake: reading $amfile\n" if $verbose;
2503
2504     $output_vars .= ("# $in_file_name generated automatically by automake "
2505                      . $VERSION . " from $am_file_name\n");
2506
2507     # Generate copyright for generated Makefile.in.
2508     $output_vars .= $gen_copyright;
2509
2510     local ($saw_bk) = 0;
2511     local ($was_rule) = 0;
2512     local ($spacing) = '';
2513     local ($comment) = '';
2514     local ($last_var_name) = '';
2515     local ($blank) = 0;
2516
2517     while (<AM_FILE>)
2518     {
2519         if (/$IGNORE_PATTERN/o)
2520         {
2521             # Merely delete comments beginning with two hashes.
2522         }
2523         elsif (/$WHITE_PATTERN/o)
2524         {
2525             # Stick a single white line before the incoming macro or rule.
2526             $spacing = "\n";
2527             $blank = 1;
2528         }
2529         elsif (/$COMMENT_PATTERN/o)
2530         {
2531             # Stick comments before the incoming macro or rule.  Make
2532             # sure a blank line preceeds comments.
2533             $spacing = "\n" unless $blank;
2534             $comment .= $spacing . $_;
2535             $spacing = '';
2536         }
2537         else
2538         {
2539             last;
2540         }
2541     }
2542
2543     $output_vars .= $comment . "\n" . $header_vars;
2544     $comment = '';
2545     $spacing = "\n";
2546
2547     local ($is_ok_macro);
2548     while ($_)
2549     {
2550         $_ .= "\n"
2551             unless substr ($_, -1, 1) eq "\n";
2552
2553         $_ =~ s/\@MAINT\@//g
2554             unless $seen_maint_mode;
2555
2556         if (/$IGNORE_PATTERN/o)
2557         {
2558             # Merely delete comments beginning with two hashes.
2559         }
2560         elsif (/$WHITE_PATTERN/o)
2561         {
2562             # Stick a single white line before the incoming macro or rule.
2563             $spacing = "\n";
2564         }
2565         elsif (/$COMMENT_PATTERN/o)
2566         {
2567             # Stick comments before the incoming macro or rule.
2568             $comment .= $spacing . $_;
2569             $spacing = '';
2570         }
2571         elsif ($saw_bk)
2572         {
2573             if ($was_rule)
2574             {
2575                 $output_trailer .= $_;
2576                 $saw_bk = /\\$/;
2577             }
2578             else
2579             {
2580                 $output_vars .= $_;
2581                 $saw_bk = /\\$/;
2582                 # Chop newline and backslash if this line is
2583                 # continued.  FIXME maybe ensure trailing whitespace
2584                 # exists?
2585                 chop if $saw_bk;
2586                 chop if $saw_bk;
2587                 $contents{$last_var_name} .= $_;
2588             }
2589         }
2590         elsif (/$RULE_PATTERN/o)
2591         {
2592             # warn "** Saw rule .$1.\n";
2593             # Found a rule.
2594             $was_rule = 1;
2595             # Value here doesn't matter; for targets we only note
2596             # existence.
2597             $contents{$1} = 1;
2598             $targets{$1} = 1;
2599             $content_lines{$1} = $.;
2600             $output_trailer .= $comment . $spacing . $_;
2601             $comment = $spacing = '';
2602             $saw_bk = /\\$/;
2603         }
2604         elsif (($is_ok_macro = /$MACRO_PATTERN/o)
2605                || /$BOGUS_MACRO_PATTERN/o)
2606         {
2607             # Found a macro definition.
2608             $was_rule = 0;
2609             $last_var_name = $1;
2610             if (substr ($2, -1) eq "\\")
2611             {
2612                 $contents{$1} = substr ($2, 0, length ($2) - 1);
2613             }
2614             else
2615             {
2616                 $contents{$1} = $2;
2617             }
2618             $content_lines{$1} = $.;
2619             $output_vars .= $comment . $spacing . $_;
2620             $comment = $spacing = '';
2621             $saw_bk = /\\$/;
2622
2623             # Error if bogus.
2624             &am_line_error ($., "bad macro name \`$1'")
2625                 if ! $is_ok_macro;
2626         }
2627         else
2628         {
2629             # This isn't an error; it is probably a continued rule.
2630             # In fact, this is what we assume.
2631             $was_rule = 1;
2632             $output_trailer .= $comment . $spacing . $_;
2633             $comment = $spacing = '';
2634             $saw_bk = /\\$/;
2635         }
2636
2637         $_ = <AM_FILE>;
2638     }
2639
2640     $output_trailer .= $comment;
2641 }
2642
2643 ################################################################
2644
2645 sub initialize_global_constants
2646 {
2647     # Values for AC_CANONICAL_*
2648     $AC_CANONICAL_HOST = 1;
2649     $AC_CANONICAL_SYSTEM = 2;
2650
2651     # Associative array of standard directory names.  Entry is TRUE if
2652     # corresponding directory should be installed during
2653     # 'install-exec' phase.
2654     %exec_dir_p =
2655         ('bin', 1,
2656          'sbin', 1,
2657          'libexec', 1,
2658          'data', 0,
2659          'sysconf', 1,
2660          'localstate', 1,
2661          'lib', 1,
2662          'info', 0,
2663          'man', 0,
2664          'include', 0,
2665          'oldinclude', 0,
2666          'pkgdata', 0,
2667          'pkglib', 1,
2668          'pkginclude', 0
2669          );
2670
2671     # Helper text for dealing with man pages.
2672     $install_man_format =
2673     '   sect=@SECTION@;                         \\
2674         inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
2675         if test -f $(srcdir)/@MAN@; then file=$(srcdir)/@MAN@; \\
2676         else file=@MAN@; fi; \\
2677         $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst
2678 ';
2679
2680     $uninstall_man_format =
2681     '   inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
2682         rm -f $(mandir)/man@SECTION@/$$inst
2683 ';
2684
2685     # Commonly found files we look for and automatically include in
2686     # DISTFILES.
2687     @common_files =
2688         (
2689          "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
2690          "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
2691          "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
2692          "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
2693          'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp'
2694          );
2695
2696     # Commonly used files we auto-include, but only sometimes.
2697     @common_sometimes =
2698         (
2699          "aclocal.m4", "acconfig.h", "config.h.top",
2700          "config.h.bot", "stamp-h.in", 'stamp-vti', 'libtool'
2701          );
2702
2703     $USAGE = "\
2704   --amdir=DIR           directory storing config files
2705   --foreign             same as --strictness=foreign
2706   --gnits               same as --strictness=gnits
2707   --gnu                 same as --strictness=gnu
2708   --help                print this help, then exit
2709   -i, --include-deps    include generated dependencies in Makefile.in
2710   -a, --add-missing     add missing standard files to package
2711   --no-force            only update Makefile.in's that are out of date
2712   -o DIR, --output-dir=DIR
2713                         put generated Makefile.in's into DIR
2714   -s LEVEL, --strictness=LEVEL
2715                         set strictness level.  LEVEL is foreign, gnu, gnits
2716   -v, --verbose         verbosely list files processed
2717   --version             print version number, then exit\n";
2718
2719     # Copyright on generated Makefile.ins.
2720     $gen_copyright = "\
2721 # Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
2722 # This Makefile.in is free software; the Free Software Foundation
2723 # gives unlimited permission to copy, distribute and modify it.
2724 ";
2725 }
2726
2727 # (Re)-Initialize per-Makefile.am variables.
2728 sub initialize_per_input
2729 {
2730     # These two variables are used when generating each Makefile.in.
2731     # They hold the Makefile.in until it is ready to be printed.
2732     $output_rules = '';
2733     $output_vars = '';
2734     $output_trailer = '';
2735
2736     # Suffixes found during a run.
2737     @suffixes = ();
2738
2739     # This holds the contents of a Makefile.am, as parsed by
2740     # read_am_file.
2741     %contents = ();
2742
2743     # This holds the names which are targets.  These also appear in
2744     # %contents.
2745     %targets = ();
2746
2747     # This holds the line numbers at which various elements of
2748     # %contents are defined.
2749     %content_lines = ();
2750
2751     # This holds the "relative directory" of the current Makefile.in.
2752     # Eg for src/Makefile.in, this is "src".
2753     $relative_dir = '';
2754
2755     # This holds a list of files that are included in the
2756     # distribution.
2757     %dist_common = ();
2758
2759     # List of dependencies for the obvious targets.
2760     @install_data = ();
2761     @install_exec = ();
2762     @uninstall = ();
2763     @installdirs = ();
2764
2765     @info = ();
2766     @dvi = ();
2767     @all = ();
2768     @check = ();
2769     @installcheck = ();
2770     @clean = ();
2771
2772     @phony = ();
2773
2774     # These are pretty obvious, too.  They are used to define the
2775     # SOURCES and OBJECTS variables.
2776     @sources = ();
2777     @objects = ();
2778
2779     # TRUE if current directory holds any C source files.  (Actually
2780     # holds object extension, but this information is encapsulated in
2781     # the function get_object_extension).
2782     $dir_holds_sources = '';
2783
2784     # TRUE if current directory holds any headers.
2785     $dir_holds_headers = 0;
2786
2787     # TRUE if install targets should work recursively.
2788     $recursive_install = 0;
2789
2790     # All .P files.
2791     %dep_files = ();
2792
2793     # Strictness levels.
2794     $strictness = $default_strictness;
2795     $strictness_name = $default_strictness_name;
2796
2797     # Options from AUTOMAKE_OPTIONS.
2798     %options = ();
2799
2800     # Whether or not dependencies are handled.  Can be further changed
2801     # in handle_options.
2802     $use_dependencies = $cmdline_use_dependencies;
2803
2804     # Per Makefile.am.
2805     $local_maint_charset = $maint_charset;
2806 }
2807
2808
2809 ################################################################
2810
2811 # Return contents of a file from $am_dir, automatically skipping
2812 # macros or rules which are already known.  Runs command on each line
2813 # as it is read; this command can modify $_.
2814 sub file_contents_with_transform
2815 {
2816     local ($command, $basename) = @_;
2817     local ($file) = $am_dir . '/' . $basename . '.am';
2818
2819     open (FC_FILE, $file)
2820         || die "automake: installation error: cannot open \`$file'\n";
2821     # Looks stupid?
2822     # print "automake: reading $file\n" if $verbose;
2823
2824     local ($was_rule) = 0;
2825     local ($result_vars) = '';
2826     local ($result_rules) = '';
2827     local ($comment) = '';
2828     local ($spacing) = "\n";
2829     local ($skipping) = 0;
2830
2831     while (<FC_FILE>)
2832     {
2833         $_ =~ s/\@MAINT\@//g
2834             unless $seen_maint_mode;
2835
2836         eval $command;
2837
2838         if (/$IGNORE_PATTERN/o)
2839         {
2840             # Merely delete comments beginning with two hashes.
2841         }
2842         elsif (/$WHITE_PATTERN/o)
2843         {
2844             # Stick a single white line before the incoming macro or rule.
2845             $spacing = "\n";
2846         }
2847         elsif (/$COMMENT_PATTERN/o)
2848         {
2849             # Stick comments before the incoming macro or rule.
2850             $comment .= $spacing . $_;
2851             $spacing = '';
2852         }
2853         elsif ($saw_bk)
2854         {
2855             if ($was_rule)
2856             {
2857                 $result_rules .= $_ if ! $skipping;
2858             }
2859             else
2860             {
2861                 $result_vars .= $_ if ! $skipping;
2862             }
2863             $saw_bk = /\\$/;
2864         }
2865         elsif (/$RULE_PATTERN/o)
2866         {
2867             # warn "** Found rule .$1.\n";
2868             # Found a rule.
2869             $was_rule = 1;
2870             $skipping = defined $contents{$1};
2871             # warn "** Skip $skipping\n" if $skipping;
2872             $result_rules .= $comment . $spacing . $_ if ! $skipping;
2873             $comment = $spacing = '';
2874             $saw_bk = /\\$/;
2875         }
2876         elsif (/$MACRO_PATTERN/o)
2877         {
2878             # warn "** Found macro .$1.\n";
2879             # Found a variable reference.
2880             $was_rule = 0;
2881             $skipping = defined $contents{$1};
2882             # warn "** Skip $skipping\n" if $skipping;
2883             $result_vars .= $comment . $spacing . $_ if ! $skipping;
2884             $comment = $spacing = '';
2885             $saw_bk = /\\$/;
2886         }
2887         else
2888         {
2889             # This isn't an error; it is probably a continued rule.
2890             # In fact, this is what we assume.
2891             $was_rule = 1;
2892             $result_rules .= $comment . $spacing . $_ if ! $skipping;
2893             $comment = $spacing = '';
2894             $saw_bk = /\\$/;
2895         }
2896     }
2897
2898     close (FC_FILE);
2899     return $result_vars . $result_rules . $comment;
2900 }
2901
2902 # Like file_contents_with_transform, but no transform.
2903 sub file_contents
2904 {
2905     return &file_contents_with_transform ('', @_);
2906 }
2907
2908 # Find all variable prefixes that are used for install directories.  A
2909 # prefix `zar' qualifies iff:
2910 # * `zardir' is a variable.
2911 # * `zar_PRIMARY' is a variable.
2912 sub am_primary_prefixes
2913 {
2914     local ($primary, @prefixes) = @_;
2915
2916     local (%valid, $varname);
2917     grep ($valid{$_} = 0, @prefixes);
2918     $valid{'EXTRA'} = 0;
2919     foreach $varname (keys %contents)
2920     {
2921         if ($varname =~ /^(.*)_$primary$/)
2922         {
2923             if (! defined $valid{$1} && ! &variable_defined ($1 . 'dir'))
2924             {
2925                 &am_line_error ($varname, "invalid variable \"$varname\"");
2926             }
2927             else
2928             {
2929                 # Ensure all extended prefixes are actually used.
2930                 $valid{$1} = 1;
2931             }
2932         }
2933     }
2934
2935     return %valid;
2936 }
2937
2938 # Handle `where_HOW' variable magic.  Does all lookups, generates
2939 # install code, and possibly generates code to define the primary
2940 # variable.  The first argument is the name of the .am file to munge,
2941 # the second argument is the primary variable (eg HEADERS), and all
2942 # subsequent arguments are possible installation locations.  Returns
2943 # list of all values of all _HOW targets.
2944 #
2945 # FIXME this should be rewritten to be cleaner.  It should be broken
2946 # up into multiple functions.
2947 #
2948 # Usage is: am_install_var (OPTION..., file, HOW, where...)
2949 sub am_install_var
2950 {
2951     local (@args) = @_;
2952
2953     local ($do_all, $do_clean) = (1, 0);
2954     while (@args)
2955     {
2956         if ($args[0] eq '-clean')
2957         {
2958             $do_clean = 1;
2959         }
2960         elsif ($args[0] eq '-no-all')
2961         {
2962             $do_all = 0;
2963         }
2964         elsif ($args[0] !~ /^-/)
2965         {
2966             last;
2967         }
2968         shift (@args);
2969     }
2970     local ($file, $primary, @prefixes) = @args;
2971
2972     local (@used) = ();
2973     local (@result) = ();
2974
2975     # Now that configure substitutions are allowed in where_HOW
2976     # variables, it is an error to actually define the primary.
2977     &am_line_error ($primary, "\`$primary' is an anachronism")
2978         if &variable_defined ($primary);
2979
2980
2981     # Look for misspellings.  It is an error to have a variable ending
2982     # in a "reserved" suffix whose prefix is unknown, eg
2983     # "bni_PROGRAMS".  However, unusual prefixes are allowed if a
2984     # variable of the same name (with "dir" appended) exists.  For
2985     # instance, if the variable "zardir" is defined, then
2986     # "zar_PROGRAMS" becomes valid.  This is to provide a little extra
2987     # flexibility in those cases which need it.  Perhaps it should be
2988     # disallowed in the Gnits case?  The problem is, sometimes it is
2989     # useful to put things in a subdir of eg pkgdatadir, perhaps even
2990     # for Gnitsoids.
2991     local (%valid) = &am_primary_prefixes ($primary, @prefixes);
2992
2993     local ($clean_file) = $file . '-clean';
2994     local ($one_name);
2995     local ($X);
2996     foreach $X (keys %valid)
2997     {
2998         $one_name = $X . '_' . $primary;
2999         if (&variable_defined ($one_name))
3000         {
3001             # Append actual contents of where_PRIMARY variable to
3002             # result.
3003             local ($rcurs);
3004             foreach $rcurs (split (' ', $contents{$one_name}))
3005             {
3006                 # Skip configure substitutions.  Possibly bogus.
3007                 next if $rcurs =~ /^\@.*\@$/;
3008                 push (@result, $rcurs);
3009             }
3010
3011             # "EXTRA" shouldn't be used when generating clean targets,
3012             # @all, or install targets.
3013             next if $X eq 'EXTRA';
3014
3015             if ($do_clean)
3016             {
3017                 $output_rules .=
3018                     &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
3019                                                    $clean_file);
3020
3021                 push (@clean, $X . $primary);
3022                 &push_phony_cleaners ($X . $primary);
3023             }
3024
3025             if ($X eq 'check')
3026             {
3027                 push (@check, '$(' . $one_name . ')');
3028             }
3029             else
3030             {
3031                 push (@used, '$(' . $one_name . ')');
3032             }
3033             if ($X eq 'noinst' || $X eq 'check')
3034             {
3035                 # Objects which don't get installed by default.
3036                 next;
3037             }
3038
3039             $output_rules .=
3040                 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
3041                                                $file);
3042
3043             push (@uninstall, 'uninstall-' . $X . $primary);
3044             push (@phony, 'uninstall-' . $X . $primary);
3045             push (@installdirs, '$(' . $X . 'dir)');
3046             if ($exec_dir_p{$X})
3047             {
3048                 push (@install_exec, 'install-' . $X . $primary);
3049                 push (@phony, 'install-' . $X . $primary);
3050             }
3051             else
3052             {
3053                 push (@install_data, 'install-' . $X . $primary);
3054                 push (@phony, 'install-' . $X . $primary);
3055             }
3056         }
3057     }
3058
3059     if (@used)
3060     {
3061         # Define it.
3062         &pretty_print ($primary . ' =', '', @used);
3063         $output_vars .= "\n";
3064     }
3065
3066     # Push here because PRIMARY might be configure time determined.
3067     push (@all, '$(' . $primary . ')')
3068         if $do_all && @used;
3069
3070     return (@result);
3071 }
3072
3073
3074 ################################################################
3075
3076 # This variable is local to the "require file" set of functions.
3077 @require_file_paths = ();
3078
3079 # Verify that the file must exist in the current directory.  Usage:
3080 # require_file (isconfigure, line_number, strictness, file) strictness
3081 # is the strictness level at which this file becomes required.  Must
3082 # set require_file_paths before calling this function.
3083 # require_file_paths is set to hold a single directory (the one in
3084 # which the first file was found) before return.
3085 sub require_file_internal
3086 {
3087     local ($is_configure, $line, $mystrict, @files) = @_;
3088     local ($file, $fullfile);
3089     local ($found_it, $errfile, $errdir);
3090     local ($save_dir);
3091
3092     foreach $file (@files)
3093     {
3094         $found_it = 0;
3095         foreach $dir (@require_file_paths)
3096         {
3097             if ($dir eq '.')
3098             {
3099                 $fullfile = $relative_dir . "/" . $file;
3100                 $errdir = $relative_dir unless $errdir;
3101             }
3102             else
3103             {
3104                 $fullfile = $dir . "/" . $file;
3105                 $errdir = $dir unless $errdir;
3106             }
3107
3108             # Use different name for "error filename".  Otherwise on
3109             # an error the bad file will be reported as eg
3110             # `../../install-sh' when using the default
3111             # config_aux_path.
3112             $errfile = $errdir . '/' . $file;
3113
3114             if (-f $fullfile)
3115             {
3116                 $found_it = 1;
3117                 &push_dist_common ($file) if $dir eq $relative_dir;
3118                 $save_dir = $dir;
3119                 last;
3120             }
3121         }
3122
3123         if ($found_it)
3124         {
3125             # Prune the path list.
3126             @require_file_paths = $save_dir;
3127         }
3128         else
3129         {
3130             if ($strictness >= $mystrict)
3131             {
3132                 # Only install missing files according to our desired
3133                 # strictness level.
3134                 if ($add_missing && -f ($am_dir . '/' . $file))
3135                 {
3136                     # Install the missing file.  Symlink if we can, copy
3137                     # if we must.
3138                     if ($symlink_exists)
3139                     {
3140                         symlink ($am_dir . '/' . $file, $errfile);
3141                     }
3142                     else
3143                     {
3144                         system ('cp', $am_dir . '/' . $file, $errfile);
3145                     }
3146
3147                     # FIXME this is a hack.  Should have am_warn.
3148                     local ($save) = $exit_status;
3149                     if ($is_configure)
3150                     {
3151                         &am_conf_line_error
3152                             ($line,
3153                              "required file \"$errfile\" not found; installing");
3154                     }
3155                     else
3156                     {
3157                         &am_line_error
3158                             ($line,
3159                              "required file \"$errfile\" not found; installing");
3160                     }
3161                     $exit_status = $save;
3162                 }
3163                 else
3164                 {
3165                     # Only an error if strictness constraint violated.
3166                     if ($is_configure)
3167                     {
3168                         &am_conf_line_error
3169                             ($line, "required file \"$errfile\" not found");
3170                     }
3171                     else
3172                     {
3173                         &am_line_error
3174                             ($line, "required file \"$errfile\" not found");
3175                     }
3176                 }
3177             }
3178         }
3179     }
3180 }
3181
3182 # Like require_file_with_line, but error messages refer to
3183 # configure.in, not the current Makefile.am.
3184 sub require_file_with_conf_line
3185 {
3186     @require_file_paths = '.';
3187     &require_file_internal (1, @_);
3188 }
3189
3190 sub require_file_with_line
3191 {
3192     @require_file_paths = '.';
3193     &require_file_internal (0, @_);
3194 }
3195
3196 sub require_file
3197 {
3198     @require_file_paths = '.';
3199     &require_file_internal (0, '', @_);
3200 }
3201
3202 # Require a file that is also required by Autoconf.  Looks in
3203 # configuration path, as specified by AC_CONFIG_AUX_DIR.
3204 sub require_config_file
3205 {
3206     @require_file_paths = @config_aux_path;
3207     &require_file_internal (0, '', @_);
3208     local ($dir) = $require_file_paths[0];
3209     @config_aux_path = @require_file_paths;
3210     if ($dir eq '.')
3211     {
3212         $config_aux_dir = '.';
3213     }
3214     else
3215     {
3216         $config_aux_dir = '$(top_srcdir)/' . $dir;
3217     }
3218 }
3219
3220 # Assumes that the line number is in Makefile.am.
3221 sub require_conf_file_with_line
3222 {
3223     @require_file_paths = @config_aux_path;
3224     &require_file_internal (0, @_);
3225     local ($dir) = $require_file_paths[0];
3226     @config_aux_path = @require_file_paths;
3227     if ($dir eq '.')
3228     {
3229         $config_aux_dir = '.';
3230     }
3231     else
3232     {
3233         $config_aux_dir = '$(top_srcdir)/' . $dir;
3234     }
3235 }
3236
3237 # Assumes that the line number is in Makefile.am.
3238 sub require_conf_file_with_conf_line
3239 {
3240     @require_file_paths = @config_aux_path;
3241     &require_file_internal (1, @_);
3242     local ($dir) = $require_file_paths[0];
3243     @config_aux_path = @require_file_paths;
3244     if ($dir eq '.')
3245     {
3246         $config_aux_dir = '.';
3247     }
3248     else
3249     {
3250         $config_aux_dir = '$(top_srcdir)/' . $dir;
3251     }
3252 }
3253
3254 ################################################################
3255
3256 # Push a list of files onto dist_common.
3257 sub push_dist_common
3258 {
3259     local (@files) = @_;
3260     local ($file);
3261
3262     foreach $file (@files)
3263     {
3264         $dist_common{$file} = 1;
3265     }
3266 }
3267
3268 # Push a list of clean targets onto phony.
3269 sub push_phony_cleaners
3270 {
3271     local ($base) = @_;
3272     local ($target);
3273     foreach $target ('mostly', 'dist', '', 'maintainer-')
3274     {
3275         push (@phony, $target . 'clean-' . $base);
3276     }
3277 }
3278
3279 # Set strictness.
3280 sub set_strictness
3281 {
3282     $strictness_name = $_[0];
3283     if ($strictness_name eq 'gnu')
3284     {
3285         $strictness = $GNU;
3286     }
3287     elsif ($strictness_name eq 'gnits')
3288     {
3289         $strictness = $GNITS;
3290     }
3291     elsif ($strictness_name eq 'foreign')
3292     {
3293         $strictness = $FOREIGN;
3294     }
3295     else
3296     {
3297         die "automake: level \`$strictness_name' not recognized\n";
3298     }
3299 }
3300
3301
3302 ################################################################
3303
3304 # Return directory name of file.
3305 sub dirname
3306 {
3307     local ($file) = @_;
3308     local ($sub);
3309
3310     ($sub = $file) =~ s,/+[^/]+$,,g;
3311     $sub = '.' if $sub eq $file;
3312     return $sub;
3313 }
3314
3315 # Make a directory.
3316 sub mkdir
3317 {
3318     local ($dirname) = @_;
3319     system ("mkdir", $dirname);
3320 }
3321
3322 ################################################################
3323
3324 # Print an error message and set exit status.
3325 sub am_error
3326 {
3327     warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
3328     $exit_status = 1;
3329 }
3330
3331 sub am_line_error
3332 {
3333     local ($symbol, @args) = @_;
3334
3335     if ($symbol)
3336     {
3337         # If SYMBOL not already a line number, look it up in Makefile.am.
3338         $symbol = $content_lines{$symbol} unless $symbol =~ /^\d+$/;
3339         $symbol .= ': ' if $symbol;
3340         warn "${am_file}.am:", $symbol, join (' ', @args), "\n";
3341         $exit_status = 1;
3342     }
3343     else
3344     {
3345         &am_error (@args);
3346     }
3347 }
3348
3349 # Like am_error, but while scanning configure.in.
3350 sub am_conf_error
3351 {
3352     # FIXME can run in subdirs.
3353     warn "automake: configure.in: ", join (' ', @_), "\n";
3354     $exit_status = 1;
3355 }
3356
3357 # Error message with line number referring to configure.in.
3358 sub am_conf_line_error
3359 {
3360     local ($line, @args) = @_;
3361
3362     if ($line)
3363     {
3364         warn "configure.in: $line: ", join (' ', @args), "\n";
3365         $exit_status = 1;
3366     }
3367     else
3368     {
3369         &am_conf_error (@args);
3370     }
3371 }
3372
3373 # Tell user where our aclocal.m4 is, but only once.
3374 sub keyed_aclocal_warning
3375 {
3376     local ($key) = @_;
3377     warn "automake: macro \`$key' can be generated by \`aclocal'\n";
3378 }
3379
3380 # Print usage information.
3381 sub usage
3382 {
3383     print "Usage: automake [OPTION] ... [Makefile]...\n";
3384     print $USAGE;
3385     print "\nFiles which are automatically distributed, if found:\n";
3386     $~ = "USAGE_FORMAT";
3387     local (@lcomm) = sort ((@common_files, @common_sometimes));
3388     local ($one, $two, $three, $four);
3389     while (@lcomm > 0)
3390     {
3391         $one = shift @lcomm;
3392         $two = @lcomm ? shift @lcomm : '';
3393         $three = @lcomm ? shift @lcomm : '';
3394         $four = @lcomm ? shift @lcomm : '';
3395         write;
3396     }
3397
3398     exit 0;
3399 }
3400
3401 format USAGE_FORMAT =
3402   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<   @<<<<<<<<<<<<<<<<
3403   $one,               $two,               $three,             $four
3404 .