automake.in

   1 #!@PERL@
   2 # -*- perl -*-
   3 # @configure_input@
   4
   5 eval "exec /usr/local/bin/perl -S $0 $*"
   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., 675 Mass Ave, Cambridge, MA 02139, USA.
  24
  25 # Originally written by David Mackenzie <djm@gnu.ai.mit.edu>.
  26 # Perl reimplementation by Tom Tromey <tromey@drip.colorado.edu>.
  27
  28
  29 # Parameters set by configure.  Not to be changed.
  30 $PACKAGE = "@PACKAGE@";
  31 $VERSION = "@VERSION@";
  32 $prefix = "@prefix@";
  33 $am_dir = "@datadir@/@PACKAGE@";
  34
  35 \f
  36
  37 # This is TRUE if GNU make specific automatic dependency generation
  38 # code should be included in generated Makefile.in.
  39 $use_dependencies = 1;
  40
  41 # This holds our (eventual) exit status.  We don't actually exit until
  42 # we have processed all input files.
  43 $exit_status = 0;
  44
  45 # These two variables are used when generating each Makefile.in.  They
  46 # hold the Makefile.in until it is ready to be printed.
  47 $output_rules = '';
  48 $output_vars = '';
  49 $output_trailer = '';
  50
  51 # Suffixes found during a run.
  52 @suffixes = ();
  53
  54 # This holds the contents of a Makefile.am, as parsed by read_am_file.
  55 %contents = ();
  56
  57 # This holds the "relative directory" of the current Makefile.in.  Eg
  58 # for src/Makefile.in, this is "src".
  59 $relative_dir = '';
  60
  61 # Directory where output files go.  Actually, output files are
  62 # relative to this directory.
  63 $output_directory = '.';
  64
  65 # This holds a list of files that are included in the distribution.
  66 @dist_common = ();
  67
  68 # List of dependencies for the obvious targets.
  69 @install_data = ();
  70 @install_exec = ();
  71 @uninstall = ();
  72 @installdirs = ();
  73
  74 @info = ();
  75 @dvi = ();
  76 @all = ('${ALL}');
  77 @check = ();
  78 @clean = ();
  79
  80 # TRUE if current directory holds any C source files.
  81 $dir_holds_sources = 0;
  82
  83 # TRUE if install targets should work recursively.
  84 $recursive_install = 0;
  85
  86 \f
  87
  88 &init_globals;
  89
  90 # Parse command line.
  91 @input_files = &parse_arguments (@ARGV);
  92
  93 # Now do all the work on each file.
  94 foreach $am_file (@input_files)
  95 {
  96     if (! -f ($am_file . '.am'))
  97     {
  98         print STDERR "automake: $am_file" . ".am: no such file\n";
  99         $exit_status = 1;
 100     }
 101     else
 102     {
 103         &generate_makefile ($am_file);
 104     }
 105 }
 106
 107 exit $exit_status;
 108
 109
 110 ################################################################
 111
 112 # Parse command line.
 113 sub parse_arguments
 114 {
 115     local (@arglist) = @_;
 116     local (@make_list);
 117
 118     while ($#arglist >= 0)
 119     {
 120         if ($arglist[0] eq "--version")
 121         {
 122             print "Automake version $VERSION\n";
 123             exit 0;
 124         }
 125         elsif ($arglist[0] eq "--help")
 126         {
 127             &usage;
 128         }
 129         elsif ($arglist[0] =~ /^--amdir=(.+)$/)
 130         {
 131             $am_dir = $1;
 132         }
 133         elsif ($arglist[0] eq '--amdir')
 134         {
 135             if ($#arglist == 0)
 136             {
 137                 print STDERR
 138                     "automake: no argument given for option \`$arglist[0]'\n";
 139                 exit 1;
 140             }
 141             shift (@arglist);
 142             $am_dir = $arglist[0];
 143         }
 144         elsif ($arglist[0] eq '--include-deps')
 145         {
 146             $use_dependencies = 0;
 147         }
 148         elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
 149         {
 150             # Set output directory.
 151             $output_directory = $1;
 152         }
 153         elsif ($arglist[0] eq '--output-dir')
 154         {
 155             if ($#arglist == 0)
 156             {
 157                 print STDERR
 158                     "automake: no argument given for option \`$arglist[0]'\n";
 159                 exit 1;
 160             }
 161             shift (@arglist);
 162             $output_directory = $arglist[0];
 163         }
 164         elsif ($arglist[0] eq '--')
 165         {
 166             # Stop option processing.
 167             shift (@arglist);
 168             push (@make_list, @arglist);
 169             last;
 170         }
 171         elsif ($arglist[0] =~ /^-/)
 172         {
 173             print STDERR "automake: unrecognized option -- \`$arglist[0]'\n";
 174             exit 1;
 175         }
 176         else
 177         {
 178             push (@make_list, $arglist[0]);
 179         }
 180
 181         shift (@arglist);
 182     }
 183
 184     if ($#make_list < 0)
 185     {
 186         # Look around for some files.
 187         push (@make_list, 'Makefile') if -f 'Makefile.am';
 188
 189         foreach (<*/Makefile.am>)
 190         {
 191             s/\.am$//;
 192             push (@make_list, $_);
 193         }
 194
 195         if ($#make_list >= 0)
 196         {
 197             print "automake: using ", join (' ', @make_list), "\n";
 198         }
 199         else
 200         {
 201             print STDERR "automake: no \"Makefile.am\" found or specified\n";
 202             exit 1;
 203         }
 204     }
 205
 206     return (@make_list);
 207 }
 208
 209 ################################################################
 210
 211 # Generate a Makefile.in given the name of the corresponding Makefile.
 212 sub generate_makefile
 213 {
 214     local ($makefile) = @_;
 215
 216     print "creating ", $makefile, ".in\n";
 217
 218     $relative_dir = &dirname ($makefile);
 219     $output_rules = '';
 220     $output_vars = '';
 221     $output_trailer = '';
 222     @suffixes = ();
 223     %contents = ();
 224     # FIXME with new 'dist' target, don't need Makefile.in.  Probably
 225     # should remove it here.
 226     @dist_common = ('Makefile.in', 'Makefile.am');
 227     @install_data = ();
 228     @install_exec = ();
 229     @uninstall = ();
 230     @installdirs = ();
 231     $dir_holds_sources = 0;
 232     $recursive_install = 0;
 233     @info = ();
 234     @dvi = ();
 235     @all = ('${ALL}');
 236     @check = ();
 237     @clean = ();
 238
 239     # Generate header before reading .am file.  The header must come
 240     # before anything else, and read_am_file copies code into the
 241     # output.
 242     &generate_header;
 243
 244     # This is always the default target.  This gives us freedom to do
 245     # things in whatever order is convenient.
 246     $output_rules .= "default: all\n\n";
 247
 248     &read_am_file ($makefile . '.am');
 249
 250     # Program stuff.
 251     local ($programs) = &am_variable ('PROGRAMS');
 252     local ($libprograms) = &am_variable ('AM_LIBPROGRAMS');
 253     local ($libraries) = &am_variable ('AM_LIBRARIES');
 254     local ($scripts) = &am_variable ('AM_SCRIPTS');
 255     local ($libscripts) = &am_variable ('AM_LIBSCRIPTS');
 256
 257     &handle_programs ($programs, $libprograms, $libraries);
 258     &handle_scripts ($scripts, $libscripts);
 259     &handle_libraries ($libraries);
 260
 261     &handle_texinfo;
 262     &handle_man_pages;
 263     &handle_data;
 264     &handle_subdirs;
 265     &handle_configure;
 266     &handle_tags;
 267     &handle_dist;
 268     &handle_dependencies;
 269     &handle_footer;
 270     &handle_merge_targets;
 271     &handle_installdirs;
 272     &handle_clean;
 273
 274     if (! -d ($output_directory . '/' . $relative_dir))
 275     {
 276         &mkdir ($output_directory . '/' . $relative_dir);
 277     }
 278     if (! open (GM_FILE, "> " . $output_directory . '/' . $makefile . ".in"))
 279     {
 280         print STDERR "automake: cannot open ", $makefile, ".in: ", $!, "\n";
 281         $exit_status = 1;
 282         return;
 283     }
 284
 285     print GM_FILE $output_vars;
 286     print GM_FILE $output_rules;
 287     print GM_FILE $output_trailer;
 288
 289     close (GM_FILE);
 290 }
 291
 292 ################################################################
 293
 294 # Generate header of Makefile.in.
 295 sub generate_header
 296 {
 297     $output_vars =
 298         ($output_vars
 299          . "# Makefile.in generated automatically by automake "
 300          . $VERSION
 301          . " from Makefile.am\n");
 302
 303     $output_vars = $output_vars . &file_contents ('header-vars');
 304 }
 305
 306 # Handle C programs and libraries.
 307 sub handle_programs
 308 {
 309     local ($programs, $libprograms, $libraries) = @_;
 310
 311     if (!$programs && !$libprograms && !$libraries)
 312     {
 313         # None exist.
 314         return;
 315     }
 316     $dir_holds_sources = 1;
 317
 318     # Boilerplate.
 319     $output_vars .= &file_contents ('compile-vars');
 320     $output_rules .= &file_contents ('compile');
 321
 322     # Check for automatic de-ANSI-fication.
 323     local ($obj) = '.o';
 324     push (@suffixes, '.c', '.o');
 325     push (@clean, 'compile');
 326
 327     if (defined $contents{'@kr@'})
 328     {
 329         $obj = '.${kr}o';
 330         push (@suffixes, '._c', '._o');
 331
 332         &require_file ('ansi2knr.c');
 333         &require_file ('ansi2knr.1');
 334
 335         $output_vars .= &file_contents ('kr-vars');
 336         $output_rules .= &file_contents ('compile-kr');
 337         $output_rules .= &file_contents ('clean-kr');
 338
 339         push (@clean, 'kr');
 340     }
 341
 342     local (@sources, @objects);
 343     push (@sources, '${SOURCES}') if (defined $contents{'SOURCES'});
 344     push (@objects, '${OBJECTS}') if (defined $contents{'OBJECTS'});
 345
 346     local ($one_file);
 347     foreach $one_file (split (' ', ($programs . ' '
 348                                     . $libprograms . ' '
 349                                     . $libraries)))
 350     {
 351         # Look for file_SOURCES and file_OBJECTS.  FIXME file_OBJECTS
 352         # should probably not be used(?)
 353         if (defined $contents{$one_file . "_SOURCES"})
 354         {
 355             if (! defined $contents{$one_file . "_OBJECTS"})
 356             {
 357                 # Turn sources into objects.
 358                 $_ = $contents{$one_file . "_SOURCES"};
 359
 360                 # Ugh: Perl syntax vs Emacs.
 361                 local ($krc1, $krc2) = ('\.\$\{kr\}c', '\.\$\(kr\)c');
 362
 363                 s/\.cc/$obj/g;
 364                 s/$krc1/$obj/g;
 365                 s/$krc2/$obj/g;
 366                 s/\.[cCmylfs]/$obj/g;
 367
 368                 $output_vars .= $one_file . "_OBJECTS = " . $_ . "\n";
 369             }
 370
 371             push (@sources, '${' . $one_file . "_SOURCES}");
 372             push (@objects, '${' . $one_file . "_OBJECTS}");
 373         }
 374         else
 375         {
 376             $output_vars .= ($one_file . "_SOURCES = " . $one_file . ".c\n"
 377                              . $one_file . "_OBJECTS = ". $one_file
 378                              . $obj . "\n");
 379             push (@sources, $one_file . '.c');
 380             push (@objects, $one_file . $obj);
 381         }
 382
 383         if (defined $contents{'CONFIG_HEADER'})
 384         {
 385             $output_rules .= ('$(' . $one_file . "_OBJECTS): "
 386                               . $contents{'CONFIG_HEADER'} . "\n");
 387         }
 388     }
 389
 390     $output_vars .= "\n";
 391
 392     # Re-init SOURCES and OBJECTS.  FIXME other code shouldn't depend
 393     # on this.
 394     $contents{'SOURCES'} = join (' ', @sources);
 395     $contents{'OBJECTS'} = join (' ', @objects);
 396
 397     # Some boilerplate, and install rules.
 398     if ($programs)
 399     {
 400         $output_rules .= &file_contents ('programs');
 401         push (@install_exec, "install-programs");
 402         push (@uninstall, 'uninstall-programs');
 403         push (@clean, 'programs');
 404         push (@installdirs, '$(bindir)');
 405     }
 406     if ($libprograms)
 407     {
 408         $output_rules .= &file_contents ('libprograms');
 409         push (@install_exec, 'install-libprograms');
 410         push (@uninstall, 'uninstall-libprograms');
 411         push (@clean, 'libprograms');
 412         push (@installdirs, '$(libexecdir)');
 413     }
 414
 415     # Handle linking.
 416     if ($programs || $libprograms)
 417     {
 418         local ($fcont) = &file_contents ('program');
 419         local ($munge);
 420         foreach $one_file (split (' ', $programs . ' ' . $libprograms))
 421         {
 422             if (! defined $contents{$one_file . "_LDADD"})
 423             {
 424                 # User didn't define prog_LDADD override.  So do it.
 425                 $output_vars .= $one_file . '_LDADD = ${LDADD}' . "\n";
 426             }
 427
 428             ($munge = $fcont) =~ s/\@PROGRAM\@/$one_file/g;
 429             $output_rules .= $munge;
 430         }
 431     }
 432 }
 433
 434 # Handle libraries.
 435 sub handle_libraries
 436 {
 437     local ($libraries) = @_;
 438
 439     return if (!$libraries);
 440
 441     local (@liblist) = split (' ', $libraries);
 442
 443     $output_rules .= &file_contents ('libraries');
 444     local ($onefile) = &file_contents ('library');
 445     local ($onelib, $munge);
 446     foreach $onelib (@liblist)
 447     {
 448         if (! defined $contents{$onelib . '_LIBADD'})
 449         {
 450             # Generate support for conditional objection inclusion in
 451             # libraries.
 452             $output_vars .= $onelib . "_LIBADD =\n";
 453         }
 454
 455         ($munge = $onefile) =~ s/\@LIBRARY\@/$onelib/g;
 456         $output_rules .= $munge;
 457     }
 458
 459     # Turn "foo" into "libfoo.a" and include macro definition.
 460     grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
 461     $output_vars .= ("LIBFILES = " . join (' ', @liblist) . "\n\n"
 462                      . &file_contents ('libraries-vars'));
 463
 464     push (@install_exec, 'install-libraries');
 465     push (@uninstall, 'uninstall-libraries');
 466     push (@clean, 'libraries');
 467 }
 468
 469 # Handle scripts.
 470 sub handle_scripts
 471 {
 472     local ($scripts, $libscripts) = @_;
 473
 474     if ($scripts)
 475     {
 476         $output_rules .= &file_contents ('scripts');
 477         push (@install_exec, 'install-scripts');
 478         push (@uninstall, 'uninstall-scripts');
 479         push (@clean, 'scripts');
 480         push (@installdirs, '$(bindir)');
 481     }
 482
 483     if ($libscripts)
 484     {
 485         $output_rules .= &file_contents ('libscripts');
 486         push (@install_exec, 'install-libscripts');
 487         push (@uninstall, 'uninstall-libscripts');
 488         push (@clean, 'libscripts');
 489         push (@installdirs, '$(libexecdir');
 490     }
 491 }
 492
 493 # Handle all Texinfo source.
 494 sub handle_texinfo
 495 {
 496     local ($texis) = &am_variable ('TEXINFOS');
 497     return if (!$texis);
 498
 499     local (@texis) = split (' ', $texis);
 500     if ($#texis > 0)
 501     {
 502         print STDERR "automake: sorry, only one file allowed in \`TEXINFOS'\n";
 503         $exit_status = 1;
 504         return;
 505     }
 506
 507     local ($infobase);
 508     ($infobase = $texis[0]) =~ s/\.texi$//;
 509
 510     # If 'version.texi' is referenced by input file, then include
 511     # automatic versioning capability.
 512     system ("grep version.texi " . $relative_dir . "/" . $texis[0]
 513             . " > /dev/null 2>&1");
 514     if (!$?)
 515     {
 516         # Got a hit.
 517         push (@texis, 'version.texi');
 518         push (@dist_common, 'version.texi', 'stamp-vti');
 519         push (@clean, 'vti');
 520
 521         local ($tfile);
 522         ($tfile = &file_contents ('texi-version')) =~ s/\@TEXI\@/$texis[0]/g;
 523         $output_rules = $output_rules . $tfile;
 524
 525         &require_file ('mdate-sh');
 526     }
 527
 528     # If user specified file_TEXINFOS, then use that as explicit
 529     # dependency list.
 530     if (defined $contents{$infobase . "_TEXINFOS"})
 531     {
 532         push (@texis, "\$" . $infobase . '_TEXINFOS');
 533         push (@dist_common, "\$" . $infobase . '_TEXINFOS');
 534     }
 535
 536     if ($#texis >= 0)
 537     {
 538         $output_rules = ($output_rules . $infobase . ".info: "
 539                          . join (' ', @texis) . "\n\n");
 540     }
 541
 542     # Some boilerplate.
 543     $output_vars = $output_vars . &file_contents ('texinfos-vars');
 544     $output_rules = $output_rules . &file_contents ('texinfos');
 545
 546     push (@suffixes, '.texi', '.info', '.dvi');
 547     push (@uninstall, 'uninstall-info');
 548     push (@clean, 'info');
 549     push (@info, '$(INFO_DEPS)');
 550     push (@dvi, '$(DVIS)');
 551     push (@installdirs, '$(infodir)');
 552     # Make sure documentation is made and installed first.
 553     unshift (@install_data, 'install-info');
 554     unshift (@all, 'info');
 555
 556     $output_vars .= ("INFOS = " . $infobase . ".info*\n"
 557                      . "INFO_DEPS = " . $infobase . ".info\n"
 558                      . "DVIS = " . $infobase . ".dvi\n\n");
 559
 560     # Do some error checking.
 561     &require_file ('texinfo.tex');
 562 }
 563
 564 # Handle any man pages.
 565 sub handle_man_pages
 566 {
 567     return if (! defined $contents{'MANS'});
 568
 569     # We generate the manpage install code by hand to avoid the use of
 570     # basename in the generated Makefile.
 571     local (@mans) = split (' ', $contents{'MANS'});
 572     local (%sections, %inames, %secmap, %fullsecmap);
 573     foreach (@mans)
 574     {
 575         m/^(.*)\.([0-9])([a-z]*)$/;
 576         $sections{$2} = 1;
 577         $inames{$1} = $_;
 578         $secmap{$1} = $2;
 579         $fullsecmap{$1} = $2 . $3;
 580     }
 581
 582     # Generate list of install dirs.
 583     $output_rules .= "install-man:\n";
 584     foreach (keys %sections)
 585     {
 586         push (@installdirs, '$(mandir)/man' . $_);
 587         $output_rules .= ("\t" . '$(top_srcdir)/mkinstalldirs $(mandir)/man'
 588                           . $_ . "\n");
 589     }
 590
 591     # Generate install target.
 592     local ($key);
 593     foreach $key (keys %inames)
 594     {
 595         $_ = $install_man_format;
 596         s/\@SECTION\@/$secmap{$key}/g;
 597         s/\@MAN\@/$inames{$key}/g;
 598         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 599         s/\@MANBASE\@/$key/g;
 600         $output_rules .= $_;
 601     }
 602     $output_rules .= "\n";
 603
 604     $output_rules .= "uninstall-man:\n";
 605     foreach $key (keys %inames)
 606     {
 607         $_ = $uninstall_man_format;
 608         s/\@SECTION\@/$secmap{$key}/g;
 609         s/\@MAN\@/$inames{$key}/g;
 610         s/\@FULLSECT\@/$fullsecmap{$key}/g;
 611         s/\@MANBASE\@/$key/g;
 612         $output_rules .= $_;
 613     }
 614     $output_rules .= "\n";
 615
 616     $output_vars .= &file_contents ('mans-vars');
 617
 618     push (@install_data, 'install-man');
 619     push (@uninstall, 'uninstall-man');
 620     push (@all, '$(MANS)');
 621 }
 622
 623 # Handle DATA and PACKAGEDATA.
 624 sub handle_data
 625 {
 626     if (defined $contents{'DATA'})
 627     {
 628         $output_rules .= &file_contents ('data');
 629         push (@install_data, 'install-ddata');
 630         push (@uninstall, 'uninstall-ddata');
 631         push (@installdirs, '$(datadir)');
 632     }
 633
 634     if (defined $contents{'PACKAGEDATA'})
 635     {
 636         $output_rules .= &file_contents ('packagedata');
 637         push (@install_data, 'install-pdata');
 638         push (@uninstall, 'uninstall-pdata');
 639         push (@installdirs, '$(datadir)/$(PACKAGE)');
 640     }
 641 }
 642
 643 # Handle TAGS.
 644 sub handle_tags
 645 {
 646     local ($tagging) = 0;
 647
 648     if (defined ($contents{'SUBDIRS'}))
 649     {
 650         $output_rules .= &file_contents ('tags');
 651         $tagging = 1;
 652     }
 653     elsif ($dir_holds_sources || defined ($contents{'ETAGS_ARGS'}))
 654     {
 655         $output_rules .= &file_contents ('tags-subd');
 656         $tagging = 1;
 657     }
 658
 659     if ($tagging)
 660     {
 661         $output_rules .= &file_contents ('tags-clean');
 662         push (@clean, 'tags');
 663     }
 664 }
 665
 666 # Handle 'dist' target.
 667 sub handle_dist
 668 {
 669     # Look for common files that should be included in distribution.
 670     local ($cfile);
 671     foreach $cfile (@common_files)
 672     {
 673         if (-f ($relative_dir . "/" . $cfile))
 674         {
 675             push (@dist_common, $cfile);
 676         }
 677     }
 678
 679     $output_vars .= "DIST_COMMON = " . join (' ', @dist_common) . "\n\n";
 680
 681     # Some boilerplate.
 682     $output_vars .= &file_contents ('dist-vars');
 683     if ($relative_dir ne '.')
 684     {
 685         # In a subdirectory.
 686         $output_vars .= "subdir = " . $relative_dir . "\n\n";
 687         $output_rules .= &file_contents ('dist-subd');
 688     }
 689     else
 690     {
 691         $output_rules .= &file_contents (defined ($contents{'SUBDIRS'})
 692                                          ? 'dist-subd-top'
 693                                          : 'dist');
 694     }
 695 }
 696
 697 # Handle auto-dependency code.
 698 sub handle_dependencies
 699 {
 700     if ($use_dependencies)
 701     {
 702         # Include GNU-make-specific auto-dep code.
 703         if ($dir_holds_sources)
 704         {
 705             $output_rules .= &file_contents ('depend');
 706         }
 707     }
 708     else
 709     {
 710         # Include any auto-generated deps that are present.
 711         if (-d ($relative_dir . "/.deps") && -f ($relative_dir . "/.deps/.P"))
 712         {
 713             local ($depfile);
 714             local ($gpat) = $relative_dir . "/.deps/*.P";
 715
 716             foreach $depfile (<${gpat}>)
 717             {
 718                 if (! open (DEP_FILE, $depfile))
 719                 {
 720                     print STDERR "automake: couldn't open $depfile: $!\n";
 721                     next;
 722                 }
 723
 724                 # Slurp entire file.
 725                 $output_rules .= join ('', <DEP_FILE>);
 726
 727                 close (DEP_FILE);
 728             }
 729
 730             $output_rules .= "\n";
 731         }
 732     }
 733 }
 734
 735 # Handle subdirectories.
 736 sub handle_subdirs
 737 {
 738     return if (! defined ($contents{'SUBDIRS'}));
 739
 740     $output_rules .= &file_contents ('subdirs');
 741
 742     push (@all, "all-recursive");
 743     push (@check, "check-recursive");
 744     push (@info, "info-recursive");
 745     push (@dvi, "dvi-recursive");
 746
 747     $recursive_install = 1;
 748 }
 749
 750 # Handle remaking and configure stuff.
 751 sub handle_configure
 752 {
 753     if ($relative_dir ne '.')
 754     {
 755         # In subdirectory.
 756         $output_rules .= &file_contents ('remake-subd');
 757     }
 758     else
 759     {
 760         if (-f 'aclocal.m4')
 761         {
 762             $output_vars .= "ACLOCAL = aclocal.m4\n";
 763             push (@dist_common, 'aclocal.m4');
 764         }
 765         $output_rules .= &file_contents ('remake');
 766
 767         # Look for some files we need.
 768         &require_file ('install-sh');
 769         &require_file ('mkinstalldirs');
 770     }
 771
 772     if (defined ($contents{'CONFIG_HEADER'})
 773         && $contents{'CONFIG_HEADER'} !~ m,/,)
 774     {
 775         # Header defined and in this directory.
 776         if (-f 'acconfig.h')
 777         {
 778             $output_vars .= "ACCONFIG = acconfig.h\n";
 779             push (@dist_common, 'acconfig.h');
 780         }
 781         if (-f 'config.h.top')
 782         {
 783             $output_vars .= "CONFIG_TOP = config.h.top\n";
 784             push (@dist_common, 'config.h.top');
 785         }
 786         if (-f 'config.h.bot')
 787         {
 788             $output_vars .= "CONFIG_BOT = config.h.bot\n";
 789             push (@dist_common, 'config.h.bot');
 790         }
 791
 792         push (@dist_common, 'stamp-h.in', $contents{'CONFIG_HEADER'} . '.in');
 793
 794         $output_rules .= &file_contents ('remake-hdr');
 795     }
 796 }
 797
 798 # Handle footer elements.
 799 sub handle_footer
 800 {
 801     if ($contents{'SOURCES'})
 802     {
 803         $output_vars .= "SOURCES = " . $contents{'SOURCES'} . "\n";
 804     }
 805     if ($contents{'OBJECTS'})
 806     {
 807         $output_vars .= "OBJECTS = " . $contents{'OBJECTS'} . "\n";
 808     }
 809     if ($contents{'SOURCES'} || $contents{'OBJECTS'})
 810     {
 811         $output_vars .= "\n";
 812     }
 813
 814     if (defined $contents{'SUFFIXES'})
 815     {
 816         push (@suffixes, '$(SUFFIXES)');
 817     }
 818
 819     $output_trailer .= ".SUFFIXES:\n";
 820     if ($#suffixes >= 0)
 821     {
 822         $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
 823     }
 824     $output_trailer .= "\n" . &file_contents ('footer');
 825 }
 826
 827 # Deal with installdirs target.
 828 sub handle_installdirs
 829 {
 830     # GNU Makefile standards recommend this.  FIXME prettyprint rule
 831     # here.
 832     $output_rules .= ("installdirs:"
 833                       . ($recursive_install
 834                          ? " installdirs-recursive\n"
 835                          : "\n"));
 836     if ($#installdirs >= 0)
 837     {
 838         $output_rules .= ("\t\$(top_srcdir)/mkinstalldirs "
 839                           . join (' ', @installdirs)
 840                           . "\n");
 841     }
 842     $output_rules .= "\n";
 843 }
 844
 845 # There are several targets which need to be merged.  This is because
 846 # their complete definition is compiled from many parts.  Note that we
 847 # avoid double colon rules, otherwise we'd use them instead.
 848 sub handle_merge_targets
 849 {
 850     &do_one_merge_target ('all', @all);
 851     &do_one_merge_target ('info', @info);
 852     &do_one_merge_target ('dvi', @dvi);
 853     &do_one_merge_target ('check', @check);
 854
 855     # Handle the various install targets specially.  We do this so
 856     # that (eg) "make install-exec" will run "install-exec-recursive"
 857     # if required, but "make install" won't run it twice.  Step one is
 858     # to see if the user specified local versions of any of the
 859     # targets we handle.
 860     if (defined $contents{'install-exec-local'})
 861     {
 862         push (@install_exec, 'install-exec-local');
 863     }
 864     if (defined $contents{'install-data-local'})
 865     {
 866         push (@install_data, 'install-data-local');
 867     }
 868     if (defined $contents{'uninstall-local'})
 869     {
 870         push (@uninstall, 'uninstall-local');
 871     }
 872
 873     if (defined $contents{'install-local'})
 874     {
 875         print STDERR "automake: use \`install-data' or \`install-exec', not \`install'\n";
 876     }
 877
 878     # Step two: if we are doing recursive makes, write out the
 879     # appropriate rules.
 880     local (@install);
 881     if ($recursive_install)
 882     {
 883         push (@install, 'install-recursive');
 884         push (@uninstall, 'uninstall-recursive');
 885
 886         if ($#install_exec >= 0)
 887         {
 888             $output_rules .= ('install-exec-am: '
 889                               . join (' ', @install_exec)
 890                               . "\n\n");
 891             @install_exec = ('install-exec-recursive', 'install-exec-am');
 892             push (@install, 'install-exec-am');
 893         }
 894         if ($#install_data >= 0)
 895         {
 896             $output_rules .= ('install-data-am: '
 897                               . join (' ', @install_data)
 898                               . "\n\n");
 899             @install_data = ('install-data-recursive', 'install-data-am');
 900             push (@install, 'install-data-am');
 901         }
 902         if ($#uninstall >= 0)
 903         {
 904             $output_rules .= ('uninstall-am: '
 905                               . join (' ', @uninstall)
 906                               . "\n\n");
 907             @uninstall = ('uninstall-recursive', 'uninstall-am');
 908         }
 909     }
 910
 911     # Step three: print definitions users can use.
 912     if ($#install_exec >= 0)
 913     {
 914         $output_rules .= ("install-exec: "
 915                           . join (' ', @install_exec)
 916                           . "\n\n");
 917         push (@install, 'install-exec') if (!$recursive_install);
 918     }
 919     if ($#install_data >= 0)
 920     {
 921         $output_rules .= ("install-data: "
 922                           . join (' ', @install_data)
 923                           . "\n\n");
 924         push (@install, 'install-data') if (!$recursive_install);
 925     }
 926
 927     $output_rules .= ('install: '
 928                       . join (' ', @install)
 929                       . "\n\n"
 930                       . 'uninstall: '
 931                       . join (' ', @uninstall)
 932                       . "\n\n");
 933 }
 934
 935 # Helper for handle_merge_targets.
 936 sub do_one_merge_target
 937 {
 938     local ($name, @values) = @_;
 939
 940     if (defined $contents{$name . '-local'})
 941     {
 942         # User defined local form of target.  So include it.
 943         push (@values, $name . '-local');
 944     }
 945
 946     $output_rules .= $name . ": " . join (' ', @values) . "\n\n";
 947 }
 948
 949 # Handle all 'clean' targets.
 950 sub handle_clean
 951 {
 952     push (@clean, 'generic');
 953     $output_rules .= &file_contents ('clean');
 954
 955     local ($target) = $recursive_install ? 'clean-am' : 'clean';
 956     &do_one_clean_target ($target, 'mostly', '', @clean);
 957     &do_one_clean_target ($target, '', 'mostly', @clean);
 958     &do_one_clean_target ($target, 'dist', '', @clean);
 959     &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
 960
 961     local (@deps);
 962     if ($recursive_install)
 963     {
 964         @deps = ('am', 'recursive');
 965         &do_one_clean_target ('', 'mostly', '', @deps);
 966         &do_one_clean_target ('', '', '', @deps);
 967         &do_one_clean_target ('', 'dist', '', @deps);
 968         &do_one_clean_target ('', 'maintainer-', '', @deps);
 969     }
 970 }
 971
 972 # Helper for handle_clean.
 973 sub do_one_clean_target
 974 {
 975     local ($target, $name, $last_name, @deps) = @_;
 976
 977     # Special case: if target not passed, then don't generate
 978     # dependency on next "lower" clean target (eg no
 979     # clean<-mostlyclean derivation).  In this case the target is
 980     # implicitly known to be 'clean'.
 981     local ($flag) = $target;
 982     if (!$flag)
 983     {
 984         $target = 'clean';
 985     }
 986
 987     $output_rules .= $name . $target . ": ";
 988     if ($flag)
 989     {
 990         if ($last_name || $name ne 'mostly')
 991         {
 992             $output_rules .= $last_name . $target . " ";
 993         }
 994     }
 995
 996     $output_rules .= ($name . 'clean-' . join (' ' . $name . 'clean-', @deps)
 997                       . "\n");
 998
 999     # FIXME shouldn't we really print these messages before running
1000     # the dependencies?
1001     if ($name . $target eq 'maintainer-clean')
1002     {
1003         # Print a special warning.
1004         $output_rules .=
1005             ("\t\@echo \"This command is intended for maintainers to use;\"\n"
1006              . "\t\@echo \"it deletes files that may require special "
1007              . "tools to rebuild.\"\n");
1008     }
1009     $output_rules .= "\n";
1010 }
1011
1012 ################################################################
1013
1014 # Read Makefile.am and set up %contents.  Simultaneously copy lines
1015 # from Makefile.am into $output_trailer or $output_vars as
1016 # appropriate.  NOTE we put rules in the trailer section.  We want
1017 # user rules to come after our generated stuff.
1018 sub read_am_file
1019 {
1020     local ($amfile) = @_;
1021
1022     if (! open (AMFILE, $amfile))
1023     {
1024         print STDERR "automake: couldn't open $amfile: $!\n";
1025         exit 1;
1026     }
1027
1028     local ($saw_bk) = 0;
1029     local ($was_rule) = 0;
1030     local ($last_var_name) = '';
1031
1032     while (<AMFILE>)
1033     {
1034         chop;
1035
1036         if ($saw_bk)
1037         {
1038             if ($was_rule)
1039             {
1040                 $output_trailer .= $_ . "\n";
1041             }
1042             else
1043             {
1044                 $output_vars .= $_ . "\n";
1045                 if (substr ($_, -1) eq "\\")
1046                 {
1047                     $contents{$last_var_name} .= substr ($_, 0,
1048                                                          length ($_) - 1);
1049                 }
1050                 else
1051                 {
1052                     $contents{$last_var_name} .= $_;
1053                 }
1054             }
1055         }
1056         elsif ($_ eq '@kr@')
1057         {
1058             # Special case: this means we want automatic
1059             # de-ANSI-fication.  FIXME think of a better way.
1060             $contents{'@kr@'} = 1;
1061         }
1062         elsif (m/^ *([a-zA-Z_.][a-zA-Z0-9_.]*) *:/)
1063         {
1064             # Found a rule.
1065             $was_rule = 1;
1066             # Value here doesn't matter; for targets we only note
1067             # existence.
1068             $contents{$1} = 1;
1069             $output_trailer .= $_ . "\n";
1070         }
1071         elsif (m/^ *([A-Za-z][A-Za-z0-9_]*)[    ]*=[    ]*(.*)$/)
1072         {
1073             # Found a variable reference.
1074             $was_rule = 0;
1075             $last_var_name = $1;
1076             if (substr ($2, -1) eq "\\")
1077             {
1078                 $contents{$1} = substr ($2, 0, length ($2) - 1);
1079             }
1080             else
1081             {
1082                 $contents{$1} = $2;
1083             }
1084             $output_vars .= $_ . "\n";
1085         }
1086         elsif (m/^$/)
1087         {
1088             # Special rule: if looking at a blank line, append it to
1089             # whatever we saw last.
1090             if ($was_rule)
1091             {
1092                 $output_trailer .= "\n";
1093             }
1094             else
1095             {
1096                 $output_vars .= "\n";
1097             }
1098         }
1099         else
1100         {
1101             # This isn't an error; it is probably a continued rule.
1102             # In fact, this is what we assume.
1103             $output_trailer .= $_ . "\n";
1104         }
1105
1106         $saw_bk = (substr ($_, -1) eq "\\");
1107     }
1108
1109     # Include some space after user code.
1110     $output_vars .= "\n";
1111     $output_trailer .= "\n";
1112 }
1113
1114 ################################################################
1115
1116 # Initialize global variables.
1117 sub init_globals
1118 {
1119     # Helper text for dealing with man pages.
1120     $install_man_format =
1121     '   sect=@SECTION@;                         \\
1122         inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1123         echo installing @MAN@ as $(mandir)/man$$sect/$$inst; \\
1124         $(INSTALL_DATA) $(srcdir)/@MAN@ $(mandir)/man$$sect/$$inst; \\
1125         if test -d $(mandir)/cat$$sect; then    \\
1126           echo formatting @MAN@ as $(mandir)/cat$$sect/$$inst;  \\
1127           $(NROFF) -man $(srcdir)/@MAN@ > $(mandir)/cat$$sect/$$inst; \\
1128         else                                    \\
1129           true;                                 \\
1130         fi
1131 ';
1132
1133     $uninstall_man_format =
1134     '   inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
1135         rm -f $(mandir)/man@SECTION@/$$inst $(mandir)/cat@SECTION@/$$inst
1136 ';
1137
1138     # Commonly found files we look for and automatically include in
1139     # DIST_FILES.
1140     @common_files =
1141         (
1142          "THANKS", "TODO", "README", "NEWS", "COPYING", "COPYING.LIB",
1143          "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
1144          "config.guess", "config.sub"
1145          );
1146
1147     # Commonly used files we auto-include, but only sometimes.
1148     @common_sometimes =
1149         (
1150          "version.texi", "aclocal.m4", "acconfig.h", "config.h.top",
1151          "config.h.bot", "stamp-h.in", "mdate-sh", "ansi2knr.c",
1152          "ansi2knr.1", 'stamp-vti', "mkinstalldirs", "install-sh"
1153          );
1154
1155     $USAGE = "\
1156   --amdir=DIR           directory storing config files
1157   --help                print this help, then exit
1158   --include-deps        include generated dependencies in Makefile.in
1159   --output-dir=DIR      put generated Makefile.in's into DIR
1160   --version             print version number, then exit\n";
1161
1162 }
1163
1164 ################################################################
1165
1166 # Return contents of a file from $am_dir.
1167 sub file_contents
1168 {
1169     local ($basename) = @_;
1170     local ($file) = $am_dir . '/' . $basename . '.am';
1171
1172     if (! open (FC_FILE, $file))
1173     {
1174         print STDERR "automake: installation error: cannot open \"$file\"\n";
1175         exit 1;
1176     }
1177
1178     # Yes, we really want to slurp it.
1179     local ($results) = join ('', <FC_FILE>);
1180
1181     close (FC_FILE);
1182
1183     return $results;
1184 }
1185
1186 # Return contents of some Makefile.am variable.  Allow for AM_ style
1187 # overrides.
1188 sub am_variable
1189 {
1190     local ($varname) = @_;
1191
1192     return (defined ($contents{'AM_' . $varname})
1193             ? $contents{'AM_' . $varname}
1194             : $contents{$varname});
1195 }
1196
1197 ################################################################
1198
1199 # Verify that the file must exist in the current directory.
1200 sub require_file
1201 {
1202     local ($file) = @_;
1203     local ($fullfile) = $relative_dir . "/" . $file;
1204
1205     if (! -f $fullfile)
1206     {
1207         print STDERR "automake: required file \"$fullfile\" not found\n";
1208         $exit_status = 1;
1209     }
1210     else
1211     {
1212         push (@dist_common, $file);
1213     }
1214 }
1215
1216
1217 ################################################################
1218
1219 # Return directory name of file.
1220 sub dirname
1221 {
1222     local ($file) = @_;
1223     local ($sub);
1224
1225     ($sub = $file) =~ s,/+[^/]+,,g;
1226     if ($sub eq $file)
1227     {
1228         $sub = '.';
1229     }
1230
1231     return $sub;
1232 }
1233
1234 # Make a directory.
1235 sub mkdir
1236 {
1237     local ($dirname) = @_;
1238     system ("mkdir", $dirname);
1239 }
1240
1241 ################################################################
1242
1243 # Print usage information.
1244 sub usage
1245 {
1246     print "Usage: automake [OPTION] ... [Makefile]...\n";
1247     print $USAGE;
1248     print "\nFiles which are automatically distributed, if found:\n";
1249     $~ = "USAGE_FORMAT";
1250     local (@lcomm) = sort ((@common_files, @common_sometimes));
1251     local ($one, $two);
1252     while ($#lcomm >= 0)
1253     {
1254         $one = shift (@lcomm);
1255         $two = shift (@lcomm);
1256         write;
1257     }
1258
1259     exit 0;
1260 }
1261
1262 format USAGE_FORMAT =
1263   @<<<<<<<<<<<<<<<<    @<<<<<<<<<<<<<<<<
1264   $one,                $two
1265 .