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