| blob | 35535431ffe7682744d284e8469801b8064b8464 |
1 #!@PERL@
2 # -*- perl -*-
3 # @configure_input@
5 eval 'exec @PERL@ -S $0 ${1+"$@"}'
6 if 0;
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 $PACKAGE = "@PACKAGE@";
34 $prefix = "@prefix@";
35 $am_dir = "@datadir@/@PACKAGE@";
37 # String constants.
38 $IGNORE_PATTERN = "^##([^#].*)?\$";
39 $WHITE_PATTERN = "^[ \t]*\$";
40 $COMMENT_PATTERN = "^#";
41 $RULE_PATTERN = "^([\$a-zA-Z_.][-.a-zA-Z0-9_(){}/]*) *:([^=].*|)\$";
42 $MACRO_PATTERN = "^([A-Za-z][A-Za-z0-9_]*)[ \t]*:?=[ \t]*(.*)\$";
43 $BOGUS_MACRO_PATTERN = "^([^ \t]*)[ \t]*:?=[ \t]*(.*)\$";
44 $GNITS_VERSION_PATTERN = "[0-9]+\\.[0-9]+([a-z]|\\.[0-9]+)?";
46 # Constants to define the "strictness" level.
47 $FOREIGN = 0;
48 $GNU = 1;
49 $GNITS = 2;
51 \f
53 # Variables global to entire run.
55 # TRUE if we should always generate Makefile.in.
56 $force_generation = 1;
58 # Strictness level as set on command line.
59 $default_strictness = $GNU;
61 # Name of strictness level, as set on command line.
62 $default_strictness_name = 'gnu';
64 # This is TRUE if GNU make specific automatic dependency generation
65 # code should be included in generated Makefile.in.
66 $cmdline_use_dependencies = 1;
68 # TRUE if in verbose mode.
69 $verbose = 0;
71 # This holds our (eventual) exit status. We don't actually exit until
72 # we have processed all input files.
73 $exit_status = 0;
75 # From the Perl manual.
76 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
78 # TRUE if missing standard files should be installed.
79 $add_missing = 0;
81 # Files found by scanning configure.in for LIBOBJS.
82 %libsources = ();
84 # True if AM_C_PROTOTYPES appears in configure.in.
85 $am_c_prototypes = 0;
87 # Names used in AC_CONFIG_HEADER call. $config_name is the actual
88 # (first) argument. $config_header is the '.in' file. Ordinarily the
89 # second is derived from the first, but they can be different if the
90 # weird "NAME:FILE" syntax is used.
91 $config_name = '';
92 $config_header = '';
93 # Line number at which AC_CONFIG_HEADER appears in configure.in.
94 $config_header_line = 0;
96 # Directory where output files go. Actually, output files are
97 # relative to this directory.
98 $output_directory = '.';
100 # Relative location of top build directory.
101 $top_builddir = '';
103 # Absolute location of top build directory.
104 $build_directory = '';
106 # Name of srcdir as given in build directory's Makefile. For
107 # dependencies only.
108 $srcdir_name = '';
110 # List of Makefile.am's to process.
111 @input_files = ();
113 # List of files in AC_OUTPUT without Makefile.am.
114 @other_input_files = ();
115 # Line number at which AC_OUTPUT seen.
116 $ac_output_line = 0;
118 # List of directories to search for configure-required files. This
119 # can be set by AC_CONFIG_AUX_DIR.
120 @config_aux_path = ('.', '..', '../..');
121 $config_aux_dir = '';
123 # Whether AC_PROG_MAKE_SET has been seen in configure.in.
124 $seen_make_set = 0;
126 # Whether ud_GNU_GETTEXT has been seen in configure.in.
127 $seen_gettext = 0;
128 # Line number at which ud_GNU_GETTEXT seen.
129 $ac_gettext_line = 0;
131 # Whether ALL_LINGUAS has been seen.
132 $seen_linguas = '';
133 # The actual text.
134 $all_linguas = '';
135 # Line number at which it appears.
136 $all_linguas_line = 0;
138 # 1 if AC_PROG_INSTALL seen, 2 if AM_PROG_INSTALL seen.
139 $seen_prog_install = 0;
141 # 1 if any scripts installed, 0 otherwise.
142 $scripts_installed = 0;
144 # Whether AC_PATH_XTRA has been seen in configure.in.
145 $seen_path_xtra = 0;
147 # Whether YACC variable has been seen in configure.in.
148 $seen_prog_yacc = 0;
150 # Two variables to control lex use. One is for AC_DECL_YYTEXT and the
151 # other is for AC_PROG_LEX.
152 $seen_decl_yytext = 0;
153 $seen_prog_lex = 0;
155 # TRUE if we've seen AC_PROG_CC.
156 $seen_prog_cc = 0;
158 # TRUE if we've seen AC_PROG_CXX.
159 $seen_prog_cxx = 0;
161 # TRUE if we've seen AC_CANONICAL_(HOST|SYSTEM). The presence of
162 # AC_CHECK_TOOL also sets this.
163 $seen_canonical = 0;
165 # TRUE if we've seen AC_PROG_RANLIB.
166 $seen_ranlib = 0;
168 # TRUE if we've seen AC_ARG_PROGRAM.
169 $seen_arg_prog = 0;
171 # TRUE if we've seen AM_PROG_LIBTOOL.
172 $seen_libtool = 0;
173 $libtool_line = 0;
175 # TRUE if we've seen AM_MAINTAINER_MODE.
176 $seen_maint_mode = 0;
178 # TRUE if we've seen PACKAGE and VERSION.
179 $seen_package = 0;
180 $seen_version = 0;
182 # Actual version we've seen.
183 $package_version = '';
185 # Line number where we saw version definition.
186 $package_version_line = 0;
188 # TRUE if we've seen AM_PATH_LISPDIR.
189 $seen_lispdir = 0;
192 # Charsets used by maintainer and in distribution. MAINT_CHARSET is
193 # handled in a funny way: if seen in the top-level Makefile.am, it is
194 # used for every directory which does not specify a different value.
195 # The rationale here is that some directories (eg gettext) might be
196 # distributions of other packages, and thus require their own charset
197 # info. However, the DIST_CHARSET must be the same for the entire
198 # package; it can only be set at top-level.
199 # FIXME: this yields bugs when rebuilding. What to do? Always
200 # read (and sometimes discard) top-level Makefile.am?
201 $maint_charset = '';
202 $dist_charset = 'utf8'; # recode doesn't support this yet.
204 # Name of input file ("Makefile.in") and output file ("Makefile.am").
205 # These have no directory components.
206 $am_file_name = '';
207 $in_file_name = '';
209 \f
211 &initialize_global_constants;
213 # Parse command line.
214 &parse_arguments (@ARGV);
216 # Do configure.in scan only once.
217 &scan_configure;
219 die "automake: no \`Makefile.am' found or specified\n"
220 if ! @input_files;
222 # Now do all the work on each file.
223 foreach $am_file (@input_files)
224 {
225 # FIXME: should support the AC_OUTPUT ":" syntax here.
226 if (! -f ($am_file . '.am'))
227 {
228 &am_error ('no such file');
229 }
230 else
231 {
232 &generate_makefile ($am_file);
233 }
234 }
236 if ($seen_prog_install <= $scripts_installed)
237 {
238 &am_conf_error (($scripts_installed ? 'AM_PROG_INSTALL' : 'AC_PROG_INSTALL')
239 . " must be used in configure.in");
240 &keyed_aclocal_warning ('AM_PROG_INSTALL')
241 if $scripts_installed;
242 }
244 exit $exit_status;
247 ################################################################
249 # Parse command line.
250 sub parse_arguments
251 {
252 local (@arglist) = @_;
254 # Start off as gnu.
255 &set_strictness ('gnu');
257 while (@arglist)
258 {
259 if ($arglist[0] eq "--version")
260 {
261 print "automake - GNU $PACKAGE $VERSION\n";
262 exit 0;
263 }
264 elsif ($arglist[0] eq "--help")
265 {
266 &usage;
267 }
268 elsif ($arglist[0] =~ /^--amdir=(.+)$/)
269 {
270 $am_dir = $1;
271 }
272 elsif ($arglist[0] eq '--amdir')
273 {
274 &require_argument (@arglist);
275 shift (@arglist);
276 $am_dir = $arglist[0];
277 }
278 elsif ($arglist[0] =~ /^--build-dir=(.+)$/)
279 {
280 # Must end in /.
281 $build_directory = $1 . '/';
282 }
283 elsif ($arglist[0] eq '--build-dir')
284 {
285 &require_argument (@arglist);
286 shift (@arglist);
287 # Must end in /.
288 $build_directory = $arglist[0] . '/';
289 }
290 elsif ($arglist[0] =~ /^--srcdir-name=(.+)$/)
291 {
292 $srcdir_name = $1;
293 }
294 elsif ($arglist[0] eq '--srcdir-name')
295 {
296 &require_argument (@arglist);
297 shift (@arglist);
298 $srcdir_name = $arglist[0];
299 }
300 elsif ($arglist[0] =~ /^--strictness=(.+)$/)
301 {
302 &set_strictness ($1);
303 }
304 elsif ($arglist[0] eq '--gnu')
305 {
306 &set_strictness ('gnu');
307 }
308 elsif ($arglist[0] eq '--gnits')
309 {
310 &set_strictness ('gnits');
311 }
312 elsif ($arglist[0] eq '--foreign')
313 {
314 &set_strictness ('foreign');
315 }
316 elsif ($arglist[0] eq '--strictness' || $arglist[0] eq '-s')
317 {
318 &require_argument (@arglist);
319 shift (@arglist);
320 &set_strictness ($arglist[0]);
321 }
322 elsif ($arglist[0] eq '--include-deps' || $arglist[0] eq '-i')
323 {
324 $cmdline_use_dependencies = 0;
325 }
326 elsif ($arglist[0] eq '--no-force')
327 {
328 $force_generation = 0;
329 }
330 elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
331 {
332 # Set output directory.
333 $output_directory = $1;
334 }
335 elsif ($arglist[0] eq '--output-dir' || $arglist[0] eq '-o')
336 {
337 &require_argument (@arglist);
338 shift (@arglist);
339 $output_directory = $arglist[0];
340 }
341 elsif ($arglist[0] eq '--add-missing' || $arglist[0] eq '-a')
342 {
343 $add_missing = 1;
344 }
345 elsif ($arglist[0] eq '--verbose' || $arglist[0] eq '-v')
346 {
347 $verbose = 1;
348 }
349 elsif ($arglist[0] eq '--')
350 {
351 # Stop option processing.
352 shift (@arglist);
353 push (@input_files, @arglist);
354 last;
355 }
356 elsif ($arglist[0] =~ /^-/)
357 {
358 die "automake: unrecognized option -- \`$arglist[0]'\n";
359 }
360 else
361 {
362 push (@input_files, $arglist[0]);
363 }
365 shift (@arglist);
366 }
368 # Take global strictness from whatever we currently have set.
369 $default_strictness = $strictness;
370 $default_strictness_name = $strictness_name;
371 }
373 # Ensure argument exists, or die.
374 sub require_argument
375 {
376 local ($arg, @arglist) = @_;
377 die "automake: no argument given for option \`$arg'\n"
378 if ! @arglist;
379 }
381 ################################################################
383 # Generate a Makefile.in given the name of the corresponding Makefile.
384 sub generate_makefile
385 {
386 local ($makefile) = @_;
388 ($am_file_name = $makefile) =~ s/^.*\///;
389 $in_file_name = $am_file_name . '.in';
390 $am_file_name .= '.am';
392 &initialize_per_input;
393 $relative_dir = &dirname ($makefile);
395 # At the toplevel directory, we might need config.guess, config.sub
396 # or libtool.
397 if ($relative_dir eq '.')
398 {
399 # libtool requires some files.
400 &require_conf_file_with_conf_line ($libtool_line, $FOREIGN,
401 'config.sub', 'config.guess',
402 'libtool') if $seen_libtool;
404 # AC_CANONICAL_HOST and AC_CANONICAL_SYSTEM need config.guess and
405 # config.sub.
406 &require_config_file ($FOREIGN, 'config.guess', 'config.sub')
407 if $seen_canonical;
408 }
410 # We still need Makefile.in here, because sometimes the `dist'
411 # target doesn't re-run automake.
412 &push_dist_common ($in_file_name, $am_file_name);
413 push (@sources, '$(SOURCES)')
414 if &variable_defined ('SOURCES');
415 push (@objects, '$(OBJECTS)')
416 if &variable_defined ('OBJECTS');
418 # This is always the default target. This gives us freedom to do
419 # things in whatever order is convenient.
420 $output_rules .= "default: all\n\n";
421 push (@phony, 'default');
423 &read_am_file ($makefile . '.am');
424 if (&handle_options)
425 {
426 # Fatal error. Just return, so we can continue with next file.
427 return;
428 }
430 # Check first, because we might modify some state.
431 &check_gnu_standards;
432 &check_gnits_standards;
434 &handle_configure;
435 &handle_gettext;
436 &handle_libraries;
437 &handle_programs;
438 &check_typos;
439 &handle_scripts;
441 # This must be run after all the sources are scanned.
442 &handle_yacc_lex_cxx;
444 # Re-init SOURCES and OBJECTS. FIXME: other code shouldn't depend
445 # on this (but currently does).
446 $contents{'SOURCES'} = join (' ', @sources);
447 $contents{'OBJECTS'} = join (' ', @objects);
449 &handle_texinfo;
450 &handle_emacs_lisp;
451 &handle_man_pages;
452 &handle_data;
453 &handle_headers;
454 &handle_subdirs;
455 &handle_tags;
456 &handle_dist;
457 &handle_dependencies;
458 &handle_tests;
459 &handle_footer;
460 &handle_merge_targets;
461 &handle_installdirs;
462 &handle_clean;
463 &handle_phony;
465 if (! -d ($output_directory . '/' . $relative_dir))
466 {
467 mkdir ($output_directory . '/' . $relative_dir, 0755);
468 }
470 local ($out_file) = $output_directory . '/' . $makefile . ".in";
471 if (! $force_generation && -e $out_file)
472 {
473 local ($am_time) = (stat ($makefile . '.am'))[9];
474 local ($in_time) = (stat ($out_file))[9];
475 # FIXME: how to do unsigned comparison?
476 if ($am_time < $in_time)
477 {
478 # No need to update.
479 return;
480 }
481 }
483 if (! open (GM_FILE, "> " . $out_file))
484 {
485 warn "automake: ${am_file}.in: cannot open: $!\n";
486 $exit_status = 1;
487 return;
488 }
489 print "automake: creating ", $makefile, ".in\n" if $verbose;
491 print GM_FILE $output_vars;
492 print GM_FILE $output_rules;
493 print GM_FILE $output_trailer;
495 close (GM_FILE);
496 }
498 ################################################################
500 # Handle AUTOMAKE_OPTIONS variable. Return 1 on error, 0 otherwise.
501 sub handle_options
502 {
503 return 0 if ! &variable_defined ('AUTOMAKE_OPTIONS');
505 foreach (&variable_value_as_list ('AUTOMAKE_OPTIONS'))
506 {
507 last if /^#/;
509 $options{$_} = 1;
510 if ($_ eq 'gnits' || $_ eq 'gnu' || $_ eq 'foreign')
511 {
512 &set_strictness ($_);
513 }
514 elsif (/ansi2knr/)
515 {
516 # An option like "../lib/ansi2knr" is allowed. With no
517 # path prefix, we assume the required programs are in this
518 # directory. We save the actual option for later.
519 $options{'ansi2knr'} = $_;
520 }
521 elsif ($_ eq 'no-installman' || $_ eq 'no-installinfo'
522 || $_ eq 'dist-shar' || $_ eq 'dist-zip'
523 || $_ eq 'dist-tarZ' || $_ eq 'dejagnu')
524 {
525 # Explicitly recognize these.
526 }
527 elsif ($_ eq 'no-dependencies')
528 {
529 $use_dependencies = 0;
530 }
531 elsif (/([0-9]+)\.([0-9]+)/)
532 {
533 # Got a version number. Note that alpha releases count as
534 # the next higher release. Note also that we assume there
535 # will be a maximum of 100 minor releases for any given
536 # major release.
537 local ($rmajor, $rminor) = ($1, $2);
538 if ($VERSION !~ /([0-9]+)\.([0-9]+)([a-z])?/)
539 {
540 print STDERR
541 "automake: programming error: version is incorrect\n";
542 exit 1;
543 }
544 local ($tmajor, $tminor) = ($1, $2);
545 # Handle alpha versions.
546 ++$tminor if defined $3;
548 if ($rmajor > $tmajor || ($rmajor == $tmajor && $rminor > $tminor))
549 {
550 &am_line_error ('AUTOMAKE_OPTIONS',
551 "require version $_, only have $VERSION");
552 return 1;
553 }
554 }
555 else
556 {
557 &am_line_error ('AUTOMAKE_OPTIONS',
558 'option ', $_, 'not recognized');
559 }
560 }
562 return 0;
563 }
565 # Return object extension. Just once, put some code into the output.
566 sub get_object_extension
567 {
568 if (! $dir_holds_sources)
569 {
570 # Boilerplate.
571 local ($xform) = '';
572 if (&variable_defined ('CONFIG_HEADER'))
573 {
574 ($xform = &dirname ($contents{'CONFIG_HEADER'}))
575 =~ s/(\W)/\\$1/g;
576 $xform = '-I' . $xform;
577 }
578 $xform = 's/\@CONFIG_INCLUDE_SPEC\@/' . $xform . '/go';
579 $output_vars .= &file_contents_with_transform ($xform,
580 'compile-vars');
581 $output_rules .= &file_contents ('compile');
582 &push_phony_cleaners ('compile');
584 # If using X, include some extra variable definitions. NOTE
585 # we don't want to force these into CFLAGS or anything,
586 # because not all programs will necessarily use X.
587 if ($seen_path_xtra)
588 {
589 local ($var);
590 foreach $var ('X_CFLAGS', 'X_LIBS', 'X_EXTRA_LIBS', 'X_PRE_LIBS')
591 {
592 &define_variable ($var, "\@$var\@");
593 }
594 }
596 # Check for automatic de-ANSI-fication.
597 $dir_holds_sources = '.o';
598 push (@suffixes, '.c', '.o');
599 push (@clean, 'compile');
601 if (defined $options{'ansi2knr'})
602 {
603 if (! $am_c_prototypes)
604 {
605 &am_line_error ('AUTOMAKE_OPTIONS',
606 "option \`ansi2knr' in use but \`AM_C_PROTOTYPES' not in configure.in");
607 &keyed_aclocal_warning ('AM_C_PROTOTYPES');
608 # Only give this error once.
609 $am_c_prototypes = 1;
610 }
612 $dir_holds_sources = '$o';
613 push (@suffixes, '._c', '._o');
615 # Only require ansi2knr files if they should appear in
616 # this directory.
617 if ($options{'ansi2knr'} eq 'ansi2knr')
618 {
619 &require_file_with_line ('AUTOMAKE_OPTIONS', $FOREIGN,
620 'ansi2knr.c', 'ansi2knr.1');
621 $output_rules .= &file_contents ('kr-extra');
622 push (@clean, 'krextra');
623 &push_phony_cleaners ('krextra');
624 }
626 &define_variable ('o', ".\@U\@o");
628 # Make sure ansi2knr can be found: if no path specified,
629 # specify "./".
630 local ($apath) = $options{'ansi2knr'};
631 $apath = './' . $apath
632 unless $apath =~ /\//;
633 &define_variable ("ANSI2KNR", $apath);
635 $output_rules .= &file_contents ('compile-kr');
636 $output_rules .= &file_contents ('clean-kr');
638 push (@clean, 'kr');
639 &push_phony_cleaners ('kr');
640 }
641 }
642 return $dir_holds_sources;
643 }
645 # Handle yacc and lex.
646 sub handle_yacc_lex_cxx
647 {
648 #
649 # First do yacc and lex.
650 #
652 local ($yacc_count) = scalar (keys %yacc_sources);
653 local ($lex_count) = scalar (keys %lex_sources);
654 if ($yacc_count)
655 {
656 push (@suffixes, '.y');
657 &define_variable ('YACC', "\@YACC\@");
658 $output_rules .= ".y.c:\n\t";
659 if ($yacc_count > 1)
660 {
661 $output_rules .= '$(INTERLOCK) =yacclockdir $(YLWRAP) y.tab.c $@ $(YACC) $(YFLAGS) $<';
662 }
663 else
664 {
665 $output_rules .= '$(YACC) $(YFLAGS) $< && mv y.tab.c $@';
666 }
667 $output_rules .= "\n";
669 if (! $seen_prog_yacc)
670 {
671 # FIXME: should include a reference line. FIXME: maybe
672 # directly reference AC_PROG_YACC somehow?
673 &am_error ("yacc source seen but \`YACC' not defined in \`configure.in'\n");
674 }
675 }
676 if ($lex_count)
677 {
678 push (@suffixes, '.l');
679 &define_variable ("LEX", "\@LEX\@");
680 &define_variable ("LEX_OUTPUT_ROOT", "\@LEX_OUTPUT_ROOT\@");
681 $output_rules .= ".l.c:\n\t";
682 if ($lex_count > 1)
683 {
684 $output_rules .= '$(INTERLOCK) =lexlockdir $(YLWRAP) $(LEX_OUTPUT_ROOT).c $@ $(LEX) $(LFLAGS) $<';
685 }
686 else
687 {
688 $output_rules .= '$(LEX) $(LFLAGS) $< && mv $(LEX_OUTPUT_ROOT).c $@';
689 }
690 $output_rules .= "\n";
692 if (! $seen_prog_lex)
693 {
694 &am_error ("lex source seen but \`AC_PROG_LEX' not in \`configure.in'\n");
695 }
696 if (! $seen_decl_yytext)
697 {
698 &am_error ("lex source seen but \`AC_DECL_YYTEXT' not in \`configure.in'\n");
699 }
700 }
702 if ($yacc_count > 1 || $lex_count > 1)
703 {
704 # If there is more than one distinct yacc (resp lex) source
705 # file in a given directory, then the `interlock' program is
706 # required to allow parallel builds to work correctly. FIXME:
707 # for now, no line number.
708 &require_config_file ($FOREIGN, 'interlock', 'ylwrap');
709 &define_variable ('INTERLOCK', $config_aux_dir . "/interlock");
710 &define_variable ('YLWRAP', $config_aux_dir . "/ylwrap");
711 }
713 #
714 # Now handle C++.
715 #
716 local (@cxx_list) = keys %cxx_extensions;
717 local ($cxx_count) = scalar @cxx_list;
718 if ($cxx_count)
719 {
720 push (@suffixes, @cxx_list);
722 &define_variable ("CXX", "\@CXX\@");
723 &define_variable ("CXXFLAGS", "\@CXXFLAGS\@");
724 &define_variable ('CXXCOMPILE', '$(CXX) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)');
725 &define_variable ('CXXLINK', '$(CXX) $(LDFLAGS) -o $@');
727 local ($ext);
728 foreach $ext (@cxx_list)
729 {
730 $output_rules .= ("$ext.o:\n"
731 . "\t\$(CXXCOMPILE) -c \$<\n");
732 }
734 if (! $seen_prog_cxx)
735 {
736 &am_error ("C++ source seen but \`AC_PROG_CXX' not in \`configure.in'\n");
737 }
738 }
740 #
741 # Last, handle some C cleanup.
742 #
743 if ($seen_c_source)
744 {
745 &define_variable ('CC', "\@CC\@");
746 &define_variable ('CFLAGS', "\@CFLAGS\@");
747 &define_variable ('COMPILE',
748 '$(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)');
749 &define_variable ('LINK', '$(CC) $(LDFLAGS) -o $@');
750 }
751 }
753 # Handle SOURCE->OBJECT transform for one program or library.
754 # Arguments are:
755 # canonical (transformed) name of object to build
756 # actual name of object to build
757 # object extension (ie either `.o' or `$o'.
758 # Return result is name of linker variable that must be used.
759 # Empty return means just use `LINK'.
760 sub handle_source_transform
761 {
762 # one_file is canonical name. unxformed is given name. obj is
763 # object extension.
764 local ($one_file, $unxformed, $obj) = @_;
765 local ($objpat) = $obj;
766 $objpat =~ s/(\W)/\\$1/g;
768 local ($linker) = '';
770 if (&variable_defined ($one_file . "_OBJECTS"))
771 {
772 &am_line_error ($one_file . '_OBJECTS',
773 $one_file . '_OBJECTS', 'should not be defined');
774 # No point in continuing.
775 return;
776 }
778 local (@files);
779 local ($prefix);
780 foreach $prefix ('', 'EXTRA_')
781 {
782 @files = ();
783 if (&variable_defined ($prefix . $one_file . "_SOURCES"))
784 {
785 push (@sources, '$(' . $prefix . $one_file . "_SOURCES)");
786 push (@objects, '$(' . $prefix . $one_file . "_OBJECTS)")
787 unless $prefix eq 'EXTRA_';
788 @files = &variable_value_as_list ($prefix
789 . $one_file . "_SOURCES");
790 }
791 elsif ($prefix eq '')
792 {
793 &define_variable ($one_file . "_SOURCES", $unxformed . ".c");
794 push (@sources, $unxformed . '.c');
795 push (@objects, $unxformed . $obj);
796 push (@files, $unxformed . '.c');
797 }
798 else
799 {
800 &define_variable ("EXTRA_" . $one_file . "_SOURCES", '');
801 }
803 if (length (@files))
804 {
805 # Turn sources into objects.
806 local (@result) = ();
807 foreach (@files)
808 {
809 # Skip header files, including C++-ish ones. The list
810 # of C++ header extensions comes from Emacs 19.32
811 # etags.
812 next if /\.[hH]$/;
813 next if /\.hxx$/;
814 next if /\.h\+\+$/;
815 next if /\.hh$/;
816 next if /\.hpp$/;
817 # Skip things that look like configure substitutions.
818 next if /^\@.*\@$/;
820 # Include .c file for lex or yacc source in distribution.
821 if (/^(.*)\.y$/)
822 {
823 # Yacc source.
824 &push_dist_common ($1 . '.c');
825 $yacc_sources{$_} = 1;
826 }
827 elsif (/^(.*)\.l$/)
828 {
829 # Lex source.
830 &push_dist_common ($1 . '.c');
831 $lex_sources{$_} = 1;
832 }
834 # Transform source files into .o files. List of C++
835 # extensions comes from Emacs 19.32 etags.
836 if (s/\.c\+\+$/$obj/g
837 || s/\.cc$/$obj/g
838 || s/\.cpp$/$obj/g
839 || s/\.cxx$/$obj/g
840 || s/\.C$/$obj/g)
841 {
842 $cxx_extensions{$&} = 1;
843 $linker = 'CXXLINK';
844 }
845 else
846 {
847 # FORTRAN support. FIXME: not finished.
848 s/\.f90$/$obj/g;
849 s/\.for$/$obj/g;
851 # .y is yacc. .l is lex. .f and .F is fortran.
852 # .s is assembly. .M is Objective-C++. .m is
853 # Objective-C.
854 s/\.[cylfFsmM]$/$obj/g;
856 # FIXME: of course, this should only happen for C
857 # source. The multi-language support must really
858 # be cleaned up more globally.
859 $seen_c_source = 1;
860 }
862 push (@result, $_)
863 unless $prefix eq 'EXTRA_';
865 # Transform .o or $o file into .P file (for automatic
866 # dependency code).
867 s/$objpat$/.P/g;
868 $dep_files{'.deps/' . $_} = 1;
869 }
871 &define_pretty_variable ($one_file . "_OBJECTS", @result)
872 unless $prefix eq 'EXTRA_';
873 }
874 }
876 if (&variable_defined ('CONFIG_HEADER'))
877 {
878 $output_rules .= ('$(' . $one_file . "_OBJECTS): "
879 . $contents{'CONFIG_HEADER'} . "\n");
880 }
882 return $linker;
883 }
885 # Special-case @ALLOCA@ and @LIBOBJS@ in _LDADD or _LIBADD variables.
886 # Also, generate _DEPENDENCIES variable if appropriate.
887 # Arguments are:
888 # transformed name of object being built, or empty string if no object
889 # name of _LDADD/_LIBADD-type variable to examine
890 sub handle_lib_objects
891 {
892 local ($xname, $var) = @_;
894 die "programming error in handle_lib_objects"
895 if ! &variable_defined ($var);
897 # We recognize certain things that are commonly put in LIBADD or
898 # LDADD.
899 local ($lsearch);
900 local (@dep_list) = ();
902 foreach $lsearch (&variable_value_as_list ($var))
903 {
904 # Skip -lfoo and -Ldir.
905 next if $lsearch =~ /^-[lL]/;
907 # Assume we have a file of some sort, and push it onto the
908 # dependency list. Autoconf substitutions are not pushed;
909 # rarely is a new dependency substituted into (eg) foo_LDADD
910 # -- but "bad things (eg -lX11) are routinely substituted.
911 push (@dep_list, $lsearch)
912 unless $lsearch =~ /^\@.*\@$/;
914 # Automatically handle @LIBOBJS@ and @ALLOCA@. Basically this
915 # means adding entries to dep_files.
916 if ($lsearch eq '@LIBOBJS@')
917 {
918 if (! keys %libsources)
919 {
920 &am_line_error ($var, "\@LIBOBJS\@ seen but never set in \`configure.in'");
921 }
923 local ($iter, $rewrite);
924 foreach $iter (keys %libsources)
925 {
926 if ($iter =~ /\.h$/)
927 {
928 &require_file_with_line ($var, $FOREIGN, $iter);
929 }
930 elsif ($iter ne 'alloca.c')
931 {
932 ($rewrite = $iter) =~ s/\.c$/.P/;
933 $dep_files{'.deps/' . $rewrite} = 1;
934 &require_file_with_line ($var, $FOREIGN, $iter);
935 }
936 }
937 }
938 elsif ($lsearch eq '@ALLOCA@')
939 {
940 &am_line_error ($var,
941 "\@ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
942 if ! defined $libsources{'alloca.c'};
943 $dep_files{'.deps/alloca.P'} = 1;
944 &require_file_with_line ($var, $FOREIGN, 'alloca.c');
945 }
946 }
948 if ($xname ne '' && ! &variable_defined ($xname . '_DEPENDENCIES'))
949 {
950 &define_pretty_variable ($xname . '_DEPENDENCIES', @dep_list);
951 }
952 }
954 # Handle C programs.
955 sub handle_programs
956 {
957 local (@proglist) = &am_install_var ('-clean',
958 'programs', 'PROGRAMS',
959 'bin', 'sbin', 'libexec', 'pkglib',
960 'noinst', 'check');
961 return if ! @proglist;
963 # If a program is installed, this is required. We only want this
964 # error to appear once.
965 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
966 unless $seen_arg_prog;
967 $seen_arg_prog = 1;
969 local ($obj) = &get_object_extension;
970 local ($one_file, $xname, $munge);
972 foreach $one_file (@proglist)
973 {
974 # Canonicalize names.
975 ($xname = $one_file) =~ tr/A-Za-z0-9_/_/c;
976 if ($xname ne $one_file)
977 {
978 local ($xt);
979 foreach $xt ('_LDADD', '_SOURCES', '_OBJECTS', '_DEPENDENCIES')
980 {
981 &am_line_error ($one_file . $xt,
982 "invalid variable \`" . $one_file . $xt
983 . "'; should be \`" . $xname . $xt . "'")
984 if &variable_defined ($one_file . $xt);
985 }
986 }
988 local ($linker) = &handle_source_transform ($xname, $one_file, $obj);
990 if (&variable_defined ($xname . "_LDADD"))
991 {
992 &handle_lib_objects ($xname, $xname . '_LDADD');
993 }
994 else
995 {
996 # User didn't define prog_LDADD override. So do it.
997 &define_variable ($xname . '_LDADD', '$(LDADD)');
999 # This does a bit too much work. But we need it to
1000 # generate _DEPENDENCIES when appropriate.
1001 &handle_lib_objects ($xname, 'LDADD')
1002 if (&variable_defined ('LDADD'));
1003 }
1005 # Determine program to use for link.
1006 local ($xlink);
1007 if (&variable_defined ($xname . '_LINK'))
1008 {
1009 $xlink = $xname . '_LINK';
1010 }
1011 else
1012 {
1013 $xlink = $linker ? $linker : 'LINK';
1014 }
1016 $output_rules .=
1017 &file_contents_with_transform
1018 ('s/\@PROGRAM\@/' . $one_file . '/go;'
1019 . 's/\@XPROGRAM\@/' . $xname . '/go;'
1020 . 's/\@XLINK\@/' . $xlink . '/go;',
1021 'program');
1022 }
1024 &handle_lib_objects ('', 'LDADD')
1025 if &variable_defined ('LDADD');
1026 }
1028 # Handle libraries.
1029 sub handle_libraries
1030 {
1031 local (@liblist) = &am_install_var ('-no-all', '-clean',
1032 'libraries', 'LIBRARIES',
1033 'lib', 'pkglib', 'noinst', 'check');
1034 return if ! @liblist;
1036 local (%valid) = &am_primary_prefixes ('LIBRARIES', 'lib', 'pkglib',
1037 'noinst', 'check');
1038 if (! $seen_ranlib)
1039 {
1040 local ($key);
1041 foreach $key (keys %valid)
1042 {
1043 if (&variable_defined ($key . '_LIBRARIES'))
1044 {
1045 &am_line_error ($key . '_LIBRARIES', "library requires either \`AC_PROG_RANLIB' or `AM_PROG_LIBTOOL' in configure.in");
1046 # Only get this error once.
1047 $seen_ranlib = 1;
1048 last;
1049 }
1050 }
1051 }
1053 # Generate _LIBFILES variables. Too bad we can't do this in
1054 # am_install_var.
1055 local ($onedir, $onelib);
1056 local (@outlist);
1057 local (@libfiles_list);
1058 foreach $onedir (keys %valid)
1059 {
1060 if (&variable_defined ($onedir . '_LIBRARIES'))
1061 {
1062 @outlist = ();
1063 foreach $onelib (&variable_value_as_list ($onedir . '_LIBRARIES'))
1064 {
1065 push (@outlist, 'lib' . $onelib . '.a');
1066 }
1067 &define_pretty_variable ($onedir . '_LIBFILES', @outlist);
1068 }
1070 push (@libfiles_list, '$(' . $onedir . '_LIBFILES)')
1071 unless $onedir eq 'EXTRA';
1072 }
1073 push (@all, '$(LIBFILES)');
1075 local ($obj) = &get_object_extension;
1076 local ($munge);
1077 local ($xlib);
1078 foreach $onelib (@liblist)
1079 {
1080 # Canonicalize names.
1081 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1082 if ($xlib ne $onelib)
1083 {
1084 local ($xt);
1085 foreach $xt ('_LIBADD', '_SOURCES', '_OBJECTS', '_DEPENDENCIES')
1086 {
1087 &am_line_error ($one_file . $xt,
1088 "invalid variable \`" . $onelib . $xt
1089 . "'; should be \`" . $xlib . $xt . "'")
1090 if &variable_defined ($onelib . $xt);
1091 }
1092 }
1094 if (&variable_defined ($xlib . '_LIBADD'))
1095 {
1096 &handle_lib_objects ($xlib, $xlib . '_LIBADD');
1097 }
1098 else
1099 {
1100 # Generate support for conditional object inclusion in
1101 # libraries.
1102 &define_variable ($xlib . "_LIBADD", '');
1103 }
1105 &handle_source_transform ($xlib, $onelib, $obj);
1107 $output_rules .=
1108 &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go;'
1109 . 's/\@XLIBRARY\@/'
1110 . $xlib . '/go;',
1111 'library');
1112 }
1114 # Turn "foo" into "libfoo.a" and include macro definition.
1115 grep (($_ = 'lib' . $_ . '.a') && 0, @liblist);
1117 if (! &variable_defined ('LIBFILES'))
1118 {
1119 &define_pretty_variable ('LIBFILES ', @libfiles_list);
1120 }
1122 if ($seen_libtool)
1123 {
1124 &define_variable ('AR', '$(LIBTOOL) archive');
1125 &define_variable ('RANLIB', '$(LIBTOOL) ranlib');
1126 &define_variable ('LCOMPILE', ('$(LIBTOOL) compile $(DEFS) $(INCLUDES)'
1127 . ' $(CPPFLAGS) $(CFLAGS)'));
1128 }
1129 else
1130 {
1131 &define_variable ('AR', 'ar');
1132 &define_variable ('RANLIB', '@RANLIB@');
1133 }
1134 }
1136 # See if any _SOURCES variable were misspelled.
1137 sub check_typos
1138 {
1139 local ($varname, $primary);
1140 foreach $varname (keys %contents)
1141 {
1142 foreach $primary ('_SOURCES', '_LIBADD', '_LDADD', '_DEPENDENCIES')
1143 {
1144 if ($varname =~ /$primary$/ && ! $content_seen{$varname})
1145 {
1146 &am_line_error ($varname,
1147 "invalid unused variable name: \`$varname'");
1148 }
1149 }
1150 }
1151 }
1153 # Handle scripts.
1154 sub handle_scripts
1155 {
1156 # NOTE we no longer automatically clean SCRIPTS, because it is
1157 # useful to sometimes distribute scripts verbatim. This happens
1158 # eg in Automake itself.
1159 &am_install_var ('scripts', 'SCRIPTS',
1160 'bin', 'sbin', 'libexec', 'pkgdata',
1161 'noinst', 'check');
1163 # Set $scripts_installed if appropriate. Make sure we only find
1164 # scripts which are actually installed -- this is why we can't
1165 # simply use the return value of am_install_var.
1166 local (%valid) = &am_primary_prefixes ('SCRIPTS', 'bin', 'sbin',
1167 'libexec', 'pkgdata',
1168 'noinst', 'check');
1169 local ($key);
1170 foreach $key (keys %valid)
1171 {
1172 if ($key ne 'noinst'
1173 && $key ne 'check'
1174 && &variable_defined ($key . '_SCRIPTS'))
1175 {
1176 $scripts_installed = 1;
1177 last;
1178 }
1179 }
1181 if ($scripts_installed)
1182 {
1183 # If a program is installed, this is required. We only want this
1184 # error to appear once.
1185 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1186 unless $seen_arg_prog;
1187 $seen_arg_prog = 1;
1188 }
1189 }
1191 # Search a file for a "version.texi" Texinfo include. Return the name
1192 # of the include file if found, or the empty string if not. A
1193 # "version.texi" file is actually any file whose name matches
1194 # "vers*.texi".
1195 sub grep_for_vers_texi
1196 {
1197 local ($filename) = @_;
1199 if (! open (TEXI, $filename))
1200 {
1201 &am_error ("couldn't open \`$filename': $!");
1202 return '';
1203 }
1204 print "automake: reading $filename\n" if $verbose;
1206 while (<TEXI>)
1207 {
1208 if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
1209 {
1210 # Found it.
1211 close (TEXI);
1212 return $1;
1213 }
1214 }
1216 close (TEXI);
1217 return '';
1218 }
1220 # Handle all Texinfo source.
1221 sub handle_texinfo
1222 {
1223 &am_line_error ('TEXINFOS',
1224 "\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
1225 if &variable_defined ('TEXINFOS');
1226 return if (! &variable_defined ('info_TEXINFOS')
1227 && ! &variable_defined ('html_TEXINFOS'));
1229 local (@texis) = &variable_value_as_list ('info_TEXINFOS');
1231 local (@infos_list, @info_deps_list, @dvis_list, @texi_deps);
1232 local ($infobase, $info_cursor);
1233 local (%versions);
1234 local ($done) = 0;
1235 local ($vti);
1236 local ($tc_cursor, @texi_cleans);
1237 local ($canonical);
1239 foreach $info_cursor (@texis)
1240 {
1241 ($infobase = $info_cursor) =~ s/\.texi(nfo)?$//;
1243 # If 'version.texi' is referenced by input file, then include
1244 # automatic versioning capability.
1245 local ($vtexi)
1246 = &grep_for_vers_texi ($relative_dir . "/" . $info_cursor);
1247 if ($vtexi)
1248 {
1249 &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
1250 if (defined $versions{$vtexi});
1251 $versions{$vtexi} = $info_cursor;
1253 # We number the stamp-vti files. This is doable since the
1254 # actual names don't matter much. We only number starting
1255 # with the second one, so that the common case looks nice.
1256 $vti = 'vti' . ($done ? $done : '');
1257 &push_dist_common ($vtexi, 'stamp-' . $vti);
1258 push (@clean, $vti);
1260 # Only require once.
1261 &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
1262 'mdate-sh')
1263 if ! $done;
1264 ++$done;
1266 local ($conf_pat);
1267 ($conf_pat = $config_aux_dir) =~ s/(\W)/\\$1/g;
1268 $output_rules .=
1269 &file_contents_with_transform
1270 ('s/\@TEXI\@/' . $info_cursor . '/g; '
1271 . 's/\@VTI\@/' . $vti . '/g; '
1272 . 's/\@VTEXI\@/' . $vtexi . '/g;'
1273 . 's,\@MDDIR\@,' . $conf_pat . ',g;',
1274 'texi-version');
1276 &push_phony_cleaners ($vti);
1277 }
1279 # If user specified file_TEXINFOS, then use that as explicit
1280 # dependency list.
1281 @texi_deps = ();
1282 push (@texi_deps, $info_cursor);
1283 push (@texi_deps, $vtexi) if $vtexi;
1285 # Canonicalize name first.
1286 ($canonical = $infobase) =~ tr/A-Za-z0-9_/_/c;
1287 if (&variable_defined ($canonical . "_TEXINFOS"))
1288 {
1289 push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
1290 &push_dist_common ('$(' . $canonical . '_TEXINFOS)');
1291 }
1293 $output_rules .= ("\n" . $infobase . ".info: "
1294 . join (' ', @texi_deps)
1295 . "\n" . $infobase . ".dvi: "
1296 . join (' ', @texi_deps)
1297 . "\n\n");
1299 # FIXME: this distributes too much. How to find out precisely
1300 # which files will be generated by `makeinfo'?
1301 push (@infos_list, $infobase . '.info', $infobase . '.info[-0-9]*');
1302 push (@info_deps_list, $infobase . '.info');
1303 push (@dvis_list, $infobase . '.dvi');
1305 # Generate list of things to clean for this target. We do
1306 # this explicitly because otherwise too many things could be
1307 # removed. In particular the ".log" extension might
1308 # reasonably be used in other contexts by the user.
1309 foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns',
1310 'ky', 'log', 'pg', 'toc', 'tp', 'vr', 'op')
1311 {
1312 push (@texi_cleans, $infobase . '.' . $tc_cursor);
1313 }
1314 }
1316 # Some boilerplate.
1317 $output_vars .= &file_contents ('texinfos-vars');
1318 $output_rules .= &file_contents ('texinfos');
1319 push (@phony, 'install-info', 'uninstall-info');
1321 # How to clean.
1322 $output_rules .= "\nmostlyclean-info:\n";
1323 &pretty_print_rule ("\trm -f", "\t ", @texi_cleans);
1324 $output_rules .= ("\nclean-info:\n\ndistclean-info:\n\n"
1325 . "maintainer-clean-info:\n\t"
1326 . 'rm -f $(INFOS)' . "\n");
1327 &push_phony_cleaners ('info');
1329 push (@suffixes, '.texi', '.texinfo', '.info', '.dvi');
1331 if (! defined $options{'no-installinfo'})
1332 {
1333 push (@uninstall, 'uninstall-info');
1334 push (@installdirs, '$(infodir)');
1335 unshift (@install_data, 'install-info');
1337 # Make sure documentation is made and installed first. Use
1338 # $(INFO_DEPS), not 'info', because otherwise recursive makes
1339 # get run twice during "make all".
1340 unshift (@all, '$(INFO_DEPS)');
1341 }
1342 push (@clean, 'info');
1343 push (@info, '$(INFO_DEPS)');
1344 push (@dvi, '$(DVIS)');
1346 &define_variable ("INFOS", join (' ', @infos_list));
1347 &define_variable ("INFO_DEPS", join (' ', @info_deps_list));
1348 &define_variable ("DVIS", join (' ', @dvis_list));
1349 # This next isn't strictly needed now -- the places that look here
1350 # could easily be changed to look in info_TEXINFOS. But this is
1351 # probably better, in case noinst_TEXINFOS is ever supported.
1352 &define_variable ("TEXINFOS", $contents{'info_TEXINFOS'});
1354 # Do some error checking.
1355 &require_file_with_line ('info_TEXINFOS', $FOREIGN, 'texinfo.tex');
1356 }
1358 # Handle any man pages.
1359 sub handle_man_pages
1360 {
1361 &am_line_error ('MANS', "\`MANS' is an anachronism; use \`man_MANS'")
1362 if &variable_defined ('MANS');
1363 return if ! &variable_defined ('man_MANS');
1365 # We generate the manpage install code by hand to avoid the use of
1366 # basename in the generated Makefile.
1367 local (@mans) = &variable_value_as_list ('man_MANS');
1368 local (%sections, %inames, %mbases, %secmap, %fullsecmap);
1369 local ($i) = 1;
1370 foreach (@mans)
1371 {
1372 # FIXME: statement without effect:
1373 /^(.*)\.([0-9])([a-z]*)$/;
1374 $sections{$2} = 1;
1375 $inames{$i} = $_;
1376 $mbases{$i} = $1;
1377 $secmap{$i} = $2;
1378 $fullsecmap{$i} = $2 . $3;
1379 $i++;
1380 }
1382 # We don't really need this, but we use it in case we ever want to
1383 # support noinst_MANS.
1384 &define_variable ("MANS", $contents{'man_MANS'});
1386 # Generate list of install dirs.
1387 $output_rules .= "install-man: \$(MANS)\n";
1388 $output_rules .= "\t\$(NORMAL_INSTALL)\n";
1389 foreach (keys %sections)
1390 {
1391 push (@installdirs, '$(mandir)/man' . $_)
1392 unless defined $options{'no-installman'};
1393 $output_rules .= ("\t" . '$(mkinstalldirs) $(mandir)/man'
1394 . $_ . "\n");
1395 }
1396 push (@phony, 'install-man');
1398 # Generate install target.
1399 local ($key);
1400 foreach $key (keys %inames)
1401 {
1402 $_ = $install_man_format;
1403 s/\@SECTION\@/$secmap{$key}/g;
1404 s/\@MAN\@/$inames{$key}/g;
1405 s/\@FULLSECT\@/$fullsecmap{$key}/g;
1406 s/\@MANBASE\@/$mbases{$key}/g;
1407 $output_rules .= $_;
1408 }
1409 $output_rules .= "\n";
1411 $output_rules .= "uninstall-man:\n";
1412 foreach $key (keys %inames)
1413 {
1414 $_ = $uninstall_man_format;
1415 s/\@SECTION\@/$secmap{$key}/g;
1416 s/\@MAN\@/$inames{$key}/g;
1417 s/\@FULLSECT\@/$fullsecmap{$key}/g;
1418 s/\@MANBASE\@/$mbases{$key}/g;
1419 $output_rules .= $_;
1420 }
1421 $output_rules .= "\n";
1422 push (@phony, 'uninstall-man');
1424 $output_vars .= &file_contents ('mans-vars');
1426 if (! defined $options{'no-installman'})
1427 {
1428 push (@install_data, 'install-man');
1429 push (@uninstall, 'uninstall-man');
1430 push (@all, '$(MANS)');
1431 }
1432 }
1434 # Handle DATA variables.
1435 sub handle_data
1436 {
1437 &am_install_var ('data', 'DATA', 'data', 'sysconf',
1438 'sharedstate', 'localstate', 'pkgdata',
1439 'noinst', 'check');
1440 }
1442 # Handle TAGS.
1443 sub handle_tags
1444 {
1445 local ($tagging) = 0;
1447 push (@phony, 'tags');
1448 if (&variable_defined ('SUBDIRS'))
1449 {
1450 $output_rules .= &file_contents ('tags');
1451 push (@phony, 'tags-recursive');
1452 $tagging = 1;
1453 }
1454 elsif ($dir_holds_sources
1455 || $dir_holds_headers
1456 || &variable_defined ('ETAGS_ARGS'))
1457 {
1458 $output_rules .= &file_contents ('tags-subd');
1459 $tagging = 1;
1460 }
1462 if ($tagging)
1463 {
1464 $output_rules .= &file_contents ('tags-clean');
1465 push (@clean, 'tags');
1466 &push_phony_cleaners ('tags');
1467 }
1468 else
1469 {
1470 # Every Makefile must define some sort of TAGS rule.
1471 # Otherwise, it would be possible for a top-level "make TAGS"
1472 # to fail because some subdirectory failed.
1473 $output_rules .= "tags: TAGS\nTAGS:\n\n";
1474 }
1475 }
1477 # Worker for handle_dist.
1478 sub handle_dist_worker
1479 {
1480 $output_rules .= 'distdir: $(DEP_DISTFILES)' . "\n";
1482 # Initialization; only at top level.
1483 if ($relative_dir eq '.')
1484 {
1485 if ($strictness >= $GNITS)
1486 {
1487 # For Gnits users, this is pretty handy. Look at 15 lines
1488 # in case some explanatory text is desirable.
1489 $output_rules .= ' @if sed 15q $(srcdir)/NEWS | fgrep -e "$(VERSION)" > /dev/null; then :; else \\
1490 echo "NEWS not updated; not releasing" 1>&2; \\
1491 exit 1; \\
1492 fi
1493 ';
1494 }
1497 $output_rules .=
1498 # Create dist directory.
1499 ' rm -rf $(distdir)
1500 mkdir $(distdir)
1501 -chmod 755 $(distdir)
1502 ';
1504 # Only run automake in `dist' target if --include-deps not
1505 # specified. That way the recipient of a distribution can run
1506 # "make dist" and not need Automake.
1507 if ($cmdline_use_dependencies)
1508 {
1509 $output_rules .=
1510 (
1511 # We need an absolute path for --output-dir. Thus the
1512 # weirdness.
1513 ' here=`pwd`; distdir=`cd $(distdir) && pwd` \\
1514 && cd $(srcdir) \\
1515 && automake --include-deps --build-dir=$$here --srcdir-name=$(srcdir) --output-dir=$$distdir --strictness='
1516 # Set strictness of output.
1517 . $strictness_name . "\n"
1518 );
1519 }
1520 }
1522 # In loop, test for file existence because sometimes a file gets
1523 # included in DISTFILES twice. For example this happens when a
1524 # single source file is used in building more than one program.
1525 # Also, there are situations in which "ln" can fail. For instance
1526 # a file to distribute could actually be a cross-filesystem
1527 # symlink -- this can easily happen if "gettextize" was run on the
1528 # distribution. Note that DISTFILES can contain a wildcard (for
1529 # info files, sigh), so we must use the echo trick.
1530 $output_rules .= ' @for file in `cd $(srcdir) && echo $(DISTFILES)`; do \\
1531 test -f $(distdir)/$$file \\
1532 || ln $(srcdir)/$$file $(distdir)/$$file 2> /dev/null \\
1533 || cp -p $(srcdir)/$$file $(distdir)/$$file; \\
1534 done
1535 ';
1537 # If we have SUBDIRS, create all dist subdirectories and do
1538 # recursive build.
1539 if (&variable_defined ('SUBDIRS'))
1540 {
1541 # Test for directory existence here because previous automake
1542 # invocation might have created some directories. Note that
1543 # we explicitly set distdir for the subdir make; that lets us
1544 # mix-n-match many automake-using packages into one large
1545 # package, and have "dist" at the top level do the right
1546 # thing.
1547 $output_rules .= ' for subdir in $(SUBDIRS); do \\
1548 test -d $(distdir)/$$subdir \\
1549 || mkdir $(distdir)/$$subdir \\
1550 || exit 1; \\
1551 chmod 755 $(distdir)/$$subdir; \\
1552 (cd $$subdir && $(MAKE) distdir=../$(distdir)/$$subdir distdir) \\
1553 || exit 1; \\
1554 done
1555 ';
1556 }
1558 # If the target `dist-hook' exists, run it now. This allows
1559 # users to do random weird things to the distribution before it is
1560 # packaged up.
1561 if (defined $contents{'dist-hook'})
1562 {
1563 $output_rules .= "\t\$(MAKE) dist-hook\n";
1564 }
1566 push (@phony, 'distdir');
1567 }
1569 # Handle 'dist' target.
1570 sub handle_dist
1571 {
1572 # Set up maint_charset.
1573 $local_maint_charset = $contents{'MAINT_CHARSET'}
1574 if &variable_defined ('MAINT_CHARSET');
1575 $maint_charset = $local_maint_charset
1576 if $relative_dir eq '.';
1578 if (&variable_defined ('DIST_CHARSET'))
1579 {
1580 &am_line_error ('DIST_CHARSET',
1581 "DIST_CHARSET defined but no MAINT_CHARSET defined")
1582 if ! $local_maint_charset;
1583 if ($relative_dir eq '.')
1584 {
1585 $dist_charset = $contents{'DIST_CHARSET'}
1586 }
1587 else
1588 {
1589 &am_line_error ('DIST_CHARSET',
1590 "DIST_CHARSET can only be defined at top level");
1591 }
1592 }
1594 # Look for common files that should be included in distribution.
1595 local ($cfile);
1596 foreach $cfile (@common_files)
1597 {
1598 if (-f ($relative_dir . "/" . $cfile))
1599 {
1600 &push_dist_common ($cfile);
1601 }
1602 }
1604 # Keys of %dist_common are names of files to distributed. We put
1605 # README first because it then becomes easier to make a
1606 # Usenet-compliant shar file (in these, README must be first).
1607 # FIXME: do more ordering of files here.
1608 local (@coms);
1609 if (defined $dist_common{'README'})
1610 {
1611 push (@coms, 'README');
1612 undef $dist_common{'README'};
1613 }
1614 push (@coms, sort keys %dist_common);
1616 &define_pretty_variable ("DIST_COMMON", @coms);
1617 $output_vars .= "\n";
1619 # Some boilerplate.
1620 $output_vars .= &file_contents ('dist-vars');
1622 # Put these things in rules section so it is easier for whoever
1623 # reads Makefile.in.
1624 if (! &variable_defined ('distdir'))
1625 {
1626 if ($relative_dir eq '.')
1627 {
1628 $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
1629 }
1630 else
1631 {
1632 $output_rules .= ("\n"
1633 . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
1634 . "\n");
1635 }
1636 }
1637 if ($relative_dir ne '.')
1638 {
1639 $output_rules .= "\nsubdir = " . $relative_dir . "\n";
1640 }
1642 # Generate 'dist' target, and maybe dist-shar / dist-zip / dist-tarZ.
1643 if ($relative_dir eq '.')
1644 {
1645 # Rule to check whether a distribution is viable.
1646 $output_rules .= ('# This target untars the dist file and tries a VPATH configuration. Then
1647 # it guarantees that the distribution is self-contained by making another
1648 # tarfile.
1649 distcheck: dist
1650 rm -rf $(distdir)
1651 $(TAR) zxf $(distdir).tar.gz
1652 mkdir $(distdir)/=build
1653 mkdir $(distdir)/=inst
1654 dc_install_base=`cd $(distdir)/=inst && pwd`; \\'
1655 . (defined $contents{'distcheck-hook'}
1656 ? "\t\$(MAKE) distcheck-hook"
1657 : '')
1658 . '
1659 cd $(distdir)/=build \\
1660 && ../configure '
1662 . ($seen_gettext ? '--with-included-gettext ' : '')
1663 . '--srcdir=.. --prefix=$$dc_install_base \\
1664 && $(MAKE) \\
1665 && $(MAKE) dvi \\
1666 && $(MAKE) check \\
1667 && $(MAKE) install \\
1668 && $(MAKE) installcheck \\
1669 && $(MAKE) dist
1670 rm -rf $(distdir)
1671 @echo "========================"; \\
1672 echo "$(distdir).tar.gz is ready for distribution"; \\
1673 echo "========================"
1674 ');
1676 $output_rules .= 'dist: distdir' . "\n\t";
1677 # Ignore return result from chmod, because it might give an
1678 # error if we chmod a symlink.
1679 $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1680 $output_rules .= '$(TAR) chozf $(distdir).tar.gz $(distdir)';
1681 $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1683 if (defined $options{'dist-shar'})
1684 {
1685 $output_rules .= 'dist-shar: distdir' . "\n\t";
1686 # Ignore return result from chmod, because it might give
1687 # an error if we chmod a symlink.
1688 $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1689 $output_rules .= 'shar $(distdir) | gzip > $(distdir).shar.gz';
1690 $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1691 }
1693 if (defined $options{'dist-zip'})
1694 {
1695 $output_rules .= 'dist-zip: distdir' . "\n\t";
1696 $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1697 $output_rules .= 'zip -rq $(distdir).zip $(distdir)';
1698 $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1699 }
1701 if (defined $options{'dist-tarZ'})
1702 {
1703 $output_rules .= 'dist-tarZ: distdir' . "\n\t";
1704 $output_rules .= '-chmod -R a+r $(distdir)' . "\n\t";
1705 $output_rules .= '$(TAR) chf - $(distdir) | compress -c > $(distdir).tar.Z';
1706 $output_rules .= "\n\t" . 'rm -rf $(distdir)' . "\n";
1707 }
1708 }
1710 # Generate distdir target.
1711 &handle_dist_worker;
1712 }
1714 # Scan a single dependency file and rewrite the dependencies as
1715 # appropriate. Essentially this means:
1716 # * Clean out absolute dependencies which are not desirable.
1717 # * Rewrite other dependencies to be relative to $(top_srcdir).
1718 sub scan_dependency_file
1719 {
1720 local ($depfile) = @_;
1722 if (! open (DEP_FILE, $depfile))
1723 {
1724 &am_error ("couldn't open \`$depfile': $!");
1725 return;
1726 }
1727 print "automake: reading $depfile\n" if $verbose;
1729 local ($first_line) = 1;
1730 local ($last_line) = 0;
1731 local ($target, @dependencies);
1732 local ($one_dep, $xform);
1734 local ($srcdir_rx, $fixup_rx);
1735 # If the top srcdir is absolute, then the current directory is
1736 # just relative_dir. But if the top srcdir is relative, then we
1737 # need to add some dots first. The same holds when matching
1738 # srcdir directly.
1739 if ($srcdir_name =~ /^\//)
1740 {
1741 ($fixup_rx = $srcdir_name . '/' . $relative_dir . '/')
1742 =~ s/(\W)/\\$1/g;
1743 ($srcdir_rx = $srcdir_name) =~ s/(\W)/\\$1/g;
1744 }
1745 else
1746 {
1747 ($fixup_rx = ($srcdir_name . '/' . $top_builddir . '/'
1748 . $relative_dir . '/')) =~ s/(\W)/\\$1/g;
1749 ($srcdir_rx = ($srcdir_name . '/' . $top_builddir))
1750 =~ s/(\W)/\\$1/g;
1751 }
1753 while (<DEP_FILE>)
1754 {
1755 if ($last_line)
1756 {
1757 # If LAST_LINE set then we've already seen what we thought
1758 # was the last line.
1759 goto bad_format;
1760 }
1761 next if (/$WHITE_PATTERN/o);
1762 chop;
1763 if (! s/\\$//)
1764 {
1765 # No trailing "\" means this should be the last line.
1766 $last_line = 1;
1767 }
1769 if ($first_line)
1770 {
1771 if (! /^([^:]+:)(.+)$/)
1772 {
1773 bad_format:
1774 &am_error ("\`$depfile' has incorrect format");
1775 close (DEP_FILE);
1776 return;
1777 }
1779 $target = $1;
1780 $_ = $2;
1782 $first_line = 0;
1783 }
1785 foreach $one_dep (split (' ', $_))
1786 {
1787 if ($one_dep =~ /^$fixup_rx/)
1788 {
1789 # The dependency points to the current directory in
1790 # some way.
1791 ($xform = $one_dep) =~ s/^$fixup_rx//;
1792 push (@dependencies, $xform);
1793 }
1794 elsif ($one_dep =~ /^$srcdir_rx\//)
1795 {
1796 # The dependency is in some other directory in the package.
1797 ($xform = $one_dep) =~ s/^$srcdir_rx/$top_builddir/;
1798 push (@dependencies, $xform);
1799 }
1800 elsif ($one_dep =~ /^\//)
1801 {
1802 # Absolute path; ignore.
1803 }
1804 else
1805 {
1806 # Anything else is assumed to be correct.
1807 push (@dependencies, $one_dep);
1808 }
1809 }
1810 }
1812 &pretty_print_rule ($target, "\t", @dependencies);
1814 close (DEP_FILE);
1815 }
1817 # Handle auto-dependency code.
1818 sub handle_dependencies
1819 {
1820 if ($use_dependencies)
1821 {
1822 # Include GNU-make-specific auto-dep code.
1823 if ($dir_holds_sources)
1824 {
1825 &define_pretty_variable ('DEP_FILES', sort keys %dep_files);
1826 $output_rules .= &file_contents ('depend');
1827 push (@clean, 'depend');
1828 &push_phony_cleaners ('depend');
1829 $output_rules .=
1830 &file_contents_with_transform ('s/\@EXT\@/.c/g;'
1831 . 's/\@MKDEP\@/MKDEP/g',
1832 'depend2');
1833 local ($ext);
1834 local ($need_cxx) = 0;
1835 foreach $ext (keys %cxx_extensions)
1836 {
1837 $output_rules .=
1838 &file_contents_with_transform ('s/\@EXT\@/' . $ext .'/g;'
1839 . 's/\@MKDEP\@/CXXMKDEP/g',
1840 'depend2');
1841 $need_cxx = 1;
1842 }
1843 if ($need_cxx)
1844 {
1845 &define_variable ('CXXMKDEP', '$(CXX) -MM $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)');
1846 }
1847 }
1848 }
1849 else
1850 {
1851 # FIXME: consider requiring --build-dir here. What about case
1852 # where this is done via an option?
1854 # Include any auto-generated deps that are present. Note that
1855 # $build_directory ends in a "/".
1856 if (-d ($build_directory . $relative_dir . "/.deps")
1857 && -f ($build_directory . $relative_dir . "/.deps/.P"))
1858 {
1859 local ($depfile);
1860 local ($gpat) = $build_directory . $relative_dir . "/.deps/*.P";
1862 foreach $depfile (<${gpat}>)
1863 {
1864 &scan_dependency_file ($depfile);
1865 }
1867 $output_rules .= "\n";
1868 }
1869 }
1870 }
1872 # Handle subdirectories.
1873 sub handle_subdirs
1874 {
1875 if (! &variable_defined ('SUBDIRS'))
1876 {
1877 &am_conf_error
1878 ("ud_GNU_GETTEXT in configure.in but SUBDIRS not defined")
1879 if $seen_gettext && $relative_dir eq '.';
1880 return;
1881 }
1883 &require_file_with_conf_line ($ac_gettext_line, $FOREIGN, 'ABOUT-NLS')
1884 if $seen_gettext;
1886 return if ! &variable_defined ('SUBDIRS');
1888 # Make sure each directory mentioned in SUBDIRS actually exists.
1889 local ($dir);
1890 foreach $dir (&variable_value_as_list ('SUBDIRS'))
1891 {
1892 # Skip directories substituted by configure.
1893 next if $dir =~ /^\@.*\@$/;
1894 &am_line_error ('SUBDIRS',
1895 "required directory $relative_dir/$dir does not exist")
1896 if ! -d $relative_dir . '/' . $dir;
1897 }
1899 $output_rules .= &file_contents ('subdirs');
1901 # Push a bunch of phony targets.
1902 local ($phonies);
1903 foreach $phonies ('-data', '-exec', 'dirs')
1904 {
1905 push (@phony, 'install' . $phonies . '-recursive');
1906 push (@phony, 'uninstall' . $phonies . '-recursive');
1907 }
1908 foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
1909 {
1910 push (@phony, $phonies . '-recursive');
1911 }
1912 &push_phony_cleaners ('recursive');
1914 push (@check, "check-recursive");
1915 push (@installcheck, "installcheck-recursive");
1916 push (@info, "info-recursive");
1917 push (@dvi, "dvi-recursive");
1919 $recursive_install = 1;
1920 }
1922 # Handle aclocal.m4.
1923 sub handle_aclocal_m4
1924 {
1925 local ($regen_aclocal) = 0;
1926 if (-f 'aclocal.m4')
1927 {
1928 &define_variable ("ACLOCAL", "aclocal.m4");
1929 &push_dist_common ('aclocal.m4');
1931 if (open (ACLOCAL, '< aclocal.m4'))
1932 {
1933 local ($line);
1934 $line = <ACLOCAL>;
1935 close (ACLOCAL);
1937 if ($line =~ 'generated automatically by aclocal')
1938 {
1939 $regen_aclocal = 1;
1940 }
1941 }
1942 }
1944 local ($acinclude) = 0;
1945 if (-f 'acinclude.m4')
1946 {
1947 $regen_aclocal = 1;
1948 $acinclude = 1;
1949 }
1951 # Note that it might be possible that aclocal.m4 doesn't exist but
1952 # should be auto-generated. This case probably isn't very
1953 # important.
1954 if ($regen_aclocal)
1955 {
1956 $output_rules .= ("aclocal.m4: "
1957 . ($seen_maint_mode ? "\@MAINT\@" : "")
1958 . "configure.in"
1959 . ($acinclude ? ' acinclude.m4' : '')
1960 . "\n\t"
1961 . 'cd $(srcdir) && aclocal'
1962 . "\n");
1963 }
1964 }
1966 # Handle remaking and configure stuff.
1967 sub handle_configure
1968 {
1969 # If SUBDIRS defined, require AC_PROG_MAKE_SET.
1970 &am_line_error ('SUBDIRS', "AC_PROG_MAKE_SET must be used in configure.in")
1971 if &variable_defined ('SUBDIRS') && ! $seen_make_set;
1973 local ($top_reldir);
1974 if ($relative_dir ne '.')
1975 {
1976 # In subdirectory.
1977 $output_rules .= &file_contents ('remake-subd');
1978 $top_reldir = '../';
1979 }
1980 else
1981 {
1982 &handle_aclocal_m4;
1983 $output_rules .= &file_contents_with_transform ('s/\@STRICTNESS\@/'
1984 . $strictness_name
1985 . '/g',
1986 'remake');
1987 $top_reldir = '';
1988 }
1990 # If we have a configure header, require it.
1991 if ($config_header && $relative_dir eq &dirname ($config_header))
1992 {
1993 local ($ch_sans_dir) = &basename ($config_header);
1994 local ($cn_sans_dir) = &basename ($config_name);
1996 &require_file_with_conf_line ($config_header_line,
1997 $FOREIGN, $ch_sans_dir);
1999 # Header defined and in this directory.
2000 if (-f $relative_dir . '/acconfig.h')
2001 {
2002 &define_variable ("ACCONFIG", "acconfig.h");
2003 &push_dist_common ('acconfig.h');
2004 }
2005 if (-f $config_name . '.top')
2006 {
2007 &define_variable ("CONFIG_TOP", "${cn_sans_dir}.top");
2008 &push_dist_common ($cn_sans_dir . '.top');
2009 }
2010 if (-f $config_name . '.bot')
2011 {
2012 &define_variable ("CONFIG_BOT", "${cn_sans_dir}.bot");
2013 &push_dist_common ($cn_sans_dir . '.bot');
2014 }
2016 &touch ($relative_dir . '/stamp-h.in');
2017 &require_file_with_conf_line ($config_header_line, $FOREIGN,
2018 'stamp-h.in');
2020 $output_rules .= &file_contents ('remake-hdr');
2021 push (@clean, 'hdr');
2022 &push_phony_cleaners ('hdr');
2023 &define_variable ("CONFIG_HEADER_IN", "${ch_sans_dir}");
2024 }
2026 # Set location of mkinstalldirs.
2027 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
2028 {
2029 &define_variable ('mkinstalldirs', $config_aux_dir . '/mkinstalldirs');
2030 }
2031 else
2032 {
2033 &define_variable ('mkinstalldirs', '$(top_srcdir)/mkinstalldirs');
2034 }
2036 &am_line_error ('CONFIG_HEADER',
2037 "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
2038 if &variable_defined ('CONFIG_HEADER');
2040 if ($config_name)
2041 {
2042 # Generate CONFIG_HEADER define.
2043 if ($relative_dir eq &dirname ($config_name))
2044 {
2045 &define_variable ("CONFIG_HEADER", &basename ($config_name));
2046 }
2047 else
2048 {
2049 &define_variable ("CONFIG_HEADER",
2050 "${top_builddir}/${config_name}");
2051 }
2052 }
2054 # Now look for other files in this directory which must be remade
2055 # by config.status, and generate rules for them.
2056 local (@actual_other_files) = ();
2057 local ($file, $local, $input);
2058 foreach $file (@other_input_files)
2059 {
2060 # Skip files not in this directory, any Makefile, and the
2061 # config header. These last two must be handled specially.
2062 next unless &dirname ($file) eq $relative_dir;
2063 next if $file eq $top_builddir . '/' . $config_name;
2064 ($local = $file) =~ s/^.*\///;
2065 next if $local eq 'Makefile';
2067 if ($local =~ /^(.*):(.*)$/)
2068 {
2069 # This is the ":" syntax of AC_OUTPUT.
2070 $input = $2;
2071 $local = $1;
2072 }
2073 else
2074 {
2075 # Normal usage.
2076 $input = $local . '.in';
2077 }
2078 # FIXME: when using autoconf ":" syntax, should we set CONFIG_FILES
2079 # to $local:$input?
2080 $output_rules .= ($local . ': '
2081 . '$(top_builddir)/config.status ' . $input . "\n"
2082 . "\t"
2083 . 'cd $(top_builddir) && CONFIG_FILES='
2084 . ($relative_dir eq '.' ? '' : '$(subdir)/')
2085 . '$@ CONFIG_HEADERS= ./config.status'
2086 . "\n");
2087 push (@actual_other_files, $local);
2089 &require_file_with_conf_line ($ac_output_line, $FOREIGN,
2090 $input);
2091 }
2093 # These files get removed by "make clean".
2094 &define_pretty_variable ('CONFIG_CLEAN_FILES', @actual_other_files);
2095 }
2097 # Handle C headers.
2098 sub handle_headers
2099 {
2100 $dir_holds_headers = &am_install_var ('header', 'HEADERS', 'include',
2101 'oldinclude', 'pkginclude',
2102 'noinst', 'check');
2103 }
2105 sub handle_gettext
2106 {
2107 return if ! $seen_gettext || $relative_dir ne '.';
2109 if (&variable_defined ('SUBDIRS'))
2110 {
2111 &am_line_error
2112 ('SUBDIRS',
2113 "ud_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
2114 if $contents{'SUBDIRS'} !~ /\bpo\b/;
2115 &am_line_error
2116 ('SUBDIRS',
2117 "ud_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
2118 if $contents{'SUBDIRS'} !~ /\bintl\b/;
2119 }
2121 # Ensure that each language in ALL_LINGUAS has a .po file, and
2122 # each po file is mentioned in ALL_LINGUAS.
2123 if ($seen_linguas)
2124 {
2125 local (%linguas) = ();
2126 grep ($linguas{$_} = 1, split (' ', $all_linguas));
2128 foreach (<po/*.po>)
2129 {
2130 s/^po\///;
2131 s/\.po$//;
2133 &am_line_error ($all_linguas_line,
2134 ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
2135 if ! $linguas{$_};
2136 }
2138 foreach (keys %linguas)
2139 {
2140 &am_line_error ($all_linguas_line,
2141 "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
2142 if ! -f "po/$_.po";
2143 }
2144 }
2145 else
2146 {
2147 &am_error ("ud_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
2148 }
2149 }
2151 # Handle footer elements.
2152 sub handle_footer
2153 {
2154 if ($contents{'SOURCES'})
2155 {
2156 # NOTE don't use define_pretty_variable here, because
2157 # $contents{...} is already defined.
2158 $output_vars .= 'SOURCES = ' . $contents{'SOURCES'} . "\n";
2159 }
2160 if ($contents{'OBJECTS'})
2161 {
2162 # NOTE don't use define_pretty_variable here, because
2163 # $contents{...} is already defined.
2164 $output_vars .= 'OBJECTS = ' . $contents{'OBJECTS'} . "\n";
2165 }
2166 if ($contents{'SOURCES'} || $contents{'OBJECTS'})
2167 {
2168 $output_vars .= "\n";
2169 }
2171 if (defined $contents{'SUFFIXES'})
2172 {
2173 # Push actual suffixes, and not $(SUFFIXES). Some versions of
2174 # make do not like variable substitutions on the .SUFFIXES
2175 # line.
2176 push (@suffixes, split (' ', $contents{'SUFFIXES'}));
2177 }
2179 $output_trailer .= ".SUFFIXES:\n";
2180 if (@suffixes)
2181 {
2182 $output_trailer .= ".SUFFIXES: " . join (' ', @suffixes) . "\n";
2183 }
2184 $output_trailer .= &file_contents ('footer');
2185 }
2187 # Deal with installdirs target.
2188 sub handle_installdirs
2189 {
2190 # GNU Makefile standards recommend this.
2191 $output_rules .= ("installdirs:"
2192 . ($recursive_install
2193 ? " installdirs-recursive\n"
2194 : "\n"));
2195 push (@phony, 'installdirs');
2196 if (@installdirs)
2197 {
2198 &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
2199 @installdirs);
2200 }
2201 $output_rules .= "\n";
2202 }
2204 # There are several targets which need to be merged. This is because
2205 # their complete definition is compiled from many parts. Note that we
2206 # avoid double colon rules, otherwise we'd use them instead.
2207 sub handle_merge_targets
2208 {
2209 # There are a few install-related variables that you should not define.
2210 local ($var);
2211 foreach $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
2212 {
2213 if (&variable_defined ($var))
2214 {
2215 &am_line_error ($var, "\`$var' should not be defined");
2216 }
2217 }
2219 push (@all, 'Makefile');
2220 push (@all, $config_name)
2221 if $config_name && &dirname ($config_name) eq $relative_dir;
2223 &do_one_merge_target ('info', @info);
2224 &do_one_merge_target ('dvi', @dvi);
2226 if (! &variable_defined ('SUBDIRS') || $relative_dir ne '.')
2227 {
2228 # 'check' must depend on 'all', but not at top level.
2229 # Ditto install.
2230 unshift (@check, 'all');
2231 unshift (@install, 'all');
2232 }
2233 &do_one_merge_target ('check', @check);
2234 &do_one_merge_target ('installcheck', @installcheck);
2236 # Handle the various install targets specially. We do this so
2237 # that (eg) "make install-exec" will run "install-exec-recursive"
2238 # if required, but "make install" won't run it twice. Step one is
2239 # to see if the user specified local versions of any of the
2240 # targets we handle. "all" is treated as one of these since
2241 # "install" can run it.
2242 push (@install_exec, 'install-exec-local')
2243 if defined $contents{'install-exec-local'};
2244 push (@install_data, 'install-data-local')
2245 if defined $contents{'install-data-local'};
2246 push (@uninstall, 'uninstall-local')
2247 if defined $contents{'uninstall-local'};
2248 local ($utarg);
2249 foreach $utarg ('uninstall-data-local', 'uninstall-data-hook',
2250 'uninstall-exec-local', 'uninstall-exec-hook')
2251 {
2252 if (defined $contents{$utarg})
2253 {
2254 local ($x);
2255 ($x = $utarg) =~ s/(data|exec)-//;
2256 &am_line_error ($utarg, "use \`$x', not \`$utarg'");
2257 }
2258 }
2259 push (@all, 'all-local')
2260 if defined $contents{'all-local'};
2262 if (defined $contents{'install-local'})
2263 {
2264 &am_line_error ('install-local',
2265 "use \`install-data' or \`install-exec', not \`install'");
2266 }
2268 # Step two: if we are doing recursive makes, write out the
2269 # appropriate rules.
2270 local (@install);
2271 if ($recursive_install)
2272 {
2273 push (@install, 'install-recursive');
2275 if (@all)
2276 {
2277 local (@hackall) = ();
2278 if ($config_name && &dirname ($config_name) eq $relative_dir)
2279 {
2281 # This is kind of a hack, but I couldn't see a better
2282 # way to handle it. In this particular case, we need
2283 # to make sure config.h is built before we recurse.
2284 # We can't do this by changing the order of
2285 # dependencies to the "all" because that breaks when
2286 # using parallel makes. Instead we handle things
2287 # explicitly.
2288 $output_rules .= ('all-recursive-hack: $(CONFIG_HEADER)'
2289 . "\n\t" . '$(MAKE) all-recursive'
2290 . "\n\n");
2291 push (@hackall, 'all-recursive-hack');
2292 push (@phony, 'all-recursive-hack');
2293 }
2294 else
2295 {
2296 push (@hackall, 'all-recursive');
2297 }
2299 $output_rules .= ('all-am: '
2300 . join (' ', @all)
2301 . "\n\n");
2302 @all = @hackall;
2303 push (@all, 'all-am');
2304 push (@phony, 'all-am');
2305 }
2306 else
2307 {
2308 @all = ('all-recursive');
2309 }
2310 if (@install_exec)
2311 {
2312 $output_rules .= ('install-exec-am: '
2313 . join (' ', @install_exec)
2314 . "\n\n");
2315 @install_exec = ('install-exec-recursive', 'install-exec-am');
2316 push (@install, 'install-exec-am');
2317 push (@phony, 'install-exec-am');
2318 }
2319 else
2320 {
2321 @install_exec = ('install-exec-recursive');
2322 }
2323 if (@install_data)
2324 {
2325 $output_rules .= ('install-data-am: '
2326 . join (' ', @install_data)
2327 . "\n\n");
2328 @install_data = ('install-data-recursive', 'install-data-am');
2329 push (@install, 'install-data-am');
2330 push (@phony, 'install-data-am');
2331 }
2332 else
2333 {
2334 @install_data = ('install-data-recursive');
2335 }
2336 if (@uninstall)
2337 {
2338 $output_rules .= ('uninstall-am: '
2339 . join (' ', @uninstall)
2340 . "\n\n");
2341 @uninstall = ('uninstall-recursive', 'uninstall-am');
2342 push (@phony, 'uninstall-am');
2343 }
2344 else
2345 {
2346 @uninstall = ('uninstall-recursive');
2347 }
2348 }
2350 # Step three: print definitions users can use. Code below knows
2351 # that install-exec is done before install-data, beware.
2352 $output_rules .= ("install-exec: "
2353 . join (' ', @install_exec)
2354 . "\n");
2355 $output_rules .= "\t\$(NORMAL_INSTALL)\n";
2356 if (defined $contents{'install-exec-hook'})
2357 {
2358 $output_rules .= "\t" . '$(MAKE) install-exec-hook' . "\n";
2359 }
2360 $output_rules .= "\n";
2361 push (@install, 'install-exec') if !$recursive_install;
2362 push (@phony, 'install-exec');
2364 $output_rules .= ("install-data: "
2365 . join (' ', @install_data)
2366 . "\n");
2367 $output_rules .= "\t\$(NORMAL_INSTALL)\n";
2368 if (defined $contents{'install-data-hook'})
2369 {
2370 $output_rules .= "\t" . '$(MAKE) install-data-hook' . "\n";
2371 }
2372 $output_rules .= "\n";
2373 push (@install, 'install-data') if !$recursive_install;
2374 push (@phony, 'install-data');
2376 # If no dependencies for 'install', add 'all'. Why? That way
2377 # "make install" at top level of distclean'd distribution won't
2378 # fail because stuff in 'lib' fails to build.
2379 if (! @install || (scalar (@install) == 2
2380 && $install[0] eq 'install-exec'
2381 && $install[1] eq 'install-data'))
2382 {
2383 push (@install, 'all');
2384 }
2385 $output_rules .= ('install: '
2386 . join (' ', @install)
2387 # Use "@:" as empty command so nothing prints.
2388 . "\n\t\@:"
2389 . "\n\n"
2390 . 'uninstall: '
2391 . join (' ', @uninstall)
2392 . "\n\n");
2393 push (@phony, 'install', 'uninstall');
2395 $output_rules .= ('all: '
2396 . join (' ', @all)
2397 . "\n\n");
2398 push (@phony, 'all');
2400 # Generate the new 'install-strip' target.
2401 $output_rules .= ("install-strip:\n\t"
2402 . '$(MAKE) INSTALL_PROGRAM=\'$(INSTALL_PROGRAM) -s\' install'
2403 . "\n");
2404 }
2406 # Helper for handle_merge_targets.
2407 sub do_one_merge_target
2408 {
2409 local ($name, @values) = @_;
2411 if (defined $contents{$name . '-local'})
2412 {
2413 # User defined local form of target. So include it.
2414 push (@values, $name . '-local');
2415 push (@phony, $name . '-local');
2416 }
2418 $output_rules .= $name . ":";
2419 if (@values)
2420 {
2421 $output_rules .= ' ' . join (' ', @values);
2422 }
2423 $output_rules .= "\n\n";
2424 push (@phony, $name);
2425 }
2427 # Handle all 'clean' targets.
2428 sub handle_clean
2429 {
2430 push (@clean, 'generic');
2431 $output_rules .= &file_contents ('clean');
2432 &push_phony_cleaners ('generic');
2434 local ($target) = $recursive_install ? 'clean-am' : 'clean';
2435 &do_one_clean_target ($target, 'mostly', '', @clean);
2436 &do_one_clean_target ($target, '', 'mostly', @clean);
2437 &do_one_clean_target ($target, 'dist', '', @clean);
2438 &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
2440 push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
2442 local (@deps);
2443 if ($recursive_install)
2444 {
2445 @deps = ('am', 'recursive');
2446 &do_one_clean_target ('', 'mostly', '', @deps);
2447 &do_one_clean_target ('', '', '', @deps);
2448 &do_one_clean_target ('', 'dist', '', @deps);
2449 &do_one_clean_target ('', 'maintainer-', '', @deps);
2450 }
2451 }
2453 # Helper for handle_clean.
2454 sub do_one_clean_target
2455 {
2456 local ($target, $name, $last_name, @deps) = @_;
2458 # Special case: if target not passed, then don't generate
2459 # dependency on next "lower" clean target (eg no
2460 # clean<-mostlyclean derivation). In this case the target is
2461 # implicitly known to be 'clean'.
2462 local ($flag) = $target;
2463 $target = 'clean' if ! $flag;
2465 grep (($_ = $name . 'clean-' . $_) && 0, @deps);
2466 if ($flag)
2467 {
2468 if ($last_name || $name ne 'mostly')
2469 {
2470 push (@deps, $last_name . $target . " ");
2471 }
2472 }
2473 # FIXME: not sure if I like the tabs here.
2474 &pretty_print_rule ($name . $target . ": ", "\t\t", @deps);
2476 # FIXME: shouldn't we really print these messages before running
2477 # the dependencies?
2478 if ($name . $target eq 'maintainer-clean')
2479 {
2480 # Print a special warning.
2481 $output_rules .=
2482 ("\t\@echo \"This command is intended for maintainers to use;\"\n"
2483 . "\t\@echo \"it deletes files that may require special "
2484 . "tools to rebuild.\"\n");
2486 $output_rules .= "\trm -f config.status\n"
2487 if $relative_dir eq '.';
2488 }
2489 elsif ($name . $target eq 'distclean')
2490 {
2491 $output_rules .= "\trm -f config.status\n";
2492 }
2493 $output_rules .= "\n";
2494 }
2496 # Handle .PHONY target.
2497 sub handle_phony
2498 {
2499 &pretty_print_rule ('.PHONY:', "", @phony);
2500 $output_rules .= "\n";
2501 }
2503 # Handle TESTS variable and other checks.
2504 sub handle_tests
2505 {
2506 if (defined $options{'dejagnu'})
2507 {
2508 push (@check, 'check-DEJAGNU');
2509 push (@phony, 'check-DEJAGNU');
2510 $output_rules .= &file_contents ('dejagnu') . "\n";
2511 # Note that in the rule we don't directly generate site.exp to
2512 # avoid the possibility of a corrupted site.exp if make is
2513 # interrupted. Jim Meyering has some useful text on this
2514 # topic.
2515 $output_rules .= ("site.exp: Makefile\n"
2516 . "\t\@echo 'Making a new site.exp file...'\n"
2517 . "\t-\@rm -f site.bak\n"
2518 . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
2519 . "\t\@echo '# Do not edit here. If you wish to override these values' >> \$\@-t\n"
2520 . "\t\@echo '# edit the last section' >> \$\@-t\n"
2521 . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
2522 . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
2523 . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
2525 # Extra stuff for AC_CANONICAL_*
2526 local (@whatlist) = ();
2527 if ($seen_canonical)
2528 {
2529 push (@whatlist, 'host')
2530 }
2532 # Extra stuff only for AC_CANONICAL_SYSTEM.
2533 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
2534 {
2535 push (@whatlist, 'target', 'build');
2536 }
2538 local ($c1, $c2);
2539 foreach $c1 (@whatlist)
2540 {
2541 foreach $c2 ('alias', 'triplet')
2542 {
2543 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
2544 }
2545 }
2547 $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
2548 . "\t-\@sed '1,/^## All variables above are.*##/ d' site.bak >> \$\@-t\n"
2549 . "\t-\@mv site.exp site.bak\n"
2550 . "\t\@mv \$\@-t site.exp\n");
2551 }
2552 else
2553 {
2554 local ($c);
2555 foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
2556 {
2557 if (&variable_defined ($c))
2558 {
2559 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
2560 }
2561 }
2562 }
2564 if (&variable_defined ('TESTS'))
2565 {
2566 push (@check, 'check-TESTS');
2567 push (@phony, 'check-TESTS');
2568 # FIXME: use $(SHELL) here? That is what Ulrich suggests.
2569 # Maybe a new macro, $(TEST_SHELL), a la $(CONFIG_SHELL)? For
2570 # now we just execute the file directly; this allows test
2571 # files which are compiled -- a possibly useful feature.
2572 $output_rules .= 'check-TESTS: $(TESTS)
2573 @failed=0; all=0; \\
2574 srcdir=$(srcdir); export srcdir; \\
2575 for tst in $(TESTS); do \\
2576 all=`expr $$all + 1`; \\
2577 if test -f $$tst; then dir=.; \\
2578 else dir="$(srcdir)"; fi; \\
2579 if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \\
2580 echo "PASS: $$tst"; \\
2581 else \\
2582 failed=`expr $$failed + 1`; \\
2583 echo "FAIL: $$tst"; \\
2584 fi; \\
2585 done; \\
2586 if test "$$failed" -eq 0; then \\
2587 echo "========================"; \\
2588 echo "All $$all tests passed"; \\
2589 echo "========================"; \\
2590 else \\
2591 echo "$$failed of $$all tests failed"; \\
2592 fi
2593 ';
2594 }
2595 }
2597 # Handle Emacs Lisp.
2598 sub handle_emacs_lisp
2599 {
2600 local (@elfiles) = &am_install_var ('lisp', 'LISP', 'lisp', 'noinst');
2602 if (@elfiles)
2603 {
2604 # Found some lisp.
2605 &define_variable ("lispdir", "\@lispdir\@");
2606 $output_rules .= (".el.elc:\n"
2607 . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
2608 . "\t\$(SHELL) \$(srcdir)/elisp-comp \$<\n");
2609 push (@suffixes, '.el', '.elc');
2611 # Generate .elc files.
2612 grep ($_ .= 'c', @elfiles);
2613 &define_pretty_variable ('ELCFILES', @elfiles);
2615 push (@clean, 'lisp');
2616 &push_phony_cleaners ('lisp');
2618 local ($varname);
2619 if (&variable_defined ('lisp_LISP'))
2620 {
2621 $varname = 'lisp_LISP';
2622 &am_error ("\`lisp_LISP' defined but \`AM_PATH_LISPDIR' not in \`configure.in'")
2623 if ! $seen_lispdir;
2624 }
2625 else
2626 {
2627 $varname = 'noinst_LISP';
2628 }
2630 &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
2631 }
2632 }
2634 ################################################################
2636 # Scan configure.in for interesting things.
2637 sub scan_configure
2638 {
2639 open (CONFIGURE, 'configure.in')
2640 || die "automake: couldn't open \`configure.in': $!\n";
2641 print "automake: reading configure.in\n" if $verbose;
2643 # Reinitialize libsources here. This isn't really necessary,
2644 # since we currently assume there is only one configure.in. But
2645 # that won't always be the case.
2646 %libsources = ();
2648 local ($in_ac_output, @make_list) = 0;
2649 local ($libobj_iter);
2650 while (<CONFIGURE>)
2651 {
2652 # Remove comments from current line.
2653 s/\bdnl\b.*$//;
2654 s/\#.*$//;
2656 # Populate libobjs array.
2657 if (/AC_FUNC_ALLOCA/)
2658 {
2659 $libsources{'alloca.c'} = 1;
2660 }
2661 elsif (/AC_FUNC_GETLOADAVG/)
2662 {
2663 $libsources{'getloadavg.c'} = 1;
2664 }
2665 elsif (/AC_FUNC_MEMCMP/)
2666 {
2667 $libsources{'memcmp.c'} = 1;
2668 }
2669 elsif (/AC_STRUCT_ST_BLOCKS/)
2670 {
2671 $libsources{'fileblocks.c'} = 1;
2672 }
2673 elsif (/AM_FUNC_FNMATCH/)
2674 {
2675 $libsources{'fnmatch.c'} = 1;
2676 }
2677 elsif (/AC_REPLACE_FUNCS\s*\((.*)\)/)
2678 {
2679 foreach (split (' ', $1))
2680 {
2681 $libsources{$_ . '.c'} = 1;
2682 }
2683 }
2684 elsif (/A[CM]_REPLACE_GNU_GETOPT/)
2685 {
2686 $libsources{'getopt.c'} = 1;
2687 $libsources{'getopt1.c'} = 1;
2688 }
2689 elsif (/AM_FUNC_STRTOD/)
2690 {
2691 $libsources{'strtod.c'} = 1;
2692 }
2693 elsif (/AM_WITH_REGEX/)
2694 {
2695 $libsources{'rx.c'} = 1;
2696 $libsources{'rx.h'} = 1;
2697 $libsources{'regex.c'} = 1;
2698 $libsources{'regex.h'} = 1;
2699 }
2700 elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
2701 || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
2702 {
2703 foreach $libobj_iter (split (' ', $1))
2704 {
2705 if ($libobj_iter =~ /^(.*)\.o$/)
2706 {
2707 $libsources{$1 . '.c'} = 1;
2708 }
2709 }
2710 }
2712 if (/(fp_FUNC_FNMATCH|fp_PROG_INSTALL|fp_C_PROTOTYPES|jm_MAINTAINER_MODE)/)
2713 {
2714 &am_conf_line_error ($., "\`$1' is obsolete; use corresponding \`AM_' macro");
2715 }
2717 # Process the AC_OUTPUT macro.
2718 if (! $in_ac_output && s/AC_OUTPUT\s*\(\[?//)
2719 {
2720 $in_ac_output = 1;
2721 $ac_output_line = $.;
2722 }
2723 if ($in_ac_output)
2724 {
2725 $in_ac_output = 0 if s/[\]\),].*$//;
2727 # Look at potential Makefile.am's.
2728 foreach (split)
2729 {
2730 next if $_ eq "\\";
2731 if (-f $_ . '.am')
2732 {
2733 push (@make_list, $_);
2734 }
2735 else
2736 {
2737 push (@other_input_files, $_);
2738 }
2739 }
2740 }
2742 if (/AC_CONFIG_AUX_DIR\(([^)]+)\)/)
2743 {
2744 @config_aux_path = $1;
2745 }
2747 # Check for ansi2knr.
2748 $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
2750 # Check for NLS support.
2751 if (/ud_GNU_GETTEXT/)
2752 {
2753 $seen_gettext = 1;
2754 $ac_gettext_line = $.;
2755 }
2757 # Look for ALL_LINGUAS.
2758 if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
2759 {
2760 $seen_linguas = 1;
2761 $all_linguas = $1;
2762 $all_linguas_line = $.;
2763 }
2765 # Handle configuration headers.
2766 if (/AC_CONFIG_HEADER\s*\((.*)\)/)
2767 {
2768 $config_header_line = $.;
2769 $config_name = $1;
2770 if ($config_name =~ /^([^:]+):(.+)$/)
2771 {
2772 $config_name = $1;
2773 $config_header = $2;
2774 }
2775 else
2776 {
2777 $config_header = $config_name . '.in';
2778 }
2779 }
2781 # Handle AC_CANONICAL_*. Always allow upgrading to
2782 # AC_CANONICAL_SYSTEM, but never downgrading.
2783 $seen_canonical = $AC_CANONICAL_HOST
2784 if ! $seen_canonical
2785 && (/AC_CANONICAL_HOST/ || /AC_CHECK_TOOL/);
2786 $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
2788 $seen_path_xtra = 1 if /AC_PATH_XTRA/;
2790 # Sometimes it is desirable to explicitly set YACC. For
2791 # instance some people don't want to use bison.
2792 $seen_prog_yacc = 1 if (/AC_PROG_YACC/
2793 || /AC_SUBST\(YACC\)/
2794 || /AC_(PATH|CHECK)_PROGS?\(YACC/);
2796 # This macro handles several different things.
2797 if (/AM_INIT_AUTOMAKE\([^,]*,([^)]+)\)/)
2798 {
2799 $seen_make_set = 1;
2800 $seen_package = 1;
2801 $seen_version = 1;
2802 $seen_arg_prog = 1;
2803 $seen_prog_install = 2;
2804 ($package_version = $1) =~ s/\s//;
2805 $package_version_line = $.;
2806 }
2808 # Some things required by Automake.
2809 $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
2810 $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
2811 $seen_ranlib = 1 if /AC_PROG_RANLIB/;
2812 $seen_prog_cc = 1 if /AC_PROG_CC/;
2813 $seen_prog_cxx = 1 if /AC_PROG_CXX/;
2814 $seen_prog_lex = 1 if /AC_PROG_LEX/;
2815 $seen_decl_yytext = 1 if /AC_DECL_YYTEXT/;
2816 $seen_maint_mode = 1 if /AM_MAINTAINER_MODE/;
2817 $seen_package = 1 if /PACKAGE=/;
2819 if (/VERSION=(\S+)/)
2820 {
2821 $seen_version = 1;
2822 $package_version = $1;
2823 $package_version_line = $.;
2824 }
2825 elsif (/VERSION=/)
2826 {
2827 $seen_version = 1;
2828 }
2830 # Weird conditionals here because it is always allowed to
2831 # upgrade to AM_PROG_INSTALL but never to downgrade to
2832 # AC_PROG_INSTALL.
2833 $seen_prog_install = 1 if ! $seen_prog_install && /AC_PROG_INSTALL/;
2834 $seen_prog_install = 2 if /AM_PROG_INSTALL/;
2836 $seen_lispdir = 1 if /AM_PATH_LISPDIR/;
2838 if (/AM_PROG_LIBTOOL/)
2839 {
2840 $seen_libtool = 1;
2841 $seen_ranlib = 2;
2842 $libtool_line = $.;
2843 }
2844 }
2846 # Set input files if not specified by user.
2847 @input_files = @make_list if (! @input_files);
2849 close (CONFIGURE);
2851 &am_conf_error ("\`PACKAGE' not defined in configure.in")
2852 if ! $seen_package;
2853 &am_conf_error ("\`VERSION' not defined in configure.in")
2854 if ! $seen_version;
2856 # Look for some files we need. Always check for these. This
2857 # check must be done for every run, even those where we are only
2858 # looking at a subdir Makefile. We must set relative_dir so that
2859 # the file-finding machinery works.
2860 local ($relative_dir) = '.';
2861 &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs');
2862 &am_error ("\`install.sh' is an anachronism; use \`install-sh' instead")
2863 if -f $config_aux_path[0] . '/install.sh';
2864 }
2866 ################################################################
2868 # Do any extra checking for GNU standards.
2869 sub check_gnu_standards
2870 {
2871 if ($relative_dir eq '.')
2872 {
2873 # In top level (or only) directory.
2874 &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
2875 'AUTHORS', 'ChangeLog');
2876 }
2878 if ($strictness >= $GNU)
2879 {
2880 if (defined $options{'no-installman'})
2881 {
2882 &am_line_error ('AUTOMAKE_OPTIONS',
2883 "option \`no-installman' disallowed by GNU standards");
2884 }
2886 if (defined $options{'no-installinfo'})
2887 {
2888 &am_line_error ('AUTOMAKE_OPTIONS',
2889 "option \`no-installinfo' disallowed by GNU standards");
2890 }
2891 }
2892 }
2894 # Do any extra checking for GNITS standards.
2895 sub check_gnits_standards
2896 {
2897 if ($strictness >= $GNITS)
2898 {
2899 if (-f $relative_dir . '/COPYING.LIB')
2900 {
2901 &am_error ("\`${relative_dir}/COPYING.LIB' disallowed by Gnits standards");
2902 }
2904 if ($relative_dir eq '.')
2905 {
2906 if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
2907 {
2908 &am_conf_line_error ($package_version_line,
2909 "version \`$package_version' doesn't follow Gnits standards");
2910 }
2911 elsif (defined $1 && -f 'README-alpha')
2912 {
2913 # This means we have an alpha release. See
2914 # GNITS_VERSION_PATTERN for details.
2915 &require_file ($GNITS, 'README-alpha');
2916 }
2917 }
2918 }
2920 if ($relative_dir eq '.')
2921 {
2922 # In top level (or only) directory.
2923 &require_file ($GNITS, 'THANKS');
2924 }
2925 }
2927 ################################################################
2929 # Pretty-print something. HEAD is what should be printed at the
2930 # beginning of the first line, FILL is what should be printed at the
2931 # beginning of every subsequent line.
2932 sub pretty_print_internal
2933 {
2934 local ($head, $fill, @values) = @_;
2936 local ($column) = length ($head);
2937 local ($result) = $head;
2939 # Fill length is number of characters. However, each Tab
2940 # character counts for eight. So we count the number of Tabs and
2941 # multiply by 7.
2942 local ($fill_length) = length ($fill);
2943 $fill_length += 7 * ($fill =~ tr/\t/\t/d);
2945 local ($bol) = 0;
2946 foreach (@values)
2947 {
2948 # "71" because we also print a space.
2949 if ($column + length ($_) > 71)
2950 {
2951 $result .= " \\\n" . $fill;
2952 $column = $fill_length;
2953 $bol = 1;
2954 }
2956 $result .= ' ' unless ($bol);
2957 $result .= $_;
2958 $column += length ($_) + 1;
2959 $bol = 0;
2960 }
2962 $result .= "\n";
2963 return $result;
2964 }
2966 # Pretty-print something and append to output_vars.
2967 sub pretty_print
2968 {
2969 $output_vars .= &pretty_print_internal (@_);
2970 }
2972 # Pretty-print something and append to output_rules.
2973 sub pretty_print_rule
2974 {
2975 $output_rules .= &pretty_print_internal (@_);
2976 }
2979 ################################################################
2981 # See if a variable exists.
2982 sub variable_defined
2983 {
2984 local ($var) = @_;
2985 if (defined $targets{$var})
2986 {
2987 &am_line_error ($var, "\`$var' is target; expected variable");
2988 return 0;
2989 }
2990 elsif (defined $contents{$var})
2991 {
2992 $content_seen{$var} = 1;
2993 return 1;
2994 }
2995 return 0;
2996 }
2998 # Return contents of variable as list, split as whitespace. This will
2999 # recursively follow $(...) and ${...} inclusions. It preserves @...@
3000 # substitutions. If PARENT is specified, it is the name of the
3001 # including variable; this is only used for error reports.
3002 sub variable_value_as_list
3003 {
3004 local ($var, $parent) = @_;
3005 local (@result);
3007 if (defined $targets{$var})
3008 {
3009 &am_line_error ($var, "\`$var' is target; expected variable");
3010 }
3011 elsif (! defined $contents{$var})
3012 {
3013 &am_line_error ($parent, "variable \`$var' not defined");
3014 }
3015 else
3016 {
3017 $content_seen{$var} = 1;
3018 foreach (split (' ', $contents{$var}))
3019 {
3020 # Handle variable substitutions.
3021 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
3022 {
3023 push (@result, &variable_value_as_list ($1, $var));
3024 }
3025 else
3026 {
3027 push (@result, $_);
3028 }
3029 }
3030 }
3032 return @result;
3033 }
3035 # Define a new variable, but only if not already defined.
3036 sub define_variable
3037 {
3038 local ($var, $value) = @_;
3040 if (! defined $contents{$var})
3041 {
3042 $output_vars .= $var . ' = ' . $value . "\n";
3043 $contents{$var} = $value;
3044 $content_seen{$var} = 1;
3045 }
3046 }
3048 # Like define_variable, but second arg is a list, and is
3049 # pretty-printed.
3050 sub define_pretty_variable
3051 {
3052 local ($var, @value) = @_;
3053 if (! defined $contents{$var})
3054 {
3055 $contents{$var} = join (' ', @value);
3056 &pretty_print ($var . ' = ', '', @value);
3057 $content_seen{$var} = 1;
3058 }
3059 }
3061 # Read Makefile.am and set up %contents. Simultaneously copy lines
3062 # from Makefile.am into $output_trailer or $output_vars as
3063 # appropriate. NOTE we put rules in the trailer section. We want
3064 # user rules to come after our generated stuff.
3065 sub read_am_file
3066 {
3067 local ($amfile) = @_;
3069 # Compute relative location of the top object directory.
3070 local (@topdir) = ();
3071 foreach (split (/\//, $relative_dir))
3072 {
3073 next if $_ eq '.' || $_ eq '';
3074 if ($_ eq '..')
3075 {
3076 pop @topdir;
3077 }
3078 else
3079 {
3080 push (@topdir, '..');
3081 }
3082 }
3083 @topdir = ('.') if ! @topdir;
3085 $top_builddir = join ('/', @topdir);
3086 local ($build_rx);
3087 ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
3088 local ($header_vars) =
3089 &file_contents_with_transform
3090 ('s/\@top_builddir\@/' . $build_rx . '/g',
3091 'header-vars');
3093 # Generate some useful variables when AC_CANONICAL_* used.
3094 if ($seen_canonical)
3095 {
3096 local ($curs, @varlist);
3097 push (@varlist, 'host_alias', 'host_triplet');
3098 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
3099 {
3100 push (@varlist, 'build_alias', 'target_alias');
3101 }
3102 foreach $curs (@varlist)
3103 {
3104 $header_vars .= "$curs = \@$curs\@\n";
3105 $contents{$curs} = "\@$curs\@";
3106 }
3107 }
3109 open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
3110 print "automake: reading $amfile\n" if $verbose;
3112 $output_vars .= ("# $in_file_name generated automatically by automake "
3113 . $VERSION . " from $am_file_name\n");
3115 # Generate copyright for generated Makefile.in.
3116 $output_vars .= $gen_copyright;
3118 local ($saw_bk) = 0;
3119 local ($was_rule) = 0;
3120 local ($spacing) = '';
3121 local ($comment) = '';
3122 local ($last_var_name) = '';
3123 local ($blank) = 0;
3125 while (<AM_FILE>)
3126 {
3127 if (/$IGNORE_PATTERN/o)
3128 {
3129 # Merely delete comments beginning with two hashes.
3130 }
3131 elsif (/$WHITE_PATTERN/o)
3132 {
3133 # Stick a single white line before the incoming macro or rule.
3134 $spacing = "\n";
3135 $blank = 1;
3136 }
3137 elsif (/$COMMENT_PATTERN/o)
3138 {
3139 # Stick comments before the incoming macro or rule. Make
3140 # sure a blank line preceeds first block of comments.
3141 $spacing = "\n" unless $blank;
3142 $blank = 1;
3143 $comment .= $spacing . $_;
3144 $spacing = '';
3145 }
3146 else
3147 {
3148 last;
3149 }
3150 }
3152 $output_vars .= $comment . "\n" . $header_vars;
3153 $comment = '';
3154 $spacing = "\n";
3156 local ($is_ok_macro);
3157 while ($_)
3158 {
3159 $_ .= "\n"
3160 unless substr ($_, -1, 1) eq "\n";
3162 $_ =~ s/\@(UN)?MAINT\@//g
3163 unless $seen_maint_mode;
3165 if (/$IGNORE_PATTERN/o)
3166 {
3167 # Merely delete comments beginning with two hashes.
3168 }
3169 elsif (/$WHITE_PATTERN/o)
3170 {
3171 # Stick a single white line before the incoming macro or rule.
3172 $spacing = "\n";
3173 }
3174 elsif (/$COMMENT_PATTERN/o)
3175 {
3176 # Stick comments before the incoming macro or rule.
3177 $comment .= $spacing . $_;
3178 $spacing = '';
3179 }
3180 elsif ($saw_bk)
3181 {
3182 if ($was_rule)
3183 {
3184 $output_trailer .= $_;
3185 $saw_bk = /\\$/;
3186 }
3187 else
3188 {
3189 $output_vars .= $_;
3190 $saw_bk = /\\$/;
3191 # Chop newline and backslash if this line is
3192 # continued. FIXME: maybe ensure trailing whitespace
3193 # exists?
3194 chop if $saw_bk;
3195 chop if $saw_bk;
3196 $contents{$last_var_name} .= $_;
3197 }
3198 }
3199 elsif (/$RULE_PATTERN/o)
3200 {
3201 # warn "** Saw rule .$1.\n";
3202 # Found a rule.
3203 $was_rule = 1;
3204 # Value here doesn't matter; for targets we only note
3205 # existence.
3206 $contents{$1} = 1;
3207 $targets{$1} = 1;
3208 $content_lines{$1} = $.;
3209 $output_trailer .= $comment . $spacing . $_;
3210 $comment = $spacing = '';
3211 $saw_bk = /\\$/;
3212 }
3213 elsif (($is_ok_macro = /$MACRO_PATTERN/o)
3214 || /$BOGUS_MACRO_PATTERN/o)
3215 {
3216 # Found a macro definition.
3217 $was_rule = 0;
3218 $last_var_name = $1;
3219 if (substr ($2, -1) eq "\\")
3220 {
3221 $contents{$1} = substr ($2, 0, length ($2) - 1);
3222 }
3223 else
3224 {
3225 $contents{$1} = $2;
3226 }
3227 $content_lines{$1} = $.;
3228 $output_vars .= $comment . $spacing . $_;
3229 $comment = $spacing = '';
3230 $saw_bk = /\\$/;
3232 # Error if bogus.
3233 &am_line_error ($., "bad macro name \`$1'")
3234 if ! $is_ok_macro;
3235 }
3236 else
3237 {
3238 # This isn't an error; it is probably a continued rule.
3239 # In fact, this is what we assume.
3240 $was_rule = 1;
3241 $output_trailer .= $comment . $spacing . $_;
3242 $comment = $spacing = '';
3243 $saw_bk = /\\$/;
3244 }
3246 $_ = <AM_FILE>;
3247 }
3249 $output_trailer .= $comment;
3250 }
3252 ################################################################
3254 sub initialize_global_constants
3255 {
3256 # Values for AC_CANONICAL_*
3257 $AC_CANONICAL_HOST = 1;
3258 $AC_CANONICAL_SYSTEM = 2;
3260 # Associative array of standard directory names. Entry is TRUE if
3261 # corresponding directory should be installed during
3262 # 'install-exec' phase.
3263 %exec_dir_p =
3264 ('bin', 1,
3265 'sbin', 1,
3266 'libexec', 1,
3267 'data', 0,
3268 'sysconf', 1,
3269 'localstate', 1,
3270 'lib', 1,
3271 'info', 0,
3272 'man', 0,
3273 'include', 0,
3274 'oldinclude', 0,
3275 'pkgdata', 0,
3276 'pkglib', 1,
3277 'pkginclude', 0
3278 );
3280 # Helper text for dealing with man pages.
3281 $install_man_format =
3282 ' sect=@SECTION@; \\
3283 inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
3284 if test -f $(srcdir)/@MAN@; then file=$(srcdir)/@MAN@; \\
3285 else file=@MAN@; fi; \\
3286 $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst
3287 ';
3289 $uninstall_man_format =
3290 ' inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
3291 rm -f $(mandir)/man@SECTION@/$$inst
3292 ';
3294 # Commonly found files we look for and automatically include in
3295 # DISTFILES.
3296 @common_files =
3297 (
3298 "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
3299 "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
3300 "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
3301 "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
3302 'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp',
3303 'interlock', 'ylwrap', 'acinclude.m4'
3304 );
3306 # Commonly used files we auto-include, but only sometimes.
3307 @common_sometimes =
3308 (
3309 "aclocal.m4", "acconfig.h", "config.h.top",
3310 "config.h.bot", "stamp-h.in", 'stamp-vti', 'libtool'
3311 );
3313 $USAGE = "\
3314 -a, --add-missing add missing standard files to package
3315 --amdir=DIR directory storing config files
3316 --build-dir=DIR directory where build being done (for dependencies)
3317 --foreign same as --strictness=foreign
3318 --gnits same as --strictness=gnits
3319 --gnu same as --strictness=gnu
3320 --help print this help, then exit
3321 -i, --include-deps include generated dependencies in Makefile.in
3322 --no-force only update Makefile.in's that are out of date
3323 -o DIR, --output-dir=DIR
3324 put generated Makefile.in's into DIR
3325 --srcdir-name=DIR name used for srcdir (for dependencies)
3326 -s LEVEL, --strictness=LEVEL
3327 set strictness level. LEVEL is foreign, gnu, gnits
3328 -v, --verbose verbosely list files processed
3329 --version print version number, then exit\n";
3331 # Copyright on generated Makefile.ins.
3332 $gen_copyright = "\
3333 # Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
3334 # This Makefile.in is free software; the Free Software Foundation
3335 # gives unlimited permission to copy, distribute and modify it.
3336 ";
3337 }
3339 # (Re)-Initialize per-Makefile.am variables.
3340 sub initialize_per_input
3341 {
3342 # These two variables are used when generating each Makefile.in.
3343 # They hold the Makefile.in until it is ready to be printed.
3344 $output_rules = '';
3345 $output_vars = '';
3346 $output_trailer = '';
3348 # Suffixes found during a run.
3349 @suffixes = ();
3351 # This holds the contents of a Makefile.am, as parsed by
3352 # read_am_file.
3353 %contents = ();
3355 # This holds the names which are targets. These also appear in
3356 # %contents.
3357 %targets = ();
3359 # This holds the line numbers at which various elements of
3360 # %contents are defined.
3361 %content_lines = ();
3363 # This holds a 1 if a particular variable was examined.
3364 %content_seen = ();
3366 # This holds the "relative directory" of the current Makefile.in.
3367 # Eg for src/Makefile.in, this is "src".
3368 $relative_dir = '';
3370 # This holds a list of files that are included in the
3371 # distribution.
3372 %dist_common = ();
3374 # List of dependencies for the obvious targets.
3375 @install_data = ();
3376 @install_exec = ();
3377 @uninstall = ();
3378 @installdirs = ();
3380 @info = ();
3381 @dvi = ();
3382 @all = ();
3383 @check = ();
3384 @installcheck = ();
3385 @clean = ();
3387 @phony = ();
3389 # These are pretty obvious, too. They are used to define the
3390 # SOURCES and OBJECTS variables.
3391 @sources = ();
3392 @objects = ();
3394 # TRUE if current directory holds any C source files. (Actually
3395 # holds object extension, but this information is encapsulated in
3396 # the function get_object_extension).
3397 $dir_holds_sources = '';
3399 # TRUE if current directory holds any headers.
3400 $dir_holds_headers = 0;
3402 # TRUE if install targets should work recursively.
3403 $recursive_install = 0;
3405 # All .P files.
3406 %dep_files = ();
3408 # Strictness levels.
3409 $strictness = $default_strictness;
3410 $strictness_name = $default_strictness_name;
3412 # Options from AUTOMAKE_OPTIONS.
3413 %options = ();
3415 # Whether or not dependencies are handled. Can be further changed
3416 # in handle_options.
3417 $use_dependencies = $cmdline_use_dependencies;
3419 # Per Makefile.am.
3420 $local_maint_charset = $maint_charset;
3422 # All yacc and lex source filenames for this directory. Use
3423 # filenames instead of raw count so that multiple instances are
3424 # counted correctly (eg one yacc file can appear in multiple
3425 # programs without harm).
3426 %yacc_sources = ();
3427 %lex_sources = ();
3429 # C++ source extensions we've seen.
3430 %cxx_extensions = ();
3432 # TRUE if we've seen any non-C++ sources.
3433 $seen_c_source = 0;
3434 }
3437 ################################################################
3439 # Return contents of a file from $am_dir, automatically skipping
3440 # macros or rules which are already known. Runs command on each line
3441 # as it is read; this command can modify $_.
3442 sub file_contents_with_transform
3443 {
3444 local ($command, $basename) = @_;
3445 local ($file) = $am_dir . '/' . $basename . '.am';
3447 open (FC_FILE, $file)
3448 || die "automake: installation error: cannot open \`$file'\n";
3449 # Looks stupid?
3450 # print "automake: reading $file\n" if $verbose;
3452 local ($was_rule) = 0;
3453 local ($result_vars) = '';
3454 local ($result_rules) = '';
3455 local ($comment) = '';
3456 local ($spacing) = "\n";
3457 local ($skipping) = 0;
3459 while (<FC_FILE>)
3460 {
3461 $_ =~ s/\@(UN)?MAINT\@//g
3462 unless $seen_maint_mode;
3464 eval $command;
3466 if (/$IGNORE_PATTERN/o)
3467 {
3468 # Merely delete comments beginning with two hashes.
3469 }
3470 elsif (/$WHITE_PATTERN/o)
3471 {
3472 # Stick a single white line before the incoming macro or rule.
3473 $spacing = "\n";
3474 }
3475 elsif (/$COMMENT_PATTERN/o)
3476 {
3477 # Stick comments before the incoming macro or rule.
3478 $comment .= $spacing . $_;
3479 $spacing = '';
3480 }
3481 elsif ($saw_bk)
3482 {
3483 if ($was_rule)
3484 {
3485 $result_rules .= $_ if ! $skipping;
3486 }
3487 else
3488 {
3489 $result_vars .= $_ if ! $skipping;
3490 }
3491 $saw_bk = /\\$/;
3492 }
3493 elsif (/$RULE_PATTERN/o)
3494 {
3495 # warn "** Found rule .$1.\n";
3496 # Found a rule.
3497 $was_rule = 1;
3498 $skipping = defined $contents{$1};
3499 # warn "** Skip $skipping\n" if $skipping;
3500 $result_rules .= $comment . $spacing . $_ if ! $skipping;
3501 $comment = $spacing = '';
3502 $saw_bk = /\\$/;
3503 }
3504 elsif (/$MACRO_PATTERN/o)
3505 {
3506 # warn "** Found macro .$1.\n";
3507 # Found a variable reference.
3508 $was_rule = 0;
3509 $skipping = defined $contents{$1};
3510 # warn "** Skip $skipping\n" if $skipping;
3511 $result_vars .= $comment . $spacing . $_ if ! $skipping;
3512 $comment = $spacing = '';
3513 $saw_bk = /\\$/;
3514 }
3515 else
3516 {
3517 # This isn't an error; it is probably a continued rule.
3518 # In fact, this is what we assume.
3519 $was_rule = 1;
3520 $result_rules .= $comment . $spacing . $_ if ! $skipping;
3521 $comment = $spacing = '';
3522 $saw_bk = /\\$/;
3523 }
3524 }
3526 close (FC_FILE);
3527 return $result_vars . $result_rules . $comment;
3528 }
3530 # Like file_contents_with_transform, but no transform.
3531 sub file_contents
3532 {
3533 return &file_contents_with_transform ('', @_);
3534 }
3536 # Find all variable prefixes that are used for install directories. A
3537 # prefix `zar' qualifies iff:
3538 # * `zardir' is a variable.
3539 # * `zar_PRIMARY' is a variable.
3540 sub am_primary_prefixes
3541 {
3542 local ($primary, @prefixes) = @_;
3544 local (%valid, $varname);
3545 grep ($valid{$_} = 0, @prefixes);
3546 $valid{'EXTRA'} = 0;
3547 foreach $varname (keys %contents)
3548 {
3549 if ($varname =~ /^(.*)_$primary$/)
3550 {
3551 if (! defined $valid{$1} && ! &variable_defined ($1 . 'dir'))
3552 {
3553 &am_line_error ($varname, "invalid variable \"$varname\"");
3554 }
3555 else
3556 {
3557 # Ensure all extended prefixes are actually used.
3558 $valid{$1} = 1;
3559 }
3560 }
3561 }
3563 return %valid;
3564 }
3566 # Handle `where_HOW' variable magic. Does all lookups, generates
3567 # install code, and possibly generates code to define the primary
3568 # variable. The first argument is the name of the .am file to munge,
3569 # the second argument is the primary variable (eg HEADERS), and all
3570 # subsequent arguments are possible installation locations. Returns
3571 # list of all values of all _HOW targets.
3572 #
3573 # FIXME: this should be rewritten to be cleaner. It should be broken
3574 # up into multiple functions.
3575 #
3576 # Usage is: am_install_var (OPTION..., file, HOW, where...)
3577 sub am_install_var
3578 {
3579 local (@args) = @_;
3581 local ($do_all, $do_clean) = (1, 0);
3582 while (@args)
3583 {
3584 if ($args[0] eq '-clean')
3585 {
3586 $do_clean = 1;
3587 }
3588 elsif ($args[0] eq '-no-all')
3589 {
3590 $do_all = 0;
3591 }
3592 elsif ($args[0] !~ /^-/)
3593 {
3594 last;
3595 }
3596 shift (@args);
3597 }
3598 local ($file, $primary, @prefixes) = @args;
3600 local (@used) = ();
3601 local (@result) = ();
3603 # Now that configure substitutions are allowed in where_HOW
3604 # variables, it is an error to actually define the primary.
3605 &am_line_error ($primary, "\`$primary' is an anachronism")
3606 if &variable_defined ($primary);
3609 # Look for misspellings. It is an error to have a variable ending
3610 # in a "reserved" suffix whose prefix is unknown, eg
3611 # "bni_PROGRAMS". However, unusual prefixes are allowed if a
3612 # variable of the same name (with "dir" appended) exists. For
3613 # instance, if the variable "zardir" is defined, then
3614 # "zar_PROGRAMS" becomes valid. This is to provide a little extra
3615 # flexibility in those cases which need it. Perhaps it should be
3616 # disallowed in the Gnits case? The problem is, sometimes it is
3617 # useful to put things in a subdir of eg pkgdatadir, perhaps even
3618 # for Gnitsoids.
3619 local (%valid) = &am_primary_prefixes ($primary, @prefixes);
3621 # If a primary includes a configure substitution, then the EXTRA_
3622 # form is required. Otherwise we can't properly do our job.
3623 local ($require_extra);
3624 local ($warned_about_extra) = 0;
3626 local ($clean_file) = $file . '-clean';
3627 local ($one_name);
3628 local ($X);
3629 foreach $X (keys %valid)
3630 {
3631 $one_name = $X . '_' . $primary;
3632 if (&variable_defined ($one_name))
3633 {
3634 # Append actual contents of where_PRIMARY variable to
3635 # result.
3636 local ($rcurs);
3637 foreach $rcurs (&variable_value_as_list ($one_name))
3638 {
3639 # Skip configure substitutions. Possibly bogus.
3640 if ($rcurs =~ /^\@.*\@$/)
3641 {
3642 if ($X eq 'EXTRA')
3643 {
3644 if (! $warned_about_extra)
3645 {
3646 $warned_about_extra = 1;
3647 &am_line_error ($one_name,
3648 "\`$one_name' contains configure substitution, but shouldn't");
3649 }
3650 }
3651 else
3652 {
3653 $require_extra = $one_name;
3654 }
3655 next;
3656 }
3657 push (@result, $rcurs);
3658 }
3660 # "EXTRA" shouldn't be used when generating clean targets,
3661 # @all, or install targets.
3662 next if $X eq 'EXTRA';
3664 if ($do_clean)
3665 {
3666 $output_rules .=
3667 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
3668 $clean_file);
3670 push (@clean, $X . $primary);
3671 &push_phony_cleaners ($X . $primary);
3672 }
3674 if ($X eq 'check')
3675 {
3676 push (@check, '$(' . $one_name . ')');
3677 }
3678 else
3679 {
3680 push (@used, '$(' . $one_name . ')');
3681 }
3682 if ($X eq 'noinst' || $X eq 'check')
3683 {
3684 # Objects which don't get installed by default.
3685 next;
3686 }
3688 $output_rules .=
3689 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go',
3690 $file);
3692 push (@uninstall, 'uninstall-' . $X . $primary);
3693 push (@phony, 'uninstall-' . $X . $primary);
3694 push (@installdirs, '$(' . $X . 'dir)');
3695 if ($exec_dir_p{$X})
3696 {
3697 push (@install_exec, 'install-' . $X . $primary);
3698 push (@phony, 'install-' . $X . $primary);
3699 }
3700 else
3701 {
3702 push (@install_data, 'install-' . $X . $primary);
3703 push (@phony, 'install-' . $X . $primary);
3704 }
3705 }
3706 }
3708 if (@used)
3709 {
3710 # Define it.
3711 &define_pretty_variable ($primary, @used);
3712 $output_vars .= "\n";
3713 }
3715 if ($require_extra && ! &variable_defined ('EXTRA_' . $primary))
3716 {
3717 &am_line_error ($require_extra,
3718 "\`$require_extra' contains configure substitution, but \`EXTRA_$primary' not defined");
3719 }
3721 # Push here because PRIMARY might be configure time determined.
3722 push (@all, '$(' . $primary . ')')
3723 if $do_all && @used;
3725 return (@result);
3726 }
3729 ################################################################
3731 # This variable is local to the "require file" set of functions.
3732 @require_file_paths = ();
3734 # Verify that the file must exist in the current directory. Usage:
3735 # require_file (isconfigure, line_number, strictness, file) strictness
3736 # is the strictness level at which this file becomes required. Must
3737 # set require_file_paths before calling this function.
3738 # require_file_paths is set to hold a single directory (the one in
3739 # which the first file was found) before return.
3740 sub require_file_internal
3741 {
3742 local ($is_configure, $line, $mystrict, @files) = @_;
3743 local ($file, $fullfile);
3744 local ($found_it, $errfile, $errdir);
3745 local ($save_dir);
3747 foreach $file (@files)
3748 {
3749 $found_it = 0;
3750 foreach $dir (@require_file_paths)
3751 {
3752 if ($dir eq '.')
3753 {
3754 $fullfile = $relative_dir . "/" . $file;
3755 $errdir = $relative_dir unless $errdir;
3756 }
3757 else
3758 {
3759 $fullfile = $dir . "/" . $file;
3760 $errdir = $dir unless $errdir;
3761 }
3763 # Use different name for "error filename". Otherwise on
3764 # an error the bad file will be reported as eg
3765 # `../../install-sh' when using the default
3766 # config_aux_path.
3767 $errfile = $errdir . '/' . $file;
3769 if (-f $fullfile)
3770 {
3771 $found_it = 1;
3772 # FIXME: Once again, special-case `.'.
3773 &push_dist_common ($file)
3774 if $dir eq $relative_dir || $dir eq '.';
3775 $save_dir = $dir;
3776 last;
3777 }
3778 }
3780 if ($found_it)
3781 {
3782 # Prune the path list.
3783 @require_file_paths = $save_dir;
3784 }
3785 else
3786 {
3787 if ($strictness >= $mystrict)
3788 {
3789 # Only install missing files according to our desired
3790 # strictness level.
3791 if ($add_missing && -f ($am_dir . '/' . $file))
3792 {
3793 # Install the missing file. Symlink if we can, copy
3794 # if we must.
3795 if ($symlink_exists)
3796 {
3797 symlink ($am_dir . '/' . $file, $errfile);
3798 }
3799 else
3800 {
3801 system ('cp', $am_dir . '/' . $file, $errfile);
3802 }
3804 # FIXME: this is a hack. Should have am_warn.
3805 local ($save) = $exit_status;
3806 if ($is_configure)
3807 {
3808 &am_conf_line_error
3809 ($line,
3810 "required file \"$errfile\" not found; installing");
3811 }
3812 else
3813 {
3814 &am_line_error
3815 ($line,
3816 "required file \"$errfile\" not found; installing");
3817 }
3818 $exit_status = $save;
3819 }
3820 else
3821 {
3822 # Only an error if strictness constraint violated.
3823 if ($is_configure)
3824 {
3825 &am_conf_line_error
3826 ($line, "required file \"$errfile\" not found");
3827 }
3828 else
3829 {
3830 &am_line_error
3831 ($line, "required file \"$errfile\" not found");
3832 }
3833 }
3834 }
3835 }
3836 }
3837 }
3839 # Like require_file_with_line, but error messages refer to
3840 # configure.in, not the current Makefile.am.
3841 sub require_file_with_conf_line
3842 {
3843 @require_file_paths = '.';
3844 &require_file_internal (1, @_);
3845 }
3847 sub require_file_with_line
3848 {
3849 @require_file_paths = '.';
3850 &require_file_internal (0, @_);
3851 }
3853 sub require_file
3854 {
3855 @require_file_paths = '.';
3856 &require_file_internal (0, '', @_);
3857 }
3859 # Require a file that is also required by Autoconf. Looks in
3860 # configuration path, as specified by AC_CONFIG_AUX_DIR.
3861 sub require_config_file
3862 {
3863 @require_file_paths = @config_aux_path;
3864 &require_file_internal (0, '', @_);
3865 local ($dir) = $require_file_paths[0];
3866 @config_aux_path = @require_file_paths;
3867 if ($dir eq '.')
3868 {
3869 $config_aux_dir = '.';
3870 }
3871 else
3872 {
3873 $config_aux_dir = '$(top_srcdir)/' . $dir;
3874 }
3875 }
3877 # Assumes that the line number is in Makefile.am.
3878 sub require_conf_file_with_line
3879 {
3880 @require_file_paths = @config_aux_path;
3881 &require_file_internal (0, @_);
3882 local ($dir) = $require_file_paths[0];
3883 @config_aux_path = @require_file_paths;
3884 if ($dir eq '.')
3885 {
3886 $config_aux_dir = '.';
3887 }
3888 else
3889 {
3890 $config_aux_dir = '$(top_srcdir)/' . $dir;
3891 }
3892 }
3894 # Assumes that the line number is in Makefile.am.
3895 sub require_conf_file_with_conf_line
3896 {
3897 @require_file_paths = @config_aux_path;
3898 &require_file_internal (1, @_);
3899 local ($dir) = $require_file_paths[0];
3900 @config_aux_path = @require_file_paths;
3901 if ($dir eq '.')
3902 {
3903 $config_aux_dir = '.';
3904 }
3905 else
3906 {
3907 $config_aux_dir = '$(top_srcdir)/' . $dir;
3908 }
3909 }
3911 ################################################################
3913 # Push a list of files onto dist_common.
3914 sub push_dist_common
3915 {
3916 local (@files) = @_;
3917 local ($file);
3919 foreach $file (@files)
3920 {
3921 $dist_common{$file} = 1;
3922 }
3923 }
3925 # Push a list of clean targets onto phony.
3926 sub push_phony_cleaners
3927 {
3928 local ($base) = @_;
3929 local ($target);
3930 foreach $target ('mostly', 'dist', '', 'maintainer-')
3931 {
3932 push (@phony, $target . 'clean-' . $base);
3933 }
3934 }
3936 # Set strictness.
3937 sub set_strictness
3938 {
3939 $strictness_name = $_[0];
3940 if ($strictness_name eq 'gnu')
3941 {
3942 $strictness = $GNU;
3943 }
3944 elsif ($strictness_name eq 'gnits')
3945 {
3946 $strictness = $GNITS;
3947 }
3948 elsif ($strictness_name eq 'foreign')
3949 {
3950 $strictness = $FOREIGN;
3951 }
3952 else
3953 {
3954 die "automake: level \`$strictness_name' not recognized\n";
3955 }
3956 }
3959 ################################################################
3961 # Return directory name of file.
3962 sub dirname
3963 {
3964 local ($file) = @_;
3965 local ($sub);
3967 ($sub = $file) =~ s,/+[^/]+$,,g;
3968 $sub = '.' if $sub eq $file;
3969 return $sub;
3970 }
3972 # Return file name of a file.
3973 sub basename
3974 {
3975 local ($file) = @_;
3976 local ($sub);
3978 ($sub = $file) =~s,^.*/+,,g;
3979 return $sub;
3980 }
3982 # Touch a file.
3983 sub touch
3984 {
3985 local ($file) = @_;
3987 open (TOUCH, ">> $file");
3988 close (TOUCH);
3989 }
3991 ################################################################
3993 # Print an error message and set exit status.
3994 sub am_error
3995 {
3996 warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
3997 $exit_status = 1;
3998 }
4000 sub am_line_error
4001 {
4002 local ($symbol, @args) = @_;
4004 if ($symbol)
4005 {
4006 # If SYMBOL not already a line number, look it up in Makefile.am.
4007 $symbol = $content_lines{$symbol} unless $symbol =~ /^\d+$/;
4008 $symbol .= ': ' if $symbol;
4009 warn "${am_file}.am:", $symbol, join (' ', @args), "\n";
4010 $exit_status = 1;
4011 }
4012 else
4013 {
4014 &am_error (@args);
4015 }
4016 }
4018 # Like am_error, but while scanning configure.in.
4019 sub am_conf_error
4020 {
4021 # FIXME: can run in subdirs.
4022 warn "automake: configure.in: ", join (' ', @_), "\n";
4023 $exit_status = 1;
4024 }
4026 # Error message with line number referring to configure.in.
4027 sub am_conf_line_error
4028 {
4029 local ($line, @args) = @_;
4031 if ($line)
4032 {
4033 warn "configure.in: $line: ", join (' ', @args), "\n";
4034 $exit_status = 1;
4035 }
4036 else
4037 {
4038 &am_conf_error (@args);
4039 }
4040 }
4042 # Tell user where our aclocal.m4 is, but only once.
4043 sub keyed_aclocal_warning
4044 {
4045 local ($key) = @_;
4046 warn "automake: macro \`$key' can be generated by \`aclocal'\n";
4047 }
4049 # Print usage information.
4050 sub usage
4051 {
4052 print "Usage: automake [OPTION] ... [Makefile]...\n";
4053 print $USAGE;
4054 print "\nFiles which are automatically distributed, if found:\n";
4055 $~ = "USAGE_FORMAT";
4056 local (@lcomm) = sort ((@common_files, @common_sometimes));
4057 local ($one, $two, $three, $four);
4058 while (@lcomm > 0)
4059 {
4060 $one = shift @lcomm;
4061 $two = @lcomm ? shift @lcomm : '';
4062 $three = @lcomm ? shift @lcomm : '';
4063 $four = @lcomm ? shift @lcomm : '';
4064 write;
4065 }
4067 print "\nReport bugs to <bug-gnu-utils\@prep.ai.mit.edu>\n";
4069 exit 0;
4070 }
4072 format USAGE_FORMAT =
4073 @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<
4074 $one, $two, $three, $four
4075 .