| blob | ceaaec34dd6fc62659e225fe08a5a7938f5252db |
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_CYGWIN32.
201 $seen_cygwin32 = 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 $output_rules .= $base . "_.c: $base.c\n\t"
924 . '$(ANSI2KNR) $< ' . $base . "_.c\n";
925 push (@objects, $base . '_.o');
926 push (@objects, $base . '_.lo') if $seen_libtool;
927 }
929 # Make all _.o (and _.lo) files depend on ansi2knr.
930 # Use a sneaky little hack to make it print nicely.
931 &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
932 }
934 #
935 # Last, handle some C cleanup.
936 #
937 if ($seen_c_source)
938 {
939 &define_configure_variable ('CFLAGS');
940 &define_variable ('COMPILE',
941 '$(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)');
942 &define_variable ('LTCOMPILE',
943 $ltcompile .
944 '$(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)')
945 if ($seen_libtool);
946 &define_variable ('LINK', $ltlink . '$(CC) $(CFLAGS) $(LDFLAGS) -o $@');
948 if (! defined $configure_vars{'CC'})
949 {
950 &am_line_error ($seen_c_source,
951 "C source seen but \`CC' not defined in \`configure.in'");
952 }
953 }
954 }
957 # Output a rule to build from a YACC source. The output from YACC is
958 # compiled with C or C++, depending on the extension of the YACC file.
959 sub output_yacc_build_rule
960 {
961 local ($yacc_suffix, $use_ylwrap, $c_suffix) = @_;
963 local ($c_suffix, $suffix);
964 ($c_suffix = $yacc_suffix) =~ tr/y/c/;
965 push (@suffixes, $yacc_suffix, $c_suffix, '.h');
967 # Generate rule for c/c++ and header file. Probably should only
968 # do header if `yacc -d' is run. But how can we determine that?
969 foreach $suffix ($c_suffix, '.h')
970 {
971 $output_rules .= "$yacc_suffix$suffix:\n\t";
973 if ($use_ylwrap)
974 {
975 $output_rules .= ('$(SHELL) $(YLWRAP)'
976 . ' "$(YACC)" $< y.tab.c $*' . $c_suffix
977 . ' y.tab.h $*.h -- $(YFLAGS)');
978 }
979 else
980 {
981 $output_rules .= ('$(YACC) $(YFLAGS) $< && mv y.tab.c $@' . "\n"
982 . "\tif test -f y.tab.h; then \\\n"
983 . "\tif cmp -s y.tab.h \$*.h; then rm -f y.tab.h; else mv y.tab.h \$*.h; fi; \\\n"
984 . "\telse :; fi");
985 }
986 $output_rules .= "\n";
987 }
988 }
990 sub output_lex_build_rule
991 {
992 local ($lex_suffix, $use_ylwrap) = @_;
993 local ($c_suffix);
995 ($c_suffix = $lex_suffix) =~ tr/l/c/;
996 push (@suffixes, $lex_suffix);
997 &define_configure_variable ('LEX_OUTPUT_ROOT');
998 &define_configure_variable ('LEXLIB');
999 $output_rules .= "$lex_suffix$c_suffix:\n\t";
1001 if ($use_ylwrap)
1002 {
1003 # Is the $@ correct here? If so, why not use it in the ylwrap
1004 # build rule for yacc above?
1005 $output_rules .= '$(SHELL) $(YLWRAP)'
1006 . ' "$(LEX)" $< $(LEX_OUTPUT_ROOT).c $@ -- $(LFLAGS)';
1007 }
1008 else
1009 {
1010 $output_rules .= '$(LEX) $(LFLAGS) $< && mv $(LEX_OUTPUT_ROOT).c $@';
1011 }
1012 $output_rules .= "\n";
1013 }
1016 # Check to make sure a source defined in LIBOBJS is not explicitly
1017 # mentioned. This is a separate function (as opposed to being inlined
1018 # in handle_source_transform) because it isn't always appropriate to
1019 # do this check.
1020 sub check_libobjs_sources
1021 {
1022 local ($one_file, $unxformed) = @_;
1024 local ($prefix, $file, @files);
1025 foreach $prefix ('', 'EXTRA_')
1026 {
1027 if (&variable_defined ($prefix . $one_file . '_SOURCES'))
1028 {
1029 @files = &variable_value_as_list (($prefix
1030 . $one_file . '_SOURCES'),
1031 'all');
1032 }
1033 elsif ($prefix eq '')
1034 {
1035 @files = ($unxformed . '.c');
1036 }
1037 else
1038 {
1039 next;
1040 }
1042 foreach $file (@files)
1043 {
1044 if (defined $libsources{$file})
1045 {
1046 &am_line_error ($prefix . $one_file . '_SOURCES',
1047 "automatically discovered file \`$file' should not be explicitly mentioned");
1048 }
1049 }
1050 }
1051 }
1053 # Does much of the actual work for handle_source_transform.
1054 # Arguments are:
1055 # list of source files to transform
1056 # Result is a list
1057 # first element is name of linker to use (empty string for default linker)
1058 # remaining elements are names of `.o's
1059 sub handle_single_transform_list
1060 {
1061 local (@files) = @_;
1062 local ($linker) = '';
1063 local (@result) = ();
1064 local ($nonansi_obj) = $obj;
1065 $nonansi_obj =~ s/_//g;
1066 if (length (@files))
1067 {
1068 # Turn sources into objects.
1069 foreach (@files)
1070 {
1071 # Skip header files, including C++-ish ones. The list
1072 # of C++ header extensions comes from Emacs 19.32
1073 # etags.
1074 next if /\.[hH]$/;
1075 next if /\.hxx$/;
1076 next if /\.h\+\+$/;
1077 next if /\.hh$/;
1078 next if /\.hpp$/;
1079 # Skip things that look like configure substitutions.
1080 next if /^\@.*\@$/;
1082 # Include appropriate file for lex or yacc source in
1083 # distribution. If the extension is the regular '.y' or
1084 # '.l', we assume C compilation, and the generated file
1085 # has exension .c. Otherwise, we compile with C++, and
1086 # make the following association: (yy -> cc, y++ -> c++,
1087 # yxx -> cxx), similarly for .ll, etc.
1088 if (/^(.*)\.(y|yy|y\+\+|yxx)$/)
1089 {
1090 # Yacc source.
1091 local ($ext) = $2;
1092 $ext =~ tr/y/c/;
1093 &push_dist_common ("$1.$ext");
1094 $yacc_sources{$_} = 1;
1095 }
1096 elsif (/^(.*)\.(l|ll|l\+\+|lxx)$/)
1097 {
1098 # Lex source.
1099 local ($ext) = $2;
1100 $ext =~ tr/l/c/;
1101 &push_dist_common ("$1.$ext");
1102 $lex_sources{$_} = 1;
1103 }
1105 # Strip any directory prefix.
1106 $_ = &basename ($_);
1108 # Transform source files into .o files. List of C++
1109 # extensions comes from Emacs 19.34 etags.
1110 if (s/\.(c\+\+|cc|cpp|cxx|C)$/$nonansi_obj/)
1111 {
1112 $cxx_extensions{'.' . $1} = 1;
1113 $linker = 'CXXLINK';
1114 }
1115 elsif (s/\.(yy|y\+\+|yxx|ll|l\+\+|lxx)$/$nonansi_obj/)
1116 {
1117 # Compiling lex or yacc with C++
1118 local ($ext) = $1;
1119 $ext =~ tr/ly/cc/;
1120 $cxx_extensions{".$ext"} = 1;
1121 $linker = 'CXXLINK';
1122 }
1123 elsif (s/\.([Ff]\\|f90\\|for)$/$nonansi_obj/)
1124 {
1125 # FORTRAN support. FIXME: not finished.
1126 }
1127 elsif (s/\.[sS]$/$nonansi_obj/)
1128 {
1129 # .s is assembly. Just rewrite it. FIXME: not finished.
1130 }
1131 elsif (defined ($options{'ansi2knr'}) && s/_\.[cly]$/_.c/)
1132 {
1133 # FIXME include line number in error.
1134 &am_error ("C source file \`$_' would be deleted by ansi2knr rules");
1135 }
1136 elsif (s/\.[cly]$//)
1137 {
1138 # .c is C. .l is lex. .y is yacc.
1140 # Note: first we rewrite (eg) foo.c to foo and push
1141 # the file onto the list of deansified files. Then we add
1142 # $obj, which can either be `_.o', or simply `.o' if
1143 # deansification is not required.
1144 $de_ansi_files{$_} = 1;
1145 $_ .= $obj;
1146 $seen_c_source = 1;
1147 }
1148 else
1149 {
1150 # No error message here. Used to have one, but it was
1151 # very unpopular.
1152 next;
1153 }
1155 push (@result, $_);
1157 # Transform .o or $o file into .P file (for automatic
1158 # dependency code).
1159 s/$objpat$/.P/g;
1160 $dep_files{'.deps/' . $_} = 1;
1161 }
1162 }
1164 return ($linker, @result);
1165 }
1167 # Handle SOURCE->OBJECT transform for one program or library.
1168 # Arguments are:
1169 # canonical (transformed) name of object to build
1170 # actual name of object to build
1171 # object extension (ie either `.o' or `$o'.
1172 # Return result is name of linker variable that must be used.
1173 # Empty return means just use `LINK'.
1174 sub handle_source_transform
1175 {
1176 # one_file is canonical name. unxformed is given name. obj is
1177 # object extension.
1178 local ($one_file, $unxformed, $obj) = @_;
1179 local ($objpat) = $obj;
1180 $objpat =~ s/(\W)/\\$1/g;
1181 # Handle explicit `.o' as well as whatever we're passed.
1182 $objpat = '(' . $objpat . "|\\.o)";
1184 local ($linker) = '';
1186 if (&variable_defined ($one_file . "_OBJECTS"))
1187 {
1188 &am_line_error ($one_file . '_OBJECTS',
1189 $one_file . '_OBJECTS', 'should not be defined');
1190 # No point in continuing.
1191 return;
1192 }
1194 local (@files, @result, $prefix, $temp);
1195 foreach $prefix ('', 'EXTRA_')
1196 {
1197 @files = ();
1198 local ($var) = $prefix . $one_file . "_SOURCES";
1199 if (&variable_defined ($var))
1200 {
1201 push (@sources, '$(' . $prefix . $one_file . "_SOURCES)");
1202 push (@objects, '$(' . $prefix . $one_file . "_OBJECTS)")
1203 unless $prefix eq 'EXTRA_';
1204 local (@conds) = &variable_conditions ($var);
1205 if (! @conds)
1206 {
1207 @files = &variable_value_as_list ($var, '');
1208 }
1209 else
1210 {
1211 local ($cond);
1212 foreach $cond (@conds)
1213 {
1214 @files = &variable_value_as_list ($var, $cond);
1215 ($temp, @result) = &handle_single_transform_list (@files);
1216 $linker = $temp if $linker eq '';
1217 &define_pretty_variable ($one_file . "_OBJECTS", $cond,
1218 @result)
1219 unless $prefix eq 'EXTRA_';
1220 }
1222 next;
1223 }
1224 }
1225 elsif ($prefix eq '')
1226 {
1227 &define_variable ($one_file . "_SOURCES", $unxformed . ".c");
1228 push (@sources, $unxformed . '.c');
1229 push (@objects, $unxformed . $obj);
1230 push (@files, $unxformed . '.c');
1231 }
1233 ($temp, @result) = &handle_single_transform_list (@files);
1234 $linker = $temp if $linker eq '';
1235 &define_pretty_variable ($one_file . "_OBJECTS", '', @result)
1236 unless $prefix eq 'EXTRA_';
1237 }
1239 return $linker;
1240 }
1242 # Handle the BUILT_SOURCES variable.
1243 sub handle_built_sources
1244 {
1245 return unless &variable_defined ('BUILT_SOURCES');
1247 local (@sources) = &variable_value_as_list ('BUILT_SOURCES', 'all');
1248 local ($s);
1249 foreach $s (@sources)
1250 {
1251 if (/^\@.*\@$/)
1252 {
1253 # FIXME: is this really the right thing to do?
1254 &am_line_error ('BUILT_SOURCES',
1255 "\`BUILT_SOURCES' should not contain a configure substitution");
1256 last;
1257 }
1258 }
1260 # We don't care about the return value of this function. We just
1261 # want to make sure to update %dep_files with the contents of
1262 # BUILT_SOURCES.
1263 &handle_single_transform_list (@sources);
1264 }
1266 # Special-case @ALLOCA@ and @LIBOBJS@ in _LDADD or _LIBADD variables.
1267 # Also, generate _DEPENDENCIES variable if appropriate.
1268 # Arguments are:
1269 # transformed name of object being built, or empty string if no object
1270 # name of _LDADD/_LIBADD-type variable to examine
1271 # boolean (lex_seen) which is true if a lex source file was seen in this
1272 # object. valid only for LDADDs, not LIBADDs. If set, LEXLIB
1273 # must be in LDADD.
1274 # Returns 1 if LIBOBJS seen, 0 otherwise.
1275 sub handle_lib_objects
1276 {
1277 local ($xname, $var, $lex_seen) = @_;
1278 local ($ret);
1280 die "automake: programming error 1 in handle_lib_objects\n"
1281 if ! &variable_defined ($var);
1283 die "automake: programming error 2 in handle_lib_objects\n"
1284 if $lex_seen && $var =~ /LIBADD/;
1286 local (@conds) = &variable_conditions ($var);
1287 if (! @conds)
1288 {
1289 $ret = &handle_lib_objects_cond ($xname, $var, $lex_seen, '');
1290 }
1291 else
1292 {
1293 local ($cond);
1294 $ret = 0;
1295 foreach $cond (@conds)
1296 {
1297 if (&handle_lib_objects_cond ($xname, $var, $lex_seen, $cond))
1298 {
1299 $ret = 1;
1300 }
1301 }
1302 }
1304 return $ret;
1305 }
1307 # Subroutine of handle_lib_objects: handle a particular condition.
1308 sub handle_lib_objects_cond
1309 {
1310 local ($xname, $var, $lex_seen, $cond) = @_;
1312 # We recognize certain things that are commonly put in LIBADD or
1313 # LDADD.
1314 local ($lsearch);
1315 local (@dep_list) = ();
1317 # If no lex source seen, just assume this is ok.
1318 local ($lex_ok) = $lex_seen ? 0 : 1;
1320 local ($seen_libobjs) = 0;
1321 local ($flagvar) = 0;
1323 foreach $lsearch (&variable_value_as_list ($var, $cond))
1324 {
1325 # Skip -lfoo and -Ldir; these are explicitly allowed.
1326 next if $lsearch =~ /^-[lL]/;
1327 if (! $flagvar && $lsearch =~ /^-/)
1328 {
1329 if ($var =~ /^(.*)LDADD$/)
1330 {
1331 &am_line_error ($var, "linker flags such as \`$lsearch' belong in \`${1}LDFLAGS");
1332 }
1333 else
1334 {
1335 # Only get this error once.
1336 $flagvar = 1;
1337 &am_line_error ($var, "you cannot use linker flags such as \`$lsearch' in \`$var'");
1338 }
1339 }
1341 # Assume we have a file of some sort, and push it onto the
1342 # dependency list. Autoconf substitutions are not pushed;
1343 # rarely is a new dependency substituted into (eg) foo_LDADD
1344 # -- but "bad things (eg -lX11) are routinely substituted.
1345 # Note that LIBOBJS and ALLOCA are exceptions to this rule,
1346 # and handled specially below.
1347 push (@dep_list, $lsearch)
1348 unless $lsearch =~ /^\@.*\@$/;
1350 # Automatically handle @LIBOBJS@ and @ALLOCA@. Basically this
1351 # means adding entries to dep_files.
1352 if ($lsearch =~ /^\@(LT)?LIBOBJS\@$/)
1353 {
1354 push (@dep_list, $lsearch);
1355 $seen_libobjs = 1;
1356 if (! keys %libsources)
1357 {
1358 &am_line_error ($var, "\@$1" . "LIBOBJS\@ seen but never set in \`configure.in'");
1359 }
1361 local ($iter, $rewrite);
1362 foreach $iter (keys %libsources)
1363 {
1364 if ($iter =~ /\.[cly]$/)
1365 {
1366 $seen_c_source = $var;
1367 }
1369 if ($iter =~ /\.h$/)
1370 {
1371 &require_file_with_line ($var, $FOREIGN, $iter);
1372 }
1373 elsif ($iter ne 'alloca.c')
1374 {
1375 ($rewrite = $iter) =~ s/\.c$/.P/;
1376 $dep_files{'.deps/' . $rewrite} = 1;
1377 &require_file_with_line ($var, $FOREIGN, $iter);
1378 }
1379 }
1380 }
1381 elsif ($lsearch =~ /^\@(LT)?ALLOCA\@$/)
1382 {
1383 push (@dep_list, $lsearch);
1384 &am_line_error ($var,
1385 "\@$1" . "ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
1386 if ! defined $libsources{'alloca.c'};
1387 $dep_files{'.deps/alloca.P'} = 1;
1388 &require_file_with_line ($var, $FOREIGN, 'alloca.c');
1389 $seen_c_source = $var;
1390 }
1391 elsif ($lsearch eq '@LEXLIB@')
1392 {
1393 # FIXME: variable_value_as_list requires us to force
1394 # @LEXLIB@ here, where we'd really prefer $(LEXLIB).
1395 # Nasty -- this will have to wait until many cleanups are
1396 # made, I think.
1397 $lex_ok = 1;
1398 }
1399 }
1401 if (! $lex_ok)
1402 {
1403 &am_line_error ($var, 'lex source file used without @LEXLIB@');
1404 }
1406 if ($xname ne '' && ! &variable_defined ($xname . '_DEPENDENCIES', $cond))
1407 {
1408 &define_pretty_variable ($xname . '_DEPENDENCIES', $cond, @dep_list);
1409 }
1411 return $seen_libobjs;
1412 }
1414 # Canonicalize a name, and check to make sure the non-canonical name
1415 # is never used. Returns canonical name. Arguments are name and a
1416 # list of suffixes to check for.
1417 sub check_canonical_spelling
1418 {
1419 local ($name, @suffixes) = @_;
1420 local ($xname, $xt);
1422 ($xname = $name) =~ tr/A-Za-z0-9_/_/c;
1423 if ($xname ne $name)
1424 {
1425 local ($xt);
1426 foreach $xt (@suffixes)
1427 {
1428 &am_line_error ($name . $xt,
1429 "invalid variable \`" . $name . $xt
1430 . "'; should be \`" . $xname . $xt . "'")
1431 if &variable_defined ($name . $xt);
1432 }
1433 }
1435 return $xname;
1436 }
1438 # Handle C programs.
1439 sub handle_programs
1440 {
1441 local (@proglist) = &am_install_var ('-clean',
1442 'progs', 'PROGRAMS',
1443 'bin', 'sbin', 'libexec', 'pkglib',
1444 'noinst', 'check');
1445 return if ! @proglist;
1447 # If a program is installed, this is required. We only want this
1448 # error to appear once.
1449 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1450 unless $seen_arg_prog;
1451 $seen_arg_prog = 1;
1453 local ($one_file, $xname, $munge);
1455 local ($seen_libobjs) = 0;
1456 foreach $one_file (@proglist)
1457 {
1458 local ($obj) = &get_object_extension ($one_file);
1460 # Canonicalize names and check for misspellings.
1461 $xname = &check_canonical_spelling ($one_file, '_LDADD', '_LDFLAGS',
1462 '_SOURCES', '_OBJECTS',
1463 '_DEPENDENCIES');
1465 # FIXME: Using a trick to figure out if any lex sources appear
1466 # in our program; should use some cleaner method.
1467 local ($lex_num) = scalar (keys %lex_sources);
1468 local ($linker) = &handle_source_transform ($xname, $one_file, $obj);
1469 local ($lex_file_seen) = (scalar (keys %lex_sources) > $lex_num);
1471 local ($xt) = '';
1472 if (&variable_defined ($xname . "_LDADD"))
1473 {
1474 if (&handle_lib_objects ($xname, $xname . '_LDADD',
1475 $lex_file_seen))
1476 {
1477 $seen_libobjs = 1;
1478 }
1479 $lex_file_seen = 0;
1480 $xt = '_LDADD';
1481 }
1482 else
1483 {
1484 # User didn't define prog_LDADD override. So do it.
1485 &define_variable ($xname . '_LDADD', '$(LDADD)');
1487 # This does a bit too much work. But we need it to
1488 # generate _DEPENDENCIES when appropriate.
1489 if (&variable_defined ('LDADD'))
1490 {
1491 if (&handle_lib_objects ($xname, 'LDADD', $lex_file_seen))
1492 {
1493 $seen_libobjs = 1;
1494 }
1495 $lex_file_seen = 0;
1496 }
1497 $xt = '_SOURCES'
1498 }
1500 if (&variable_defined ($xname . '_LIBADD'))
1501 {
1502 &am_line_error ($xname . '_LIBADD',
1503 "use \`" . $xname . "_LDADD', not \`"
1504 . $xname . "_LIBADD'");
1505 }
1507 if (! &variable_defined ($xname . '_LDFLAGS'))
1508 {
1509 # Define the prog_LDFLAGS variable.
1510 &define_variable ($xname . '_LDFLAGS', '');
1511 }
1513 if ($lex_file_seen)
1514 {
1515 &am_line_error ($xname . $xt,
1516 'lex source file used without @LEXLIB@');
1517 }
1519 # Determine program to use for link.
1520 local ($xlink);
1521 if (&variable_defined ($xname . '_LINK'))
1522 {
1523 $xlink = $xname . '_LINK';
1524 }
1525 else
1526 {
1527 $xlink = $linker ? $linker : 'LINK';
1528 }
1530 local ($cygxform);
1531 if (! $seen_cygwin32)
1532 {
1533 $cygxform = 's/^CYGWIN.*$//; s/^NOTCYGWIN//;';
1534 }
1535 else
1536 {
1537 $cygxform = 's/^NOTCYGWIN.*$//; s/^CYGWIN//;';
1538 }
1540 $output_rules .=
1541 &file_contents_with_transform
1542 ('s/\@PROGRAM\@/' . $one_file . '/go;'
1543 . 's/\@XPROGRAM\@/' . $xname . '/go;'
1544 . 's/\@XLINK\@/' . $xlink . '/go;'
1545 . $cygxform,
1546 'program');
1547 }
1549 if (&variable_defined ('LDADD') && &handle_lib_objects ('', 'LDADD', 0))
1550 {
1551 $seen_libobjs = 1;
1552 }
1554 if ($seen_libobjs)
1555 {
1556 foreach $one_file (@proglist)
1557 {
1558 # Canonicalize names.
1559 ($xname = $one_file) =~ tr/A-Za-z0-9_/_/c;
1561 if (&variable_defined ($xname . '_LDADD'))
1562 {
1563 &check_libobjs_sources ($xname, $xname . '_LDADD');
1564 }
1565 elsif (&variable_defined ('LDADD'))
1566 {
1567 &check_libobjs_sources ($xname, 'LDADD');
1568 }
1569 }
1570 }
1571 }
1574 # Handle libraries.
1575 sub handle_libraries
1576 {
1577 local (@liblist) = &am_install_var ('-clean',
1578 'libs', 'LIBRARIES',
1579 'lib', 'pkglib', 'noinst', 'check');
1580 return if ! @liblist;
1582 local (%valid) = &am_primary_prefixes ('LIBRARIES', 'lib', 'pkglib',
1583 'noinst', 'check');
1584 if (! defined $configure_vars{'RANLIB'})
1585 {
1586 local ($key);
1587 foreach $key (keys %valid)
1588 {
1589 if (&variable_defined ($key . '_LIBRARIES'))
1590 {
1591 &am_line_error ($key . '_LIBRARIES', "library used but \`RANLIB' not defined in \`configure.in'");
1592 # Only get this error once.
1593 $configure_vars{'RANLIB'} = 1;
1594 last;
1595 }
1596 }
1597 }
1599 local ($onelib);
1600 local ($munge);
1601 local ($xlib);
1602 local ($seen_libobjs) = 0;
1603 foreach $onelib (@liblist)
1604 {
1605 # Check that the library fits the standard naming convention.
1606 if ($onelib !~ /^lib.*\.a$/)
1607 {
1608 # FIXME this should only be a warning for foreign packages
1609 # FIXME should put line number here. That means mapping
1610 # from library name back to variable name.
1611 &am_error ("\`$onelib' is not a standard library name");
1612 }
1614 local ($obj) = &get_object_extension ($onelib);
1616 # Canonicalize names and check for misspellings.
1617 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
1618 '_OBJECTS', '_DEPENDENCIES');
1620 if (&variable_defined ($xlib . '_LIBADD'))
1621 {
1622 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
1623 {
1624 $seen_libobjs = 1;
1625 }
1626 }
1627 else
1628 {
1629 # Generate support for conditional object inclusion in
1630 # libraries.
1631 &define_variable ($xlib . "_LIBADD", '');
1632 }
1634 if (&variable_defined ($xlib . '_LDADD'))
1635 {
1636 &am_line_error ($xlib . '_LDADD',
1637 "use \`" . $xlib . "_LIBADD', not \`"
1638 . $xlib . "_LDADD'");
1639 }
1641 &handle_source_transform ($xlib, $onelib, $obj);
1643 $output_rules .=
1644 &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go;'
1645 . 's/\@XLIBRARY\@/'
1646 . $xlib . '/go;',
1647 'library');
1648 }
1650 if ($seen_libobjs)
1651 {
1652 foreach $onelib (@liblist)
1653 {
1654 # Canonicalize names.
1655 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1656 if (&variable_defined ($xlib . '_LIBADD'))
1657 {
1658 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
1659 }
1660 }
1661 }
1663 &define_variable ('AR', 'ar');
1664 &define_configure_variable ('RANLIB');
1665 }
1667 # Handle shared libraries.
1668 sub handle_ltlibraries
1669 {
1670 local (@liblist) = &am_install_var ('-clean',
1671 'ltlib', 'LTLIBRARIES',
1672 'lib', 'pkglib');
1673 return if ! @liblist;
1675 local (%instdirs);
1676 local (%valid) = &am_primary_prefixes ('LTLIBRARIES', 'lib', 'pkglib');
1678 local ($key);
1679 foreach $key (keys %valid)
1680 {
1681 if (&variable_defined ($key . '_LTLIBRARIES'))
1682 {
1683 if (!$seen_libtool)
1684 {
1685 &am_line_error ($key . '_LTLIBRARIES', "library used but \`LIBTOOL' not defined in \`configure.in'");
1686 # Only get this error once.
1687 $configure_vars{'LIBTOOL'} = 1;
1688 $seen_libtool = 1;
1689 }
1691 # Get the installation directory of each library.
1692 for (&variable_value_as_list ($key . '_LTLIBRARIES', 'all'))
1693 {
1694 if ($instdirs{$_})
1695 {
1696 &am_error ("\`$_' is already going to be installed in \`$instdirs{$_}'");
1697 }
1698 else
1699 {
1700 $instdirs{$_} = $key;
1701 }
1702 }
1703 }
1704 }
1706 local ($onelib);
1707 local ($munge);
1708 local ($xlib);
1709 local ($seen_libobjs) = 0;
1710 foreach $onelib (@liblist)
1711 {
1712 # Check that the library fits the standard naming convention.
1713 if ($onelib !~ /^lib.*\.la$/)
1714 {
1715 # FIXME this should only be a warning for foreign packages
1716 # FIXME should put line number here. That means mapping
1717 # from library name back to variable name.
1718 &am_error ("\`$onelib' is not a standard libtool library name");
1719 }
1721 local ($obj) = &get_object_extension ($onelib);
1723 # Canonicalize names and check for misspellings.
1724 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
1725 '_SOURCES', '_OBJECTS',
1726 '_DEPENDENCIES');
1728 if (! &variable_defined ($xlib . '_LDFLAGS'))
1729 {
1730 # Define the lib_LDFLAGS variable.
1731 &define_variable ($xlib . '_LDFLAGS', '');
1732 }
1734 if (&variable_defined ($xlib . '_LIBADD'))
1735 {
1736 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
1737 {
1738 $seen_libobjs = 1;
1739 }
1740 }
1741 else
1742 {
1743 # Generate support for conditional object inclusion in
1744 # libraries.
1745 &define_variable ($xlib . "_LIBADD", '');
1746 }
1748 if (&variable_defined ($xlib . '_LDADD'))
1749 {
1750 &am_line_error ($xlib . '_LDADD',
1751 "use \`" . $xlib . "_LIBADD', not \`"
1752 . $xlib . "_LDADD'");
1753 }
1755 local ($linker) = &handle_source_transform ($xlib, $onelib, $obj);
1757 # Determine program to use for link.
1758 local ($xlink);
1759 if (&variable_defined ($xlib . '_LINK'))
1760 {
1761 $xlink = $xlib . '_LINK';
1762 }
1763 else
1764 {
1765 $xlink = $linker ? $linker : 'LINK';
1766 }
1768 local ($rpath);
1769 if ($instdirs{$onelib} eq 'EXTRA')
1770 {
1771 # It's an EXTRA_ library, so we can't specify -rpath.
1772 # Yuck.
1773 $rpath = 's/\@RPATH\@//go;';
1774 }
1775 else
1776 {
1777 $rpath = ('s/\@RPATH\@/-rpath \$(' . $instdirs{$onelib}
1778 . 'dir)/go;');
1779 }
1781 $output_rules .=
1782 &file_contents_with_transform ('s/\@LTLIBRARY\@/'
1783 . $onelib . '/go;'
1784 . 's/\@XLTLIBRARY\@/'
1785 . $xlib . '/go;'
1786 . $rpath
1787 . 's/\@XLINK\@/' . $xlink . '/go;',
1788 'ltlibrary');
1789 }
1791 if ($seen_libobjs)
1792 {
1793 foreach $onelib (@liblist)
1794 {
1795 # Canonicalize names.
1796 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1797 if (&variable_defined ($xlib . '_LIBADD'))
1798 {
1799 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
1800 }
1801 }
1802 }
1803 }
1805 # See if any _SOURCES variable were misspelled. Also, make sure that
1806 # EXTRA_ variables don't contain configure substitutions.
1807 sub check_typos
1808 {
1809 local ($varname, $primary);
1810 foreach $varname (keys %contents)
1811 {
1812 foreach $primary ('_SOURCES', '_LIBADD', '_LDADD', '_LDFLAGS', '_DEPENDENCIES')
1813 {
1814 if ($varname =~ /$primary$/ && ! $content_seen{$varname})
1815 {
1816 &am_line_error ($varname,
1817 "invalid unused variable name: \`$varname'");
1818 }
1819 }
1820 }
1821 }
1823 # Handle scripts.
1824 sub handle_scripts
1825 {
1826 # NOTE we no longer automatically clean SCRIPTS, because it is
1827 # useful to sometimes distribute scripts verbatim. This happens
1828 # eg in Automake itself.
1829 &am_install_var ('scripts', 'SCRIPTS',
1830 'bin', 'sbin', 'libexec', 'pkgdata',
1831 'noinst', 'check');
1833 # Set $scripts_installed if appropriate. Make sure we only find
1834 # scripts which are actually installed -- this is why we can't
1835 # simply use the return value of am_install_var.
1836 local (%valid) = &am_primary_prefixes ('SCRIPTS', 'bin', 'sbin',
1837 'libexec', 'pkgdata',
1838 'noinst', 'check');
1839 local ($key);
1840 foreach $key (keys %valid)
1841 {
1842 if ($key ne 'noinst'
1843 && $key ne 'check'
1844 && &variable_defined ($key . '_SCRIPTS'))
1845 {
1846 $scripts_installed = 1;
1847 # push (@check_tests, 'check-' . $key . 'SCRIPTS');
1848 }
1849 }
1851 if ($scripts_installed)
1852 {
1853 # If a program is installed, this is required. We only want this
1854 # error to appear once.
1855 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1856 unless $seen_arg_prog;
1857 $seen_arg_prog = 1;
1858 }
1859 }
1861 # Search a file for a "version.texi" Texinfo include. Return the name
1862 # of the include file if found, or the empty string if not. A
1863 # "version.texi" file is actually any file whose name matches
1864 # "vers*.texi".
1865 sub scan_texinfo_file
1866 {
1867 local ($filename) = @_;
1869 if (! open (TEXI, $filename))
1870 {
1871 &am_error ("couldn't open \`$filename': $!");
1872 return '';
1873 }
1874 print "automake: reading $filename\n" if $verbose;
1876 local ($vfile, $outfile);
1877 while (<TEXI>)
1878 {
1879 if (/^\@setfilename +(\S+)/)
1880 {
1881 $outfile = $1;
1882 last if ($vfile);
1883 }
1885 if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
1886 {
1887 # Found version.texi include.
1888 $vfile = $1;
1889 last if $outfile;
1890 }
1891 }
1893 close (TEXI);
1894 return ($outfile, $vfile);
1895 }
1897 # Handle all Texinfo source.
1898 sub handle_texinfo
1899 {
1900 &am_line_error ('TEXINFOS',
1901 "\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
1902 if &variable_defined ('TEXINFOS');
1903 return if (! &variable_defined ('info_TEXINFOS')
1904 && ! &variable_defined ('html_TEXINFOS'));
1906 local (@texis) = &variable_value_as_list ('info_TEXINFOS', 'all');
1908 local (@info_deps_list, @dvis_list, @texi_deps);
1909 local ($infobase, $info_cursor);
1910 local (%versions);
1911 local ($done) = 0;
1912 local ($vti);
1913 local ($tc_cursor, @texi_cleans);
1914 local ($canonical);
1916 foreach $info_cursor (@texis)
1917 {
1918 ($infobase = $info_cursor) =~ s/\.texi(nfo)?$//;
1920 # If 'version.texi' is referenced by input file, then include
1921 # automatic versioning capability.
1922 local ($out_file, $vtexi) = &scan_texinfo_file ($relative_dir
1923 . "/" . $info_cursor);
1925 if ($out_file eq '')
1926 {
1927 &am_error ("\`$info_cursor' missing \@setfilename");
1928 next;
1929 }
1931 if ($out_file =~ /\.(.+)$/ && $1 ne 'info')
1932 {
1933 # FIXME should report line number in input file.
1934 &am_error ("output of \`$info_cursor', \`$out_file', has unrecognized extension");
1935 next;
1936 }
1938 if ($vtexi)
1939 {
1940 &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
1941 if (defined $versions{$vtexi});
1942 $versions{$vtexi} = $info_cursor;
1944 # We number the stamp-vti files. This is doable since the
1945 # actual names don't matter much. We only number starting
1946 # with the second one, so that the common case looks nice.
1947 $vti = 'vti' . ($done ? $done : '');
1948 &push_dist_common ($vtexi, 'stamp-' . $vti);
1949 push (@clean, $vti);
1951 # Only require once.
1952 &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
1953 'mdate-sh')
1954 if ! $done;
1955 ++$done;
1957 local ($conf_pat);
1958 ($conf_pat = $config_aux_dir) =~ s/(\W)/\\$1/g;
1959 $output_rules .=
1960 &file_contents_with_transform
1961 ('s/\@TEXI\@/' . $info_cursor . '/g; '
1962 . 's/\@VTI\@/' . $vti . '/g; '
1963 . 's/\@VTEXI\@/' . $vtexi . '/g;'
1964 . 's,\@MDDIR\@,' . $conf_pat . ',g;',
1965 'texi-vers');
1967 &push_phony_cleaners ($vti);
1968 }
1970 # If user specified file_TEXINFOS, then use that as explicit
1971 # dependency list.
1972 @texi_deps = ();
1973 push (@texi_deps, $info_cursor);
1974 push (@texi_deps, $vtexi) if $vtexi;
1976 # Canonicalize name first.
1977 ($canonical = $infobase) =~ tr/A-Za-z0-9_/_/c;
1978 if (&variable_defined ($canonical . "_TEXINFOS"))
1979 {
1980 push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
1981 &push_dist_common ('$(' . $canonical . '_TEXINFOS)');
1982 }
1984 $output_rules .= ("\n" . $out_file . ": "
1985 . join (' ', @texi_deps)
1986 . "\n" . $infobase . ".dvi: "
1987 . join (' ', @texi_deps)
1988 . "\n\n");
1990 push (@info_deps_list, $out_file);
1991 push (@dvis_list, $infobase . '.dvi');
1993 # Generate list of things to clean for this target. We do
1994 # this explicitly because otherwise too many things could be
1995 # removed. In particular the ".log" extension might
1996 # reasonably be used in other contexts by the user.
1997 foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns',
1998 'ky', 'log', 'pg', 'toc', 'tp', 'tps',
1999 'vr', 'vrs', 'op', 'tr', 'cv')
2000 {
2001 push (@texi_cleans, $infobase . '.' . $tc_cursor);
2002 }
2003 }
2005 # Find these programs wherever they may lie. Yes, this has
2006 # intimate knowledge of the structure of the texinfo distribution.
2007 &define_program_variable ('MAKEINFO', 'build', 'texinfo/makeinfo',
2008 'makeinfo',
2009 # Circumlocution to avoid accidental
2010 # configure substitution.
2011 '@MAKE' . 'INFO@');
2012 &define_program_variable ('TEXI2DVI', 'src', 'texinfo/util',
2013 'texi2dvi');
2015 # Set transform for including texinfos.am. First, handle --cygnus
2016 # stuff.
2017 local ($xform);
2018 if ($cygnus_mode)
2019 {
2020 $xform = 's/^NOTCYGNUS.*$//; s/^CYGNUS//;';
2021 }
2022 else
2023 {
2024 $xform = 's/^CYGNUS.*$//; s/^NOTCYGNUS//;';
2025 }
2027 # Handle location of texinfo.tex.
2028 if ($cygnus_mode)
2029 {
2030 &define_variable ('TEXINFO_TEX',
2031 '$(top_srcdir)/../texinfo/texinfo.tex');
2032 }
2033 elsif ($config_aux_dir ne '.' && $config_aux_dir ne '')
2034 {
2035 &define_variable ('TEXINFO_TEX', $config_aux_dir . '/texinfo.tex');
2036 }
2037 elsif (! &variable_defined ('TEXINFO_TEX'))
2038 {
2039 &define_variable ('TEXINFO_TEX', '$(srcdir)/texinfo.tex');
2040 }
2041 local ($xxform) = &dirname (&variable_value ('TEXINFO_TEX'));
2042 $xxform =~ s/(\W)/\\$1/g;
2043 $xform .= ' s/\@TEXINFODIR\@/' . $xxform . '/g;';
2045 $output_rules .= &file_contents_with_transform ($xform, 'texinfos');
2046 push (@phony, 'install-info-am', 'uninstall-info');
2047 push (@dist_targets, 'dist-info');
2049 # How to clean. The funny name is due to --cygnus influence; in
2050 # Cygnus mode, `clean-info' is a target that users can use.
2051 $output_rules .= "\nmostlyclean-aminfo:\n";
2052 &pretty_print_rule ("\trm -f", "\t ", @texi_cleans);
2053 $output_rules .= ("\nclean-aminfo:\n\ndistclean-aminfo:\n\n"
2054 . "maintainer-clean-aminfo:\n\t"
2055 . 'for i in $(INFO_DEPS); do rm -f `eval echo $$i*`; done'
2056 . "\n");
2057 &push_phony_cleaners ('aminfo');
2058 if ($cygnus_mode)
2059 {
2060 $output_rules .= "clean-info: mostlyclean-aminfo\n";
2061 }
2063 push (@suffixes, '.texi', '.texinfo', '.info', '.dvi', '.ps');
2065 if (! defined $options{'no-installinfo'})
2066 {
2067 push (@uninstall, 'uninstall-info');
2068 push (@installdirs, '$(infodir)');
2069 unshift (@install_data, 'install-info-am');
2071 # Make sure documentation is made and installed first. Use
2072 # $(INFO_DEPS), not 'info', because otherwise recursive makes
2073 # get run twice during "make all".
2074 unshift (@all, '$(INFO_DEPS)');
2075 }
2076 push (@clean, 'aminfo');
2077 push (@info, '$(INFO_DEPS)');
2078 push (@dvi, '$(DVIS)');
2080 &define_variable ("INFO_DEPS", join (' ', @info_deps_list));
2081 &define_variable ("DVIS", join (' ', @dvis_list));
2082 # This next isn't strictly needed now -- the places that look here
2083 # could easily be changed to look in info_TEXINFOS. But this is
2084 # probably better, in case noinst_TEXINFOS is ever supported.
2085 &define_variable ("TEXINFOS", &variable_value ('info_TEXINFOS'));
2087 # Do some error checking. Note that this file is not required
2088 # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
2089 # up above.
2090 &require_file_with_line ('info_TEXINFOS', $FOREIGN, 'texinfo.tex')
2091 unless (defined $options{'no-texinfo.tex'}
2092 || &variable_defined ('TEXINFO_TEX'));
2093 }
2095 # Handle any man pages.
2096 sub handle_man_pages
2097 {
2098 &am_line_error ('MANS', "\`MANS' is an anachronism; use \`man_MANS'")
2099 if &variable_defined ('MANS');
2100 return if ! &variable_defined ('man_MANS');
2102 # We generate the manpage install code by hand to avoid the use of
2103 # basename in the generated Makefile.
2104 local (@mans) = &variable_value_as_list ('man_MANS', 'all');
2105 local (%sections, %inames, %mbases, %secmap, %fullsecmap);
2106 local ($i) = 1;
2107 foreach (@mans)
2108 {
2109 # FIXME: statement without effect:
2110 /^(.*)\.([0-9])([a-z]*)$/;
2111 $sections{$2} = 1;
2112 $inames{$i} = $_;
2113 $mbases{$i} = $1;
2114 $secmap{$i} = $2;
2115 $fullsecmap{$i} = $2 . $3;
2116 $i++;
2117 }
2119 # We don't really need this, but we use it in case we ever want to
2120 # support noinst_MANS.
2121 &define_variable ("MANS", &variable_value ('man_MANS'));
2123 # Generate list of install dirs.
2124 $output_rules .= "install-man: \$(MANS)\n";
2125 $output_rules .= "\t\$(NORMAL_INSTALL)\n";
2126 # Sort keys so that output is deterministic.
2127 foreach (sort keys %sections)
2128 {
2129 push (@installdirs, '$(mandir)/man' . $_)
2130 unless defined $options{'no-installman'};
2131 $output_rules .= ("\t" . '$(mkinstalldirs) $(mandir)/man'
2132 . $_ . "\n");
2133 }
2134 push (@phony, 'install-man');
2136 # Generate install target.
2137 local ($key);
2138 foreach $key (sort keys %inames)
2139 {
2140 $_ = $install_man_format;
2141 s/\@SECTION\@/$secmap{$key}/g;
2142 s/\@MAN\@/$inames{$key}/g;
2143 s/\@FULLSECT\@/$fullsecmap{$key}/g;
2144 s/\@MANBASE\@/$mbases{$key}/g;
2145 $output_rules .= $_;
2146 }
2147 $output_rules .= "\n";
2149 $output_rules .= "uninstall-man:\n\t\$(NORMAL_UNINSTALL)\n";
2150 foreach $key (sort keys %inames)
2151 {
2152 $_ = $uninstall_man_format;
2153 s/\@SECTION\@/$secmap{$key}/g;
2154 s/\@MAN\@/$inames{$key}/g;
2155 s/\@FULLSECT\@/$fullsecmap{$key}/g;
2156 s/\@MANBASE\@/$mbases{$key}/g;
2157 $output_rules .= $_;
2158 }
2159 $output_rules .= "\n";
2160 push (@phony, 'uninstall-man');
2162 $output_vars .= &file_contents ('mans-vars');
2164 if (! defined $options{'no-installman'})
2165 {
2166 push (@install_data, 'install-man');
2167 push (@uninstall, 'uninstall-man');
2168 push (@all, '$(MANS)');
2169 }
2170 }
2172 # Handle DATA variables.
2173 sub handle_data
2174 {
2175 &am_install_var ('data', 'DATA', 'data', 'sysconf',
2176 'sharedstate', 'localstate', 'pkgdata',
2177 'noinst', 'check');
2178 }
2180 # Handle TAGS.
2181 sub handle_tags
2182 {
2183 push (@phony, 'tags');
2184 local (@tag_deps) = ();
2185 if (&variable_defined ('SUBDIRS'))
2186 {
2187 $output_rules .= ("tags-recursive:\n"
2188 . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
2189 # Never fail here if a subdir fails; it
2190 # isn't important.
2191 . "\t (cd \$\$subdir && \$(MAKE) tags); \\\n"
2192 . "\tdone\n");
2193 push (@tag_deps, 'tags-recursive');
2194 push (@phony, 'tags-recursive');
2195 }
2197 if ($dir_holds_sources
2198 || $dir_holds_headers
2199 || &variable_defined ('ETAGS_ARGS')
2200 || @tag_deps)
2201 {
2202 local ($xform) = '';
2203 local ($one_hdr);
2204 foreach $one_hdr (@config_headers)
2205 {
2206 if ($relative_dir eq &dirname ($one_hdr))
2207 {
2208 # The config header is in this directory. So require it.
2209 local ($var);
2210 ($var = &basename ($one_hdr)) =~ s/(\W)/\\$1/g;
2211 $xform .= ' ' if $xform;
2212 $xform .= $var;
2213 }
2214 }
2215 $xform = ('s/\@CONFIG\@/' . $xform . '/;'
2216 . 's/\@DIRS\@/' . join (' ', @tag_deps) . '/;');
2218 if (&variable_defined ('SUBDIRS'))
2219 {
2220 $xform .= 's/^SUBDIRS//;';
2221 }
2222 else
2223 {
2224 $xform .= 's/^SUBDIRS.*$//;';
2225 }
2227 $output_rules .= &file_contents_with_transform ($xform, 'tags');
2228 $output_rules .= &file_contents ('tags-clean');
2229 push (@clean, 'tags');
2230 &push_phony_cleaners ('tags');
2231 &examine_variable ('TAGS_DEPENDENCIES');
2232 }
2233 elsif (&variable_defined ('TAGS_DEPENDENCIES'))
2234 {
2235 &am_line_error ('TAGS_DEPENDENCIES',
2236 "doesn't make sense to define \`TAGS_DEPENDENCIES' without sources or \`ETAGS_ARGS'");
2237 }
2238 else
2239 {
2240 # Every Makefile must define some sort of TAGS rule.
2241 # Otherwise, it would be possible for a top-level "make TAGS"
2242 # to fail because some subdirectory failed.
2243 $output_rules .= "tags: TAGS\nTAGS:\n\n";
2244 }
2245 }
2247 # Worker for handle_dist.
2248 sub handle_dist_worker
2249 {
2250 local ($makefile) = @_;
2252 $output_rules .= 'distdir: $(DISTFILES)' . "\n";
2254 # Initialization; only at top level.
2255 if ($relative_dir eq '.')
2256 {
2257 if ($strictness >= $GNITS)
2258 {
2259 # For Gnits users, this is pretty handy. Look at 15 lines
2260 # in case some explanatory text is desirable.
2261 $output_rules .= ' @if sed 15q $(srcdir)/NEWS | fgrep -e "$(VERSION)" > /dev/null; then :; else \\
2262 echo "NEWS not updated; not releasing" 1>&2; \\
2263 exit 1; \\
2264 fi
2265 ';
2266 }
2269 # Create dist directory.
2270 $output_rules .= ("\trm -rf \$(distdir)\n"
2271 . "\tmkdir \$(distdir)\n"
2272 . "\t-chmod 777 \$(distdir)\n");
2273 }
2275 # Only run automake in `dist' target if --include-deps and
2276 # `no-dependencies' not specified. That way the recipient of a
2277 # distribution can run "make dist" and not need Automake. You
2278 # might be wondering why we run automake once for each directory
2279 # we distribute, instead of running it once at the top level. The
2280 # answer is that we want to run automake after the dependencies
2281 # have been generated. This occurs when "make" is run in the
2282 # subdir. So automake must be run after make has updated the
2283 # Makefile, which means that it must run once per directory.
2284 if ($use_dependencies)
2285 {
2286 $output_rules .=
2287 (
2288 # We need an absolute path for --output-dir. Thus the
2289 # weirdness.
2290 "\t" . 'here=`cd $(top_builddir) && pwd`; ' . "\\\n"
2291 . "\t" . 'top_distdir=`cd $(top_distdir) && pwd`; ' . "\\\n"
2292 . "\tcd \$(top_srcdir) \\\n"
2293 . "\t && \$(AUTOMAKE) --include-deps --build-dir=\$\$here --srcdir-name=\$(top_srcdir) --output-dir=\$\$top_distdir "
2294 # Set strictness of output.
2295 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
2296 . ($cmdline_use_dependencies ? '' : ' --include-deps')
2297 . " " . $makefile . "\n"
2298 );
2299 }
2301 # Scan EXTRA_DIST to see if we need to distribute anything from a
2302 # subdir. If so, add it to the list. I didn't want to do this
2303 # originally, but there were so many requests that I finally
2304 # relented.
2305 local (@dist_dirs);
2306 if (&variable_defined ('EXTRA_DIST'))
2307 {
2308 # FIXME: This should be fixed to work with conditionals. That
2309 # will require only making the entries in @dist_dirs under the
2310 # appropriate condition. This is meaningful if the nature of
2311 # the distribution should depend upon the configure options
2312 # used.
2313 foreach (&variable_value_as_list ('EXTRA_DIST', ''))
2314 {
2315 next if /^\@.*\@$/;
2316 next unless s,/+[^/]+$,,;
2317 push (@dist_dirs, $_)
2318 unless $_ eq '.';
2319 }
2320 }
2321 if (@dist_dirs)
2322 {
2323 # Prepend $(distdir) to each directory given. Doing it via a
2324 # hash lets us ensure that each directory is used only once.
2325 local (%dhash);
2326 grep ($dhash{'$(distdir)/' . $_} = 1, @dist_dirs);
2327 $output_rules .= "\t";
2328 &pretty_print_rule ('$(mkinstalldirs)', "\t ", sort keys %dhash);
2329 }
2331 # In loop, test for file existence because sometimes a file gets
2332 # included in DISTFILES twice. For example this happens when a
2333 # single source file is used in building more than one program.
2334 # Also, there are situations in which "ln" can fail. For instance
2335 # a file to distribute could actually be a cross-filesystem
2336 # symlink -- this can easily happen if "gettextize" was run on the
2337 # distribution.
2338 $output_rules .= "\t\@for file in \$(DISTFILES); do \\\n";
2339 if ($cygnus_mode)
2340 {
2341 $output_rules .= "\t if test -f \$\$file; then d=.; else d=\$(srcdir); fi; \\\n";
2342 }
2343 else
2344 {
2345 $output_rules .= "\t d=\$(srcdir); \\\n";
2346 }
2347 $output_rules .= ' test -f $(distdir)/$$file \\
2348 || ln $$d/$$file $(distdir)/$$file 2> /dev/null \\
2349 || cp -p $$d/$$file $(distdir)/$$file; \\
2350 done
2351 ';
2353 # If we have SUBDIRS, create all dist subdirectories and do
2354 # recursive build.
2355 if (&variable_defined ('SUBDIRS'))
2356 {
2357 # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
2358 # to all possible directories, and use it.
2359 if (! &variable_conditions ('SUBDIRS'))
2360 {
2361 $dist_subdir_name = 'SUBDIRS';
2362 }
2363 else
2364 {
2365 $dist_subdir_name = 'DIST_SUBDIRS';
2366 if (! &variable_defined ('DIST_SUBDIRS'))
2367 {
2368 &define_pretty_variable ('DIST_SUBDIRS', '',
2369 &variable_value_as_list ('SUBDIRS',
2370 'all'));
2371 }
2372 }
2374 # Test for directory existence here because previous automake
2375 # invocation might have created some directories. Note that
2376 # we explicitly set distdir for the subdir make; that lets us
2377 # mix-n-match many automake-using packages into one large
2378 # package, and have "dist" at the top level do the right
2379 # thing.
2380 $output_rules .= ' for subdir in $(' . $dist_subdir_name . '); do \\
2381 test -d $(distdir)/$$subdir \\
2382 || mkdir $(distdir)/$$subdir \\
2383 || exit 1; \\
2384 chmod 777 $(distdir)/$$subdir; \\
2385 (cd $$subdir && $(MAKE) top_distdir=../$(top_distdir) distdir=../$(distdir)/$$subdir distdir) \\
2386 || exit 1; \\
2387 done
2388 ';
2389 }
2391 # If the target `dist-hook' exists, make sure it is run. This
2392 # allows users to do random weird things to the distribution
2393 # before it is packaged up.
2394 push (@dist_targets, 'dist-hook') if defined $contents{'dist-hook'};
2396 local ($targ);
2397 foreach $targ (@dist_targets)
2398 {
2399 # We must explicitly set distdir and top_distdir for these
2400 # sub-makes.
2401 $output_rules .= "\t\$(MAKE) top_distdir=\"\$(top_distdir)\" distdir=\"\$(distdir)\" $targ\n";
2402 }
2404 push (@phony, 'distdir');
2405 }
2407 # Handle 'dist' target.
2408 sub handle_dist
2409 {
2410 local ($makefile) = @_;
2412 # Set up maint_charset.
2413 $local_maint_charset = &variable_value ('MAINT_CHARSET')
2414 if &variable_defined ('MAINT_CHARSET');
2415 $maint_charset = $local_maint_charset
2416 if $relative_dir eq '.';
2418 if (&variable_defined ('DIST_CHARSET'))
2419 {
2420 &am_line_error ('DIST_CHARSET',
2421 "DIST_CHARSET defined but no MAINT_CHARSET defined")
2422 if ! $local_maint_charset;
2423 if ($relative_dir eq '.')
2424 {
2425 $dist_charset = &variable_value ('DIST_CHARSET')
2426 }
2427 else
2428 {
2429 &am_line_error ('DIST_CHARSET',
2430 "DIST_CHARSET can only be defined at top level");
2431 }
2432 }
2434 # Look for common files that should be included in distribution.
2435 local ($cfile);
2436 foreach $cfile (@common_files)
2437 {
2438 if (-f ($relative_dir . "/" . $cfile))
2439 {
2440 &push_dist_common ($cfile);
2441 }
2442 }
2444 # Keys of %dist_common are names of files to distributed. We put
2445 # README first because it then becomes easier to make a
2446 # Usenet-compliant shar file (in these, README must be first).
2447 # FIXME: do more ordering of files here.
2448 local (@coms);
2449 if (defined $dist_common{'README'})
2450 {
2451 push (@coms, 'README');
2452 delete $dist_common{'README'};
2453 }
2454 push (@coms, sort keys %dist_common);
2456 &define_pretty_variable ("DIST_COMMON", '', @coms);
2457 $output_vars .= "\n";
2459 # Some boilerplate.
2460 $output_vars .= &file_contents ('dist-vars') . "\n";
2461 &define_variable ('TAR', $TAR);
2462 &define_variable ('GZIP', '--best');
2464 # Put these things in rules section so it is easier for whoever
2465 # reads Makefile.in.
2466 if (! &variable_defined ('distdir'))
2467 {
2468 if ($relative_dir eq '.')
2469 {
2470 $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
2471 }
2472 else
2473 {
2474 $output_rules .= ("\n"
2475 . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
2476 . "\n");
2477 }
2478 }
2479 if ($relative_dir eq '.')
2480 {
2481 $output_rules .= "top_distdir = \$(distdir)\n\n";
2482 }
2483 else
2484 {
2485 $output_rules .= "\nsubdir = " . $relative_dir . "\n\n";
2486 }
2488 # Generate 'dist' target, and maybe dist-shar / dist-zip / dist-tarZ.
2489 if ($relative_dir eq '.')
2490 {
2491 # Rule to check whether a distribution is viable.
2492 $output_rules .= ('# This target untars the dist file and tries a VPATH configuration. Then
2493 # it guarantees that the distribution is self-contained by making another
2494 # tarfile.
2495 distcheck: dist
2496 rm -rf $(distdir)
2497 GZIP=$(GZIP) $(TAR) zxf $(distdir).tar.gz
2498 mkdir $(distdir)/=build
2499 mkdir $(distdir)/=inst
2500 dc_install_base=`cd $(distdir)/=inst && pwd`; \\'
2501 . (defined $contents{'distcheck-hook'}
2502 ? "\t\$(MAKE) distcheck-hook"
2503 : '')
2504 . '
2505 cd $(distdir)/=build \\
2506 && ../configure '
2508 . ($seen_gettext ? '--with-included-gettext ' : '')
2509 . '--srcdir=.. --prefix=$$dc_install_base \\
2510 && $(MAKE) \\
2511 && $(MAKE) dvi \\
2512 && $(MAKE) check \\
2513 && $(MAKE) install \\
2514 && $(MAKE) installcheck \\
2515 && $(MAKE) dist
2516 rm -rf $(distdir)
2517 @echo "========================"; \\
2518 echo "$(distdir).tar.gz is ready for distribution"; \\
2519 echo "========================"
2520 ');
2522 local ($dist_all) = ('dist-all: distdir' . "\n"
2523 . $dist_header);
2524 local ($curs);
2525 foreach $curs ('dist', 'dist-shar', 'dist-zip', 'dist-tarZ')
2526 {
2527 if (defined $options{$curs} || $curs eq 'dist')
2528 {
2529 $output_rules .= ($curs . ': distdir' . "\n"
2530 . $dist_header
2531 . $dist{$curs}
2532 . $dist_trailer);
2533 $dist_all .= $dist{$curs};
2534 }
2535 }
2536 $output_rules .= $dist_all . $dist_trailer;
2537 }
2539 # Generate distdir target.
2540 &handle_dist_worker ($makefile);
2541 }
2543 # Scan a single dependency file and rewrite the dependencies as
2544 # appropriate. Essentially this means:
2545 # * Clean out absolute dependencies which are not desirable.
2546 # * Rewrite other dependencies to be relative to $(top_srcdir).
2547 sub scan_dependency_file
2548 {
2549 local ($depfile) = @_;
2551 if (! open (DEP_FILE, $depfile))
2552 {
2553 &am_error ("couldn't open \`$depfile': $!");
2554 return;
2555 }
2556 print "automake: reading $depfile\n" if $verbose;
2558 # Sometimes it is necessary to omit some dependencies.
2559 local (%omit) = %omit_dependencies;
2560 if (&variable_defined ('OMIT_DEPENDENCIES'))
2561 {
2562 # FIXME: Doesn't work with conditionals. I'm not sure if this
2563 # matters.
2564 grep ($omit{$_} = 1,
2565 &variable_value_as_list ('OMIT_DEPENDENCIES', ''));
2566 }
2568 local ($first_line) = 1;
2569 local ($last_line) = 0;
2570 local ($target, @dependencies);
2571 local ($one_dep, $xform);
2572 local ($just_file);
2574 local ($srcdir_rx, $fixup_rx);
2575 ($fixup_rx = $srcdir_name . '/' . $relative_dir . '/')
2576 =~ s/(\W)/\\$1/g;
2577 ($srcdir_rx = $srcdir_name . '/') =~ s/(\W)/\\$1/g;
2579 local ($rewrite_builddir) = (($top_builddir eq '.')
2580 ? ''
2581 : $top_builddir . '/');
2583 while (<DEP_FILE>)
2584 {
2585 if ($last_line)
2586 {
2587 # If LAST_LINE set then we've already seen what we thought
2588 # was the last line.
2589 goto bad_format;
2590 }
2591 next if (/$WHITE_PATTERN/o);
2592 chop;
2593 if (! s/\\$//)
2594 {
2595 # No trailing "\" means this should be the last line.
2596 $last_line = 1;
2597 }
2599 if ($first_line)
2600 {
2601 if (! /^([^:]+:)(.+)$/)
2602 {
2603 bad_format:
2604 &am_error ("\`$depfile' has incorrect format");
2605 close (DEP_FILE);
2606 return;
2607 }
2609 $_ = $2;
2610 # Make sure to strip the .P file from the target.
2611 ($target = $1) =~ s, *\.deps/[^.]+\.P,,;
2613 $first_line = 0;
2614 }
2616 foreach $one_dep (split (' ', $_))
2617 {
2618 if ($one_dep =~ /^$fixup_rx/)
2619 {
2620 # The dependency points to the current directory in
2621 # some way.
2622 ($xform = $one_dep) =~ s/^$fixup_rx//;
2623 push (@dependencies, $xform);
2624 }
2625 elsif ($one_dep =~ /^$srcdir_rx/)
2626 {
2627 # The dependency is in some other directory in the package.
2628 ($xform = $one_dep) =~ s/^$srcdir_rx/$rewrite_builddir/;
2629 push (@dependencies, $xform);
2630 }
2631 elsif ($one_dep =~ /^\//)
2632 {
2633 # Absolute path; ignore.
2634 }
2635 else
2636 {
2637 # Anything else is assumed to be correct. But first
2638 # make sure it is not on our list of dependencies to
2639 # omit.
2640 ($just_file = $one_dep) =~ s,^.*/,,;
2641 push (@dependencies, $one_dep)
2642 if ! defined $omit{$just_file};
2643 }
2644 }
2645 }
2647 &pretty_print_rule ($target, "\t", @dependencies);
2649 close (DEP_FILE);
2650 }
2652 # Handle auto-dependency code.
2653 sub handle_dependencies
2654 {
2655 if ($use_dependencies)
2656 {
2657 # Include GNU-make-specific auto-dep code. Don't include it
2658 # if DEP_FILES would be empty.
2659 if ($dir_holds_sources && keys %dep_files)
2660 {
2661 &define_pretty_variable ('DEP_FILES', '', sort keys %dep_files);
2662 $output_rules .= &file_contents ('depend');
2663 push (@clean, 'depend');
2664 &push_phony_cleaners ('depend');
2665 $output_rules .=
2666 &file_contents_with_transform ('s/\@EXT\@/.c/g;'
2667 . 's/\@MKDEP\@/MKDEP/g;'
2668 . 's/^ONLYC//g;',
2669 'depend2');
2670 local ($ext);
2671 local ($need_cxx) = 0;
2672 foreach $ext (sort keys %cxx_extensions)
2673 {
2674 $output_rules .=
2675 &file_contents_with_transform ('s/\@EXT\@/' . $ext .'/g;'
2676 . 's/\@MKDEP\@/CXXMKDEP/g;'
2677 . 's/^ONLYC.*$//;',
2678 'depend2');
2679 $need_cxx = 1;
2680 }
2681 if ($need_cxx)
2682 {
2683 &define_variable ('CXXMKDEP', '$(CXX) -M $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CXXFLAGS)');
2684 }
2685 }
2686 }
2687 elsif ($build_directory ne '')
2688 {
2689 # Include any auto-generated deps that are present. Note that
2690 # $build_directory ends in a "/".
2691 if (-d ($build_directory . $relative_dir . "/.deps")
2692 && -f ($build_directory . $relative_dir . "/.deps/.P"))
2693 {
2694 local ($depfile);
2696 foreach $depfile (&my_glob ($build_directory
2697 . $relative_dir . "/.deps/*.P"))
2698 {
2699 &scan_dependency_file ($depfile);
2700 }
2702 $output_rules .= "\n";
2703 }
2704 }
2705 }
2707 # Handle subdirectories.
2708 sub handle_subdirs
2709 {
2710 return if ! &variable_defined ('SUBDIRS');
2712 # Make sure each directory mentioned in SUBDIRS actually exists.
2713 local ($dir);
2714 foreach $dir (&variable_value_as_list ('SUBDIRS', 'all'))
2715 {
2716 # Skip directories substituted by configure.
2717 next if $dir =~ /^\@.*\@$/;
2719 if (! -d $am_relative_dir . '/' . $dir)
2720 {
2721 &am_line_error ('SUBDIRS',
2722 "required directory $am_relative_dir/$dir does not exist");
2723 next;
2724 }
2726 &am_line_error ('SUBDIRS', "directory should not contain \`/'")
2727 if $dir =~ /\//;
2728 }
2730 local ($xform) = ('s/\@INSTALLINFO\@/' .
2731 (defined $options{'no-installinfo'}
2732 ? 'install-info-recursive'
2733 : '')
2734 . '/;');
2735 $output_rules .= &file_contents_with_transform ($xform, 'subdirs');
2737 # Push a bunch of phony targets.
2738 local ($phonies);
2739 foreach $phonies ('-data', '-exec', 'dirs')
2740 {
2741 push (@phony, 'install' . $phonies . '-recursive');
2742 push (@phony, 'uninstall' . $phonies . '-recursive');
2743 }
2744 foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
2745 {
2746 push (@phony, $phonies . '-recursive');
2747 }
2748 &push_phony_cleaners ('recursive');
2750 push (@check_tests, "check-recursive");
2751 push (@installcheck, "installcheck-recursive");
2752 push (@info, "info-recursive");
2753 push (@dvi, "dvi-recursive");
2755 $recursive_install = 1;
2756 }
2758 # Handle aclocal.m4.
2759 sub handle_aclocal_m4
2760 {
2761 local ($regen_aclocal) = 0;
2762 if (-f 'aclocal.m4')
2763 {
2764 &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4');
2765 &push_dist_common ('aclocal.m4');
2767 if (open (ACLOCAL, '< aclocal.m4'))
2768 {
2769 local ($line);
2770 $line = <ACLOCAL>;
2771 close (ACLOCAL);
2773 if ($line =~ 'generated automatically by aclocal')
2774 {
2775 $regen_aclocal = 1;
2776 }
2777 }
2778 }
2780 local ($acinclude) = 0;
2781 if (-f 'acinclude.m4')
2782 {
2783 $regen_aclocal = 1;
2784 $acinclude = 1;
2785 }
2787 # Note that it might be possible that aclocal.m4 doesn't exist but
2788 # should be auto-generated. This case probably isn't very
2789 # important.
2790 if ($regen_aclocal)
2791 {
2792 local (@ac_deps) = (
2793 ($seen_maint_mode ? "\@MAINT\@" : "") ,
2794 "configure.in",
2795 ($acinclude ? ' acinclude.m4' : '')
2796 );
2798 # Scan all -I directories for m4 files. These are our
2799 # dependencies.
2800 if (&variable_defined ('ACLOCAL_AMFLAGS'))
2801 {
2802 local ($amdir);
2803 foreach $amdir (&variable_value_as_list ('ACLOCAL_AMFLAGS', ''))
2804 {
2805 if ($amdir =~ s/^-I//
2806 && $amdir !~ /^\//
2807 && -d $amdir)
2808 {
2809 push (@ac_deps, &my_glob ($am_dir . '/*.m4'));
2810 }
2811 }
2812 }
2814 &pretty_print_rule ("\$(ACLOCAL_M4):", "\t\t", @ac_deps);
2816 $output_rules .= ("\t"
2817 . 'cd $(srcdir) && $(ACLOCAL)'
2818 . (&variable_defined ('ACLOCAL_AMFLAGS')
2819 ? ' $(ACLOCAL_AMFLAGS)' : '')
2820 . "\n");
2821 }
2822 }
2824 # Rewrite a list of input files into a form suitable to put on a
2825 # dependency list. The idea is that if an input file has a directory
2826 # part the same as the current directory, then the directory part is
2827 # simply removed. But if the directory part is different, then
2828 # $(top_srcdir) is prepended. Among other things, this is used to
2829 # generate the dependency list for the output files generated by
2830 # AC_OUTPUT. Consider what the dependencies should look like in this
2831 # case:
2832 # AC_OUTPUT(src/out:src/in1:lib/in2)
2833 sub rewrite_inputs_into_dependencies
2834 {
2835 local (@inputs) = @_;
2836 local ($single, @newinputs);
2838 foreach $single (@inputs)
2839 {
2840 if (&dirname ($single) eq $relative_dir)
2841 {
2842 push (@newinputs, &basename ($single));
2843 }
2844 else
2845 {
2846 push (@newinputs, '$(top_srcdir)/' . $single);
2847 }
2848 }
2850 return @newinputs;
2851 }
2853 # Handle remaking and configure stuff.
2854 # We need the name of the input file, to do proper remaking rules.
2855 sub handle_configure
2856 {
2857 local ($local, $input, @secondary_inputs) = @_;
2859 # If SUBDIRS defined, require AC_PROG_MAKE_SET.
2860 &am_line_error ('SUBDIRS', "AC_PROG_MAKE_SET must be used in configure.in")
2861 if &variable_defined ('SUBDIRS') && ! $seen_make_set;
2863 local ($top_reldir);
2865 local ($input_base) = &basename ($input);
2866 local ($local_base) = &basename ($local);
2868 local ($amfile) = $input_base . '.am';
2869 # We know we can always add '.in' because it really should be an
2870 # error if the .in was missing originally.
2871 local ($infile) = '$(srcdir)/' . $input_base . '.in';
2872 local ($colon_infile);
2873 if ($local ne $input)
2874 {
2875 $colon_infile = ':' . $input . '.in';
2876 }
2877 $colon_infile .= ':' . join (':', @secondary_inputs)
2878 if @secondary_inputs;
2880 local (@rewritten) = &rewrite_inputs_into_dependencies (@secondary_inputs);
2881 # This rule remakes the Makefile.in. Note use of @MAINT@ forces
2882 # us to abandon pretty-printing. Sigh.
2883 $output_rules .= ($infile
2884 # NOTE perl 5.003 (with -w) gives a
2885 # uninitialized value error on the next line.
2886 # Don't know why.
2887 . ': '
2888 . ($seen_maint_mode ? '@MAINT@ ' : '')
2889 . $amfile . ' '
2890 . '$(top_srcdir)/configure.in $(ACLOCAL_M4) '
2891 . join (' ', @rewritten) . "\n"
2892 . "\tcd \$(top_srcdir) && \$(AUTOMAKE) "
2893 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
2894 . ($cmdline_use_dependencies ? '' : ' --include-deps')
2895 . ' ' . $input . $colon_infile . "\n\n");
2897 # This rule remakes the Makefile.
2898 $output_rules .= ($local_base
2899 # NOTE: bogus uninit value error on next line;
2900 # see comment above.
2901 . ': '
2902 . $infile . ' '
2903 . '$(top_builddir)/config.status'
2904 # NOTE: Makefile only depends on BUILT_SOURCES
2905 # when dependencies are being computed. This is
2906 # a workaround for an obscure bug with
2907 # AC_LINK_FILES. Anyway, when dependencies are
2908 # turned off, this shouldn't matter.
2909 . ($use_dependencies ? ' $(BUILT_SOURCES)' : '')
2910 . "\n"
2911 . "\tcd \$(top_builddir) \\\n"
2912 . "\t && CONFIG_FILES="
2913 . (($relative_dir eq '.') ? '$@' : '$(subdir)/$@')
2914 . $colon_infile
2915 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
2916 . "\n\n");
2918 if ($relative_dir ne '.')
2919 {
2920 # In subdirectory.
2921 $top_reldir = '../';
2922 }
2923 else
2924 {
2925 &handle_aclocal_m4;
2926 $output_rules .= &file_contents ('remake');
2927 &examine_variable ('CONFIGURE_DEPENDENCIES');
2928 $top_reldir = '';
2929 }
2931 # If we have a configure header, require it.
2932 local ($one_hdr);
2933 local (@local_fullnames) = @config_fullnames;
2934 local (@local_names) = @config_names;
2935 local ($hdr_index) = 0;
2936 local ($distclean_config) = '';
2937 foreach $one_hdr (@config_headers)
2938 {
2939 local ($one_fullname) = shift (@local_fullnames);
2940 local ($one_name) = shift (@local_names);
2941 $hdr_index += 1;
2942 if ($relative_dir eq &dirname ($one_hdr))
2943 {
2944 local ($ch_sans_dir) = &basename ($one_hdr);
2945 local ($cn_sans_dir) = &basename ($one_name);
2947 &require_file_with_conf_line ($config_header_line,
2948 $FOREIGN, $ch_sans_dir);
2950 # Header defined and in this directory.
2951 local (@files);
2952 if (-f $relative_dir . '/acconfig.h')
2953 {
2954 push (@files, 'acconfig.h');
2955 }
2956 if (-f $one_name . '.top')
2957 {
2958 push (@files, "${cn_sans_dir}.top");
2959 }
2960 if (-f $one_name . '.bot')
2961 {
2962 push (@files, "${cn_sans_dir}.bot");
2963 }
2965 &push_dist_common (@files);
2967 local ($stamp_name) = 'stamp-h';
2968 $stamp_name .= "${hdr_index}" if scalar (@config_headers) > 1;
2970 local ($xform) = '';
2972 $xform = 's,\@FILES\@,' . join (' ', @files) . ',;';
2973 $xform .= 's,\@CONFIG_HEADER\@,' . "${cn_sans_dir}" . ',;';
2974 $xform .= 's,\@CONFIG_HEADER_IN\@,' . "${ch_sans_dir}" . ',;';
2975 $xform .= 's,\@CONFIG_HEADER_FULL\@,' . "${one_fullname}" . ',;';
2976 $xform .= 's,\@STAMP\@,' . "${stamp_name}" . ',;';
2978 $output_rules .= &file_contents_with_transform ($xform,
2979 'remake-hdr');
2981 &touch ($relative_dir . "/${stamp_name}.in");
2982 &require_file_with_conf_line ($config_header_line, $FOREIGN,
2983 "${stamp_name}.in");
2985 $distclean_config .= ' ' if $distclean_config;
2986 $distclean_config .= $cn_sans_dir;
2987 }
2988 }
2990 if ($distclean_config)
2991 {
2992 $output_rules .= &file_contents_with_transform ('s,\@FILES\@,'
2993 . $distclean_config
2994 . ',;',
2995 'clean-hdr');
2996 push (@clean, 'hdr');
2997 &push_phony_cleaners ('hdr');
2998 }
3000 # Set location of mkinstalldirs.
3001 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
3002 {
3003 &define_variable ('mkinstalldirs', ('$(SHELL) ' . $config_aux_dir
3004 . '/mkinstalldirs'));
3005 }
3006 else
3007 {
3008 &define_variable ('mkinstalldirs',
3009 '$(SHELL) $(top_srcdir)/mkinstalldirs');
3010 }
3012 &am_line_error ('CONFIG_HEADER',
3013 "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
3014 if &variable_defined ('CONFIG_HEADER');
3016 local ($one_name);
3017 local ($config_header) = '';
3018 foreach $one_name (@config_names)
3019 {
3020 # Generate CONFIG_HEADER define.
3021 local ($one_hdr);
3022 if ($relative_dir eq &dirname ($one_name))
3023 {
3024 $one_hdr = &basename ($one_name);
3025 }
3026 else
3027 {
3028 $one_hdr = "${top_builddir}/${one_name}";
3029 }
3031 $config_header .= ' ' if $config_header;
3032 $config_header .= $one_hdr;
3033 }
3034 if ($config_header)
3035 {
3036 &define_variable ("CONFIG_HEADER", $config_header);
3037 }
3039 # Now look for other files in this directory which must be remade
3040 # by config.status, and generate rules for them.
3041 local (@actual_other_files) = ();
3042 local ($file, $local);
3043 local (@inputs, @rewritten_inputs, $single);
3044 foreach $file (@other_input_files)
3045 {
3046 if ($file =~ /^(.*):(.*)$/)
3047 {
3048 # This is the ":" syntax of AC_OUTPUT.
3049 $file = $1;
3050 $local = &basename ($file);
3051 @inputs = split (':', $2);
3052 @rewritten_inputs = &rewrite_inputs_into_dependencies (@inputs);
3053 }
3054 else
3055 {
3056 # Normal usage.
3057 $local = &basename ($file);
3058 @inputs = ($local . '.in');
3059 @rewritten_inputs =
3060 &rewrite_inputs_into_dependencies ($file . '.in');
3061 }
3063 # Skip files not in this directory.
3064 next unless &dirname ($file) eq $relative_dir;
3066 # Skip any file that is an automake input.
3067 next if -f $file . '.am';
3069 # Some users have been tempted to put `stamp-h' in the
3070 # AC_OUTPUT line. This won't do the right thing, so we
3071 # explicitly fail here.
3072 if ($local eq 'stamp-h')
3073 {
3074 # FIXME: allow real filename.
3075 &am_conf_error ('configure.in', $ac_output_line,
3076 'stamp-h should not appear in AC_OUTPUT');
3077 next;
3078 }
3080 $output_rules .= ($local . ': '
3081 . '$(top_builddir)/config.status '
3082 . join (' ', @rewritten_inputs) . "\n"
3083 . "\t"
3084 . 'cd $(top_builddir) && CONFIG_FILES='
3085 . ($relative_dir eq '.' ? '' : '$(subdir)/')
3086 . '$@' . (length (@rewritten_inputs) > 1
3087 ? (':' . join (':', @rewritten_inputs))
3088 : '')
3089 . ' CONFIG_HEADERS= ./config.status'
3090 . "\n");
3091 push (@actual_other_files, $local);
3093 # Require all input files.
3094 &require_file_with_conf_line ($ac_output_line, $FOREIGN,
3095 @inputs);
3096 }
3098 # These files get removed by "make clean".
3099 &define_pretty_variable ('CONFIG_CLEAN_FILES', '', @actual_other_files);
3100 }
3102 # Handle C headers.
3103 sub handle_headers
3104 {
3105 $dir_holds_headers = &am_install_var ('header', 'HEADERS', 'include',
3106 'oldinclude', 'pkginclude',
3107 'noinst', 'check');
3108 }
3110 sub handle_gettext
3111 {
3112 return if ! $seen_gettext || $relative_dir ne '.';
3114 if (! &variable_defined ('SUBDIRS'))
3115 {
3116 &am_conf_error
3117 ("AM_GNU_GETTEXT in configure.in but SUBDIRS not defined");
3118 return;
3119 }
3121 &require_file_with_conf_line ($ac_gettext_line, $FOREIGN, 'ABOUT-NLS')
3122 if $seen_gettext;
3124 if (&variable_defined ('SUBDIRS'))
3125 {
3126 &am_line_error
3127 ('SUBDIRS',
3128 "AM_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
3129 if $contents{'SUBDIRS'} !~ /\bpo\b/;
3130 &am_line_error
3131 ('SUBDIRS',
3132 "AM_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
3133 if $contents{'SUBDIRS'} !~ /\bintl\b/;
3134 }
3136 # Ensure that each language in ALL_LINGUAS has a .po file, and
3137 # each po file is mentioned in ALL_LINGUAS.
3138 if ($seen_linguas)
3139 {
3140 local (%linguas) = ();
3141 grep ($linguas{$_} = 1, split (' ', $all_linguas));
3143 foreach (<po/*.po>)
3144 {
3145 s/^po\///;
3146 s/\.po$//;
3148 &am_line_error ($all_linguas_line,
3149 ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
3150 if ! $linguas{$_};
3151 }
3153 foreach (keys %linguas)
3154 {
3155 &am_line_error ($all_linguas_line,
3156 "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
3157 if ! -f "po/$_.po";
3158 }
3159 }
3160 else
3161 {
3162 &am_error ("AM_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
3163 }
3164 }
3166 # Handle footer elements.
3167 sub handle_footer
3168 {
3169 if ($contents{'SOURCES'})
3170 {
3171 # NOTE don't use define_pretty_variable here, because
3172 # $contents{...} is already defined.
3173 $output_vars .= 'SOURCES = ' . $contents{'SOURCES'} . "\n";
3174 }
3175 if ($contents{'OBJECTS'})
3176 {
3177 # NOTE don't use define_pretty_variable here, because
3178 # $contents{...} is already defined.
3179 $output_vars .= 'OBJECTS = ' . $contents{'OBJECTS'} . "\n";
3180 }
3181 if ($contents{'SOURCES'} || $contents{'OBJECTS'})
3182 {
3183 $output_vars .= "\n";
3184 }
3186 if (&variable_defined ('SUFFIXES'))
3187 {
3188 # Push actual suffixes, and not $(SUFFIXES). Some versions of
3189 # make do not like variable substitutions on the .SUFFIXES
3190 # line.
3191 push (@suffixes, &variable_value_as_list ('SUFFIXES', ''));
3192 }
3193 if (&target_defined ('.SUFFIXES'))
3194 {
3195 &am_line_error ('.SUFFIXES',
3196 "use variable \`SUFFIXES', not target \`.SUFFIXES'");
3197 }
3199 # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
3200 # before .SUFFIXES. So we make sure that .SUFFIXES appears before
3201 # anything else, by sticking it right after the default: target.
3202 $output_header .= ".SUFFIXES:\n";
3203 if (@suffixes)
3204 {
3206 # Make sure suffixes has unique elements. Sort them to ensure
3207 # the output remains consistent.
3208 local (%suffixes);
3210 grep ($suffixes{$_} = 1, @suffixes);
3212 $output_header .= (".SUFFIXES: "
3213 . join (' ', sort keys %suffixes)
3214 . "\n");
3215 }
3216 $output_trailer .= &file_contents ('footer');
3217 }
3219 # Deal with installdirs target.
3220 sub handle_installdirs
3221 {
3222 # GNU Makefile standards recommend this.
3223 $output_rules .= ("installdirs:"
3224 . ($recursive_install
3225 ? " installdirs-recursive\n"
3226 : "\n"));
3227 push (@phony, 'installdirs');
3228 if (@installdirs)
3229 {
3230 &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
3231 @installdirs);
3232 }
3233 $output_rules .= "\n";
3234 }
3236 # There are several targets which need to be merged. This is because
3237 # their complete definition is compiled from many parts. Note that we
3238 # avoid double colon rules, otherwise we'd use them instead.
3239 sub handle_merge_targets
3240 {
3241 local ($makefile) = @_;
3243 # There are a few install-related variables that you should not define.
3244 local ($var);
3245 foreach $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
3246 {
3247 if (&variable_defined ($var))
3248 {
3249 &am_line_error ($var, "\`$var' should not be defined");
3250 }
3251 }
3253 # Put this at the beginning for the sake of non-GNU makes. This
3254 # is still wrong if these makes can run parallel jobs. But it is
3255 # right enough.
3256 unshift (@all, &basename ($makefile));
3258 local ($one_name);
3259 foreach $one_name (@config_names)
3260 {
3261 push (@all, &basename ($one_name))
3262 if &dirname ($one_name) eq $relative_dir;
3263 }
3265 &do_one_merge_target ('info', @info);
3266 &do_one_merge_target ('dvi', @dvi);
3267 &do_check_merge_target;
3268 &do_one_merge_target ('installcheck', @installcheck);
3270 if (defined $options{'no-installinfo'})
3271 {
3272 # FIXME: this is kind of a hack; should find another way to
3273 # know that this is required.
3274 local (@dirs);
3275 if (grep ($_ eq 'install-info-am', @phony))
3276 {
3277 push (@dirs, 'install-info-am');
3278 }
3279 if (&variable_defined ('SUBDIRS'))
3280 {
3281 push (@dirs, 'install-info-recursive');
3282 }
3283 &do_one_merge_target ('install-info', @dirs);
3284 }
3286 # Handle the various install targets specially. We do this so
3287 # that (eg) "make install-exec" will run "install-exec-recursive"
3288 # if required, but "make install" won't run it twice. Step one is
3289 # to see if the user specified local versions of any of the
3290 # targets we handle. "all" is treated as one of these since
3291 # "install" can run it.
3292 push (@install_exec, 'install-exec-local')
3293 if defined $contents{'install-exec-local'};
3294 push (@install_data, 'install-data-local')
3295 if defined $contents{'install-data-local'};
3296 push (@uninstall, 'uninstall-local')
3297 if defined $contents{'uninstall-local'};
3298 local ($utarg);
3299 foreach $utarg ('uninstall-data-local', 'uninstall-data-hook',
3300 'uninstall-exec-local', 'uninstall-exec-hook')
3301 {
3302 if (defined $contents{$utarg})
3303 {
3304 local ($x);
3305 ($x = $utarg) =~ s/(data|exec)-//;
3306 &am_line_error ($utarg, "use \`$x', not \`$utarg'");
3307 }
3308 }
3309 push (@all, 'all-local')
3310 if defined $contents{'all-local'};
3312 if (defined $contents{'install-local'})
3313 {
3314 &am_line_error ('install-local',
3315 "use \`install-data' or \`install-exec', not \`install'");
3316 }
3318 # Step two: if we are doing recursive makes, write out the
3319 # appropriate rules.
3320 local (@install);
3321 if ($recursive_install)
3322 {
3323 push (@install, 'install-recursive');
3325 if (@all)
3326 {
3327 local (@hackall) = ();
3328 local ($one_name);
3329 local ($local_headers) = '';
3330 foreach $one_name (@config_names)
3331 {
3332 if (&dirname ($one_name) eq $relative_dir)
3333 {
3334 $local_headers .= ' ' if $local_headers;
3335 $local_headers .= &basename ($one_name);
3336 }
3337 }
3338 if ($local_headers)
3339 {
3341 # This is kind of a hack, but I couldn't see a better
3342 # way to handle it. In this particular case, we need
3343 # to make sure config.h is built before we recurse.
3344 # We can't do this by changing the order of
3345 # dependencies to the "all" because that breaks when
3346 # using parallel makes. Instead we handle things
3347 # explicitly.
3348 $output_rules .= ("all-recursive-am: ${local_headers}"
3349 . "\n\t" . '$(MAKE) all-recursive'
3350 . "\n\n");
3351 push (@hackall, 'all-recursive-am');
3352 push (@phony, 'all-recursive-am');
3353 }
3354 else
3355 {
3356 push (@hackall, 'all-recursive');
3357 }
3359 $output_rules .= ('all-am: '
3360 . join (' ', @all)
3361 . "\n\n");
3362 @all = @hackall;
3363 push (@all, 'all-am');
3364 push (@phony, 'all-am');
3365 }
3366 else
3367 {
3368 @all = ('all-recursive');
3370 # Must always generate `all-am' target, so it can be
3371 # referred to elsewhere.
3372 $output_rules .= "all-am:\n";
3373 }
3374 if (@install_exec)
3375 {
3376 $output_rules .= ('install-exec-am: '
3377 . join (' ', @install_exec)
3378 . "\n\n");
3379 @install_exec = ('install-exec-recursive', 'install-exec-am');
3380 push (@install, 'install-exec-am');
3381 push (@phony, 'install-exec-am');
3382 }
3383 else
3384 {
3385 @install_exec = ('install-exec-recursive');
3386 }
3387 if (@install_data)
3388 {
3389 $output_rules .= ('install-data-am: '
3390 . join (' ', @install_data)
3391 . "\n\n");
3392 @install_data = ('install-data-recursive', 'install-data-am');
3393 push (@install, 'install-data-am');
3394 push (@phony, 'install-data-am');
3395 }
3396 else
3397 {
3398 @install_data = ('install-data-recursive');
3399 }
3400 if (@uninstall)
3401 {
3402 $output_rules .= ('uninstall-am: '
3403 . join (' ', @uninstall)
3404 . "\n\n");
3405 @uninstall = ('uninstall-recursive', 'uninstall-am');
3406 push (@phony, 'uninstall-am');
3407 }
3408 else
3409 {
3410 @uninstall = ('uninstall-recursive');
3411 }
3412 }
3414 # Step three: print definitions users can use. Code below knows
3415 # that install-exec is done before install-data, beware.
3416 $output_rules .= ("install-exec: "
3417 . join (' ', @install_exec)
3418 . "\n");
3419 $output_rules .= "\t\@\$(NORMAL_INSTALL)\n";
3420 if (defined $contents{'install-exec-hook'})
3421 {
3422 $output_rules .= "\t" . '$(MAKE) install-exec-hook' . "\n";
3423 }
3424 $output_rules .= "\n";
3425 push (@install, 'install-exec') if !$recursive_install;
3426 push (@phony, 'install-exec');
3428 $output_rules .= ("install-data: "
3429 . join (' ', @install_data)
3430 . "\n");
3431 $output_rules .= "\t\@\$(NORMAL_INSTALL)\n";
3432 if (defined $contents{'install-data-hook'})
3433 {
3434 $output_rules .= "\t" . '$(MAKE) install-data-hook' . "\n";
3435 }
3436 $output_rules .= "\n";
3437 push (@install, 'install-data') if !$recursive_install;
3438 push (@phony, 'install-data');
3440 # If no dependencies for 'install', add 'all'. Why? That way
3441 # "make install" at top level of distclean'd distribution won't
3442 # fail because stuff in 'lib' fails to build.
3443 if (! @install || (scalar (@install) == 2
3444 && $install[0] eq 'install-exec'
3445 && $install[1] eq 'install-data'))
3446 {
3447 push (@install, 'all');
3448 }
3449 $output_rules .= ('install: '
3450 . join (' ', @install)
3451 # Use "@:" as empty command so nothing prints.
3452 . "\n\t\@:"
3453 . "\n\n"
3454 . 'uninstall: '
3455 . join (' ', @uninstall)
3456 . "\n\n");
3457 push (@phony, 'install', 'uninstall');
3459 $output_rules .= ('all: '
3460 . join (' ', @all)
3461 . "\n\n");
3462 push (@phony, 'all');
3464 # Generate the new 'install-strip' target. Must set
3465 # INSTALL_SCRIPT to avoid stripping scripts.
3466 $output_rules .= ("install-strip:\n\t"
3467 . '$(MAKE) INSTALL_PROGRAM=\'$(INSTALL_PROGRAM) -s\' INSTALL_SCRIPT=\'$(INSTALL_PROGRAM)\' install'
3468 . "\n");
3469 }
3471 # Helper for handle_merge_targets.
3472 sub do_one_merge_target
3473 {
3474 local ($name, @values) = @_;
3476 if (defined $contents{$name . '-local'})
3477 {
3478 # User defined local form of target. So include it.
3479 push (@values, $name . '-local');
3480 push (@phony, $name . '-local');
3481 }
3483 &pretty_print_rule ($name . ":", "\t\t", @values);
3484 push (@phony, $name);
3485 }
3487 # Handle check merge target specially.
3488 sub do_check_merge_target
3489 {
3490 if (defined $contents{'check-local'})
3491 {
3492 # User defined local form of target. So include it.
3493 push (@check_tests, 'check-local');
3494 push (@phony, 'check-local');
3495 }
3497 if (! &variable_defined ('SUBDIRS'))
3498 {
3499 # 'check' must depend on `all', but not when doing recursive
3500 # build.
3501 unshift (@check, 'all');
3502 }
3503 else
3504 {
3505 # When subdirs are used, do the `all' build and then do all
3506 # the recursive stuff. Actually use `all-am' because it
3507 # doesn't recurse; we rely on the check target in the subdirs
3508 # to do the required builds there.
3509 unshift (@check, 'all-am');
3510 }
3512 # The check target must depend on the local equivalent of `all',
3513 # to ensure all the primary targets are built. Also it must
3514 # depend on the test code named in @check.
3515 &pretty_print_rule ('check:', "\t\t", @check);
3517 # Now the check rules must explicitly run anything named in
3518 # @check_tests. This is done via a separate make invocation to
3519 # avoid problems with parallel makes. Every time I write code
3520 # like this I wonder: how could you invent a parallel make and not
3521 # provide any real synchronization facilities?
3522 &pretty_print_rule ("\t\$(MAKE)", "\t ", @check_tests);
3523 }
3525 # Handle all 'clean' targets.
3526 sub handle_clean
3527 {
3528 push (@clean, 'generic');
3529 $output_rules .= &file_contents ('clean');
3530 &push_phony_cleaners ('generic');
3532 local ($target) = $recursive_install ? 'clean-am' : 'clean';
3533 &do_one_clean_target ($target, 'mostly', '', @clean);
3534 &do_one_clean_target ($target, '', 'mostly', @clean);
3535 &do_one_clean_target ($target, 'dist', '', @clean);
3536 &do_one_clean_target ($target, 'maintainer-', 'dist', @clean);
3538 push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
3540 local (@deps);
3541 if ($recursive_install)
3542 {
3543 # Do -recursive before -am. If you aren't doing a parallel
3544 # make, this can be nicer.
3545 @deps = ('recursive', 'am');
3546 &do_one_clean_target ('', 'mostly', '', @deps);
3547 &do_one_clean_target ('', '', '', @deps);
3548 &do_one_clean_target ('', 'dist', '', @deps);
3549 &do_one_clean_target ('', 'maintainer-', '', @deps);
3550 }
3551 }
3553 # Helper for handle_clean.
3554 sub do_one_clean_target
3555 {
3556 local ($target, $name, $last_name, @deps) = @_;
3558 # Special case: if target not passed, then don't generate
3559 # dependency on next "lower" clean target (eg no
3560 # clean<-mostlyclean derivation). In this case the target is
3561 # implicitly known to be 'clean'.
3562 local ($flag) = $target;
3563 $target = 'clean' if ! $flag;
3565 grep (($_ = $name . 'clean-' . $_) && 0, @deps);
3566 if ($flag)
3567 {
3568 if ($last_name || $name ne 'mostly')
3569 {
3570 push (@deps, $last_name . $target);
3571 }
3572 }
3574 # If a -local version of the rule is given, add it to the list.
3575 if (defined $contents{$name . $target . '-local'})
3576 {
3577 push (@deps, $name . $target . '-local');
3578 }
3580 # Print the target and the dependencies.
3581 &pretty_print_rule ($name . $target . ": ", "\t\t", @deps);
3583 # FIXME: shouldn't we really print these messages before running
3584 # the dependencies?
3585 if ($name . $target eq 'maintainer-clean')
3586 {
3587 # Print a special warning.
3588 $output_rules .=
3589 ("\t\@echo \"This command is intended for maintainers to use;\"\n"
3590 . "\t\@echo \"it deletes files that may require special "
3591 . "tools to rebuild.\"\n");
3593 $output_rules .= "\trm -f config.status\n"
3594 if $relative_dir eq '.';
3595 }
3596 elsif ($name . $target eq 'distclean')
3597 {
3598 $output_rules .= "\trm -f config.status\n";
3599 $output_rules .= "\trm -f libtool\n" if $seen_libtool;
3600 }
3601 $output_rules .= "\n";
3602 }
3604 # Handle .PHONY target.
3605 sub handle_phony
3606 {
3607 &pretty_print_rule ('.PHONY:', "", @phony);
3608 $output_rules .= "\n";
3609 }
3611 # Handle TESTS variable and other checks.
3612 sub handle_tests
3613 {
3614 if (defined $options{'dejagnu'})
3615 {
3616 push (@check_tests, 'check-DEJAGNU');
3617 push (@phony, 'check-DEJAGNU');
3619 local ($xform);
3620 if ($cygnus_mode)
3621 {
3622 $xform = 's/^CYGNUS//;';
3623 }
3624 else
3625 {
3626 $xform = 's/^CYGNUS.*$//;';
3627 }
3628 $output_rules .= &file_contents_with_transform ($xform, 'dejagnu');
3630 # In Cygnus mode, these are found in the build tree.
3631 # Otherwise they are looked for in $PATH.
3632 &define_program_variable ('EXPECT', 'build', 'expect', 'expect');
3633 &define_program_variable ('RUNTEST', 'src', 'dejagnu', 'runtest');
3635 # Note that in the rule we don't directly generate site.exp to
3636 # avoid the possibility of a corrupted site.exp if make is
3637 # interrupted. Jim Meyering has some useful text on this
3638 # topic.
3639 $output_rules .= ("site.exp: Makefile\n"
3640 . "\t\@echo 'Making a new site.exp file...'\n"
3641 . "\t-\@rm -f site.bak\n"
3642 . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
3643 . "\t\@echo '# Do not edit here. If you wish to override these values' >> \$\@-t\n"
3644 . "\t\@echo '# edit the last section' >> \$\@-t\n"
3645 . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
3646 . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
3647 . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
3649 # Extra stuff for AC_CANONICAL_*
3650 local (@whatlist) = ();
3651 if ($seen_canonical)
3652 {
3653 push (@whatlist, 'host')
3654 }
3656 # Extra stuff only for AC_CANONICAL_SYSTEM.
3657 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
3658 {
3659 push (@whatlist, 'target', 'build');
3660 }
3662 local ($c1, $c2);
3663 foreach $c1 (@whatlist)
3664 {
3665 foreach $c2 ('alias', 'triplet')
3666 {
3667 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
3668 }
3669 }
3671 $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
3672 . "\t-\@sed '1,/^## All variables above are.*##/ d' site.bak >> \$\@-t\n"
3673 . "\t-\@mv site.exp site.bak\n"
3674 . "\t\@mv \$\@-t site.exp\n");
3675 }
3676 else
3677 {
3678 local ($c);
3679 foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
3680 {
3681 if (&variable_defined ($c))
3682 {
3683 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
3684 }
3685 }
3686 }
3688 if (&variable_defined ('TESTS'))
3689 {
3690 push (@check_tests, 'check-TESTS');
3691 push (@phony, 'check-TESTS');
3693 $output_rules .= 'check-TESTS: $(TESTS)
3694 @failed=0; all=0; \\
3695 srcdir=$(srcdir); export srcdir; \\
3696 for tst in $(TESTS); do \\
3697 if test -f $$tst; then dir=.; \\
3698 else dir="$(srcdir)"; fi; \\
3699 if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \\
3700 all=`expr $$all + 1`; \\
3701 echo "PASS: $$tst"; \\
3702 elif test $$? -ne 77; then \\
3703 all=`expr $$all + 1`; \\
3704 failed=`expr $$failed + 1`; \\
3705 echo "FAIL: $$tst"; \\
3706 fi; \\
3707 done; \\
3708 if test "$$failed" -eq 0; then \\
3709 banner="All $$all tests passed"; \\
3710 else \\
3711 banner="$$failed of $$all tests failed"; \\
3712 fi; \\
3713 dashes=`echo "$$banner" | sed s/./=/g`; \\
3714 echo "$$dashes"; \\
3715 echo "$$banner"; \\
3716 echo "$$dashes"; \\
3717 test "$$failed" -eq 0
3718 ';
3719 }
3720 }
3722 # Handle Emacs Lisp.
3723 sub handle_emacs_lisp
3724 {
3725 local (@elfiles) = &am_install_var ('lisp', 'LISP', 'lisp', 'noinst');
3727 if (@elfiles)
3728 {
3729 # Found some lisp.
3730 &define_configure_variable ('lispdir');
3731 &define_configure_variable ('EMACS');
3732 $output_rules .= (".el.elc:\n"
3733 . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
3734 . "\tif test \$(EMACS) != no; then \\\n"
3735 . "\t EMACS=\$(EMACS) \$(SHELL) \$(srcdir)/elisp-comp \$<; \\\n"
3736 . "\tfi\n");
3737 push (@suffixes, '.el', '.elc');
3739 # Generate .elc files.
3740 grep ($_ .= 'c', @elfiles);
3741 &define_pretty_variable ('ELCFILES', '', @elfiles);
3743 push (@clean, 'lisp');
3744 &push_phony_cleaners ('lisp');
3746 push (@all, '$(ELCFILES)');
3748 local ($varname);
3749 if (&variable_defined ('lisp_LISP'))
3750 {
3751 $varname = 'lisp_LISP';
3752 &am_error ("\`lisp_LISP' defined but \`AM_PATH_LISPDIR' not in \`configure.in'")
3753 if ! $seen_lispdir;
3754 }
3755 else
3756 {
3757 $varname = 'noinst_LISP';
3758 }
3760 &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
3761 }
3762 }
3764 ################################################################
3766 # Scan one file for interesting things. Subroutine of scan_configure.
3767 sub scan_one_configure_file
3768 {
3769 local ($filename) = @_;
3771 open (CONFIGURE, $filename)
3772 || die "automake: couldn't open \`$filename': $!\n";
3773 print "automake: reading $filename\n" if $verbose;
3775 while (<CONFIGURE>)
3776 {
3777 # Remove comments from current line.
3778 s/\bdnl\b.*$//;
3779 s/\#.*$//;
3781 # Skip macro definitions. Otherwise we might be confused into
3782 # thinking that a macro that was only defined was actually
3783 # used.
3784 next if /AC_DEFUN/;
3786 # Populate libobjs array.
3787 if (/AC_FUNC_ALLOCA/)
3788 {
3789 $libsources{'alloca.c'} = 1;
3790 }
3791 elsif (/AC_FUNC_GETLOADAVG/)
3792 {
3793 $libsources{'getloadavg.c'} = 1;
3794 }
3795 elsif (/AC_FUNC_MEMCMP/)
3796 {
3797 $libsources{'memcmp.c'} = 1;
3798 }
3799 elsif (/AC_STRUCT_ST_BLOCKS/)
3800 {
3801 $libsources{'fileblocks.c'} = 1;
3802 }
3803 elsif (/A[CM]_REPLACE_GNU_GETOPT/)
3804 {
3805 $libsources{'getopt.c'} = 1;
3806 $libsources{'getopt1.c'} = 1;
3807 }
3808 elsif (/AM_FUNC_STRTOD/)
3809 {
3810 $libsources{'strtod.c'} = 1;
3811 }
3812 elsif (/AM_WITH_REGEX/)
3813 {
3814 $libsources{'rx.c'} = 1;
3815 $libsources{'rx.h'} = 1;
3816 $libsources{'regex.c'} = 1;
3817 $libsources{'regex.h'} = 1;
3818 $omit_dependencies{'rx.h'} = 1;
3819 $omit_dependencies{'regex.h'} = 1;
3820 }
3821 elsif (/AM_FUNC_MKTIME/)
3822 {
3823 $libsources{'mktime.c'} = 1;
3824 }
3825 elsif (/AM_FUNC_ERROR_AT_LINE/)
3826 {
3827 $libsources{'error.c'} = 1;
3828 $libsources{'error.h'} = 1;
3829 }
3830 elsif (/AM_FUNC_OBSTACK/)
3831 {
3832 $libsources{'obstack.c'} = 1;
3833 $libsources{'obstack.h'} = 1;
3834 }
3835 elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
3836 || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
3837 {
3838 foreach $libobj_iter (split (' ', $1))
3839 {
3840 if ($libobj_iter =~ /^(.*)\.o$/)
3841 {
3842 $libsources{$1 . '.c'} = 1;
3843 }
3844 }
3845 }
3847 if (! $in_ac_replace && s/AC_REPLACE_FUNCS\s*\(\[?//)
3848 {
3849 $in_ac_replace = 1;
3850 }
3851 if ($in_ac_replace)
3852 {
3853 $in_ac_replace = 0 if s/[\]\)].*$//;
3854 # Remove trailing backslash.
3855 s/\\$//;
3856 foreach (split)
3857 {
3858 # Need to skip empty elements for Perl 4.
3859 next if $_ eq '';
3860 $libsources{$_ . '.c'} = 1;
3861 }
3862 }
3864 if (/$obsolete_rx/o)
3865 {
3866 local ($hint) = '';
3867 if ($obsolete_macros{$1})
3868 {
3869 $hint = '; ' . $obsolete_macros{$1};
3870 }
3871 &am_conf_line_error ($filename, $., "\`$1' is obsolete$hint");
3872 }
3874 # Process the AC_OUTPUT macro.
3875 if (! $in_ac_output && s/AC_OUTPUT\s*\(\[?//)
3876 {
3877 $in_ac_output = 1;
3878 $ac_output_line = $.;
3879 }
3880 if ($in_ac_output)
3881 {
3882 $in_ac_output = 0 if s/[\]\),].*$//;
3884 # Look at potential Makefile.am's.
3885 foreach (split)
3886 {
3887 next if $_ eq "\\";
3889 # Handle $local:$input syntax. Note that we ignore
3890 # every input file past the first, though we keep
3891 # those around for later.
3892 local ($local, $input, @rest) = split (/:/);
3893 if (! $input)
3894 {
3895 $input = $local;
3896 }
3897 else
3898 {
3899 # FIXME: should be error if .in is missing.
3900 $input =~ s/\.in$//;
3901 }
3903 if (-f $input . '.am')
3904 {
3905 # We have a file that automake should generate.
3906 push (@make_input_list, $input);
3907 $make_list{$input} = join (':', ($local, @rest));
3908 }
3909 else
3910 {
3911 # We have a file that automake should cause to be
3912 # rebuilt, but shouldn't generate itself.
3913 push (@other_input_files, $_);
3914 }
3915 }
3916 }
3918 if (/$AC_CONFIG_AUX_DIR_PATTERN/o)
3919 {
3920 @config_aux_path = $1;
3921 }
3923 # Check for ansi2knr.
3924 $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
3926 # Check for Cygwin32.
3927 if (/AM_CYGWIN32/)
3928 {
3929 $seen_cygwin32 = 1;
3930 $configure_vars{'EXEEXT'} = 1;
3931 }
3933 # Check for NLS support.
3934 if (/AM_GNU_GETTEXT/)
3935 {
3936 $seen_gettext = 1;
3937 $ac_gettext_line = $.;
3938 $omit_dependencies{'libintl.h'} = 1;
3939 }
3941 # Look for ALL_LINGUAS.
3942 if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
3943 {
3944 $seen_linguas = 1;
3945 $all_linguas = $1;
3946 $all_linguas_line = $.;
3947 }
3949 # Handle configuration headers. A config header of `[$1]'
3950 # means we are actually scanning AM_CONFIG_HEADER from
3951 # aclocal.m4.
3952 if (/A([CM])_CONFIG_HEADER\s*\((.*)\)/
3953 && $2 ne '[$1]')
3954 {
3955 &am_conf_line_error
3956 ($filename, $.,
3957 "\`AC_CONFIG_HEADER' is obsolete; use \`AM_CONFIG_HEADER'")
3958 if $1 eq 'C';
3960 $config_header_line = $.;
3961 local ($one_hdr);
3962 foreach $one_hdr (split (' ', $2))
3963 {
3964 push (@config_fullnames, $one_hdr);
3965 if ($one_hdr =~ /^([^:]+):(.+)$/)
3966 {
3967 push (@config_names, $1);
3968 push (@config_headers, $2);
3969 }
3970 else
3971 {
3972 push (@config_names, $one_hdr);
3973 push (@config_headers, $one_hdr . '.in');
3974 }
3975 }
3976 }
3978 # Handle AC_CANONICAL_*. Always allow upgrading to
3979 # AC_CANONICAL_SYSTEM, but never downgrading.
3980 $seen_canonical = $AC_CANONICAL_HOST
3981 if ! $seen_canonical
3982 && (/AC_CANONICAL_HOST/ || /AC_CHECK_TOOL/);
3983 $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
3985 $seen_path_xtra = 1 if /AC_PATH_XTRA/;
3987 # This macro handles several different things.
3988 if (/$AM_INIT_AUTOMAKE_PATTERN/o)
3989 {
3990 $seen_make_set = 1;
3991 $seen_package = 1;
3992 $seen_version = 1;
3993 $seen_arg_prog = 1;
3994 $seen_prog_install = 2;
3995 ($package_version = $1) =~ s/$AM_PACKAGE_VERSION_PATTERN/$1/o;
3996 $package_version_line = $.;
3997 }
3999 # This is like AM_INIT_AUTOMAKE, but doesn't actually set the
4000 # package and version number. (This might change in the
4001 # future). Yes, I'm not above hacking Automake so it works
4002 # well with other GNU tools -- that is actually the point.
4003 if (/AM_INIT_GUILE_MODULE/)
4004 {
4005 $seen_make_set = 1;
4006 $seen_package = 1;
4007 $seen_version = 1;
4008 $seen_arg_prog = 1;
4009 $seen_prog_install = 2;
4010 @config_aux_path = ('..');
4011 }
4013 # Some things required by Automake.
4014 $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
4015 $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
4017 if (/AC_PROG_(YACC|RANLIB|CC|CXX|LEX|AWK|CPP|CXXCPP|LN_S)/)
4018 {
4019 $configure_vars{$1} = 1;
4020 }
4021 if (/$AC_CHECK_PATTERN/o)
4022 {
4023 $configure_vars{$3} = 1;
4024 }
4025 if (/$AM_MISSING_PATTERN/o
4026 && $1 ne 'ACLOCAL'
4027 && $1 ne 'AUTOCONF'
4028 && $1 ne 'AUTOMAKE'
4029 && $1 ne 'AUTOHEADER')
4030 {
4031 $configure_vars{$1} = 1;
4032 }
4034 # Explicitly avoid ANSI2KNR -- we AC_SUBST that in protos.m4,
4035 # but later define it elsewhere. This is pretty hacky. We
4036 # also explicitly avoid INSTALL_SCRIPT and some other
4037 # variables because they are defined in header-vars.am.
4038 # FIXME.
4039 if (/$AC_SUBST_PATTERN/o
4040 && $1 ne 'ANSI2KNR'
4041 && $1 ne 'INSTALL_SCRIPT')
4042 {
4043 $configure_vars{$1} = 1;
4044 }
4046 $seen_decl_yytext = 1 if /AC_DECL_YYTEXT/;
4047 $seen_maint_mode = 1 if /AM_MAINTAINER_MODE/;
4048 $seen_package = 1 if /PACKAGE=/;
4050 # Skip VERSION of [$2]; that is from AM_INIT_AUTOMAKE.
4051 if (/\bVERSION=(\S+)/ && $1 ne '[$2]')
4052 {
4053 $seen_version = 1;
4054 $package_version = $1;
4055 $package_version_line = $.;
4056 }
4057 elsif (/VERSION=/)
4058 {
4059 $seen_version = 1;
4060 }
4062 # Weird conditionals here because it is always allowed to
4063 # upgrade to AM_PROG_INSTALL but never to downgrade to
4064 # AC_PROG_INSTALL.
4065 $seen_prog_install = 1 if ! $seen_prog_install && /AC_PROG_INSTALL/;
4066 $seen_prog_install = 2 if /AM_PROG_INSTALL/;
4068 $seen_lispdir = 1 if /AM_PATH_LISPDIR/;
4070 if (/AM_PROG_LIBTOOL/)
4071 {
4072 $seen_libtool = 1;
4073 $libtool_line = $.;
4074 $configure_vars{'LIBTOOL'} = 1;
4075 $configure_vars{'RANLIB'} = 1;
4076 $configure_vars{'CC'} = 1;
4077 # AM_PROG_LIBTOOL runs AC_CANONICAL_HOST. Make sure we
4078 # never downgrade (if we've seen AC_CANONICAL_SYSTEM).
4079 $seen_canonical = $AC_CANONICAL_HOST if ! $seen_canonical;
4080 }
4082 if (/$AM_CONDITIONAL_PATTERN/o)
4083 {
4084 $configure_cond{$1} = 1;
4085 }
4086 }
4088 close (CONFIGURE);
4089 }
4091 # Scan configure.in and aclocal.m4 for interesting things. We must
4092 # scan aclocal.m4 because there might be AC_SUBSTs and such there.
4093 sub scan_configure
4094 {
4095 # Reinitialize libsources here. This isn't really necessary,
4096 # since we currently assume there is only one configure.in. But
4097 # that won't always be the case.
4098 %libsources = ();
4100 local ($in_ac_output, $in_ac_replace) = (0, 0);
4101 local (%make_list, @make_input_list);
4102 local ($libobj_iter);
4104 &scan_one_configure_file ('configure.in');
4105 &scan_one_configure_file ('aclocal.m4')
4106 if -f 'aclocal.m4';
4108 # Set input and output files if not specified by user.
4109 if (! @input_files)
4110 {
4111 @input_files = @make_input_list;
4112 %output_files = %make_list;
4113 }
4115 &am_conf_error ("\`PACKAGE' not defined in configure.in")
4116 if ! $seen_package;
4117 &am_conf_error ("\`VERSION' not defined in configure.in")
4118 if ! $seen_version;
4120 # Look for some files we need. Always check for these. This
4121 # check must be done for every run, even those where we are only
4122 # looking at a subdir Makefile. We must set relative_dir so that
4123 # the file-finding machinery works.
4124 local ($relative_dir) = '.';
4125 &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs', 'missing');
4126 &am_error ("\`install.sh' is an anachronism; use \`install-sh' instead")
4127 if -f $config_aux_path[0] . '/install.sh';
4128 }
4130 ################################################################
4132 # Set up for Cygnus mode.
4133 sub check_cygnus
4134 {
4135 return unless $cygnus_mode;
4137 &set_strictness ('foreign');
4138 $options{'no-installinfo'} = 1;
4139 $options{'no-dependencies'} = 1;
4140 $use_dependencies = 0;
4142 if (! $seen_maint_mode)
4143 {
4144 &am_conf_error ("\`AM_MAINTAINER_MODE' required when --cygnus specified");
4145 }
4147 if (! $seen_cygwin32)
4148 {
4149 &am_conf_error ("\`AM_CYGWIN32' required when --cygnus specified");
4150 }
4151 }
4153 # Do any extra checking for GNU standards.
4154 sub check_gnu_standards
4155 {
4156 if ($relative_dir eq '.')
4157 {
4158 # In top level (or only) directory.
4159 &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
4160 'AUTHORS', 'ChangeLog');
4161 }
4163 if ($strictness >= $GNU)
4164 {
4165 if (defined $options{'no-installman'})
4166 {
4167 &am_line_error ('AUTOMAKE_OPTIONS',
4168 "option \`no-installman' disallowed by GNU standards");
4169 }
4171 if (defined $options{'no-installinfo'})
4172 {
4173 &am_line_error ('AUTOMAKE_OPTIONS',
4174 "option \`no-installinfo' disallowed by GNU standards");
4175 }
4176 }
4177 }
4179 # Do any extra checking for GNITS standards.
4180 sub check_gnits_standards
4181 {
4182 if ($strictness >= $GNITS)
4183 {
4184 if (-f $relative_dir . '/COPYING.LIB')
4185 {
4186 &am_error ("\`${relative_dir}/COPYING.LIB' disallowed by Gnits standards");
4187 }
4189 if ($relative_dir eq '.')
4190 {
4191 if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
4192 {
4193 # FIXME: allow real filename.
4194 &am_conf_line_error ('configure.in',
4195 $package_version_line,
4196 "version \`$package_version' doesn't follow Gnits standards");
4197 }
4198 elsif (defined $1 && -f 'README-alpha')
4199 {
4200 # This means we have an alpha release. See
4201 # GNITS_VERSION_PATTERN for details.
4202 &require_file ($GNITS, 'README-alpha');
4203 }
4204 }
4205 }
4207 if ($relative_dir eq '.')
4208 {
4209 # In top level (or only) directory.
4210 &require_file ($GNITS, 'THANKS');
4211 }
4212 }
4214 ################################################################
4216 # Pretty-print something. HEAD is what should be printed at the
4217 # beginning of the first line, FILL is what should be printed at the
4218 # beginning of every subsequent line.
4219 sub pretty_print_internal
4220 {
4221 local ($head, $fill, @values) = @_;
4223 local ($column) = length ($head);
4224 local ($result) = $head;
4226 # Fill length is number of characters. However, each Tab
4227 # character counts for eight. So we count the number of Tabs and
4228 # multiply by 7.
4229 local ($fill_length) = length ($fill);
4230 $fill_length += 7 * ($fill =~ tr/\t/\t/d);
4232 local ($bol) = ($head eq '');
4233 foreach (@values)
4234 {
4235 # "71" because we also print a space.
4236 if ($column + length ($_) > 71)
4237 {
4238 $result .= " \\\n" . $fill;
4239 $column = $fill_length;
4240 $bol = 1;
4241 }
4243 $result .= ' ' unless ($bol);
4244 $result .= $_;
4245 $column += length ($_) + 1;
4246 $bol = 0;
4247 }
4249 $result .= "\n";
4250 return $result;
4251 }
4253 # Pretty-print something and append to output_vars.
4254 sub pretty_print
4255 {
4256 $output_vars .= &pretty_print_internal (@_);
4257 }
4259 # Pretty-print something and append to output_rules.
4260 sub pretty_print_rule
4261 {
4262 $output_rules .= &pretty_print_internal (@_);
4263 }
4266 ################################################################
4268 # See if a target exists.
4269 sub target_defined
4270 {
4271 local ($target) = @_;
4272 return defined $targets{$target};
4273 }
4275 # See if two conditionals are the same.
4276 sub conditional_same
4277 {
4278 local ($cond1, $cond2) = @_;
4280 return (&conditional_true_when ($cond1, $cond2)
4281 && &conditional_true_when ($cond2, $cond1));
4282 }
4284 # See if a conditional is true. Both arguments are conditional
4285 # strings. This returns true if the first conditional is true when
4286 # the second conditional is true.
4287 sub conditional_true_when
4288 {
4289 local ($cond, $when) = @_;
4291 # Check the easy case first.
4292 if ($cond eq $when)
4293 {
4294 return 1;
4295 }
4297 # Check each component of $cond, which looks @COND1@@COND2@.
4298 foreach $comp (split ('@', $cond))
4299 {
4300 # The way we split will give null strings between each
4301 # condition.
4302 next if ! $comp;
4304 if (index ($when, '@' . $comp . '@') == -1)
4305 {
4306 return 0;
4307 }
4308 }
4310 return 1;
4311 }
4313 # Check for an ambiguous conditional. This is called when a variable
4314 # or target is being defined conditionally. If we already know about
4315 # a definition that is true under the same conditions, then we have an
4316 # ambiguity.
4317 sub check_ambiguous_conditional
4318 {
4319 local ($var_name, $cond) = @_;
4320 local (@cond_vals) = split (/ /, $conditional{$var_name});
4321 while (@cond_vals)
4322 {
4323 local ($vcond) = shift (@cond_vals);
4324 shift (@cond_vals);
4325 if (&conditional_true_when ($vcond, $cond)
4326 || &conditional_true_when ($cond, $vcond))
4327 {
4328 &am_line_error ($var_name,
4329 "$var_name multiply defined in condition");
4330 }
4331 }
4332 }
4334 # See if a variable exists. The first argument is the variable name,
4335 # and the optional second argument is the condition which we should
4336 # check. If no condition is given, we currently return true if the
4337 # variable is defined under any condition.
4338 sub variable_defined
4339 {
4340 local ($var, $cond) = @_;
4341 if (defined $targets{$var})
4342 {
4343 &am_line_error ($var, "\`$var' is target; expected variable");
4344 return 0;
4345 }
4346 elsif (defined $contents{$var})
4347 {
4348 if ($cond && $conditional{$var})
4349 {
4350 # We have been asked to check for a particular condition,
4351 # and the variable is defined conditionally. We need to
4352 # look through the conditions under which the variable is
4353 # defined, and see if any of them match the conditional we
4354 # have been asked to check.
4355 local (@cond_vars) = split (/ /, $conditional{$var});
4356 while (@cond_vars)
4357 {
4358 if (&conditional_same ($cond, shift (@cond_vars)))
4359 {
4360 return 1;
4361 }
4362 shift (@cond_vars);
4363 }
4365 # The variable is not defined for the given condition.
4366 return 0;
4367 }
4369 $content_seen{$var} = 1;
4370 return 1;
4371 }
4372 return 0;
4373 }
4375 # Mark a variable as examined.
4376 sub examine_variable
4377 {
4378 local ($var) = @_;
4379 &variable_defined ($var);
4380 }
4382 # Quote a value in order to put it in $conditional. We need to quote
4383 # spaces, and we need to handle null strings, so that we can later
4384 # retrieve values by splitting on space.
4385 sub quote_cond_val
4386 {
4387 local ($val) = @_;
4388 $val =~ s/ /\001/g;
4389 $val = '\002' if $val eq '';
4390 return $val;
4391 }
4393 # Unquote a value in $conditional.
4394 sub unquote_cond_val
4395 {
4396 local ($val) = @_;
4397 $val =~ s/\001/ /g;
4398 $val = '' if $val eq '\002';
4399 return $val;
4400 }
4402 # Return the set of conditions for which a variable is defined.
4404 # If the variable is not defined conditionally, and is not defined in
4405 # terms of any variables which are defined conditionally, then this
4406 # returns the empty list.
4408 # If the variable is defined conditionally, but is not defined in
4409 # terms of any variables which are defined conditionally, then this
4410 # returns the list of conditions for which the variable is defined.
4412 # If the variable is defined in terms of any variables which are
4413 # defined conditionally, then this returns a full set of permutations
4414 # of the subvariable conditions. For example, if the variable is
4415 # defined in terms of a variable which is defined for @COND_TRUE@,
4416 # then this returns both @COND_TRUE@ and @COND_FALSE@. This is
4417 # because we will need to define the variable under both conditions.
4419 sub variable_conditions
4420 {
4421 local ($var) = @_;
4422 local (%uniqify);
4423 local ($cond);
4425 foreach $cond (&variable_conditions_sub ($var, '', ()))
4426 {
4427 $uniqify{$cond} = 1;
4428 }
4430 return keys %uniqify;
4431 }
4433 # A subroutine of variable_conditions. We only return conditions
4434 # which are true for all the conditions in @PARENT_CONDS.
4435 sub variable_conditions_sub
4436 {
4437 local ($var, $parent, @parent_conds) = @_;
4438 local (@new_conds) = ();
4440 if (! $conditional{$var})
4441 {
4442 foreach (split (' ', $contents{$var}))
4443 {
4444 # If a comment seen, just leave.
4445 last if /^#/;
4447 # Handle variable substitutions.
4448 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
4449 {
4450 push (@new_conds,
4451 &variable_conditions_sub ($1, $var, @parent_conds));
4452 }
4453 }
4455 return &variable_conditions_reduce (@new_conds);
4456 }
4458 local (@this_conds) = ();
4459 local (@condvals) = split (/ /, $conditional{$var});
4460 while (@condvals)
4461 {
4462 local ($cond) = shift (@condvals);
4463 local ($val) = &unquote_cond_val (shift (@condvals));
4465 if (@parent_conds)
4466 {
4467 local ($ok) = 1;
4468 local ($parent_cond);
4469 foreach $parent_cond (@parent_conds)
4470 {
4471 if (! &conditional_true_when ($parent_cond, $cond))
4472 {
4473 $ok = 0;
4474 last;
4475 }
4476 }
4478 next if ! $ok;
4479 }
4481 push (@this_conds, $cond);
4483 push (@parent_conds, $cond);
4484 local (@subvar_conds) = ();
4485 foreach (split (' ', $val))
4486 {
4487 # If a comment seen, just leave.
4488 last if /^#/;
4490 # Handle variable substitutions.
4491 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
4492 {
4493 push (@subvar_conds,
4494 &variable_conditions_sub ($1, $var, @parent_conds));
4495 }
4496 }
4497 pop (@parent_conds);
4499 # If there are no conditional subvariables, then we want to
4500 # return this condition. Otherwise, we want to return the
4501 # permutations of the subvariables.
4502 if (! @subvar_conds)
4503 {
4504 push (@new_conds, $cond);
4505 }
4506 else
4507 {
4508 push (@new_conds, &variable_conditions_reduce (@subvar_conds));
4509 }
4510 }
4512 return @new_conds
4513 if ! $parent;
4515 # If we are being called on behalf of another variable, we need to
4516 # return all possible permutations of the conditions. We have
4517 # already handled everything in @this_conds along with their
4518 # subvariables. We now need to add any permutations that are not
4519 # in @this_conds.
4520 local ($this_cond);
4521 foreach $this_cond (@this_conds)
4522 {
4523 local (@perms) =
4524 &variable_conditions_permutations (split('@', $this_cond));
4525 local ($perm);
4526 foreach $perm (@perms)
4527 {
4528 local ($scan);
4529 local ($ok) = 1;
4530 foreach $scan (@this_conds)
4531 {
4532 if (&conditional_true_when ($perm, $scan)
4533 || &conditional_true_when ($scan, $perm))
4534 {
4535 $ok = 0;
4536 last;
4537 }
4538 }
4539 next if ! $ok;
4541 if (@parent_conds)
4542 {
4543 local ($ok) = 1;
4544 local ($parent_cond);
4545 foreach $parent_cond (@parent_conds)
4546 {
4547 if (! &conditional_true_when ($parent_cond, $perm))
4548 {
4549 $ok = 0;
4550 last;
4551 }
4552 }
4554 next if ! $ok;
4555 }
4557 # This permutation was not already handled, and is valid
4558 # for the parents.
4559 push (@new_conds, $perm);
4560 }
4561 }
4563 return @new_conds;
4564 }
4566 # Subroutine for variable_conditions_sort
4567 sub variable_conditions_cmp
4568 {
4569 local ($as) = $a;
4570 $as =~ s/[^@]//g;
4571 local ($bs) = $b;
4572 $bs =~ s/[^@]//g;
4573 return (length ($as) <=> length ($bs)
4574 || $a cmp $b);
4575 }
4577 # Sort a list of conditionals so that only the exclusive ones are
4578 # retained. For example, if both @COND1_TRUE@@COND2_TRUE@ and
4579 # @COND1_TRUE@ are in the list, discard the latter.
4580 sub variable_conditions_reduce
4581 {
4582 local (@conds) = @_;
4583 local (@ret) = ();
4584 local ($cond);
4585 foreach $cond (sort variable_conditions_cmp @conds)
4586 {
4587 local ($ok) = 1;
4588 local ($scan);
4589 foreach $scan (@ret)
4590 {
4591 if (&conditional_true_when ($cond, $scan))
4592 {
4593 $ok = 0;
4594 last;
4595 }
4596 }
4597 next if ! $ok;
4598 push (@ret, $cond);
4599 }
4601 return @ret;
4602 }
4604 # Return a list of permutations of a conditional string.
4605 sub variable_conditions_permutations
4606 {
4607 local (@comps) = @_;
4608 return ()
4609 if ! @comps;
4610 local ($comp) = shift (@comps);
4611 return &variable_conditions_permutations (@comps)
4612 if $comp eq '';
4613 local ($neg) = $comp;
4614 $neg =~ s/TRUE$/TRUEO/;
4615 $neg =~ s/FALSE$/TRUE/;
4616 $neg =~ s/TRUEO$/FALSE/;
4617 local (@ret);
4618 local ($sub);
4619 foreach $sub (&variable_conditions_permutations (@comps))
4620 {
4621 push (@ret, '@' . $comp . '@' . $sub);
4622 push (@ret, '@' . $neg . '@' . $sub);
4623 }
4624 if (! @ret)
4625 {
4626 push (@ret, '@' . $comp . '@');
4627 push (@ret, '@' . $neg . '@');
4628 }
4629 return @ret;
4630 }
4632 # Warn if a variable is conditionally defined. This is called if we
4633 # are using the value of a variable.
4634 sub variable_conditionally_defined
4635 {
4636 local ($var, $parent) = @_;
4637 if ($conditional{$var})
4638 {
4639 if ($parent)
4640 {
4641 &am_line_error ($parent,
4642 "warning: automake does not support conditional definition of $var in $parent");
4643 }
4644 else
4645 {
4646 &am_line_error ($parent,
4647 "warning: automake does not support $var being defined conditionally")
4648 }
4649 }
4650 }
4652 # Get the value of a variable. This just returns $contents, but warns
4653 # if the variable is conditionally defined.
4654 sub variable_value
4655 {
4656 local ($var) = @_;
4657 &variable_conditionally_defined ($var);
4658 return $contents{$var};
4659 }
4661 # Convert a variable value to a list, split as whitespace. This will
4662 # recursively follow $(...) and ${...} inclusions. It preserves @...@
4663 # substitutions. If COND is 'all', then all values under all
4664 # conditions should be returned; if COND is a particular condition
4665 # (all conditions are surrounded by @...@) then only the value for
4666 # that condition should be returned; otherwise, warn if VAR is
4667 # conditionally defined.
4668 sub value_to_list
4669 {
4670 local ($var, $val, $cond) = @_;
4671 local (@result);
4673 foreach (split (' ', $val))
4674 {
4675 # If a comment seen, just leave.
4676 last if /^#/;
4678 # Handle variable substitutions.
4679 if (/^\$\{([^}]*)\}$/ || /^\$\(([^)]*)\)$/)
4680 {
4681 local ($varname) = $1;
4682 local ($from, $to);
4683 local (@temp_list);
4684 if ($varname =~ /^([^:]*):([^=]*)=(.*)$/)
4685 {
4686 $varname = $1;
4687 $to = $3;
4688 ($from = $2) =~ s/(\W)/\\$1/g;
4689 }
4691 # Find the value.
4692 @temp_list = &variable_value_as_list ($1, $cond, $var);
4694 # Now rewrite the value if appropriate.
4695 if ($from)
4696 {
4697 grep (s/$from$/$to/, @temp_list);
4698 }
4700 push (@result, @temp_list);
4701 }
4702 else
4703 {
4704 push (@result, $_);
4705 }
4706 }
4708 return @result;
4709 }
4711 # Return contents of variable as list, split as whitespace. This will
4712 # recursively follow $(...) and ${...} inclusions. It preserves @...@
4713 # substitutions. If COND is 'all', then all values under all
4714 # conditions should be returned; if COND is a particular condition
4715 # (all conditions are surrounded by @...@) then only the value for
4716 # that condition should be returned; otherwise, warn if VAR is
4717 # conditionally defined. If PARENT is specified, it is the name of
4718 # the including variable; this is only used for error reports.
4719 sub variable_value_as_list
4720 {
4721 local ($var, $cond, $parent) = @_;
4722 local (@result);
4724 if (defined $targets{$var})
4725 {
4726 &am_line_error ($var, "\`$var' is target; expected variable");
4727 }
4728 elsif (! defined $contents{$var})
4729 {
4730 &am_line_error ($parent, "variable \`$var' not defined");
4731 }
4732 elsif ($cond eq 'all' && $conditional{$var})
4733 {
4734 local (@condvals) = split (/ /, $conditional{$var});
4735 while (@condvals)
4736 {
4737 shift (@condvals);
4738 local ($val) = &unquote_cond_val (shift (@condvals));
4739 push (@result, &value_to_list ($var, $val, $cond));
4740 }
4741 }
4742 elsif ($cond && $conditional{$var})
4743 {
4744 local (@condvals) = split (/ /, $conditional{$var});
4745 local ($onceflag);
4746 while (@condvals)
4747 {
4748 local ($vcond) = shift (@condvals);
4749 local ($val) = &unquote_cond_val (shift (@condvals));
4750 if (&conditional_true_when ($vcond, $cond))
4751 {
4752 # Warn if we have an ambiguity. It's hard to know how
4753 # to handle this case correctly.
4754 &variable_conditionally_defined ($var, $parent)
4755 if $onceflag;
4756 $onceflag = 1;
4757 push (@result, &value_to_list ($var, $val, $cond));
4758 }
4759 }
4760 }
4761 else
4762 {
4763 &variable_conditionally_defined ($var, $parent);
4764 $content_seen{$var} = 1;
4765 push (@result, &value_to_list ($var, $contents{$var}, $cond));
4766 }
4768 return @result;
4769 }
4771 # Define a new variable, but only if not already defined.
4772 sub define_variable
4773 {
4774 local ($var, $value) = @_;
4776 if (! defined $contents{$var})
4777 {
4778 $output_vars .= $var . ' = ' . $value . "\n";
4779 $contents{$var} = $value;
4780 $content_seen{$var} = 1;
4781 }
4782 }
4784 # Like define_variable, but the value is a list, and the variable may
4785 # be defined conditionally. The second argument is the conditional
4786 # under which the value should be defined; this should be the empty
4787 # string to define the variable unconditionally. The third argument
4788 # is a list holding the values to use for the variable. The value is
4789 # pretty printed in the output file.
4790 sub define_pretty_variable
4791 {
4792 local ($var, $cond, @value) = @_;
4793 if (! defined $contents{$var}
4794 || ($cond && ! &variable_defined ($var, $cond)))
4795 {
4796 $contents{$var} = join (' ', @value);
4797 if ($cond)
4798 {
4799 if ($conditional{$var})
4800 {
4801 $conditional{$var} .= ' ';
4802 }
4803 else
4804 {
4805 $conditional{$var} = '';
4806 }
4807 $conditional{$var} .= ($cond
4808 . ' '
4809 . "e_cond_val ($contents{$var}));
4810 }
4811 &pretty_print ($cond . $var . ' = ', $cond, @value);
4812 $content_seen{$var} = 1;
4813 }
4814 }
4816 # Like define_variable, but define a variable to be the configure
4817 # substitution by the same name.
4818 sub define_configure_variable
4819 {
4820 local ($var) = @_;
4821 local ($value) = '@' . $var . '@';
4822 &define_variable ($var, $value);
4823 }
4825 # Define a variable that represents a program to run. If in Cygnus
4826 # mode, the program is searched for in the build (or source) tree.
4827 # Otherwise no searching is done at all. Arguments are:
4828 # * VAR Name of variable to define
4829 # * WHATDIR Either `src' or `build', depending on where program should
4830 # be found. (runtest is in srcdir!)
4831 # * SUBDIR Subdir of top-level dir
4832 # * PROGRAM Name of program
4833 # * OVERRIDE If specified, the name of the program to use when not in
4834 # Cygnus mode. Defaults to PROGRAM.
4835 sub define_program_variable
4836 {
4837 local ($var, $whatdir, $subdir, $program, $override) = @_;
4839 if (! $override)
4840 {
4841 $override = $program;
4842 }
4844 if ($cygnus_mode)
4845 {
4846 local ($full) = ('$(top_' . $whatdir . 'dir)/../'
4847 . $subdir . '/' . $program);
4848 &define_variable ($var, ('`if test -f ' . $full
4849 . '; then echo ' . $full . '; else echo '
4850 . $program . '; fi`'));
4851 }
4852 else
4853 {
4854 &define_variable ($var, $override);
4855 }
4856 }
4859 ################################################################
4861 # Read Makefile.am and set up %contents. Simultaneously copy lines
4862 # from Makefile.am into $output_trailer or $output_vars as
4863 # appropriate. NOTE we put rules in the trailer section. We want
4864 # user rules to come after our generated stuff.
4865 sub read_am_file
4866 {
4867 local ($amfile) = @_;
4869 open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
4870 print "automake: reading $amfile\n" if $verbose;
4872 $output_vars = ("# $in_file_name generated automatically by automake "
4873 . $VERSION . " from $am_file_name\n");
4875 # Generate copyright for generated Makefile.in.
4876 $output_vars .= $gen_copyright;
4878 local ($saw_bk) = 0;
4879 local ($was_rule) = 0;
4880 local ($spacing) = '';
4881 local ($comment) = '';
4882 local ($last_var_name) = '';
4883 local ($blank) = 0;
4885 while (<AM_FILE>)
4886 {
4887 if (/$IGNORE_PATTERN/o)
4888 {
4889 # Merely delete comments beginning with two hashes.
4890 }
4891 elsif (/$WHITE_PATTERN/o)
4892 {
4893 # Stick a single white line before the incoming macro or rule.
4894 $spacing = "\n";
4895 $blank = 1;
4896 }
4897 elsif (/$COMMENT_PATTERN/o)
4898 {
4899 # Stick comments before the incoming macro or rule. Make
4900 # sure a blank line preceeds first block of comments.
4901 $spacing = "\n" unless $blank;
4902 $blank = 1;
4903 $comment .= $spacing . $_;
4904 $spacing = '';
4905 }
4906 else
4907 {
4908 last;
4909 }
4910 }
4912 $output_vars .= $comment . "\n";
4913 $comment = '';
4914 $spacing = "\n";
4915 local ($am_vars) = '';
4917 local ($is_ok_macro);
4918 while ($_)
4919 {
4920 $_ .= "\n"
4921 unless substr ($_, -1, 1) eq "\n";
4923 $_ =~ s/\@MAINT\@//g
4924 unless $seen_maint_mode;
4926 if (/$IGNORE_PATTERN/o)
4927 {
4928 # Merely delete comments beginning with two hashes.
4929 }
4930 elsif (/$WHITE_PATTERN/o)
4931 {
4932 # Stick a single white line before the incoming macro or rule.
4933 $spacing = "\n";
4934 }
4935 elsif (/$COMMENT_PATTERN/o)
4936 {
4937 # Stick comments before the incoming macro or rule.
4938 $comment .= $spacing . $_;
4939 $spacing = '';
4940 }
4941 elsif ($saw_bk)
4942 {
4943 if ($was_rule)
4944 {
4945 $output_trailer .= join ('', @conditional_stack) . $_;
4946 $saw_bk = /\\$/;
4947 }
4948 else
4949 {
4950 $am_vars .= join ('', @conditional_stack) . $_;
4951 $saw_bk = /\\$/;
4952 # Chop newline and backslash if this line is
4953 # continued. FIXME: maybe ensure trailing whitespace
4954 # exists?
4955 chop if $saw_bk;
4956 chop if $saw_bk;
4957 $contents{$last_var_name} .= $_;
4958 if (@conditional_stack)
4959 {
4960 $conditional{$last_var_name} .= "e_cond_val ($_);
4961 }
4962 }
4963 }
4964 elsif (/$IF_PATTERN/o)
4965 {
4966 &am_line_error ($., "$1 does not appear in AM_CONDITIONAL")
4967 if (! $configure_cond{$1});
4968 push (@conditional_stack, "\@" . $1 . "_TRUE\@");
4969 }
4970 elsif (/$ELSE_PATTERN/o)
4971 {
4972 if (! @conditional_stack)
4973 {
4974 &am_line_error ($., "else without if");
4975 }
4976 elsif ($conditional_stack[$#conditional_stack] =~ /_FALSE\@$/)
4977 {
4978 &am_line_error ($., "else after else");
4979 }
4980 else
4981 {
4982 $conditional_stack[$#conditional_stack]
4983 =~ s/_TRUE\@$/_FALSE\@/;
4984 }
4985 }
4986 elsif (/$ENDIF_PATTERN/o)
4987 {
4988 if (! @conditional_stack)
4989 {
4990 &am_line_error ($., "endif without if");
4991 }
4992 else
4993 {
4994 pop @conditional_stack;
4995 }
4996 }
4997 elsif (/$RULE_PATTERN/o)
4998 {
4999 # Found a rule.
5000 $was_rule = 1;
5001 if (defined $contents{$1}
5002 && (@conditional_stack
5003 ? ! defined $conditional{$1}
5004 : defined $conditional{$1}))
5005 {
5006 &am_line_error ($1,
5007 "$1 defined both conditionally and unconditionally");
5008 }
5009 # Value here doesn't matter; for targets we only note
5010 # existence.
5011 $contents{$1} = 1;
5012 $targets{$1} = 1;
5013 local ($cond_string) = join ('', @conditional_stack);
5014 if (@conditional_stack)
5015 {
5016 if ($conditional{$1})
5017 {
5018 &check_ambiguous_conditional ($1, $cond_string);
5019 $conditional{$1} .= ' ';
5020 }
5021 else
5022 {
5023 $conditional{$1} = '';
5024 }
5025 $conditional{$1} .= $cond_string . ' 1';
5026 }
5027 $content_lines{$1} = $.;
5028 $output_trailer .= $comment . $spacing . $cond_string . $_;
5029 $comment = $spacing = '';
5030 $saw_bk = /\\$/;
5031 }
5032 elsif (($is_ok_macro = /$MACRO_PATTERN/o)
5033 || /$BOGUS_MACRO_PATTERN/o)
5034 {
5035 # Found a macro definition.
5036 $was_rule = 0;
5037 $last_var_name = $1;
5038 if (defined $contents{$1}
5039 && (@conditional_stack
5040 ? ! defined $conditional{$1}
5041 : defined $conditional{$1}))
5042 {
5043 &am_line_error ($1,
5044 "$1 defined both conditionally and unconditionally");
5045 }
5046 if ($2 ne '' && substr ($2, -1) eq "\\")
5047 {
5048 $contents{$last_var_name} = substr ($2, 0, length ($2) - 1);
5049 }
5050 else
5051 {
5052 $contents{$last_var_name} = $2;
5053 }
5054 local ($cond_string) = join ('', @conditional_stack);
5055 if (@conditional_stack)
5056 {
5057 if ($conditional{$last_var_name})
5058 {
5059 &check_ambiguous_conditional ($last_var_name,
5060 $cond_string);
5061 $conditional{$last_var_name} .= ' ';
5062 }
5063 else
5064 {
5065 $conditional{$last_var_name} = '';
5066 }
5067 local ($val) = $contents{$last_var_name};
5068 $conditional{$last_var_name} .= ($cond_string
5069 . ' '
5070 . "e_cond_val ($val));
5071 }
5072 $content_lines{$last_var_name} = $.;
5073 $am_vars .= $comment . $spacing . $cond_string . $_;
5074 $comment = $spacing = '';
5075 $saw_bk = /\\$/;
5077 # Error if bogus.
5078 &am_line_error ($., "bad macro name \`$last_var_name'")
5079 if ! $is_ok_macro;
5080 }
5081 else
5082 {
5083 # This isn't an error; it is probably a continued rule.
5084 # In fact, this is what we assume.
5085 $was_rule = 1;
5086 $output_trailer .= ($comment . $spacing
5087 . join ('', @conditional_stack) . $_);
5088 $comment = $spacing = '';
5089 $saw_bk = /\\$/;
5090 }
5092 $_ = <AM_FILE>;
5093 }
5095 $output_trailer .= $comment;
5097 &am_error ("unterminated conditionals: " . join (' ', @conditional_stack))
5098 if (@conditional_stack);
5100 # Compute relative location of the top object directory.
5101 local (@topdir) = ();
5102 foreach (split (/\//, $relative_dir))
5103 {
5104 next if $_ eq '.' || $_ eq '';
5105 if ($_ eq '..')
5106 {
5107 pop @topdir;
5108 }
5109 else
5110 {
5111 push (@topdir, '..');
5112 }
5113 }
5114 @topdir = ('.') if ! @topdir;
5116 $top_builddir = join ('/', @topdir);
5117 local ($build_rx);
5118 ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
5119 $output_vars .= &file_contents_with_transform
5120 ('s/\@top_builddir\@/' . $build_rx . '/g;',
5121 'header-vars');
5123 # Generate some useful variables when AC_CANONICAL_* used. FIXME:
5124 # this should use generic %configure_vars method.
5125 if ($seen_canonical)
5126 {
5127 local ($curs, %vars);
5128 $vars{'host_alias'} = 'host_alias';
5129 $vars{'host_triplet'} = 'host';
5130 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
5131 {
5132 $vars{'build_alias'} = 'build_alias';
5133 $vars{'build_triplet'} = 'build';
5134 $vars{'target_alias'} = 'target_alias';
5135 $vars{'target_triplet'} = 'target';
5136 }
5137 foreach $curs (sort keys %vars)
5138 {
5139 $output_vars .= "$curs = \@$vars{$curs}\@\n";
5140 $contents{$curs} = "\@$vars{$curs}\@";
5141 }
5142 }
5144 local ($curs);
5145 foreach $curs (sort keys %configure_vars)
5146 {
5147 &define_configure_variable ($curs);
5148 }
5150 $output_vars .= $am_vars;
5151 }
5153 ################################################################
5155 sub initialize_global_constants
5156 {
5157 # Values for AC_CANONICAL_*
5158 $AC_CANONICAL_HOST = 1;
5159 $AC_CANONICAL_SYSTEM = 2;
5161 # Associative array of standard directory names. Entry is TRUE if
5162 # corresponding directory should be installed during
5163 # 'install-exec' phase.
5164 %exec_dir_p =
5165 ('bin', 1,
5166 'sbin', 1,
5167 'libexec', 1,
5168 'data', 0,
5169 'sysconf', 1,
5170 'localstate', 1,
5171 'lib', 1,
5172 'info', 0,
5173 'man', 0,
5174 'include', 0,
5175 'oldinclude', 0,
5176 'pkgdata', 0,
5177 'pkglib', 1,
5178 'pkginclude', 0
5179 );
5181 # Helper text for dealing with man pages.
5182 $install_man_format =
5183 ' @sect=@SECTION@; \\
5184 inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
5185 if test -f $(srcdir)/@MAN@; then file=$(srcdir)/@MAN@; \\
5186 else file=@MAN@; fi; \\
5187 echo " $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst"; \\
5188 $(INSTALL_DATA) $$file $(mandir)/man$$sect/$$inst
5189 ';
5191 $uninstall_man_format =
5192 ' inst=`echo "@MANBASE@" | sed \'$(transform)\'`.@FULLSECT@; \\
5193 rm -f $(mandir)/man@SECTION@/$$inst
5194 ';
5196 # Commonly found files we look for and automatically include in
5197 # DISTFILES.
5198 @common_files =
5199 (
5200 "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
5201 "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
5202 "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
5203 "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
5204 'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp',
5205 'ylwrap', 'acinclude.m4', @libtoolize_files,
5206 'missing'
5207 );
5209 # Commonly used files we auto-include, but only sometimes.
5210 @common_sometimes =
5211 (
5212 "aclocal.m4", "acconfig.h", "config.h.top",
5213 "config.h.bot", "stamp-h.in", 'stamp-vti'
5214 );
5216 $USAGE = "\
5217 -a, --add-missing add missing standard files to package
5218 --amdir=DIR directory storing config files
5219 --build-dir=DIR directory where build being done (for dependencies)
5220 --cygnus assume program is part of Cygnus-style tree
5221 --foreign set strictness to foreign
5222 --gnits set strictness to gnits
5223 --gnu set strictness to gnu
5224 --help print this help, then exit
5225 -i, --include-deps include generated dependencies in Makefile.in
5226 --no-force only update Makefile.in's that are out of date
5227 -o DIR, --output-dir=DIR
5228 put generated Makefile.in's into DIR
5229 --srcdir-name=DIR name used for srcdir (for dependencies)
5230 -v, --verbose verbosely list files processed
5231 --version print version number, then exit\n";
5233 # Copyright on generated Makefile.ins.
5234 $gen_copyright = "\
5235 # Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
5236 # This Makefile.in is free software; the Free Software Foundation
5237 # gives unlimited permission to copy, distribute and modify it.
5238 ";
5240 # Ignore return result from chmod, because it might give an error
5241 # if we chmod a symlink.
5242 $dist_header = "\t" . '-chmod -R a+r $(distdir)' . "\n";
5243 $dist{'tarZ'} = ("\t"
5244 . '$(TAR) chf - $(distdir) | compress -c > $(distdir).tar.Z'
5245 . "\n");
5246 $dist{'shar'} = ("\t"
5247 . 'shar $(distdir) | gzip > $(distdir).shar.gz'
5248 . "\n");
5249 $dist{'zip'} = "\t" . 'zip -rq $(distdir).zip $(distdir)' . "\n";
5250 $dist{'dist'} = "\t" . 'GZIP=$(GZIP) $(TAR) chozf $(distdir).tar.gz $(distdir)' . "\n";
5251 $dist_trailer = "\t" . 'rm -rf $(distdir)' . "\n";
5252 }
5254 # (Re)-Initialize per-Makefile.am variables.
5255 sub initialize_per_input
5256 {
5257 # These two variables are used when generating each Makefile.in.
5258 # They hold the Makefile.in until it is ready to be printed.
5259 $output_rules = '';
5260 $output_vars = '';
5261 $output_trailer = '';
5262 $output_header = '';
5264 # Suffixes found during a run.
5265 @suffixes = ();
5267 # This holds the contents of a Makefile.am, as parsed by
5268 # read_am_file.
5269 %contents = ();
5271 # This holds the names which are targets. These also appear in
5272 # %contents.
5273 %targets = ();
5275 # For a variable or target which is defined conditionally, this
5276 # holds an array of the conditional values. The array is composed
5277 # of pairs of condition strings (the variables which configure
5278 # will substitute) and values (the value of a target is
5279 # meaningless). For an unconditional variable, this is empty.
5280 %conditional = ();
5282 # This holds the line numbers at which various elements of
5283 # %contents are defined.
5284 %content_lines = ();
5286 # This holds a 1 if a particular variable was examined.
5287 %content_seen = ();
5289 # This is the conditional stack.
5290 @conditional_stack = ();
5292 # This holds the "relative directory" of the current Makefile.in.
5293 # Eg for src/Makefile.in, this is "src".
5294 $relative_dir = '';
5296 # This holds a list of files that are included in the
5297 # distribution.
5298 %dist_common = ();
5300 # List of dependencies for the obvious targets.
5301 @install_data = ();
5302 @install_exec = ();
5303 @uninstall = ();
5304 @installdirs = ();
5306 @info = ();
5307 @dvi = ();
5308 @all = ();
5309 @check = ();
5310 @check_tests = ();
5311 @installcheck = ();
5312 @clean = ();
5314 @phony = ();
5316 # These are pretty obvious, too. They are used to define the
5317 # SOURCES and OBJECTS variables.
5318 @sources = ();
5319 @objects = ();
5321 # TRUE if current directory holds any C source files.
5322 $dir_holds_sources = 0;
5324 # These variables track inclusion of various compile-related .am
5325 # files. $included_generic_compile is TRUE if the basic code has
5326 # been included. $included_knr_compile is TRUE if the ansi2knr
5327 # code has been included. $included_libtool_compile is TRUE if
5328 # libtool support has been included.
5329 $included_generic_compile = 0;
5330 $included_knr_compile = 0;
5331 $included_libtool_compile = 0;
5333 # TRUE if current directory holds any headers.
5334 $dir_holds_headers = 0;
5336 # TRUE if install targets should work recursively.
5337 $recursive_install = 0;
5339 # All .P files.
5340 %dep_files = ();
5342 # Strictness levels.
5343 $strictness = $default_strictness;
5344 $strictness_name = $default_strictness_name;
5346 # Options from AUTOMAKE_OPTIONS.
5347 %options = ();
5349 # Whether or not dependencies are handled. Can be further changed
5350 # in handle_options.
5351 $use_dependencies = $cmdline_use_dependencies;
5353 # Per Makefile.am.
5354 $local_maint_charset = $maint_charset;
5356 # All yacc and lex source filenames for this directory. Use
5357 # filenames instead of raw count so that multiple instances are
5358 # counted correctly (eg one yacc file can appear in multiple
5359 # programs without harm).
5360 %yacc_sources = ();
5361 %lex_sources = ();
5363 # C++ source extensions we've seen.
5364 %cxx_extensions = ();
5366 # TRUE if we've seen any non-C++ sources. This actually holds a
5367 # line number or the name of a symbol corresponding to a line
5368 # number where the C sources were seen. If it is -1 then it means
5369 # we couldn't (easily) figure out which line of the Makefile.am
5370 # mentioned the sources.
5371 $seen_c_source = 0;
5373 # This is a list of all targets to run during "make dist".
5374 @dist_targets = ();
5376 # Keys in this hash are the basenames of files which must depend
5377 # on ansi2knr.
5378 %de_ansi_files = ();
5379 }
5382 ################################################################
5384 # Return contents of a file from $am_dir, automatically skipping
5385 # macros or rules which are already known. Runs command on each line
5386 # as it is read; this command can modify $_.
5387 sub file_contents_with_transform
5388 {
5389 local ($command, $basename) = @_;
5390 local ($file) = $am_dir . '/' . $basename . '.am';
5392 if ($command ne '' && substr ($command, -1) ne ';')
5393 {
5394 die "automake: programming error in file_contents_with_transform\n";
5395 }
5397 open (FC_FILE, $file)
5398 || die "automake: installation error: cannot open \`$file'\n";
5399 # Looks stupid?
5400 # print "automake: reading $file\n" if $verbose;
5402 local ($was_rule) = 0;
5403 local ($result_vars) = '';
5404 local ($result_rules) = '';
5405 local ($comment) = '';
5406 local ($spacing) = "\n";
5407 local ($skipping) = 0;
5408 local ($had_chars);
5410 while (<FC_FILE>)
5411 {
5412 $_ =~ s/\@MAINT\@//g
5413 unless $seen_maint_mode;
5415 $had_chars = length ($_) && $_ ne "\n";
5416 eval $command;
5417 # If the transform caused all the characters to go away, then
5418 # ignore the line. Why do this? Because in Perl 4, a "next"
5419 # inside of an eval doesn't affect a loop outside the eval.
5420 # So we can't pass in a "transform" that uses next. We used
5421 # to do this. "Empty" also means consisting of a single
5422 # newline.
5423 next if $had_chars && ($_ eq '' || $_ eq "\n");
5425 if (/$IGNORE_PATTERN/o)
5426 {
5427 # Merely delete comments beginning with two hashes.
5428 }
5429 elsif (/$WHITE_PATTERN/o)
5430 {
5431 # Stick a single white line before the incoming macro or rule.
5432 $spacing = "\n";
5433 }
5434 elsif (/$COMMENT_PATTERN/o)
5435 {
5436 # Stick comments before the incoming macro or rule.
5437 $comment .= $spacing . $_;
5438 $spacing = '';
5439 }
5440 elsif ($saw_bk)
5441 {
5442 if ($was_rule)
5443 {
5444 $result_rules .= $_ if ! $skipping;
5445 }
5446 else
5447 {
5448 $result_vars .= $_ if ! $skipping;
5449 }
5450 $saw_bk = /\\$/;
5451 }
5452 elsif (/$RULE_PATTERN/o)
5453 {
5454 # Found a rule.
5455 $was_rule = 1;
5456 $skipping = defined $contents{$1};
5457 $result_rules .= $comment . $spacing . $_ if ! $skipping;
5458 $comment = $spacing = '';
5459 $saw_bk = /\\$/;
5460 }
5461 elsif (/$MACRO_PATTERN/o)
5462 {
5463 # Found a variable reference.
5464 $was_rule = 0;
5465 $skipping = defined $contents{$1};
5466 $result_vars .= $comment . $spacing . $_ if ! $skipping;
5467 $comment = $spacing = '';
5468 $saw_bk = /\\$/;
5469 }
5470 else
5471 {
5472 # This isn't an error; it is probably a continued rule.
5473 # In fact, this is what we assume.
5474 $was_rule = 1;
5475 $result_rules .= $comment . $spacing . $_ if ! $skipping;
5476 $comment = $spacing = '';
5477 $saw_bk = /\\$/;
5478 }
5479 }
5481 close (FC_FILE);
5482 return $result_vars . $result_rules . $comment;
5483 }
5485 # Like file_contents_with_transform, but no transform.
5486 sub file_contents
5487 {
5488 return &file_contents_with_transform ('', @_);
5489 }
5491 # Find all variable prefixes that are used for install directories. A
5492 # prefix `zar' qualifies iff:
5493 # * `zardir' is a variable.
5494 # * `zar_PRIMARY' is a variable.
5495 sub am_primary_prefixes
5496 {
5497 local ($primary, @prefixes) = @_;
5499 local (%valid, $varname);
5500 grep ($valid{$_} = 0, @prefixes);
5501 $valid{'EXTRA'} = 0;
5502 foreach $varname (keys %contents)
5503 {
5504 if ($varname =~ /^(.*)_$primary$/)
5505 {
5506 if (! defined $valid{$1}
5507 && ! &variable_defined ($1 . 'dir')
5508 # Note that a configure variable is always legitimate.
5509 # It is natural to name such variables after the
5510 # primary, so we explicitly allow it.
5511 && ! defined $configure_vars{$varname})
5512 {
5513 &am_line_error ($varname, "invalid variable \"$varname\"");
5514 }
5515 else
5516 {
5517 # Ensure all extended prefixes are actually used.
5518 $valid{$1} = 1;
5519 }
5520 }
5521 }
5523 return %valid;
5524 }
5526 # Handle `where_HOW' variable magic. Does all lookups, generates
5527 # install code, and possibly generates code to define the primary
5528 # variable. The first argument is the name of the .am file to munge,
5529 # the second argument is the primary variable (eg HEADERS), and all
5530 # subsequent arguments are possible installation locations. Returns
5531 # list of all values of all _HOW targets.
5532 #
5533 # FIXME: this should be rewritten to be cleaner. It should be broken
5534 # up into multiple functions.
5535 #
5536 # Usage is: am_install_var (OPTION..., file, HOW, where...)
5537 sub am_install_var
5538 {
5539 local (@args) = @_;
5541 local ($do_clean) = 0;
5543 local ($ltxform);
5544 if (defined $configure_vars{'LIBTOOL'})
5545 {
5546 # Transform '@LIBTOOL ...@' to '$(LIBTOOL) ...'
5547 $ltxform = 's/\@LIBTOOL([^\@]*)\@/\$(LIBTOOL) $1/;';
5548 }
5549 else
5550 {
5551 # Delete '@LIBTOOL ...@'
5552 $ltxform = 's/\@LIBTOOL([^\@]*)\@//;';
5553 }
5555 local ($cygxform);
5556 if (! $seen_cygwin32)
5557 {
5558 $cygxform = 's/\@EXEEXT\@//g; s/^NOTCYGWIN//; s/^CYGWIN.*$//;';
5559 }
5560 else
5561 {
5562 $cygxform = 's/\@EXEEXT\@/\$(EXEEXT)/g; s/^CYGWIN//; s/^NOTCYGWIN.*$//;';
5563 }
5565 while (@args)
5566 {
5567 if ($args[0] eq '-clean')
5568 {
5569 $do_clean = 1;
5570 }
5571 elsif ($args[0] !~ /^-/)
5572 {
5573 last;
5574 }
5575 shift (@args);
5576 }
5577 local ($file, $primary, @prefixes) = @args;
5579 local (@used) = ();
5580 local (@result) = ();
5582 # Now that configure substitutions are allowed in where_HOW
5583 # variables, it is an error to actually define the primary.
5584 &am_line_error ($primary, "\`$primary' is an anachronism")
5585 if &variable_defined ($primary);
5588 # Look for misspellings. It is an error to have a variable ending
5589 # in a "reserved" suffix whose prefix is unknown, eg
5590 # "bni_PROGRAMS". However, unusual prefixes are allowed if a
5591 # variable of the same name (with "dir" appended) exists. For
5592 # instance, if the variable "zardir" is defined, then
5593 # "zar_PROGRAMS" becomes valid. This is to provide a little extra
5594 # flexibility in those cases which need it. Perhaps it should be
5595 # disallowed in the Gnits case? The problem is, sometimes it is
5596 # useful to put things in a subdir of eg pkgdatadir, perhaps even
5597 # for Gnitsoids.
5598 local (%valid) = &am_primary_prefixes ($primary, @prefixes);
5600 # If a primary includes a configure substitution, then the EXTRA_
5601 # form is required. Otherwise we can't properly do our job.
5602 local ($require_extra);
5603 local ($warned_about_extra) = 0;
5605 local ($clean_file) = $file . '-clean';
5606 local ($one_name);
5607 local ($X);
5608 foreach $X (sort keys %valid)
5609 {
5610 $one_name = $X . '_' . $primary;
5611 if (&variable_defined ($one_name))
5612 {
5613 # Append actual contents of where_PRIMARY variable to
5614 # result.
5615 local ($rcurs);
5616 foreach $rcurs (&variable_value_as_list ($one_name, 'all'))
5617 {
5618 # Skip configure substitutions. Possibly bogus.
5619 if ($rcurs =~ /^\@.*\@$/)
5620 {
5621 if ($X eq 'EXTRA')
5622 {
5623 if (! $warned_about_extra)
5624 {
5625 $warned_about_extra = 1;
5626 &am_line_error ($one_name,
5627 "\`$one_name' contains configure substitution, but shouldn't");
5628 }
5629 }
5630 # Check here to make sure variables defined in
5631 # configure.in do not imply that EXTRA_PRIMARY
5632 # must be defined.
5633 elsif (! defined $configure_vars{$one_name})
5634 {
5635 $require_extra = $one_name;
5636 }
5637 next;
5638 }
5639 push (@result, $rcurs);
5640 }
5642 # "EXTRA" shouldn't be used when generating clean targets,
5643 # @all, or install targets.
5644 next if $X eq 'EXTRA';
5646 if ($do_clean)
5647 {
5648 $output_rules .=
5649 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go;'
5650 . $cygxform,
5651 $clean_file);
5653 push (@clean, $X . $primary);
5654 &push_phony_cleaners ($X . $primary);
5655 }
5657 if ($X eq 'check')
5658 {
5659 push (@check, '$(' . $one_name . ')');
5660 }
5661 else
5662 {
5663 push (@used, '$(' . $one_name . ')');
5664 }
5665 if ($X eq 'noinst' || $X eq 'check')
5666 {
5667 # Objects which don't get installed by default.
5668 next;
5669 }
5671 $output_rules .=
5672 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/g;'
5673 . $ltxform . $cygxform,
5674 $file);
5676 push (@uninstall, 'uninstall-' . $X . $primary);
5677 push (@phony, 'uninstall-' . $X . $primary);
5678 push (@installdirs, '$(' . $X . 'dir)');
5679 if (defined $exec_dir_p{$X} ? $exec_dir_p{$X} : ($X =~ /exec/))
5680 {
5681 push (@install_exec, 'install-' . $X . $primary);
5682 push (@phony, 'install-' . $X . $primary);
5683 }
5684 else
5685 {
5686 push (@install_data, 'install-' . $X . $primary);
5687 push (@phony, 'install-' . $X . $primary);
5688 }
5689 }
5690 }
5692 if (@used)
5693 {
5694 # Define it.
5695 &define_pretty_variable ($primary, '', @used);
5696 $output_vars .= "\n";
5697 }
5699 if ($require_extra && ! &variable_defined ('EXTRA_' . $primary))
5700 {
5701 &am_line_error ($require_extra,
5702 "\`$require_extra' contains configure substitution, but \`EXTRA_$primary' not defined");
5703 }
5705 # Push here because PRIMARY might be configure time determined.
5706 push (@all, '$(' . $primary . ')')
5707 if @used;
5709 return (@result);
5710 }
5713 ################################################################
5715 # This variable is local to the "require file" set of functions.
5716 @require_file_paths = ();
5718 # Verify that the file must exist in the current directory. Usage:
5719 # require_file (isconfigure, line_number, strictness, file) strictness
5720 # is the strictness level at which this file becomes required. Must
5721 # set require_file_paths before calling this function.
5722 # require_file_paths is set to hold a single directory (the one in
5723 # which the first file was found) before return.
5724 sub require_file_internal
5725 {
5726 local ($is_configure, $line, $mystrict, @files) = @_;
5727 local ($file, $fullfile);
5728 local ($found_it, $errfile, $errdir);
5729 local ($save_dir);
5731 foreach $file (@files)
5732 {
5733 $found_it = 0;
5734 foreach $dir (@require_file_paths)
5735 {
5736 if ($dir eq '.')
5737 {
5738 $fullfile = $relative_dir . "/" . $file;
5739 $errdir = $relative_dir unless $errdir;
5740 }
5741 else
5742 {
5743 $fullfile = $dir . "/" . $file;
5744 $errdir = $dir unless $errdir;
5745 }
5747 # Use different name for "error filename". Otherwise on
5748 # an error the bad file will be reported as eg
5749 # `../../install-sh' when using the default
5750 # config_aux_path.
5751 $errfile = $errdir . '/' . $file;
5753 if (-f $fullfile)
5754 {
5755 $found_it = 1;
5756 # FIXME: Once again, special-case `.'.
5757 &push_dist_common ($file)
5758 if $dir eq $relative_dir || $dir eq '.';
5759 $save_dir = $dir;
5760 last;
5761 }
5762 }
5764 if ($found_it)
5765 {
5766 # Prune the path list.
5767 @require_file_paths = $save_dir;
5768 }
5769 else
5770 {
5771 if ($strictness >= $mystrict)
5772 {
5773 local ($trailer) = '';
5774 local ($suppress) = 0;
5776 # Only install missing files according to our desired
5777 # strictness level.
5778 if ($add_missing)
5779 {
5780 $suppress = 1;
5782 # Maybe run libtoolize.
5783 if ($seen_libtool
5784 && grep ($_ eq $file, @libtoolize_files)
5785 && system ('libtoolize', '--automake'))
5786 {
5787 $trailer = "; installing";
5788 $suppress = 0;
5789 $trailer .= "; cannot run \`libtoolize': $!";
5790 }
5791 elsif (-f ($am_dir . '/' . $file))
5792 {
5793 # Install the missing file. Symlink if we
5794 # can, copy if we must. Note: delete the file
5795 # first, in case it is a dangling symlink.
5796 $trailer = "; installing";
5797 unlink ($errfile);
5798 if ($symlink_exists)
5799 {
5800 if (! symlink ($am_dir . '/' . $file, $errfile))
5801 {
5802 $suppress = 0;
5803 $trailer .= "; error while making link: $!\n";
5804 }
5805 }
5806 elsif (! system ('cp', $am_dir . '/' . $file, $errfile))
5807 {
5808 $suppress = 0;
5809 $trailer .= "\n error while making link\n";
5810 }
5811 }
5812 }
5814 local ($save) = $exit_status;
5815 if ($is_configure)
5816 {
5817 # FIXME: allow actual file to be specified.
5818 &am_conf_line_error
5819 ('configure.in', $line,
5820 "required file \"$errfile\" not found$trailer");
5821 }
5822 else
5823 {
5824 &am_line_error
5825 ($line,
5826 "required file \"$errfile\" not found$trailer");
5827 }
5828 $exit_status = $save if $suppress;
5829 }
5830 }
5831 }
5832 }
5834 # Like require_file_with_line, but error messages refer to
5835 # configure.in, not the current Makefile.am.
5836 sub require_file_with_conf_line
5837 {
5838 @require_file_paths = '.';
5839 &require_file_internal (1, @_);
5840 }
5842 sub require_file_with_line
5843 {
5844 @require_file_paths = '.';
5845 &require_file_internal (0, @_);
5846 }
5848 sub require_file
5849 {
5850 @require_file_paths = '.';
5851 &require_file_internal (0, '', @_);
5852 }
5854 # Require a file that is also required by Autoconf. Looks in
5855 # configuration path, as specified by AC_CONFIG_AUX_DIR.
5856 sub require_config_file
5857 {
5858 @require_file_paths = @config_aux_path;
5859 &require_file_internal (1, '', @_);
5860 local ($dir) = $require_file_paths[0];
5861 @config_aux_path = @require_file_paths;
5862 if ($dir eq '.')
5863 {
5864 $config_aux_dir = '.';
5865 }
5866 else
5867 {
5868 $config_aux_dir = '$(top_srcdir)/' . $dir;
5869 }
5870 }
5872 # Assumes that the line number is in Makefile.am.
5873 sub require_conf_file_with_line
5874 {
5875 @require_file_paths = @config_aux_path;
5876 &require_file_internal (0, @_);
5877 local ($dir) = $require_file_paths[0];
5878 @config_aux_path = @require_file_paths;
5879 if ($dir eq '.')
5880 {
5881 $config_aux_dir = '.';
5882 }
5883 else
5884 {
5885 $config_aux_dir = '$(top_srcdir)/' . $dir;
5886 }
5887 }
5889 # Assumes that the line number is in Makefile.am.
5890 sub require_conf_file_with_conf_line
5891 {
5892 @require_file_paths = @config_aux_path;
5893 &require_file_internal (1, @_);
5894 local ($dir) = $require_file_paths[0];
5895 @config_aux_path = @require_file_paths;
5896 if ($dir eq '.')
5897 {
5898 $config_aux_dir = '.';
5899 }
5900 else
5901 {
5902 $config_aux_dir = '$(top_srcdir)/' . $dir;
5903 }
5904 }
5906 ################################################################
5908 # Push a list of files onto dist_common.
5909 sub push_dist_common
5910 {
5911 local (@files) = @_;
5912 local ($file);
5914 foreach $file (@files)
5915 {
5916 $dist_common{$file} = 1;
5917 }
5918 }
5920 # Push a list of clean targets onto phony.
5921 sub push_phony_cleaners
5922 {
5923 local ($base) = @_;
5924 local ($target);
5925 foreach $target ('mostly', 'dist', '', 'maintainer-')
5926 {
5927 push (@phony, $target . 'clean-' . $base);
5928 }
5929 }
5931 # Set strictness.
5932 sub set_strictness
5933 {
5934 $strictness_name = $_[0];
5935 if ($strictness_name eq 'gnu')
5936 {
5937 $strictness = $GNU;
5938 }
5939 elsif ($strictness_name eq 'gnits')
5940 {
5941 $strictness = $GNITS;
5942 }
5943 elsif ($strictness_name eq 'foreign')
5944 {
5945 $strictness = $FOREIGN;
5946 }
5947 else
5948 {
5949 die "automake: level \`$strictness_name' not recognized\n";
5950 }
5951 }
5954 ################################################################
5956 # Return directory name of file.
5957 sub dirname
5958 {
5959 local ($file) = @_;
5960 local ($sub);
5962 ($sub = $file) =~ s,/+[^/]+$,,g;
5963 $sub = '.' if $sub eq $file;
5964 return $sub;
5965 }
5967 # Return file name of a file.
5968 sub basename
5969 {
5970 local ($file) = @_;
5971 local ($sub);
5973 ($sub = $file) =~s,^.*/+,,g;
5974 return $sub;
5975 }
5977 # Touch a file.
5978 sub touch
5979 {
5980 local ($file) = @_;
5982 open (TOUCH, ">> $file");
5983 close (TOUCH);
5984 }
5986 # Glob something. Do this to avoid indentation screwups everywhere we
5987 # want to glob. Gross!
5988 sub my_glob
5989 {
5990 local ($pat) = @_;
5991 return <${pat}>;
5992 }
5994 ################################################################
5996 # Print an error message and set exit status.
5997 sub am_error
5998 {
5999 warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
6000 $exit_status = 1;
6001 }
6003 sub am_line_error
6004 {
6005 local ($symbol, @args) = @_;
6007 if ($symbol && "$symbol" ne '-1')
6008 {
6009 # If SYMBOL not already a line number, look it up in Makefile.am.
6010 if ($symbol =~ /^\d+$/)
6011 {
6012 $symbol .= ': ';
6013 }
6014 elsif (defined $content_lines{$symbol})
6015 {
6016 $symbol = $content_lines{$symbol} . ': ';
6017 }
6018 else
6019 {
6020 # A single space, to provide nice separation.
6021 $symbol = ' ';
6022 }
6023 warn "${am_file}.am:", $symbol, join (' ', @args), "\n";
6024 $exit_status = 1;
6025 }
6026 else
6027 {
6028 &am_error (@args);
6029 }
6030 }
6032 # Like am_error, but while scanning configure.in.
6033 sub am_conf_error
6034 {
6035 # FIXME: can run in subdirs.
6036 warn "automake: configure.in: ", join (' ', @_), "\n";
6037 $exit_status = 1;
6038 }
6040 # Error message with line number referring to configure.in.
6041 sub am_conf_line_error
6042 {
6043 local ($file, $line, @args) = @_;
6045 if ($line)
6046 {
6047 warn "$file: $line: ", join (' ', @args), "\n";
6048 $exit_status = 1;
6049 }
6050 else
6051 {
6052 &am_conf_error (@args);
6053 }
6054 }
6056 # Tell user where our aclocal.m4 is, but only once.
6057 sub keyed_aclocal_warning
6058 {
6059 local ($key) = @_;
6060 warn "automake: macro \`$key' can be generated by \`aclocal'\n";
6061 }
6063 # Print usage information.
6064 sub usage
6065 {
6066 print "Usage: automake [OPTION] ... [Makefile]...\n";
6067 print $USAGE;
6068 print "\nFiles which are automatically distributed, if found:\n";
6069 $~ = "USAGE_FORMAT";
6070 local (@lcomm) = sort ((@common_files, @common_sometimes));
6071 local ($one, $two, $three, $four);
6072 while (@lcomm > 0)
6073 {
6074 $one = shift @lcomm;
6075 $two = @lcomm ? shift @lcomm : '';
6076 $three = @lcomm ? shift @lcomm : '';
6077 $four = @lcomm ? shift @lcomm : '';
6078 write;
6079 }
6081 print "\nReport bugs to <automake-bugs\@gnu.ai.mit.edu>\n";
6083 exit 0;
6084 }
6086 format USAGE_FORMAT =
6087 @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<
6088 $one, $two, $three, $four
6089 .