| blob | e894d19e8cb0e839d620965b6e7f42139f30d769 |
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, 1997 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@cygnus.com>.
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@";
36 $TAR = "@TAR@";
38 # String constants.
39 $IGNORE_PATTERN = "^##([^#].*)?\$";
40 $WHITE_PATTERN = "^[ \t]*\$";
41 $COMMENT_PATTERN = "^#";
42 $RULE_PATTERN = "^([\$a-zA-Z_.][-.a-zA-Z0-9_(){}/\$]*) *:([^=].*|)\$";
43 $MACRO_PATTERN = "^([A-Za-z][A-Za-z0-9_]*)[ \t]*:?=[ \t]*(.*)\$";
44 $BOGUS_MACRO_PATTERN = "^([^ \t]*)[ \t]*:?=[ \t]*(.*)\$";
45 $GNITS_VERSION_PATTERN = "[0-9]+\\.[0-9]+([a-z]|\\.[0-9]+)?";
46 $IF_PATTERN = "^if[ \t]+\([A-Za-z][A-Za-z0-9_]*\)[ \t]*\(#.*\)?\$";
47 $ELSE_PATTERN = "^else[ \t]*\(#.*\)?\$";
48 $ENDIF_PATTERN = "^endif[ \t]*\(#.*\)?\$";
50 # Some regular expressions. One reason to put them here is that it
51 # makes indentation work better in Emacs.
52 $AC_CONFIG_AUX_DIR_PATTERN = "AC_CONFIG_AUX_DIR\\(([^)]+)\\)";
53 $AM_INIT_AUTOMAKE_PATTERN = "AM_INIT_AUTOMAKE\\([^,]*,([^,)]+)[,)]";
54 $AM_PACKAGE_VERSION_PATTERN = "^\\s*\\[?([^]\\s]+)\\]?\\s*\$";
55 # Note that there is no AC_PATH_TOOL. But we don't really care.
56 $AC_CHECK_PATTERN = "AC_(CHECK|PATH)_(PROG|PROGS|TOOL)\\(\\[?(\\w+)";
57 $AM_MISSING_PATTERN = "AM_MISSING_PROG\\(\\[?(\\w+)";
58 # Just check for alphanumeric in AC_SUBST. If you do AC_SUBST(5),
59 # then too bad.
60 $AC_SUBST_PATTERN = "AC_SUBST\\(\\[?(\\w+)";
61 $AM_CONDITIONAL_PATTERN = "AM_CONDITIONAL\\((\\w+)";
63 # Constants to define the "strictness" level.
64 $FOREIGN = 0;
65 $GNU = 1;
66 $GNITS = 2;
68 \f
70 # Variables global to entire run.
72 # TRUE if we should always generate Makefile.in.
73 $force_generation = 1;
75 # Strictness level as set on command line.
76 $default_strictness = $GNU;
78 # Name of strictness level, as set on command line.
79 $default_strictness_name = 'gnu';
81 # This is TRUE if GNU make specific automatic dependency generation
82 # code should be included in generated Makefile.in.
83 $cmdline_use_dependencies = 1;
85 # TRUE if in verbose mode.
86 $verbose = 0;
88 # This holds our (eventual) exit status. We don't actually exit until
89 # we have processed all input files.
90 $exit_status = 0;
92 # From the Perl manual.
93 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
95 # TRUE if missing standard files should be installed.
96 $add_missing = 0;
98 # Files found by scanning configure.in for LIBOBJS.
99 %libsources = ();
101 # True if AM_C_PROTOTYPES appears in configure.in.
102 $am_c_prototypes = 0;
104 # Names used in AC_CONFIG_HEADER call. @config_fullnames holds the
105 # name which appears in AC_CONFIG_HEADER, colon and all.
106 # @config_names holds the file names. @config_headers holds the '.in'
107 # files. Ordinarily these are similar, but they can be different if
108 # the weird "NAME:FILE" syntax is used.
109 @config_fullnames = ();
110 @config_names = ();
111 @config_headers = ();
112 # Line number at which AC_CONFIG_HEADER appears in configure.in.
113 $config_header_line = 0;
115 # Directory where output files go. Actually, output files are
116 # relative to this directory.
117 $output_directory = '.';
119 # Relative location of top build directory.
120 $top_builddir = '';
122 # Absolute location of top build directory.
123 $build_directory = '';
125 # Name of srcdir as given in build directory's Makefile. For
126 # dependencies only.
127 $srcdir_name = '';
129 # List of Makefile.am's to process, and their corresponding outputs.
130 @input_files = ();
131 %output_files = ();
133 # List of files in AC_OUTPUT without Makefile.am, and their outputs.
134 @other_input_files = ();
135 # Line number at which AC_OUTPUT seen.
136 $ac_output_line = 0;
138 # List of directories to search for configure-required files. This
139 # can be set by AC_CONFIG_AUX_DIR.
140 @config_aux_path = ('.', '..', '../..');
141 $config_aux_dir = '';
143 # Whether AC_PROG_MAKE_SET has been seen in configure.in.
144 $seen_make_set = 0;
146 # Whether AM_GNU_GETTEXT has been seen in configure.in.
147 $seen_gettext = 0;
148 # Line number at which AM_GNU_GETTEXT seen.
149 $ac_gettext_line = 0;
151 # Whether ALL_LINGUAS has been seen.
152 $seen_linguas = '';
153 # The actual text.
154 $all_linguas = '';
155 # Line number at which it appears.
156 $all_linguas_line = 0;
158 # 1 if AC_PROG_INSTALL seen, 2 if AM_PROG_INSTALL seen.
159 $seen_prog_install = 0;
161 # 1 if any scripts installed, 0 otherwise.
162 $scripts_installed = 0;
164 # Whether AC_PATH_XTRA has been seen in configure.in.
165 $seen_path_xtra = 0;
167 # TRUE if AC_DECL_YYTEXT was seen.
168 $seen_decl_yytext = 0;
170 # TRUE if we've seen AC_CANONICAL_(HOST|SYSTEM). The presence of
171 # AC_CHECK_TOOL also sets this.
172 $seen_canonical = 0;
174 # TRUE if we've seen AC_ARG_PROGRAM.
175 $seen_arg_prog = 0;
177 # TRUE if we've seen AM_PROG_LIBTOOL.
178 $seen_libtool = 0;
179 $libtool_line = 0;
181 # Files installed by libtoolize.
182 @libtoolize_files = ('ltconfig', 'ltmain.sh', 'config.guess', 'config.sub');
184 # TRUE if we've seen AM_MAINTAINER_MODE.
185 $seen_maint_mode = 0;
187 # TRUE if we've seen PACKAGE and VERSION.
188 $seen_package = 0;
189 $seen_version = 0;
191 # Actual version we've seen.
192 $package_version = '';
194 # Line number where we saw version definition.
195 $package_version_line = 0;
197 # TRUE if we've seen AM_PATH_LISPDIR.
198 $seen_lispdir = 0;
200 # TRUE if we've seen AM_EXEEXT.
201 $seen_exeext = 0;
203 # Hash table of discovered configure substitutions. Keys are names,
204 # values are meaningless.
205 %configure_vars = ();
207 # Charsets used by maintainer and in distribution. MAINT_CHARSET is
208 # handled in a funny way: if seen in the top-level Makefile.am, it is
209 # used for every directory which does not specify a different value.
210 # The rationale here is that some directories (eg gettext) might be
211 # distributions of other packages, and thus require their own charset
212 # info. However, the DIST_CHARSET must be the same for the entire
213 # package; it can only be set at top-level.
214 # FIXME: this yields bugs when rebuilding. What to do? Always
215 # read (and sometimes discard) top-level Makefile.am?
216 $maint_charset = '';
217 $dist_charset = 'utf8'; # recode doesn't support this yet.
219 # Name of input file ("Makefile.in") and output file ("Makefile.am").
220 # These have no directory components.
221 $am_file_name = '';
222 $in_file_name = '';
224 # TRUE if --cygnus seen.
225 $cygnus_mode = 0;
227 # Keys of this hash are names of dependency files to ignore.
228 %omit_dependencies = ();
230 # Hash table of AM_CONDITIONAL variables seen in configure.
231 %configure_cond = ();
233 # Map from obsolete macros to hints for new macros.
234 # FIXME complete the list so that there are no `0' hints.
235 %obsolete_macros =
236 (
237 'AC_FEATURE_CTYPE', "use \`AC_HEADER_STDC'",
238 'AC_FEATURE_ERRNO', "add \`strerror' to \`AC_REPLACE_FUNCS(...)'",
239 'AC_FEATURE_EXIT', 0,
240 'AC_SYSTEM_HEADER', 0,
242 # Note that we do not handle this one, because it is still run
243 # from AM_CONFIG_HEADER. So we deal with it specially in
244 # scan_configure.
245 # 'AC_CONFIG_HEADER', "use \`AM_CONFIG_HEADER'",
247 'fp_C_PROTOTYPES', "use \`AM_C_PROTOTYPES'",
248 'fp_PROG_CC_STDC', "use \`AM_PROG_CC_STDC'",
249 'fp_PROG_INSTALL', "use \`AM_PROG_INSTALL'",
250 'fp_WITH_DMALLOC', "use \`AM_WITH_DMALLOC'",
251 'fp_WITH_REGEX', "use \`AM_WITH_REGEX'",
252 'gm_PROG_LIBTOOL', "use \`AM_PROG_LIBTOOL'",
253 'jm_MAINTAINER_MODE', "use \`AM_MAINTAINER_MODE'",
254 'md_TYPE_PTRDIFF_T', "use \`AM_TYPE_PTRDIFF_T'",
255 'ud_PATH_LISPDIR', "use \`AM_PATH_LISPDIR'",
257 # Now part of autoconf proper, under a different name.
258 'AM_FUNC_FNMATCH', "use \`AC_FUNC_FNMATCH'",
259 'fp_FUNC_FNMATCH', "use \`AC_FUNC_FNMATCH'",
260 'AM_SANITY_CHECK_CC', "automatically done by \`AC_PROG_CC'",
262 # These aren't quite obsolete.
263 # 'md_PATH_PROG',
264 );
266 # Regexp to match the above macros.
267 $obsolete_rx = '(' . join ('|', keys %obsolete_macros) . ')';
269 \f
271 &initialize_global_constants;
273 # Parse command line.
274 &parse_arguments (@ARGV);
276 # Do configure.in scan only once.
277 &scan_configure;
279 die "automake: no \`Makefile.am' found or specified\n"
280 if ! @input_files;
282 # Now do all the work on each file.
283 foreach $am_file (@input_files)
284 {
285 if (! -f ($am_file . '.am'))
286 {
287 &am_error ("\`" . $am_file . ".am' does not exist");
288 }
289 else
290 {
291 &generate_makefile ($output_files{$am_file}, $am_file);
292 }
293 }
295 if ($seen_prog_install <= $scripts_installed)
296 {
297 &am_conf_error (($scripts_installed ? 'AM_PROG_INSTALL' : 'AC_PROG_INSTALL')
298 . " must be used in configure.in");
299 &keyed_aclocal_warning ('AM_PROG_INSTALL')
300 if $scripts_installed;
301 }
303 exit $exit_status;
306 ################################################################
308 # Parse command line.
309 sub parse_arguments
310 {
311 local (@arglist) = @_;
313 # Start off as gnu.
314 &set_strictness ('gnu');
316 while (@arglist)
317 {
318 if ($arglist[0] eq "--version")
319 {
320 print "automake (GNU $PACKAGE) $VERSION\n\n";
321 print "Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.\n";
322 print "This is free software; see the source for copying conditions. There is NO\n";
323 print "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n";
324 print "Written by Tom Tromey <tromey\@cygnus.com>\n";
326 exit 0;
327 }
328 elsif ($arglist[0] eq "--help")
329 {
330 &usage;
331 }
332 elsif ($arglist[0] =~ /^--amdir=(.+)$/)
333 {
334 $am_dir = $1;
335 }
336 elsif ($arglist[0] eq '--amdir')
337 {
338 &require_argument (@arglist);
339 shift (@arglist);
340 $am_dir = $arglist[0];
341 }
342 elsif ($arglist[0] =~ /^--build-dir=(.+)$/)
343 {
344 # Must end in /.
345 $build_directory = $1 . '/';
346 }
347 elsif ($arglist[0] eq '--build-dir')
348 {
349 &require_argument (@arglist);
350 shift (@arglist);
351 # Must end in /.
352 $build_directory = $arglist[0] . '/';
353 }
354 elsif ($arglist[0] =~ /^--srcdir-name=(.+)$/)
355 {
356 $srcdir_name = $1;
357 }
358 elsif ($arglist[0] eq '--srcdir-name')
359 {
360 &require_argument (@arglist);
361 shift (@arglist);
362 $srcdir_name = $arglist[0];
363 }
364 elsif ($arglist[0] eq '--gnu')
365 {
366 &set_strictness ('gnu');
367 }
368 elsif ($arglist[0] eq '--gnits')
369 {
370 &set_strictness ('gnits');
371 }
372 elsif ($arglist[0] eq '--cygnus')
373 {
374 $cygnus_mode = 1;
375 }
376 elsif ($arglist[0] eq '--foreign')
377 {
378 &set_strictness ('foreign');
379 }
380 elsif ($arglist[0] eq '--include-deps' || $arglist[0] eq '-i')
381 {
382 $cmdline_use_dependencies = 0;
383 }
384 elsif ($arglist[0] eq '--no-force')
385 {
386 $force_generation = 0;
387 }
388 elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
389 {
390 # Set output directory.
391 $output_directory = $1;
392 }
393 elsif ($arglist[0] eq '--output-dir' || $arglist[0] eq '-o')
394 {
395 &require_argument (@arglist);
396 shift (@arglist);
397 $output_directory = $arglist[0];
398 }
399 elsif ($arglist[0] eq '--add-missing' || $arglist[0] eq '-a')
400 {
401 $add_missing = 1;
402 }
403 elsif ($arglist[0] eq '--verbose' || $arglist[0] eq '-v')
404 {
405 $verbose = 1;
406 }
407 elsif ($arglist[0] eq '--')
408 {
409 # Stop option processing.
410 shift (@arglist);
411 push (@input_files, @arglist);
412 last;
413 }
414 elsif ($arglist[0] =~ /^-/)
415 {
416 die "automake: unrecognized option -- \`$arglist[0]'\nTry \`automake --help' for more information.\n";
417 }
418 else
419 {
420 # Handle $local:$input syntax. Note that we only examine
421 # the first ":" file to see if it is automake input; the
422 # rest are just taken verbatim. We still keep all the
423 # files around for dependency checking, however.
424 local ($local, $input, @rest) = split (/:/, $arglist[0]);
425 if (! $input)
426 {
427 $input = $local;
428 }
429 else
430 {
431 # Strip .in; later on .am is tacked on. That is how
432 # the automake input file is found. Maybe not the
433 # best way, but it is easy to explain. FIXME: should
434 # be error if .in is missing.
435 $input =~ s/\.in$//;
436 }
437 push (@input_files, $input);
438 $output_files{$input} = join (':', ($local, @rest));
439 }
441 shift (@arglist);
442 }
444 # Take global strictness from whatever we currently have set.
445 $default_strictness = $strictness;
446 $default_strictness_name = $strictness_name;
447 }
449 # Ensure argument exists, or die.
450 sub require_argument
451 {
452 local ($arg, @arglist) = @_;
453 die "automake: no argument given for option \`$arg'\n"
454 if ! @arglist;
455 }
457 ################################################################
459 # Generate a Makefile.in given the name of the corresponding Makefile and
460 # the name of the file output by config.status.
461 sub generate_makefile
462 {
463 local ($output, $makefile) = @_;
465 ($am_file_name = $makefile) =~ s/^.*\///;
466 $in_file_name = $am_file_name . '.in';
467 $am_file_name .= '.am';
469 # $OUTPUT is encoded. If it contains a ":" then the first element
470 # is the real output file, and all remaining elements are input
471 # files. We don't scan or otherwise deal with these input file,
472 # other than to mark them as dependencies. See scan_configure for
473 # details.
474 local (@secondary_inputs);
475 ($output, @secondary_inputs) = split (/:/, $output);
477 &initialize_per_input;
478 $relative_dir = &dirname ($output);
479 $am_relative_dir = &dirname ($makefile);
481 # At the toplevel directory, we might need config.guess, config.sub
482 # or libtool scripts (ltconfig and ltmain.sh).
483 if ($relative_dir eq '.')
484 {
485 # libtool requires some files.
486 &require_conf_file_with_conf_line ($libtool_line, $FOREIGN,
487 @libtoolize_files)
488 if $seen_libtool;
490 # AC_CANONICAL_HOST and AC_CANONICAL_SYSTEM need config.guess and
491 # config.sub.
492 &require_config_file ($FOREIGN, 'config.guess', 'config.sub')
493 if $seen_canonical;
494 }
496 # We still need Makefile.in here, because sometimes the `dist'
497 # target doesn't re-run automake.
498 if ($am_relative_dir eq $relative_dir)
499 {
500 # Only distribute the files if they are in the same subdir as
501 # the generated makefile.
502 &push_dist_common ($in_file_name, $am_file_name);
503 }
504 push (@sources, '$(SOURCES)')
505 if &variable_defined ('SOURCES');
506 push (@objects, '$(OBJECTS)')
507 if &variable_defined ('OBJECTS');
509 # This is always the default target. This gives us freedom to do
510 # things in whatever order is convenient. Note that we set up
511 # $output_header here so that we can insert some text just after
512 # the "default" target, but before any other targets. In
513 # particular we want to support the .SUFFIX hack here; this is
514 # documented elsewhere.
515 $output_header = "default: all\n\n";
516 push (@phony, 'default');
518 &read_am_file ($makefile . '.am');
519 if (&handle_options)
520 {
521 # Fatal error. Just return, so we can continue with next file.
522 return;
523 }
525 # Check first, because we might modify some state.
526 &check_cygnus;
527 &check_gnu_standards;
528 &check_gnits_standards;
530 &handle_configure ($output, $makefile, @secondary_inputs);
531 &handle_gettext;
532 &handle_libraries;
533 &handle_ltlibraries;
534 &handle_programs;
535 &handle_scripts;
537 &handle_built_sources;
539 # This must be run after all the sources are scanned.
540 &handle_yacc_lex_cxx;
542 # Re-init SOURCES and OBJECTS. FIXME: other code shouldn't depend
543 # on this (but currently does).
544 $contents{'SOURCES'} = join (' ', @sources);
545 $contents{'OBJECTS'} = join (' ', @objects);
547 &handle_texinfo;
548 &handle_emacs_lisp;
549 &handle_man_pages;
550 &handle_data;
551 &handle_headers;
552 &handle_subdirs;
553 &handle_tags;
554 &handle_dist ($makefile);
555 &handle_dependencies;
556 &handle_tests;
557 &handle_footer;
558 &handle_merge_targets ($makefile);
559 &handle_installdirs;
560 &handle_clean;
561 &handle_phony;
563 &check_typos;
565 if (! -d ($output_directory . '/' . $am_relative_dir))
566 {
567 mkdir ($output_directory . '/' . $am_relative_dir, 0755);
568 }
570 local ($out_file) = $output_directory . '/' . $makefile . ".in";
571 if (! $force_generation && -e $out_file)
572 {
573 local ($am_time) = (stat ($makefile . '.am'))[9];
574 local ($in_time) = (stat ($out_file))[9];
575 # FIXME: should cache these times.
576 local ($conf_time) = (stat ('configure.in'))[9];
577 # FIXME: how to do unsigned comparison?
578 if ($am_time < $in_time || $am_time < $conf_time)
579 {
580 # No need to update.
581 return;
582 }
583 if (-f 'aclocal.m4')
584 {
585 local ($acl_time) = (stat _)[9];
586 return if ($am_time < $acl_time);
587 }
588 }
590 if (! open (GM_FILE, "> " . $out_file))
591 {
592 warn "automake: ${am_file}.in: cannot write: $!\n";
593 $exit_status = 1;
594 return;
595 }
596 print "automake: creating ", $makefile, ".in\n" if $verbose;
598 print GM_FILE $output_vars;
599 print GM_FILE $output_header;
600 print GM_FILE $output_rules;
601 print GM_FILE $output_trailer;
603 close (GM_FILE);
604 }
606 ################################################################
608 # Handle AUTOMAKE_OPTIONS variable. Return 1 on error, 0 otherwise.
609 sub handle_options
610 {
611 return 0 if ! &variable_defined ('AUTOMAKE_OPTIONS');
613 foreach (&variable_value_as_list ('AUTOMAKE_OPTIONS', ''))
614 {
615 $options{$_} = 1;
616 if ($_ eq 'gnits' || $_ eq 'gnu' || $_ eq 'foreign')
617 {
618 &set_strictness ($_);
619 }
620 elsif (/ansi2knr/)
621 {
622 # An option like "../lib/ansi2knr" is allowed. With no
623 # path prefix, we assume the required programs are in this
624 # directory. We save the actual option for later.
625 $options{'ansi2knr'} = $_;
626 }
627 elsif ($_ eq 'no-installman' || $_ eq 'no-installinfo'
628 || $_ eq 'dist-shar' || $_ eq 'dist-zip'
629 || $_ eq 'dist-tarZ' || $_ eq 'dejagnu'
630 || $_ eq 'no-texinfo.tex')
631 {
632 # Explicitly recognize these.
633 }
634 elsif ($_ eq 'no-dependencies')
635 {
636 $use_dependencies = 0;
637 }
638 elsif (/([0-9]+)\.([0-9]+)/)
639 {
640 # Got a version number. Note that alpha releases count as
641 # the next higher release. Note also that we assume there
642 # will be a maximum of 100 minor releases for any given
643 # major release.
644 local ($rmajor, $rminor) = ($1, $2);
645 if ($VERSION !~ /([0-9]+)\.([0-9]+)([a-z])?/)
646 {
647 print STDERR
648 "automake: programming error: version is incorrect\n";
649 exit 1;
650 }
651 local ($tmajor, $tminor) = ($1, $2);
652 # Handle alpha versions.
653 ++$tminor if defined $3;
655 if ($rmajor > $tmajor || ($rmajor == $tmajor && $rminor > $tminor))
656 {
657 &am_line_error ('AUTOMAKE_OPTIONS',
658 "require version $_, only have $VERSION");
659 return 1;
660 }
661 }
662 else
663 {
664 &am_line_error ('AUTOMAKE_OPTIONS',
665 'option ', $_, 'not recognized');
666 }
667 }
669 return 0;
670 }
672 # Return object extension. Just once, put some code into the output.
673 # Argument is the name of the output file
674 sub get_object_extension
675 {
676 local ($out) = @_;
678 # Always set this.
679 $dir_holds_sources = 1;
681 # Maybe require libtool library object files.
682 local ($extension) = '.o';
683 $extension = '.lo' if ($out =~ /\.la$/);
685 if (! $included_generic_compile)
686 {
687 # Boilerplate.
688 local ($xform) = '';
689 if (&variable_defined ('CONFIG_HEADER'))
690 {
691 local ($one_hdr);
692 foreach $one_hdr (split (' ', &variable_value ('CONFIG_HEADER')))
693 {
694 local ($var);
695 ($var = &dirname ($one_hdr)) =~ s/(\W)/\\$1/g;
696 $xform .= ' ' if $xform;
697 $xform .= '-I' . $var;
698 }
699 }
700 $xform = 's/\@CONFIG_INCLUDE_SPEC\@/' . $xform . '/go;';
701 $output_vars .= &file_contents_with_transform ($xform,
702 'comp-vars');
703 $output_rules .= &file_contents ('compile');
704 &push_phony_cleaners ('compile');
706 # If using X, include some extra variable definitions. NOTE
707 # we don't want to force these into CFLAGS or anything,
708 # because not all programs will necessarily use X.
709 if ($seen_path_xtra)
710 {
711 local ($var);
712 foreach $var ('X_CFLAGS', 'X_LIBS', 'X_EXTRA_LIBS', 'X_PRE_LIBS')
713 {
714 &define_configure_variable ($var);
715 }
716 }
718 push (@suffixes, '.c', '.o');
719 push (@clean, 'compile');
721 $included_generic_compile = 1;
722 }
724 if ($seen_libtool && ! $included_libtool_compile)
725 {
726 # Output the libtool compilation rules.
727 $output_rules .= &file_contents ('libtool');
728 &push_phony_cleaners ('libtool');
730 push (@suffixes, '.lo');
731 push (@clean, 'libtool');
733 $included_libtool_compile = 1;
734 }
736 # Check for automatic de-ANSI-fication.
737 if (defined $options{'ansi2knr'})
738 {
739 $extension = '$U' . $extension;
740 if (! $included_knr_compile)
741 {
742 if (! $am_c_prototypes)
743 {
744 &am_line_error ('AUTOMAKE_OPTIONS',
745 "option \`ansi2knr' in use but \`AM_C_PROTOTYPES' not in configure.in");
746 &keyed_aclocal_warning ('AM_C_PROTOTYPES');
747 # Only give this error once.
748 $am_c_prototypes = 1;
749 }
751 # Only require ansi2knr files if they should appear in
752 # this directory.
753 if ($options{'ansi2knr'} eq 'ansi2knr')
754 {
755 &require_file_with_line ('AUTOMAKE_OPTIONS', $FOREIGN,
756 'ansi2knr.c', 'ansi2knr.1');
757 $output_rules .= &file_contents ('kr-extra');
758 push (@clean, 'krextra');
759 &push_phony_cleaners ('krextra');
760 }
762 # Generate rules to build ansi2knr. If it is in some
763 # other directory, then generate dependencies but have the
764 # rule just run elsewhere.
765 $output_rules .= ($options{'ansi2knr'} . ': '
766 . $options{'ansi2knr'} . ".o\n");
767 if ($options{'ansi2knr'} eq 'ansi2knr')
768 {
769 $output_rules .= ("\t\$(LINK) ansi2knr.o \$(LIBS)\n"
770 . "ansi2knr.o: \$(CONFIG_HEADER)\n\n");
771 }
772 else
773 {
774 $output_rules .= ("\tcd " . &dirname ($options{'ansi2knr'})
775 . " && \$(MAKE) ansi2knr\n\n");
776 }
778 # Make sure ansi2knr can be found: if no path specified,
779 # specify "./".
780 if ($options{'ansi2knr'} eq 'ansi2knr')
781 {
782 # Substitution from AM_C_PROTOTYPES. This makes it be
783 # built only when necessary.
784 &define_configure_variable ('ANSI2KNR');
785 # ansi2knr needs to be built before subdirs, so unshift it.
786 unshift (@all, '$(ANSI2KNR)');
787 }
788 else
789 {
790 # Found in another directory.
791 &define_variable ("ANSI2KNR", $options{'ansi2knr'});
792 }
794 $output_rules .= &file_contents ('clean-kr');
796 push (@clean, 'kr');
797 &push_phony_cleaners ('kr');
799 $included_knr_compile = 1;
800 }
801 }
803 return $extension;
804 }
806 # Handle yacc and lex.
807 sub handle_yacc_lex_cxx
808 {
809 #
810 # First do yacc and lex.
811 #
813 local ($yacc_count) = scalar (keys %yacc_sources);
814 local ($lex_count) = scalar (keys %lex_sources);
816 if ($yacc_count)
817 {
818 local (%seen_suffix) = ();
819 foreach (keys %yacc_sources)
820 {
821 /(\..*)$/;
822 &output_yacc_build_rule ($1, $yacc_count > 1)
823 if (! defined $seen_suffix{$1});
824 $seen_suffix{$1} = 1;
825 }
827 if (! defined $configure_vars{'YACC'})
828 {
829 &am_error ("yacc source seen but \`YACC' not defined in \`configure.in'");
830 }
831 }
832 if ($lex_count)
833 {
834 local (%seen_suffix) = ();
835 foreach (keys %lex_sources)
836 {
837 /(\..*)$/;
838 &output_lex_build_rule ($1, $lex_count > 1)
839 if (! defined $seen_suffix{$1});
840 $seen_suffix{$1} = 1;
841 }
843 if (! defined $configure_vars{'LEX'})
844 {
845 &am_error ("lex source seen but \`LEX' not defined in \`configure.in'");
846 }
847 if (! $seen_decl_yytext)
848 {
849 &am_error ("lex source seen but \`AC_DECL_YYTEXT' not in \`configure.in'");
850 }
851 }
853 if ($yacc_count > 1 || $lex_count > 1)
854 {
855 # If there is more than one distinct yacc (resp lex) source
856 # file in a given directory, then the `ylwrap' program is
857 # required to allow parallel builds to work correctly. FIXME:
858 # for now, no line number.
859 &require_config_file ($FOREIGN, 'ylwrap');
860 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
861 {
862 &define_variable ('YLWRAP', $config_aux_dir . "/ylwrap");
863 }
864 else
865 {
866 &define_variable ('YLWRAP', '$(srcdir)/ylwrap');
867 }
868 }
870 #
871 # Handle libtool.
872 #
873 local ($ltcompile, $ltlink) = ('', '');
874 if ($seen_libtool)
875 {
876 &define_configure_variable ("LIBTOOL");
877 $ltcompile = '$(LIBTOOL) --mode=compile ';
878 $ltlink = '$(LIBTOOL) --mode=link ';
879 }
881 #
882 # Now handle C++.
883 #
884 local (@cxx_list) = keys %cxx_extensions;
885 local ($cxx_count) = scalar @cxx_list;
886 if ($cxx_count)
887 {
888 push (@suffixes, @cxx_list);
890 &define_configure_variable ("CXXFLAGS");
891 &define_variable ('CXXCOMPILE', '$(CXX) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)');
892 &define_variable ('LTCXXCOMPILE',
893 $ltcompile . '$(CXX) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)')
894 if ($seen_libtool);
896 &define_variable ('CXXLINK', $ltlink . '$(CXX) $(CXXFLAGS) $(LDFLAGS) -o $@');
898 local ($ext);
899 foreach $ext (@cxx_list)
900 {
901 $output_rules .= ("$ext.o:\n"
902 . "\t\$(CXXCOMPILE) -c \$<\n");
903 $output_rules .= ("$ext.lo:\n"
904 . "\t\$(LTCXXCOMPILE) -c \$<\n")
905 if ($seen_libtool);
906 }
908 if (! defined $configure_vars{'CXX'})
909 {
910 &am_error ("C++ source seen but \`CXX' not defined in \`configure.in'");
911 }
912 }
914 #
915 # Handle some ansi2knr cleanup.
916 #
917 if (defined $options{'ansi2knr'} && keys %de_ansi_files)
918 {
919 # Make all _.c files depend on their corresponding .c files.
920 local ($base, @objects);
921 foreach $base (sort (keys %de_ansi_files))
922 {
923 # Each _.c file must depend on ansi2knr; otherwise it
924 # might be used in a parallel build before it is built.
925 $output_rules .= $base . "_.c: $base.c $(ANSI2KNR)\n\t"
926 . '$(ANSI2KNR) ' . $base . '.c ' . $base . "_.c\n";
927 push (@objects, $base . '_.o');
928 push (@objects, $base . '_.lo') if $seen_libtool;
929 }
931 # Make all _.o (and _.lo) files depend on ansi2knr.
932 # Use a sneaky little hack to make it print nicely.
933 &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
934 }
936 #
937 # Last, handle some C cleanup.
938 #
939 if ($seen_c_source)
940 {
941 &define_configure_variable ('CFLAGS');
942 &define_variable ('COMPILE',
943 '$(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)');
944 &define_variable ('LTCOMPILE',
945 $ltcompile .
946 '$(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)')
947 if ($seen_libtool);
948 &define_variable ('LINK', $ltlink . '$(CC) $(CFLAGS) $(LDFLAGS) -o $@');
950 if (! defined $configure_vars{'CC'})
951 {
952 &am_line_error ($seen_c_source,
953 "C source seen but \`CC' not defined in \`configure.in'");
954 }
955 }
956 }
959 # Output a rule to build from a YACC source. The output from YACC is
960 # compiled with C or C++, depending on the extension of the YACC file.
961 sub output_yacc_build_rule
962 {
963 local ($yacc_suffix, $use_ylwrap, $c_suffix) = @_;
965 local ($c_suffix, $suffix);
966 ($c_suffix = $yacc_suffix) =~ tr/y/c/;
967 push (@suffixes, $yacc_suffix, $c_suffix, '.h');
969 # Generate rule for c/c++ and header file. Probably should only
970 # do header if `yacc -d' is run. But how can we determine that?
971 foreach $suffix ($c_suffix, '.h')
972 {
973 $output_rules .= "$yacc_suffix$suffix:\n\t";
975 if ($use_ylwrap)
976 {
977 $output_rules .= ('$(SHELL) $(YLWRAP)'
978 . ' "$(YACC)" $< y.tab.c $*' . $c_suffix
979 . ' y.tab.h $*.h -- $(YACCFLAGS)');
980 }
981 else
982 {
983 $output_rules .= ('$(YACC) $(YACCFLAGS) $< && mv y.tab.c $@' . "\n"
984 . "\tif test -f y.tab.h; then \\\n"
985 . "\tif cmp -s y.tab.h \$*.h; then rm -f y.tab.h; else mv y.tab.h \$*.h; fi; \\\n"
986 . "\telse :; fi");
987 }
988 $output_rules .= "\n";
989 }
990 }
992 sub output_lex_build_rule
993 {
994 local ($lex_suffix, $use_ylwrap) = @_;
995 local ($c_suffix);
997 ($c_suffix = $lex_suffix) =~ tr/l/c/;
998 push (@suffixes, $lex_suffix);
999 &define_configure_variable ('LEX_OUTPUT_ROOT');
1000 &define_configure_variable ('LEXLIB');
1001 $output_rules .= "$lex_suffix$c_suffix:\n\t";
1003 if ($use_ylwrap)
1004 {
1005 # Is the $@ correct here? If so, why not use it in the ylwrap
1006 # build rule for yacc above?
1007 $output_rules .= '$(SHELL) $(YLWRAP)'
1008 . ' "$(LEX)" $< $(LEX_OUTPUT_ROOT).c $@ -- $(LFLAGS)';
1009 }
1010 else
1011 {
1012 $output_rules .= '$(LEX) $(LFLAGS) $< && mv $(LEX_OUTPUT_ROOT).c $@';
1013 }
1014 $output_rules .= "\n";
1015 }
1018 # Check to make sure a source defined in LIBOBJS is not explicitly
1019 # mentioned. This is a separate function (as opposed to being inlined
1020 # in handle_source_transform) because it isn't always appropriate to
1021 # do this check.
1022 sub check_libobjs_sources
1023 {
1024 local ($one_file, $unxformed) = @_;
1026 local ($prefix, $file, @files);
1027 foreach $prefix ('', 'EXTRA_')
1028 {
1029 if (&variable_defined ($prefix . $one_file . '_SOURCES'))
1030 {
1031 @files = &variable_value_as_list (($prefix
1032 . $one_file . '_SOURCES'),
1033 'all');
1034 }
1035 elsif ($prefix eq '')
1036 {
1037 @files = ($unxformed . '.c');
1038 }
1039 else
1040 {
1041 next;
1042 }
1044 foreach $file (@files)
1045 {
1046 if (defined $libsources{$file})
1047 {
1048 &am_line_error ($prefix . $one_file . '_SOURCES',
1049 "automatically discovered file \`$file' should not be explicitly mentioned");
1050 }
1051 }
1052 }
1053 }
1055 # Does much of the actual work for handle_source_transform.
1056 # Arguments are:
1057 # list of source files to transform
1058 # Result is a list
1059 # first element is name of linker to use (empty string for default linker)
1060 # remaining elements are names of `.o's
1061 sub handle_single_transform_list
1062 {
1063 local (@files) = @_;
1064 local ($linker) = '';
1065 local (@result) = ();
1066 local ($nonansi_obj) = $obj;
1067 $nonansi_obj =~ s/_//g;
1068 if (length (@files))
1069 {
1070 # Turn sources into objects.
1071 foreach (@files)
1072 {
1073 # Skip header files, including C++-ish ones. The list
1074 # of C++ header extensions comes from Emacs 19.32
1075 # etags.
1076 next if /\.[hH]$/;
1077 next if /\.hxx$/;
1078 next if /\.h\+\+$/;
1079 next if /\.hh$/;
1080 next if /\.hpp$/;
1081 # Skip things that look like configure substitutions.
1082 next if /^\@.*\@$/;
1084 # Include appropriate file for lex or yacc source in
1085 # distribution. If the extension is the regular '.y' or
1086 # '.l', we assume C compilation, and the generated file
1087 # has exension .c. Otherwise, we compile with C++, and
1088 # make the following association: (yy -> cc, y++ -> c++,
1089 # yxx -> cxx), similarly for .ll, etc.
1090 if (/^(.*)\.(y|yy|y\+\+|yxx)$/)
1091 {
1092 # Yacc source.
1093 local ($ext) = $2;
1094 $ext =~ tr/y/c/;
1095 &push_dist_common ("$1.$ext");
1096 $yacc_sources{$_} = 1;
1097 }
1098 elsif (/^(.*)\.(l|ll|l\+\+|lxx)$/)
1099 {
1100 # Lex source.
1101 local ($ext) = $2;
1102 $ext =~ tr/l/c/;
1103 &push_dist_common ("$1.$ext");
1104 $lex_sources{$_} = 1;
1105 }
1107 # Strip any directory prefix.
1108 $_ = &basename ($_);
1110 # Transform source files into .o files. List of C++
1111 # extensions comes from Emacs 19.34 etags.
1112 if (s/\.(c\+\+|cc|cpp|cxx|C)$/$nonansi_obj/)
1113 {
1114 $cxx_extensions{'.' . $1} = 1;
1115 $linker = 'CXXLINK';
1116 }
1117 elsif (s/\.(yy|y\+\+|yxx|ll|l\+\+|lxx)$/$nonansi_obj/)
1118 {
1119 # Compiling lex or yacc with C++
1120 local ($ext) = $1;
1121 $ext =~ tr/ly/cc/;
1122 $cxx_extensions{".$ext"} = 1;
1123 $linker = 'CXXLINK';
1124 }
1125 elsif (s/\.([Ff]\\|f90\\|for)$/$nonansi_obj/)
1126 {
1127 # FORTRAN support. FIXME: not finished.
1128 }
1129 elsif (s/\.[sS]$/$nonansi_obj/)
1130 {
1131 # .s is assembly. Just rewrite it. FIXME: not finished.
1132 }
1133 elsif (defined ($options{'ansi2knr'}) && s/_\.[cly]$/_.c/)
1134 {
1135 # FIXME include line number in error.
1136 &am_error ("C source file \`$_' would be deleted by ansi2knr rules");
1137 }
1138 elsif (s/\.[cly]$//)
1139 {
1140 # .c is C. .l is lex. .y is yacc.
1142 # Note: first we rewrite (eg) foo.c to foo and push
1143 # the file onto the list of deansified files. Then we add
1144 # $obj, which can either be `_.o', or simply `.o' if
1145 # deansification is not required.
1146 $de_ansi_files{$_} = 1;
1147 $_ .= $obj;
1148 $seen_c_source = 1;
1149 }
1150 else
1151 {
1152 # No error message here. Used to have one, but it was
1153 # very unpopular.
1154 next;
1155 }
1157 push (@result, $_);
1159 # Transform .o or $o file into .P file (for automatic
1160 # dependency code).
1161 s/$objpat$/.P/g;
1162 $dep_files{'.deps/' . $_} = 1;
1163 }
1164 }
1166 return ($linker, @result);
1167 }
1169 # Handle SOURCE->OBJECT transform for one program or library.
1170 # Arguments are:
1171 # canonical (transformed) name of object to build
1172 # actual name of object to build
1173 # object extension (ie either `.o' or `$o'.
1174 # Return result is name of linker variable that must be used.
1175 # Empty return means just use `LINK'.
1176 sub handle_source_transform
1177 {
1178 # one_file is canonical name. unxformed is given name. obj is
1179 # object extension.
1180 local ($one_file, $unxformed, $obj) = @_;
1181 local ($objpat) = $obj;
1182 $objpat =~ s/(\W)/\\$1/g;
1183 # Handle explicit `.o' as well as whatever we're passed.
1184 $objpat = '(' . $objpat . "|\\.o)";
1186 local ($linker) = '';
1188 if (&variable_defined ($one_file . "_OBJECTS"))
1189 {
1190 &am_line_error ($one_file . '_OBJECTS',
1191 $one_file . '_OBJECTS', 'should not be defined');
1192 # No point in continuing.
1193 return;
1194 }
1196 local (@files, @result, $prefix, $temp);
1197 foreach $prefix ('', 'EXTRA_')
1198 {
1199 @files = ();
1200 local ($var) = $prefix . $one_file . "_SOURCES";
1201 if (&variable_defined ($var))
1202 {
1203 push (@sources, '$(' . $prefix . $one_file . "_SOURCES)");
1204 push (@objects, '$(' . $prefix . $one_file . "_OBJECTS)")
1205 unless $prefix eq 'EXTRA_';
1206 local (@conds) = &variable_conditions ($var);
1207 if (! @conds)
1208 {
1209 @files = &variable_value_as_list ($var, '');
1210 }
1211 else
1212 {
1213 local ($cond);
1214 foreach $cond (@conds)
1215 {
1216 @files = &variable_value_as_list ($var, $cond);
1217 ($temp, @result) = &handle_single_transform_list (@files);
1218 $linker = $temp if $linker eq '';
1219 &define_pretty_variable ($one_file . "_OBJECTS", $cond,
1220 @result)
1221 unless $prefix eq 'EXTRA_';
1222 }
1224 next;
1225 }
1226 }
1227 elsif ($prefix eq '')
1228 {
1229 &define_variable ($one_file . "_SOURCES", $unxformed . ".c");
1230 push (@sources, $unxformed . '.c');
1231 push (@objects, $unxformed . $obj);
1232 push (@files, $unxformed . '.c');
1233 }
1235 ($temp, @result) = &handle_single_transform_list (@files);
1236 $linker = $temp if $linker eq '';
1237 &define_pretty_variable ($one_file . "_OBJECTS", '', @result)
1238 unless $prefix eq 'EXTRA_';
1239 }
1241 return $linker;
1242 }
1244 # Handle the BUILT_SOURCES variable.
1245 sub handle_built_sources
1246 {
1247 return unless &variable_defined ('BUILT_SOURCES');
1249 local (@sources) = &variable_value_as_list ('BUILT_SOURCES', 'all');
1250 local ($s);
1251 foreach $s (@sources)
1252 {
1253 if (/^\@.*\@$/)
1254 {
1255 # FIXME: is this really the right thing to do?
1256 &am_line_error ('BUILT_SOURCES',
1257 "\`BUILT_SOURCES' should not contain a configure substitution");
1258 last;
1259 }
1260 }
1262 # We don't care about the return value of this function. We just
1263 # want to make sure to update %dep_files with the contents of
1264 # BUILT_SOURCES.
1265 &handle_single_transform_list (@sources);
1266 }
1268 # Special-case @ALLOCA@ and @LIBOBJS@ in _LDADD or _LIBADD variables.
1269 # Also, generate _DEPENDENCIES variable if appropriate.
1270 # Arguments are:
1271 # transformed name of object being built, or empty string if no object
1272 # name of _LDADD/_LIBADD-type variable to examine
1273 # boolean (lex_seen) which is true if a lex source file was seen in this
1274 # object. valid only for LDADDs, not LIBADDs. If set, LEXLIB
1275 # must be in LDADD.
1276 # Returns 1 if LIBOBJS seen, 0 otherwise.
1277 sub handle_lib_objects
1278 {
1279 local ($xname, $var, $lex_seen) = @_;
1280 local ($ret);
1282 die "automake: programming error 1 in handle_lib_objects\n"
1283 if ! &variable_defined ($var);
1285 die "automake: programming error 2 in handle_lib_objects\n"
1286 if $lex_seen && $var =~ /LIBADD/;
1288 local (@conds) = &variable_conditions ($var);
1289 if (! @conds)
1290 {
1291 $ret = &handle_lib_objects_cond ($xname, $var, $lex_seen, '');
1292 }
1293 else
1294 {
1295 local ($cond);
1296 $ret = 0;
1297 foreach $cond (@conds)
1298 {
1299 if (&handle_lib_objects_cond ($xname, $var, $lex_seen, $cond))
1300 {
1301 $ret = 1;
1302 }
1303 }
1304 }
1306 return $ret;
1307 }
1309 # Subroutine of handle_lib_objects: handle a particular condition.
1310 sub handle_lib_objects_cond
1311 {
1312 local ($xname, $var, $lex_seen, $cond) = @_;
1314 # We recognize certain things that are commonly put in LIBADD or
1315 # LDADD.
1316 local ($lsearch);
1317 local (@dep_list) = ();
1319 # If no lex source seen, just assume this is ok.
1320 local ($lex_ok) = $lex_seen ? 0 : 1;
1322 local ($seen_libobjs) = 0;
1323 local ($flagvar) = 0;
1325 foreach $lsearch (&variable_value_as_list ($var, $cond))
1326 {
1327 # Skip -lfoo and -Ldir; these are explicitly allowed.
1328 next if $lsearch =~ /^-[lL]/;
1329 if (! $flagvar && $lsearch =~ /^-/)
1330 {
1331 if ($var =~ /^(.*)LDADD$/)
1332 {
1333 &am_line_error ($var, "linker flags such as \`$lsearch' belong in \`${1}LDFLAGS");
1334 }
1335 else
1336 {
1337 # Only get this error once.
1338 $flagvar = 1;
1339 &am_line_error ($var, "you cannot use linker flags such as \`$lsearch' in \`$var'");
1340 }
1341 }
1343 # Assume we have a file of some sort, and push it onto the
1344 # dependency list. Autoconf substitutions are not pushed;
1345 # rarely is a new dependency substituted into (eg) foo_LDADD
1346 # -- but "bad things (eg -lX11) are routinely substituted.
1347 # Note that LIBOBJS and ALLOCA are exceptions to this rule,
1348 # and handled specially below.
1349 push (@dep_list, $lsearch)
1350 unless $lsearch =~ /^\@.*\@$/;
1352 # Automatically handle @LIBOBJS@ and @ALLOCA@. Basically this
1353 # means adding entries to dep_files.
1354 if ($lsearch =~ /^\@(LT)?LIBOBJS\@$/)
1355 {
1356 push (@dep_list, $lsearch);
1357 $seen_libobjs = 1;
1358 if (! keys %libsources)
1359 {
1360 &am_line_error ($var, "\@$1" . "LIBOBJS\@ seen but never set in \`configure.in'");
1361 }
1363 local ($iter, $rewrite);
1364 foreach $iter (keys %libsources)
1365 {
1366 if ($iter =~ /\.[cly]$/)
1367 {
1368 $seen_c_source = $var;
1369 }
1371 if ($iter =~ /\.h$/)
1372 {
1373 &require_file_with_line ($var, $FOREIGN, $iter);
1374 }
1375 elsif ($iter ne 'alloca.c')
1376 {
1377 ($rewrite = $iter) =~ s/\.c$/.P/;
1378 $dep_files{'.deps/' . $rewrite} = 1;
1379 &require_file_with_line ($var, $FOREIGN, $iter);
1380 }
1381 }
1382 }
1383 elsif ($lsearch =~ /^\@(LT)?ALLOCA\@$/)
1384 {
1385 push (@dep_list, $lsearch);
1386 &am_line_error ($var,
1387 "\@$1" . "ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
1388 if ! defined $libsources{'alloca.c'};
1389 $dep_files{'.deps/alloca.P'} = 1;
1390 &require_file_with_line ($var, $FOREIGN, 'alloca.c');
1391 $seen_c_source = $var;
1392 }
1393 elsif ($lsearch eq '@LEXLIB@')
1394 {
1395 # FIXME: variable_value_as_list requires us to force
1396 # @LEXLIB@ here, where we'd really prefer $(LEXLIB).
1397 # Nasty -- this will have to wait until many cleanups are
1398 # made, I think.
1399 $lex_ok = 1;
1400 }
1401 }
1403 if (! $lex_ok)
1404 {
1405 &am_line_error ($var, 'lex source file used without @LEXLIB@');
1406 }
1408 if ($xname ne '' && ! &variable_defined ($xname . '_DEPENDENCIES', $cond))
1409 {
1410 &define_pretty_variable ($xname . '_DEPENDENCIES', $cond, @dep_list);
1411 }
1413 return $seen_libobjs;
1414 }
1416 # Canonicalize a name, and check to make sure the non-canonical name
1417 # is never used. Returns canonical name. Arguments are name and a
1418 # list of suffixes to check for.
1419 sub check_canonical_spelling
1420 {
1421 local ($name, @suffixes) = @_;
1422 local ($xname, $xt);
1424 ($xname = $name) =~ tr/A-Za-z0-9_/_/c;
1425 if ($xname ne $name)
1426 {
1427 local ($xt);
1428 foreach $xt (@suffixes)
1429 {
1430 &am_line_error ($name . $xt,
1431 "invalid variable \`" . $name . $xt
1432 . "'; should be \`" . $xname . $xt . "'")
1433 if &variable_defined ($name . $xt);
1434 }
1435 }
1437 return $xname;
1438 }
1440 # Handle C programs.
1441 sub handle_programs
1442 {
1443 local (@proglist) = &am_install_var ('-clean',
1444 'progs', 'PROGRAMS',
1445 'bin', 'sbin', 'libexec', 'pkglib',
1446 'noinst', 'check');
1447 return if ! @proglist;
1449 # If a program is installed, this is required. We only want this
1450 # error to appear once.
1451 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1452 unless $seen_arg_prog;
1453 $seen_arg_prog = 1;
1455 local ($one_file, $xname, $munge);
1457 local ($seen_libobjs) = 0;
1458 foreach $one_file (@proglist)
1459 {
1460 local ($obj) = &get_object_extension ($one_file);
1462 # Canonicalize names and check for misspellings.
1463 $xname = &check_canonical_spelling ($one_file, '_LDADD', '_LDFLAGS',
1464 '_SOURCES', '_OBJECTS',
1465 '_DEPENDENCIES');
1467 # FIXME: Using a trick to figure out if any lex sources appear
1468 # in our program; should use some cleaner method.
1469 local ($lex_num) = scalar (keys %lex_sources);
1470 local ($linker) = &handle_source_transform ($xname, $one_file, $obj);
1471 local ($lex_file_seen) = (scalar (keys %lex_sources) > $lex_num);
1473 local ($xt) = '';
1474 if (&variable_defined ($xname . "_LDADD"))
1475 {
1476 if (&handle_lib_objects ($xname, $xname . '_LDADD',
1477 $lex_file_seen))
1478 {
1479 $seen_libobjs = 1;
1480 }
1481 $lex_file_seen = 0;
1482 $xt = '_LDADD';
1483 }
1484 else
1485 {
1486 # User didn't define prog_LDADD override. So do it.
1487 &define_variable ($xname . '_LDADD', '$(LDADD)');
1489 # This does a bit too much work. But we need it to
1490 # generate _DEPENDENCIES when appropriate.
1491 if (&variable_defined ('LDADD'))
1492 {
1493 if (&handle_lib_objects ($xname, 'LDADD', $lex_file_seen))
1494 {
1495 $seen_libobjs = 1;
1496 }
1497 $lex_file_seen = 0;
1498 }
1499 $xt = '_SOURCES'
1500 }
1502 if (&variable_defined ($xname . '_LIBADD'))
1503 {
1504 &am_line_error ($xname . '_LIBADD',
1505 "use \`" . $xname . "_LDADD', not \`"
1506 . $xname . "_LIBADD'");
1507 }
1509 if (! &variable_defined ($xname . '_LDFLAGS'))
1510 {
1511 # Define the prog_LDFLAGS variable.
1512 &define_variable ($xname . '_LDFLAGS', '');
1513 }
1515 if ($lex_file_seen)
1516 {
1517 &am_line_error ($xname . $xt,
1518 'lex source file used without @LEXLIB@');
1519 }
1521 # Determine program to use for link.
1522 local ($xlink);
1523 if (&variable_defined ($xname . '_LINK'))
1524 {
1525 $xlink = $xname . '_LINK';
1526 }
1527 else
1528 {
1529 $xlink = $linker ? $linker : 'LINK';
1530 }
1532 local ($xexe);
1533 if ($seen_exeext && $one_file !~ /\./)
1534 {
1535 $xexe = 's/\@EXEEXT\@/\$(EXEEXT)/g;';
1536 }
1537 else
1538 {
1539 $xexe = 's/\@EXEEXT\@//g;';
1540 }
1542 $output_rules .=
1543 &file_contents_with_transform
1544 ('s/\@PROGRAM\@/' . $one_file . '/go;'
1545 . 's/\@XPROGRAM\@/' . $xname . '/go;'
1546 . 's/\@XLINK\@/' . $xlink . '/go;'
1547 . $xexe,
1548 'program');
1549 }
1551 if (&variable_defined ('LDADD') && &handle_lib_objects ('', 'LDADD', 0))
1552 {
1553 $seen_libobjs = 1;
1554 }
1556 if ($seen_libobjs)
1557 {
1558 foreach $one_file (@proglist)
1559 {
1560 # Canonicalize names.
1561 ($xname = $one_file) =~ tr/A-Za-z0-9_/_/c;
1563 if (&variable_defined ($xname . '_LDADD'))
1564 {
1565 &check_libobjs_sources ($xname, $xname . '_LDADD');
1566 }
1567 elsif (&variable_defined ('LDADD'))
1568 {
1569 &check_libobjs_sources ($xname, 'LDADD');
1570 }
1571 }
1572 }
1573 }
1576 # Handle libraries.
1577 sub handle_libraries
1578 {
1579 local (@liblist) = &am_install_var ('-clean',
1580 'libs', 'LIBRARIES',
1581 'lib', 'pkglib', 'noinst', 'check');
1582 return if ! @liblist;
1584 local (%valid) = &am_primary_prefixes ('LIBRARIES', 'lib', 'pkglib',
1585 'noinst', 'check');
1586 if (! defined $configure_vars{'RANLIB'})
1587 {
1588 local ($key);
1589 foreach $key (keys %valid)
1590 {
1591 if (&variable_defined ($key . '_LIBRARIES'))
1592 {
1593 &am_line_error ($key . '_LIBRARIES', "library used but \`RANLIB' not defined in \`configure.in'");
1594 # Only get this error once.
1595 $configure_vars{'RANLIB'} = 1;
1596 last;
1597 }
1598 }
1599 }
1601 local ($onelib);
1602 local ($munge);
1603 local ($xlib);
1604 local ($seen_libobjs) = 0;
1605 foreach $onelib (@liblist)
1606 {
1607 # Check that the library fits the standard naming convention.
1608 if ($onelib !~ /^lib.*\.a$/)
1609 {
1610 # FIXME this should only be a warning for foreign packages
1611 # FIXME should put line number here. That means mapping
1612 # from library name back to variable name.
1613 &am_error ("\`$onelib' is not a standard library name");
1614 }
1616 local ($obj) = &get_object_extension ($onelib);
1618 # Canonicalize names and check for misspellings.
1619 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
1620 '_OBJECTS', '_DEPENDENCIES');
1622 if (&variable_defined ($xlib . '_LIBADD'))
1623 {
1624 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
1625 {
1626 $seen_libobjs = 1;
1627 }
1628 }
1629 else
1630 {
1631 # Generate support for conditional object inclusion in
1632 # libraries.
1633 &define_variable ($xlib . "_LIBADD", '');
1634 }
1636 if (&variable_defined ($xlib . '_LDADD'))
1637 {
1638 &am_line_error ($xlib . '_LDADD',
1639 "use \`" . $xlib . "_LIBADD', not \`"
1640 . $xlib . "_LDADD'");
1641 }
1643 &handle_source_transform ($xlib, $onelib, $obj);
1645 $output_rules .=
1646 &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go;'
1647 . 's/\@XLIBRARY\@/'
1648 . $xlib . '/go;',
1649 'library');
1650 }
1652 if ($seen_libobjs)
1653 {
1654 foreach $onelib (@liblist)
1655 {
1656 # Canonicalize names.
1657 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1658 if (&variable_defined ($xlib . '_LIBADD'))
1659 {
1660 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
1661 }
1662 }
1663 }
1665 &define_variable ('AR', 'ar');
1666 &define_configure_variable ('RANLIB');
1667 }
1669 # Handle shared libraries.
1670 sub handle_ltlibraries
1671 {
1672 local (@liblist) = &am_install_var ('-clean',
1673 'ltlib', 'LTLIBRARIES',
1674 'lib', 'pkglib');
1675 return if ! @liblist;
1677 local (%instdirs);
1678 local (%valid) = &am_primary_prefixes ('LTLIBRARIES', 'lib', 'pkglib');
1680 local ($key);
1681 foreach $key (keys %valid)
1682 {
1683 if (&variable_defined ($key . '_LTLIBRARIES'))
1684 {
1685 if (!$seen_libtool)
1686 {
1687 &am_line_error ($key . '_LTLIBRARIES', "library used but \`LIBTOOL' not defined in \`configure.in'");
1688 # Only get this error once.
1689 $configure_vars{'LIBTOOL'} = 1;
1690 $seen_libtool = 1;
1691 }
1693 # Get the installation directory of each library.
1694 for (&variable_value_as_list ($key . '_LTLIBRARIES', 'all'))
1695 {
1696 if ($instdirs{$_})
1697 {
1698 &am_error ("\`$_' is already going to be installed in \`$instdirs{$_}'");
1699 }
1700 else
1701 {
1702 $instdirs{$_} = $key;
1703 }
1704 }
1705 }
1706 }
1708 local ($onelib);
1709 local ($munge);
1710 local ($xlib);
1711 local ($seen_libobjs) = 0;
1712 foreach $onelib (@liblist)
1713 {
1714 # Check that the library fits the standard naming convention.
1715 if ($onelib !~ /^lib.*\.la$/)
1716 {
1717 # FIXME this should only be a warning for foreign packages
1718 # FIXME should put line number here. That means mapping
1719 # from library name back to variable name.
1720 &am_error ("\`$onelib' is not a standard libtool library name");
1721 }
1723 local ($obj) = &get_object_extension ($onelib);
1725 # Canonicalize names and check for misspellings.
1726 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
1727 '_SOURCES', '_OBJECTS',
1728 '_DEPENDENCIES');
1730 if (! &variable_defined ($xlib . '_LDFLAGS'))
1731 {
1732 # Define the lib_LDFLAGS variable.
1733 &define_variable ($xlib . '_LDFLAGS', '');
1734 }
1736 if (&variable_defined ($xlib . '_LIBADD'))
1737 {
1738 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
1739 {
1740 $seen_libobjs = 1;
1741 }
1742 }
1743 else
1744 {
1745 # Generate support for conditional object inclusion in
1746 # libraries.
1747 &define_variable ($xlib . "_LIBADD", '');
1748 }
1750 if (&variable_defined ($xlib . '_LDADD'))
1751 {
1752 &am_line_error ($xlib . '_LDADD',
1753 "use \`" . $xlib . "_LIBADD', not \`"
1754 . $xlib . "_LDADD'");
1755 }
1757 local ($linker) = &handle_source_transform ($xlib, $onelib, $obj);
1759 # Determine program to use for link.
1760 local ($xlink);
1761 if (&variable_defined ($xlib . '_LINK'))
1762 {
1763 $xlink = $xlib . '_LINK';
1764 }
1765 else
1766 {
1767 $xlink = $linker ? $linker : 'LINK';
1768 }
1770 local ($rpath);
1771 if ($instdirs{$onelib} eq 'EXTRA')
1772 {
1773 # It's an EXTRA_ library, so we can't specify -rpath.
1774 # Yuck.
1775 $rpath = 's/\@RPATH\@//go;';
1776 }
1777 else
1778 {
1779 $rpath = ('s/\@RPATH\@/-rpath \$(' . $instdirs{$onelib}
1780 . 'dir)/go;');
1781 }
1783 $output_rules .=
1784 &file_contents_with_transform ('s/\@LTLIBRARY\@/'
1785 . $onelib . '/go;'
1786 . 's/\@XLTLIBRARY\@/'
1787 . $xlib . '/go;'
1788 . $rpath
1789 . 's/\@XLINK\@/' . $xlink . '/go;',
1790 'ltlibrary');
1791 }
1793 if ($seen_libobjs)
1794 {
1795 foreach $onelib (@liblist)
1796 {
1797 # Canonicalize names.
1798 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1799 if (&variable_defined ($xlib . '_LIBADD'))
1800 {
1801 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
1802 }
1803 }
1804 }
1805 }
1807 # See if any _SOURCES variable were misspelled. Also, make sure that
1808 # EXTRA_ variables don't contain configure substitutions.
1809 sub check_typos
1810 {
1811 local ($varname, $primary);
1812 foreach $varname (keys %contents)
1813 {
1814 foreach $primary ('_SOURCES', '_LIBADD', '_LDADD', '_LDFLAGS',
1815 '_DEPENDENCIES')
1816 {
1817 if ($varname =~ /$primary$/ && ! $content_seen{$varname})
1818 {
1819 &am_line_error ($varname,
1820 "invalid unused variable name: \`$varname'");
1821 }
1822 }
1823 }
1824 }
1826 # Handle scripts.
1827 sub handle_scripts
1828 {
1829 # NOTE we no longer automatically clean SCRIPTS, because it is
1830 # useful to sometimes distribute scripts verbatim. This happens
1831 # eg in Automake itself.
1832 &am_install_var ('scripts', 'SCRIPTS',
1833 'bin', 'sbin', 'libexec', 'pkgdata',
1834 'noinst', 'check');
1836 # Set $scripts_installed if appropriate. Make sure we only find
1837 # scripts which are actually installed -- this is why we can't
1838 # simply use the return value of am_install_var.
1839 local (%valid) = &am_primary_prefixes ('SCRIPTS', 'bin', 'sbin',
1840 'libexec', 'pkgdata',
1841 'noinst', 'check');
1842 local ($key);
1843 foreach $key (keys %valid)
1844 {
1845 if ($key ne 'noinst'
1846 && $key ne 'check'
1847 && &variable_defined ($key . '_SCRIPTS'))
1848 {
1849 $scripts_installed = 1;
1850 # push (@check_tests, 'check-' . $key . 'SCRIPTS');
1851 }
1852 }
1854 if ($scripts_installed)
1855 {
1856 # If a program is installed, this is required. We only want this
1857 # error to appear once.
1858 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1859 unless $seen_arg_prog;
1860 $seen_arg_prog = 1;
1861 }
1862 }
1864 # Search a file for a "version.texi" Texinfo include. Return the name
1865 # of the include file if found, or the empty string if not. A
1866 # "version.texi" file is actually any file whose name matches
1867 # "vers*.texi".
1868 sub scan_texinfo_file
1869 {
1870 local ($filename) = @_;
1872 if (! open (TEXI, $filename))
1873 {
1874 &am_error ("couldn't open \`$filename': $!");
1875 return '';
1876 }
1877 print "automake: reading $filename\n" if $verbose;
1879 local ($vfile, $outfile);
1880 while (<TEXI>)
1881 {
1882 if (/^\@setfilename +(\S+)/)
1883 {
1884 $outfile = $1;
1885 last if ($vfile);
1886 }
1888 if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
1889 {
1890 # Found version.texi include.
1891 $vfile = $1;
1892 last if $outfile;
1893 }
1894 }
1896 close (TEXI);
1897 return ($outfile, $vfile);
1898 }
1900 # Handle all Texinfo source.
1901 sub handle_texinfo
1902 {
1903 &am_line_error ('TEXINFOS',
1904 "\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
1905 if &variable_defined ('TEXINFOS');
1906 return if (! &variable_defined ('info_TEXINFOS')
1907 && ! &variable_defined ('html_TEXINFOS'));
1909 local (@texis) = &variable_value_as_list ('info_TEXINFOS', 'all');
1911 local (@info_deps_list, @dvis_list, @texi_deps);
1912 local ($infobase, $info_cursor);
1913 local (%versions);
1914 local ($done) = 0;
1915 local ($vti);
1916 local ($tc_cursor, @texi_cleans);
1917 local ($canonical);
1919 foreach $info_cursor (@texis)
1920 {
1921 ($infobase = $info_cursor) =~ s/\.texi(nfo)?$//;
1923 # If 'version.texi' is referenced by input file, then include
1924 # automatic versioning capability.
1925 local ($out_file, $vtexi) = &scan_texinfo_file ($relative_dir
1926 . "/" . $info_cursor);
1928 if ($out_file eq '')
1929 {
1930 &am_error ("\`$info_cursor' missing \@setfilename");
1931 next;
1932 }
1934 if ($out_file =~ /\.(.+)$/ && $1 ne 'info')
1935 {
1936 # FIXME should report line number in input file.
1937 &am_error ("output of \`$info_cursor', \`$out_file', has unrecognized extension");
1938 next;
1939 }
1941 if ($vtexi)
1942 {
1943 &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
1944 if (defined $versions{$vtexi});
1945 $versions{$vtexi} = $info_cursor;
1947 # We number the stamp-vti files. This is doable since the
1948 # actual names don't matter much. We only number starting
1949 # with the second one, so that the common case looks nice.
1950 $vti = 'vti' . ($done ? $done : '');
1951 &push_dist_common ($vtexi, 'stamp-' . $vti);
1952 push (@clean, $vti);
1954 # Only require once.
1955 &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
1956 'mdate-sh')
1957 if ! $done;
1958 ++$done;
1960 local ($conf_pat);
1961 ($conf_pat = $config_aux_dir) =~ s/(\W)/\\$1/g;
1962 $output_rules .=
1963 &file_contents_with_transform
1964 ('s/\@TEXI\@/' . $info_cursor . '/g; '
1965 . 's/\@VTI\@/' . $vti . '/g; '
1966 . 's/\@VTEXI\@/' . $vtexi . '/g;'
1967 . 's,\@MDDIR\@,' . $conf_pat . ',g;',
1968 'texi-vers');
1970 &push_phony_cleaners ($vti);
1971 }
1973 # If user specified file_TEXINFOS, then use that as explicit
1974 # dependency list.
1975 @texi_deps = ();
1976 push (@texi_deps, $info_cursor);
1977 push (@texi_deps, $vtexi) if $vtexi;
1979 # Canonicalize name first.
1980 ($canonical = $infobase) =~ tr/A-Za-z0-9_/_/c;
1981 if (&variable_defined ($canonical . "_TEXINFOS"))
1982 {
1983 push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
1984 &push_dist_common ('$(' . $canonical . '_TEXINFOS)');
1985 }
1987 $output_rules .= ("\n" . $out_file . ": "
1988 . join (' ', @texi_deps)
1989 . "\n" . $infobase . ".dvi: "
1990 . join (' ', @texi_deps)
1991 . "\n\n");
1993 push (@info_deps_list, $out_file);
1994 push (@dvis_list, $infobase . '.dvi');
1996 # Generate list of things to clean for this target. We do
1997 # this explicitly because otherwise too many things could be
1998 # removed. In particular the ".log" extension might
1999 # reasonably be used in other contexts by the user.
2000 foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns',
2001 'ky', 'log', 'pg', 'toc', 'tp', 'tps',
2002 'vr', 'vrs', 'op', 'tr', 'cv', 'cn')
2003 {
2004 push (@texi_cleans, $infobase . '.' . $tc_cursor);
2005 }
2006 }
2008 # Find these programs wherever they may lie. Yes, this has
2009 # intimate knowledge of the structure of the texinfo distribution.
2010 &define_program_variable ('MAKEINFO', 'build', 'texinfo/makeinfo',
2011 'makeinfo',
2012 # Circumlocution to avoid accidental
2013 # configure substitution.
2014 '@MAKE' . 'INFO@');
2015 &define_program_variable ('TEXI2DVI', 'src', 'texinfo/util',
2016 'texi2dvi');
2018 # Set transform for including texinfos.am. First, handle --cygnus
2019 # stuff.
2020 local ($xform);
2021 if ($cygnus_mode)
2022 {
2023 $xform = 's/^NOTCYGNUS.*$//; s/^CYGNUS//;';
2024 }
2025 else
2026 {
2027 $xform = 's/^CYGNUS.*$//; s/^NOTCYGNUS//;';
2028 }
2030 # Handle location of texinfo.tex.
2031 if ($cygnus_mode)
2032 {
2033 &define_variable ('TEXINFO_TEX',
2034 '$(top_srcdir)/../texinfo/texinfo.tex');
2035 }
2036 elsif ($config_aux_dir ne '.' && $config_aux_dir ne '')
2037 {
2038 &define_variable ('TEXINFO_TEX', $config_aux_dir . '/texinfo.tex');
2039 }
2040 elsif (! &variable_defined ('TEXINFO_TEX'))
2041 {
2042 &define_variable ('TEXINFO_TEX', '$(srcdir)/texinfo.tex');
2043 }
2044 local ($xxform) = &dirname (&variable_value ('TEXINFO_TEX'));
2045 $xxform =~ s/(\W)/\\$1/g;
2046 $xform .= ' s/\@TEXINFODIR\@/' . $xxform . '/g;';
2048 $output_rules .= &file_contents_with_transform ($xform, 'texinfos');
2049 push (@phony, 'install-info-am', 'uninstall-info');
2050 push (@dist_targets, 'dist-info');
2052 # How to clean. The funny name is due to --cygnus influence; in
2053 # Cygnus mode, `clean-info' is a target that users can use.
2054 $output_rules .= "\nmostlyclean-aminfo:\n";
2055 &pretty_print_rule ("\trm -f", "\t ", @texi_cleans);
2056 $output_rules .= ("\nclean-aminfo:\n\ndistclean-aminfo:\n\n"
2057 . "maintainer-clean-aminfo:\n\t"
2058 # Eww. But how else can we find all the output
2059 # files from makeinfo?
2060 . 'for i in $(INFO_DEPS); do' . " \\\n"
2061 . "\t" . ' rm -f $$i;' . " \\\n"
2062 . "\t" . ' if test "`echo $$i-[0-9]*`" != "$$i-[0-9]*"; then' . " \\\n"
2063 . "\t" . ' rm -f $$i-[0-9]*;' . " \\\n"
2064 . "\t" . ' fi;' . " \\\n"
2065 . "\tdone\n");
2066 &push_phony_cleaners ('aminfo');
2067 if ($cygnus_mode)
2068 {
2069 $output_rules .= "clean-info: mostlyclean-aminfo\n";
2070 }
2072 push (@suffixes, '.texi', '.texinfo', '.info', '.dvi', '.ps');
2074 if (! defined $options{'no-installinfo'})
2075 {
2076 push (@uninstall, 'uninstall-info');
2077 push (@installdirs, '$(infodir)');
2078 unshift (@install_data, 'install-info-am');
2080 # Make sure documentation is made and installed first. Use
2081 # $(INFO_DEPS), not 'info', because otherwise recursive makes
2082 # get run twice during "make all".
2083 unshift (@all, '$(INFO_DEPS)');
2084 }
2085 push (@clean, 'aminfo');
2086 push (@info, '$(INFO_DEPS)');
2087 push (@dvi, '$(DVIS)');
2089 &define_variable ("INFO_DEPS", join (' ', @info_deps_list));
2090 &define_variable ("DVIS", join (' ', @dvis_list));
2091 # This next isn't strictly needed now -- the places that look here
2092 # could easily be changed to look in info_TEXINFOS. But this is
2093 # probably better, in case noinst_TEXINFOS is ever supported.
2094 &define_variable ("TEXINFOS", &variable_value ('info_TEXINFOS'));
2096 # Do some error checking. Note that this file is not required
2097 # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
2098 # up above.
2099 &require_file_with_line ('info_TEXINFOS', $FOREIGN, 'texinfo.tex')
2100 unless (defined $options{'no-texinfo.tex'}
2101 || &variable_defined ('TEXINFO_TEX'));
2102 }
2104 # Handle any man pages.
2105 sub handle_man_pages
2106 {
2107 &am_line_error ('MANS', "\`MANS' is an anachronism; use \`man_MANS'")
2108 if &variable_defined ('MANS');
2109 return if ! &variable_defined ('man_MANS');
2111 # We generate the manpage install code by hand to avoid the use of
2112 # basename in the generated Makefile.
2113 local (@mans) = &variable_value_as_list ('man_MANS', 'all');
2114 local (%sections, %inames, %mbases, %secmap, %fullsecmap);
2115 local ($i) = 1;
2116 foreach (@mans)
2117 {
2118 # FIXME: statement without effect:
2119 /^(.*)\.([0-9])([a-z]*)$/;
2120 $sections{$2} = 1;
2121 $inames{$i} = $_;
2122 $mbases{$i} = $1;
2123 $secmap{$i} = $2;
2124 $fullsecmap{$i} = $2 . $3;
2125 $i++;
2126 }
2128 # We don't really need this, but we use it in case we ever want to
2129 # support noinst_MANS.
2130 &define_variable ("MANS", &variable_value ('man_MANS'));
2132 # Generate list of install dirs.
2133 $output_rules .= "install-man: \$(MANS)\n";
2134 $output_rules .= "\t\$(NORMAL_INSTALL)\n";
2135 # Sort keys so that output is deterministic.
2136 foreach (sort keys %sections)
2137 {
2138 push (@installdirs, '$(mandir)/man' . $_)
2139 unless defined $options{'no-installman'};
2140 $output_rules .= ("\t" . '$(mkinstalldirs) $(mandir)/man'
2141 . $_ . "\n");
2142 }
2143 push (@phony, 'install-man');
2145 # Generate install target.
2146 local ($key);
2147 foreach $key (sort keys %inames)
2148 {
2149 $_ = $install_man_format;
2150 s/\@SECTION\@/$secmap{$key}/g;
2151 s/\@MAN\@/$inames{$key}/g;
2152 s/\@FULLSECT\@/$fullsecmap{$key}/g;
2153 s/\@MANBASE\@/$mbases{$key}/g;
2154 $output_rules .= $_;
2155 }
2156 $output_rules .= "\n";
2158 $output_rules .= "uninstall-man:\n\t\$(NORMAL_UNINSTALL)\n";
2159 foreach $key (sort keys %inames)
2160 {
2161 $_ = $uninstall_man_format;
2162 s/\@SECTION\@/$secmap{$key}/g;
2163 s/\@MAN\@/$inames{$key}/g;
2164 s/\@FULLSECT\@/$fullsecmap{$key}/g;
2165 s/\@MANBASE\@/$mbases{$key}/g;
2166 $output_rules .= $_;
2167 }
2168 $output_rules .= "\n";
2169 push (@phony, 'uninstall-man');
2171 $output_vars .= &file_contents ('mans-vars');
2173 if (! defined $options{'no-installman'})
2174 {
2175 push (@install_data, 'install-man');
2176 push (@uninstall, 'uninstall-man');
2177 push (@all, '$(MANS)');
2178 }
2179 }
2181 # Handle DATA variables.
2182 sub handle_data
2183 {
2184 &am_install_var ('data', 'DATA', 'data', 'sysconf',
2185 'sharedstate', 'localstate', 'pkgdata',
2186 'noinst', 'check');
2187 }
2189 # Handle TAGS.
2190 sub handle_tags
2191 {
2192 push (@phony, 'tags');
2193 local (@tag_deps) = ();
2194 if (&variable_defined ('SUBDIRS'))
2195 {
2196 $output_rules .= ("tags-recursive:\n"
2197 . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
2198 # Never fail here if a subdir fails; it
2199 # isn't important.
2200 . "\t (cd \$\$subdir && \$(MAKE) tags); \\\n"
2201 . "\tdone\n");
2202 push (@tag_deps, 'tags-recursive');
2203 push (@phony, 'tags-recursive');
2204 }
2206 if ($dir_holds_sources
2207 || $dir_holds_headers
2208 || &variable_defined ('ETAGS_ARGS')
2209 || @tag_deps)
2210 {
2211 local ($xform) = '';
2212 local ($one_hdr);
2213 foreach $one_hdr (@config_headers)
2214 {
2215 if ($relative_dir eq &dirname ($one_hdr))
2216 {
2217 # The config header is in this directory. So require it.
2218 local ($var);
2219 ($var = &basename ($one_hdr)) =~ s/(\W)/\\$1/g;
2220 $xform .= ' ' if $xform;
2221 $xform .= $var;
2222 }
2223 }
2224 $xform = ('s/\@CONFIG\@/' . $xform . '/;'
2225 . 's/\@DIRS\@/' . join (' ', @tag_deps) . '/;');
2227 if (&variable_defined ('SUBDIRS'))
2228 {
2229 $xform .= 's/^SUBDIRS//;';
2230 }
2231 else
2232 {
2233 $xform .= 's/^SUBDIRS.*$//;';
2234 }
2236 $output_rules .= &file_contents_with_transform ($xform, 'tags');
2237 $output_rules .= &file_contents ('tags-clean');
2238 push (@clean, 'tags');
2239 &push_phony_cleaners ('tags');
2240 &examine_variable ('TAGS_DEPENDENCIES');
2241 }
2242 elsif (&variable_defined ('TAGS_DEPENDENCIES'))
2243 {
2244 &am_line_error ('TAGS_DEPENDENCIES',
2245 "doesn't make sense to define \`TAGS_DEPENDENCIES' without sources or \`ETAGS_ARGS'");
2246 }
2247 else
2248 {
2249 # Every Makefile must define some sort of TAGS rule.
2250 # Otherwise, it would be possible for a top-level "make TAGS"
2251 # to fail because some subdirectory failed.
2252 $output_rules .= "tags: TAGS\nTAGS:\n\n";
2253 }
2254 }
2256 # Worker for handle_dist.
2257 sub handle_dist_worker
2258 {
2259 local ($makefile) = @_;
2261 $output_rules .= 'distdir: $(DISTFILES)' . "\n";
2263 # Initialization; only at top level.
2264 if ($relative_dir eq '.')
2265 {
2266 if ($strictness >= $GNITS)
2267 {
2268 # For Gnits users, this is pretty handy. Look at 15 lines
2269 # in case some explanatory text is desirable.
2270 $output_rules .= ' @if sed 15q $(srcdir)/NEWS | fgrep -e "$(VERSION)" > /dev/null; then :; else \\
2271 echo "NEWS not updated; not releasing" 1>&2; \\
2272 exit 1; \\
2273 fi
2274 ';
2275 }
2278 # Create dist directory.
2279 $output_rules .= ("\trm -rf \$(distdir)\n"
2280 . "\tmkdir \$(distdir)\n"
2281 . "\t-chmod 777 \$(distdir)\n");
2282 }
2284 # Only run automake in `dist' target if --include-deps and
2285 # `no-dependencies' not specified. That way the recipient of a
2286 # distribution can run "make dist" and not need Automake. You
2287 # might be wondering why we run automake once for each directory
2288 # we distribute, instead of running it once at the top level. The
2289 # answer is that we want to run automake after the dependencies
2290 # have been generated. This occurs when "make" is run in the
2291 # subdir. So automake must be run after make has updated the
2292 # Makefile, which means that it must run once per directory.
2293 if ($use_dependencies)
2294 {
2295 $output_rules .=
2296 (
2297 # We need an absolute path for --output-dir. Thus the
2298 # weirdness.
2299 "\t" . 'here=`cd $(top_builddir) && pwd`; ' . "\\\n"
2300 . "\t" . 'top_distdir=`cd $(top_distdir) && pwd`; ' . "\\\n"
2301 . "\tcd \$(top_srcdir) \\\n"
2302 . "\t && \$(AUTOMAKE) --include-deps --build-dir=\$\$here --srcdir-name=\$(top_srcdir) --output-dir=\$\$top_distdir "
2303 # Set strictness of output.
2304 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
2305 . ($cmdline_use_dependencies ? '' : ' --include-deps')
2306 . " " . $makefile . "\n"
2307 );
2308 }
2310 # Scan EXTRA_DIST to see if we need to distribute anything from a
2311 # subdir. If so, add it to the list. I didn't want to do this
2312 # originally, but there were so many requests that I finally
2313 # relented.
2314 local (@dist_dirs);
2315 if (&variable_defined ('EXTRA_DIST'))
2316 {
2317 # FIXME: This should be fixed to work with conditionals. That
2318 # will require only making the entries in @dist_dirs under the
2319 # appropriate condition. This is meaningful if the nature of
2320 # the distribution should depend upon the configure options
2321 # used.
2322 foreach (&variable_value_as_list ('EXTRA_DIST', ''))
2323 {
2324 next if /^\@.*\@$/;
2325 next unless s,/+[^/]+$,,;
2326 push (@dist_dirs, $_)
2327 unless $_ eq '.';
2328 }
2329 }
2330 if (@dist_dirs)
2331 {
2332 # Prepend $(distdir) to each directory given. Doing it via a
2333 # hash lets us ensure that each directory is used only once.
2334 local (%dhash);
2335 grep ($dhash{'$(distdir)/' . $_} = 1, @dist_dirs);
2336 $output_rules .= "\t";
2337 &pretty_print_rule ('$(mkinstalldirs)', "\t ", sort keys %dhash);
2338 }
2340 # In loop, test for file existence because sometimes a file gets
2341 # included in DISTFILES twice. For example this happens when a
2342 # single source file is used in building more than one program.
2343 # Also, there are situations in which "ln" can fail. For instance
2344 # a file to distribute could actually be a cross-filesystem
2345 # symlink -- this can easily happen if "gettextize" was run on the
2346 # distribution.
2347 $output_rules .= "\t\@for file in \$(DISTFILES); do \\\n";
2348 if ($cygnus_mode)
2349 {
2350 $output_rules .= "\t if test -f \$\$file; then d=.; else d=\$(srcdir); fi; \\\n";
2351 }
2352 else
2353 {
2354 $output_rules .= "\t d=\$(srcdir); \\\n";
2355 }
2356 $output_rules .= ' test -f $(distdir)/$$file \\
2357 || ln $$d/$$file $(distdir)/$$file 2> /dev/null \\
2358 || cp -p $$d/$$file $(distdir)/$$file; \\
2359 done
2360 ';
2362 # If we have SUBDIRS, create all dist subdirectories and do
2363 # recursive build.
2364 if (&variable_defined ('SUBDIRS'))
2365 {
2366 # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
2367 # to all possible directories, and use it.
2368 if (! &variable_conditions ('SUBDIRS'))
2369 {
2370 $dist_subdir_name = 'SUBDIRS';
2371 }
2372 else
2373 {
2374 $dist_subdir_name = 'DIST_SUBDIRS';
2375 if (! &variable_defined ('DIST_SUBDIRS'))
2376 {
2377 &define_pretty_variable ('DIST_SUBDIRS', '',
2378 &variable_value_as_list ('SUBDIRS',
2379 'all'));
2380 }
2381 }
2383 # Test for directory existence here because previous automake
2384 # invocation might have created some directories. Note that
2385 # we explicitly set distdir for the subdir make; that lets us
2386 # mix-n-match many automake-using packages into one large
2387 # package, and have "dist" at the top level do the right
2388 # thing.
2389 $output_rules .= ' for subdir in $(' . $dist_subdir_name . '); do \\
2390 test -d $(distdir)/$$subdir \\
2391 || mkdir $(distdir)/$$subdir \\
2392 || exit 1; \\
2393 chmod 777 $(distdir)/$$subdir; \\
2394 (cd $$subdir && $(MAKE) top_distdir=../$(top_distdir) distdir=../$(distdir)/$$subdir distdir) \\
2395 || exit 1; \\
2396 done
2397 ';
2398 }
2400 # If the target `dist-hook' exists, make sure it is run. This
2401 # allows users to do random weird things to the distribution
2402 # before it is packaged up.
2403 push (@dist_targets, 'dist-hook') if defined $contents{'dist-hook'};
2405 local ($targ);
2406 foreach $targ (@dist_targets)
2407 {
2408 # We must explicitly set distdir and top_distdir for these
2409 # sub-makes.
2410 $output_rules .= "\t\$(MAKE) top_distdir=\"\$(top_distdir)\" distdir=\"\$(distdir)\" $targ\n";
2411 }
2413 push (@phony, 'distdir');
2414 }
2416 # Handle 'dist' target.
2417 sub handle_dist
2418 {
2419 local ($makefile) = @_;
2421 # Set up maint_charset.
2422 $local_maint_charset = &variable_value ('MAINT_CHARSET')
2423 if &variable_defined ('MAINT_CHARSET');
2424 $maint_charset = $local_maint_charset
2425 if $relative_dir eq '.';
2427 if (&variable_defined ('DIST_CHARSET'))
2428 {
2429 &am_line_error ('DIST_CHARSET',
2430 "DIST_CHARSET defined but no MAINT_CHARSET defined")
2431 if ! $local_maint_charset;
2432 if ($relative_dir eq '.')
2433 {
2434 $dist_charset = &variable_value ('DIST_CHARSET')
2435 }
2436 else
2437 {
2438 &am_line_error ('DIST_CHARSET',
2439 "DIST_CHARSET can only be defined at top level");
2440 }
2441 }
2443 # Look for common files that should be included in distribution.
2444 local ($cfile);
2445 foreach $cfile (@common_files)
2446 {
2447 if (-f ($relative_dir . "/" . $cfile))
2448 {
2449 &push_dist_common ($cfile);
2450 }
2451 }
2453 # Keys of %dist_common are names of files to distributed. We put
2454 # README first because it then becomes easier to make a
2455 # Usenet-compliant shar file (in these, README must be first).
2456 # FIXME: do more ordering of files here.
2457 local (@coms);
2458 if (defined $dist_common{'README'})
2459 {
2460 push (@coms, 'README');
2461 delete $dist_common{'README'};
2462 }
2463 push (@coms, sort keys %dist_common);
2465 &define_pretty_variable ("DIST_COMMON", '', @coms);
2466 $output_vars .= "\n";
2468 # Some boilerplate.
2469 $output_vars .= &file_contents ('dist-vars') . "\n";
2470 &define_variable ('TAR', $TAR);
2471 &define_variable ('GZIP', '--best');
2473 # Put these things in rules section so it is easier for whoever
2474 # reads Makefile.in.
2475 if (! &variable_defined ('distdir'))
2476 {
2477 if ($relative_dir eq '.')
2478 {
2479 $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
2480 }
2481 else
2482 {
2483 $output_rules .= ("\n"
2484 . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
2485 . "\n");
2486 }
2487 }
2488 if ($relative_dir eq '.')
2489 {
2490 $output_rules .= "top_distdir = \$(distdir)\n\n";
2491 }
2492 else
2493 {
2494 $output_rules .= "\nsubdir = " . $relative_dir . "\n\n";
2495 }
2497 # Generate 'dist' target, and maybe dist-shar / dist-zip / dist-tarZ.
2498 if ($relative_dir eq '.')
2499 {
2500 # Rule to check whether a distribution is viable.
2501 $output_rules .= ('# This target untars the dist file and tries a VPATH configuration. Then
2502 # it guarantees that the distribution is self-contained by making another
2503 # tarfile.
2504 distcheck: dist
2505 rm -rf $(distdir)
2506 GZIP=$(GZIP) $(TAR) zxf $(distdir).tar.gz
2507 mkdir $(distdir)/=build
2508 mkdir $(distdir)/=inst
2509 dc_install_base=`cd $(distdir)/=inst && pwd`; \\'
2510 . (defined $contents{'distcheck-hook'}
2511 ? "\t\$(MAKE) distcheck-hook"
2512 : '')
2513 . '
2514 cd $(distdir)/=build \\
2515 && ../configure '
2517 . ($seen_gettext ? '--with-included-gettext ' : '')
2518 . '--srcdir=.. --prefix=$$dc_install_base \\
2519 && $(MAKE) \\
2520 && $(MAKE) dvi \\
2521 && $(MAKE) check \\
2522 && $(MAKE) install \\
2523 && $(MAKE) installcheck \\
2524 && $(MAKE) dist
2525 rm -rf $(distdir)
2526 @echo "========================"; \\
2527 echo "$(distdir).tar.gz is ready for distribution"; \\
2528 echo "========================"
2529 ');
2531 local ($dist_all) = ('dist-all: distdir' . "\n"
2532 . $dist_header);
2533 local ($curs);
2534 foreach $curs ('dist', 'dist-shar', 'dist-zip', 'dist-tarZ')
2535 {
2536 if (defined $options{$curs} || $curs eq 'dist')
2537 {
2538 $output_rules .= ($curs . ': distdir' . "\n"
2539 . $dist_header
2540 . $dist{$curs}
2541 . $dist_trailer);
2542 $dist_all .= $dist{$curs};
2543 }
2544 }
2545 $output_rules .= $dist_all . $dist_trailer;
2546 }
2548 # Generate distdir target.
2549 &handle_dist_worker ($makefile);
2550 }
2552 # Scan a single dependency file and rewrite the dependencies as
2553 # appropriate. Essentially this means:
2554 # * Clean out absolute dependencies which are not desirable.
2555 # * Rewrite other dependencies to be relative to $(top_srcdir).
2556 sub scan_dependency_file
2557 {
2558 local ($depfile) = @_;
2560 if (! open (DEP_FILE, $depfile))
2561 {
2562 &am_error ("couldn't open \`$depfile': $!");
2563 return;
2564 }
2565 print "automake: reading $depfile\n" if $verbose;
2567 # Sometimes it is necessary to omit some dependencies.
2568 local (%omit) = %omit_dependencies;
2569 if (&variable_defined ('OMIT_DEPENDENCIES'))
2570 {
2571 # FIXME: Doesn't work with conditionals. I'm not sure if this
2572 # matters.
2573 grep ($omit{$_} = 1,
2574 &variable_value_as_list ('OMIT_DEPENDENCIES', ''));
2575 }
2577 local ($first_line) = 1;
2578 local ($last_line) = 0;
2579 local ($target, @dependencies);
2580 local ($one_dep, $xform);
2581 local ($just_file);
2583 local ($srcdir_rx, $fixup_rx);
2584 ($fixup_rx = $srcdir_name . '/' . $relative_dir . '/')
2585 =~ s/(\W)/\\$1/g;
2586 ($srcdir_rx = $srcdir_name . '/') =~ s/(\W)/\\$1/g;
2588 local ($rewrite_builddir) = (($top_builddir eq '.')
2589 ? ''
2590 : $top_builddir . '/');
2592 while (<DEP_FILE>)
2593 {
2594 if ($last_line)
2595 {
2596 # If LAST_LINE set then we've already seen what we thought
2597 # was the last line.
2598 goto bad_format;
2599 }
2600 next if (/$WHITE_PATTERN/o);
2601 chop;
2602 if (! s/\\$//)
2603 {
2604 # No trailing "\" means this should be the last line.
2605 $last_line = 1;
2606 }
2608 if ($first_line)
2609 {
2610 if (! /^([^:]+:)(.+)$/)
2611 {
2612 bad_format:
2613 &am_error ("\`$depfile' has incorrect format");
2614 close (DEP_FILE);
2615 return;
2616 }
2618 $_ = $2;
2619 # Make sure to strip the .P file from the target.
2620 ($target = $1) =~ s, *\.deps/[^.]+\.P,,;
2622 $first_line = 0;
2623 }
2625 foreach $one_dep (split (' ', $_))
2626 {
2627 ($just_file = $one_dep) =~ s,^.*/,,;
2628 next if defined $omit{$just_file};
2630 if ($one_dep =~ /^$fixup_rx/)
2631 {
2632 # The dependency points to the current directory in
2633 # some way.
2634 ($xform = $one_dep) =~ s/^$fixup_rx//;
2635 push (@dependencies, $xform);
2636 }
2637 elsif ($one_dep =~ /^$srcdir_rx/)
2638 {
2639 # The dependency is in some other directory in the package.
2640 ($xform = $one_dep) =~ s/^$srcdir_rx/$rewrite_builddir/;
2641 push (@dependencies, $xform);
2642 }
2643 elsif ($one_dep =~ /^\//)
2644 {
2645 # Absolute path; ignore.
2646 }
2647 else
2648 {
2649 # Anything else is assumed to be correct.
2650 push (@dependencies, $one_dep);
2651 }
2652 }
2653 }
2655 &pretty_print_rule ($target, "\t", @dependencies);
2657 close (DEP_FILE);
2658 }
2660 # Handle auto-dependency code.
2661 sub handle_dependencies
2662 {
2663 # Make sure this variable is always marked as used.
2664 &examine_variable ('OMIT_DEPENDENCIES');
2666 if ($use_dependencies)
2667 {
2668 # Include GNU-make-specific auto-dep code. Don't include it
2669 # if DEP_FILES would be empty.
2670 if ($dir_holds_sources && keys %dep_files)
2671 {
2672 &define_pretty_variable ('DEP_FILES', '', sort keys %dep_files);
2673 $output_rules .= &file_contents ('depend');
2674 push (@clean, 'depend');
2675 &push_phony_cleaners ('depend');
2676 $output_rules .=
2677 &file_contents_with_transform ('s/\@EXT\@/.c/g;'
2678 . 's/\@MKDEP\@/MKDEP/g;'
2679 . 's/^ONLYC//g;',
2680 'depend2');
2681 local ($ext);
2682 local ($need_cxx) = 0;
2683 foreach $ext (sort keys %cxx_extensions)
2684 {
2685 $output_rules .=
2686 &file_contents_with_transform ('s/\@EXT\@/' . $ext .'/g;'
2687 . 's/\@MKDEP\@/CXXMKDEP/g;'
2688 . 's/^ONLYC.*$//;',
2689 'depend2');
2690 $need_cxx = 1;
2691 }
2692 if ($need_cxx)
2693 {
2694 &define_variable ('CXXMKDEP', '$(CXX) -M $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)');
2695 }
2696 }
2697 }
2698 elsif ($build_directory ne '')
2699 {
2700 # Include any auto-generated deps that are present. Note that
2701 # $build_directory ends in a "/".
2702 if (-d ($build_directory . $relative_dir . "/.deps")
2703 && -f ($build_directory . $relative_dir . "/.deps/.P"))
2704 {
2705 local ($depfile);
2707 foreach $depfile (&my_glob ($build_directory
2708 . $relative_dir . "/.deps/*.P"))
2709 {
2710 &scan_dependency_file ($depfile);
2711 }
2713 $output_rules .= "\n";
2714 }
2715 }
2716 }
2718 # Handle subdirectories.
2719 sub handle_subdirs
2720 {
2721 return if ! &variable_defined ('SUBDIRS');
2723 # Make sure each directory mentioned in SUBDIRS actually exists.
2724 local ($dir);
2725 foreach $dir (&variable_value_as_list ('SUBDIRS', 'all'))
2726 {
2727 # Skip directories substituted by configure.
2728 next if $dir =~ /^\@.*\@$/;
2730 if (! -d $am_relative_dir . '/' . $dir)
2731 {
2732 &am_line_error ('SUBDIRS',
2733 "required directory $am_relative_dir/$dir does not exist");
2734 next;
2735 }
2737 &am_line_error ('SUBDIRS', "directory should not contain \`/'")
2738 if $dir =~ /\//;
2739 }
2741 local ($xform) = ('s/\@INSTALLINFO\@/' .
2742 (defined $options{'no-installinfo'}
2743 ? 'install-info-recursive'
2744 : '')
2745 . '/;');
2746 $output_rules .= &file_contents_with_transform ($xform, 'subdirs');
2748 # Push a bunch of phony targets.
2749 local ($phonies);
2750 foreach $phonies ('-data', '-exec', 'dirs')
2751 {
2752 push (@phony, 'install' . $phonies . '-recursive');
2753 push (@phony, 'uninstall' . $phonies . '-recursive');
2754 }
2755 foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
2756 {
2757 push (@phony, $phonies . '-recursive');
2758 }
2759 &push_phony_cleaners ('recursive');
2761 push (@check_tests, "check-recursive");
2762 push (@installcheck, "installcheck-recursive");
2763 push (@info, "info-recursive");
2764 push (@dvi, "dvi-recursive");
2766 $recursive_install = 1;
2767 }
2769 # Handle aclocal.m4.
2770 sub handle_aclocal_m4
2771 {
2772 local ($regen_aclocal) = 0;
2773 if (-f 'aclocal.m4')
2774 {
2775 &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4');
2776 &push_dist_common ('aclocal.m4');
2778 if (open (ACLOCAL, '< aclocal.m4'))
2779 {
2780 local ($line);
2781 $line = <ACLOCAL>;
2782 close (ACLOCAL);
2784 if ($line =~ 'generated automatically by aclocal')
2785 {
2786 $regen_aclocal = 1;
2787 }
2788 }
2789 }
2791 local ($acinclude) = 0;
2792 if (-f 'acinclude.m4')
2793 {
2794 $regen_aclocal = 1;
2795 $acinclude = 1;
2796 }
2798 # Note that it might be possible that aclocal.m4 doesn't exist but
2799 # should be auto-generated. This case probably isn't very
2800 # important.
2801 if ($regen_aclocal)
2802 {
2803 local (@ac_deps) = (
2804 ($seen_maint_mode ? "\@MAINT\@" : "") ,
2805 "configure.in",
2806 ($acinclude ? ' acinclude.m4' : '')
2807 );
2809 # Scan all -I directories for m4 files. These are our
2810 # dependencies.
2811 if (&variable_defined ('ACLOCAL_AMFLAGS'))
2812 {
2813 local ($amdir);
2814 foreach $amdir (&variable_value_as_list ('ACLOCAL_AMFLAGS', ''))
2815 {
2816 if ($amdir =~ s/^-I//
2817 && $amdir !~ /^\//
2818 && -d $amdir)
2819 {
2820 push (@ac_deps, &my_glob ($am_dir . '/*.m4'));
2821 }
2822 }
2823 }
2825 &pretty_print_rule ("\$(ACLOCAL_M4):", "\t\t", @ac_deps);
2827 $output_rules .= ("\t"
2828 . 'cd $(srcdir) && $(ACLOCAL)'
2829 . (&variable_defined ('ACLOCAL_AMFLAGS')
2830 ? ' $(ACLOCAL_AMFLAGS)' : '')
2831 . "\n");
2832 }
2833 }
2835 # Rewrite a list of input files into a form suitable to put on a
2836 # dependency list. The idea is that if an input file has a directory
2837 # part the same as the current directory, then the directory part is
2838 # simply removed. But if the directory part is different, then
2839 # $(top_srcdir) is prepended. Among other things, this is used to
2840 # generate the dependency list for the output files generated by
2841 # AC_OUTPUT. Consider what the dependencies should look like in this
2842 # case:
2843 # AC_OUTPUT(src/out:src/in1:lib/in2)
2844 sub rewrite_inputs_into_dependencies
2845 {
2846 local (@inputs) = @_;
2847 local ($single, @newinputs);
2849 foreach $single (@inputs)
2850 {
2851 if (&dirname ($single) eq $relative_dir)
2852 {
2853 push (@newinputs, &basename ($single));
2854 }
2855 else
2856 {
2857 push (@newinputs, '$(top_srcdir)/' . $single);
2858 }
2859 }
2861 return @newinputs;
2862 }
2864 # Handle remaking and configure stuff.
2865 # We need the name of the input file, to do proper remaking rules.
2866 sub handle_configure
2867 {
2868 local ($local, $input, @secondary_inputs) = @_;
2870 # If SUBDIRS defined, require AC_PROG_MAKE_SET.
2871 &am_line_error ('SUBDIRS', "AC_PROG_MAKE_SET must be used in configure.in")
2872 if &variable_defined ('SUBDIRS') && ! $seen_make_set;
2874 local ($top_reldir);
2876 local ($input_base) = &basename ($input);
2877 local ($local_base) = &basename ($local);
2879 local ($amfile) = $input_base . '.am';
2880 # We know we can always add '.in' because it really should be an
2881 # error if the .in was missing originally.
2882 local ($infile) = '$(srcdir)/' . $input_base . '.in';
2883 local ($colon_infile);
2884 if ($local ne $input)
2885 {
2886 $colon_infile = ':' . $input . '.in';
2887 }
2888 $colon_infile .= ':' . join (':', @secondary_inputs)
2889 if @secondary_inputs;
2891 local (@rewritten) = &rewrite_inputs_into_dependencies (@secondary_inputs);
2892 # This rule remakes the Makefile.in. Note use of @MAINT@ forces
2893 # us to abandon pretty-printing. Sigh.
2894 $output_rules .= ($infile
2895 # NOTE perl 5.003 (with -w) gives a
2896 # uninitialized value error on the next line.
2897 # Don't know why.
2898 . ': '
2899 . ($seen_maint_mode ? '@MAINT@ ' : '')
2900 . $amfile . ' '
2901 . '$(top_srcdir)/configure.in $(ACLOCAL_M4) '
2902 . join (' ', @rewritten) . "\n"
2903 . "\tcd \$(top_srcdir) && \$(AUTOMAKE) "
2904 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
2905 . ($cmdline_use_dependencies ? '' : ' --include-deps')
2906 . ' ' . $input . $colon_infile . "\n\n");
2908 # This rule remakes the Makefile.
2909 $output_rules .= ($local_base
2910 # NOTE: bogus uninit value error on next line;
2911 # see comment above.
2912 . ': '
2913 . $infile . ' '
2914 . '$(top_builddir)/config.status'
2915 # NOTE: Makefile only depends on BUILT_SOURCES
2916 # when dependencies are being computed. This is
2917 # a workaround for an obscure bug with
2918 # AC_LINK_FILES. Anyway, when dependencies are
2919 # turned off, this shouldn't matter.
2920 . ($use_dependencies ? ' $(BUILT_SOURCES)' : '')
2921 . "\n"
2922 . "\tcd \$(top_builddir) \\\n"
2923 . "\t && CONFIG_FILES="
2924 . (($relative_dir eq '.') ? '$@' : '$(subdir)/$@')
2925 . $colon_infile
2926 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
2927 . "\n\n");
2929 if ($relative_dir ne '.')
2930 {
2931 # In subdirectory.
2932 $top_reldir = '../';
2933 }
2934 else
2935 {
2936 &handle_aclocal_m4;
2937 $output_rules .= &file_contents ('remake');
2938 &examine_variable ('CONFIGURE_DEPENDENCIES');
2939 $top_reldir = '';
2940 }
2942 # If we have a configure header, require it.
2943 local ($one_hdr);
2944 local (@local_fullnames) = @config_fullnames;
2945 local (@local_names) = @config_names;
2946 local ($hdr_index) = 0;
2947 local ($distclean_config) = '';
2948 foreach $one_hdr (@config_headers)
2949 {
2950 local ($one_fullname) = shift (@local_fullnames);
2951 local ($one_name) = shift (@local_names);
2952 $hdr_index += 1;
2953 if ($relative_dir eq &dirname ($one_hdr))
2954 {
2955 local ($ch_sans_dir) = &basename ($one_hdr);
2956 local ($cn_sans_dir) = &basename ($one_name);
2958 &require_file_with_conf_line ($config_header_line,
2959 $FOREIGN, $ch_sans_dir);
2961 # Header defined and in this directory.
2962 local (@files);
2963 if (-f $relative_dir . '/acconfig.h')
2964 {
2965 push (@files, 'acconfig.h');
2966 }
2967 if (-f $one_name . '.top')
2968 {
2969 push (@files, "${cn_sans_dir}.top");
2970 }
2971 if (-f $one_name . '.bot')
2972 {
2973 push (@files, "${cn_sans_dir}.bot");
2974 }
2976 &push_dist_common (@files);
2978 local ($stamp_name) = 'stamp-h';
2979 $stamp_name .= "${hdr_index}" if scalar (@config_headers) > 1;
2981 local ($xform) = '';
2983 $xform = 's,\@FILES\@,' . join (' ', @files) . ',;';
2984 $xform .= 's,\@CONFIG_HEADER\@,' . "${cn_sans_dir}" . ',;';
2985 $xform .= 's,\@CONFIG_HEADER_IN\@,' . "${ch_sans_dir}" . ',;';
2986 $xform .= 's,\@CONFIG_HEADER_FULL\@,' . "${one_fullname}" . ',;';
2987 $xform .= 's,\@STAMP\@,' . "${stamp_name}" . ',;';
2989 $output_rules .= &file_contents_with_transform ($xform,
2990 'remake-hdr');
2992 &touch ($relative_dir . "/${stamp_name}.in");
2993 &require_file_with_conf_line ($config_header_line, $FOREIGN,
2994 "${stamp_name}.in");
2996 $distclean_config .= ' ' if $distclean_config;
2997 $distclean_config .= $cn_sans_dir;
2998 }
2999 }
3001 if ($distclean_config)
3002 {
3003 $output_rules .= &file_contents_with_transform ('s,\@FILES\@,'
3004 . $distclean_config
3005 . ',;',
3006 'clean-hdr');
3007 push (@clean, 'hdr');
3008 &push_phony_cleaners ('hdr');
3009 }
3011 # Set location of mkinstalldirs.
3012 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
3013 {
3014 &define_variable ('mkinstalldirs', ('$(SHELL) ' . $config_aux_dir
3015 . '/mkinstalldirs'));
3016 }
3017 else
3018 {
3019 &define_variable ('mkinstalldirs',
3020 '$(SHELL) $(top_srcdir)/mkinstalldirs');
3021 }
3023 &am_line_error ('CONFIG_HEADER',
3024 "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
3025 if &variable_defined ('CONFIG_HEADER');
3027 local ($one_name);
3028 local ($config_header) = '';
3029 foreach $one_name (@config_names)
3030 {
3031 # Generate CONFIG_HEADER define.
3032 local ($one_hdr);
3033 if ($relative_dir eq &dirname ($one_name))
3034 {
3035 $one_hdr = &basename ($one_name);
3036 }
3037 else
3038 {
3039 $one_hdr = "${top_builddir}/${one_name}";
3040 }
3042 $config_header .= ' ' if $config_header;
3043 $config_header .= $one_hdr;
3044 }
3045 if ($config_header)
3046 {
3047 &define_variable ("CONFIG_HEADER", $config_header);
3048 }
3050 # Now look for other files in this directory which must be remade
3051 # by config.status, and generate rules for them.
3052 local (@actual_other_files) = ();
3053 local ($file, $local);
3054 local (@inputs, @rewritten_inputs, $single);
3055 local ($need_rewritten);
3056 foreach $file (@other_input_files)
3057 {
3058 if ($file =~ /^(.*):(.*)$/)
3059 {
3060 # This is the ":" syntax of AC_OUTPUT.
3061 $file = $1;
3062 $local = &basename ($file);
3063 @inputs = split (':', $2);
3064 @rewritten_inputs = &rewrite_inputs_into_dependencies (@inputs);
3065 $need_rewritten = 1;
3066 }
3067 else
3068 {
3069 # Normal usage.
3070 $local = &basename ($file);
3071 @inputs = ($local . '.in');
3072 @rewritten_inputs =
3073 &rewrite_inputs_into_dependencies ($file . '.in');
3074 $need_rewritten = 0;
3075 }
3077 # Skip files not in this directory.
3078 next unless &dirname ($file) eq $relative_dir;
3080 # Skip any file that is an automake input.
3081 next if -f $file . '.am';
3083 # Some users have been tempted to put `stamp-h' in the
3084 # AC_OUTPUT line. This won't do the right thing, so we
3085 # explicitly fail here.
3086 if ($local eq 'stamp-h')
3087 {
3088 # FIXME: allow real filename.
3089 &am_conf_error ('configure.in', $ac_output_line,
3090 'stamp-h should not appear in AC_OUTPUT');
3091 next;
3092 }
3094 $output_rules .= ($local . ': '
3095 . '$(top_builddir)/config.status '
3096 . join (' ', @rewritten_inputs) . "\n"
3097 . "\t"
3098 . 'cd $(top_builddir) && CONFIG_FILES='
3099 . ($relative_dir eq '.' ? '' : '$(subdir)/')
3100 . '$@' . ($need_rewritten
3101 ? (':' . join (':', @rewritten_inputs))
3102 : '')
3103 . ' CONFIG_HEADERS= ./config.status'
3104 . "\n");
3105 push (@actual_other_files, $local);
3107 # Require all input files.
3108 &require_file_with_conf_line ($ac_output_line, $FOREIGN,
3109 @inputs);
3110 }
3112 # These files get removed by "make clean".
3113 &define_pretty_variable ('CONFIG_CLEAN_FILES', '', @actual_other_files);
3114 }
3116 # Handle C headers.
3117 sub handle_headers
3118 {
3119 $dir_holds_headers = &am_install_var ('header', 'HEADERS', 'include',
3120 'oldinclude', 'pkginclude',
3121 'noinst', 'check');
3122 }
3124 sub handle_gettext
3125 {
3126 return if ! $seen_gettext || $relative_dir ne '.';
3128 if (! &variable_defined ('SUBDIRS'))
3129 {
3130 &am_conf_error
3131 ("AM_GNU_GETTEXT in configure.in but SUBDIRS not defined");
3132 return;
3133 }
3135 &require_file_with_conf_line ($ac_gettext_line, $FOREIGN, 'ABOUT-NLS')
3136 if $seen_gettext;
3138 if (&variable_defined ('SUBDIRS'))
3139 {
3140 &am_line_error
3141 ('SUBDIRS',
3142 "AM_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
3143 if $contents{'SUBDIRS'} !~ /\bpo\b/;
3144 &am_line_error
3145 ('SUBDIRS',
3146 "AM_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
3147 if $contents{'SUBDIRS'} !~ /\bintl\b/;
3148 }
3150 # Ensure that each language in ALL_LINGUAS has a .po file, and
3151 # each po file is mentioned in ALL_LINGUAS.
3152 if ($seen_linguas)
3153 {
3154 local (%linguas) = ();
3155 grep ($linguas{$_} = 1, split (' ', $all_linguas));
3157 foreach (<po/*.po>)
3158 {
3159 s/^po\///;
3160 s/\.po$//;
3162 &am_line_error ($all_linguas_line,
3163 ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
3164 if ! $linguas{$_};
3165 }
3167 foreach (keys %linguas)
3168 {
3169 &am_line_error ($all_linguas_line,
3170 "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
3171 if ! -f "po/$_.po";
3172 }
3173 }
3174 else
3175 {
3176 &am_error ("AM_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
3177 }
3178 }
3180 # Handle footer elements.
3181 sub handle_footer
3182 {
3183 if ($contents{'SOURCES'})
3184 {
3185 # NOTE don't use define_pretty_variable here, because
3186 # $contents{...} is already defined.
3187 $output_vars .= 'SOURCES = ' . $contents{'SOURCES'} . "\n";
3188 }
3189 if ($contents{'OBJECTS'})
3190 {
3191 # NOTE don't use define_pretty_variable here, because
3192 # $contents{...} is already defined.
3193 $output_vars .= 'OBJECTS = ' . $contents{'OBJECTS'} . "\n";
3194 }
3195 if ($contents{'SOURCES'} || $contents{'OBJECTS'})
3196 {
3197 $output_vars .= "\n";
3198 }
3200 if (&variable_defined ('SUFFIXES'))
3201 {
3202 # Push actual suffixes, and not $(SUFFIXES). Some versions of
3203 # make do not like variable substitutions on the .SUFFIXES
3204 # line.
3205 push (@suffixes, &variable_value_as_list ('SUFFIXES', ''));
3206 }
3207 if (&target_defined ('.SUFFIXES'))
3208 {
3209 &am_line_error ('.SUFFIXES',
3210 "use variable \`SUFFIXES', not target \`.SUFFIXES'");
3211 }
3213 # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
3214 # before .SUFFIXES. So we make sure that .SUFFIXES appears before
3215 # anything else, by sticking it right after the default: target.
3216 $output_header .= ".SUFFIXES:\n";
3217 if (@suffixes)
3218 {
3220 # Make sure suffixes has unique elements. Sort them to ensure
3221 # the output remains consistent.
3222 local (%suffixes);
3224 grep ($suffixes{$_} = 1, @suffixes);
3226 $output_header .= (".SUFFIXES: "
3227 . join (' ', sort keys %suffixes)
3228 . "\n");
3229 }
3230 $output_trailer .= &file_contents ('footer');
3231 }
3233 # Deal with installdirs target.
3234 sub handle_installdirs
3235 {
3236 # GNU Makefile standards recommend this.
3237 $output_rules .= ("installdirs:"
3238 . ($recursive_install
3239 ? " installdirs-recursive\n"
3240 : "\n"));
3241 push (@phony, 'installdirs');
3242 if (@installdirs)
3243 {
3244 &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
3245 @installdirs);
3246 }
3247 $output_rules .= "\n";
3248 }
3250 # There are several targets which need to be merged. This is because
3251 # their complete definition is compiled from many parts. Note that we
3252 # avoid double colon rules, otherwise we'd use them instead.
3253 sub handle_merge_targets
3254 {
3255 local ($makefile) = @_;
3257 # There are a few install-related variables that you should not define.
3258 local ($var);
3259 foreach $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
3260 {
3261 if (&variable_defined ($var))
3262 {
3263 &am_line_error ($var, "\`$var' should not be defined");
3264 }
3265 }
3267 # Put this at the beginning for the sake of non-GNU makes. This
3268 # is still wrong if these makes can run parallel jobs. But it is
3269 # right enough.
3270 unshift (@all, &basename ($makefile));
3272 local ($one_name);
3273 foreach $one_name (@config_names)
3274 {
3275 push (@all, &basename ($one_name))
3276 if &dirname ($one_name) eq $relative_dir;
3277 }
3279 &do_one_merge_target ('info', @info);
3280 &do_one_merge_target ('dvi', @dvi);
3281 &do_check_merge_target;
3282 &do_one_merge_target ('installcheck', @installcheck);
3284 if (defined $options{'no-installinfo'})
3285 {
3286 # FIXME: this is kind of a hack; should find another way to
3287 # know that this is required.
3288 local (@dirs);
3289 if (grep ($_ eq 'install-info-am', @phony))
3290 {
3291 push (@dirs, 'install-info-am');
3292 }
3293 if (&variable_defined ('SUBDIRS'))
3294 {
3295 push (@dirs, 'install-info-recursive');
3296 }
3297 &do_one_merge_target ('install-info', @dirs);
3298 }
3300 # Handle the various install targets specially. We do this so
3301 # that (eg) "make install-exec" will run "install-exec-recursive"
3302 # if required, but "make install" won't run it twice. Step one is
3303 # to see if the user specified local versions of any of the
3304 # targets we handle. "all" is treated as one of these since
3305 # "install" can run it.
3306 push (@install_exec, 'install-exec-local')
3307 if defined $contents{'install-exec-local'};
3308 push (@install_data, 'install-data-local')
3309 if defined $contents{'install-data-local'};
3310 push (@uninstall, 'uninstall-local')
3311 if defined $contents{'uninstall-local'};
3312 local ($utarg);
3313 foreach $utarg ('uninstall-data-local', 'uninstall-data-hook',
3314 'uninstall-exec-local', 'uninstall-exec-hook')
3315 {
3316 if (defined $contents{$utarg})
3317 {
3318 local ($x);
3319 ($x = $utarg) =~ s/(data|exec)-//;
3320 &am_line_error ($utarg, "use \`$x', not \`$utarg'");
3321 }
3322 }
3323 push (@all, 'all-local')
3324 if defined $contents{'all-local'};
3326 if (defined $contents{'install-local'})
3327 {
3328 &am_line_error ('install-local',
3329 "use \`install-data' or \`install-exec', not \`install'");
3330 }
3332 # Step two: if we are doing recursive makes, write out the
3333 # appropriate rules.
3334 local (@install);
3335 if ($recursive_install)
3336 {
3337 push (@install, 'install-recursive');
3339 if (@all)
3340 {
3341 local (@hackall) = ();
3342 local ($one_name);
3343 local ($local_headers) = '';
3344 foreach $one_name (@config_names)
3345 {
3346 if (&dirname ($one_name) eq $relative_dir)
3347 {
3348 $local_headers .= ' ' if $local_headers;
3349 $local_headers .= &basename ($one_name);
3350 }
3351 }
3352 if ($local_headers)
3353 {
3355 # This is kind of a hack, but I couldn't see a better
3356 # way to handle it. In this particular case, we need
3357 # to make sure config.h is built before we recurse.
3358 # We can't do this by changing the order of
3359 # dependencies to the "all" because that breaks when
3360 # using parallel makes. Instead we handle things
3361 # explicitly.
3362 $output_rules .= ("all-recursive-am: ${local_headers}"
3363 . "\n\t" . '$(MAKE) all-recursive'
3364 . "\n\n");
3365 push (@hackall, 'all-recursive-am');
3366 push (@phony, 'all-recursive-am');
3367 }
3368 else
3369 {
3370 push (@hackall, 'all-recursive');
3371 }
3373 $output_rules .= ('all-am: '
3374 . join (' ', @all)
3375 . "\n\n");
3376 @all = @hackall;
3377 push (@all, 'all-am');
3378 push (@phony, 'all-am');
3379 }
3380 else
3381 {
3382 @all = ('all-recursive');
3384 # Must always generate `all-am' target, so it can be
3385 # referred to elsewhere.
3386 $output_rules .= "all-am:\n";
3387 }
3388 if (@install_exec)
3389 {
3390 $output_rules .= ('install-exec-am: '
3391 . join (' ', @install_exec)
3392 . "\n\n");
3393 @install_exec = ('install-exec-recursive', 'install-exec-am');
3394 push (@install, 'install-exec-am');
3395 push (@phony, 'install-exec-am');
3396 }
3397 else
3398 {
3399 @install_exec = ('install-exec-recursive');
3400 }
3401 if (@install_data)
3402 {
3403 $output_rules .= ('install-data-am: '
3404 . join (' ', @install_data)
3405 . "\n\n");
3406 @install_data = ('install-data-recursive', 'install-data-am');
3407 push (@install, 'install-data-am');
3408 push (@phony, 'install-data-am');
3409 }
3410 else
3411 {
3412 @install_data = ('install-data-recursive');
3413 }
3414 if (@uninstall)
3415 {
3416 $output_rules .= ('uninstall-am: '
3417 . join (' ', @uninstall)
3418 . "\n\n");
3419 @uninstall = ('uninstall-recursive', 'uninstall-am');
3420 push (@phony, 'uninstall-am');
3421 }
3422 else
3423 {
3424 @uninstall = ('uninstall-recursive');
3425 }
3426 }
3428 # Step three: print definitions users can use. Code below knows
3429 # that install-exec is done before install-data, beware.
3430 $output_rules .= ("install-exec: "
3431 . join (' ', @install_exec)
3432 . "\n");
3433 $output_rules .= "\t\@\$(NORMAL_INSTALL)\n";
3434 if (defined $contents{'install-exec-hook'})
3435 {
3436 $output_rules .= "\t" . '$(MAKE) install-exec-hook' . "\n";
3437 }
3438 $output_rules .= "\n";
3439 push (@install, 'install-exec') if !$recursive_install;
3440 push (@phony, 'install-exec');
3442 $output_rules .= ("install-data: "
3443 . join (' ', @install_data)
3444 . "\n");
3445 $output_rules .= "\t\@\$(NORMAL_INSTALL)\n";
3446 if (defined $contents{'install-data-hook'})
3447 {
3448 $output_rules .= "\t" . '$(MAKE) install-data-hook' . "\n";
3449 }
3450 $output_rules .= "\n";
3451 push (@install, 'install-data') if !$recursive_install;
3452 push (@phony, 'install-data');
3454 # If no dependencies for 'install', add 'all'. Why? That way
3455 # "make install" at top level of distclean'd distribution won't
3456 # fail because stuff in 'lib' fails to build.
3457 if (! @install || (scalar (@install) == 2
3458 && $install[0] eq 'install-exec'
3459 && $install[1] eq 'install-data'))
3460 {
3461 push (@install, 'all');
3462 }
3463 $output_rules .= ('install: '
3464 . join (' ', @install)
3465 # Use "@:" as empty command so nothing prints.
3466 . "\n\t\@:"
3467 . "\n\n"
3468 . 'uninstall: '
3469 . join (' ', @uninstall)
3470 . "\n\n");
3471 push (@phony, 'install', 'uninstall');
3473 $output_rules .= ('all: '
3474 . join (' ', @all)
3475 . "\n\n");
3476 push (@phony, 'all');
3478 # Generate the new 'install-strip' target. Must set
3479 # INSTALL_SCRIPT to avoid stripping scripts.
3480 $output_rules .= ("install-strip:\n\t"
3481 . '$(MAKE) INSTALL_PROGRAM=\'$(INSTALL_PROGRAM) -s\' INSTALL_SCRIPT=\'$(INSTALL_PROGRAM)\' install'
3482 . "\n");
3483 }
3485 # Helper for handle_merge_targets.
3486 sub do_one_merge_target
3487 {
3488 local ($name, @values) = @_;
3490 if (defined $contents{$name . '-local'})
3491 {
3492 # User defined local form of target. So include it.
3493 push (@values, $name . '-local');
3494 push (@phony, $name . '-local');
3495 }
3497 &pretty_print_rule ($name . ":", "\t\t", @values);
3498 push (@phony, $name);
3499 }
3501 # Handle check merge target specially.
3502 sub do_check_merge_target
3503 {
3504 if (defined $contents{'check-local'})
3505 {
3506 # User defined local form of target. So include it.
3507 push (@check_tests, 'check-local');
3508 push (@phony, 'check-local');
3509 }
3511 # In --cygnus mode, check doesn't depend on all.
3512 if (! $cygnus_mode)
3513 {
3514 if (! &variable_defined ('SUBDIRS'))
3515 {
3516 # 'check' must depend on `all', but not when doing
3517 # recursive build.
3518 unshift (@check, 'all');
3519 }
3520 else
3521 {
3522 # When subdirs are used, do the `all' build and then do
3523 # all the recursive stuff. Actually use `all-am' because
3524 # it doesn't recurse; we rely on the check target in the
3525 # subdirs to do the required builds there.
3526 unshift (@check, 'all-am');
3527 }
3528 }
3530 # The check target must depend on the local equivalent of `all',
3531 # to ensure all the primary targets are built. Also it must
3532 # depend on the test code named in @check.
3533 &pretty_print_rule ('check:', "\t\t", @check);
3535 # Now the check rules must explicitly run anything named in
3536 # @check_tests. This is done via a separate make invocation to
3537 # avoid problems with parallel makes. Every time I write code
3538 # like this I wonder: how could you invent a parallel make and not
3539 # provide any real synchronization facilities?
3540 &pretty_print_rule ("\t\$(MAKE)", "\t ", @check_tests);
3541 }
3543 # Handle all 'clean' targets.
3544 sub handle_clean
3545 {
3546 push (@clean, 'generic');
3547 $output_rules .= &file_contents ('clean');
3548 &push_phony_cleaners ('generic');
3550 local ($target) = $recursive_install ? 'clean-am' : 'clean';
3551 &do_one_clean_target ($target, 'mostly', '', @clean);
3552 &do_one_clean_target ($target, '', 'mostly', @clean);
3553 &do_one_clean_target ($target, 'dist', '', @clean);
3554 &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
3556 push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
3558 local (@deps);
3559 if ($recursive_install)
3560 {
3561 # Do -recursive before -am. If you aren't doing a parallel
3562 # make, this can be nicer.
3563 @deps = ('recursive', 'am');
3564 &do_one_clean_target ('', 'mostly', '', @deps);
3565 &do_one_clean_target ('', '', '', @deps);
3566 &do_one_clean_target ('', 'dist', '', @deps);
3567 &do_one_clean_target ('', 'maintainer-', '', @deps);
3568 }
3569 }
3571 # Helper for handle_clean.
3572 sub do_one_clean_target
3573 {
3574 local ($target, $name, $last_name, @deps) = @_;
3576 # Special case: if target not passed, then don't generate
3577 # dependency on next "lower" clean target (eg no
3578 # clean<-mostlyclean derivation). In this case the target is
3579 # implicitly known to be 'clean'.
3580 local ($flag) = $target;
3581 $target = 'clean' if ! $flag;
3583 grep (($_ = $name . 'clean-' . $_) && 0, @deps);
3584 if ($flag)
3585 {
3586 if ($last_name || $name ne 'mostly')
3587 {
3588 push (@deps, $last_name . $target);
3589 }
3590 }
3592 # If a -local version of the rule is given, add it to the list.
3593 if (defined $contents{$name . $target . '-local'})
3594 {
3595 push (@deps, $name . $target . '-local');
3596 }
3598 # Print the target and the dependencies.
3599 &pretty_print_rule ($name . $target . ": ", "\t\t", @deps);
3601 # FIXME: shouldn't we really print these messages before running
3602 # the dependencies?
3603 if ($name . $target eq 'maintainer-clean')
3604 {
3605 # Print a special warning.
3606 $output_rules .=
3607 ("\t\@echo \"This command is intended for maintainers to use;\"\n"
3608 . "\t\@echo \"it deletes files that may require special "
3609 . "tools to rebuild.\"\n");
3611 $output_rules .= "\trm -f config.status\n"
3612 if $relative_dir eq '.';
3613 }
3614 elsif ($name . $target eq 'distclean')
3615 {
3616 $output_rules .= "\trm -f config.status\n";
3617 $output_rules .= "\trm -f libtool\n" if $seen_libtool;
3618 }
3619 $output_rules .= "\n";
3620 }
3622 # Handle .PHONY target.
3623 sub handle_phony
3624 {
3625 &pretty_print_rule ('.PHONY:', "", @phony);
3626 $output_rules .= "\n";
3627 }
3629 # Handle TESTS variable and other checks.
3630 sub handle_tests
3631 {
3632 if (defined $options{'dejagnu'})
3633 {
3634 push (@check_tests, 'check-DEJAGNU');
3635 push (@phony, 'check-DEJAGNU');
3637 local ($xform);
3638 if ($cygnus_mode)
3639 {
3640 $xform = 's/^CYGNUS//;';
3641 }
3642 else
3643 {
3644 $xform = 's/^CYGNUS.*$//;';
3645 }
3646 $output_rules .= &file_contents_with_transform ($xform, 'dejagnu');
3648 # In Cygnus mode, these are found in the build tree.
3649 # Otherwise they are looked for in $PATH.
3650 &define_program_variable ('EXPECT', 'build', 'expect', 'expect');
3651 &define_program_variable ('RUNTEST', 'src', 'dejagnu', 'runtest');
3653 # Note that in the rule we don't directly generate site.exp to
3654 # avoid the possibility of a corrupted site.exp if make is
3655 # interrupted. Jim Meyering has some useful text on this
3656 # topic.
3657 $output_rules .= ("site.exp: Makefile\n"
3658 . "\t\@echo 'Making a new site.exp file...'\n"
3659 . "\t-\@rm -f site.bak\n"
3660 . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
3661 . "\t\@echo '# Do not edit here. If you wish to override these values' >> \$\@-t\n"
3662 . "\t\@echo '# edit the last section' >> \$\@-t\n"
3663 . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
3664 . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
3665 . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
3667 # Extra stuff for AC_CANONICAL_*
3668 local (@whatlist) = ();
3669 if ($seen_canonical)
3670 {
3671 push (@whatlist, 'host')
3672 }
3674 # Extra stuff only for AC_CANONICAL_SYSTEM.
3675 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
3676 {
3677 push (@whatlist, 'target', 'build');
3678 }
3680 local ($c1, $c2);
3681 foreach $c1 (@whatlist)
3682 {
3683 foreach $c2 ('alias', 'triplet')
3684 {
3685 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
3686 }
3687 }
3689 $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
3690 . "\t-\@sed '1,/^## All variables above are.*##/ d' site.bak >> \$\@-t\n"
3691 . "\t-\@mv site.exp site.bak\n"
3692 . "\t\@mv \$\@-t site.exp\n");
3693 }
3694 else
3695 {
3696 local ($c);
3697 foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
3698 {
3699 if (&variable_defined ($c))
3700 {
3701 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
3702 }
3703 }
3704 }
3706 if (&variable_defined ('TESTS'))
3707 {
3708 push (@check_tests, 'check-TESTS');
3709 push (@phony, 'check-TESTS');
3711 $output_rules .= 'check-TESTS: $(TESTS)
3712 @failed=0; all=0; \\
3713 srcdir=$(srcdir); export srcdir; \\
3714 for tst in $(TESTS); do \\
3715 if test -f $$tst; then dir=.; \\
3716 else dir="$(srcdir)"; fi; \\
3717 if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \\
3718 all=`expr $$all + 1`; \\
3719 echo "PASS: $$tst"; \\
3720 elif test $$? -ne 77; then \\
3721 all=`expr $$all + 1`; \\
3722 failed=`expr $$failed + 1`; \\
3723 echo "FAIL: $$tst"; \\
3724 fi; \\
3725 done; \\
3726 if test "$$failed" -eq 0; then \\
3727 banner="All $$all tests passed"; \\
3728 else \\
3729 banner="$$failed of $$all tests failed"; \\
3730 fi; \\
3731 dashes=`echo "$$banner" | sed s/./=/g`; \\
3732 echo "$$dashes"; \\
3733 echo "$$banner"; \\
3734 echo "$$dashes"; \\
3735 test "$$failed" -eq 0
3736 ';
3737 }
3738 }
3740 # Handle Emacs Lisp.
3741 sub handle_emacs_lisp
3742 {
3743 local (@elfiles) = &am_install_var ('lisp', 'LISP', 'lisp', 'noinst');
3745 if (@elfiles)
3746 {
3747 # Found some lisp.
3748 &define_configure_variable ('lispdir');
3749 &define_configure_variable ('EMACS');
3750 $output_rules .= (".el.elc:\n"
3751 . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
3752 . "\tif test \$(EMACS) != no; then \\\n"
3753 . "\t EMACS=\$(EMACS) \$(SHELL) \$(srcdir)/elisp-comp \$<; \\\n"
3754 . "\tfi\n");
3755 push (@suffixes, '.el', '.elc');
3757 # Generate .elc files.
3758 grep ($_ .= 'c', @elfiles);
3759 &define_pretty_variable ('ELCFILES', '', @elfiles);
3761 $output_rules .= &file_contents ('lisp-clean');
3762 push (@clean, 'lisp');
3763 &push_phony_cleaners ('lisp');
3765 push (@all, '$(ELCFILES)');
3767 local ($varname);
3768 if (&variable_defined ('lisp_LISP'))
3769 {
3770 $varname = 'lisp_LISP';
3771 &am_error ("\`lisp_LISP' defined but \`AM_PATH_LISPDIR' not in \`configure.in'")
3772 if ! $seen_lispdir;
3773 }
3774 else
3775 {
3776 $varname = 'noinst_LISP';
3777 }
3779 &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
3780 }
3781 }
3783 ################################################################
3785 # Scan one file for interesting things. Subroutine of scan_configure.
3786 sub scan_one_configure_file
3787 {
3788 local ($filename) = @_;
3790 open (CONFIGURE, $filename)
3791 || die "automake: couldn't open \`$filename': $!\n";
3792 print "automake: reading $filename\n" if $verbose;
3794 while (<CONFIGURE>)
3795 {
3796 # Remove comments from current line.
3797 s/\bdnl\b.*$//;
3798 s/\#.*$//;
3800 # Skip macro definitions. Otherwise we might be confused into
3801 # thinking that a macro that was only defined was actually
3802 # used.
3803 next if /AC_DEFUN/;
3805 # Populate libobjs array.
3806 if (/AC_FUNC_ALLOCA/)
3807 {
3808 $libsources{'alloca.c'} = 1;
3809 }
3810 elsif (/AC_FUNC_GETLOADAVG/)
3811 {
3812 $libsources{'getloadavg.c'} = 1;
3813 }
3814 elsif (/AC_FUNC_MEMCMP/)
3815 {
3816 $libsources{'memcmp.c'} = 1;
3817 }
3818 elsif (/AC_STRUCT_ST_BLOCKS/)
3819 {
3820 $libsources{'fileblocks.c'} = 1;
3821 }
3822 elsif (/A[CM]_REPLACE_GNU_GETOPT/)
3823 {
3824 $libsources{'getopt.c'} = 1;
3825 $libsources{'getopt1.c'} = 1;
3826 }
3827 elsif (/AM_FUNC_STRTOD/)
3828 {
3829 $libsources{'strtod.c'} = 1;
3830 }
3831 elsif (/AM_WITH_REGEX/)
3832 {
3833 $libsources{'rx.c'} = 1;
3834 $libsources{'rx.h'} = 1;
3835 $libsources{'regex.c'} = 1;
3836 $libsources{'regex.h'} = 1;
3837 $omit_dependencies{'rx.h'} = 1;
3838 $omit_dependencies{'regex.h'} = 1;
3839 }
3840 elsif (/AM_FUNC_MKTIME/)
3841 {
3842 $libsources{'mktime.c'} = 1;
3843 }
3844 elsif (/AM_FUNC_ERROR_AT_LINE/)
3845 {
3846 $libsources{'error.c'} = 1;
3847 $libsources{'error.h'} = 1;
3848 }
3849 elsif (/AM_FUNC_OBSTACK/)
3850 {
3851 $libsources{'obstack.c'} = 1;
3852 $libsources{'obstack.h'} = 1;
3853 }
3854 elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
3855 || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
3856 {
3857 foreach $libobj_iter (split (' ', $1))
3858 {
3859 if ($libobj_iter =~ /^(.*)\.o$/)
3860 {
3861 $libsources{$1 . '.c'} = 1;
3862 }
3863 }
3864 }
3866 if (! $in_ac_replace && s/AC_REPLACE_FUNCS\s*\(\[?//)
3867 {
3868 $in_ac_replace = 1;
3869 }
3870 if ($in_ac_replace)
3871 {
3872 $in_ac_replace = 0 if s/[\]\)].*$//;
3873 # Remove trailing backslash.
3874 s/\\$//;
3875 foreach (split)
3876 {
3877 # Need to skip empty elements for Perl 4.
3878 next if $_ eq '';
3879 $libsources{$_ . '.c'} = 1;
3880 }
3881 }
3883 if (/$obsolete_rx/o)
3884 {
3885 local ($hint) = '';
3886 if ($obsolete_macros{$1})
3887 {
3888 $hint = '; ' . $obsolete_macros{$1};
3889 }
3890 &am_conf_line_error ($filename, $., "\`$1' is obsolete$hint");
3891 }
3893 # Process the AC_OUTPUT macro.
3894 if (! $in_ac_output && s/AC_OUTPUT\s*\(\[?//)
3895 {
3896 $in_ac_output = 1;
3897 $ac_output_line = $.;
3898 }
3899 if ($in_ac_output)
3900 {
3901 $in_ac_output = 0 if s/[\]\),].*$//;
3903 # Look at potential Makefile.am's.
3904 foreach (split)
3905 {
3906 next if $_ eq "\\";
3908 # Handle $local:$input syntax. Note that we ignore
3909 # every input file past the first, though we keep
3910 # those around for later.
3911 local ($local, $input, @rest) = split (/:/);
3912 if (! $input)
3913 {
3914 $input = $local;
3915 }
3916 else
3917 {
3918 # FIXME: should be error if .in is missing.
3919 $input =~ s/\.in$//;
3920 }
3922 if (-f $input . '.am')
3923 {
3924 # We have a file that automake should generate.
3925 push (@make_input_list, $input);
3926 $make_list{$input} = join (':', ($local, @rest));
3927 }
3928 else
3929 {
3930 # We have a file that automake should cause to be
3931 # rebuilt, but shouldn't generate itself.
3932 push (@other_input_files, $_);
3933 }
3934 }
3935 }
3937 if (/$AC_CONFIG_AUX_DIR_PATTERN/o)
3938 {
3939 @config_aux_path = $1;
3940 }
3942 # Check for ansi2knr.
3943 $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
3945 # Check for exe extension stuff.
3946 if (/AM_EXEEXT/)
3947 {
3948 $seen_exeext = 1;
3949 $configure_vars{'EXEEXT'} = 1;
3950 }
3952 # Check for NLS support.
3953 if (/AM_GNU_GETTEXT/)
3954 {
3955 $seen_gettext = 1;
3956 $ac_gettext_line = $.;
3957 $omit_dependencies{'libintl.h'} = 1;
3958 }
3960 # Look for ALL_LINGUAS.
3961 if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
3962 {
3963 $seen_linguas = 1;
3964 $all_linguas = $1;
3965 $all_linguas_line = $.;
3966 }
3968 # Handle configuration headers. A config header of `[$1]'
3969 # means we are actually scanning AM_CONFIG_HEADER from
3970 # aclocal.m4.
3971 if (/A([CM])_CONFIG_HEADER\s*\((.*)\)/
3972 && $2 ne '[$1]')
3973 {
3974 &am_conf_line_error
3975 ($filename, $.,
3976 "\`AC_CONFIG_HEADER' is obsolete; use \`AM_CONFIG_HEADER'")
3977 if $1 eq 'C';
3979 $config_header_line = $.;
3980 local ($one_hdr);
3981 foreach $one_hdr (split (' ', $2))
3982 {
3983 push (@config_fullnames, $one_hdr);
3984 if ($one_hdr =~ /^([^:]+):(.+)$/)
3985 {
3986 push (@config_names, $1);
3987 push (@config_headers, $2);
3988 }
3989 else
3990 {
3991 push (@config_names, $one_hdr);
3992 push (@config_headers, $one_hdr . '.in');
3993 }
3994 }
3995 }
3997 # Handle AC_CANONICAL_*. Always allow upgrading to
3998 # AC_CANONICAL_SYSTEM, but never downgrading.
3999 $seen_canonical = $AC_CANONICAL_HOST
4000 if ! $seen_canonical
4001 && (/AC_CANONICAL_HOST/ || /AC_CHECK_TOOL/);
4002 $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
4004 $seen_path_xtra = 1 if /AC_PATH_XTRA/;
4006 # This macro handles several different things.
4007 if (/$AM_INIT_AUTOMAKE_PATTERN/o)
4008 {
4009 $seen_make_set = 1;
4010 $seen_package = 1;
4011 $seen_version = 1;
4012 $seen_arg_prog = 1;
4013 $seen_prog_install = 2;
4014 ($package_version = $1) =~ s/$AM_PACKAGE_VERSION_PATTERN/$1/o;
4015 $package_version_line = $.;
4016 }
4018 # This is like AM_INIT_AUTOMAKE, but doesn't actually set the
4019 # package and version number. (This might change in the
4020 # future). Yes, I'm not above hacking Automake so it works
4021 # well with other GNU tools -- that is actually the point.
4022 if (/AM_INIT_GUILE_MODULE/)
4023 {
4024 $seen_make_set = 1;
4025 $seen_package = 1;
4026 $seen_version = 1;
4027 $seen_arg_prog = 1;
4028 $seen_prog_install = 2;
4029 @config_aux_path = ('..');
4030 }
4032 # Some things required by Automake.
4033 $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
4034 $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
4036 if (/AC_PROG_(YACC|RANLIB|CC|CXX|LEX|AWK|CPP|CXXCPP|LN_S)/)
4037 {
4038 $configure_vars{$1} = 1;
4039 }
4040 if (/$AC_CHECK_PATTERN/o)
4041 {
4042 $configure_vars{$3} = 1;
4043 }
4044 if (/$AM_MISSING_PATTERN/o
4045 && $1 ne 'ACLOCAL'
4046 && $1 ne 'AUTOCONF'
4047 && $1 ne 'AUTOMAKE'
4048 && $1 ne 'AUTOHEADER')
4049 {
4050 $configure_vars{$1} = 1;
4051 }
4053 # Explicitly avoid ANSI2KNR -- we AC_SUBST that in protos.m4,
4054 # but later define it elsewhere. This is pretty hacky. We
4055 # also explicitly avoid INSTALL_SCRIPT and some other
4056 # variables because they are defined in header-vars.am.
4057 # FIXME.
4058 if (/$AC_SUBST_PATTERN/o
4059 && $1 ne 'ANSI2KNR'
4060 && $1 ne 'INSTALL_SCRIPT')
4061 {
4062 $configure_vars{$1} = 1;
4063 }
4065 $seen_decl_yytext = 1 if /AC_DECL_YYTEXT/;
4066 $seen_maint_mode = 1 if /AM_MAINTAINER_MODE/;
4067 $seen_package = 1 if /PACKAGE=/;
4069 # Skip VERSION of [$2]; that is from AM_INIT_AUTOMAKE.
4070 if (/\bVERSION=(\S+)/ && $1 ne '[$2]')
4071 {
4072 $seen_version = 1;
4073 $package_version = $1;
4074 $package_version_line = $.;
4075 }
4076 elsif (/VERSION=/)
4077 {
4078 $seen_version = 1;
4079 }
4081 # Weird conditionals here because it is always allowed to
4082 # upgrade to AM_PROG_INSTALL but never to downgrade to
4083 # AC_PROG_INSTALL.
4084 $seen_prog_install = 1 if ! $seen_prog_install && /AC_PROG_INSTALL/;
4085 $seen_prog_install = 2 if /AM_PROG_INSTALL/;
4087 $seen_lispdir = 1 if /AM_PATH_LISPDIR/;
4089 if (/AM_PROG_LIBTOOL/)
4090 {
4091 $seen_libtool = 1;
4092 $libtool_line = $.;
4093 $configure_vars{'LIBTOOL'} = 1;
4094 $configure_vars{'RANLIB'} = 1;
4095 $configure_vars{'CC'} = 1;
4096 # AM_PROG_LIBTOOL runs AC_CANONICAL_HOST. Make sure we
4097 # never downgrade (if we've seen AC_CANONICAL_SYSTEM).
4098 $seen_canonical = $AC_CANONICAL_HOST if ! $seen_canonical;
4099 }
4101 if (/$AM_CONDITIONAL_PATTERN/o)
4102 {
4103 $configure_cond{$1} = 1;
4104 }
4105 }
4107 close (CONFIGURE);
4108 }
4110 # Scan configure.in and aclocal.m4 for interesting things. We must
4111 # scan aclocal.m4 because there might be AC_SUBSTs and such there.
4112 sub scan_configure
4113 {
4114 # Reinitialize libsources here. This isn't really necessary,
4115 # since we currently assume there is only one configure.in. But
4116 # that won't always be the case.
4117 %libsources = ();
4119 local ($in_ac_output, $in_ac_replace) = (0, 0);
4120 local (%make_list, @make_input_list);
4121 local ($libobj_iter);
4123 &scan_one_configure_file ('configure.in');
4124 &scan_one_configure_file ('aclocal.m4')
4125 if -f 'aclocal.m4';
4127 # Set input and output files if not specified by user.
4128 if (! @input_files)
4129 {
4130 @input_files = @make_input_list;
4131 %output_files = %make_list;
4132 }
4134 &am_conf_error ("\`PACKAGE' not defined in configure.in")
4135 if ! $seen_package;
4136 &am_conf_error ("\`VERSION' not defined in configure.in")
4137 if ! $seen_version;
4139 # Look for some files we need. Always check for these. This
4140 # check must be done for every run, even those where we are only
4141 # looking at a subdir Makefile. We must set relative_dir so that
4142 # the file-finding machinery works.
4143 local ($relative_dir) = '.';
4144 &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs', 'missing');
4145 &am_error ("\`install.sh' is an anachronism; use \`install-sh' instead")
4146 if -f $config_aux_path[0] . '/install.sh';
4147 }
4149 ################################################################
4151 # Set up for Cygnus mode.
4152 sub check_cygnus
4153 {
4154 return unless $cygnus_mode;
4156 &set_strictness ('foreign');
4157 $options{'no-installinfo'} = 1;
4158 $options{'no-dependencies'} = 1;
4159 $use_dependencies = 0;
4161 if (! $seen_maint_mode)
4162 {
4163 &am_conf_error ("\`AM_MAINTAINER_MODE' required when --cygnus specified");
4164 }
4166 if (! $seen_exeext)
4167 {
4168 &am_conf_error ("\`AM_EXEEXT' required when --cygnus specified");
4169 }
4170 }
4172 # Do any extra checking for GNU standards.
4173 sub check_gnu_standards
4174 {
4175 if ($relative_dir eq '.')
4176 {
4177 # In top level (or only) directory.
4178 &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
4179 'AUTHORS', 'ChangeLog');
4180 }
4182 if ($strictness >= $GNU)
4183 {
4184 if (defined $options{'no-installman'})
4185 {
4186 &am_line_error ('AUTOMAKE_OPTIONS',
4187 "option \`no-installman' disallowed by GNU standards");
4188 }
4190 if (defined $options{'no-installinfo'})
4191 {
4192 &am_line_error ('AUTOMAKE_OPTIONS',
4193 "option \`no-installinfo' disallowed by GNU standards");
4194 }
4195 }
4196 }
4198 # Do any extra checking for GNITS standards.
4199 sub check_gnits_standards
4200 {
4201 if ($strictness >= $GNITS)
4202 {
4203 if (-f $relative_dir . '/COPYING.LIB')
4204 {
4205 &am_error ("\`${relative_dir}/COPYING.LIB' disallowed by Gnits standards");
4206 }
4208 if ($relative_dir eq '.')
4209 {
4210 if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
4211 {
4212 # FIXME: allow real filename.
4213 &am_conf_line_error ('configure.in',
4214 $package_version_line,
4215 "version \`$package_version' doesn't follow Gnits standards");
4216 }
4217 elsif (defined $1 && -f 'README-alpha')
4218 {
4219 # This means we have an alpha release. See
4220 # GNITS_VERSION_PATTERN for details.
4221 &require_file ($GNITS, 'README-alpha');
4222 }
4223 }
4224 }
4226 if ($relative_dir eq '.')
4227 {
4228 # In top level (or only) directory.
4229 &require_file ($GNITS, 'THANKS');
4230 }
4231 }
4233 ################################################################
4235 # Pretty-print something. HEAD is what should be printed at the
4236 # beginning of the first line, FILL is what should be printed at the
4237 # beginning of every subsequent line.
4238 sub pretty_print_internal
4239 {
4240 local ($head, $fill, @values) = @_;
4242 local ($column) = length ($head);
4243 local ($result) = $head;
4245 # Fill length is number of characters. However, each Tab
4246 # character counts for eight. So we count the number of Tabs and
4247 # multiply by 7.
4248 local ($fill_length) = length ($fill);
4249 $fill_length += 7 * ($fill =~ tr/\t/\t/d);
4251 local ($bol) = ($head eq '');
4252 foreach (@values)
4253 {
4254 # "71" because we also print a space.
4255 if ($column + length ($_) > 71)
4256 {
4257 $result .= " \\\n" . $fill;
4258 $column = $fill_length;
4259 $bol = 1;
4260 }
4262 $result .= ' ' unless ($bol);
4263 $result .= $_;
4264 $column += length ($_) + 1;
4265 $bol = 0;
4266 }
4268 $result .= "\n";
4269 return $result;
4270 }
4272 # Pretty-print something and append to output_vars.
4273 sub pretty_print
4274 {
4275 $output_vars .= &pretty_print_internal (@_);
4276 }
4278 # Pretty-print something and append to output_rules.
4279 sub pretty_print_rule
4280 {
4281 $output_rules .= &pretty_print_internal (@_);
4282 }
4285 ################################################################
4287 # See if a target exists.
4288 sub target_defined
4289 {
4290 local ($target) = @_;
4291 return defined $targets{$target};
4292 }
4294 # See if two conditionals are the same.
4295 sub conditional_same
4296 {
4297 local ($cond1, $cond2) = @_;
4299 return (&conditional_true_when ($cond1, $cond2)
4300 && &conditional_true_when ($cond2, $cond1));
4301 }
4303 # See if a conditional is true. Both arguments are conditional
4304 # strings. This returns true if the first conditional is true when
4305 # the second conditional is true.
4306 sub conditional_true_when
4307 {
4308 local ($cond, $when) = @_;
4310 # Check the easy case first.
4311 if ($cond eq $when)
4312 {
4313 return 1;
4314 }
4316 # Check each component of $cond, which looks @COND1@@COND2@.
4317 foreach $comp (split ('@', $cond))
4318 {
4319 # The way we split will give null strings between each
4320 # condition.
4321 next if ! $comp;
4323 if (index ($when, '@' . $comp . '@') == -1)
4324 {
4325 return 0;
4326 }
4327 }
4329 return 1;
4330 }
4332 # Check for an ambiguous conditional. This is called when a variable
4333 # or target is being defined conditionally. If we already know about
4334 # a definition that is true under the same conditions, then we have an
4335 # ambiguity.
4336 sub check_ambiguous_conditional
4337 {
4338 local ($var_name, $cond) = @_;
4339 local (@cond_vals) = split (' ', $conditional{$var_name});
4340 while (@cond_vals)
4341 {
4342 local ($vcond) = shift (@cond_vals);
4343 shift (@cond_vals);
4344 if (&conditional_true_when ($vcond, $cond)
4345 || &conditional_true_when ($cond, $vcond))
4346 {
4347 &am_line_error ($var_name,
4348 "$var_name multiply defined in condition");
4349 }
4350 }
4351 }
4353 # See if a variable exists. The first argument is the variable name,
4354 # and the optional second argument is the condition which we should
4355 # check. If no condition is given, we currently return true if the
4356 # variable is defined under any condition.
4357 sub variable_defined
4358 {
4359 local ($var, $cond) = @_;
4360 if (defined $targets{$var})
4361 {
4362 &am_line_error ($var, "\`$var' is target; expected variable");
4363 return 0;
4364 }
4365 elsif (defined $contents{$var})
4366 {
4367 if ($cond && $conditional{$var})
4368 {
4369 # We have been asked to check for a particular condition,
4370 # and the variable is defined conditionally. We need to
4371 # look through the conditions under which the variable is
4372 # defined, and see if any of them match the conditional we
4373 # have been asked to check.
4374 local (@cond_vars) = split (' ', $conditional{$var});
4375 while (@cond_vars)
4376 {
4377 if (&conditional_same ($cond, shift (@cond_vars)))
4378 {
4379 # Even a conditional examination is good enough
4380 # for us. FIXME: really should maintain examined
4381 # status on a per-condition basis.
4382 $content_seen{$var} = 1;
4383 return 1;
4384 }
4385 shift (@cond_vars);
4386 }
4388 # The variable is not defined for the given condition.
4389 return 0;
4390 }
4392 $content_seen{$var} = 1;
4393 return 1;
4394 }
4395 return 0;
4396 }
4398 # Mark a variable as examined.
4399 sub examine_variable
4400 {
4401 local ($var) = @_;
4402 &variable_defined ($var);
4403 }
4405 # Quote a value in order to put it in $conditional. We need to quote
4406 # spaces, and we need to handle null strings, so that we can later
4407 # retrieve values by splitting on space.
4408 sub quote_cond_val
4409 {
4410 local ($val) = @_;
4411 $val =~ s/ /\001/g;
4412 $val = '\002' if $val eq '';
4413 return $val;
4414 }
4416 # Unquote a value in $conditional.
4417 sub unquote_cond_val
4418 {
4419 local ($val) = @_;
4420 $val =~ s/\001/ /g;
4421 $val = '' if $val eq '\002';
4422 return $val;
4423 }
4425 # Return the set of conditions for which a variable is defined.
4427 # If the variable is not defined conditionally, and is not defined in
4428 # terms of any variables which are defined conditionally, then this
4429 # returns the empty list.
4431 # If the variable is defined conditionally, but is not defined in
4432 # terms of any variables which are defined conditionally, then this
4433 # returns the list of conditions for which the variable is defined.
4435 # If the variable is defined in terms of any variables which are
4436 # defined conditionally, then this returns a full set of permutations
4437 # of the subvariable conditions. For example, if the variable is
4438 # defined in terms of a variable which is defined for @COND_TRUE@,
4439 # then this returns both @COND_TRUE@ and @COND_FALSE@. This is
4440 # because we will need to define the variable under both conditions.
4442 sub variable_conditions
4443 {
4444 local ($var) = @_;
4445 local (%uniqify);
4446 local ($cond);
4448 foreach $cond (&variable_conditions_sub ($var, '', ()))
4449 {
4450 $uniqify{$cond} = 1;
4451 }
4453 return keys %uniqify;
4454 }
4456 # A subroutine of variable_conditions. We only return conditions
4457 # which are true for all the conditions in @PARENT_CONDS.
4458 sub variable_conditions_sub
4459 {
4460 local ($var, $parent, @parent_conds) = @_;
4461 local (@new_conds) = ();
4463 if (! $conditional{$var})
4464 {
4465 foreach (split (' ', $contents{$var}))
4466 {
4467 # If a comment seen, just leave.
4468 last if /^#/;
4470 # Handle variable substitutions.
4471 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
4472 {
4473 push (@new_conds,
4474 &variable_conditions_sub ($1, $var, @parent_conds));
4475 }
4476 }
4478 return &variable_conditions_reduce (@new_conds);
4479 }
4481 local (@this_conds) = ();
4482 local (@condvals) = split (' ', $conditional{$var});
4483 while (@condvals)
4484 {
4485 local ($cond) = shift (@condvals);
4486 local ($val) = &unquote_cond_val (shift (@condvals));
4488 if (@parent_conds)
4489 {
4490 local ($ok) = 1;
4491 local ($parent_cond);
4492 foreach $parent_cond (@parent_conds)
4493 {
4494 if (! &conditional_true_when ($parent_cond, $cond))
4495 {
4496 $ok = 0;
4497 last;
4498 }
4499 }
4501 next if ! $ok;
4502 }
4504 push (@this_conds, $cond);
4506 push (@parent_conds, $cond);
4507 local (@subvar_conds) = ();
4508 foreach (split (' ', $val))
4509 {
4510 # If a comment seen, just leave.
4511 last if /^#/;
4513 # Handle variable substitutions.
4514 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
4515 {
4516 push (@subvar_conds,
4517 &variable_conditions_sub ($1, $var, @parent_conds));
4518 }
4519 }
4520 pop (@parent_conds);
4522 # If there are no conditional subvariables, then we want to
4523 # return this condition. Otherwise, we want to return the
4524 # permutations of the subvariables.
4525 if (! @subvar_conds)
4526 {
4527 push (@new_conds, $cond);
4528 }
4529 else
4530 {
4531 push (@new_conds, &variable_conditions_reduce (@subvar_conds));
4532 }
4533 }
4535 return @new_conds
4536 if ! $parent;
4538 # If we are being called on behalf of another variable, we need to
4539 # return all possible permutations of the conditions. We have
4540 # already handled everything in @this_conds along with their
4541 # subvariables. We now need to add any permutations that are not
4542 # in @this_conds.
4543 local ($this_cond);
4544 foreach $this_cond (@this_conds)
4545 {
4546 local (@perms) =
4547 &variable_conditions_permutations (split('@', $this_cond));
4548 local ($perm);
4549 foreach $perm (@perms)
4550 {
4551 local ($scan);
4552 local ($ok) = 1;
4553 foreach $scan (@this_conds)
4554 {
4555 if (&conditional_true_when ($perm, $scan)
4556 || &conditional_true_when ($scan, $perm))
4557 {
4558 $ok = 0;
4559 last;
4560 }
4561 }
4562 next if ! $ok;
4564 if (@parent_conds)
4565 {
4566 local ($ok) = 1;
4567 local ($parent_cond);
4568 foreach $parent_cond (@parent_conds)
4569 {
4570 if (! &conditional_true_when ($parent_cond, $perm))
4571 {
4572 $ok = 0;
4573 last;
4574 }
4575 }
4577 next if ! $ok;
4578 }
4580 # This permutation was not already handled, and is valid
4581 # for the parents.
4582 push (@new_conds, $perm);
4583 }
4584 }
4586 return @new_conds;
4587 }
4589 # Subroutine for variable_conditions_sort
4590 sub variable_conditions_cmp
4591 {
4592 local ($as) = $a;
4593 $as =~ s/[^@]//g;
4594 local ($bs) = $b;
4595 $bs =~ s/[^@]//g;
4596 return (length ($as) <=> length ($bs)
4597 || $a cmp $b);
4598 }
4600 # Sort a list of conditionals so that only the exclusive ones are
4601 # retained. For example, if both @COND1_TRUE@@COND2_TRUE@ and
4602 # @COND1_TRUE@ are in the list, discard the latter.
4603 sub variable_conditions_reduce
4604 {
4605 local (@conds) = @_;
4606 local (@ret) = ();
4607 local ($cond);
4608 foreach $cond (sort variable_conditions_cmp @conds)
4609 {
4610 local ($ok) = 1;
4611 local ($scan);
4612 foreach $scan (@ret)
4613 {
4614 if (&conditional_true_when ($cond, $scan))
4615 {
4616 $ok = 0;
4617 last;
4618 }
4619 }
4620 next if ! $ok;
4621 push (@ret, $cond);
4622 }
4624 return @ret;
4625 }
4627 # Return a list of permutations of a conditional string.
4628 sub variable_conditions_permutations
4629 {
4630 local (@comps) = @_;
4631 return ()
4632 if ! @comps;
4633 local ($comp) = shift (@comps);
4634 return &variable_conditions_permutations (@comps)
4635 if $comp eq '';
4636 local ($neg) = $comp;
4637 $neg =~ s/TRUE$/TRUEO/;
4638 $neg =~ s/FALSE$/TRUE/;
4639 $neg =~ s/TRUEO$/FALSE/;
4640 local (@ret);
4641 local ($sub);
4642 foreach $sub (&variable_conditions_permutations (@comps))
4643 {
4644 push (@ret, '@' . $comp . '@' . $sub);
4645 push (@ret, '@' . $neg . '@' . $sub);
4646 }
4647 if (! @ret)
4648 {
4649 push (@ret, '@' . $comp . '@');
4650 push (@ret, '@' . $neg . '@');
4651 }
4652 return @ret;
4653 }
4655 # Warn if a variable is conditionally defined. This is called if we
4656 # are using the value of a variable.
4657 sub variable_conditionally_defined
4658 {
4659 local ($var, $parent) = @_;
4660 if ($conditional{$var})
4661 {
4662 if ($parent)
4663 {
4664 &am_line_error ($parent,
4665 "warning: automake does not support conditional definition of $var in $parent");
4666 }
4667 else
4668 {
4669 &am_line_error ($parent,
4670 "warning: automake does not support $var being defined conditionally")
4671 }
4672 }
4673 }
4675 # Get the value of a variable. This just returns $contents, but warns
4676 # if the variable is conditionally defined.
4677 sub variable_value
4678 {
4679 local ($var) = @_;
4680 &variable_conditionally_defined ($var);
4681 return $contents{$var};
4682 }
4684 # Convert a variable value to a list, split as whitespace. This will
4685 # recursively follow $(...) and ${...} inclusions. It preserves @...@
4686 # substitutions. If COND is 'all', then all values under all
4687 # conditions should be returned; if COND is a particular condition
4688 # (all conditions are surrounded by @...@) then only the value for
4689 # that condition should be returned; otherwise, warn if VAR is
4690 # conditionally defined.
4691 sub value_to_list
4692 {
4693 local ($var, $val, $cond) = @_;
4694 local (@result);
4696 foreach (split (' ', $val))
4697 {
4698 # If a comment seen, just leave.
4699 last if /^#/;
4701 # Handle variable substitutions.
4702 if (/^\$\{([^}]*)\}$/ || /^\$\(([^)]*)\)$/)
4703 {
4704 local ($varname) = $1;
4706 # If the user uses a losing variable name, just ignore it.
4707 # This isn't ideal, but people have requested it.
4708 next if ($varname =~ /\@.*\@/);
4710 local ($from, $to);
4711 local (@temp_list);
4712 if ($varname =~ /^([^:]*):([^=]*)=(.*)$/)
4713 {
4714 $varname = $1;
4715 $to = $3;
4716 ($from = $2) =~ s/(\W)/\\$1/g;
4717 }
4719 # Find the value.
4720 @temp_list = &variable_value_as_list ($1, $cond, $var);
4722 # Now rewrite the value if appropriate.
4723 if ($from)
4724 {
4725 grep (s/$from$/$to/, @temp_list);
4726 }
4728 push (@result, @temp_list);
4729 }
4730 else
4731 {
4732 push (@result, $_);
4733 }
4734 }
4736 return @result;
4737 }
4739 # Return contents of variable as list, split as whitespace. This will
4740 # recursively follow $(...) and ${...} inclusions. It preserves @...@
4741 # substitutions. If COND is 'all', then all values under all
4742 # conditions should be returned; if COND is a particular condition
4743 # (all conditions are surrounded by @...@) then only the value for
4744 # that condition should be returned; otherwise, warn if VAR is
4745 # conditionally defined. If PARENT is specified, it is the name of
4746 # the including variable; this is only used for error reports.
4747 sub variable_value_as_list
4748 {
4749 local ($var, $cond, $parent) = @_;
4750 local (@result);
4752 if (defined $targets{$var})
4753 {
4754 &am_line_error ($var, "\`$var' is target; expected variable");
4755 }
4756 elsif (! defined $contents{$var})
4757 {
4758 &am_line_error ($parent, "variable \`$var' not defined");
4759 }
4760 elsif ($cond eq 'all' && $conditional{$var})
4761 {
4762 local (@condvals) = split (' ', $conditional{$var});
4763 while (@condvals)
4764 {
4765 shift (@condvals);
4766 local ($val) = &unquote_cond_val (shift (@condvals));
4767 push (@result, &value_to_list ($var, $val, $cond));
4768 }
4769 }
4770 elsif ($cond && $conditional{$var})
4771 {
4772 local (@condvals) = split (' ', $conditional{$var});
4773 local ($onceflag);
4774 while (@condvals)
4775 {
4776 local ($vcond) = shift (@condvals);
4777 local ($val) = &unquote_cond_val (shift (@condvals));
4778 if (&conditional_true_when ($vcond, $cond))
4779 {
4780 # Warn if we have an ambiguity. It's hard to know how
4781 # to handle this case correctly.
4782 &variable_conditionally_defined ($var, $parent)
4783 if $onceflag;
4784 $onceflag = 1;
4785 push (@result, &value_to_list ($var, $val, $cond));
4786 }
4787 }
4788 }
4789 else
4790 {
4791 &variable_conditionally_defined ($var, $parent);
4792 $content_seen{$var} = 1;
4793 push (@result, &value_to_list ($var, $contents{$var}, $cond));
4794 }
4796 return @result;
4797 }
4799 # Define a new variable, but only if not already defined.
4800 sub define_variable
4801 {
4802 local ($var, $value) = @_;
4804 if (! defined $contents{$var})
4805 {
4806 $output_vars .= $var . ' = ' . $value . "\n";
4807 $contents{$var} = $value;
4808 $content_seen{$var} = 1;
4809 }
4810 }
4812 # Like define_variable, but the value is a list, and the variable may
4813 # be defined conditionally. The second argument is the conditional
4814 # under which the value should be defined; this should be the empty
4815 # string to define the variable unconditionally. The third argument
4816 # is a list holding the values to use for the variable. The value is
4817 # pretty printed in the output file.
4818 sub define_pretty_variable
4819 {
4820 local ($var, $cond, @value) = @_;
4821 if (! defined $contents{$var}
4822 || ($cond && ! &variable_defined ($var, $cond)))
4823 {
4824 $contents{$var} = join (' ', @value);
4825 if ($cond)
4826 {
4827 if ($conditional{$var})
4828 {
4829 $conditional{$var} .= ' ';
4830 }
4831 else
4832 {
4833 $conditional{$var} = '';
4834 }
4835 $conditional{$var} .= ($cond
4836 . ' '
4837 . "e_cond_val ($contents{$var}));
4838 }
4839 &pretty_print ($cond . $var . ' = ', $cond, @value);
4840 $content_seen{$var} = 1;
4841 }
4842 }
4844 # Like define_variable, but define a variable to be the configure
4845 # substitution by the same name.
4846 sub define_configure_variable
4847 {
4848 local ($var) = @_;
4849 local ($value) = '@' . $var . '@';
4850 &define_variable ($var, $value);
4851 }
4853 # Define a variable that represents a program to run. If in Cygnus
4854 # mode, the program is searched for in the build (or source) tree.
4855 # Otherwise no searching is done at all. Arguments are:
4856 # * VAR Name of variable to define
4857 # * WHATDIR Either `src' or `build', depending on where program should
4858 # be found. (runtest is in srcdir!)
4859 # * SUBDIR Subdir of top-level dir
4860 # * PROGRAM Name of program
4861 # * OVERRIDE If specified, the name of the program to use when not in
4862 # Cygnus mode. Defaults to PROGRAM.
4863 sub define_program_variable
4864 {
4865 local ($var, $whatdir, $subdir, $program, $override) = @_;
4867 if (! $override)
4868 {
4869 $override = $program;
4870 }
4872 if ($cygnus_mode)
4873 {
4874 local ($full) = ('$(top_' . $whatdir . 'dir)/../'
4875 . $subdir . '/' . $program);
4876 &define_variable ($var, ('`if test -f ' . $full
4877 . '; then echo ' . $full . '; else echo '
4878 . $program . '; fi`'));
4879 }
4880 else
4881 {
4882 &define_variable ($var, $override);
4883 }
4884 }
4887 ################################################################
4889 # Read Makefile.am and set up %contents. Simultaneously copy lines
4890 # from Makefile.am into $output_trailer or $output_vars as
4891 # appropriate. NOTE we put rules in the trailer section. We want
4892 # user rules to come after our generated stuff.
4893 sub read_am_file
4894 {
4895 local ($amfile) = @_;
4897 open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
4898 print "automake: reading $amfile\n" if $verbose;
4900 $output_vars = ("# $in_file_name generated automatically by automake "
4901 . $VERSION . " from $am_file_name\n");
4903 # Generate copyright for generated Makefile.in.
4904 $output_vars .= $gen_copyright;
4906 local ($saw_bk) = 0;
4907 local ($was_rule) = 0;
4908 local ($spacing) = '';
4909 local ($comment) = '';
4910 local ($last_var_name) = '';
4911 local ($blank) = 0;
4913 while (<AM_FILE>)
4914 {
4915 if (/$IGNORE_PATTERN/o)
4916 {
4917 # Merely delete comments beginning with two hashes.
4918 }
4919 elsif (/$WHITE_PATTERN/o)
4920 {
4921 # Stick a single white line before the incoming macro or rule.
4922 $spacing = "\n";
4923 $blank = 1;
4924 }
4925 elsif (/$COMMENT_PATTERN/o)
4926 {
4927 # Stick comments before the incoming macro or rule. Make
4928 # sure a blank line preceeds first block of comments.
4929 $spacing = "\n" unless $blank;
4930 $blank = 1;
4931 $comment .= $spacing . $_;
4932 $spacing = '';
4933 }
4934 else
4935 {
4936 last;
4937 }
4938 }
4940 $output_vars .= $comment . "\n";
4941 $comment = '';
4942 $spacing = "\n";
4943 local ($am_vars) = '';
4945 local ($is_ok_macro);
4946 while ($_)
4947 {
4948 $_ .= "\n"
4949 unless substr ($_, -1, 1) eq "\n";
4951 $_ =~ s/\@MAINT\@//g
4952 unless $seen_maint_mode;
4954 if (/$IGNORE_PATTERN/o)
4955 {
4956 # Merely delete comments beginning with two hashes.
4957 }
4958 elsif (/$WHITE_PATTERN/o)
4959 {
4960 # Stick a single white line before the incoming macro or rule.
4961 $spacing = "\n";
4962 }
4963 elsif (/$COMMENT_PATTERN/o)
4964 {
4965 # Stick comments before the incoming macro or rule.
4966 $comment .= $spacing . $_;
4967 $spacing = '';
4968 }
4969 elsif ($saw_bk)
4970 {
4971 if ($was_rule)
4972 {
4973 $output_trailer .= join ('', @conditional_stack) . $_;
4974 $saw_bk = /\\$/;
4975 }
4976 else
4977 {
4978 $am_vars .= join ('', @conditional_stack) . $_;
4979 $saw_bk = /\\$/;
4980 # Chop newline and backslash if this line is
4981 # continued. FIXME: maybe ensure trailing whitespace
4982 # exists?
4983 chop if $saw_bk;
4984 chop if $saw_bk;
4985 $contents{$last_var_name} .= $_;
4986 if (@conditional_stack)
4987 {
4988 $conditional{$last_var_name} .= "e_cond_val ($_);
4989 }
4990 }
4991 }
4992 elsif (/$IF_PATTERN/o)
4993 {
4994 &am_line_error ($., "$1 does not appear in AM_CONDITIONAL")
4995 if (! $configure_cond{$1});
4996 push (@conditional_stack, "\@" . $1 . "_TRUE\@");
4997 }
4998 elsif (/$ELSE_PATTERN/o)
4999 {
5000 if (! @conditional_stack)
5001 {
5002 &am_line_error ($., "else without if");
5003 }
5004 elsif ($conditional_stack[$#conditional_stack] =~ /_FALSE\@$/)
5005 {
5006 &am_line_error ($., "else after else");
5007 }
5008 else
5009 {
5010 $conditional_stack[$#conditional_stack]
5011 =~ s/_TRUE\@$/_FALSE\@/;
5012 }
5013 }
5014 elsif (/$ENDIF_PATTERN/o)
5015 {
5016 if (! @conditional_stack)
5017 {
5018 &am_line_error ($., "endif without if");
5019 }
5020 else
5021 {
5022 pop @conditional_stack;
5023 }
5024 }
5025 elsif (/$RULE_PATTERN/o)
5026 {
5027 # Found a rule.
5028 $was_rule = 1;
5029 if (defined $contents{$1}
5030 && (@conditional_stack
5031 ? ! defined $conditional{$1}
5032 : defined $conditional{$1}))
5033 {
5034 &am_line_error ($1,
5035 "$1 defined both conditionally and unconditionally");
5036 }
5037 # Value here doesn't matter; for targets we only note
5038 # existence.
5039 $contents{$1} = 1;
5040 $targets{$1} = 1;
5041 local ($cond_string) = join ('', @conditional_stack);
5042 if (@conditional_stack)
5043 {
5044 if ($conditional{$1})
5045 {
5046 &check_ambiguous_conditional ($1, $cond_string);
5047 $conditional{$1} .= ' ';
5048 }
5049 else
5050 {
5051 $conditional{$1} = '';
5052 }
5053 $conditional{$1} .= $cond_string . ' 1';
5054 }
5055 $content_lines{$1} = $.;
5056 $output_trailer .= $comment . $spacing . $cond_string . $_;
5057 $comment = $spacing = '';
5058 $saw_bk = /\\$/;
5059 }
5060 elsif (($is_ok_macro = /$MACRO_PATTERN/o)
5061 || /$BOGUS_MACRO_PATTERN/o)
5062 {
5063 # Found a macro definition.
5064 $was_rule = 0;
5065 $last_var_name = $1;
5066 if (defined $contents{$1}
5067 && (@conditional_stack
5068 ? ! defined $conditional{$1}
5069 : defined $conditional{$1}))
5070 {
5071 &am_line_error ($1,
5072 "$1 defined both conditionally and unconditionally");
5073 }
5074 if ($2 ne '' && substr ($2, -1) eq "\\")
5075 {
5076 $contents{$last_var_name} = substr ($2, 0, length ($2) - 1);
5077 }
5078 else
5079 {
5080 $contents{$last_var_name} = $2;
5081 }
5082 local ($cond_string) = join ('', @conditional_stack);
5083 if (@conditional_stack)
5084 {
5085 if ($conditional{$last_var_name})
5086 {
5087 &check_ambiguous_conditional ($last_var_name,
5088 $cond_string);
5089 $conditional{$last_var_name} .= ' ';
5090 }
5091 else
5092 {
5093 $conditional{$last_var_name} = '';
5094 }
5095 local ($val) = $contents{$last_var_name};
5096 $conditional{$last_var_name} .= ($cond_string
5097 . ' '
5098 . "e_cond_val ($val));
5099 }
5100 $content_lines{$last_var_name} = $.;
5101 $am_vars .= $comment . $spacing . $cond_string . $_;
5102 $comment = $spacing = '';
5103 $saw_bk = /\\$/;
5105 # Error if bogus.
5106 &am_line_error ($., "bad macro name \`$last_var_name'")
5107 if ! $is_ok_macro;
5108 }
5109 else
5110 {
5111 # This isn't an error; it is probably a continued rule.
5112 # In fact, this is what we assume.
5113 $was_rule = 1;
5114 $output_trailer .= ($comment . $spacing
5115 . join ('', @conditional_stack) . $_);
5116 $comment = $spacing = '';
5117 $saw_bk = /\\$/;
5118 }
5120 $_ = <AM_FILE>;
5121 }
5123 $output_trailer .= $comment;
5125 &am_error ("unterminated conditionals: " . join (' ', @conditional_stack))
5126 if (@conditional_stack);
5128 # Compute relative location of the top object directory.
5129 local (@topdir) = ();
5130 foreach (split (/\//, $relative_dir))
5131 {
5132 next if $_ eq '.' || $_ eq '';
5133 if ($_ eq '..')
5134 {
5135 pop @topdir;
5136 }
5137 else
5138 {
5139 push (@topdir, '..');
5140 }
5141 }
5142 @topdir = ('.') if ! @topdir;
5144 $top_builddir = join ('/', @topdir);
5145 local ($build_rx);
5146 ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
5147 $output_vars .= &file_contents_with_transform
5148 ('s/\@top_builddir\@/' . $build_rx . '/g;',
5149 'header-vars');
5151 # Generate some useful variables when AC_CANONICAL_* used. FIXME:
5152 # this should use generic %configure_vars method.
5153 if ($seen_canonical)
5154 {
5155 local ($curs, %vars);
5156 $vars{'host_alias'} = 'host_alias';
5157 $vars{'host_triplet'} = 'host';
5158 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
5159 {
5160 $vars{'build_alias'} = 'build_alias';
5161 $vars{'build_triplet'} = 'build';
5162 $vars{'target_alias'} = 'target_alias';
5163 $vars{'target_triplet'} = 'target';
5164 }
5165 foreach $curs (sort keys %vars)
5166 {
5167 $output_vars .= "$curs = \@$vars{$curs}\@\n";
5168 $contents{$curs} = "\@$vars{$curs}\@";
5169 }
5170 }
5172 local ($curs);
5173 foreach $curs (sort keys %configure_vars)
5174 {
5175 &define_configure_variable ($curs);
5176 }
5178 $output_vars .= $am_vars;
5179 }
5181 ################################################################
5183 sub initialize_global_constants
5184 {
5185 # Values for AC_CANONICAL_*
5186 $AC_CANONICAL_HOST = 1;
5187 $AC_CANONICAL_SYSTEM = 2;
5189 # Associative array of standard directory names. Entry is TRUE if
5190 # corresponding directory should be installed during
5191 # 'install-exec' phase.
5192 %exec_dir_p =
5193 ('bin', 1,
5194 'sbin', 1,
5195 'libexec', 1,
5196 'data', 0,
5197 'sysconf', 1,
5198 'localstate', 1,
5199 'lib', 1,
5200 'info', 0,
5201 'man', 0,
5202 'include', 0,
5203 'oldinclude', 0,
5204 'pkgdata', 0,
5205 'pkglib', 1,
5206 'pkginclude', 0
5207 );
5209 # Helper text for dealing with man pages.
5210 $install_man_format =
5211 ' @sect=@SECTION@; \\
5212 inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
5213 if test -f $(srcdir)/@MAN@; then file=$(srcdir)/@MAN@; \\
5214 else file=@MAN@; fi; \\
5215 echo " $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst"; \\
5216 $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst
5217 ';
5219 $uninstall_man_format =
5220 ' inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
5221 rm -f $(mandir)/man@SECTION@/$$inst
5222 ';
5224 # Commonly found files we look for and automatically include in
5225 # DISTFILES.
5226 @common_files =
5227 (
5228 "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
5229 "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
5230 "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
5231 "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
5232 'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp',
5233 'ylwrap', 'acinclude.m4', @libtoolize_files,
5234 'missing'
5235 );
5237 # Commonly used files we auto-include, but only sometimes.
5238 @common_sometimes =
5239 (
5240 "aclocal.m4", "acconfig.h", "config.h.top",
5241 "config.h.bot", "stamp-h.in", 'stamp-vti'
5242 );
5244 $USAGE = "\
5245 -a, --add-missing add missing standard files to package
5246 --amdir=DIR directory storing config files
5247 --build-dir=DIR directory where build being done (for dependencies)
5248 --cygnus assume program is part of Cygnus-style tree
5249 --foreign set strictness to foreign
5250 --gnits set strictness to gnits
5251 --gnu set strictness to gnu
5252 --help print this help, then exit
5253 -i, --include-deps include generated dependencies in Makefile.in
5254 --no-force only update Makefile.in's that are out of date
5255 -o DIR, --output-dir=DIR
5256 put generated Makefile.in's into DIR
5257 --srcdir-name=DIR name used for srcdir (for dependencies)
5258 -v, --verbose verbosely list files processed
5259 --version print version number, then exit\n";
5261 # Copyright on generated Makefile.ins.
5262 $gen_copyright = "\
5263 # Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
5264 # This Makefile.in is free software; the Free Software Foundation
5265 # gives unlimited permission to copy and/or distribute it,
5266 # with or without modifications, as long as this notice is preserved.
5267 ";
5269 # Ignore return result from chmod, because it might give an error
5270 # if we chmod a symlink.
5271 $dist_header = "\t" . '-chmod -R a+r $(distdir)' . "\n";
5272 $dist{'dist-tarZ'} = ("\t"
5273 . '$(TAR) chf - $(distdir) | compress -c > $(distdir).tar.Z'
5274 . "\n");
5275 $dist{'dist-shar'} = ("\t"
5276 . 'shar $(distdir) | gzip > $(distdir).shar.gz'
5277 . "\n");
5278 $dist{'dist-zip'} = "\t" . 'zip -rq $(distdir).zip $(distdir)' . "\n";
5279 $dist{'dist'} = "\t" . 'GZIP=$(GZIP) $(TAR) chozf $(distdir).tar.gz $(distdir)' . "\n";
5280 $dist_trailer = "\t" . 'rm -rf $(distdir)' . "\n";
5281 }
5283 # (Re)-Initialize per-Makefile.am variables.
5284 sub initialize_per_input
5285 {
5286 # These two variables are used when generating each Makefile.in.
5287 # They hold the Makefile.in until it is ready to be printed.
5288 $output_rules = '';
5289 $output_vars = '';
5290 $output_trailer = '';
5291 $output_header = '';
5293 # Suffixes found during a run.
5294 @suffixes = ();
5296 # This holds the contents of a Makefile.am, as parsed by
5297 # read_am_file.
5298 %contents = ();
5300 # This holds the names which are targets. These also appear in
5301 # %contents.
5302 %targets = ();
5304 # For a variable or target which is defined conditionally, this
5305 # holds an array of the conditional values. The array is composed
5306 # of pairs of condition strings (the variables which configure
5307 # will substitute) and values (the value of a target is
5308 # meaningless). For an unconditional variable, this is empty.
5309 %conditional = ();
5311 # This holds the line numbers at which various elements of
5312 # %contents are defined.
5313 %content_lines = ();
5315 # This holds a 1 if a particular variable was examined.
5316 %content_seen = ();
5318 # This is the conditional stack.
5319 @conditional_stack = ();
5321 # This holds the "relative directory" of the current Makefile.in.
5322 # Eg for src/Makefile.in, this is "src".
5323 $relative_dir = '';
5325 # This holds a list of files that are included in the
5326 # distribution.
5327 %dist_common = ();
5329 # List of dependencies for the obvious targets.
5330 @install_data = ();
5331 @install_exec = ();
5332 @uninstall = ();
5333 @installdirs = ();
5335 @info = ();
5336 @dvi = ();
5337 @all = ();
5338 @check = ();
5339 @check_tests = ();
5340 @installcheck = ();
5341 @clean = ();
5343 @phony = ();
5345 # These are pretty obvious, too. They are used to define the
5346 # SOURCES and OBJECTS variables.
5347 @sources = ();
5348 @objects = ();
5350 # TRUE if current directory holds any C source files.
5351 $dir_holds_sources = 0;
5353 # These variables track inclusion of various compile-related .am
5354 # files. $included_generic_compile is TRUE if the basic code has
5355 # been included. $included_knr_compile is TRUE if the ansi2knr
5356 # code has been included. $included_libtool_compile is TRUE if
5357 # libtool support has been included.
5358 $included_generic_compile = 0;
5359 $included_knr_compile = 0;
5360 $included_libtool_compile = 0;
5362 # TRUE if current directory holds any headers.
5363 $dir_holds_headers = 0;
5365 # TRUE if install targets should work recursively.
5366 $recursive_install = 0;
5368 # All .P files.
5369 %dep_files = ();
5371 # Strictness levels.
5372 $strictness = $default_strictness;
5373 $strictness_name = $default_strictness_name;
5375 # Options from AUTOMAKE_OPTIONS.
5376 %options = ();
5378 # Whether or not dependencies are handled. Can be further changed
5379 # in handle_options.
5380 $use_dependencies = $cmdline_use_dependencies;
5382 # Per Makefile.am.
5383 $local_maint_charset = $maint_charset;
5385 # All yacc and lex source filenames for this directory. Use
5386 # filenames instead of raw count so that multiple instances are
5387 # counted correctly (eg one yacc file can appear in multiple
5388 # programs without harm).
5389 %yacc_sources = ();
5390 %lex_sources = ();
5392 # C++ source extensions we've seen.
5393 %cxx_extensions = ();
5395 # TRUE if we've seen any non-C++ sources. This actually holds a
5396 # line number or the name of a symbol corresponding to a line
5397 # number where the C sources were seen. If it is -1 then it means
5398 # we couldn't (easily) figure out which line of the Makefile.am
5399 # mentioned the sources.
5400 $seen_c_source = 0;
5402 # This is a list of all targets to run during "make dist".
5403 @dist_targets = ();
5405 # Keys in this hash are the basenames of files which must depend
5406 # on ansi2knr.
5407 %de_ansi_files = ();
5408 }
5411 ################################################################
5413 # Return contents of a file from $am_dir, automatically skipping
5414 # macros or rules which are already known. Runs command on each line
5415 # as it is read; this command can modify $_.
5416 sub file_contents_with_transform
5417 {
5418 local ($command, $basename) = @_;
5419 local ($file) = $am_dir . '/' . $basename . '.am';
5421 if ($command ne '' && substr ($command, -1) ne ';')
5422 {
5423 die "automake: programming error in file_contents_with_transform\n";
5424 }
5426 open (FC_FILE, $file)
5427 || die "automake: installation error: cannot open \`$file'\n";
5428 # Looks stupid?
5429 # print "automake: reading $file\n" if $verbose;
5431 local ($was_rule) = 0;
5432 local ($result_vars) = '';
5433 local ($result_rules) = '';
5434 local ($comment) = '';
5435 local ($spacing) = "\n";
5436 local ($skipping) = 0;
5437 local ($had_chars);
5439 while (<FC_FILE>)
5440 {
5441 $_ =~ s/\@MAINT\@//g
5442 unless $seen_maint_mode;
5444 $had_chars = length ($_) && $_ ne "\n";
5445 eval $command;
5446 # If the transform caused all the characters to go away, then
5447 # ignore the line. Why do this? Because in Perl 4, a "next"
5448 # inside of an eval doesn't affect a loop outside the eval.
5449 # So we can't pass in a "transform" that uses next. We used
5450 # to do this. "Empty" also means consisting of a single
5451 # newline.
5452 next if $had_chars && ($_ eq '' || $_ eq "\n");
5454 if (/$IGNORE_PATTERN/o)
5455 {
5456 # Merely delete comments beginning with two hashes.
5457 }
5458 elsif (/$WHITE_PATTERN/o)
5459 {
5460 # Stick a single white line before the incoming macro or rule.
5461 $spacing = "\n";
5462 }
5463 elsif (/$COMMENT_PATTERN/o)
5464 {
5465 # Stick comments before the incoming macro or rule.
5466 $comment .= $spacing . $_;
5467 $spacing = '';
5468 }
5469 elsif ($saw_bk)
5470 {
5471 if ($was_rule)
5472 {
5473 $result_rules .= $_ if ! $skipping;
5474 }
5475 else
5476 {
5477 $result_vars .= $_ if ! $skipping;
5478 }
5479 $saw_bk = /\\$/;
5480 }
5481 elsif (/$RULE_PATTERN/o)
5482 {
5483 # Found a rule.
5484 $was_rule = 1;
5485 $skipping = defined $contents{$1};
5486 $result_rules .= $comment . $spacing . $_ if ! $skipping;
5487 $comment = $spacing = '';
5488 $saw_bk = /\\$/;
5489 }
5490 elsif (/$MACRO_PATTERN/o)
5491 {
5492 # Found a variable reference.
5493 $was_rule = 0;
5494 $skipping = defined $contents{$1};
5495 $result_vars .= $comment . $spacing . $_ if ! $skipping;
5496 $comment = $spacing = '';
5497 $saw_bk = /\\$/;
5498 }
5499 else
5500 {
5501 # This isn't an error; it is probably a continued rule.
5502 # In fact, this is what we assume.
5503 $was_rule = 1;
5504 $result_rules .= $comment . $spacing . $_ if ! $skipping;
5505 $comment = $spacing = '';
5506 $saw_bk = /\\$/;
5507 }
5508 }
5510 close (FC_FILE);
5511 return $result_vars . $result_rules . $comment;
5512 }
5514 # Like file_contents_with_transform, but no transform.
5515 sub file_contents
5516 {
5517 return &file_contents_with_transform ('', @_);
5518 }
5520 # Find all variable prefixes that are used for install directories. A
5521 # prefix `zar' qualifies iff:
5522 # * `zardir' is a variable.
5523 # * `zar_PRIMARY' is a variable.
5524 sub am_primary_prefixes
5525 {
5526 local ($primary, @prefixes) = @_;
5528 local (%valid, $varname);
5529 grep ($valid{$_} = 0, @prefixes);
5530 $valid{'EXTRA'} = 0;
5531 foreach $varname (keys %contents)
5532 {
5533 if ($varname =~ /^(.*)_$primary$/)
5534 {
5535 if (! defined $valid{$1}
5536 && ! &variable_defined ($1 . 'dir')
5537 # Note that a configure variable is always legitimate.
5538 # It is natural to name such variables after the
5539 # primary, so we explicitly allow it.
5540 && ! defined $configure_vars{$varname})
5541 {
5542 &am_line_error ($varname, "invalid variable \`$varname'");
5543 }
5544 else
5545 {
5546 # Ensure all extended prefixes are actually used.
5547 $valid{$1} = 1;
5548 }
5549 }
5550 }
5552 return %valid;
5553 }
5555 # Handle `where_HOW' variable magic. Does all lookups, generates
5556 # install code, and possibly generates code to define the primary
5557 # variable. The first argument is the name of the .am file to munge,
5558 # the second argument is the primary variable (eg HEADERS), and all
5559 # subsequent arguments are possible installation locations. Returns
5560 # list of all values of all _HOW targets.
5561 #
5562 # FIXME: this should be rewritten to be cleaner. It should be broken
5563 # up into multiple functions.
5564 #
5565 # Usage is: am_install_var (OPTION..., file, HOW, where...)
5566 sub am_install_var
5567 {
5568 local (@args) = @_;
5570 local ($do_clean) = 0;
5572 local ($ltxform);
5573 if (defined $configure_vars{'LIBTOOL'})
5574 {
5575 # Transform '@LIBTOOL ...@' to '$(LIBTOOL) ...'
5576 $ltxform = 's/\@LIBTOOL([^\@]*)\@/\$(LIBTOOL) $1/;';
5577 }
5578 else
5579 {
5580 # Delete '@LIBTOOL ...@'
5581 $ltxform = 's/\@LIBTOOL([^\@]*)\@//;';
5582 }
5584 local ($cygxform);
5585 if (! $seen_exeext)
5586 {
5587 $cygxform = 's/\@EXEEXT\@//g;';
5588 }
5589 else
5590 {
5591 $cygxform = 's/\@EXEEXT\@/\$(EXEEXT)/g;';
5592 }
5594 while (@args)
5595 {
5596 if ($args[0] eq '-clean')
5597 {
5598 $do_clean = 1;
5599 }
5600 elsif ($args[0] !~ /^-/)
5601 {
5602 last;
5603 }
5604 shift (@args);
5605 }
5606 local ($file, $primary, @prefixes) = @args;
5608 local (@used) = ();
5609 local (@result) = ();
5611 # Now that configure substitutions are allowed in where_HOW
5612 # variables, it is an error to actually define the primary.
5613 &am_line_error ($primary, "\`$primary' is an anachronism")
5614 if &variable_defined ($primary);
5617 # Look for misspellings. It is an error to have a variable ending
5618 # in a "reserved" suffix whose prefix is unknown, eg
5619 # "bni_PROGRAMS". However, unusual prefixes are allowed if a
5620 # variable of the same name (with "dir" appended) exists. For
5621 # instance, if the variable "zardir" is defined, then
5622 # "zar_PROGRAMS" becomes valid. This is to provide a little extra
5623 # flexibility in those cases which need it. Perhaps it should be
5624 # disallowed in the Gnits case? The problem is, sometimes it is
5625 # useful to put things in a subdir of eg pkgdatadir, perhaps even
5626 # for Gnitsoids.
5627 local (%valid) = &am_primary_prefixes ($primary, @prefixes);
5629 # If a primary includes a configure substitution, then the EXTRA_
5630 # form is required. Otherwise we can't properly do our job.
5631 local ($require_extra);
5632 local ($warned_about_extra) = 0;
5634 local ($clean_file) = $file . '-clean';
5635 local ($one_name);
5636 local ($X);
5637 foreach $X (sort keys %valid)
5638 {
5639 $one_name = $X . '_' . $primary;
5640 if (&variable_defined ($one_name))
5641 {
5642 # Append actual contents of where_PRIMARY variable to
5643 # result.
5644 local ($rcurs);
5645 foreach $rcurs (&variable_value_as_list ($one_name, 'all'))
5646 {
5647 # Skip configure substitutions. Possibly bogus.
5648 if ($rcurs =~ /^\@.*\@$/)
5649 {
5650 if ($X eq 'EXTRA')
5651 {
5652 if (! $warned_about_extra)
5653 {
5654 $warned_about_extra = 1;
5655 &am_line_error ($one_name,
5656 "\`$one_name' contains configure substitution, but shouldn't");
5657 }
5658 }
5659 # Check here to make sure variables defined in
5660 # configure.in do not imply that EXTRA_PRIMARY
5661 # must be defined.
5662 elsif (! defined $configure_vars{$one_name})
5663 {
5664 $require_extra = $one_name;
5665 }
5667 next;
5668 }
5670 push (@result, $rcurs);
5671 }
5673 # "EXTRA" shouldn't be used when generating clean targets,
5674 # all, or install targets.
5675 next if $X eq 'EXTRA';
5677 # A blatant hack: we rewrite each _PROGRAMS primary to
5678 # include EXEEXT when in Cygwin32 mode.
5679 if ($seen_exeext && $primary eq 'PROGRAMS')
5680 {
5681 local (@conds) = &variable_conditions ($one_name);
5682 local (@one_binlist);
5684 # FIXME: this definitely loses aesthetically; it
5685 # redefines $ONE_NAME. Instead we should arrange for
5686 # variable definitions to be output later, instead of
5687 # at scan time.
5689 if (! @conds)
5690 {
5691 @one_binlist = ();
5692 foreach $rcurs (&variable_value_as_list ($one_name, ''))
5693 {
5694 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
5695 {
5696 push (@one_binlist, $rcurs);
5697 }
5698 else
5699 {
5700 push (@one_binlist, $rcurs . '$(EXEEXT)');
5701 }
5702 }
5704 delete $contents{$one_name};
5705 &define_pretty_variable ($one_name, '', @one_binlist);
5706 }
5707 else
5708 {
5709 local ($cond);
5710 local ($condvals) = '';
5711 foreach $cond (@conds)
5712 {
5713 @one_binlist = ();
5714 local (@condval) = &variable_value_as_list ($one_name,
5715 $cond);
5716 foreach $rcurs (@condval)
5717 {
5718 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
5719 {
5720 push (@one_binlist, $rcurs);
5721 }
5722 else
5723 {
5724 push (@one_binlist, $rcurs . '$(EXEEXT)');
5725 }
5726 }
5728 push (@condvals, $cond);
5729 push (@condvals, join (' ', @one_binlist));
5730 }
5732 delete $contents{$one_name};
5734 while (@condvals)
5735 {
5736 $cond = shift (@condvals);
5737 local (@val) = split (' ', shift (@condvals));
5738 &define_pretty_variable ($one_name, $cond, @val);
5739 }
5740 }
5741 }
5743 if ($do_clean)
5744 {
5745 $output_rules .=
5746 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go;'
5747 . $cygxform,
5748 $clean_file);
5750 push (@clean, $X . $primary);
5751 &push_phony_cleaners ($X . $primary);
5752 }
5754 if ($X eq 'check')
5755 {
5756 push (@check, '$(' . $one_name . ')');
5757 }
5758 else
5759 {
5760 push (@used, '$(' . $one_name . ')');
5761 }
5762 if ($X eq 'noinst' || $X eq 'check')
5763 {
5764 # Objects which don't get installed by default.
5765 next;
5766 }
5768 $output_rules .=
5769 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/g;'
5770 . $ltxform . $cygxform,
5771 $file);
5773 push (@uninstall, 'uninstall-' . $X . $primary);
5774 push (@phony, 'uninstall-' . $X . $primary);
5775 push (@installdirs, '$(' . $X . 'dir)');
5776 if (defined $exec_dir_p{$X} ? $exec_dir_p{$X} : ($X =~ /exec/))
5777 {
5778 push (@install_exec, 'install-' . $X . $primary);
5779 push (@phony, 'install-' . $X . $primary);
5780 }
5781 else
5782 {
5783 push (@install_data, 'install-' . $X . $primary);
5784 push (@phony, 'install-' . $X . $primary);
5785 }
5786 }
5787 }
5789 if (@used)
5790 {
5791 # Define it.
5792 &define_pretty_variable ($primary, '', @used);
5793 $output_vars .= "\n";
5794 }
5796 if ($require_extra && ! &variable_defined ('EXTRA_' . $primary))
5797 {
5798 &am_line_error ($require_extra,
5799 "\`$require_extra' contains configure substitution, but \`EXTRA_$primary' not defined");
5800 }
5802 # Push here because PRIMARY might be configure time determined.
5803 push (@all, '$(' . $primary . ')')
5804 if @used;
5806 return (@result);
5807 }
5810 ################################################################
5812 # This variable is local to the "require file" set of functions.
5813 @require_file_paths = ();
5815 # Verify that the file must exist in the current directory. Usage:
5816 # require_file (isconfigure, line_number, strictness, file) strictness
5817 # is the strictness level at which this file becomes required. Must
5818 # set require_file_paths before calling this function.
5819 # require_file_paths is set to hold a single directory (the one in
5820 # which the first file was found) before return.
5821 sub require_file_internal
5822 {
5823 local ($is_configure, $line, $mystrict, @files) = @_;
5824 local ($file, $fullfile);
5825 local ($found_it, $errfile, $errdir);
5826 local ($save_dir);
5828 foreach $file (@files)
5829 {
5830 $found_it = 0;
5831 foreach $dir (@require_file_paths)
5832 {
5833 if ($dir eq '.')
5834 {
5835 $fullfile = $relative_dir . "/" . $file;
5836 $errdir = $relative_dir unless $errdir;
5837 }
5838 else
5839 {
5840 $fullfile = $dir . "/" . $file;
5841 $errdir = $dir unless $errdir;
5842 }
5844 # Use different name for "error filename". Otherwise on
5845 # an error the bad file will be reported as eg
5846 # `../../install-sh' when using the default
5847 # config_aux_path.
5848 $errfile = $errdir . '/' . $file;
5850 if (-f $fullfile)
5851 {
5852 $found_it = 1;
5853 # FIXME: Once again, special-case `.'.
5854 &push_dist_common ($file)
5855 if $dir eq $relative_dir || $dir eq '.';
5856 $save_dir = $dir;
5857 last;
5858 }
5859 }
5861 if ($found_it)
5862 {
5863 # Prune the path list.
5864 @require_file_paths = $save_dir;
5865 }
5866 else
5867 {
5868 if ($strictness >= $mystrict)
5869 {
5870 local ($trailer) = '';
5871 local ($suppress) = 0;
5873 # Only install missing files according to our desired
5874 # strictness level.
5875 local ($message) = "required file \`$errfile' not found";
5876 if ($add_missing)
5877 {
5878 $suppress = 1;
5880 # Maybe run libtoolize.
5881 if ($seen_libtool
5882 && grep ($_ eq $file, @libtoolize_files)
5883 && system ('libtoolize', '--automake'))
5884 {
5885 $message = "installing \`$errfile'";
5886 $suppress = 0;
5887 $trailer = "; cannot run \`libtoolize': $!";
5888 }
5889 elsif (-f ($am_dir . '/' . $file))
5890 {
5891 # Install the missing file. Symlink if we
5892 # can, copy if we must. Note: delete the file
5893 # first, in case it is a dangling symlink.
5894 $message = "installing \`$errfile'";
5895 unlink ($errfile);
5896 if ($symlink_exists)
5897 {
5898 if (! symlink ($am_dir . '/' . $file, $errfile))
5899 {
5900 $suppress = 0;
5901 $trailer = "; error while making link: $!\n";
5902 }
5903 }
5904 elsif (! system ('cp', $am_dir . '/' . $file, $errfile))
5905 {
5906 $suppress = 0;
5907 $trailer = "\n error while making link\n";
5908 }
5909 }
5910 }
5912 local ($save) = $exit_status;
5913 if ($is_configure)
5914 {
5915 # FIXME: allow actual file to be specified.
5916 &am_conf_line_error ('configure.in', $line,
5917 "$message$trailer");
5918 }
5919 else
5920 {
5921 &am_line_error ($line, "$message$trailer");
5922 }
5923 $exit_status = $save if $suppress;
5924 }
5925 }
5926 }
5927 }
5929 # Like require_file_with_line, but error messages refer to
5930 # configure.in, not the current Makefile.am.
5931 sub require_file_with_conf_line
5932 {
5933 @require_file_paths = '.';
5934 &require_file_internal (1, @_);
5935 }
5937 sub require_file_with_line
5938 {
5939 @require_file_paths = '.';
5940 &require_file_internal (0, @_);
5941 }
5943 sub require_file
5944 {
5945 @require_file_paths = '.';
5946 &require_file_internal (0, '', @_);
5947 }
5949 # Require a file that is also required by Autoconf. Looks in
5950 # configuration path, as specified by AC_CONFIG_AUX_DIR.
5951 sub require_config_file
5952 {
5953 @require_file_paths = @config_aux_path;
5954 &require_file_internal (1, '', @_);
5955 local ($dir) = $require_file_paths[0];
5956 @config_aux_path = @require_file_paths;
5957 if ($dir eq '.')
5958 {
5959 $config_aux_dir = '.';
5960 }
5961 else
5962 {
5963 $config_aux_dir = '$(top_srcdir)/' . $dir;
5964 }
5965 }
5967 # Assumes that the line number is in Makefile.am.
5968 sub require_conf_file_with_line
5969 {
5970 @require_file_paths = @config_aux_path;
5971 &require_file_internal (0, @_);
5972 local ($dir) = $require_file_paths[0];
5973 @config_aux_path = @require_file_paths;
5974 if ($dir eq '.')
5975 {
5976 $config_aux_dir = '.';
5977 }
5978 else
5979 {
5980 $config_aux_dir = '$(top_srcdir)/' . $dir;
5981 }
5982 }
5984 # Assumes that the line number is in Makefile.am.
5985 sub require_conf_file_with_conf_line
5986 {
5987 @require_file_paths = @config_aux_path;
5988 &require_file_internal (1, @_);
5989 local ($dir) = $require_file_paths[0];
5990 @config_aux_path = @require_file_paths;
5991 if ($dir eq '.')
5992 {
5993 $config_aux_dir = '.';
5994 }
5995 else
5996 {
5997 $config_aux_dir = '$(top_srcdir)/' . $dir;
5998 }
5999 }
6001 ################################################################
6003 # Push a list of files onto dist_common.
6004 sub push_dist_common
6005 {
6006 local (@files) = @_;
6007 local ($file);
6009 foreach $file (@files)
6010 {
6011 $dist_common{$file} = 1;
6012 }
6013 }
6015 # Push a list of clean targets onto phony.
6016 sub push_phony_cleaners
6017 {
6018 local ($base) = @_;
6019 local ($target);
6020 foreach $target ('mostly', 'dist', '', 'maintainer-')
6021 {
6022 push (@phony, $target . 'clean-' . $base);
6023 }
6024 }
6026 # Set strictness.
6027 sub set_strictness
6028 {
6029 $strictness_name = $_[0];
6030 if ($strictness_name eq 'gnu')
6031 {
6032 $strictness = $GNU;
6033 }
6034 elsif ($strictness_name eq 'gnits')
6035 {
6036 $strictness = $GNITS;
6037 }
6038 elsif ($strictness_name eq 'foreign')
6039 {
6040 $strictness = $FOREIGN;
6041 }
6042 else
6043 {
6044 die "automake: level \`$strictness_name' not recognized\n";
6045 }
6046 }
6049 ################################################################
6051 # Return directory name of file.
6052 sub dirname
6053 {
6054 local ($file) = @_;
6055 local ($sub);
6057 ($sub = $file) =~ s,/+[^/]+$,,g;
6058 $sub = '.' if $sub eq $file;
6059 return $sub;
6060 }
6062 # Return file name of a file.
6063 sub basename
6064 {
6065 local ($file) = @_;
6066 local ($sub);
6068 ($sub = $file) =~s,^.*/+,,g;
6069 return $sub;
6070 }
6072 # Touch a file.
6073 sub touch
6074 {
6075 local ($file) = @_;
6077 open (TOUCH, ">> $file");
6078 close (TOUCH);
6079 }
6081 # Glob something. Do this to avoid indentation screwups everywhere we
6082 # want to glob. Gross!
6083 sub my_glob
6084 {
6085 local ($pat) = @_;
6086 return <${pat}>;
6087 }
6089 ################################################################
6091 # Print an error message and set exit status.
6092 sub am_error
6093 {
6094 warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
6095 $exit_status = 1;
6096 }
6098 sub am_line_error
6099 {
6100 local ($symbol, @args) = @_;
6102 if ($symbol && "$symbol" ne '-1')
6103 {
6104 # If SYMBOL not already a line number, look it up in Makefile.am.
6105 if ($symbol =~ /^\d+$/)
6106 {
6107 $symbol .= ': ';
6108 }
6109 elsif (defined $content_lines{$symbol})
6110 {
6111 $symbol = $content_lines{$symbol} . ': ';
6112 }
6113 else
6114 {
6115 # A single space, to provide nice separation.
6116 $symbol = ' ';
6117 }
6118 warn "${am_file}.am:", $symbol, join (' ', @args), "\n";
6119 $exit_status = 1;
6120 }
6121 else
6122 {
6123 &am_error (@args);
6124 }
6125 }
6127 # Like am_error, but while scanning configure.in.
6128 sub am_conf_error
6129 {
6130 # FIXME: can run in subdirs.
6131 warn "automake: configure.in: ", join (' ', @_), "\n";
6132 $exit_status = 1;
6133 }
6135 # Error message with line number referring to configure.in.
6136 sub am_conf_line_error
6137 {
6138 local ($file, $line, @args) = @_;
6140 if ($line)
6141 {
6142 warn "$file: $line: ", join (' ', @args), "\n";
6143 $exit_status = 1;
6144 }
6145 else
6146 {
6147 &am_conf_error (@args);
6148 }
6149 }
6151 # Tell user where our aclocal.m4 is, but only once.
6152 sub keyed_aclocal_warning
6153 {
6154 local ($key) = @_;
6155 warn "automake: macro \`$key' can be generated by \`aclocal'\n";
6156 }
6158 # Print usage information.
6159 sub usage
6160 {
6161 print "Usage: automake [OPTION] ... [Makefile]...\n\n";
6162 print "Generate Makefile.in for autoconf from Makefile.am\n";
6163 print $USAGE;
6164 print "\nFiles which are automatically distributed, if found:\n";
6165 $~ = "USAGE_FORMAT";
6166 local (@lcomm) = sort ((@common_files, @common_sometimes));
6167 local ($one, $two, $three, $four);
6168 while (@lcomm > 0)
6169 {
6170 $one = shift @lcomm;
6171 $two = @lcomm ? shift @lcomm : '';
6172 $three = @lcomm ? shift @lcomm : '';
6173 $four = @lcomm ? shift @lcomm : '';
6174 write;
6175 }
6177 print "\nReport bugs to <automake-bugs\@gnu.ai.mit.edu>.\n";
6179 exit 0;
6180 }
6182 format USAGE_FORMAT =
6183 @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<
6184 $one, $two, $three, $four
6185 .