automake.in

   1 #!@PERL@
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
   6     if $running_under_some_shell;
   7
   8 # automake - create Makefile.in from Makefile.am
   9 # Copyright (C) 1994 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.
  31 $VERSION = "@VERSION@";
  32 $prefix = "@prefix@";
  33 $am_dir = "@datadir@/@PACKAGE@";
  34
  35 \f
  36
  37 # Constants to define the "strictness" level.
  38 $NORMAL = 0;
  39 $GNU = 1;
  40 $GNITS = 2;
  41
  42 \f
  43
  44 # Variables global to entire run.
  45
  46 # Strictness level.
  47 $strictness = $NORMAL;
  48
  49 # This is TRUE if GNU make specific automatic dependency generation
  50 # code should be included in generated Makefile.in.
  51 $use_dependencies = 1;
  52
  53 # This holds our (eventual) exit status.  We don't actually exit until
  54 # we have processed all input files.
  55 $exit_status = 0;
  56
  57 # From the Perl manual.
  58 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
  59
  60 # TRUE if missing standard files should be installed.
  61 $install_missing = 0;
  62
  63 \f
  64
  65 &initialize_global_constants;
  66
  67 # Parse command line.
  68 @input_files = &parse_arguments (@ARGV);
  69
  70 # Now do all the work on each file.
  71 foreach $am_file (@input_files)
  72 {
  73     if (! -f ($am_file . '.am'))
  74     {
  75         &am_error ('no such file');
  76     }
  77     else
  78     {
  79         &generate_makefile ($am_file);
  80     }
  81 }
  82
  83 exit $exit_status;
  84
  85
  86 ################################################################
  87
  88 # Parse command line.
  89 sub parse_arguments
  90 {
  91     local (@arglist) = @_;
  92     local (@make_list);
  93
  94     while ($#arglist >= 0)
  95     {
  96         if ($arglist[0] eq "--version")
  97         {
  98             print "Automake version $VERSION\n";
  99             exit 0;
 100         }
 101         elsif ($arglist[0] eq "--help")
 102         {
 103             &usage;
 104         }
 105         elsif ($arglist[0] =~ /^--amdir=(.+)$/)
 106         {
 107             $am_dir = $1;
 108         }
 109         elsif ($arglist[0] eq '--amdir')
 110         {
 111             &require_argument (@arglist);
 112             shift (@arglist);
 113             $am_dir = $arglist[0];
 114         }
 115         elsif ($arglist[0] =~ /^--strictness=(.+)$/)
 116         {
 117             &set_strictness ($1);
 118         }
 119         elsif ($arglist[0] eq '--strictness')
 120         {
 121             &require_argument (@arglist);
 122             shift (@arglist);
 123             &set_strictness ($arglist[0]);
 124         }
 125         elsif ($arglist[0] eq '--include-deps')
 126         {
 127             $use_dependencies = 0;
 128         }
 129         elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
 130         {
 131             # Set output directory.
 132             $output_directory = $1;
 133         }
 134         elsif ($arglist[0] eq '--output-dir')
 135         {
 136             &require_argument (@arglist);
 137             shift (@arglist);
 138             $output_directory = $arglist[0];
 139         }
 140         elsif ($arglist[0] eq '--install-missing')
 141         {
 142             $install_missing = 1;
 143         }
 144         elsif ($arglist[0] eq '--')
 145         {
 146             # Stop option processing.
 147             shift (@arglist);
 148             push (@make_list, @arglist);
 149             last;
 150         }
 151         elsif ($arglist[0] =~ /^-/)
 152         {
 153             print STDERR "automake: unrecognized option -- \`$arglist[0]'\n";
 154             exit 1;
 155         }
 156         else
 157         {
 158             push (@make_list, $arglist[0]);
 159         }
 160
 161         shift (@arglist);
 162     }
 163
 164     if ($#make_list < 0)
 165     {
 166         # Look around for some files.
 167         push (@make_list, 'Makefile') if -f 'Makefile.am';
 168
 169         foreach (<*/Makefile.am>)
 170         {
 171             s/\.am$//;
 172             push (@make_list, $_);
 173         }
 174
 175         if ($#make_list >= 0)
 176         {
 177             print "automake: using ", join (' ', @make_list), "\n";
 178         }
 179         else
 180         {
 181             print STDERR "automake: no \"Makefile.am\" found or specified\n";
 182             exit 1;
 183         }
 184     }
 185
 186     return (@make_list);
 187 }
 188
 189 # Ensure argument exists, or die.
 190 sub require_argument
 191 {
 192     local ($arg, @arglist) = @_;
 193     if ($#arglist >= 0)
 194     {
 195         print STDERR "automake: no argument given for option \`$arg'\n";
 196         exit 1;
 197     }
 198 }
 199
 200 ################################################################
 201
 202 # Generate a Makefile.in given the name of the corresponding Makefile.
 203 sub generate_makefile
 204 {
 205     local ($makefile) = @_;
 206
 207     print "creating ", $makefile, ".in\n";
 208
 209     &initialize_per_input;
 210     $relative_dir = &dirname ($makefile);
 211     # FIXME with new 'dist' target, don't need Makefile.in.  Probably
 212     # should remove it here.
 213     &push_dist_common ('Makefile.in', 'Makefile.am');
 214     push (@sources, '$(SOURCES)') if (defined $contents{'SOURCES'});
 215     push (@objects, '$(OBJECTS)') if (defined $contents{'OBJECTS'});
 216
 217     # Generate header before reading .am file.  The header must come
 218     # before anything else, and read_am_file copies code into the
 219     # output.
 220     &generate_header;
 221
 222     # This is always the default target.  This gives us freedom to do
 223     # things in whatever order is convenient.
 224     $output_rules .= "default: all\n\n";
 225
 226     &read_am_file ($makefile . '.am');
 227
 228     # Check first, because we might modify some state.
 229     &check_gnu_standards;
 230     &check_gnits_standards;
 231
 232     &handle_libraries;
 233     &handle_programs;
 234     &handle_scripts;
 235
 236     # Re-init SOURCES and OBJECTS.  FIXME other code shouldn't depend
 237     # on this (but currently does).
 238     $contents{'SOURCES'} = join (' ', @sources);
 239     $contents{'OBJECTS'} = join (' ', @objects);
 240
 241     &handle_texinfo;
 242     &handle_man_pages;
 243     &handle_data;
 244     &handle_headers;
 245     &handle_subdirs;
 246     &handle_configure;
 247     &handle_tags;
 248     &handle_dist;
 249     &handle_dependencies;
 250     &handle_footer;
 251     &handle_merge_targets;
 252     &handle_installdirs;
 253     &handle_clean;
 254
 255     if (! -d ($output_directory . '/' . $relative_dir))
 256     {
 257         &mkdir ($output_directory . '/' . $relative_dir);
 258     }
 259     if (! open (GM_FILE, "> " . $output_directory . '/' . $makefile . ".in"))
 260     {
 261         &am_error ("cannot open:", $!);
 262         return;
 263     }
 264
 265     print GM_FILE $output_vars;
 266     print GM_FILE $output_rules;
 267     print GM_FILE $output_trailer;
 268
 269     close (GM_FILE);
 270 }
 271
 272 ################################################################
 273
 274 # Generate header of Makefile.in.
 275 sub generate_header
 276 {
 277     $output_vars =
 278         ($output_vars
 279          . "# Makefile.in generated automatically by automake "
 280          . $VERSION
 281          . " from Makefile.am\n");
 282
 283     $output_vars = $output_vars . &file_contents ('header-vars');
 284 }
 285
 286 # Return object extension.  Just once, put some code into the output.
 287 sub get_object_extension
 288 {
 289     if (! $dir_holds_sources)
 290     {
 291
 292         # Boilerplate.
 293         $output_vars .= &file_contents ('compile-vars');
 294         $output_rules .= &file_contents ('compile');
 295
 296         # Check for automatic de-ANSI-fication.
 297         $dir_holds_sources = '.o';
 298         push (@suffixes, '.c', '.o');
 299         push (@clean, 'compile');
 300
 301         if (defined $contents{'@kr@'})
 302         {
 303             $dir_holds_sources = '.$(kr)o';
 304             push (@suffixes, '._c', '._o');
 305
 306             &require_file ($NORMAL, 'ansi2knr.c');
 307             &require_file ($NORMAL, 'ansi2knr.1');
 308
 309             $output_vars .= &file_contents ('kr-vars');
 310             $output_rules .= &file_contents ('compile-kr');
 311             $output_rules .= &file_contents ('clean-kr');
 312
 313             push (@clean, 'kr');
 314         }
 315     }
 316     return $dir_holds_sources;
 317 }
 318
 319 # Handle SOURCE->OBJECT transform for one program or library.
 320 sub handle_source_transform
 321 {
 322     local ($one_file, $obj) = @_;
 323
 324     # Look for file_SOURCES and file_OBJECTS.
 325     if (defined $contents{$one_file . "_SOURCES"})
 326     {
 327         if (! defined $contents{$one_file . "_OBJECTS"})
 328         {
 329             # Turn sources into objects.
 330             local (@files) = split (/\s+/, $contents{$one_file . "_SOURCES"});
 331             # Ugh: Perl syntax vs Emacs.
 332             local ($krc1, $krc2) = ('\.\$\{kr\}c', '\.\$\(kr\)c');
 333             local (@result) = ();
 334             foreach (@files)
 335             {
 336                 if (/^(.*)\.[yl]$/)
 337                 {
 338                     # Automatically include generated .c file in
 339                     # distribution.
 340                     &push_dist_common ($1 . '.c');
 341                 }
 342
 343                 # Transform source files into .o files.
 344                 s/\.cc$/$obj/g;
 345                 s/$krc1$/$obj/g;
 346                 s/$krc2$/$obj/g;
 347                 s/\.[cCmylfs]$/$obj/g;
 348
 349                 push (@result, $_);
 350             }
 351
 352             $output_vars .= ($one_file . "_OBJECTS = " . join (' ', @result)
 353                              . "\n");
 354         }
 355         else
 356         {
 357             &am_error ($one_file . '_OBJECTS', 'should not be defined');
 358         }
 359
 360         push (@sources, '$(' . $one_file . "_SOURCES)");
 361         push (@objects, '$(' . $one_file . "_OBJECTS)");
 362     }
 363     else
 364     {
 365         $output_vars .= ($one_file . "_SOURCES = " . $one_file . ".c\n"
 366                          . $one_file . "_OBJECTS = ". $one_file
 367                          . $obj . "\n");
 368         push (@sources, $one_file . '.c');
 369         push (@objects, $one_file . $obj);
 370     }
 371
 372     if (defined $contents{'CONFIG_HEADER'})
 373     {
 374         $output_rules .= ('$(' . $one_file . "_OBJECTS): "
 375                           . $contents{'CONFIG_HEADER'} . "\n");
 376     }
 377
 378     return @result;
 379 }
 380
 381 # Handle C programs.
 382 sub handle_programs
 383 {
 384     local (@proglist) = &am_install_var ('-clean',
 385                                          'programs', 'PROGRAMS',
 386                                          'bin', 'sbin', 'libexec', 'noinst');
 387     # FIXME error if PROGRAMS defined but no blah_PROGRAMS defined.
 388     return if ($#proglist < 0);
 389
 390     local ($obj) = &get_object_extension;
 391     local ($one_file, $munge);
 392     local ($fcont) = &file_contents ('program');
 393     foreach $one_file (@proglist)
 394     {
 395         &handle_source_transform ($one_file, $obj);
 396
 397         if (! defined $contents{$one_file . "_LDADD"})
 398         {
 399             # User didn't define prog_LDADD override.  So do it.
 400             $output_vars .= $one_file . '_LDADD = $(LDADD)' . "\n";
 401         }
 402
 403         ($munge = $fcont) =~ s/\@PROGRAM\@/$one_file/g;
 404         $output_rules .= $munge;
 405     }
 406 }
 407
 408 # Handle libraries.
 409 sub handle_libraries
 410 {
 411     local (@liblist) = &am_install_var ('-no-all', '-clean',
 412                                         'libraries', 'LIBRARIES',
 413                                         'lib', 'pkglib', 'noinst');
 414     # FIXME error if LIBRARIES defined but no blah_LIBRARIES defined.
 415     return if ($#liblist < 0);
 416
 417     # Generate _LIBFILES variables.  Too bad we can't do this in
 418     # am_install_var.
 419     local ($onedir, $onelib);
 420     local (@outlist);
 421     foreach $onedir ('lib', 'pkglib', 'noinst')
 422     {
 423         if (defined $contents{$onedir . '_LIBRARIES'})
 424         {
 425             @outlist = ();
 426             foreach $onelib (split (/\s+/, $contents{$onedir . '_LIBRARIES'}))
 427             {
 428                 push (@outlist, 'lib' . $onelib . '.a');
 429             }
 430             $output_vars .= ($onedir . '_LIBFILES = '
 431                              . join (' ', @outlist) . "\n");
 432         }
 433     }
 434     push (@all, '$(LIBFILES)');
 435
 436     local ($obj) = &get_object_extension;
 437     local ($template) = &file_contents ('library');
 438     local ($munge);
 439     foreach $onelib (@liblist)
 440     {
 441         if (! defined $contents{$onelib . '_LIBADD'})
 442         {
 443             # Generate support for conditional object inclusion in
 444             # libraries.
 445             $output_vars .= $onelib . "_LIBADD =\n";
 446         }
 447
 448         &handle_source_transform ($onelib, $obj);
 449
 450         ($munge = $template) =~ s/\@LIBRARY\@/$onelib/g;
 451         $output_rules .= $munge;
 452     }
 453
 454     # Turn "foo" into "libfoo.a" and include macro definition.
 455     grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
 456
 457     if (! defined $contents{'LIBFILES'})
 458     {
 459         $output_vars .= 'LIBFILES = ' . join (' ', @liblist) . "\n";
 460     }
 461     $output_vars .= &file_contents ('libraries-vars');
 462 }
 463
 464 # Handle scripts.
 465 sub handle_scripts
 466 {
 467     &am_install_var ('-clean',
 468                      'scripts', 'SCRIPTS',
 469                      'bin', 'sbin', 'libexec', 'noinst');
 470 }
 471
 472 # Handle all Texinfo source.
 473 sub handle_texinfo
 474 {
 475     local ($texis) = &am_variable ('TEXINFOS');
 476     return if (!$texis);
 477
 478     local (@texis) = split (/\s+/, $texis);
 479     if ($#texis > 0)
 480     {
 481         &am_error ('sorry, only one file allowed in `TEXINFOS\'');
 482         return;
 483     }
 484
 485     local ($infobase);
 486     ($infobase = $texis[0]) =~ s/\.texi$//;
 487
 488     # If 'version.texi' is referenced by input file, then include
 489     # automatic versioning capability.
 490     system ("grep version.texi " . $relative_dir . "/" . $texis[0]
 491             . " > /dev/null 2>&1");
 492     if (! ($? >> 8))
 493     {
 494         # Got a hit.
 495         push (@texis, 'version.texi');
 496         &push_dist_common ('version.texi', 'stamp-vti');
 497         push (@clean, 'vti');
 498
 499         local ($tfile);
 500         ($tfile = &file_contents ('texi-version')) =~ s/\@TEXI\@/$texis[0]/g;
 501         $output_rules = $output_rules . $tfile;
 502
 503         &require_file ($NORMAL, 'mdate-sh');
 504     }
 505
 506     # If user specified file_TEXINFOS, then use that as explicit
 507     # dependency list.
 508     if (defined $contents{$infobase . "_TEXINFOS"})
 509     {
 510         push (@texis, "\$" . $infobase . '_TEXINFOS');
 511         &push_dist_common ("\$" . $infobase . '_TEXINFOS');
 512     }
 513
 514     if ($#texis >= 0)
 515     {
 516         $output_rules = ($output_rules . $infobase . ".info: "
 517                          . join (' ', @texis) . "\n\n");
 518     }
 519
 520     # Some boilerplate.
 521     $output_vars = $output_vars . &file_contents ('texinfos-vars');
 522     $output_rules = $output_rules . &file_contents ('texinfos');
 523
 524     # How to clean.
 525     local ($crules) = &file_contents ('texi-clean');
 526     $crules =~ s/\@TEXI\@/$infobase/g;
 527     $output_rules .= $crules;
 528
 529     push (@suffixes, '.texi', '.info', '.dvi');
 530     push (@uninstall, 'uninstall-info');
 531     push (@clean, 'info');
 532     push (@info, '$(INFO_DEPS)');
 533     push (@dvi, '$(DVIS)');
 534     push (@installdirs, '$(infodir)');
 535     # Make sure documentation is made and installed first.
 536     unshift (@install_data, 'install-info');
 537     unshift (@all, 'info');
 538
 539     $output_vars .= ("INFOS = " . $infobase . ".info*\n"
 540                      . "INFO_DEPS = " . $infobase . ".info\n"
 541                      . "DVIS = " . $infobase . ".dvi\n\n");
 542
 543     # Do some error checking.
 544     &require_file ($NORMAL, 'texinfo.tex');
 545 }
 546
 547 # Handle any man pages.
 548 sub handle_man_pages
 549 {
 550     return if (! defined $contents{'MANS'});
 551
 552     # We generate the manpage install code by hand to avoid the use of
 553     # basename in the generated Makefile.
 554     local (@mans) = split (/\s+/, $contents{'MANS'});
 555     local (%sections, %inames, %secmap, %fullsecmap);
 556     foreach (@mans)
 557     {
 558         m/^(.*)\.([0-9])([a-z]*)$/;
 559         $sections{$2} = 1;
 560         $inames{$1} = $_;
 561         $secmap{$1} = $2;
 562         $fullsecmap{$1} = $2 . $3;
 563     }
 564
 565     # Generate list of install dirs.
 566     $output_rules .= "install-man:\n";
 567     foreach (keys %sections)
 568     {
 569         push (@installdirs, '$(mandir)/man' . $_);
 570         $output_rules .= ("\t" . '$(top_srcdir)/mkinstalldirs $(mandir)/man'
 571                           . $_ . "\n");
 572     }
 573
 574     # Generate install target.
 575     local ($key);
 576     foreach $key (keys %inames)
 577     {
 578         $_ = $install_man_format;
 579         s/\@SECTION\@/$secmap{$key}/g;
 580         s/\@MAN\@/$inames{$key}/g;
 581         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 582         s/\@MANBASE\@/$key/g;
 583         $output_rules .= $_;
 584     }
 585     $output_rules .= "\n";
 586
 587     $output_rules .= "uninstall-man:\n";
 588     foreach $key (keys %inames)
 589     {
 590         $_ = $uninstall_man_format;
 591         s/\@SECTION\@/$secmap{$key}/g;
 592         s/\@MAN\@/$inames{$key}/g;
 593         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 594         s/\@MANBASE\@/$key/g;
 595         $output_rules .= $_;
 596     }
 597     $output_rules .= "\n";
 598
 599     $output_vars .= &file_contents ('mans-vars');
 600
 601     push (@install_data, 'install-man');
 602     push (@uninstall, 'uninstall-man');
 603     push (@all, '$(MANS)');
 604 }
 605
 606 # Handle DATA variables.
 607 sub handle_data
 608 {
 609     &am_install_var ('data', 'DATA', 'data', 'sysconf',
 610                      'sharedstate', 'localstate', 'pkgdata',
 611                      'noinst');
 612 }
 613
 614 # Handle TAGS.
 615 sub handle_tags
 616 {
 617     local ($tagging) = 0;
 618
 619     if (defined ($contents{'SUBDIRS'}))
 620     {
 621         $output_rules .= &file_contents ('tags');
 622         $tagging = 1;
 623     }
 624     elsif ($dir_holds_sources || defined ($contents{'ETAGS_ARGS'}))
 625     {
 626         $output_rules .= &file_contents ('tags-subd');
 627         $tagging = 1;
 628     }
 629
 630     if ($tagging)
 631     {
 632         $output_rules .= &file_contents ('tags-clean');
 633         push (@clean, 'tags');
 634     }
 635     else
 636     {
 637         # Every Makefile must define some sort of TAGS rule.
 638         # Otherwise, it would be possible for a top-level "make TAGS"
 639         # to fail because some subdirectory failed.
 640         $output_rules .= "tags: TAGS\nTAGS:\n\n";
 641     }
 642 }
 643
 644 # Handle 'dist' target.
 645 sub handle_dist
 646 {
 647     # Look for common files that should be included in distribution.
 648     local ($cfile);
 649     foreach $cfile (@common_files)
 650     {
 651         if (-f ($relative_dir . "/" . $cfile))
 652         {
 653             &push_dist_common ($cfile);
 654         }
 655     }
 656
 657     $output_vars .= ("DIST_COMMON = " . join (' ', keys (%dist_common))
 658                      . "\n\n");
 659
 660     # Some boilerplate.
 661     $output_vars .= &file_contents ('dist-vars');
 662     if ($relative_dir ne '.')
 663     {
 664         # In a subdirectory.
 665         $output_vars .= "subdir = " . $relative_dir . "\n\n";
 666         $output_rules .= &file_contents ('dist-subd');
 667     }
 668     else
 669     {
 670         $output_rules .= &file_contents (defined ($contents{'SUBDIRS'})
 671                                          ? 'dist-subd-top'
 672                                          : 'dist');
 673     }
 674 }
 675
 676 # Handle auto-dependency code.
 677 sub handle_dependencies
 678 {
 679     if ($use_dependencies)
 680     {
 681         # Include GNU-make-specific auto-dep code.
 682         if ($dir_holds_sources)
 683         {
 684             $output_rules .= &file_contents ('depend');
 685         }
 686     }
 687     else
 688     {
 689         # Include any auto-generated deps that are present.
 690         if (-d ($relative_dir . "/.deps") && -f ($relative_dir . "/.deps/.P"))
 691         {
 692             local ($depfile);
 693             local ($gpat) = $relative_dir . "/.deps/*.P";
 694
 695             foreach $depfile (<${gpat}>)
 696             {
 697                 if (! open (DEP_FILE, $depfile))
 698                 {
 699                     &am_error ("couldn't open $depfile", $!);
 700                     next;
 701                 }
 702
 703                 # Slurp entire file.
 704                 $output_rules .= join ('', <DEP_FILE>);
 705
 706                 close (DEP_FILE);
 707             }
 708
 709             $output_rules .= "\n";
 710         }
 711     }
 712 }
 713
 714 # Handle subdirectories.
 715 sub handle_subdirs
 716 {
 717     return if (! defined ($contents{'SUBDIRS'}));
 718
 719     $output_rules .= &file_contents ('subdirs');
 720
 721     push (@all, "all-recursive");
 722     push (@check, "check-recursive");
 723     push (@installcheck, "installcheck-recursive");
 724     push (@info, "info-recursive");
 725     push (@dvi, "dvi-recursive");
 726
 727     $recursive_install = 1;
 728 }
 729
 730 # Handle remaking and configure stuff.
 731 sub handle_configure
 732 {
 733     if ($relative_dir ne '.')
 734     {
 735         # In subdirectory.
 736         $output_rules .= &file_contents ('remake-subd');
 737     }
 738     else
 739     {
 740         &require_file ($NORMAL, 'configure.in');
 741         # FIXME require 'configure'?  What if autoconf hasn't been run
 742         # yet?
 743
 744         if (defined $contents{'SUBDIRS'})
 745         {
 746             # We required AC_PROG_MAKE_SET.
 747             system ("grep AC_PROG_MAKE_SET configure.in > /dev/null 2>&1");
 748             if ($? >> 8)
 749             {
 750                 # Nope.
 751                 &am_error ("AC_PROG_MAKE_SET must be used in configure.in");
 752             }
 753         }
 754
 755         if (-f 'aclocal.m4')
 756         {
 757             $output_vars .= "ACLOCAL = aclocal.m4\n";
 758             &push_dist_common ('aclocal.m4');
 759         }
 760         $output_rules .= &file_contents ('remake');
 761
 762         # Look for some files we need.
 763         &require_file ($NORMAL, 'install-sh');
 764         &require_file ($NORMAL, 'mkinstalldirs');
 765     }
 766
 767     if (defined ($contents{'CONFIG_HEADER'})
 768         && $contents{'CONFIG_HEADER'} !~ m,/,)
 769     {
 770         # Header defined and in this directory.
 771         if (-f 'acconfig.h')
 772         {
 773             $output_vars .= "ACCONFIG = acconfig.h\n";
 774             &push_dist_common ('acconfig.h');
 775         }
 776         if (-f 'config.h.top')
 777         {
 778             $output_vars .= "CONFIG_TOP = config.h.top\n";
 779             &push_dist_common ('config.h.top');
 780         }
 781         if (-f 'config.h.bot')
 782         {
 783             $output_vars .= "CONFIG_BOT = config.h.bot\n";
 784             &push_dist_common ('config.h.bot');
 785         }
 786
 787         &push_dist_common ('stamp-h.in', $contents{'CONFIG_HEADER'} . '.in');
 788
 789         $output_rules .= &file_contents ('remake-hdr');
 790     }
 791 }
 792
 793 # Handle C headers.
 794 sub handle_headers
 795 {
 796     &am_install_var ('data', 'HEADERS', 'include',
 797                      'oldinclude', 'pkginclude',
 798                      'noinst');
 799 }
 800
 801 # Handle footer elements.
 802 sub handle_footer
 803 {
 804     if ($contents{'SOURCES'})
 805     {
 806         $output_vars .= "SOURCES = " . $contents{'SOURCES'} . "\n";
 807     }
 808     if ($contents{'OBJECTS'})
 809     {
 810         $output_vars .= "OBJECTS = " . $contents{'OBJECTS'} . "\n";
 811     }
 812     if ($contents{'SOURCES'} || $contents{'OBJECTS'})
 813     {
 814         $output_vars .= "\n";
 815     }
 816
 817     if (defined $contents{'SUFFIXES'})
 818     {
 819         push (@suffixes, '$(SUFFIXES)');
 820     }
 821
 822     $output_trailer .= ".SUFFIXES:\n";
 823     if ($#suffixes >= 0)
 824     {
 825         $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
 826     }
 827     $output_trailer .= "\n" . &file_contents ('footer');
 828 }
 829
 830 # Deal with installdirs target.
 831 sub handle_installdirs
 832 {
 833     # GNU Makefile standards recommend this.  FIXME prettyprint rule
 834     # here.
 835     $output_rules .= ("installdirs:"
 836                       . ($recursive_install
 837                          ? " installdirs-recursive\n"
 838                          : "\n"));
 839     if ($#installdirs >= 0)
 840     {
 841         $output_rules .= ("\t\$(top_srcdir)/mkinstalldirs "
 842                           . join (' ', @installdirs)
 843                           . "\n");
 844     }
 845     $output_rules .= "\n";
 846 }
 847
 848 # There are several targets which need to be merged.  This is because
 849 # their complete definition is compiled from many parts.  Note that we
 850 # avoid double colon rules, otherwise we'd use them instead.
 851 sub handle_merge_targets
 852 {
 853     &do_one_merge_target ('all', @all);
 854     &do_one_merge_target ('info', @info);
 855     &do_one_merge_target ('dvi', @dvi);
 856     &do_one_merge_target ('check', @check);
 857     &do_one_merge_target ('installcheck', @installcheck);
 858
 859     # Handle the various install targets specially.  We do this so
 860     # that (eg) "make install-exec" will run "install-exec-recursive"
 861     # if required, but "make install" won't run it twice.  Step one is
 862     # to see if the user specified local versions of any of the
 863     # targets we handle.
 864     if (defined $contents{'install-exec-local'})
 865     {
 866         push (@install_exec, 'install-exec-local');
 867     }
 868     if (defined $contents{'install-data-local'})
 869     {
 870         push (@install_data, 'install-data-local');
 871     }
 872     if (defined $contents{'uninstall-local'})
 873     {
 874         push (@uninstall, 'uninstall-local');
 875     }
 876
 877     if (defined $contents{'install-local'})
 878     {
 879         &am_error ("use \`install-data' or \`install-exec', not \`install'");
 880     }
 881
 882     # Step two: if we are doing recursive makes, write out the
 883     # appropriate rules.
 884     local (@install);
 885     if ($recursive_install)
 886     {
 887         push (@install, 'install-recursive');
 888         push (@uninstall, 'uninstall-recursive');
 889
 890         if ($#install_exec >= 0)
 891         {
 892             $output_rules .= ('install-exec-am: '
 893                               . join (' ', @install_exec)
 894                               . "\n\n");
 895             @install_exec = ('install-exec-recursive', 'install-exec-am');
 896             push (@install, 'install-exec-am');
 897         }
 898         if ($#install_data >= 0)
 899         {
 900             $output_rules .= ('install-data-am: '
 901                               . join (' ', @install_data)
 902                               . "\n\n");
 903             @install_data = ('install-data-recursive', 'install-data-am');
 904             push (@install, 'install-data-am');
 905         }
 906         if ($#uninstall >= 0)
 907         {
 908             $output_rules .= ('uninstall-am: '
 909                               . join (' ', @uninstall)
 910                               . "\n\n");
 911             @uninstall = ('uninstall-recursive', 'uninstall-am');
 912         }
 913     }
 914
 915     # Step three: print definitions users can use.
 916     if ($#install_exec >= 0)
 917     {
 918         $output_rules .= ("install-exec: "
 919                           . join (' ', @install_exec)
 920                           . "\n\n");
 921         push (@install, 'install-exec') if (!$recursive_install);
 922     }
 923     if ($#install_data >= 0)
 924     {
 925         $output_rules .= ("install-data: "
 926                           . join (' ', @install_data)
 927                           . "\n\n");
 928         push (@install, 'install-data') if (!$recursive_install);
 929     }
 930
 931     $output_rules .= ('install: '
 932                       . join (' ', @install)
 933                       . "\n\n"
 934                       . 'uninstall: '
 935                       . join (' ', @uninstall)
 936                       . "\n\n");
 937 }
 938
 939 # Helper for handle_merge_targets.
 940 sub do_one_merge_target
 941 {
 942     local ($name, @values) = @_;
 943
 944     if (defined $contents{$name . '-local'})
 945     {
 946         # User defined local form of target.  So include it.
 947         push (@values, $name . '-local');
 948     }
 949
 950     $output_rules .= $name . ": " . join (' ', @values) . "\n\n";
 951 }
 952
 953 # Handle all 'clean' targets.
 954 sub handle_clean
 955 {
 956     push (@clean, 'generic');
 957     $output_rules .= &file_contents ('clean');
 958
 959     local ($target) = $recursive_install ? 'clean-am' : 'clean';
 960     &do_one_clean_target ($target, 'mostly', '', @clean);
 961     &do_one_clean_target ($target, '', 'mostly', @clean);
 962     &do_one_clean_target ($target, 'dist', '', @clean);
 963     &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
 964
 965     local (@deps);
 966     if ($recursive_install)
 967     {
 968         @deps = ('am', 'recursive');
 969         &do_one_clean_target ('', 'mostly', '', @deps);
 970         &do_one_clean_target ('', '', '', @deps);
 971         &do_one_clean_target ('', 'dist', '', @deps);
 972         &do_one_clean_target ('', 'maintainer-', '', @deps);
 973     }
 974 }
 975
 976 # Helper for handle_clean.
 977 sub do_one_clean_target
 978 {
 979     local ($target, $name, $last_name, @deps) = @_;
 980
 981     # Special case: if target not passed, then don't generate
 982     # dependency on next "lower" clean target (eg no
 983     # clean<-mostlyclean derivation).  In this case the target is
 984     # implicitly known to be 'clean'.
 985     local ($flag) = $target;
 986     if (!$flag)
 987     {
 988         $target = 'clean';
 989     }
 990
 991     $output_rules .= $name . $target . ": ";
 992     if ($flag)
 993     {
 994         if ($last_name || $name ne 'mostly')
 995         {
 996             $output_rules .= $last_name . $target . " ";
 997         }
 998     }
 999
1000     $output_rules .= ($name . 'clean-' . join (' ' . $name . 'clean-', @deps)
1001                       . "\n");
1002
1003     # FIXME shouldn't we really print these messages before running
1004     # the dependencies?
1005     if ($name . $target eq 'maintainer-clean')
1006     {
1007         # Print a special warning.
1008         $output_rules .=
1009             ("\t\@echo \"This command is intended for maintainers to use;\"\n"
1010              . "\t\@echo \"it deletes files that may require special "
1011              . "tools to rebuild.\"\n");
1012     }
1013     elsif ($name . $target eq 'distclean'
1014            || $name . $target eq 'maintainer-clean')
1015     {
1016         $output_rules .= "\trm -f config.status\n";
1017     }
1018     $output_rules .= "\n";
1019 }
1020
1021 ################################################################
1022
1023 # Do any extra checking for GNU standards.
1024 sub check_gnu_standards
1025 {
1026     &require_file ($GNU, 'ChangeLog');
1027
1028     if ($relative_dir eq '.')
1029     {
1030         # In top level (or only) directory.
1031         &require_file ($GNU, 'INSTALL', 'NEWS', 'README');
1032     }
1033 }
1034
1035 # Do any extra checking for GNITS standards.
1036 sub check_gnits_standards
1037 {
1038 }
1039
1040 ################################################################
1041
1042 # Read Makefile.am and set up %contents.  Simultaneously copy lines
1043 # from Makefile.am into $output_trailer or $output_vars as
1044 # appropriate.  NOTE we put rules in the trailer section.  We want
1045 # user rules to come after our generated stuff.
1046 sub read_am_file
1047 {
1048     local ($amfile) = @_;
1049
1050     if (! open (AMFILE, $amfile))
1051     {
1052         print STDERR "automake: couldn't open $amfile: $!\n";
1053         exit 1;
1054     }
1055
1056     local ($saw_bk) = 0;
1057     local ($was_rule) = 0;
1058     local ($last_var_name) = '';
1059
1060     while (<AMFILE>)
1061     {
1062         chop;
1063
1064         if ($saw_bk)
1065         {
1066             if ($was_rule)
1067             {
1068                 $output_trailer .= $_ . "\n";
1069             }
1070             else
1071             {
1072                 $output_vars .= $_ . "\n";
1073                 if (substr ($_, -1) eq "\\")
1074                 {
1075                     $contents{$last_var_name} .= substr ($_, 0,
1076                                                          length ($_) - 1);
1077                 }
1078                 else
1079                 {
1080                     $contents{$last_var_name} .= $_;
1081                 }
1082             }
1083         }
1084         elsif ($_ eq '@kr@')
1085         {
1086             # Special case: this means we want automatic
1087             # de-ANSI-fication.  FIXME think of a better way.
1088             $contents{'@kr@'} = 1;
1089         }
1090         elsif (m/^ *([a-zA-Z_.][-.a-zA-Z0-9_.]*) *:/)
1091         {
1092             # Found a rule.
1093             $was_rule = 1;
1094             # Value here doesn't matter; for targets we only note
1095             # existence.
1096             $contents{$1} = 1;
1097             $output_trailer .= $_ . "\n";
1098         }
1099         elsif (m/^ *([A-Za-z][A-Za-z0-9_]*)[ \t]*=[ \t]*(.*)$/)
1100         {
1101             # Found a variable reference.
1102             $was_rule = 0;
1103             $last_var_name = $1;
1104             if (substr ($2, -1) eq "\\")
1105             {
1106                 $contents{$1} = substr ($2, 0, length ($2) - 1);
1107             }
1108             else
1109             {
1110                 $contents{$1} = $2;
1111             }
1112             $output_vars .= $_ . "\n";
1113         }
1114         elsif (m/^$/)
1115         {
1116             # Special rule: if looking at a blank line, append it to
1117             # whatever we saw last.
1118             if ($was_rule)
1119             {
1120                 $output_trailer .= "\n";
1121             }
1122             else
1123             {
1124                 $output_vars .= "\n";
1125             }
1126         }
1127         else
1128         {
1129             # This isn't an error; it is probably a continued rule.
1130             # In fact, this is what we assume.
1131             $output_trailer .= $_ . "\n";
1132         }
1133
1134         $saw_bk = (substr ($_, -1) eq "\\");
1135     }
1136
1137     # Include some space after user code.
1138     $output_vars .= "\n";
1139     $output_trailer .= "\n";
1140 }
1141
1142 ################################################################
1143
1144 sub initialize_global_constants
1145 {
1146     # Associative array of standard directory names.  Entry is TRUE if
1147     # corresponding directory should be installed during
1148     # 'install-exec' phase.
1149     %exec_dir_p =
1150         ('bin', 1,
1151          'sbin', 1,
1152          'libexec', 1,
1153          'data', 0,
1154          'sysconf', 1,
1155          'localstate', 1,
1156          'lib', 1,
1157          'info', 0,
1158          'man', 0,
1159          'include', 0,
1160          'oldinclude', 0,
1161          'pkgdata', 0,
1162          'pkglib', 1,
1163          'pkginclude', 0
1164          );
1165
1166     # Helper text for dealing with man pages.
1167     $install_man_format =
1168     '   sect=@SECTION@;                         \\
1169         inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1170         echo installing @MAN@ as $(mandir)/man$$sect/$$inst; \\
1171         $(INSTALL_DATA) $(srcdir)/@MAN@ $(mandir)/man$$sect/$$inst; \\
1172         if test -d $(mandir)/cat$$sect; then    \\
1173           echo formatting @MAN@ as $(mandir)/cat$$sect/$$inst;  \\
1174           $(NROFF) -man $(srcdir)/@MAN@ > $(mandir)/cat$$sect/$$inst; \\
1175         else                                    \\
1176           true;                                 \\
1177         fi
1178 ';
1179
1180     $uninstall_man_format =
1181     '   inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1182         rm -f $(mandir)/man@SECTION@/$$inst $(mandir)/cat@SECTION@/$$inst
1183 ';
1184
1185     # Commonly found files we look for and automatically include in
1186     # DISTFILES.
1187     @common_files =
1188         (
1189          "THANKS", "TODO", "README", "NEWS", "COPYING", "COPYING.LIB",
1190          "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
1191          "config.guess", "config.sub"
1192          );
1193
1194     # Commonly used files we auto-include, but only sometimes.
1195     @common_sometimes =
1196         (
1197          "version.texi", "aclocal.m4", "acconfig.h", "config.h.top",
1198          "config.h.bot", "stamp-h.in", "mdate-sh", "ansi2knr.c",
1199          "ansi2knr.1", 'stamp-vti', "mkinstalldirs", "install-sh"
1200          );
1201
1202     $USAGE = "\
1203   --amdir=DIR           directory storing config files
1204   --help                print this help, then exit
1205   --include-deps        include generated dependencies in Makefile.in
1206   --install-missing     install missing standard files
1207   --output-dir=DIR      put generated Makefile.in's into DIR
1208   --strictness=LEVEL    set strictness level.  LEVEL is normal, gnu, gnits
1209   --version             print version number, then exit\n";
1210 }
1211
1212 # (Re)-Initialize per-Makefile.am variables.
1213 sub initialize_per_input
1214 {
1215     # These two variables are used when generating each Makefile.in.
1216     # They hold the Makefile.in until it is ready to be printed.
1217     $output_rules = '';
1218     $output_vars = '';
1219     $output_trailer = '';
1220
1221     # Suffixes found during a run.
1222     @suffixes = ();
1223
1224     # This holds the contents of a Makefile.am, as parsed by
1225     # read_am_file.
1226     %contents = ();
1227
1228     # This holds the "relative directory" of the current Makefile.in.
1229     # Eg for src/Makefile.in, this is "src".
1230     $relative_dir = '';
1231
1232     # Directory where output files go.  Actually, output files are
1233     # relative to this directory.
1234     $output_directory = '.';
1235
1236     # This holds a list of files that are included in the
1237     # distribution.
1238     %dist_common = ();
1239
1240     # List of dependencies for the obvious targets.
1241     @install_data = ();
1242     @install_exec = ();
1243     @uninstall = ();
1244     @installdirs = ();
1245
1246     @info = ();
1247     @dvi = ();
1248     @all = ();
1249     @check = ();
1250     @installcheck = ();
1251     @clean = ();
1252
1253     # These are pretty obvious, too.  They are used to define the
1254     # SOURCES and OBJECTS variables.
1255     @sources = ();
1256     @objects = ();
1257
1258     # TRUE if current directory holds any C source files.  (Actually
1259     # holds object extension, but this information is encapsulated in
1260     # the function get_object_extension).
1261     $dir_holds_sources = '';
1262
1263     # TRUE if install targets should work recursively.
1264     $recursive_install = 0;
1265 }
1266
1267
1268 ################################################################
1269
1270 # Return contents of a file from $am_dir.
1271 sub file_contents
1272 {
1273     local ($basename) = @_;
1274     local ($file) = $am_dir . '/' . $basename . '.am';
1275
1276     if (! open (FC_FILE, $file))
1277     {
1278         print STDERR "automake: installation error: cannot open \"$file\"\n";
1279         exit 1;
1280     }
1281
1282     # Lines starting with "##" are comments for developer use only.
1283     local ($result) = '';
1284     while (<FC_FILE>)
1285     {
1286         $result .= $_ unless ( m/^##/);
1287     }
1288     close (FC_FILE);
1289     return $result;
1290 }
1291
1292 # Return contents of some Makefile.am variable.  Allow for AM_ style
1293 # overrides.
1294 sub am_variable
1295 {
1296     local ($varname) = @_;
1297
1298     return (defined ($contents{'AM_' . $varname})
1299             ? $contents{'AM_' . $varname}
1300             : $contents{$varname});
1301 }
1302
1303 # Handle `where_HOW' variable magic.  Does all lookups, generates
1304 # install code,and possibly generates code to define the primary
1305 # variable.  The first argument is the name of the .am file to munge,
1306 # the second argument is the primary variable (eg HEADERS), and all
1307 # subsequent arguments are possible installation locations.  FIXME
1308 # should scan all defined variables and do some error checking to
1309 # avoid typos (eg 'bni_PROGRAMS' should give error).  Returns list of
1310 # all values of all _HOW targets.
1311 #
1312 # FIXME this should be rewritten to be cleaner.  It should be broken
1313 # up into multiple functions.
1314 #
1315 # Usage is: am_install_var (OPTION..., file, HOW, where...)
1316 sub am_install_var
1317 {
1318     local (@args) = @_;
1319
1320     local ($do_all, $do_clean) = (1, 0);
1321     while ($#args >= 0)
1322     {
1323         if ($args[0] eq '-clean')
1324         {
1325             $do_clean = 1;
1326         }
1327         elsif ($args[0] eq '-no-all')
1328         {
1329             $do_all = 0;
1330         }
1331         elsif ($args[0] !~ /^-/)
1332         {
1333             last;
1334         }
1335         shift (@args);
1336     }
1337     local ($file, $primary, @prefixes) = @args;
1338
1339     local (@used) = ();
1340     local (@result) = ();
1341
1342     local ($template) = &file_contents ($file);
1343     local ($clean_templ) = &file_contents ($file . '-clean');
1344     local ($munge);
1345     local ($one_name);
1346     foreach (@prefixes)
1347     {
1348         $one_name = $_ . '_' . $primary;
1349         if (defined $contents{$one_name})
1350         {
1351             # Append actual contents to result.
1352             push (@result, split (/\s+/, $contents{$one_name}));
1353
1354             if ($do_clean)
1355             {
1356                 ($munge = $clean_templ) =~ s/\@DIR\@/$_/g;
1357                 $output_rules .= $munge;
1358                 push (@clean, $_ . $primary);
1359             }
1360
1361             push (@used, '$(' . $one_name . ')');
1362             if ($_ eq 'noinst')
1363             {
1364                 # Objects in noinst_FOO never get installed.
1365                 next;
1366             }
1367
1368             ($munge = $template) =~ s/\@DIR\@/$_/g;
1369             $output_rules .= $munge;
1370
1371             push (@uninstall, 'uninstall-' . $_ . $primary);
1372             push (@installdirs, '$(' . $_ . 'dir)');
1373             if ($exec_dir_p{$_})
1374             {
1375                 push (@install_exec, 'install-' . $_ . $primary);
1376             }
1377             else
1378             {
1379                 push (@install_data, 'install-' . $_ . $primary);
1380             }
1381         }
1382     }
1383
1384     if (! defined $contents{$primary} && $#used >= 0)
1385     {
1386         # Define it.
1387         $output_vars .= $primary . " = " . join (' ', @used) . "\n\n";
1388     }
1389
1390     # Push here because PRIMARY might be configure time determined.
1391     push (@all, '$(' . $primary . ')') if ($do_all && $#used >= 0);
1392
1393     # Look for misspellings.  It is an error to have a variable ending
1394     # in a "reserved" suffix whose prefix is unknown, eg
1395     # "bni_PROGRAMS".
1396     local (%valid, $varname);
1397     grep ($valid{$_} = 0, @prefixes);
1398     foreach $varname (keys %contents)
1399     {
1400         if ($varname =~ /^(.*)_$primary$/ && ! defined $valid{$1})
1401         {
1402             &am_error ("invalid variable \"$varname\"");
1403         }
1404     }
1405
1406     return (@result);
1407 }
1408
1409
1410 ################################################################
1411
1412 # Verify that the file must exist in the current directory.
1413 # Usage: require_file (strictness, file)
1414 # strictness is the strictness level at which this file becomes
1415 # required.
1416 sub require_file
1417 {
1418     local ($mystrict, $file) = @_;
1419     local ($fullfile) = $relative_dir . "/" . $file;
1420
1421     if (-f $fullfile)
1422     {
1423         &push_dist_common ($file);
1424     }
1425     elsif ($install_missing && -f ($am_dir . '/' . $file))
1426     {
1427         # Install the missing file.  Symlink if we can, copy if we must.
1428         if ($symlink_exists)
1429         {
1430             symlink ($am_dir . '/' . $file, $fullfile);
1431         }
1432         else
1433         {
1434             system ('cp', $am_dir . '/' . $file, $fullfile);
1435         }
1436         &am_error ("required file \"$fullfile\" not found; installing");
1437     }
1438     elsif ($strictness >= $mystrict)
1439     {
1440         # Only an error if strictness constraint violated.
1441         &am_error ("required file \"$fullfile\" not found");
1442     }
1443 }
1444
1445 # Push a list of files onto dist_common.
1446 sub push_dist_common
1447 {
1448     local (@files) = @_;
1449     local ($file);
1450
1451     foreach $file (@files)
1452     {
1453         $dist_common{$file} = 1;
1454     }
1455 }
1456
1457 # Set strictness.
1458 sub set_strictness
1459 {
1460     local ($name) = @_;
1461
1462     if ($name eq 'gnu')
1463     {
1464         $strictness = $GNU;
1465     }
1466     elsif ($name eq 'gnits')
1467     {
1468         $strictness = $GNITS;
1469     }
1470     elsif ($name eq 'normal')
1471     {
1472         $strictness = $NORMAL;
1473     }
1474     else
1475     {
1476         print STDERR "automake: level \`$name' not recognized\n";
1477         exit 1;
1478     }
1479 }
1480
1481
1482 ################################################################
1483
1484 # Return directory name of file.
1485 sub dirname
1486 {
1487     local ($file) = @_;
1488     local ($sub);
1489
1490     ($sub = $file) =~ s,/+[^/]+,,g;
1491     if ($sub eq $file)
1492     {
1493         $sub = '.';
1494     }
1495
1496     return $sub;
1497 }
1498
1499 # Make a directory.
1500 sub mkdir
1501 {
1502     local ($dirname) = @_;
1503     system ("mkdir", $dirname);
1504 }
1505
1506 ################################################################
1507
1508 # Print an error message and set exit status.
1509 sub am_error
1510 {
1511     print STDERR "automake: ${am_file}.am: ", join (' ', @_), "\n";
1512     $exit_status = 1;
1513 }
1514
1515 # Print usage information.
1516 sub usage
1517 {
1518     print "Usage: automake [OPTION] ... [Makefile]...\n";
1519     print $USAGE;
1520     print "\nFiles which are automatically distributed, if found:\n";
1521     $~ = "USAGE_FORMAT";
1522     local (@lcomm) = sort ((@common_files, @common_sometimes));
1523     local ($one, $two);
1524     while ($#lcomm >= 0)
1525     {
1526         $one = shift (@lcomm);
1527         $two = shift (@lcomm);
1528         write;
1529     }
1530
1531     exit 0;
1532 }
1533
1534 format USAGE_FORMAT =
1535   @<<<<<<<<<<<<<<<<    @<<<<<<<<<<<<<<<<
1536   $one,                $two
1537 .