automake.in

   1 #!@PERL@
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 # automake - create Makefile.in from Makefile.am
   6 # Copyright (C) 1994 Free Software Foundation, Inc.
   7
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2, or (at your option)
  11 # any later version.
  12
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 # Originally written by David Mackenzie <djm@gnu.ai.mit.edu>.
  23 # Perl reimplementation by Tom Tromey <tromey@drip.colorado.edu>.
  24
  25
  26 # Parameters set by configure.  Not to be changed.
  27 $PACKAGE = "@PACKAGE@";
  28 $VERSION = "@VERSION@";
  29 $prefix = "@prefix@";
  30 $am_dir = "@datadir@/@PACKAGE@";
  31
  32 # Commonly found files we look for and automatically include in
  33 # DIST_FILES.
  34 @common_files =
  35     (
  36      "THANKS", "TODO", "README", "NEWS", "COPYING", "COPYING.LIB",
  37      "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
  38      "config.guess", "config.sub", "mkinstalldirs", "install-sh"
  39      );
  40
  41 # Commonly used files we auto-include, but only sometimes.
  42 @common_sometimes =
  43     (
  44      "version.texi", "aclocal.m4", "acconfig.h", "config.h.top",
  45      "config.h.bot", "stamp-h.in", "mdate-sh", "ansi2knr.c",
  46      "ansi2knr.1"
  47      );
  48
  49 $USAGE = "  --amdir=DIR           directory storing config files
  50   --help                print this help, then exit
  51   --version             print version number, then exit
  52   --include-deps        include generated dependencies in Makefile\n";
  53
  54 \f
  55
  56 # This is TRUE if GNU make specific automatic dependency generation
  57 # code should be included in generated Makefile.in.
  58 $use_dependencies = 1;
  59
  60 # This holds our (eventual) exit status.  We don't actually exit until
  61 # we have processed all input files.
  62 $exit_status = 0;
  63
  64 # These two variables are used when generating each Makefile.in.  They
  65 # hold the Makefile.in until it is ready to be printed.
  66 $output_rules = '';
  67 $output_vars = '';
  68 $output_trailer = '';
  69
  70 # Suffixes found during a run.
  71 @suffixes = ();
  72
  73 # This holds the contents of a Makefile.am, as parsed by read_am_file.
  74 %contents = ();
  75
  76 # This holds the "relative directory" of the current Makefile.in.  Eg
  77 # for src/Makefile.in, this is "src".
  78 $relative_dir = '';
  79
  80 # This holds a list of files that are included in the distribution.
  81 @dist_common = ();
  82
  83 # List of dependencies for the obvious targets.
  84 @install_data = ();
  85 @install_exec = ();
  86 @uninstall = ();
  87
  88 @info = ();
  89 @dvi = ();
  90 @all = ('${ALL}');
  91 @check = ();
  92
  93 # TRUE if current directory holds any C source files.
  94 $dir_holds_sources = 0;
  95
  96 # TRUE if install targets should work recursively.
  97 $recursive_install = 0;
  98
  99 \f
 100
 101 # Parse command line.
 102 @input_files = &parse_arguments (@ARGV);
 103
 104 # Now do all the work on each file.
 105 foreach $am_file (@input_files)
 106 {
 107     if (! -f ($am_file . '.am'))
 108     {
 109         print STDERR "automake: $am_file" . ".am: no such file\n";
 110         $exit_status = 1;
 111     }
 112     else
 113     {
 114         &generate_makefile ($am_file);
 115     }
 116 }
 117
 118 exit $exit_status;
 119
 120
 121 ################################################################
 122
 123 # Parse command line.
 124 sub parse_arguments
 125 {
 126     local (@arglist) = @_;
 127     local (@make_list);
 128
 129     while ($#arglist >= 0)
 130     {
 131         if ($arglist[0] eq "--version")
 132         {
 133             print "Automake version $VERSION\n";
 134             exit 0;
 135         }
 136         elsif ($arglist[0] eq "--help")
 137         {
 138             &usage;
 139         }
 140         elsif ($arglist[0] =~ /^--amdir=(.+)$/)
 141         {
 142             $am_dir = $1;
 143         }
 144         elsif ($arglist[0] eq '--amdir')
 145         {
 146             if ($#arglist == 1)
 147             {
 148                 print STDERR
 149                     "automake: no argument given for option \`$arglist[0]'\n";
 150                 exit 1;
 151             }
 152             shift (@arglist);
 153             $am_dir = $arglist[0];
 154         }
 155         elsif ($arglist[0] eq '--include-deps')
 156         {
 157             $use_dependencies = 0;
 158         }
 159         elsif ($arglist[0] eq '--')
 160         {
 161             # Stop option processing.
 162             shift (@arglist);
 163             push (@make_list, @arglist);
 164             last;
 165         }
 166         elsif ($arglist[0] =~ /^-/)
 167         {
 168             print STDERR "automake: unrecognized option -- \`$arglist[0]'\n";
 169             exit 1;
 170         }
 171         else
 172         {
 173             push (@make_list, $arglist[0]);
 174         }
 175
 176         shift (@arglist);
 177     }
 178
 179     if ($#make_list < 0)
 180     {
 181         # Look around for some files.
 182         push (@make_list, 'Makefile') if -f 'Makefile.am';
 183
 184         foreach (<*/Makefile.am>)
 185         {
 186             s/\.am$//;
 187             push (@make_list, $_);
 188         }
 189
 190         if ($#make_list >= 0)
 191         {
 192             print "automake: using ", join (' ', @make_list), "\n";
 193         }
 194         else
 195         {
 196             print STDERR "automake: no \"Makefile.am\" found or specified\n";
 197             exit 1;
 198         }
 199     }
 200
 201     return (@make_list);
 202 }
 203
 204 ################################################################
 205
 206 # Generate a Makefile.in given the name of the corresponding Makefile.
 207 sub generate_makefile
 208 {
 209     local ($makefile) = @_;
 210
 211     print "creating ", $makefile, ".in\n";
 212
 213     $relative_dir = &dirname ($makefile);
 214     $output_rules = '';
 215     $output_vars = '';
 216     $output_trailer = '';
 217     @suffixes = ();
 218     %contents = ();
 219     @dist_common = ('Makefile.in', 'Makefile.am');
 220     @install_data = ();
 221     @install_exec = ();
 222     @uninstall = ();
 223     $dir_holds_sources = 0;
 224     $recursive_install = 0;
 225     @info = ();
 226     @dvi = ();
 227     @all = ('${ALL}');
 228     @check = ();
 229
 230     # Generate header before reading .am file.  The header must come
 231     # before anything else, and read_am_file copies code into the
 232     # output.
 233     &generate_header;
 234
 235     # This is always the default target.  This gives us freedom to do
 236     # things in whatever order is convenient.
 237     $output_rules .= "default: all\n\n";
 238
 239     &read_am_file ($makefile . '.am');
 240
 241     # Program stuff.
 242     local ($programs) = (defined ($contents{'AM_PROGRAMS'})
 243                          ? $contents{'AM_PROGRAMS'}
 244                          : $contents{'PROGRAMS'});
 245     local ($libprograms) = (defined ($contents{'AM_LIBPROGRAMS'})
 246                             ? $contents{'AM_LIBPROGRAMS'}
 247                             : $contents{'LIBPROGRAMS'});
 248     local ($libraries) = (defined ($contents{'AM_LIBRARIES'})
 249                           ? $contents{'AM_LIBRARIES'}
 250                           : $contents{'LIBRARIES'});
 251     local ($scripts) = (defined ($contents{'AM_SCRIPTS'})
 252                         ? $contents{'AM_SCRIPTS'}
 253                         : $contents{'SCRIPTS'});
 254     local ($libscripts) = (defined ($contents{'AM_LIBSCRIPTS'})
 255                            ? $contents{'AM_LIBSCRIPTS'}
 256                            : $contents{'LIBSCRIPTS'});
 257
 258     &handle_programs ($programs, $libprograms, $libraries);
 259     &handle_scripts ($scripts, $libscripts);
 260     &handle_libraries ($libraries);
 261
 262     &handle_texinfo;
 263     &handle_man_pages;
 264     &handle_data;
 265     &handle_subdirs;
 266     &handle_configure;
 267     &handle_tags;
 268     &handle_dist;
 269     &handle_dependencies;
 270     &handle_footer;
 271     &handle_merge_targets;
 272
 273     if (! open (GM_FILE, "> " . $makefile . ".in"))
 274     {
 275         print STDERR "automake: cannot open ", $makefile, ".in: ", $!, "\n";
 276         $exit_status = 1;
 277         return;
 278     }
 279
 280     print GM_FILE $output_vars;
 281     print GM_FILE $output_rules;
 282     print GM_FILE $output_trailer;
 283
 284     close (GM_FILE);
 285 }
 286
 287 ################################################################
 288
 289 # Generate header of Makefile.in.
 290 sub generate_header
 291 {
 292     $output_vars =
 293         ($output_vars
 294          . "# Makefile.in generated automatically by automake "
 295          . $VERSION
 296          . " from Makefile.am\n");
 297
 298     $output_vars = $output_vars . &file_contents ('header-vars');
 299     $output_rules = $output_rules . &file_contents ('header');
 300 }
 301
 302 # Handle C programs and libraries.
 303 sub handle_programs
 304 {
 305     local ($programs, $libprograms, $libraries) = @_;
 306
 307     if (!$programs && !$libprograms && !$libraries)
 308     {
 309         # None exist.
 310         return;
 311     }
 312     $dir_holds_sources = 1;
 313
 314     # Boilerplate.
 315     $output_vars .= &file_contents ('compile-vars');
 316     $output_rules .= &file_contents ('compile');
 317
 318     # Check for automatic de-ANSI-fication.
 319     local ($obj) = '.o';
 320     push (@suffixes, '.c', '.o');
 321     if (defined $contents{'@kr@'})
 322     {
 323         $obj = '.${kr}o';
 324         push (@suffixes, '._c', '._o');
 325
 326         &require_file ('ansi2knr.c');
 327         &require_file ('ansi2knr.1');
 328
 329         $output_vars .= &file_contents ('kr-vars');
 330         $output_rules .= &file_contents ('compile-kr');
 331     }
 332
 333     local (@sources, @objects);
 334     push (@sources, '${SOURCES}') if (defined $contents{'SOURCES'});
 335     push (@objects, '${OBJECTS}') if (defined $contents{'OBJECTS'});
 336
 337     local ($one_file);
 338     foreach $one_file (split (' ', ($programs . ' '
 339                                     . $libprograms . ' '
 340                                     . $libraries)))
 341     {
 342         # Look for file_SOURCES and file_OBJECTS.  FIXME file_OBJECTS
 343         # should probably not be used(?)
 344         if (defined $contents{$one_file . "_SOURCES"})
 345         {
 346             if (! defined $contents{$one_file . "_OBJECTS"})
 347             {
 348                 # Turn sources into objects.
 349                 $_ = $contents{$one_file . "_SOURCES"};
 350
 351                 # Ugh: Perl syntax vs Emacs.
 352                 local ($krc1, $krc2) = ('\.\$\{kr\}c', '\.\$\(kr\)c');
 353
 354                 s/\.cc/$obj/g;
 355                 s/$krc1/$obj/g;
 356                 s/$krc2/$obj/g;
 357                 s/\.[cCmylfs]/$obj/g;
 358
 359                 $output_vars .= $one_file . "_OBJECTS = " . $_ . "\n";
 360             }
 361
 362             push (@sources, '${' . $one_file . "_SOURCES}");
 363             push (@objects, '${' . $one_file . "_OBJECTS}");
 364         }
 365         else
 366         {
 367             $output_vars .= ($one_file . "_SOURCES = " . $one_file . ".c\n"
 368                              . $one_file . "_OBJECTS = ". $one_file
 369                              . $obj . "\n");
 370             push (@sources, $one_file . '.c');
 371             push (@objects, $one_file . $obj);
 372         }
 373
 374         if (defined $contents{'CONFIG_HEADER'})
 375         {
 376             $output_rules .= ('$(' . $one_file . "_OBJECTS): "
 377                               . $contents{'CONFIG_HEADER'} . "\n");
 378         }
 379     }
 380
 381     $output_vars .= "\n";
 382
 383     # Re-init SOURCES and OBJECTS.  FIXME other code shouldn't depend
 384     # on this.
 385     $contents{'SOURCES'} = join (' ', @sources);
 386     $contents{'OBJECTS'} = join (' ', @objects);
 387
 388     # Some boilerplate, and install rules.
 389     if ($programs)
 390     {
 391         $output_rules .= &file_contents ('programs');
 392         push (@install_exec, "install-programs");
 393         push (@uninstall, 'uninstall-programs');
 394     }
 395     if ($libprograms)
 396     {
 397         $output_rules .= &file_contents ('libprograms');
 398         push (@install_exec, 'install-libprograms');
 399         push (@uninstall, 'uninstall-libprograms');
 400     }
 401
 402     # Handle linking.
 403     if ($programs || $libprograms)
 404     {
 405         local ($fcont) = &file_contents ('program');
 406         local ($munge);
 407         foreach $one_file (split (' ', $programs . ' ' . $libprograms))
 408         {
 409             if (! defined $contents{$one_file . "_LDADD"})
 410             {
 411                 # User didn't define prog_LDADD override.  So do it.
 412                 $output_vars .= $one_file . '_LDADD = ${LDADD}' . "\n";
 413             }
 414
 415             ($munge = $fcont) =~ s/@PROGRAM@/$one_file/g;
 416             $output_rules .= $munge;
 417         }
 418     }
 419 }
 420
 421 # Handle libraries.
 422 sub handle_libraries
 423 {
 424     local ($libraries) = @_;
 425
 426     return if (!$libraries);
 427
 428     local (@liblist) = split (' ', $libraries);
 429
 430     $output_rules .= &file_contents ('libraries');
 431     local ($onefile) = &file_contents ('library');
 432     local ($onelib, $munge);
 433     foreach $onelib (@liblist)
 434     {
 435         ($munge = $onefile) =~ s/@LIBRARY@/$onelib/g;
 436         $output_rules .= $munge;
 437     }
 438
 439     # Turn "foo" into "libfoo.a" and include macro definition.
 440     grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
 441     $output_vars .= ("LIBFILES = " . join (' ', @liblist) . "\n\n"
 442                      . &file_contents ('libraries-vars'));
 443
 444     push (@install_exec, 'install-libraries');
 445     push (@uninstall, 'uninstall-libraries');
 446 }
 447
 448 # Handle scripts.
 449 sub handle_scripts
 450 {
 451     local ($scripts, $libscripts) = @_;
 452
 453     if ($scripts)
 454     {
 455         $output_rules .= &file_contents ('scripts');
 456         push (@install_exec, 'install-scripts');
 457         push (@uninstall, 'uninstall-scripts');
 458     }
 459
 460     if ($libscripts)
 461     {
 462         $output_rules .= &file_contents ('libscripts');
 463         push (@install_exec, 'install-libscripts');
 464         push (@uninstall, 'uninstall-libscripts');
 465     }
 466 }
 467
 468 # Handle all Texinfo source.
 469 sub handle_texinfo
 470 {
 471     return if (! defined $contents{TEXINFOS});
 472
 473     local (@texis) = split (' ', $contents{TEXINFOS});
 474     if ($#texis > 0)
 475     {
 476         print STDERR "automake: sorry, only one file allowed in \`TEXINFOS'\n";
 477         $exit_status = 1;
 478         return;
 479     }
 480
 481     local ($infobase);
 482     ($infobase = $texis[0]) =~ s/\.texi$//;
 483
 484     # If 'version.texi' is referenced by input file, then include
 485     # automatic versioning capability.
 486     system ("grep version.texi " . $relative_dir . "/" . $texis[0]
 487             . " > /dev/null 2>&1");
 488     if (!$?)
 489     {
 490         # Got a hit.
 491         push (@texis, 'version.texi');
 492         push (@dist_common, 'version.texi');
 493         local ($tfile);
 494         ($tfile = &file_contents ('texi-version')) =~ s/@TEXI@/$texis[0]/g;
 495         $output_rules = $output_rules . $tfile;
 496
 497         &require_file ('mdate-sh');
 498     }
 499
 500     # If user specified file_TEXINFOS, then use that as explicit
 501     # dependency list.
 502     if (defined $contents{$infobase . "_TEXINFOS"})
 503     {
 504         push (@texis, "\$" . $infobase . '_TEXINFOS');
 505         push (@dist_common, "\$" . $infobase . '_TEXINFOS');
 506     }
 507
 508     if ($#texis >= 0)
 509     {
 510         $output_rules = ($output_rules . $infobase . ".info: "
 511                          . join (' ', @texis) . "\n\n");
 512     }
 513
 514     # Some boilerplate.
 515     $output_vars = $output_vars . &file_contents ('texinfos-vars');
 516     $output_rules = $output_rules . &file_contents ('texinfos');
 517
 518     push (@suffixes, '.texi', '.info', '.dvi');
 519     push (@install_data, 'install-info');
 520     push (@uninstall, 'uninstall-info');
 521
 522     push (@info, '$(INFO_DEPS)');
 523     push (@dvi, '$(DVIS)');
 524
 525     $output_vars .= ("INFOS = " . $infobase . "info*\n"
 526                      . "INFO_DEPS = " . $infobase . ".info\n"
 527                      . "DVIS = " . $infobase . ".dvi\n\n");
 528
 529     # Do some error checking.
 530     &require_file ('texinfo.tex');
 531 }
 532
 533 # Handle any man pages.
 534 sub handle_man_pages
 535 {
 536     return if (! defined $contents{'MANS'});
 537
 538     $output_vars .= &file_contents ('mans-vars');
 539     $output_rules .= &file_contents ('mans');
 540
 541     push (@install_data, 'install-man');
 542     push (@uninstall, 'uninstall-man');
 543 }
 544
 545 # Handle DATA and PACKAGEDATA.
 546 sub handle_data
 547 {
 548     if (defined $contents{'DATA'})
 549     {
 550         $output_rules .= &file_contents ('data');
 551         push (@install_data, 'install-ddata');
 552         push (@uninstall, 'uninstall-ddata');
 553     }
 554
 555     if (defined $contents{'PACKAGEDATA'})
 556     {
 557         $output_rules .= &file_contents ('packagedata');
 558         push (@install_data, 'install-pdata');
 559         push (@uninstall, 'uninstall-pdata');
 560     }
 561 }
 562
 563 # Handle TAGS.
 564 sub handle_tags
 565 {
 566     if (defined ($contents{'SUBDIRS'}))
 567     {
 568         $output_rules .= &file_contents ('tags');
 569     }
 570     elsif ($dir_holds_sources || defined ($contents{'ETAGS_ARGS'}))
 571     {
 572         $output_rules .= &file_contents ('tags-subd');
 573     }
 574 }
 575
 576 # Handle 'dist' target.
 577 sub handle_dist
 578 {
 579     # Look for common files that should be included in distribution.
 580     local ($cfile);
 581     foreach $cfile (@common_files)
 582     {
 583         if (-f ($relative_dir . "/" . $cfile))
 584         {
 585             push (@dist_common, $cfile);
 586         }
 587     }
 588
 589     $output_vars .= "DIST_COMMON = " . join (' ', @dist_common) . "\n\n";
 590
 591     # Some boilerplate.
 592     if ($relative_dir ne '.')
 593     {
 594         # In a subdirectory.
 595         $output_vars .= (&file_contents ('dist-subd-vars')
 596                          . "subdir = " . $relative_dir . "\n\n");
 597         $output_rules .= &file_contents ('dist-subd');
 598     }
 599     else
 600     {
 601         $output_vars .= &file_contents ('dist-vars');
 602         $output_rules .= &file_contents (defined ($contents{'SUBDIRS'})
 603                                          ? 'dist-subd-top'
 604                                          : 'dist');
 605     }
 606 }
 607
 608 # Handle auto-dependency code.
 609 sub handle_dependencies
 610 {
 611     if ($use_dependencies)
 612     {
 613         # Include GNU-make-specific auto-dep code.
 614         if ($dir_holds_sources)
 615         {
 616             $output_rules .= &file_contents ('depend');
 617         }
 618     }
 619     else
 620     {
 621         # Include any auto-generated deps that are present.
 622         if (-d ($relative_dir . "/.deps") && -f ($relative_dir . ".deps/.P"))
 623         {
 624             local ($depfile);
 625             local ($gpat) = $relative_dir . "/.deps/*.P";
 626
 627             foreach $depfile (<${gpat}>)
 628             {
 629                 if (! open (DEP_FILE, $depfile))
 630                 {
 631                     print STDERR "automake: couldn't open $depfile: $!\n";
 632                     next;
 633                 }
 634
 635                 $output_rules .= <DEP_FILE>;
 636
 637                 close (DEP_FILE);
 638             }
 639         }
 640     }
 641 }
 642
 643 # Handle subdirectories.
 644 sub handle_subdirs
 645 {
 646     return if (! defined ($contents{'SUBDIRS'}));
 647
 648     $output_rules .= &file_contents ('subdirs');
 649
 650     push (@all, "all-recursive");
 651     push (@check, "check-recursive");
 652     push (@info, "info-recursive");
 653     push (@dvi, "dvi-recursive");
 654
 655     $recursive_install = 1;
 656 }
 657
 658 # Handle remaking and configure stuff.
 659 sub handle_configure
 660 {
 661     if ($relative_dir ne '.')
 662     {
 663         # In subdirectory.
 664         $output_rules .= &file_contents ('remake-subd');
 665     }
 666     else
 667     {
 668         if (-f 'aclocal.m4')
 669         {
 670             $output_vars .= "ACLOCAL = aclocal.m4\n";
 671             push (@dist_common, 'aclocal.m4');
 672         }
 673         $output_rules .= &file_contents ('remake');
 674     }
 675
 676     if (defined ($configure{'CONFIG_HEADER'})
 677         && $contents{'CONFIG_HEADER'} !~ m,/,)
 678     {
 679         # Header defined and in this directory.
 680         if (-f 'acconfig.h')
 681         {
 682             $output_vars .= "ACCONFIG = acconfig.h\n";
 683             push (@dist_common, 'acconfig.h');
 684         }
 685         if (-f 'config.h.top')
 686         {
 687             $output_vars .= "CONFIG_TOP = config.h.top\n";
 688             push (@dist_common, 'config.h.top');
 689         }
 690         if (-f 'config.h.bot')
 691         {
 692             $output_vars .= "CONFIG_BOT = config.h.bot\n";
 693             push (@dist_common, 'config.h.bot');
 694         }
 695
 696         push (@dist_common, 'stamp-h.in', $contents{'CONFIG_HEADER'} . '.in');
 697
 698         $output_rules .= &file_contents ('remake-hdr');
 699     }
 700 }
 701
 702 # Handle footer elements.
 703 sub handle_footer
 704 {
 705     if ($contents{'SOURCES'})
 706     {
 707         $output_vars .= "SOURCES = " . $contents{'SOURCES'} . "\n";
 708     }
 709     if ($contents{'OBJECTS'})
 710     {
 711         $output_vars .= "OBJECTS = " . $contents{'OBJECTS'} . "\n";
 712     }
 713     if ($contents{'SOURCES'} || $contents{'OBJECTS'})
 714     {
 715         $output_vars .= "\n";
 716     }
 717
 718     $output_trailer .= ".SUFFIXES:\n";
 719     if ($#suffixes >= 0)
 720     {
 721         $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
 722     }
 723     $output_trailer .= "\n" . &file_contents ('footer');
 724 }
 725
 726 # There are several targets which need to be merged.  This is because
 727 # their complete definition is compiled from many parts.  Note that we
 728 # avoid double colon rules, otherwise we'd use them instead.
 729 sub handle_merge_targets
 730 {
 731     &do_one_merge_target ('all', @all);
 732     &do_one_merge_target ('info', @info);
 733     &do_one_merge_target ('dvi', @dvi);
 734     &do_one_merge_target ('check', @check);
 735
 736     # Handle the various install targets specially.  We do this so
 737     # that (eg) "make install-exec" will run "install-exec-recursive"
 738     # if required, but "make install" won't run it twice.  Step one is
 739     # to see if the user specified local versions of any of the
 740     # targets we handle.
 741     if (defined $contents{'install-exec-local'})
 742     {
 743         push (@install_exec, 'install-exec-local');
 744     }
 745     if (defined $contents{'install-data-local'})
 746     {
 747         push (@install_data, 'install-data-local');
 748     }
 749     if (defined $contents{'uninstall-local'})
 750     {
 751         push (@uninstall, 'uninstall-local');
 752     }
 753
 754     if (defined $contents{'install-local'})
 755     {
 756         print STDERR "automake: use \`install-data' or \`install-exec', not \`install'\n";
 757     }
 758
 759     # Step two: if we are doing recursive makes, write out the
 760     # appropriate rules.
 761     local (@install);
 762     if ($recursive_install)
 763     {
 764         push (@install, 'install-recursive');
 765         push (@uninstall, 'uninstall-recursive');
 766
 767         if ($#install_exec >= 0)
 768         {
 769             $output_rules .= ('install-exec-am: '
 770                               . join (' ', @install_exec)
 771                               . "\n\n");
 772             @install_exec = ('install-exec-recursive', 'install-exec-am');
 773             push (@install, 'install-exec-am');
 774         }
 775         if ($#install_data >= 0)
 776         {
 777             $output_rules .= ('install-data-am: '
 778                               . join (' ', @install_data)
 779                               . "\n\n");
 780             @install_data = ('install-data-recursive', 'install-data-am');
 781             push (@install, 'install-data-am');
 782         }
 783         if ($#uninstall >= 0)
 784         {
 785             $output_rules .= ('uninstall-am: '
 786                               . join (' ', @uninstall)
 787                               . "\n\n");
 788             @uninstall = ('uninstall-recursive', 'uninstall-am');
 789         }
 790     }
 791
 792     # Step three: print definitions users can use.
 793     if ($#install_exec >= 0)
 794     {
 795         $output_rules .= ("install-exec: "
 796                           . join (' ', @install_exec)
 797                           . "\n\n");
 798         push (@install, 'install-exec') if (!$recursive_install);
 799     }
 800     if ($#install_data >= 0)
 801     {
 802         $output_rules .= ("install-data: "
 803                           . join (' ', @install_data)
 804                           . "\n\n");
 805         push (@install, 'install-data') if (!$recursive_install);
 806     }
 807
 808     $output_rules .= ('install: '
 809                       . join (' ', @install)
 810                       . "\n\n"
 811                       . 'uninstall: '
 812                       . join (' ', @uninstall)
 813                       . "\n\n");
 814 }
 815
 816 # Helper for handle_merge_targets.
 817 sub do_one_merge_target
 818 {
 819     local ($name, @values) = @_;
 820
 821     if (defined $contents{$name . '-local'})
 822     {
 823         # User defined local form of target.  So include it.
 824         push (@values, $name . '-local');
 825     }
 826
 827     $output_rules .= $name . ": " . join (' ', @values) . "\n\n";
 828 }
 829
 830 ################################################################
 831
 832 # Read Makefile.am and set up %contents.  Simultaneously copy lines
 833 # from Makefile.am into $output_rules or $output_vars as appropriate.
 834 # NOTE we put rules in the trailer section.  We want user rules
 835 # to come after our generated stuff.
 836 sub read_am_file
 837 {
 838     local ($amfile) = @_;
 839
 840     if (! open (AMFILE, $amfile))
 841     {
 842         print STDERR "automake: couldn't open $amfile: $!\n";
 843         exit 1;
 844     }
 845
 846     local ($saw_bk) = 0;
 847     local ($was_rule) = 0;
 848     local ($last_var_name) = '';
 849
 850     while (<AMFILE>)
 851     {
 852         chop;
 853
 854         if ($saw_bk)
 855         {
 856             if ($was_rule)
 857             {
 858                 $output_trailer .= $_ . "\n";
 859             }
 860             else
 861             {
 862                 $output_vars .= $_ . "\n";
 863                 if (substr ($_, -1) eq "\\")
 864                 {
 865                     $contents{$last_var_name} .= substr ($_, 0,
 866                                                          length ($_) - 1);
 867                 }
 868                 else
 869                 {
 870                     $contents{$last_var_name} .= $_;
 871                 }
 872             }
 873         }
 874         elsif ($_ eq '@kr@')
 875         {
 876             # Special case: this means we want automatic
 877             # de-ANSI-fication.  FIXME think of a better way.
 878             $contents{'@kr@'} = 1;
 879         }
 880         elsif (m/^ *([a-zA-Z_.][a-zA-Z0-9_.]*) *:/)
 881         {
 882             # Found a rule.
 883             $was_rule = 1;
 884             # Value here doesn't matter; for targets we only note
 885             # existence.
 886             $contents{$1} = 1;
 887             $output_trailer .= $_ . "\n";
 888         }
 889         elsif (m/^ *([A-Za-z][A-Za-z0-9_]*)[    ]*=[    ]*(.*)$/)
 890         {
 891             # Found a variable reference.
 892             $was_rule = 0;
 893             $last_var_name = $1;
 894             if (substr ($2, -1) eq "\\")
 895             {
 896                 $contents{$1} = substr ($2, 0, length ($2) - 1);
 897             }
 898             else
 899             {
 900                 $contents{$1} = $2;
 901             }
 902             $output_vars .= $_ . "\n";
 903         }
 904         elsif (m/^$/)
 905         {
 906             # Special rule: if looking at a blank line, append it to
 907             # whatever we saw last.
 908             if ($was_rule)
 909             {
 910                 $output_trailer .= "\n";
 911             }
 912             else
 913             {
 914                 $output_vars .= "\n";
 915             }
 916         }
 917         else
 918         {
 919             # This isn't an error; it is probably a continued rule.
 920             # In fact, this is what we assume.
 921             $output_trailer .= $_ . "\n";
 922         }
 923
 924         $saw_bk = (substr ($_, -1) eq "\\");
 925     }
 926
 927     # Include some space after user code.
 928     $output_vars .= "\n";
 929     $output_trailer .= "\n";
 930 }
 931
 932
 933 ################################################################
 934
 935 # Return contents of a file from $am_dir.
 936 sub file_contents
 937 {
 938     local ($basename) = @_;
 939     local ($file) = $am_dir . '/' . $basename . '.am';
 940
 941     if (! open (FC_FILE, $file))
 942     {
 943         print STDERR "automake: installation error: cannot open \"$file\"\n";
 944         exit 1;
 945     }
 946
 947     # Yes, we really want to slurp it.
 948     local ($results) = join ('', <FC_FILE>);
 949
 950     close (FC_FILE);
 951
 952     return $results;
 953 }
 954
 955 ################################################################
 956
 957 # Verify that the file must exist in the current directory.
 958 sub require_file
 959 {
 960     local ($file) = @_;
 961     local ($fullfile) = $relative_dir . "/" . $file;
 962
 963     if (! -f $fullfile)
 964     {
 965         print STDERR "automake: required file \"$fullfile\" not found\n";
 966         $exit_status = 1;
 967     }
 968     else
 969     {
 970         push (@dist_common, $file);
 971     }
 972 }
 973
 974
 975 ################################################################
 976
 977 # Return directory name of file.
 978 sub dirname
 979 {
 980     local ($file) = @_;
 981     local ($sub);
 982
 983     ($sub = $file) =~ s,/+[^/]+,,g;
 984     if ($sub eq $file)
 985     {
 986         $sub = '.';
 987     }
 988
 989     return $sub;
 990 }
 991
 992 ################################################################
 993
 994 # Print usage information.
 995 sub usage
 996 {
 997     print "Usage: automake [OPTION] ... [Makefile]...\n";
 998     print $USAGE;
 999     print "\nFiles which are automatically distributed, if found:\n";
1000     $~ = "USAGE_FORMAT";
1001     local (@lcomm) = sort ((@common_files, @common_sometimes));
1002     local ($one, $two);
1003     while ($#lcomm >= 0)
1004     {
1005         $one = shift (@lcomm);
1006         $two = shift (@lcomm);
1007         write;
1008     }
1009
1010     exit 0;
1011 }
1012
1013 format USAGE_FORMAT =
1014   @<<<<<<<<<<<<<<<<    @<<<<<<<<<<<<<<<<
1015   $one,                $two
1016 .