| blob | 66ed92d37904e11a66d1032cece9b9f729504a90 |
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-99, 2000 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@";
37 # String constants.
38 $IGNORE_PATTERN = "^##([^#].*)?\$";
39 $WHITE_PATTERN = "^[ \t]*\$";
40 $COMMENT_PATTERN = "^#";
41 $RULE_PATTERN = "^([\$a-zA-Z_.][-.a-zA-Z0-9_(){}/\$]*) *:([^=].*|)\$";
42 $SUFFIX_RULE_PATTERN = "^\\.([a-zA-Z0-9]+)\\.([a-zA-Z0-9]+)\$";
43 $MACRO_PATTERN = "^([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]*\(#.*\)?\$";
49 $PATH_PATTERN='(\\w|[/.-])+';
50 # This will pass through anything not of the prescribed form.
51 $INCLUDE_PATTERN = "^include[ \t]+((\\\$\\\(top_srcdir\\\)/${PATH_PATTERN})|(\\\$\\\(srcdir\\\)/${PATH_PATTERN})|([^/\\\$]${PATH_PATTERN}))[ \t]*(#.*)?\$";
53 # Some regular expressions. One reason to put them here is that it
54 # makes indentation work better in Emacs.
55 $AC_CONFIG_AUX_DIR_PATTERN = "AC_CONFIG_AUX_DIR\\(([^)]+)\\)";
56 $AM_INIT_AUTOMAKE_PATTERN = "AM_INIT_AUTOMAKE\\([^,]*,([^,)]+)[,)]";
57 $AM_PACKAGE_VERSION_PATTERN = "^\\s*\\[?([^]\\s]+)\\]?\\s*\$";
58 # Note that there is no AC_PATH_TOOL. But we don't really care.
59 $AC_CHECK_PATTERN = "AC_(CHECK|PATH)_(PROG|PROGS|TOOL)\\(\\[?(\\w+)";
60 $AM_MISSING_PATTERN = "AM_MISSING_PROG\\(\\[?(\\w+)";
61 # Just check for alphanumeric in AC_SUBST. If you do AC_SUBST(5),
62 # then too bad.
63 $AC_SUBST_PATTERN = "AC_SUBST\\(\\[?(\\w+)";
64 $AM_CONDITIONAL_PATTERN = "AM_CONDITIONAL\\((\\w+)";
66 # Constants to define the "strictness" level.
67 $FOREIGN = 0;
68 $GNU = 1;
69 $GNITS = 2;
71 # These constants are returned by lang_*_rewrite functions.
72 # LANG_SUBDIR means that the resulting object file should be in a
73 # subdir if the source file is. In this case the file name cannot
74 # have `..' components.
75 $LANG_IGNORE = 0;
76 $LANG_PROCESS = 1;
77 $LANG_SUBDIR = 2;
79 \f
81 # Variables global to entire run.
83 # TRUE if we should always generate Makefile.in.
84 $force_generation = 1;
86 # Strictness level as set on command line.
87 $default_strictness = $GNU;
89 # Name of strictness level, as set on command line.
90 $default_strictness_name = 'gnu';
92 # This is TRUE if automatic dependency generation code should be
93 # included in generated Makefile.in.
94 $cmdline_use_dependencies = 1;
96 # TRUE if in verbose mode.
97 $verbose = 0;
99 # This holds our (eventual) exit status. We don't actually exit until
100 # we have processed all input files.
101 $exit_status = 0;
103 # From the Perl manual.
104 $symlink_exists = (eval 'symlink ("", "");', $@ eq '');
106 # TRUE if missing standard files should be installed.
107 $add_missing = 0;
109 # TRUE if we should copy missing files; otherwise symlink if possible.
110 $copy_missing = 0;
112 # TRUE if we should always update files that we know about.
113 $force_missing = 0;
115 # Files found by scanning configure.in for LIBOBJS.
116 %libsources = ();
118 # True if AM_C_PROTOTYPES appears in configure.in.
119 $am_c_prototypes = 0;
121 # Names used in AC_CONFIG_HEADER call. @config_fullnames holds the
122 # name which appears in AC_CONFIG_HEADER, colon and all.
123 # @config_names holds the file names. @config_headers holds the '.in'
124 # files. Ordinarily these are similar, but they can be different if
125 # the weird "NAME:FILE" syntax is used.
126 @config_fullnames = ();
127 @config_names = ();
128 @config_headers = ();
129 # Line number at which AC_CONFIG_HEADER appears in configure.in.
130 $config_header_line = 0;
132 # Directory where output files go. Actually, output files are
133 # relative to this directory.
134 $output_directory = '.';
136 # Relative location of top build directory.
137 $top_builddir = '';
139 # List of Makefile.am's to process, and their corresponding outputs.
140 @input_files = ();
141 %output_files = ();
143 # Complete list of Makefile.am's that exist.
144 @configure_input_files = ();
146 # List of files in AC_OUTPUT without Makefile.am, and their outputs.
147 @other_input_files = ();
148 # Line number at which AC_OUTPUT seen.
149 $ac_output_line = 0;
151 # List of directories to search for configure-required files. This
152 # can be set by AC_CONFIG_AUX_DIR.
153 @config_aux_path = ('.', '..', '../..');
154 $config_aux_dir = '';
156 # Whether AC_PROG_MAKE_SET has been seen in configure.in.
157 $seen_make_set = 0;
159 # Whether AM_GNU_GETTEXT has been seen in configure.in.
160 $seen_gettext = 0;
161 # Line number at which AM_GNU_GETTEXT seen.
162 $ac_gettext_line = 0;
164 # Whether ALL_LINGUAS has been seen.
165 $seen_linguas = '';
166 # The actual text.
167 $all_linguas = '';
168 # Line number at which it appears.
169 $all_linguas_line = 0;
171 # 1 if AC_PROG_INSTALL seen.
172 $seen_prog_install = 0;
174 # Whether AC_PATH_XTRA has been seen in configure.in.
175 $seen_path_xtra = 0;
177 # TRUE if AC_DECL_YYTEXT was seen.
178 $seen_decl_yytext = 0;
180 # TRUE if we've seen AC_CANONICAL_(HOST|SYSTEM). The presence of
181 # AC_CHECK_TOOL also sets this.
182 $seen_canonical = 0;
184 # TRUE if we've seen AC_ARG_PROGRAM.
185 $seen_arg_prog = 0;
187 # TRUE if we've seen AC_PROG_LIBTOOL.
188 $seen_libtool = 0;
189 $libtool_line = 0;
191 # Files installed by libtoolize.
192 @libtoolize_files = ('ltconfig', 'ltmain.sh', 'config.guess', 'config.sub');
194 # TRUE if we've seen AM_MAINTAINER_MODE.
195 $seen_maint_mode = 0;
197 # Actual version we've seen.
198 $package_version = '';
200 # Line number where we saw version definition.
201 $package_version_line = 0;
203 # TRUE if we've seen AM_PATH_LISPDIR.
204 $seen_lispdir = 0;
206 # TRUE if we've seen AM_CHECK_PYTHON.
207 $seen_pythondir = 0;
209 # TRUE if we've seen AC_EXEEXT.
210 $seen_exeext = 0;
212 # TRUE if we've seen AC_OBJEXT.
213 $seen_objext = 0;
215 # TRUE if we've seen AC_ENABLE_MULTILIB.
216 $seen_multilib = 0;
218 # TRUE if we've seen AM_PROG_CC_C_O
219 $seen_cc_c_o = 0;
221 # TRUE if we've seen AM_INIT_AUTOMAKE.
222 $seen_init_automake = 0;
224 # Hash table of discovered configure substitutions. Keys are names,
225 # values are `FILE:LINE' strings which are used by error message
226 # generation.
227 %configure_vars = ();
229 # This is used to keep track of which variable definitions we are
230 # scanning. It is only used in certain limited ways, but it has to be
231 # global. It is declared just for documentation purposes.
232 %vars_scanned = ();
234 # Charsets used by maintainer and in distribution. MAINT_CHARSET is
235 # handled in a funny way: if seen in the top-level Makefile.am, it is
236 # used for every directory which does not specify a different value.
237 # The rationale here is that some directories (eg gettext) might be
238 # distributions of other packages, and thus require their own charset
239 # info. However, the DIST_CHARSET must be the same for the entire
240 # package; it can only be set at top-level.
241 # FIXME: this yields bugs when rebuilding. What to do? Always
242 # read (and sometimes discard) top-level Makefile.am?
243 $maint_charset = '';
244 $dist_charset = 'utf8'; # recode doesn't support this yet.
246 # Name of input file ("Makefile.in") and output file ("Makefile.am").
247 # These have no directory components.
248 $am_file_name = '';
249 $in_file_name = '';
251 # TRUE if --cygnus seen.
252 $cygnus_mode = 0;
254 # Hash table of AM_CONDITIONAL variables seen in configure.
255 %configure_cond = ();
257 # Map from obsolete macros to hints for new macros.
258 # If you change this, change the corresponding list in aclocal.in.
259 # FIXME: should just put this into a single file.
260 %obsolete_macros =
261 (
262 'AC_FEATURE_CTYPE', "use \`AC_HEADER_STDC'",
263 'AC_FEATURE_ERRNO', "add \`strerror' to \`AC_REPLACE_FUNCS(...)'",
264 'AC_FEATURE_EXIT', '',
265 'AC_SYSTEM_HEADER', '',
267 # Note that we do not handle this one, because it is still run
268 # from AM_CONFIG_HEADER. So we deal with it specially in
269 # scan_configure.
270 # 'AC_CONFIG_HEADER', "use \`AM_CONFIG_HEADER'",
272 'fp_C_PROTOTYPES', "use \`AM_C_PROTOTYPES'",
273 'fp_PROG_CC_STDC', "use \`AM_PROG_CC_STDC'",
274 'fp_PROG_INSTALL', "use \`AC_PROG_INSTALL'",
275 'fp_WITH_DMALLOC', "use \`AM_WITH_DMALLOC'",
276 'fp_WITH_REGEX', "use \`AM_WITH_REGEX'",
277 'gm_PROG_LIBTOOL', "use \`AM_PROG_LIBTOOL'",
278 'jm_MAINTAINER_MODE', "use \`AM_MAINTAINER_MODE'",
279 'md_TYPE_PTRDIFF_T', "use \`AM_TYPE_PTRDIFF_T'",
280 'ud_PATH_LISPDIR', "use \`AM_PATH_LISPDIR'",
281 'ud_GNU_GETTEXT', "use \`AM_GNU_GETTEXT'",
283 # Now part of autoconf proper, under a different name.
284 'AM_FUNC_FNMATCH', "use \`AC_FUNC_FNMATCH'",
285 'fp_FUNC_FNMATCH', "use \`AC_FUNC_FNMATCH'",
286 'AM_SANITY_CHECK_CC', "automatically done by \`AC_PROG_CC'",
287 'AM_PROG_INSTALL', "use \`AC_PROG_INSTALL'",
288 'AM_EXEEXT', "use \`AC_EXEEXT'",
289 'AM_CYGWIN32', "use \`AC_CYGWIN'",
290 'AM_MINGW32', "use \`AC_MINGW32'",
291 'AM_FUNC_MKTIME', "use \`AC_FUNC_MKTIME'",
293 # These aren't quite obsolete.
294 # 'md_PATH_PROG',
295 );
297 # Regexp to match the above macros.
298 $obsolete_rx = '(' . join ('|', keys %obsolete_macros) . ')';
300 # This maps extensions onto language names.
301 %extension_map = ();
303 # This maps languages names onto properties.
304 %language_map = ();
306 # This holds all the files that would go in `dist_common' which we
307 # discovered while scanning configure.in. We might distribute these
308 # in the top-level Makefile.in.
309 %configure_dist_common = ();
311 \f
313 # Initialize global constants and our list of languages that are
314 # internally supported.
315 &initialize_global_constants;
317 ®ister_language ('c', 'ansi-p=1', 'autodep=', 'flags=CFLAGS',
318 'compile=$(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)',
319 'compiler-name=COMPILE',
320 'output-arg=-c',
321 'c');
322 ®ister_language ('cxx', 'linker=CXXLINK', 'autodep=CXX', 'flags=CXXFLAGS',
323 'compile=$(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)',
324 'compiler-name=CXXCOMPILE',
325 'output-arg=-c -o $@',
326 'c++', 'cc', 'cpp', 'cxx', 'C');
327 ®ister_language ('objc', 'linker=OBJCLINK', 'autodep=OBJC',
328 'flags=OBJCFLAGS',
329 'compile=$(OBJC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_OBJCFLAGS) $(OBJCFLAGS)',
330 'compiler-name=OBJCCOMPILE',
331 'output-arg=-c -o $@',
332 'm');
333 ®ister_language ('header',
334 'h', 'H', 'hxx', 'h++', 'hh', 'hpp', 'inc');
336 # For now, yacc and lex can't be handled on a per-exe basis.
337 ®ister_language ('yacc', 'ansi-p=1',
338 'y');
339 ®ister_language ('yaccxx', 'linker=CXXLINK',
340 'y++', 'yy', 'yxx', 'ypp');
341 ®ister_language ('lex', 'ansi-p=1',
342 'l');
343 ®ister_language ('lexxx', 'linker=CXXLINK',
344 'l++', 'll', 'lxx', 'lpp');
346 ®ister_language ('asm',
347 'flags=CFLAGS', # FIXME: asmflags?
348 'compile=$(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)', # FIXME: a different compiler?
349 'compiler-name=COMPILE',
350 'output-arg=-c',
351 's', 'S');
353 ®ister_language ('f77', 'linker=F77LINK', 'flags=FFLAGS',
354 'compile=$(F77) $(AM_FFLAGS) $(FFLAGS)',
355 'compiler-name=F77COMPILE',
356 'output-arg=-c -o $@',
357 'f', 'for', 'f90');
358 ®ister_language ('ppf77', 'linker=F77LINK', 'flags=FFLAGS',
359 'compile=$(F77) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_FFLAGS) $(FFLAGS)',
360 'compiler-name=PPF77COMPILE',
361 'output-arg=-c -o $@',
362 'F');
363 ®ister_language ('ratfor', 'linker=F77LINK',
364 'flags=RFLAGS', # FIXME also FFLAGS.
365 'compile=$(F77) $(AM_FFLAGS) $(FFLAGS) $(AM_RFLAGS) $(RFLAGS)',
366 'compiler-name=RCOMPILE',
367 'output-arg=-c -o $@',
368 'r');
369 # FIXME: for now we can't do dependency tracking for Java.
370 # autodep=GCJ
371 ®ister_language ('java', 'linker=GCJLINK', 'flags=GCJFLAGS',
372 'compile=$(GCJ) $(DEFS) $(INCLUDES) $(AM_GCJFLAGS) $(GCJFLAGS)',
373 'compiler-name=GCJCOMPILE',
374 'output-arg=-c -o $@',
375 'java', 'class', 'zip', 'jar');
378 # Parse command line.
379 &parse_arguments (@ARGV);
381 # Do configure.in scan only once.
382 &scan_configure;
384 die "automake: no \`Makefile.am' found or specified\n"
385 if ! @input_files;
387 # Now do all the work on each file.
388 foreach $am_file (@input_files)
389 {
390 if (! -f ($am_file . '.am'))
391 {
392 &am_error ("\`" . $am_file . ".am' does not exist");
393 }
394 else
395 {
396 &generate_makefile ($output_files{$am_file}, $am_file);
397 }
398 }
400 &am_conf_error ("AC_PROG_INSTALL must be used in configure.in")
401 if (! $seen_prog_install);
403 exit $exit_status;
406 ################################################################
408 # Parse command line.
409 sub parse_arguments
410 {
411 local (@arglist) = @_;
413 # Start off as gnu.
414 &set_strictness ('gnu');
416 while (@arglist)
417 {
418 if ($arglist[0] eq "--version")
419 {
420 print "automake (GNU $PACKAGE) $VERSION\n\n";
421 print "Copyright (C) 2000 Free Software Foundation, Inc.\n";
422 print "This is free software; see the source for copying conditions. There is NO\n";
423 print "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n";
424 print "Written by Tom Tromey <tromey\@cygnus.com>\n";
426 exit 0;
427 }
428 elsif ($arglist[0] eq "--help")
429 {
430 &usage;
431 }
432 elsif ($arglist[0] =~ /^--amdir=(.+)$/)
433 {
434 $am_dir = $1;
435 }
436 elsif ($arglist[0] eq '--amdir')
437 {
438 &require_argument (@arglist);
439 shift (@arglist);
440 $am_dir = $arglist[0];
441 }
442 elsif ($arglist[0] eq '--gnu')
443 {
444 &set_strictness ('gnu');
445 }
446 elsif ($arglist[0] eq '--gnits')
447 {
448 &set_strictness ('gnits');
449 }
450 elsif ($arglist[0] eq '--cygnus')
451 {
452 $cygnus_mode = 1;
453 }
454 elsif ($arglist[0] eq '--foreign')
455 {
456 &set_strictness ('foreign');
457 }
458 elsif ($arglist[0] eq '--include-deps')
459 {
460 $cmdline_use_dependencies = 1;
461 }
462 elsif ($arglist[0] eq '--ignore-deps' || $arglist[0] eq '-i')
463 {
464 $cmdline_use_dependencies = 0;
465 }
466 elsif ($arglist[0] eq '--no-force')
467 {
468 $force_generation = 0;
469 }
470 elsif ($arglist[0] eq '--force-missing')
471 {
472 $force_missing = 1;
473 }
474 elsif ($arglist[0] =~ /^--output-dir=(.*)$/)
475 {
476 # Set output directory.
477 $output_directory = $1;
478 }
479 elsif ($arglist[0] eq '--output-dir' || $arglist[0] eq '-o')
480 {
481 &require_argument (@arglist);
482 shift (@arglist);
483 $output_directory = $arglist[0];
484 }
485 elsif ($arglist[0] eq '--add-missing' || $arglist[0] eq '-a')
486 {
487 $add_missing = 1;
488 }
489 elsif ($arglist[0] eq '--copy' || $arglist[0] eq '-c')
490 {
491 $copy_missing = 1;
492 }
493 elsif ($arglist[0] eq '--verbose' || $arglist[0] eq '-v')
494 {
495 $verbose = 1;
496 }
497 elsif ($arglist[0] eq '--')
498 {
499 # Stop option processing.
500 shift (@arglist);
501 push (@input_files, @arglist);
502 last;
503 }
504 elsif ($arglist[0] =~ /^-/)
505 {
506 die "automake: unrecognized option -- \`$arglist[0]'\nTry \`automake --help' for more information.\n";
507 }
508 else
509 {
510 # Handle $local:$input syntax. Note that we only examine
511 # the first ":" file to see if it is automake input; the
512 # rest are just taken verbatim. We still keep all the
513 # files around for dependency checking, however.
514 local ($local, $input, @rest) = split (/:/, $arglist[0]);
515 if (! $input)
516 {
517 $input = $local;
518 }
519 else
520 {
521 # Strip .in; later on .am is tacked on. That is how
522 # the automake input file is found. Maybe not the
523 # best way, but it is easy to explain. FIXME: should
524 # be error if .in is missing.
525 $input =~ s/\.in$//;
526 }
527 push (@input_files, $input);
528 $output_files{$input} = join (':', ($local, @rest));
529 }
531 shift (@arglist);
532 }
534 # Take global strictness from whatever we currently have set.
535 $default_strictness = $strictness;
536 $default_strictness_name = $strictness_name;
537 }
539 # Ensure argument exists, or die.
540 sub require_argument
541 {
542 local ($arg, @arglist) = @_;
543 die "automake: no argument given for option \`$arg'\n"
544 if ! @arglist;
545 }
547 ################################################################
549 # Generate a Makefile.in given the name of the corresponding Makefile and
550 # the name of the file output by config.status.
551 sub generate_makefile
552 {
553 local ($output, $makefile) = @_;
555 ($am_file_name = $makefile) =~ s/^.*\///;
556 $in_file_name = $am_file_name . '.in';
557 $am_file_name .= '.am';
559 # $OUTPUT is encoded. If it contains a ":" then the first element
560 # is the real output file, and all remaining elements are input
561 # files. We don't scan or otherwise deal with these input file,
562 # other than to mark them as dependencies. See scan_configure for
563 # details.
564 local (@secondary_inputs);
565 ($output, @secondary_inputs) = split (/:/, $output);
567 &initialize_per_input;
568 $relative_dir = &dirname ($output);
569 $am_relative_dir = &dirname ($makefile);
571 # At the toplevel directory, we might need config.guess, config.sub
572 # or libtool scripts (ltconfig and ltmain.sh).
573 if ($relative_dir eq '.')
574 {
575 # libtool requires some files.
576 &require_conf_file_with_conf_line ($libtool_line, $FOREIGN,
577 @libtoolize_files)
578 if $seen_libtool;
580 # AC_CANONICAL_HOST and AC_CANONICAL_SYSTEM need config.guess and
581 # config.sub.
582 &require_config_file ($FOREIGN, 'config.guess', 'config.sub')
583 if $seen_canonical;
584 }
586 # We still need Makefile.in here, because sometimes the `dist'
587 # target doesn't re-run automake.
588 if ($am_relative_dir eq $relative_dir)
589 {
590 # Only distribute the files if they are in the same subdir as
591 # the generated makefile.
592 &push_dist_common ($in_file_name, $am_file_name);
593 }
595 push (@sources, '$(SOURCES)')
596 if &variable_defined ('SOURCES');
597 push (@objects, '$(OBJECTS)')
598 if &variable_defined ('OBJECTS');
600 &read_main_am_file ($makefile . '.am');
601 if (&handle_options)
602 {
603 # Fatal error. Just return, so we can continue with next file.
604 return;
605 }
607 # Must do this after reading .am file. See read_main_am_file to
608 # understand weird tricks we play there with variables.
609 &define_variable ('subdir', $relative_dir);
611 # Check first, because we might modify some state.
612 &check_cygnus;
613 &check_gnu_standards;
614 &check_gnits_standards;
616 &handle_configure ($output, $makefile, @secondary_inputs);
617 &handle_gettext;
618 &handle_libraries;
619 &handle_ltlibraries;
620 &handle_programs;
621 &handle_scripts;
623 &handle_built_sources;
625 # This must be run after all the sources are scanned.
626 &finish_languages;
628 # Re-init SOURCES and OBJECTS. FIXME: other code shouldn't depend
629 # on this (but currently does).
630 $contents{'SOURCES'} = join (' ', @sources);
631 $contents{'OBJECTS'} = join (' ', @objects);
632 &define_pretty_variable ('DIST_SOURCES', '', @dist_sources);
634 &handle_multilib;
635 &handle_texinfo;
636 &handle_emacs_lisp;
637 &handle_python;
638 &handle_java;
639 &handle_man_pages;
640 &handle_data;
641 &handle_headers;
642 &handle_subdirs;
643 &handle_tags;
644 &handle_minor_options;
645 &handle_dependencies;
646 &handle_tests;
648 # This must come after most other rules.
649 &handle_dist ($makefile);
651 &handle_footer;
652 &handle_merge_targets ($output);
653 &handle_installdirs;
654 &handle_clean;
655 &handle_phony;
657 &check_typos;
659 if (! -d ($output_directory . '/' . $am_relative_dir))
660 {
661 mkdir ($output_directory . '/' . $am_relative_dir, 0755);
662 }
664 local ($out_file) = $output_directory . '/' . $makefile . ".in";
665 if (! $force_generation && -e $out_file)
666 {
667 local ($am_time) = (stat ($makefile . '.am'))[9];
668 local ($in_time) = (stat ($out_file))[9];
669 # FIXME: should cache these times.
670 local ($conf_time) = (stat ('configure.in'))[9];
671 # FIXME: how to do unsigned comparison?
672 if ($am_time < $in_time || $am_time < $conf_time)
673 {
674 # No need to update.
675 return;
676 }
677 if (-f 'aclocal.m4')
678 {
679 local ($acl_time) = (stat _)[9];
680 return if ($am_time < $acl_time);
681 }
682 }
684 if (! open (GM_FILE, "> " . $out_file))
685 {
686 warn "automake: ${am_file}.in: cannot write: $!\n";
687 $exit_status = 1;
688 return;
689 }
690 print "automake: creating ", $makefile, ".in\n" if $verbose;
692 print GM_FILE $output_vars;
693 # We make sure that `all:' is the first target.
694 print GM_FILE $output_all;
695 print GM_FILE $output_header;
696 print GM_FILE $output_rules;
697 print GM_FILE $output_trailer;
699 if (! close (GM_FILE))
700 {
701 warn "automake: $am_file.in: cannot close: $!\n";
702 $exit_status = 1;
703 return;
704 }
705 }
707 ################################################################
709 # Handle AUTOMAKE_OPTIONS variable. Return 1 on error, 0 otherwise.
710 sub handle_options
711 {
712 if (&variable_defined ('AUTOMAKE_OPTIONS'))
713 {
714 foreach (&variable_value_as_list ('AUTOMAKE_OPTIONS', ''))
715 {
716 $options{$_} = 1;
717 if ($_ eq 'gnits' || $_ eq 'gnu' || $_ eq 'foreign')
718 {
719 &set_strictness ($_);
720 }
721 elsif ($_ eq 'cygnus')
722 {
723 $cygnus_mode = 1;
724 }
725 elsif (/ansi2knr/)
726 {
727 # An option like "../lib/ansi2knr" is allowed. With
728 # no path prefix, we assume the required programs are
729 # in this directory. We save the actual option for
730 # later.
731 $options{'ansi2knr'} = $_;
732 }
733 elsif ($_ eq 'no-installman' || $_ eq 'no-installinfo'
734 || $_ eq 'dist-shar' || $_ eq 'dist-zip'
735 || $_ eq 'dist-tarZ' || $_ eq 'dist-bzip2'
736 || $_ eq 'dejagnu' || $_ eq 'no-texinfo.tex'
737 || $_ eq 'readme-alpha' || $_ eq 'check-news'
738 || $_ eq 'subdir-objects' || $_ eq 'nostdinc')
739 {
740 # Explicitly recognize these.
741 }
742 elsif ($_ eq 'no-dependencies')
743 {
744 $use_dependencies = 0;
745 }
746 elsif (/([0-9]+)\.([0-9]+)([a-z])?/)
747 {
748 # Got a version number.
750 local ($rmajor, $rminor, $ralpha) = ($1, $2, $3);
752 if ($VERSION !~ /([0-9]+)\.([0-9]+)([a-z])?/)
753 {
754 print STDERR
755 "automake: programming error: version is incorrect\n";
756 exit 1;
757 }
758 local ($tmajor, $tminor, $talpha) = ($1, $2, $3);
760 # 2.0 is better than 1.0.
761 # 1.2 is better than 1.1.
762 # 1.2a is better than 1.2.
763 if ($rmajor > $tmajor
764 || ($rmajor == $tmajor && $rminor > $tminor)
765 || ($rminor == $tminor && $rminor == $tminor
766 && $ralpha gt $talpha))
767 {
768 &am_line_error ('AUTOMAKE_OPTIONS',
769 "require version $_, only have $VERSION");
770 return 1;
771 }
772 }
773 else
774 {
775 &am_line_error ('AUTOMAKE_OPTIONS',
776 "option \`" . $_ . "\' not recognized");
777 }
778 }
779 }
781 if ($strictness == $GNITS)
782 {
783 $options{'readme-alpha'} = 1;
784 $options{'check-news'} = 1;
785 }
787 return 0;
788 }
790 # Return object extension. Just once, put some code into the output.
791 # Argument is the name of the output file
792 sub get_object_extension
793 {
794 local ($out) = @_;
796 # Maybe require libtool library object files.
797 local ($extension) = '.o';
798 $extension = '.$(OBJEXT)' if $seen_objext;
799 $extension = '.lo' if ($out =~ /\.la$/);
801 if (! $included_generic_compile)
802 {
803 # Boilerplate.
804 local ($xform) = '';
805 if (! defined $options{'nostdinc'})
806 {
807 $xform = ' -I. -I\$(srcdir)';
809 if (&variable_defined ('CONFIG_HEADER'))
810 {
811 local ($one_hdr);
812 foreach $one_hdr (split (' ',
813 &variable_value ('CONFIG_HEADER')))
814 {
815 local ($var);
816 ($var = &dirname ($one_hdr)) =~ s/(\W)/\\$1/g;
817 $xform .= ' -I' . $var;
818 }
819 }
820 }
821 $xform = 's/\@DEFAULT_INCLUDES\@/' . $xform . '/go;';
822 $output_vars .= &file_contents_with_transform ($xform,
823 'comp-vars');
825 $xform = $seen_objext ? 's/^OBJEXT//;' : 's/^OBJEXT.*$//;';
826 $output_rules .= &file_contents_with_transform ($xform, 'compile');
828 &push_phony_cleaners ('compile');
830 # If using X, include some extra variable definitions. NOTE
831 # we don't want to force these into CFLAGS or anything,
832 # because not all programs will necessarily use X.
833 if ($seen_path_xtra)
834 {
835 local ($var);
836 foreach $var ('X_CFLAGS', 'X_LIBS', 'X_EXTRA_LIBS', 'X_PRE_LIBS')
837 {
838 &define_configure_variable ($var);
839 }
840 }
842 push (@suffixes, '.c', '.o');
843 push (@suffixes, '.obj') if $seen_objext;
844 push (@clean, 'compile');
846 $included_generic_compile = 1;
847 }
849 if ($seen_libtool && ! $included_libtool_compile)
850 {
851 # Output the libtool compilation rules.
852 $output_rules .= &file_contents ('libtool');
854 &push_phony_cleaners ('libtool');
856 push (@suffixes, '.lo');
857 push (@clean, 'libtool');
859 $included_libtool_compile = 1;
860 }
862 # Check for automatic de-ANSI-fication.
863 if (defined $options{'ansi2knr'})
864 {
865 $extension = '$U' . $extension;
866 if (! $included_knr_compile)
867 {
868 if (! $am_c_prototypes)
869 {
870 &am_line_error ('AUTOMAKE_OPTIONS',
871 "option \`ansi2knr' in use but \`AM_C_PROTOTYPES' not in configure.in");
872 &keyed_aclocal_warning ('AM_C_PROTOTYPES');
873 # Only give this error once.
874 $am_c_prototypes = 1;
875 }
877 # Only require ansi2knr files if they should appear in
878 # this directory.
879 if ($options{'ansi2knr'} eq 'ansi2knr')
880 {
881 &require_file_with_line ('AUTOMAKE_OPTIONS', $FOREIGN,
882 'ansi2knr.c', 'ansi2knr.1');
883 $output_rules .= &file_contents ('kr-extra');
884 push (@clean, 'krextra');
885 &push_phony_cleaners ('krextra');
886 }
888 # Generate rules to build ansi2knr. If it is in some
889 # other directory, then generate dependencies but have the
890 # rule just run elsewhere.
891 $objext = $seen_objext ? ".\$(OBJEXT)" : ".o";
892 $output_rules .= ($options{'ansi2knr'} . ': '
893 . $options{'ansi2knr'} . $objext . "\n");
894 if ($options{'ansi2knr'} eq 'ansi2knr')
895 {
896 $output_rules .= ("\t\$(LINK) ansi2knr" . $objext
897 . " \$(LIBS)\n"
898 . "ansi2knr" . $objext
899 . ": \$(CONFIG_HEADER)\n\n");
900 }
901 else
902 {
903 $output_rules .= ("\tcd " . &dirname ($options{'ansi2knr'})
904 . " && \$(MAKE) \$(AM_MAKEFLAGS) "
905 . "ansi2knr\n\n");
906 # This is required for non-GNU makes.
907 $output_rules .= ($options{'ansi2knr'} . $objext . ":\n");
908 $output_rules .= ("\tcd " . &dirname ($options{'ansi2knr'})
909 . " && \$(MAKE) \$(AM_MAKEFLAGS)"
910 . " ansi2knr" . $objext . "\n\n");
911 }
913 # Make sure ansi2knr can be found: if no path specified,
914 # specify "./".
915 if ($options{'ansi2knr'} eq 'ansi2knr')
916 {
917 # Substitution from AM_C_PROTOTYPES. This makes it be
918 # built only when necessary.
919 &define_configure_variable ('ANSI2KNR');
920 # ansi2knr needs to be built before subdirs, so unshift it.
921 unshift (@all, '$(ANSI2KNR)');
922 }
923 else
924 {
925 # Found in another directory.
926 &define_variable ("ANSI2KNR", $options{'ansi2knr'});
927 }
929 $output_rules .= &file_contents ('clean-kr');
931 push (@clean, 'kr');
932 &push_phony_cleaners ('kr');
934 $included_knr_compile = 1;
935 }
936 }
938 return $extension;
939 }
941 # Call finish function for each language that was used.
942 sub finish_languages
943 {
944 local ($ltcompile, $ltlink) = &libtool_compiler;
946 local ($ext, $name, $lang, %done);
947 local ($non_c) = 1;
948 foreach $ext (sort keys %extension_seen)
949 {
950 $lang = $extension_map{$ext};
952 # Generate the appropriate rules for this extension. If
953 # dependency tracking was requested, and this extension
954 # supports it, then we don't generate the rule here.
955 local ($comp) = '';
957 if ($use_dependencies && $language_map{$lang . '-autodep'} ne 'no')
958 {
959 # Don't generate the rule, but still generate the variables.
960 if (defined $language_map{$lang . '-compile'})
961 {
962 $comp = $language_map{$lang . '-compile'};
963 }
964 }
965 elsif (defined $language_map{$lang . '-compile'})
966 {
967 $comp = $language_map{$lang . '-compile'};
969 local ($outarg) = $language_map{$lang . '-output-arg'};
970 if ($language_map{$lang . '-flags'} eq 'CFLAGS')
971 {
972 # C compilers don't always support -c -o.
973 if (defined $options{'subdir-objects'})
974 {
975 $outarg .= ' -o $@';
976 }
977 }
979 local ($full) = ("\t\$("
980 . $language_map{$lang . '-compiler-name'}
981 . ") "
982 . $outarg);
983 $output_rules .= (".$ext.o:\n"
984 . $full
985 . " \$<\n");
986 # FIXME: Using cygpath should be somehow conditional.
987 $output_rules .= (".$ext.obj:\n"
988 . $full
989 . " \`cygpath -w \$<\`\n")
990 if $seen_objext;
991 $output_rules .= (".$ext.lo:\n"
992 . "\t\$(LT"
993 . $language_map{$lang . '-compiler-name'}
994 . ") "
995 . $language_map{$lang . '-output-arg'}
996 # We can always use -c -o with libtool.
997 . ($language_map{$lang . '-flags'} eq 'CFLAGS'
998 ? ' -o $@' : '')
999 . " \$<\n")
1000 if $seen_libtool;
1001 }
1003 push (@suffixes, '.' . $ext);
1005 # The rest of the loop is done once per language.
1006 next if defined $done{$lang};
1007 $done{$lang} = 1;
1009 $non_c = 0 if $lang !~ /(objc|cxx|f77|ratfor)$/;
1011 if ($comp ne '')
1012 {
1013 &define_compiler_variable ($language_map{$lang . '-compiler-name'},
1014 $ltcompile, $comp);
1015 }
1016 # The compiler's flag must be a configure variable.
1017 if (defined $language_map{$lang . '-flags'})
1018 {
1019 &define_configure_variable ($language_map{$lang . '-flags'});
1020 }
1022 # Compute the function name of the finisher and then call it.
1023 $name = 'lang_' . $lang . '_finish';
1024 & $name ();
1025 }
1027 # If the project is entirely C++ or entirely Fortran 77, don't
1028 # bother with the C stuff. But if anything else creeps in, then use
1029 # it.
1030 if (! $non_c || scalar keys %suffix_rules > 0)
1031 {
1032 if (! defined $done{'c'})
1033 {
1034 &define_configure_variable ($language_map{'c-flags'});
1035 &define_compiler_variable ($language_map{'c-compiler-name'},
1036 $ltcompile,
1037 $language_map{'c-compile'});
1038 }
1039 &define_variable ('CCLD', '$(CC)');
1040 &define_variable ('LINK', $ltlink . '$(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
1041 }
1042 }
1044 # Output a rule to build from a YACC source. The output from YACC is
1045 # compiled with C or C++, depending on the extension of the YACC file.
1046 sub output_yacc_build_rule
1047 {
1048 local ($yacc_suffix, $use_ylwrap, $c_suffix) = @_;
1050 local ($suffix);
1051 ($suffix = $yacc_suffix) =~ tr/y/c/;
1052 push (@suffixes, $yacc_suffix, $suffix);
1054 # Generate rule for c/c++.
1055 $output_rules .= "$yacc_suffix$suffix:\n\t";
1057 if ($use_ylwrap)
1058 {
1059 $output_rules .= ('$(SHELL) $(YLWRAP)'
1060 . ' "$(YACC)" $< y.tab.c $*' . $suffix
1061 . ' y.tab.h $*.h -- $(AM_YFLAGS) $(YFLAGS)');
1062 }
1063 else
1064 {
1065 $output_rules .= ('$(YACC) $(AM_YFLAGS) $(YFLAGS) $< && mv y.tab.c $*'
1066 . $suffix . "\n"
1067 . "\tif test -f y.tab.h; then \\\n"
1068 . "\tif cmp -s y.tab.h \$*.h; then rm -f y.tab.h; else mv y.tab.h \$*.h; fi; \\\n"
1069 . "\telse :; fi");
1070 }
1071 $output_rules .= "\n";
1072 }
1074 sub output_lex_build_rule
1075 {
1076 local ($lex_suffix, $use_ylwrap) = @_;
1077 local ($c_suffix);
1079 ($c_suffix = $lex_suffix) =~ tr/l/c/;
1080 push (@suffixes, $lex_suffix);
1081 &define_configure_variable ('LEX_OUTPUT_ROOT');
1082 &define_configure_variable ('LEXLIB');
1083 $output_rules .= "$lex_suffix$c_suffix:\n\t";
1085 if ($use_ylwrap)
1086 {
1087 # Is the $@ correct here? If so, why not use it in the ylwrap
1088 # build rule for yacc above?
1089 $output_rules .= '$(SHELL) $(YLWRAP)'
1090 . ' "$(LEX)" $< $(LEX_OUTPUT_ROOT).c $@ -- $(AM_LFLAGS) $(LFLAGS)';
1091 }
1092 else
1093 {
1094 $output_rules .= '$(LEX) $(AM_LFLAGS) $(LFLAGS) $< && mv $(LEX_OUTPUT_ROOT).c $@';
1095 }
1096 $output_rules .= "\n";
1097 }
1100 # Check to make sure a source defined in LIBOBJS is not explicitly
1101 # mentioned. This is a separate function (as opposed to being inlined
1102 # in handle_source_transform) because it isn't always appropriate to
1103 # do this check.
1104 sub check_libobjs_sources
1105 {
1106 local ($one_file, $unxformed) = @_;
1108 local ($prefix, $file, @files);
1109 foreach $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
1110 'dist_EXTRA_', 'nodist_EXTRA_')
1111 {
1112 if (&variable_defined ($prefix . $one_file . '_SOURCES'))
1113 {
1114 @files = &variable_value_as_list (($prefix
1115 . $one_file . '_SOURCES'),
1116 'all');
1117 }
1118 elsif ($prefix eq '')
1119 {
1120 @files = ($unxformed . '.c');
1121 }
1122 else
1123 {
1124 next;
1125 }
1127 foreach $file (@files)
1128 {
1129 if (defined $libsources{$file})
1130 {
1131 &am_line_error ($prefix . $one_file . '_SOURCES',
1132 "automatically discovered file \`$file' should not be explicitly mentioned");
1133 }
1134 }
1135 }
1136 }
1138 # Does much of the actual work for handle_source_transform.
1139 # Arguments are:
1140 # name of resulting executable or library ("derived")
1141 # object extension (e.g., `$U.lo')
1142 # list of source files to transform
1143 # Result is a list
1144 # first element is name of linker to use (empty string for default linker)
1145 # remaining elements are names of objects
1146 sub handle_single_transform_list
1147 {
1148 local ($var, $derived, $obj, @files) = @_;
1149 local (@result) = ();
1150 local ($nonansi_obj) = $obj;
1151 $nonansi_obj =~ s/_//g;
1152 local (%linkers_used) = ();
1153 if (@files > 0)
1154 {
1155 # Turn sources into objects.
1156 foreach (@files)
1157 {
1158 # Configure substitutions in _SOURCES variables are errors.
1159 if (/^\@.*\@$/)
1160 {
1161 &am_line_error ($var, "$var includes configure substitution \`$_'");
1162 next;
1163 }
1165 # If the source file is in a subdirectory then the `.o' is
1166 # put into the current directory.
1168 # Split file name into base and extension.
1169 local ($full, $directory, $base, $extension, $linker, $object);
1170 next if ! /^((.*)\/)?([^\/]*)\.(.*)$/;
1171 $full = $_;
1172 $directory = $2;
1173 $base = $3;
1174 $extension = $4;
1176 local ($xbase) = $base;
1178 # We must generate a rule for the object if it requires
1179 # its own flags.
1180 local ($rule) = '';
1181 local ($renamed) = 0;
1183 $extension = &derive_suffix ($extension);
1184 local ($lang) = $extension_map{$extension};
1185 if ($lang)
1186 {
1187 &saw_extension ($extension);
1188 # Found the language, so see what it says.
1189 local ($subr) = 'lang_' . $lang . '_rewrite';
1190 # Note: computed subr call.
1191 local ($r) = & $subr ($directory, $base, $extension);
1192 # Skip this entry if we were asked not to process it.
1193 next if $r == $LANG_IGNORE;
1195 # Now extract linker and other info.
1196 $linker = $language_map{$lang . '-linker'};
1198 local ($this_obj_ext);
1199 if ($language_map{$lang . '-ansi-p'})
1200 {
1201 $object = $base . $obj;
1202 $this_obj_ext = $obj;
1203 }
1204 else
1205 {
1206 $object = $base . $nonansi_obj;
1207 $this_obj_ext = $nonansi_obj;
1208 }
1210 if ($language_map{$lang . '-flags'} ne ''
1211 && &variable_defined ($derived . '_'
1212 . $language_map{$lang . '-flags'}))
1213 {
1214 # We have a per-executable flag in effect for this
1215 # object. In this case we rewrite the object's
1216 # name to ensure it is unique. We also require
1217 # the `compile' program to deal with compilers
1218 # where `-c -o' does not work.
1220 # We choose the name `DERIVED-OBJECT' to ensure
1221 # (1) uniqueness, and (2) continuity between
1222 # invocations. However, this will result in a
1223 # name that is too long for losing systems, in
1224 # some situations. So we provide _SHORTNAME to
1225 # override.
1227 local ($dname) = $derived;
1228 if (&variable_defined ($derived . '_SHORTNAME'))
1229 {
1230 # FIXME: should use the same conditional as
1231 # the _SOURCES variable. But this is really
1232 # silly overkill -- nobody should have
1233 # conditional shortnames.
1234 $dname = &variable_value ($derived . '_SHORTNAME');
1235 }
1236 $object = $dname . '-' . $object;
1238 &require_file ($FOREIGN, 'compile')
1239 if $lang eq 'c';
1241 if (! defined $language_map{$lang . '-compile'})
1242 {
1243 print STDERR "automake: programming error: $lang flags defined without compiler\n";
1244 exit 1;
1245 }
1246 # Compute the rule to compile this object.
1247 local ($flag) = $language_map{$lang . '-flags'};
1248 local ($val) = "(${derived}_${flag}";
1249 ($rule = $language_map{$lang . '-compile'}) =~
1250 s/\(AM_$flag/$val/;
1252 $rule .= ' ' . $language_map{$lang . '-output-arg'};
1253 # For C we have to add the -o, because the
1254 # standard rule doesn't include it.
1255 if ($language_map{$lang . '-flags'} eq 'CFLAGS')
1256 {
1257 $rule .= ' -o $@';
1258 }
1260 $renamed = 1;
1261 }
1263 # If rewrite said it was ok, put the object into a
1264 # subdir.
1265 if ($r == $LANG_SUBDIR && $directory ne '')
1266 {
1267 $object = $directory . '/' . $object;
1268 $xbase = $directory . '/' . $base;
1269 }
1271 # If doing dependency tracking, then we can't print
1272 # the rule. Also, if we have a subdir object, we need
1273 # to generate an explicit rule.
1274 if (($use_dependencies
1275 && $rule ne ''
1276 && $language_map{$lang . '-autodep'} ne 'no')
1277 || ($r == $LANG_SUBDIR && $directory ne ''))
1278 {
1279 $rule = '';
1280 local ($obj_sans_ext) = substr ($object, 0,
1281 - length ($this_obj_ext));
1282 $lang_specific_files{$lang} .= (' ' . $derived
1283 . ' ' . $full
1284 . ' ' . $obj_sans_ext);
1285 }
1286 }
1287 elsif ($extension eq 'o')
1288 {
1289 # This is probably the result of a direct suffix rule.
1290 # In this case we just accept the rewrite. FIXME:
1291 # this fails if we want libtool objects.
1292 $object = $base . '.' . $extension;
1293 $linker = '';
1294 }
1295 else
1296 {
1297 # No error message here. Used to have one, but it was
1298 # very unpopular.
1299 next;
1300 }
1302 $linkers_used{$linker} = 1;
1304 push (@result, $object);
1306 if (defined $object_map{$object})
1307 {
1308 if ($object_map{$object} ne $full)
1309 {
1310 &am_error ("object \`$object' created by \`$full' and \`$object_map{$object}'");
1311 }
1312 }
1313 else
1314 {
1315 local (@dep_list) = ();
1316 $object_map{$object} = $full;
1318 # If file is in subdirectory, we need explicit
1319 # dependency.
1320 if ($directory ne '' || $renamed)
1321 {
1322 push (@dep_list, $full);
1323 }
1325 # If resulting object is in subdir, we need to make
1326 # sure the subdir exists at build time.
1327 if ($object =~ /\//)
1328 {
1329 # FIXME: check that $DIRECTORY is somewhere in the
1330 # project
1332 # We don't allow `..' in object file names for
1333 # *any* source, not just Java. For Java it just
1334 # doesn't make sense, but in general it is
1335 # a problem because we can't pick a good name for
1336 # the .deps entry.
1337 if ($object =~ /(\/|^)\.\.\//)
1338 {
1339 &am_error ("\`$full' contains \`..' component but should not");
1340 }
1342 push (@dep_list, $directory . '/.dirstamp');
1344 # If we're generating dependencies, we also want
1345 # to make sure that the appropriate subdir of the
1346 # .deps directory is created.
1347 if ($use_dependencies)
1348 {
1349 push (@dep_list, '.deps/' . $directory . '/.dirstamp');
1350 }
1352 if (! defined $directory_map{$directory})
1353 {
1354 $directory_map{$directory} = 1;
1355 $output_rules .= ($directory . "/.dirstamp:\n"
1356 . "\t\@\$(mkinstalldirs) $directory\n"
1357 . "\t\@: > $directory/.dirstamp\n");
1358 if ($use_dependencies)
1359 {
1360 $output_rules .= ('.deps/' . $directory
1361 . "/.dirstamp:\n"
1362 . "\t\@\$(mkinstalldirs) .deps/$directory\n"
1363 . "\t\@: > .deps/$directory/.dirstamp\n");
1364 }
1365 }
1366 }
1368 &pretty_print_rule ($object . ':', "\t", @dep_list)
1369 if scalar @dep_list > 0 || $rule ne '';
1371 # Print the rule if we have one.
1372 if ($rule ne '')
1373 {
1374 # Turn `$@' into name of our object file.
1375 local ($xform);
1376 ($xform = $object) =~ s,/,\\/,g;
1377 $rule =~ s/\$\@/$xform/;
1379 # We cannot use $< here since this is an explicit
1380 # rule and not all makes handle that.
1381 $rule .= " \`test -f $full || echo '\$(srcdir)/'\`$full";
1383 # FIXME: handle .lo and .obj as well.
1384 $output_rules .= "\t" . $rule . "\n";
1385 }
1386 }
1388 # Transform .o or $o file into .P file (for automatic
1389 # dependency code).
1390 local ($depfile) = $object;
1391 $depfile =~ s/\.([^.]*)$/.P$1/;
1392 $depfile =~ s/\$\(OBJEXT\)$/o/ if $seen_objext;
1393 $dep_files{'$(DEPDIR)/' . $depfile} = 1;
1394 }
1395 }
1397 return (&resolve_linker (%linkers_used), @result);
1398 }
1400 # Handle SOURCE->OBJECT transform for one program or library.
1401 # Arguments are:
1402 # canonical (transformed) name of object to build
1403 # actual name of object to build
1404 # object extension (ie either `.o' or `$o'.
1405 # Return result is name of linker variable that must be used.
1406 # Empty return means just use `LINK'.
1407 sub handle_source_transform
1408 {
1409 # one_file is canonical name. unxformed is given name. obj is
1410 # object extension.
1411 local ($one_file, $unxformed, $obj) = @_;
1413 local ($linker) = '';
1415 if (&variable_defined ($one_file . "_OBJECTS"))
1416 {
1417 &am_line_error ($one_file . '_OBJECTS',
1418 $one_file . '_OBJECTS', 'should not be defined');
1419 # No point in continuing.
1420 return;
1421 }
1423 local (@files, @result, $prefix, $temp, $xpfx);
1424 local (%used_pfx) = ();
1425 foreach $prefix ('', 'EXTRA_', 'dist_', 'nodist_',
1426 'dist_EXTRA_', 'nodist_EXTRA_')
1427 {
1428 # We are going to define _OBJECTS variables using the prefix.
1429 # Then we glom them all together. So we can't use the null
1430 # prefix here as we need it later.
1431 $xpfx = ($prefix eq '') ? 'am_' : $prefix;
1433 @files = ();
1434 local ($var) = $prefix . $one_file . "_SOURCES";
1435 if (&variable_defined ($var))
1436 {
1437 # Keep track of which prefixes we saw.
1438 $used_pfx{$xpfx} = 1
1439 unless $prefix =~ /EXTRA_/;
1441 push (@sources, '$(' . $prefix . $one_file . "_SOURCES)");
1442 push (@objects, '$(' . $xpfx . $one_file . "_OBJECTS)")
1443 unless $prefix =~ /EXTRA_/;
1444 push (@dist_sources, '$(' . $prefix . $one_file . "_SOURCES)")
1445 unless $prefix =~ /^nodist_/;
1446 local (@conds) = &variable_conditions ($var);
1447 if (! @conds)
1448 {
1449 @files = &variable_value_as_list ($var, '');
1450 }
1451 else
1452 {
1453 local ($cond);
1454 foreach $cond (@conds)
1455 {
1456 @files = &variable_value_as_list ($var, $cond);
1457 ($temp, @result) =
1458 &handle_single_transform_list ($var, $one_file, $obj,
1459 @files);
1460 $linker = $temp if $linker eq '';
1462 # Define _OBJECTS conditionally.
1463 &define_pretty_variable ($xpfx . $one_file . '_OBJECTS',
1464 $cond, @result)
1465 unless $prefix =~ /EXTRA_/;
1466 }
1468 next;
1469 }
1470 }
1472 # Avoid defining needless variables.
1473 next if (scalar @files == 0);
1475 ($temp, @result) = &handle_single_transform_list ($var, $one_file,
1476 $obj, @files);
1477 $linker = $temp if $linker eq '';
1478 &define_pretty_variable ($xpfx . $one_file . "_OBJECTS", '', @result)
1479 unless $prefix =~ /EXTRA_/;
1480 }
1482 local (@keys) = sort keys %used_pfx;
1483 if (scalar @keys == 0)
1484 {
1485 &define_variable ($one_file . "_SOURCES", $unxformed . ".c");
1486 push (@sources, $unxformed . '.c');
1487 push (@dist_sources, $unxformed . '.c');
1488 push (@objects, $unxformed . $obj);
1489 push (@files, $unxformed . '.c');
1491 ($temp, @result) = &handle_single_transform_list ($one_file . '_SOURCES',
1492 $one_file, $obj,
1493 @files);
1494 $linker = $temp if $linker eq '';
1495 &define_pretty_variable ($one_file . "_OBJECTS", '', @result)
1496 }
1497 else
1498 {
1499 grep ($_ = '$(' . $_ . $one_file . '_OBJECTS)', @keys);
1500 &define_pretty_variable ($one_file . '_OBJECTS', '', @keys);
1501 }
1503 return $linker;
1504 }
1506 # Handle the BUILT_SOURCES variable.
1507 sub handle_built_sources
1508 {
1509 return unless &variable_defined ('BUILT_SOURCES');
1511 local (@sources) = &variable_value_as_list ('BUILT_SOURCES', 'all');
1512 local ($s);
1513 foreach $s (@sources)
1514 {
1515 if (/^\@.*\@$/)
1516 {
1517 # FIXME: is this really the right thing to do?
1518 &am_line_error ('BUILT_SOURCES',
1519 "\`BUILT_SOURCES' should not contain a configure substitution");
1520 last;
1521 }
1522 }
1523 }
1525 # Special-case @ALLOCA@ and @LIBOBJS@ in _LDADD or _LIBADD variables.
1526 # Also, generate _DEPENDENCIES variable if appropriate.
1527 # Arguments are:
1528 # transformed name of object being built, or empty string if no object
1529 # name of _LDADD/_LIBADD-type variable to examine
1530 # boolean (lex_seen) which is true if a lex source file was seen in this
1531 # object. valid only for LDADDs, not LIBADDs.
1532 # Returns 1 if LIBOBJS seen, 0 otherwise.
1533 sub handle_lib_objects
1534 {
1535 local ($xname, $var, $lex_seen) = @_;
1536 local ($ret);
1538 die "automake: programming error 1 in handle_lib_objects\n"
1539 if ! &variable_defined ($var);
1541 die "automake: programming error 2 in handle_lib_objects\n"
1542 if $lex_seen && $var =~ /LIBADD/;
1544 local (@conds) = &variable_conditions ($var);
1545 if (! @conds)
1546 {
1547 $ret = &handle_lib_objects_cond ($xname, $var, $lex_seen, '');
1548 }
1549 else
1550 {
1551 local ($cond);
1552 $ret = 0;
1553 foreach $cond (@conds)
1554 {
1555 if (&handle_lib_objects_cond ($xname, $var, $lex_seen, $cond))
1556 {
1557 $ret = 1;
1558 }
1559 }
1560 }
1562 return $ret;
1563 }
1565 # Subroutine of handle_lib_objects: handle a particular condition.
1566 sub handle_lib_objects_cond
1567 {
1568 local ($xname, $var, $lex_seen, $cond) = @_;
1570 # We recognize certain things that are commonly put in LIBADD or
1571 # LDADD.
1572 local ($lsearch);
1573 local (@dep_list) = ();
1575 local ($seen_libobjs) = 0;
1576 local ($flagvar) = 0;
1578 foreach $lsearch (&variable_value_as_list ($var, $cond))
1579 {
1580 # Skip -lfoo and -Ldir; these are explicitly allowed.
1581 next if $lsearch =~ /^-[lL]/;
1582 if (! $flagvar && $lsearch =~ /^-/)
1583 {
1584 if ($var =~ /^(.*)LDADD$/)
1585 {
1586 # Skip -dlopen and -dlpreopen; these are explicitly allowed.
1587 next if $lsearch =~ /^-dl(pre)?open$/;
1588 &am_line_error ($var, "linker flags such as \`$lsearch' belong in \`${1}LDFLAGS");
1589 }
1590 else
1591 {
1592 # Only get this error once.
1593 $flagvar = 1;
1594 &am_line_error ($var, "linker flags such as \`$lsearch' belong in \`${1}LDFLAGS");
1595 }
1596 }
1598 # Assume we have a file of some sort, and push it onto the
1599 # dependency list. Autoconf substitutions are not pushed;
1600 # rarely is a new dependency substituted into (eg) foo_LDADD
1601 # -- but "bad things (eg -lX11) are routinely substituted.
1602 # Note that LIBOBJS and ALLOCA are exceptions to this rule,
1603 # and handled specially below.
1604 push (@dep_list, $lsearch)
1605 unless $lsearch =~ /^\@.*\@$/;
1607 # Automatically handle @LIBOBJS@ and @ALLOCA@. Basically this
1608 # means adding entries to dep_files.
1609 if ($lsearch =~ /^\@(LT)?LIBOBJS\@$/)
1610 {
1611 local ($myobjext) = ($1 ? 'l' : '') . 'o';
1613 push (@dep_list, $lsearch);
1614 $seen_libobjs = 1;
1615 if (! keys %libsources
1616 && ! &variable_defined ($1 . 'LIBOBJS'))
1617 {
1618 &am_line_error ($var, "\@$1" . "LIBOBJS\@ seen but never set in \`configure.in'");
1619 }
1621 local ($iter, $rewrite);
1622 foreach $iter (keys %libsources)
1623 {
1624 if ($iter =~ /\.([cly])$/)
1625 {
1626 &saw_extension ($1);
1627 &saw_extension ('c');
1628 }
1630 if ($iter =~ /\.h$/)
1631 {
1632 &require_file_with_line ($var, $FOREIGN, $iter);
1633 }
1634 elsif ($iter ne 'alloca.c')
1635 {
1636 ($rewrite = $iter) =~ s/\.c$/.P$myobjext/;
1637 $dep_files{'$(DEPDIR)/' . $rewrite} = 1;
1638 ($rewrite = $iter) =~ s/(\W)/\\$1/g;
1639 $rewrite = "^" . $rewrite . "\$";
1640 # Only require the file if it is not a built source.
1641 if (! &variable_defined ('BUILT_SOURCES')
1642 || ! grep (/$rewrite/,
1643 &variable_value_as_list ('BUILT_SOURCES',
1644 'all')))
1645 {
1646 &require_file_with_line ($var, $FOREIGN, $iter);
1647 }
1648 }
1649 }
1650 }
1651 elsif ($lsearch =~ /^\@(LT)?ALLOCA\@$/)
1652 {
1653 local ($myobjext) = ($1 ? 'l' : '') . 'o';
1655 push (@dep_list, $lsearch);
1656 &am_line_error ($var,
1657 "\@$1" . "ALLOCA\@ seen but \`AC_FUNC_ALLOCA' not in \`configure.in'")
1658 if ! defined $libsources{'alloca.c'};
1659 $dep_files{'$(DEPDIR)/alloca.P' . $myobjext} = 1;
1660 &require_file_with_line ($var, $FOREIGN, 'alloca.c');
1661 &saw_extension ('c');
1662 }
1663 }
1665 if ($xname ne '' && ! &variable_defined ($xname . '_DEPENDENCIES', $cond))
1666 {
1667 &define_pretty_variable ($xname . '_DEPENDENCIES', $cond, @dep_list);
1668 }
1670 return $seen_libobjs;
1671 }
1673 # Canonicalize a name, and check to make sure the non-canonical name
1674 # is never used. Returns canonical name. Arguments are name and a
1675 # list of suffixes to check for.
1676 sub check_canonical_spelling
1677 {
1678 local ($name, @suffixes) = @_;
1679 local ($xname, $xt);
1681 ($xname = $name) =~ tr/A-Za-z0-9_/_/c;
1682 if ($xname ne $name)
1683 {
1684 local ($xt);
1685 foreach $xt (@suffixes)
1686 {
1687 &am_line_error ($name . $xt,
1688 "invalid variable \`" . $name . $xt
1689 . "'; should be \`" . $xname . $xt . "'")
1690 if &variable_defined ($name . $xt);
1691 }
1692 }
1694 return $xname;
1695 }
1697 # Handle C programs.
1698 sub handle_programs
1699 {
1700 local (@proglist) = &am_install_var ('-clean',
1701 'progs', 'PROGRAMS',
1702 'bin', 'sbin', 'libexec', 'pkglib',
1703 'noinst', 'check');
1704 return if ! @proglist;
1706 # If a program is installed, this is required. We only want this
1707 # error to appear once.
1708 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
1709 unless $seen_arg_prog;
1710 $seen_arg_prog = 1;
1712 local ($one_file, $xname, $munge);
1714 local ($seen_libobjs) = 0;
1715 foreach $one_file (@proglist)
1716 {
1717 local ($obj) = &get_object_extension ($one_file);
1719 # Canonicalize names and check for misspellings.
1720 $xname = &check_canonical_spelling ($one_file, '_LDADD', '_LDFLAGS',
1721 '_SOURCES', '_OBJECTS',
1722 '_DEPENDENCIES');
1724 # FIXME: Using a trick to figure out if any lex sources appear
1725 # in our program; should use some cleaner method.
1726 local ($lex_num) = scalar (keys %lex_sources);
1727 local ($linker) = &handle_source_transform ($xname, $one_file, $obj);
1728 local ($lex_file_seen) = (scalar (keys %lex_sources) > $lex_num);
1730 local ($xt) = '';
1731 if (&variable_defined ($xname . "_LDADD"))
1732 {
1733 if (&handle_lib_objects ($xname, $xname . '_LDADD',
1734 $lex_file_seen))
1735 {
1736 $seen_libobjs = 1;
1737 }
1738 $lex_file_seen = 0;
1739 $xt = '_LDADD';
1740 }
1741 else
1742 {
1743 # User didn't define prog_LDADD override. So do it.
1744 &define_variable ($xname . '_LDADD', '$(LDADD)');
1746 # This does a bit too much work. But we need it to
1747 # generate _DEPENDENCIES when appropriate.
1748 if (&variable_defined ('LDADD'))
1749 {
1750 if (&handle_lib_objects ($xname, 'LDADD', $lex_file_seen))
1751 {
1752 $seen_libobjs = 1;
1753 }
1754 $lex_file_seen = 0;
1755 }
1756 elsif (! &variable_defined ($xname . '_DEPENDENCIES'))
1757 {
1758 &define_variable ($xname . '_DEPENDENCIES', '');
1759 }
1760 $xt = '_SOURCES'
1761 }
1763 if (&variable_defined ($xname . '_LIBADD'))
1764 {
1765 &am_line_error ($xname . '_LIBADD',
1766 "use \`" . $xname . "_LDADD', not \`"
1767 . $xname . "_LIBADD'");
1768 }
1770 if (! &variable_defined ($xname . '_LDFLAGS'))
1771 {
1772 # Define the prog_LDFLAGS variable.
1773 &define_variable ($xname . '_LDFLAGS', '');
1774 }
1776 # Determine program to use for link.
1777 local ($xlink);
1778 if (&variable_defined ($xname . '_LINK'))
1779 {
1780 $xlink = $xname . '_LINK';
1781 }
1782 else
1783 {
1784 $xlink = $linker ? $linker : 'LINK';
1785 }
1787 local ($xexe);
1788 if ($seen_exeext && $one_file !~ /\./)
1789 {
1790 $xexe = 's/\@EXEEXT\@/\$(EXEEXT)/g;';
1791 }
1792 else
1793 {
1794 $xexe = 's/\@EXEEXT\@//g;';
1795 }
1797 $output_rules .=
1798 &file_contents_with_transform
1799 ('s/\@PROGRAM\@/' . $one_file . '/go;'
1800 . 's/\@XPROGRAM\@/' . $xname . '/go;'
1801 . 's/\@XLINK\@/' . $xlink . '/go;'
1802 . $xexe,
1803 'program');
1804 }
1806 if (&variable_defined ('LDADD') && &handle_lib_objects ('', 'LDADD', 0))
1807 {
1808 $seen_libobjs = 1;
1809 }
1811 if ($seen_libobjs)
1812 {
1813 foreach $one_file (@proglist)
1814 {
1815 # Canonicalize names.
1816 ($xname = $one_file) =~ tr/A-Za-z0-9_/_/c;
1818 if (&variable_defined ($xname . '_LDADD'))
1819 {
1820 &check_libobjs_sources ($xname, $xname . '_LDADD');
1821 }
1822 elsif (&variable_defined ('LDADD'))
1823 {
1824 &check_libobjs_sources ($xname, 'LDADD');
1825 }
1826 }
1827 }
1828 }
1831 # Handle libraries.
1832 sub handle_libraries
1833 {
1834 local (@liblist) = &am_install_var ('-clean',
1835 'libs', 'LIBRARIES',
1836 'lib', 'pkglib', 'noinst', 'check');
1837 return if ! @liblist;
1839 local (%valid) = &am_primary_prefixes ('LIBRARIES', 0, 'lib', 'pkglib',
1840 'noinst', 'check');
1841 if (! defined $configure_vars{'RANLIB'})
1842 {
1843 local ($key);
1844 foreach $key (keys %valid)
1845 {
1846 if (&variable_defined ($key . '_LIBRARIES'))
1847 {
1848 &am_line_error ($key . '_LIBRARIES', "library used but \`RANLIB' not defined in \`configure.in'");
1849 # Only get this error once. If this is ever printed,
1850 # we have a bug.
1851 $configure_vars{'RANLIB'} = 'BUG';
1852 last;
1853 }
1854 }
1855 }
1857 local ($onelib);
1858 local ($munge);
1859 local ($xlib);
1860 local ($seen_libobjs) = 0;
1861 foreach $onelib (@liblist)
1862 {
1863 # Check that the library fits the standard naming convention.
1864 if ($onelib !~ /^lib.*\.a$/)
1865 {
1866 # FIXME should put line number here. That means mapping
1867 # from library name back to variable name.
1868 &am_error ("\`$onelib' is not a standard library name");
1869 }
1871 local ($obj) = &get_object_extension ($onelib);
1873 # Canonicalize names and check for misspellings.
1874 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_SOURCES',
1875 '_OBJECTS', '_DEPENDENCIES', '_AR');
1877 if (! &variable_defined ($xlib . '_AR'))
1878 {
1879 &define_variable ($xlib . '_AR', '$(AR) cru');
1880 }
1882 if (&variable_defined ($xlib . '_LIBADD'))
1883 {
1884 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
1885 {
1886 $seen_libobjs = 1;
1887 }
1888 }
1889 else
1890 {
1891 # Generate support for conditional object inclusion in
1892 # libraries.
1893 &define_variable ($xlib . "_LIBADD", '');
1894 }
1896 if (&variable_defined ($xlib . '_LDADD'))
1897 {
1898 &am_line_error ($xlib . '_LDADD',
1899 "use \`" . $xlib . "_LIBADD', not \`"
1900 . $xlib . "_LDADD'");
1901 }
1903 # Make sure we at look at this.
1904 &examine_variable ($xlib . '_DEPENDENCIES');
1906 &handle_source_transform ($xlib, $onelib, $obj);
1908 $output_rules .=
1909 &file_contents_with_transform ('s/\@LIBRARY\@/' . $onelib . '/go;'
1910 . 's/\@XLIBRARY\@/'
1911 . $xlib . '/go;',
1912 'library');
1913 }
1915 if ($seen_libobjs)
1916 {
1917 foreach $onelib (@liblist)
1918 {
1919 # Canonicalize names.
1920 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
1921 if (&variable_defined ($xlib . '_LIBADD'))
1922 {
1923 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
1924 }
1925 }
1926 }
1928 &define_variable ('AR', 'ar');
1929 &define_configure_variable ('RANLIB');
1930 }
1932 # Handle shared libraries.
1933 sub handle_ltlibraries
1934 {
1935 local (@liblist) = &am_install_var ('-clean',
1936 'ltlib', 'LTLIBRARIES',
1937 'noinst', 'lib', 'pkglib', 'check');
1938 return if ! @liblist;
1940 local (%instdirs);
1941 local (%valid) = &am_primary_prefixes ('LTLIBRARIES', 0, 'lib', 'pkglib',
1942 'noinst', 'check');
1944 local ($key);
1945 foreach $key (keys %valid)
1946 {
1947 if (&variable_defined ($key . '_LTLIBRARIES'))
1948 {
1949 if (!$seen_libtool)
1950 {
1951 &am_line_error ($key . '_LTLIBRARIES', "library used but \`LIBTOOL' not defined in \`configure.in'");
1952 # Only get this error once. If this is ever printed,
1953 # we have a bug.
1954 $configure_vars{'LIBTOOL'} = 'BUG';
1955 $seen_libtool = 1;
1956 }
1958 # Get the installation directory of each library.
1959 for (&variable_value_as_list ($key . '_LTLIBRARIES', 'all'))
1960 {
1961 if ($instdirs{$_})
1962 {
1963 &am_error ("\`$_' is already going to be installed in \`$instdirs{$_}'");
1964 }
1965 else
1966 {
1967 $instdirs{$_} = $key;
1968 }
1969 }
1970 }
1971 }
1973 local ($onelib);
1974 local ($munge);
1975 local ($xlib);
1976 local ($seen_libobjs) = 0;
1977 foreach $onelib (@liblist)
1978 {
1979 local ($obj) = &get_object_extension ($onelib);
1981 # Canonicalize names and check for misspellings.
1982 $xlib = &check_canonical_spelling ($onelib, '_LIBADD', '_LDFLAGS',
1983 '_SOURCES', '_OBJECTS',
1984 '_DEPENDENCIES');
1986 if (! &variable_defined ($xlib . '_LDFLAGS'))
1987 {
1988 # Define the lib_LDFLAGS variable.
1989 &define_variable ($xlib . '_LDFLAGS', '');
1990 }
1992 # Check that the library fits the standard naming convention.
1993 $libname_rx = "^lib.*\.la";
1994 if (&variable_value ($xlib . '_LDFLAGS') =~ /-module/
1995 || &variable_value ('LDFLAGS') =~ /-module/)
1996 {
1997 # Relax name checking for libtool modules.
1998 $libname_rx = "\.la";
1999 }
2000 if ($onelib !~ /$libname_rx$/)
2001 {
2002 # FIXME this should only be a warning for foreign packages
2003 # FIXME should put line number here. That means mapping
2004 # from library name back to variable name.
2005 &am_error ("\`$onelib' is not a standard libtool library name");
2006 }
2008 if (&variable_defined ($xlib . '_LIBADD'))
2009 {
2010 if (&handle_lib_objects ($xlib, $xlib . '_LIBADD', 0))
2011 {
2012 $seen_libobjs = 1;
2013 }
2014 }
2015 else
2016 {
2017 # Generate support for conditional object inclusion in
2018 # libraries.
2019 &define_variable ($xlib . "_LIBADD", '');
2020 }
2022 if (&variable_defined ($xlib . '_LDADD'))
2023 {
2024 &am_line_error ($xlib . '_LDADD',
2025 "use \`" . $xlib . "_LIBADD', not \`"
2026 . $xlib . "_LDADD'");
2027 }
2029 # Make sure we at look at this.
2030 &examine_variable ($xlib . '_DEPENDENCIES');
2032 local ($linker) = &handle_source_transform ($xlib, $onelib, $obj);
2034 # Determine program to use for link.
2035 local ($xlink);
2036 if (&variable_defined ($xlib . '_LINK'))
2037 {
2038 $xlink = $xlib . '_LINK';
2039 }
2040 else
2041 {
2042 $xlink = $linker ? $linker : 'LINK';
2043 }
2045 local ($rpath);
2046 if ($instdirs{$onelib} eq 'EXTRA' || $instdirs{$onelib} eq 'noinst')
2047 {
2048 # It's an EXTRA_ library, so we can't specify -rpath,
2049 # because we don't know where the library will end up.
2050 # The user probably knows, but generally speaking automake
2051 # doesn't -- and in fact configure could decide
2052 # dynamically between two different locations.
2053 $rpath = 's/\@RPATH\@//go;';
2054 }
2055 else
2056 {
2057 $rpath = ('s/\@RPATH\@/-rpath \$(' . $instdirs{$onelib}
2058 . 'dir)/go;');
2059 }
2061 $output_rules .=
2062 &file_contents_with_transform ('s/\@LTLIBRARY\@/'
2063 . $onelib . '/go;'
2064 . 's/\@XLTLIBRARY\@/'
2065 . $xlib . '/go;'
2066 . $rpath
2067 . 's/\@XLINK\@/' . $xlink . '/go;',
2068 'ltlibrary');
2069 }
2071 if ($seen_libobjs)
2072 {
2073 foreach $onelib (@liblist)
2074 {
2075 # Canonicalize names.
2076 ($xlib = $onelib) =~ tr/A-Za-z0-9_/_/c;
2077 if (&variable_defined ($xlib . '_LIBADD'))
2078 {
2079 &check_libobjs_sources ($xlib, $xlib . '_LIBADD');
2080 }
2081 }
2082 }
2083 }
2085 # See if any _SOURCES variable were misspelled. Also, make sure that
2086 # EXTRA_ variables don't contain configure substitutions.
2087 sub check_typos
2088 {
2089 local ($varname, $primary);
2090 foreach $varname (keys %contents)
2091 {
2092 foreach $primary ('_SOURCES', '_LIBADD', '_LDADD', '_LDFLAGS',
2093 '_DEPENDENCIES')
2094 {
2095 if ($varname =~ /$primary$/ && ! $content_seen{$varname})
2096 {
2097 &am_line_error ($varname,
2098 "invalid unused variable name: \`$varname'");
2099 }
2100 }
2101 }
2102 }
2104 # Handle scripts.
2105 sub handle_scripts
2106 {
2107 # NOTE we no longer automatically clean SCRIPTS, because it is
2108 # useful to sometimes distribute scripts verbatim. This happens
2109 # eg in Automake itself.
2110 &am_install_var ('-candist', 'scripts', 'SCRIPTS',
2111 'bin', 'sbin', 'libexec', 'pkgdata',
2112 'noinst', 'check');
2114 local ($scripts_installed) = 0;
2115 # Set $scripts_installed if appropriate. Make sure we only find
2116 # scripts which are actually installed -- this is why we can't
2117 # simply use the return value of am_install_var.
2118 local (%valid) = &am_primary_prefixes ('SCRIPTS', 1, 'bin', 'sbin',
2119 'libexec', 'pkgdata',
2120 'noinst', 'check');
2121 local ($key);
2122 foreach $key (keys %valid)
2123 {
2124 if ($key ne 'noinst'
2125 && $key ne 'check'
2126 && &variable_defined ($key . '_SCRIPTS'))
2127 {
2128 $scripts_installed = 1;
2129 # push (@check_tests, 'check-' . $key . 'SCRIPTS');
2130 }
2131 }
2133 if ($scripts_installed)
2134 {
2135 # If a program is installed, this is required. We only want this
2136 # error to appear once.
2137 &am_conf_error ("AC_ARG_PROGRAM must be used in configure.in")
2138 unless $seen_arg_prog;
2139 $seen_arg_prog = 1;
2140 }
2141 }
2143 # Search a file for a "version.texi" Texinfo include. Return the name
2144 # of the include file if found, or the empty string if not. A
2145 # "version.texi" file is actually any file whose name matches
2146 # "vers*.texi".
2147 sub scan_texinfo_file
2148 {
2149 local ($filename) = @_;
2151 if (! open (TEXI, $filename))
2152 {
2153 &am_error ("couldn't open \`$filename': $!");
2154 return '';
2155 }
2156 print "automake: reading $filename\n" if $verbose;
2158 local ($vfile, $outfile);
2159 while (<TEXI>)
2160 {
2161 if (/^\@setfilename +(\S+)/)
2162 {
2163 $outfile = $1;
2164 last if ($vfile);
2165 }
2167 if (/^\@include\s+(vers[^.]*\.texi)\s*$/)
2168 {
2169 # Found version.texi include.
2170 $vfile = $1;
2171 last if $outfile;
2172 }
2173 }
2175 close (TEXI);
2176 return ($outfile, $vfile);
2177 }
2179 # Handle all Texinfo source.
2180 sub handle_texinfo
2181 {
2182 &am_line_error ('TEXINFOS',
2183 "\`TEXINFOS' is an anachronism; use \`info_TEXINFOS'")
2184 if &variable_defined ('TEXINFOS');
2185 return if (! &variable_defined ('info_TEXINFOS')
2186 && ! &variable_defined ('html_TEXINFOS'));
2188 if (&variable_defined ('html_TEXINFOS'))
2189 {
2190 &am_line_error ('html_TEXINFOS',
2191 "HTML generation not yet supported");
2192 return;
2193 }
2195 local (@texis) = &variable_value_as_list ('info_TEXINFOS', 'all');
2197 local (@info_deps_list, @dvis_list, @texi_deps);
2198 local ($infobase, $info_cursor);
2199 local (%versions);
2200 local ($done) = 0;
2201 local ($vti);
2202 local ($tc_cursor, @texi_cleans);
2203 local ($canonical);
2205 foreach $info_cursor (@texis)
2206 {
2207 # FIXME: This is mildly hacky, since it recognizes "txinfo".
2208 # I don't feel like making it right.
2209 ($infobase = $info_cursor) =~ s/\.te?xi(nfo)?$//;
2211 # If 'version.texi' is referenced by input file, then include
2212 # automatic versioning capability.
2213 local ($out_file, $vtexi) = &scan_texinfo_file ($relative_dir
2214 . "/" . $info_cursor);
2216 if ($out_file eq '')
2217 {
2218 &am_error ("\`$info_cursor' missing \@setfilename");
2219 next;
2220 }
2222 if ($out_file =~ /\.(.+)$/ && $1 ne 'info')
2223 {
2224 # FIXME should report line number in input file.
2225 &am_error ("output of \`$info_cursor', \`$out_file', has unrecognized extension");
2226 next;
2227 }
2229 if ($vtexi)
2230 {
2231 &am_error ("\`$vtexi', included in \`$info_cursor', also included in \`$versions{$vtexi}'")
2232 if (defined $versions{$vtexi});
2233 $versions{$vtexi} = $info_cursor;
2235 # We number the stamp-vti files. This is doable since the
2236 # actual names don't matter much. We only number starting
2237 # with the second one, so that the common case looks nice.
2238 $vti = ($done ? $done : 'vti');
2239 ++$done;
2241 &push_dist_common ($vtexi, 'stamp-' . $vti);
2242 push (@clean, $vti);
2244 &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
2245 'mdate-sh');
2247 local ($conf_pat, $conf_dir);
2248 if ($config_aux_dir eq '.' || $config_aux_dir eq '')
2249 {
2250 $conf_dir = '$(srcdir)/';
2251 }
2252 else
2253 {
2254 $conf_dir = $config_aux_dir;
2255 $conf_dir .= '/' unless $conf_dir =~ /\/$/;
2256 }
2257 ($conf_pat = $conf_dir) =~ s/(\W)/\\$1/g;
2258 $output_rules .=
2259 &file_contents_with_transform
2260 ('s/\@TEXI\@/' . $info_cursor . '/g; '
2261 . 's/\@VTI\@/' . $vti . '/g; '
2262 . 's/\@VTEXI\@/' . $vtexi . '/g;'
2263 . 's,\@MDDIR\@,' . $conf_pat . ',g;',
2264 'texi-vers');
2266 &push_phony_cleaners ($vti);
2267 }
2269 # If user specified file_TEXINFOS, then use that as explicit
2270 # dependency list.
2271 @texi_deps = ();
2272 push (@texi_deps, $info_cursor);
2273 push (@texi_deps, $vtexi) if $vtexi;
2275 # Canonicalize name first.
2276 ($canonical = $infobase) =~ tr/A-Za-z0-9_/_/c;
2277 if (&variable_defined ($canonical . "_TEXINFOS"))
2278 {
2279 push (@texi_deps, '$(' . $canonical . '_TEXINFOS)');
2280 &push_dist_common ('$(' . $canonical . '_TEXINFOS)');
2281 }
2283 $output_rules .= ("\n" . $out_file . ": "
2284 . join (' ', @texi_deps)
2285 . "\n" . $infobase . ".dvi: "
2286 . join (' ', @texi_deps)
2287 . "\n\n");
2289 push (@info_deps_list, $out_file);
2290 push (@dvis_list, $infobase . '.dvi');
2292 # Generate list of things to clean for this target. We do
2293 # this explicitly because otherwise too many things could be
2294 # removed. In particular the ".log" extension might
2295 # reasonably be used in other contexts by the user.
2296 # FIXME: this is really out of control.
2297 foreach $tc_cursor ('aux', 'cp', 'cps', 'dvi', 'fn', 'fns', 'pgs',
2298 'ky', 'kys', 'ps', 'log', 'pg', 'toc', 'tp', 'tps',
2299 'vr', 'vrs', 'op', 'tr', 'cv', 'cn', 'cm', 'ov')
2300 {
2301 push (@texi_cleans, $infobase . '.' . $tc_cursor);
2302 }
2303 }
2305 # Find these programs wherever they may lie. Yes, this has
2306 # intimate knowledge of the structure of the texinfo distribution.
2307 &define_program_variable ('MAKEINFO', 'build', 'texinfo/makeinfo',
2308 'makeinfo',
2309 # Circumlocution to avoid accidental
2310 # configure substitution.
2311 '@MAKE' . 'INFO@');
2312 &define_program_variable ('TEXI2DVI', 'src', 'texinfo/util',
2313 'texi2dvi');
2315 # Set transform for including texinfos.am. First, handle --cygnus
2316 # stuff.
2317 local ($xform);
2318 if ($cygnus_mode)
2319 {
2320 $xform = 's/^NOTCYGNUS.*$//; s/^CYGNUS//;';
2321 }
2322 else
2323 {
2324 $xform = 's/^CYGNUS.*$//; s/^NOTCYGNUS//;';
2325 }
2327 # Handle location of texinfo.tex.
2328 local ($need_texi_file) = 0;
2329 local ($texinfo_tex);
2330 if ($cygnus_mode)
2331 {
2332 $texinfo_tex = '$(top_srcdir)/../texinfo/texinfo.tex';
2333 &define_variable ('TEXINFO_TEX', $texinfo_tex);
2335 }
2336 elsif ($config_aux_dir ne '.' && $config_aux_dir ne '')
2337 {
2338 $texinfo_tex = $config_aux_dir . '/texinfo.tex';
2339 &define_variable ('TEXINFO_TEX', $texinfo_tex);
2340 $need_texi_file = 2; # so that we require_conf_file later
2341 }
2342 elsif (&variable_defined ('TEXINFO_TEX'))
2343 {
2344 # The user defined TEXINFO_TEX so assume he knows what he is
2345 # doing.
2346 $texinfo_tex = ('$(srcdir)/'
2347 . &dirname (&variable_value ('TEXINFO_TEX')));
2348 }
2349 else
2350 {
2351 $texinfo_tex = '$(srcdir)/texinfo.tex';
2352 $need_texi_file = 1;
2353 }
2354 local ($xxform);
2355 ($xxform = $texinfo_tex) =~ s/\/texinfo\.tex$//;
2356 $xxform =~ s/(\W)/\\$1/g;
2357 $xform .= ' s/\@TEXINFODIR\@/' . $xxform . '/g;';
2359 $output_rules .= &file_contents_with_transform ($xform, 'texinfos');
2360 push (@phony, 'install-info-am', 'uninstall-info');
2361 push (@dist_targets, 'dist-info');
2363 # How to clean. The funny name is due to --cygnus influence; in
2364 # Cygnus mode, `clean-info' is a target that users can use.
2365 $output_rules .= "\nmostlyclean-aminfo:\n";
2366 &pretty_print_rule ("\t-rm -f", "\t ", @texi_cleans);
2367 $output_rules .= ("\nclean-aminfo:\n\ndistclean-aminfo:\n\n"
2368 . "maintainer-clean-aminfo:\n\t"
2369 # Eww. But how else can we find all the output
2370 # files from makeinfo?
2371 . ($cygnus_mode ? '' : 'cd $(srcdir) && ')
2372 . 'for i in $(INFO_DEPS); do' . " \\\n"
2373 . "\t" . ' rm -f $$i;' . " \\\n"
2374 . "\t" . ' if test "`echo $$i-[0-9]*`" != "$$i-[0-9]*"; then' . " \\\n"
2375 . "\t" . ' rm -f $$i-[0-9]*;' . " \\\n"
2376 . "\t" . ' fi;' . " \\\n"
2377 . "\tdone\n");
2378 &push_phony_cleaners ('aminfo');
2379 if ($cygnus_mode)
2380 {
2381 $output_rules .= "clean-info: mostlyclean-aminfo\n";
2382 }
2384 push (@suffixes, '.texi', '.texinfo', '.txi', '.info', '.dvi', '.ps');
2386 if (! defined $options{'no-installinfo'})
2387 {
2388 push (@uninstall, 'uninstall-info');
2389 push (@installdirs, '$(DESTDIR)$(infodir)');
2390 unshift (@install_data, 'install-info-am');
2392 # Make sure documentation is made and installed first. Use
2393 # $(INFO_DEPS), not 'info', because otherwise recursive makes
2394 # get run twice during "make all".
2395 unshift (@all, '$(INFO_DEPS)');
2396 }
2397 push (@clean, 'aminfo');
2398 push (@info, '$(INFO_DEPS)');
2399 push (@dvi, '$(DVIS)');
2401 &define_variable ("INFO_DEPS", join (' ', @info_deps_list));
2402 &define_variable ("DVIS", join (' ', @dvis_list));
2403 # This next isn't strictly needed now -- the places that look here
2404 # could easily be changed to look in info_TEXINFOS. But this is
2405 # probably better, in case noinst_TEXINFOS is ever supported.
2406 &define_variable ("TEXINFOS", &variable_value ('info_TEXINFOS'));
2408 # Do some error checking. Note that this file is not required
2409 # when in Cygnus mode; instead we defined TEXINFO_TEX explicitly
2410 # up above.
2411 if ($need_texi_file && ! defined $options{'no-texinfo.tex'})
2412 {
2413 if ($need_texi_file > 1)
2414 {
2415 &require_conf_file_with_line ('info_TEXINFOS', $FOREIGN,
2416 'texinfo.tex');
2417 }
2418 else
2419 {
2420 &require_file_with_line ('info_TEXINFOS', $FOREIGN, 'texinfo.tex');
2421 }
2422 }
2423 }
2425 # Handle any man pages.
2426 sub handle_man_pages
2427 {
2428 &am_line_error ('MANS', "\`MANS' is an anachronism; use \`man_MANS'")
2429 if &variable_defined ('MANS');
2430 return if ! &variable_defined ('man_MANS');
2432 # Find all the sections in use. We do this by first looking for
2433 # "standard" sections, and then looking for any additional
2434 # sections used in man_MANS.
2435 local ($sect, %sections, %vlist);
2436 # Add more sections as needed.
2437 foreach $sect ('0'..'9', 'n', 'l')
2438 {
2439 if (&variable_defined ('man' . $sect . '_MANS'))
2440 {
2441 $sections{$sect} = 1;
2442 $vlist{'$(man' . $sect . '_MANS)'} = 1;
2443 }
2444 }
2446 if (&variable_defined ('man_MANS'))
2447 {
2448 $vlist{'$(man_MANS)'} = 1;
2449 foreach (&variable_value_as_list ('man_MANS', 'all'))
2450 {
2451 # A page like `foo.1c' goes into man1dir.
2452 if (/\.([0-9a-z])([a-z]*)$/)
2453 {
2454 $sections{$1} = 1;
2455 }
2456 }
2457 }
2460 # Now for each section, generate an install and unintall rule.
2461 # Sort sections so output is deterministic.
2462 local (@namelist);
2463 foreach $sect (sort keys %sections)
2464 {
2465 &define_variable ('man' . $sect . 'dir', '$(mandir)/man' . $sect);
2466 push (@installdirs, '$(DESTDIR)$(mandir)/man' . $sect)
2467 unless defined $options{'no-installman'};
2468 $output_rules .= &file_contents_with_transform ('s/\@SECTION\@/'
2469 . $sect . '/g;',
2470 'mans');
2471 push (@phony, 'install-man' . $sect, 'uninstall-man' . $sect);
2472 push (@namelist, 'install-man' . $sect);
2473 }
2475 # We don't really need this, but we use it in case we ever want to
2476 # support noinst_MANS.
2477 &define_variable ("MANS", join (' ', sort keys %vlist));
2479 # Generate list of install dirs.
2480 $output_rules .= ("install-man: \$(MANS)\n"
2481 . "\t\@\$(NORMAL_INSTALL)\n");
2482 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ", @namelist);
2483 push (@phony, 'install-man');
2485 $output_rules .= "uninstall-man:\n\t\@\$(NORMAL_UNINSTALL)\n";
2486 grep ($_ = 'un' . $_, @namelist);
2487 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ", @namelist);
2488 push (@phony, 'uninstall-man');
2490 $output_vars .= &file_contents ('mans-vars');
2492 if (! defined $options{'no-installman'})
2493 {
2494 push (@install_data, 'install-man');
2495 push (@uninstall, 'uninstall-man');
2496 push (@all, '$(MANS)');
2497 }
2498 }
2500 # Handle DATA variables.
2501 sub handle_data
2502 {
2503 &am_install_var ('-noextra', '-candist', 'data', 'DATA',
2504 'data', 'sysconf', 'sharedstate', 'localstate',
2505 'pkgdata', 'noinst', 'check');
2506 }
2508 # Handle TAGS.
2509 sub handle_tags
2510 {
2511 push (@phony, 'tags');
2512 local (@tag_deps) = ();
2513 if (&variable_defined ('SUBDIRS'))
2514 {
2515 $output_rules .= ("tags-recursive:\n"
2516 . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
2517 # Never fail here if a subdir fails; it
2518 # isn't important.
2519 . "\t test \"\$\$subdir\" = . || (cd \$\$subdir"
2520 . " && \$(MAKE) \$(AM_MAKEFLAGS) tags); \\\n"
2521 . "\tdone\n");
2522 push (@tag_deps, 'tags-recursive');
2523 push (@phony, 'tags-recursive');
2524 }
2526 if (&saw_sources_p (1)
2527 || &variable_defined ('ETAGS_ARGS')
2528 || @tag_deps)
2529 {
2530 local ($xform) = '';
2531 local ($one_hdr);
2532 foreach $one_hdr (@config_headers)
2533 {
2534 if ($relative_dir eq &dirname ($one_hdr))
2535 {
2536 # The config header is in this directory. So require it.
2537 local ($var);
2538 ($var = &basename ($one_hdr)) =~ s/(\W)/\\$1/g;
2539 $xform .= ' ' if $xform;
2540 $xform .= $var;
2541 }
2542 }
2543 $xform = ('s/\@CONFIG\@/' . $xform . '/;'
2544 . 's/\@DIRS\@/' . join (' ', @tag_deps) . '/;');
2546 if (&variable_defined ('SUBDIRS'))
2547 {
2548 $xform .= 's/^SUBDIRS//;';
2549 }
2550 else
2551 {
2552 $xform .= 's/^SUBDIRS.*$//;';
2553 }
2555 $output_rules .= &file_contents_with_transform ($xform, 'tags');
2556 $output_rules .= &file_contents ('tags-clean');
2557 push (@clean, 'tags');
2558 &push_phony_cleaners ('tags');
2559 &examine_variable ('TAGS_DEPENDENCIES');
2560 }
2561 elsif (&variable_defined ('TAGS_DEPENDENCIES'))
2562 {
2563 &am_line_error ('TAGS_DEPENDENCIES',
2564 "doesn't make sense to define \`TAGS_DEPENDENCIES' without sources or \`ETAGS_ARGS'");
2565 }
2566 else
2567 {
2568 # Every Makefile must define some sort of TAGS rule.
2569 # Otherwise, it would be possible for a top-level "make TAGS"
2570 # to fail because some subdirectory failed.
2571 $output_rules .= "tags: TAGS\nTAGS:\n\n";
2572 }
2573 }
2575 # Handle multilib support.
2576 sub handle_multilib
2577 {
2578 return unless $seen_multilib;
2580 $output_rules .= &file_contents ('multilib.am');
2581 &push_phony_cleaners ('multi');
2582 push (@phony, 'all-multi', 'install-multi');
2583 }
2585 # Worker for handle_dist.
2586 sub handle_dist_worker
2587 {
2588 local ($makefile) = @_;
2590 $output_rules .= 'distdir: $(DISTFILES)' . "\n";
2592 # Initialization; only at top level.
2593 if ($relative_dir eq '.')
2594 {
2595 if (defined $options{'check-news'})
2596 {
2597 # For Gnits users, this is pretty handy. Look at 15 lines
2598 # in case some explanatory text is desirable.
2599 $output_rules .= ' @if sed 15q $(srcdir)/NEWS | fgrep -e "$(VERSION)" > /dev/null; then :; else \\
2600 echo "NEWS not updated; not releasing" 1>&2; \\
2601 exit 1; \\
2602 fi
2603 ';
2604 }
2607 # Create dist directory.
2608 $output_rules .= ("\t-chmod -R a+w \$(distdir) > /dev/null 2>&1; rm -rf \$(distdir)\n"
2609 . "\tmkdir \$(distdir)\n");
2610 }
2612 # Scan EXTRA_DIST to see if we need to distribute anything from a
2613 # subdir. If so, add it to the list. I didn't want to do this
2614 # originally, but there were so many requests that I finally
2615 # relented.
2616 local (@dist_dirs);
2617 if (&variable_defined ('EXTRA_DIST'))
2618 {
2619 # FIXME: This should be fixed to work with conditionals. That
2620 # will require only making the entries in @dist_dirs under the
2621 # appropriate condition. This is meaningful if the nature of
2622 # the distribution should depend upon the configure options
2623 # used.
2624 foreach (&variable_value_as_list ('EXTRA_DIST', ''))
2625 {
2626 next if /^\@.*\@$/;
2627 next unless s,/+[^/]+$,,;
2628 push (@dist_dirs, $_)
2629 unless $_ eq '.';
2630 }
2631 }
2633 # We have to check DIST_COMMON for extra directories in case the
2634 # user put a source used in AC_OUTPUT into a subdir.
2635 foreach (&variable_value_as_list ('DIST_COMMON', 'all'))
2636 {
2637 next if /^\@.*\@$/;
2638 next unless s,/+[^/]+$,,;
2639 push (@dist_dirs, $_)
2640 unless $_ eq '.';
2641 }
2643 if (@dist_dirs)
2644 {
2645 # Prepend $(distdir) to each directory given. Doing it via a
2646 # hash lets us ensure that each directory is used only once.
2647 local (%dhash);
2648 grep ($dhash{'$(distdir)/' . $_} = 1, @dist_dirs);
2649 $output_rules .= "\t";
2650 &pretty_print_rule ('$(mkinstalldirs)', "\t ", sort keys %dhash);
2651 }
2653 # In loop, test for file existence because sometimes a file gets
2654 # included in DISTFILES twice. For example this happens when a
2655 # single source file is used in building more than one program.
2656 # Also, there are situations in which "ln" can fail. For instance
2657 # a file to distribute could actually be a cross-filesystem
2658 # symlink -- this can easily happen if "gettextize" was run on the
2659 # distribution.
2660 $output_rules .= "\t\@for file in \$(DISTFILES); do \\\n";
2661 if ($cygnus_mode)
2662 {
2663 $output_rules .= "\t if test -f \$\$file; then d=.; else d=\$(srcdir); fi; \\\n";
2664 }
2665 else
2666 {
2667 $output_rules .= "\t d=\$(srcdir); \\\n";
2668 }
2669 $output_rules .= ("\t if test -d \$\$d/\$\$file; then \\\n"
2670 # Don't mention $$file in destination argument,
2671 # since this fails if destination directory
2672 # already exists. Also, use `-R' and not `-r'.
2673 # `-r' is almost always incorrect.
2674 . "\t cp -pR \$\$d/\$\$file \$(distdir) \\\n"
2675 . "\t || exit 1; \\\n"
2676 . "\t else \\\n"
2677 . "\t test -f \$(distdir)/\$\$file \\\n"
2678 . "\t || cp -p \$\$d/\$\$file \$(distdir)/\$\$file \\\n"
2679 . "\t || exit 1; \\\n"
2680 . "\t fi; \\\n"
2681 . "\tdone\n");
2683 # If we have SUBDIRS, create all dist subdirectories and do
2684 # recursive build.
2685 if (&variable_defined ('SUBDIRS'))
2686 {
2687 # If SUBDIRS is conditionally defined, then set DIST_SUBDIRS
2688 # to all possible directories, and use it. If DIST_SUBDIRS is
2689 # defined, just use it.
2690 local ($dist_subdir_name);
2691 if (&variable_conditions ('SUBDIRS')
2692 || &variable_defined ('DIST_SUBDIRS'))
2693 {
2694 $dist_subdir_name = 'DIST_SUBDIRS';
2695 if (! &variable_defined ('DIST_SUBDIRS'))
2696 {
2697 local (@full_list) = &variable_value_as_list ('SUBDIRS',
2698 'all');
2699 local (@ds_list, %uniq, $iter);
2700 foreach $iter (@full_list)
2701 {
2702 if (! defined $uniq{$iter})
2703 {
2704 $uniq{$iter} = 1;
2705 push (@ds_list, $iter);
2706 }
2707 }
2708 &define_pretty_variable ('DIST_SUBDIRS', '', @ds_list);
2709 }
2710 }
2711 else
2712 {
2713 $dist_subdir_name = 'SUBDIRS';
2714 }
2716 # Test for directory existence here because previous automake
2717 # invocation might have created some directories. Note that
2718 # we explicitly set distdir for the subdir make; that lets us
2719 # mix-n-match many automake-using packages into one large
2720 # package, and have "dist" at the top level do the right
2721 # thing. If we're in the topmost directory, then we use
2722 # `distdir' instead of `top_distdir'; this lets us work
2723 # correctly with an enclosing package.
2724 $output_rules .=
2725 ("\t" . 'for subdir in $(' . $dist_subdir_name . '); do ' . "\\\n"
2726 . "\t" . ' if test "$$subdir" = .; then :; else ' . "\\\n"
2727 . "\t" . ' test -d $(distdir)/$$subdir ' . "\\\n"
2728 . "\t" . ' || mkdir $(distdir)/$$subdir ' . "\\\n"
2729 . "\t" . ' || exit 1; ' . "\\\n"
2730 . "\t" . ' (cd $$subdir'
2731 . ' && $(MAKE) $(AM_MAKEFLAGS) top_distdir=../$('
2732 . (($relative_dir eq '.') ? 'distdir' : 'top_distdir')
2733 . ') distdir=../$(distdir)/$$subdir distdir) ' . "\\\n"
2734 . "\t" . ' || exit 1; ' . "\\\n"
2735 . "\t" . ' fi; ' . "\\\n"
2736 . "\tdone\n");
2737 }
2739 # If the target `dist-hook' exists, make sure it is run. This
2740 # allows users to do random weird things to the distribution
2741 # before it is packaged up.
2742 push (@dist_targets, 'dist-hook') if &target_defined ('dist-hook');
2744 local ($targ);
2745 foreach $targ (@dist_targets)
2746 {
2747 # We must explicitly set distdir and top_distdir for these
2748 # sub-makes.
2749 $output_rules .= ("\t\$(MAKE) \$(AM_MAKEFLAGS)"
2750 . " top_distdir=\"\$(top_distdir)\""
2751 . " distdir=\"\$(distdir)\" $targ\n");
2752 }
2754 push (@phony, 'distdir');
2755 }
2757 # Handle 'dist' target.
2758 sub handle_dist
2759 {
2760 local ($makefile) = @_;
2762 # Set up maint_charset.
2763 $local_maint_charset = &variable_value ('MAINT_CHARSET')
2764 if &variable_defined ('MAINT_CHARSET');
2765 $maint_charset = $local_maint_charset
2766 if $relative_dir eq '.';
2768 if (&variable_defined ('DIST_CHARSET'))
2769 {
2770 &am_line_error ('DIST_CHARSET',
2771 "DIST_CHARSET defined but no MAINT_CHARSET defined")
2772 if ! $local_maint_charset;
2773 if ($relative_dir eq '.')
2774 {
2775 $dist_charset = &variable_value ('DIST_CHARSET')
2776 }
2777 else
2778 {
2779 &am_line_error ('DIST_CHARSET',
2780 "DIST_CHARSET can only be defined at top level");
2781 }
2782 }
2784 # Look for common files that should be included in distribution.
2785 local ($cfile);
2786 foreach $cfile (@common_files)
2787 {
2788 if (-f ($relative_dir . "/" . $cfile))
2789 {
2790 &push_dist_common ($cfile);
2791 }
2792 }
2794 # Always require configure.in and configure at top level, even if
2795 # they don't exist. This is especially important for configure,
2796 # since it won't be created until autoconf is run -- which might
2797 # be after automake is run.
2798 &push_dist_common ('configure.in', 'configure')
2799 if $relative_dir eq '.';
2801 # We might copy elements from %configure_dist_common to
2802 # %dist_common if we think we need to. If the file appears in our
2803 # directory, we would have discovered it already, so we don't
2804 # check that. But if the file is in a subdir without a Makefile,
2805 # we want to distribute it here if we are doing `.'. Ugly!
2806 if ($relative_dir eq '.')
2807 {
2808 local ($iter);
2809 foreach $iter (keys %configure_dist_common)
2810 {
2811 if (! &is_make_dir (&dirname ($iter)))
2812 {
2813 &push_dist_common ($iter);
2814 }
2815 }
2816 }
2818 # Keys of %dist_common are names of files to distributed. We put
2819 # README first because it then becomes easier to make a
2820 # Usenet-compliant shar file (in these, README must be first).
2821 # FIXME: do more ordering of files here.
2822 local (@coms);
2823 if (defined $dist_common{'README'})
2824 {
2825 push (@coms, 'README');
2826 delete $dist_common{'README'};
2827 }
2828 push (@coms, sort keys %dist_common);
2830 # Now that we've processed %dist_common, disallow further attempts
2831 # to set it.
2832 $handle_dist_run = 1;
2834 &define_pretty_variable ("DIST_COMMON", '', @coms);
2835 $output_vars .= "\n";
2837 # Some boilerplate.
2838 $output_vars .= &file_contents ('dist-vars') . "\n";
2839 &define_variable ('GZIP_ENV', '--best');
2841 # Put these things in rules section so it is easier for whoever
2842 # reads Makefile.in.
2843 if (! &variable_defined ('distdir'))
2844 {
2845 if ($relative_dir eq '.')
2846 {
2847 $output_rules .= "\n" . 'distdir = $(PACKAGE)-$(VERSION)' . "\n";
2848 }
2849 else
2850 {
2851 $output_rules .= ("\n"
2852 . 'distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)'
2853 . "\n");
2854 }
2855 }
2856 if ($relative_dir eq '.')
2857 {
2858 $output_rules .= "top_distdir = \$(distdir)\n";
2859 }
2860 $output_rules .= "\n";
2862 # Generate 'dist' target, and maybe other dist targets.
2863 if ($relative_dir eq '.')
2864 {
2865 # Rule to check whether a distribution is viable.
2866 local ($xform) = '';
2868 if (&target_defined ('distcheck-hook'))
2869 {
2870 $xform .= 's/^DISTHOOK//;';
2871 }
2872 else
2873 {
2874 $xform .= 's/^DISTHOOK.*$//;';
2875 }
2876 if ($seen_gettext)
2877 {
2878 $xform .= 's/^GETTEXT//;';
2879 }
2880 else
2881 {
2882 $xform .= 's/^GETTEXT.*$//;';
2883 }
2885 $output_rules .= &file_contents_with_transform ($xform, 'dist');
2887 local ($dist_all) = ('dist-all: distdir' . "\n"
2888 . $dist_header);
2889 local ($curs);
2890 foreach $curs ('dist', 'dist-shar', 'dist-zip', 'dist-tarZ',
2891 'dist-bzip2')
2892 {
2893 if (defined $options{$curs} || $curs eq 'dist')
2894 {
2895 $output_rules .= ($curs . ': distdir' . "\n"
2896 . $dist_header
2897 . $dist{$curs}
2898 . $dist_trailer);
2899 $dist_all .= $dist{$curs};
2900 }
2901 }
2902 $output_rules .= $dist_all . $dist_trailer;
2903 }
2905 # Generate distdir target.
2906 &handle_dist_worker ($makefile);
2907 }
2909 # A subroutine of handle_dependencies. This function includes
2910 # `depend2' with appropriate transformations.
2911 sub add_depend2
2912 {
2913 local ($lang) = @_;
2915 # First include code for ordinary objects.
2916 local ($key) = $lang . '-autodep';
2917 local ($xform, $ext);
2919 local ($pfx) = $language_map{$key};
2920 local ($fpfx) = ($pfx eq '') ? 'CC' : $pfx;
2921 $xform = ('s/\@PFX\@/' . $pfx . '/g;'
2922 . 's/\@FPFX\@/' . $fpfx . '/g;'
2923 . ($seen_objext ? 's/^OBJEXT//;' : 's/^OBJEXT.*$//;')
2924 . ($seen_libtool ? 's/^LIBTOOL//;' : 's/^LIBTOOL.*$//;'));
2926 # This function can be called even when we don't want dependency
2927 # tracking. This happens when we need an explicit rule for some
2928 # target. In this case we don't want to include the generic code.
2929 if ($use_dependencies)
2930 {
2931 local ($xform1) = ($xform
2932 . 's/\@BASE\@/\$\*/g;'
2933 . 's/\@SOURCE\@/\$\</g;'
2934 . 's/\@(LT|OBJ)?OBJ\@/\$\@/g;');
2936 foreach $ext (&lang_extensions ($lang))
2937 {
2938 $output_rules .= (&file_contents_with_transform ('s/\@EXT\@/'
2939 . $ext . '/g;'
2940 . $xform1,
2941 'depend2')
2942 . "\n");
2943 }
2944 }
2946 # Now include code for each specially handled object with this
2947 # language.
2948 local (@list) = grep ($_ ne '', split (' ', $lang_specific_files{$lang}));
2949 local ($max) = scalar @list;
2950 local ($i) = 0;
2951 local ($derived, $source, $obj);
2953 # If dependency tracking is disabled, we just elide the code.
2954 if (! $use_dependencies)
2955 {
2956 $xform .= 's/\@AMDEP\@.*$//;';
2957 }
2959 while ($i < $max)
2960 {
2961 $derived = $list[$i];
2962 ($source = $list[$i + 1]) =~ s,([/\$]),\\$1,g;
2963 ($obj = $list[$i + 2]) =~ s,([/\$]),\\$1,g;
2964 $i += 3;
2966 local ($flag) = $language_map{$lang . '-flags'};
2967 local ($val) = "(${derived}_${flag}";
2968 ($rule = $language_map{$lang . '-compile'}) =~
2969 s/\(AM_$flag/$val/;
2971 $rule =~ s,([/\$]),\\$1,g;
2973 # Generate a transform which will turn suffix targets in
2974 # depend2.am into real targets for the particular objects we
2975 # are building.
2976 $output_rules .=
2977 &file_contents_with_transform ($xform
2978 . 's/\$\(' . $pfx . 'COMPILE\)/'
2979 . $rule . '/g;'
2980 . 's/\$\(LT' . $pfx . 'COMPILE\)/'
2981 . '\$(LIBTOOL) --mode=compile '
2982 . $rule . '/g;'
2983 # Generate rule for `.o'.
2984 . 's/^\@EXT\@\.o:/'
2985 . $obj . '.o: ' . $source
2986 . '/g;'
2987 # Maybe generate rule for `.lo'.
2988 # Might be eliminated by
2989 # $XFORM.
2990 . 's/^\@EXT\@\.lo:/'
2991 . $obj . '.lo: ' . $source
2992 . '/g;'
2993 # Maybe generate rule for `.obj'.
2994 # Might be eliminated by
2995 # $XFORM.
2996 . 's/^\@EXT\@\.obj:/'
2997 . $obj . '.obj: ' . $source
2998 . '/g;'
2999 # Handle source and obj
3000 # transforms.
3001 . 's/\@OBJ\@/' . $obj . '.o/g;'
3002 . 's/\@OBJOBJ\@/' . $obj . '.obj/g;'
3003 . 's/\@LTOBJ\@/' . $obj . '.lo/g;'
3004 . 's/\@BASE\@/' . $obj . '/g;'
3005 . 's/\@SOURCE\@/' . $source . '/g;',
3006 'depend2');
3007 }
3008 }
3010 # Handle auto-dependency code.
3011 sub handle_dependencies
3012 {
3013 if ($use_dependencies)
3014 {
3015 # Include auto-dep code. Don't include it if DEP_FILES would
3016 # be empty.
3017 if (&saw_sources_p (0) && keys %dep_files)
3018 {
3019 &require_config_file ($FOREIGN, 'depcomp');
3021 # Set location of depcomp.
3022 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
3023 {
3024 &define_variable ('depcomp', ('$(SHELL) ' . $config_aux_dir
3025 . '/depcomp'));
3026 }
3027 else
3028 {
3029 &define_variable ('depcomp',
3030 '$(SHELL) $(top_srcdir)/depcomp');
3031 }
3033 local ($iter);
3034 local (@deplist) = sort keys %dep_files;
3036 &define_pretty_variable ('DEP_FILES', '', ("\@AMDEP\@", @deplist));
3038 # Generate each `include' individually. Irix 6 make will
3039 # not properly include several files resulting from a
3040 # variable expansion; generating many separate includes
3041 # seems safest.
3042 $output_rules .= "\n";
3043 foreach $iter (@deplist)
3044 {
3045 $output_rules .= "\@AMDEP\@" . 'include ' . $iter . "\n";
3046 }
3048 $output_rules .= &file_contents ('depend');
3049 push (@clean, 'depend');
3050 &push_phony_cleaners ('depend');
3051 }
3052 }
3053 else
3054 {
3055 &define_variable ('depcomp', '');
3056 }
3058 local ($key, $lang, $ext, $xform);
3059 foreach $key (sort keys %language_map)
3060 {
3061 next unless $key =~ /^(.*)-autodep$/;
3062 next if $language_map{$key} eq 'no';
3063 &add_depend2 ($1);
3064 }
3065 }
3067 # Handle subdirectories.
3068 sub handle_subdirs
3069 {
3070 return if ! &variable_defined ('SUBDIRS');
3072 # Make sure each directory mentioned in SUBDIRS actually exists.
3073 local ($dir);
3074 foreach $dir (&variable_value_as_list ('SUBDIRS', 'all'))
3075 {
3076 # Skip directories substituted by configure.
3077 next if $dir =~ /^\@.*\@$/;
3079 if (! -d $am_relative_dir . '/' . $dir)
3080 {
3081 &am_line_error ('SUBDIRS',
3082 "required directory $am_relative_dir/$dir does not exist");
3083 next;
3084 }
3086 &am_line_error ('SUBDIRS', "directory should not contain \`/'")
3087 if $dir =~ /\//;
3088 }
3090 local ($xform) = ('s/\@INSTALLINFO\@/' .
3091 (defined $options{'no-installinfo'}
3092 ? 'install-info-recursive'
3093 : '')
3094 . '/;');
3095 $output_rules .= &file_contents_with_transform ($xform, 'subdirs');
3097 # Push a bunch of phony targets.
3098 local ($phonies);
3099 foreach $phonies ('', '-data', '-exec', 'dirs')
3100 {
3101 push (@phony, 'install' . $phonies . '-recursive');
3102 push (@phony, 'uninstall' . $phonies . '-recursive');
3103 }
3104 foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
3105 {
3106 push (@phony, $phonies . '-recursive');
3107 }
3108 &push_phony_cleaners ('recursive');
3110 $recursive_install = 1;
3111 }
3113 # Handle aclocal.m4.
3114 sub handle_aclocal_m4
3115 {
3116 local ($regen_aclocal) = 0;
3117 if (-f 'aclocal.m4')
3118 {
3119 &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4');
3120 &push_dist_common ('aclocal.m4');
3122 if (open (ACLOCAL, '< aclocal.m4'))
3123 {
3124 local ($line);
3125 $line = <ACLOCAL>;
3126 close (ACLOCAL);
3128 if ($line =~ 'generated automatically by aclocal')
3129 {
3130 $regen_aclocal = 1;
3131 }
3132 }
3133 }
3135 local ($acinclude) = 0;
3136 if (-f 'acinclude.m4')
3137 {
3138 $regen_aclocal = 1;
3139 $acinclude = 1;
3140 }
3142 # Note that it might be possible that aclocal.m4 doesn't exist but
3143 # should be auto-generated. This case probably isn't very
3144 # important.
3145 if ($regen_aclocal)
3146 {
3147 local (@ac_deps) = (
3148 ($seen_maint_mode
3149 ? "\@MAINTAINER_MODE_TRUE\@"
3150 : "") ,
3151 "configure.in",
3152 ($acinclude ? ' acinclude.m4' : '')
3153 );
3155 # Scan all -I directories for m4 files. These are our
3156 # dependencies.
3157 if (&variable_defined ('ACLOCAL_AMFLAGS'))
3158 {
3159 local ($examine_next, $amdir) = 0;
3160 foreach $amdir (&variable_value_as_list ('ACLOCAL_AMFLAGS', ''))
3161 {
3162 if ($examine_next)
3163 {
3164 $examine_next = 0;
3165 if ($amdir !~ /^\// && -d $amdir)
3166 {
3167 push (@ac_deps, &my_glob ($amdir . '/*.m4'));
3168 }
3169 }
3170 elsif ($amdir eq '-I')
3171 {
3172 $examine_next = 1;
3173 }
3174 }
3175 }
3177 &pretty_print_rule ("\$(ACLOCAL_M4):", "\t\t", @ac_deps);
3179 $output_rules .= ("\t"
3180 . 'cd $(srcdir) && $(ACLOCAL)'
3181 . (&variable_defined ('ACLOCAL_AMFLAGS')
3182 ? ' $(ACLOCAL_AMFLAGS)' : '')
3183 . "\n");
3184 }
3185 }
3187 # Rewrite a list of input files into a form suitable to put on a
3188 # dependency list. The idea is that if an input file has a directory
3189 # part the same as the current directory, then the directory part is
3190 # simply removed. But if the directory part is different, then
3191 # $(top_srcdir) is prepended. Among other things, this is used to
3192 # generate the dependency list for the output files generated by
3193 # AC_OUTPUT. Consider what the dependencies should look like in this
3194 # case:
3195 # AC_OUTPUT(src/out:src/in1:lib/in2)
3196 # The first argument, ADD_SRCDIR, is 1 if $(top_srcdir) should be added.
3197 # If 0 then files that require this addition will simply be ignored.
3198 sub rewrite_inputs_into_dependencies
3199 {
3200 local ($add_srcdir, @inputs) = @_;
3201 local ($single, @newinputs);
3203 foreach $single (@inputs)
3204 {
3205 if (&dirname ($single) eq $relative_dir)
3206 {
3207 push (@newinputs, &basename ($single));
3208 }
3209 elsif ($add_srcdir)
3210 {
3211 push (@newinputs, '$(top_srcdir)/' . $single);
3212 }
3213 }
3215 return @newinputs;
3216 }
3218 # Handle remaking and configure stuff.
3219 # We need the name of the input file, to do proper remaking rules.
3220 sub handle_configure
3221 {
3222 local ($local, $input, @secondary_inputs) = @_;
3224 local ($top_reldir);
3226 local ($input_base) = &basename ($input);
3227 local ($local_base) = &basename ($local);
3229 local ($amfile) = $input_base . '.am';
3230 # We know we can always add '.in' because it really should be an
3231 # error if the .in was missing originally.
3232 local ($infile) = '$(srcdir)/' . $input_base . '.in';
3233 local ($colon_infile);
3234 if ($local ne $input || @secondary_inputs)
3235 {
3236 $colon_infile = ':' . $input . '.in';
3237 }
3238 $colon_infile .= ':' . join (':', @secondary_inputs)
3239 if @secondary_inputs;
3241 local (@rewritten) = &rewrite_inputs_into_dependencies (1,
3242 @secondary_inputs);
3244 # This rule remakes the Makefile.in. Note use of
3245 # @MAINTAINER_MODE_TRUE@ forces us to abandon pretty-printing.
3246 # Sigh.
3247 $output_rules .= ($infile
3248 # NOTE perl 5.003 (with -w) gives a
3249 # uninitialized value error on the next line.
3250 # Don't know why.
3251 . ': '
3252 . ($seen_maint_mode ? "\@MAINTAINER_MODE_TRUE\@ " : '')
3253 . $amfile . ' '
3254 . '$(top_srcdir)/configure.in $(ACLOCAL_M4)'
3255 . ' ' . join (' ', @include_stack)
3256 . "\n"
3257 . "\tcd \$(top_srcdir) && \$(AUTOMAKE) "
3258 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
3259 . ($cmdline_use_dependencies ? '' : ' --ignore-deps')
3260 . ' ' . $input . $colon_infile . "\n\n");
3262 # This rule remakes the Makefile.
3263 $output_rules .= ($local_base
3264 # NOTE: bogus uninit value error on next line;
3265 # see comment above.
3266 . ': '
3267 . $infile . ' '
3268 . join (' ', @rewritten)
3269 . ' $(top_builddir)/config.status'
3270 . "\n"
3271 . "\tcd \$(top_builddir) \\\n"
3272 . "\t && CONFIG_FILES="
3273 . (($relative_dir eq '.') ? '$@' : '$(subdir)/$@')
3274 . $colon_infile
3275 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
3276 . "\n\n");
3278 if ($relative_dir ne '.')
3279 {
3280 # In subdirectory.
3281 $top_reldir = '../';
3282 }
3283 else
3284 {
3285 &handle_aclocal_m4;
3286 $output_rules .= &file_contents ('remake');
3287 &examine_variable ('CONFIG_STATUS_DEPENDENCIES');
3288 &examine_variable ('CONFIGURE_DEPENDENCIES');
3289 $top_reldir = '';
3291 &push_dist_common ('acconfig.h')
3292 if -f 'acconfig.h';
3293 }
3295 # If we have a configure header, require it.
3296 local ($one_hdr);
3297 local (@local_fullnames) = @config_fullnames;
3298 local (@local_names) = @config_names;
3299 local ($hdr_index) = 0;
3300 local ($distclean_config) = '';
3301 foreach $one_hdr (@config_headers)
3302 {
3303 local ($one_fullname) = shift (@local_fullnames);
3304 local ($one_name) = shift (@local_names);
3305 $hdr_index += 1;
3306 local ($header_dir) = &dirname ($one_name);
3308 # If the header is in the current directory we want to build
3309 # the header here. Otherwise, if we're at the topmost
3310 # directory and the header's directory doesn't have a
3311 # Makefile, then we also want to build the header.
3312 if ($relative_dir eq $header_dir
3313 || ($relative_dir eq '.' && ! &is_make_dir ($header_dir)))
3314 {
3315 local ($ch_sans_dir, $cn_sans_dir, $stamp_dir);
3316 if ($relative_dir eq $header_dir)
3317 {
3318 $cn_sans_dir = &basename ($one_name);
3319 $stamp_dir = '';
3320 }
3321 else
3322 {
3323 $cn_sans_dir = $one_name;
3324 if ($header_dir eq '.')
3325 {
3326 $stamp_dir = '';
3327 }
3328 else
3329 {
3330 $stamp_dir = $header_dir . '/';
3331 }
3332 }
3334 # Compute relative path from directory holding output
3335 # header to directory holding input header. FIXME:
3336 # doesn't handle case where we have multiple inputs.
3337 if (&dirname ($one_hdr) eq $relative_dir)
3338 {
3339 $ch_sans_dir = &basename ($one_hdr);
3340 }
3341 else
3342 {
3343 local (@rel_out_path);
3344 # FIXME this chunk of code should be its own sub.
3345 # It is used elsewhere.
3346 foreach (split (/\//, $relative_dir))
3347 {
3348 next if $_ eq '' || $_ eq '.';
3349 if ($_ eq '..')
3350 {
3351 # FIXME: actually this is an error.
3352 pop @rel_out_path;
3353 }
3354 else
3355 {
3356 push (@rel_out_path, '..');
3357 }
3358 }
3359 if (@rel_out_path)
3360 {
3361 $ch_sans_dir = join ('/', @rel_out_path) . '/' . $one_hdr;
3362 }
3363 else
3364 {
3365 $ch_sans_dir = $one_hdr;
3366 }
3367 }
3369 &require_file_with_conf_line ($config_header_line,
3370 $FOREIGN, $ch_sans_dir);
3372 # Header defined and in this directory.
3373 local (@files);
3374 if (-f $one_name . '.top')
3375 {
3376 push (@files, "${cn_sans_dir}.top");
3377 }
3378 if (-f $one_name . '.bot')
3379 {
3380 push (@files, "${cn_sans_dir}.bot");
3381 }
3383 &push_dist_common (@files);
3385 # For now, acconfig.h can only appear in the top srcdir.
3386 if (-f 'acconfig.h')
3387 {
3388 if ($relative_dir eq '.')
3389 {
3390 push (@files, 'acconfig.h');
3391 }
3392 else
3393 {
3394 # Strange quoting because this gets fed through
3395 # Perl.
3396 push (@files, '\$(top_srcdir)/acconfig.h');
3397 }
3398 }
3400 local ($stamp_name) = 'stamp-h';
3401 $stamp_name .= "${hdr_index}" if scalar (@config_headers) > 1;
3403 local ($xform) = '';
3405 $xform = 's,\@FILES\@,' . join (' ', @files) . ',;';
3406 $xform .= 's,\@CONFIG_HEADER\@,' . "${cn_sans_dir}" . ',;';
3407 $xform .= 's,\@CONFIG_HEADER_IN\@,' . "${ch_sans_dir}" . ',;';
3408 $xform .= 's,\@CONFIG_HEADER_FULL\@,' . "${one_fullname}" . ',;';
3409 $xform .= 's,\@STAMP\@,' . "${stamp_dir}${stamp_name}" . ',g;';
3411 local ($out_dir) = &dirname ($ch_sans_dir);
3412 $xform .= 's,\@SRC_STAMP\@,' . "${out_dir}/${stamp_name}" . ',g;';
3413 $output_rules .= &file_contents_with_transform ($xform,
3414 'remake-hdr');
3416 &create ("${relative_dir}/${out_dir}/${stamp_name}.in");
3417 &require_file_with_conf_line ($config_header_line, $FOREIGN,
3418 "${out_dir}/${stamp_name}.in");
3420 $distclean_config .= ' ' if $distclean_config;
3421 $distclean_config .= $cn_sans_dir;
3422 }
3423 }
3425 if ($distclean_config)
3426 {
3427 $output_rules .= &file_contents_with_transform ('s,\@FILES\@,'
3428 . $distclean_config
3429 . ',;',
3430 'clean-hdr');
3431 push (@clean, 'hdr');
3432 &push_phony_cleaners ('hdr');
3433 }
3435 # Set location of mkinstalldirs.
3436 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
3437 {
3438 &define_variable ('mkinstalldirs', ('$(SHELL) ' . $config_aux_dir
3439 . '/mkinstalldirs'));
3440 }
3441 else
3442 {
3443 &define_variable ('mkinstalldirs',
3444 '$(SHELL) $(top_srcdir)/mkinstalldirs');
3445 }
3447 &am_line_error ('CONFIG_HEADER',
3448 "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
3449 if &variable_defined ('CONFIG_HEADER');
3451 local ($one_name);
3452 local ($config_header) = '';
3453 foreach $one_name (@config_names)
3454 {
3455 # Generate CONFIG_HEADER define.
3456 local ($one_hdr);
3457 if ($relative_dir eq &dirname ($one_name))
3458 {
3459 $one_hdr = &basename ($one_name);
3460 }
3461 else
3462 {
3463 $one_hdr = "${top_builddir}/${one_name}";
3464 }
3466 $config_header .= ' ' if $config_header;
3467 $config_header .= $one_hdr;
3468 }
3469 if ($config_header)
3470 {
3471 &define_variable ("CONFIG_HEADER", $config_header);
3472 }
3474 # Now look for other files in this directory which must be remade
3475 # by config.status, and generate rules for them.
3476 local (@actual_other_files) = ();
3477 local ($file, $local);
3478 local (@inputs, @rewritten_inputs, $single);
3479 local ($need_rewritten);
3480 foreach $file (@other_input_files)
3481 {
3482 if ($file =~ /^([^:]*):(.*)$/)
3483 {
3484 # This is the ":" syntax of AC_OUTPUT.
3485 $file = $1;
3486 $local = &basename ($file);
3487 @inputs = split (':', $2);
3488 @rewritten_inputs = &rewrite_inputs_into_dependencies (1, @inputs);
3489 $need_rewritten = 1;
3490 }
3491 else
3492 {
3493 # Normal usage.
3494 $local = &basename ($file);
3495 @inputs = ($local . '.in');
3496 @rewritten_inputs =
3497 &rewrite_inputs_into_dependencies (1, $file . '.in');
3498 $need_rewritten = 0;
3499 }
3501 # Skip files not in this directory.
3502 next unless &dirname ($file) eq $relative_dir;
3504 # Skip any file that is an automake input.
3505 next if -f $file . '.am';
3507 # Some users have been tempted to put `stamp-h' in the
3508 # AC_OUTPUT line. This won't do the right thing, so we
3509 # explicitly fail here.
3510 if ($local eq 'stamp-h')
3511 {
3512 # FIXME: allow real filename.
3513 &am_conf_error ('configure.in', $ac_output_line,
3514 'stamp-h should not appear in AC_OUTPUT');
3515 next;
3516 }
3518 $output_rules .= ($local . ': '
3519 . '$(top_builddir)/config.status '
3520 . join (' ', @rewritten_inputs) . "\n"
3521 . "\t"
3522 . 'cd $(top_builddir) && CONFIG_FILES='
3523 . ($relative_dir eq '.' ? '' : '$(subdir)/')
3524 . '$@' . ($need_rewritten
3525 ? (':' . join (':', @inputs))
3526 : '')
3527 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
3528 . "\n");
3529 &push_dist_common (@inputs);
3530 push (@actual_other_files, $local);
3532 # Require all input files.
3533 &require_file_with_conf_line ($ac_output_line, $FOREIGN,
3534 &rewrite_inputs_into_dependencies (0, @inputs));
3535 }
3537 # These files get removed by "make clean".
3538 &define_pretty_variable ('CONFIG_CLEAN_FILES', '', @actual_other_files);
3539 }
3541 # Handle C headers.
3542 sub handle_headers
3543 {
3544 local (@r);
3545 @r = &am_install_var ('-defaultdist', 'header', 'HEADERS', 'include',
3546 'oldinclude', 'pkginclude',
3547 'noinst', 'check');
3548 foreach (@r)
3549 {
3550 next unless /\.(.*)$/;
3551 &saw_extension ($1);
3552 }
3553 }
3555 sub handle_gettext
3556 {
3557 return if ! $seen_gettext || $relative_dir ne '.';
3559 if (! &variable_defined ('SUBDIRS'))
3560 {
3561 &am_conf_error
3562 ("AM_GNU_GETTEXT in configure.in but SUBDIRS not defined");
3563 return;
3564 }
3566 &require_file_with_conf_line ($ac_gettext_line, $GNU, 'ABOUT-NLS');
3568 if (&variable_defined ('SUBDIRS'))
3569 {
3570 &am_line_error
3571 ('SUBDIRS',
3572 "AM_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
3573 if $contents{'SUBDIRS'} !~ /\bpo\b/;
3574 &am_line_error
3575 ('SUBDIRS',
3576 "AM_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
3577 if $contents{'SUBDIRS'} !~ /\bintl\b/;
3578 }
3580 # Ensure that each language in ALL_LINGUAS has a .po file, and
3581 # each po file is mentioned in ALL_LINGUAS.
3582 if ($seen_linguas)
3583 {
3584 local (%linguas) = ();
3585 grep ($linguas{$_} = 1, split (' ', $all_linguas));
3587 foreach (<po/*.po>)
3588 {
3589 s/^po\///;
3590 s/\.po$//;
3592 &am_line_error ($all_linguas_line,
3593 ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
3594 if ! $linguas{$_};
3595 }
3597 foreach (keys %linguas)
3598 {
3599 &am_line_error ($all_linguas_line,
3600 "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
3601 if ! -f "po/$_.po";
3602 }
3603 }
3604 else
3605 {
3606 &am_error ("AM_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
3607 }
3608 }
3610 # Handle footer elements.
3611 sub handle_footer
3612 {
3613 if ($contents{'SOURCES'})
3614 {
3615 # NOTE don't use define_pretty_variable here, because
3616 # $contents{...} is already defined.
3617 $output_vars .= 'SOURCES = ' . $contents{'SOURCES'} . "\n";
3618 }
3619 if ($contents{'OBJECTS'})
3620 {
3621 # NOTE don't use define_pretty_variable here, because
3622 # $contents{...} is already defined.
3623 $output_vars .= 'OBJECTS = ' . $contents{'OBJECTS'} . "\n";
3624 }
3625 if ($contents{'SOURCES'} || $contents{'OBJECTS'})
3626 {
3627 $output_vars .= "\n";
3628 }
3630 if (&variable_defined ('SUFFIXES'))
3631 {
3632 # Push actual suffixes, and not $(SUFFIXES). Some versions of
3633 # make do not like variable substitutions on the .SUFFIXES
3634 # line.
3635 push (@suffixes, &variable_value_as_list ('SUFFIXES', ''));
3636 }
3637 if (&target_defined ('.SUFFIXES'))
3638 {
3639 &am_line_error ('.SUFFIXES',
3640 "use variable \`SUFFIXES', not target \`.SUFFIXES'");
3641 }
3643 # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
3644 # before .SUFFIXES. So we make sure that .SUFFIXES appears before
3645 # anything else, by sticking it right after the default: target.
3646 $output_header .= ".SUFFIXES:\n";
3647 if (@suffixes)
3648 {
3649 # Make sure suffixes has unique elements. Sort them to ensure
3650 # the output remains consistent.
3651 local (%suffixes);
3653 grep ($suffixes{$_} = 1, @suffixes);
3655 $output_header .= (".SUFFIXES: "
3656 . join (' ', sort keys %suffixes)
3657 . "\n");
3658 }
3659 $output_trailer .= &file_contents ('footer');
3660 }
3662 # Deal with installdirs target.
3663 sub handle_installdirs
3664 {
3665 # GNU Makefile standards recommend this.
3666 if ($recursive_install)
3667 {
3668 # We create a separate `-am' target so that the -recursive
3669 # rule will work correctly.
3670 $output_rules .= ("installdirs: installdirs-recursive\n"
3671 . "installdirs-am:\n");
3672 push (@phony, 'installdirs-am');
3673 }
3674 else
3675 {
3676 $output_rules .= "installdirs:\n";
3677 }
3678 push (@phony, 'installdirs');
3679 if (@installdirs)
3680 {
3681 &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
3682 @installdirs);
3683 }
3684 $output_rules .= "\n";
3685 }
3687 # There are several targets which need to be merged. This is because
3688 # their complete definition is compiled from many parts. Note that we
3689 # avoid double colon rules, otherwise we'd use them instead.
3690 sub handle_merge_targets
3691 {
3692 local ($makefile) = @_;
3694 # There are a few install-related variables that you should not define.
3695 local ($var);
3696 foreach $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
3697 {
3698 if (&variable_defined ($var))
3699 {
3700 &am_line_error ($var, "\`$var' should not be defined");
3701 }
3702 }
3704 # Put this at the beginning for the sake of non-GNU makes. This
3705 # is still wrong if these makes can run parallel jobs. But it is
3706 # right enough.
3707 unshift (@all, &basename ($makefile));
3709 local ($one_name);
3710 foreach $one_name (@config_names)
3711 {
3712 push (@all, &basename ($one_name))
3713 if &dirname ($one_name) eq $relative_dir;
3714 }
3716 &do_one_merge_target ('info', @info);
3717 &do_one_merge_target ('dvi', @dvi);
3718 &do_check_merge_target;
3719 &do_one_merge_target ('installcheck', @installcheck);
3721 if (defined $options{'no-installinfo'})
3722 {
3723 &do_one_merge_target ('install-info', '');
3724 }
3725 elsif (&target_defined ('install-info-local'))
3726 {
3727 &am_line_error ('install-info-local',
3728 "\`install-info-local' target defined but \`no-installinfo' option not in use");
3729 }
3731 local ($utarg);
3732 foreach $utarg ('uninstall-data-local', 'uninstall-data-hook',
3733 'uninstall-exec-local', 'uninstall-exec-hook')
3734 {
3735 if (&target_defined ($utarg))
3736 {
3737 local ($x);
3738 ($x = $utarg) =~ s/(data|exec)-//;
3739 &am_line_error ($utarg, "use \`$x', not \`$utarg'");
3740 }
3741 }
3743 if (&target_defined ('install-local'))
3744 {
3745 &am_line_error ('install-local',
3746 "use \`install-data-local' or \`install-exec-local', not \`install-local'");
3747 }
3749 if (@all)
3750 {
3751 local ($one_name);
3752 local ($local_headers) = '';
3753 foreach $one_name (@config_names)
3754 {
3755 if (&dirname ($one_name) eq $relative_dir)
3756 {
3757 $local_headers .= ' ' if $local_headers;
3758 $local_headers .= &basename ($one_name);
3759 }
3760 }
3761 if ($local_headers)
3762 {
3763 # This is kind of a hack, but I couldn't see a better way
3764 # to handle it. In this particular case, we need to make
3765 # sure config.h is built before we recurse. We can't do
3766 # this by changing the order of dependencies to the "all"
3767 # because that breaks when using parallel makes. Instead
3768 # we handle things explicitly.
3769 $output_rules .= ("all-recursive-am: ${local_headers}"
3770 . "\n\t"
3771 . '$(MAKE) $(AM_MAKEFLAGS)'
3772 . " all-recursive"
3773 . "\n\n");
3774 $all_target = 'all-recursive-am';
3775 push (@phony, 'all-recursive-am');
3776 }
3777 }
3779 # Print definitions users can use.
3780 &do_one_merge_target ('install-exec', @install_exec);
3781 $output_rules .= "\n";
3783 &do_one_merge_target ('install-data', @install_data);
3784 $output_rules .= "\n";
3786 &do_one_merge_target ('install', 'all-am');
3787 &do_one_merge_target ('uninstall', @uninstall);
3789 &do_one_merge_target ('all', @all);
3791 # Generate the new 'install-strip' target. We can't just set
3792 # INSTALL_PROGRAM because that might be a relative path.
3793 $output_rules .= ("install-strip:\n\t"
3794 . '$(MAKE) $(AM_MAKEFLAGS) INSTALL_STRIP_FLAG=-s install'
3795 . "\n");
3796 push (@phony, 'install-strip');
3797 }
3799 # Helper for handle_merge_targets. Note that handle_merge_targets
3800 # relies on the fact that this doesn't add an extra \n at the end.
3801 sub do_one_merge_target
3802 {
3803 local ($name, @values) = @_;
3805 if (&target_defined ($name . '-local'))
3806 {
3807 # User defined local form of target. So include it.
3808 push (@values, $name . '-local');
3809 push (@phony, $name . '-local');
3810 }
3812 &pretty_print_rule ($name . "-am:", "\t\t", @values);
3813 if ($name eq 'install')
3814 {
3815 # Special-case `install-am' to run install-exec-am and
3816 # install-data-am after all-am is built.
3817 &pretty_print_rule ("\t\@\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3818 'install-exec-am', 'install-data-am');
3819 }
3820 elsif ($name eq 'install-exec' && &target_defined ('install-exec-hook'))
3821 {
3822 $output_rules .= ("\t\@\$(NORMAL_INSTALL)\n"
3823 . "\t" . '$(MAKE) $(AM_MAKEFLAGS) install-exec-hook'
3824 . "\n");
3825 }
3826 elsif ($name eq 'install-data' && &target_defined ('install-data-hook'))
3827 {
3828 $output_rules .= ("\t\@\$(NORMAL_INSTALL)\n"
3829 . "\t" . '$(MAKE) $(AM_MAKEFLAGS) install-data-hook'
3830 . "\n");
3831 }
3833 local ($lname) = $name . ($recursive_install ? '-recursive' : '-am');
3834 local ($tname) = $name;
3835 # To understand this special case, see handle_merge_targets.
3836 if ($name eq 'all')
3837 {
3838 $tname = 'all-redirect';
3839 $lname = $all_target if $recursive_install;
3840 push (@phony, 'all-redirect');
3841 $output_all = "all: all-redirect\n";
3842 }
3843 &pretty_print_rule ($tname . ":", "\t\t", $lname);
3844 push (@phony, $name . '-am', $name);
3845 }
3847 # Handle check merge target specially.
3848 sub do_check_merge_target
3849 {
3850 if (&target_defined ('check-local'))
3851 {
3852 # User defined local form of target. So include it.
3853 push (@check_tests, 'check-local');
3854 push (@phony, 'check-local');
3855 }
3857 # In --cygnus mode, check doesn't depend on all.
3858 if ($cygnus_mode)
3859 {
3860 # Just run the local check rules.
3861 &pretty_print_rule ('check-am:', "\t\t", @check);
3862 }
3863 else
3864 {
3865 # The check target must depend on the local equivalent of
3866 # `all', to ensure all the primary targets are built. Then it
3867 # must build the local check rules.
3868 $output_rules .= "check-am: all-am\n";
3869 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3870 @check)
3871 if @check;
3872 }
3873 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3874 @check_tests)
3875 if @check_tests;
3877 push (@phony, 'check', 'check-am');
3878 $output_rules .= ("check: "
3879 . ($recursive_install ? 'check-recursive' : 'check-am')
3880 . "\n");
3881 }
3883 # Handle all 'clean' targets.
3884 sub handle_clean
3885 {
3886 local ($xform) = '';
3887 local ($name);
3889 # Don't include `MAINTAINER'; it is handled specially below.
3890 foreach $name ('MOSTLY', '', 'DIST')
3891 {
3892 if (! &variable_defined ($name . 'CLEANFILES'))
3893 {
3894 $xform .= 's/^' . $name . 'CLEAN.*$//;';
3895 }
3896 else
3897 {
3898 $xform .= 's/^' . $name . 'CLEAN//;';
3899 }
3900 }
3902 # Built sources are automatically removed by maintainer-clean.
3903 push (@maintainer_clean_files, '\$(BUILT_SOURCES)')
3904 if &variable_defined ('BUILT_SOURCES');
3905 push (@maintainer_clean_files, '\$(MAINTAINERCLEANFILES)')
3906 if &variable_defined ('MAINTAINERCLEANFILES');
3907 if (! @maintainer_clean_files)
3908 {
3909 $xform .= 's/^MAINTAINERCLEAN.*$//;';
3910 }
3911 else
3912 {
3913 $xform .= ('s/^MAINTAINERCLEAN//;'
3914 # Join with no space to avoid spurious `test -z'
3915 # success at runtime.
3916 . 's,\@MCFILES\@,' . join ('', @maintainer_clean_files)
3917 . ',;'
3918 # A space is required in the join here.
3919 . 's,\@MFILES\@,' . join (' ', @maintainer_clean_files)
3920 . ',;');
3921 }
3923 $output_rules .= &file_contents_with_transform ($xform, 'clean');
3925 push (@clean, 'generic');
3926 &push_phony_cleaners ('generic');
3928 &do_one_clean_target ('clean', 'mostly', '', @clean);
3929 &do_one_clean_target ('clean', '', 'mostly', @clean);
3930 &do_one_clean_target ('clean', 'dist', '', @clean);
3931 &do_one_clean_target ('clean', 'maintainer-', 'dist', @clean);
3933 push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
3934 }
3936 # Helper for handle_clean.
3937 sub do_one_clean_target
3938 {
3939 local ($target, $name, $last_name, @deps) = @_;
3941 # Change each dependency `BLARG' into `clean-BLARG'.
3942 grep (($_ = $name . 'clean-' . $_) && 0, @deps);
3944 # Push the previous clean target. There is no previous clean
3945 # target if we're doing mostlyclean.
3946 push (@deps, $last_name . $target . '-am')
3947 unless $name eq 'mostly';
3949 # If a -local version of the rule is given, add it to the list.
3950 if (&target_defined ($name . $target . '-local'))
3951 {
3952 push (@deps, $name . $target . '-local');
3953 }
3955 # Print the target and the dependencies.
3956 &pretty_print_rule ($name . $target . "-am: ", "\t\t", @deps);
3958 # FIXME: shouldn't we really print these messages before running
3959 # the dependencies?
3960 if ($name . $target eq 'maintainer-clean')
3961 {
3962 # Print a special warning.
3963 $output_rules .=
3964 ("\t\@echo \"This command is intended for maintainers to use;\"\n"
3965 . "\t\@echo \"it deletes files that may require special "
3966 . "tools to rebuild.\"\n");
3967 }
3968 elsif ($name . $target eq 'distclean')
3969 {
3970 $output_rules .= "\t-rm -f libtool\n" if $seen_libtool;
3971 }
3972 $output_rules .= "\n";
3974 # Now generate the actual clean target.
3975 $output_rules .= ($name . $target . ": " . $name . $target
3976 . ($recursive_install ? '-recursive' : '-am')
3977 . "\n");
3979 # We special-case config.status here. If we do it as part of the
3980 # normal clean processing for this directory, then it might be
3981 # removed before some subdir is cleaned. However, that subdir's
3982 # Makefile depends on config.status.
3983 if (($name . $target eq 'maintainer-clean'
3984 || $name . $target eq 'distclean')
3985 && $relative_dir eq '.')
3986 {
3987 $output_rules .= "\t-rm -f config.status\n";
3988 }
3989 $output_rules .= "\n";
3990 }
3992 # Handle .PHONY target.
3993 sub handle_phony
3994 {
3995 &pretty_print_rule ('.PHONY:', "", @phony);
3996 $output_rules .= "\n";
3997 }
3999 # Handle TESTS variable and other checks.
4000 sub handle_tests
4001 {
4002 if (defined $options{'dejagnu'})
4003 {
4004 push (@check_tests, 'check-DEJAGNU');
4005 push (@phony, 'check-DEJAGNU');
4007 local ($xform);
4008 if ($cygnus_mode)
4009 {
4010 $xform = 's/^CYGNUS//;';
4011 }
4012 else
4013 {
4014 $xform = 's/^CYGNUS.*$//;';
4015 }
4016 $output_rules .= &file_contents_with_transform ($xform, 'dejagnu');
4018 # In Cygnus mode, these are found in the build tree.
4019 # Otherwise they are looked for in $PATH.
4020 &define_program_variable ('EXPECT', 'build', 'expect', 'expect');
4021 &define_program_variable ('RUNTEST', 'src', 'dejagnu', 'runtest');
4023 # Only create site.exp rule if user hasn't already written
4024 # one.
4025 if (! &target_defined ('site.exp'))
4026 {
4027 # Note that in the rule we don't directly generate
4028 # site.exp to avoid the possibility of a corrupted
4029 # site.exp if make is interrupted. Jim Meyering has some
4030 # useful text on this topic.
4031 $output_rules .= ("site.exp: Makefile\n"
4032 . "\t\@echo 'Making a new site.exp file...'\n"
4033 . "\t\@test ! -f site.bak || rm -f site.bak\n"
4034 . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
4035 . "\t\@echo '# Do not edit here. If you wish to override these values' >> \$\@-t\n"
4036 . "\t\@echo '# edit the last section' >> \$\@-t\n"
4037 . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
4038 . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
4039 . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
4041 # Extra stuff for AC_CANONICAL_*
4042 local (@whatlist) = ();
4043 if ($seen_canonical)
4044 {
4045 push (@whatlist, 'host');
4046 }
4048 # Extra stuff only for AC_CANONICAL_SYSTEM.
4049 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
4050 {
4051 push (@whatlist, 'target', 'build');
4052 }
4054 local ($c1, $c2);
4055 foreach $c1 (@whatlist)
4056 {
4057 foreach $c2 ('alias', 'triplet')
4058 {
4059 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
4060 }
4061 }
4063 $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
4064 . "\t\@test ! -f site.exp || sed '1,/^## All variables above are.*##/ d' site.exp >> \$\@-t\n"
4065 . "\t\@test ! -f site.exp || mv site.exp site.bak\n"
4066 . "\t\@mv \$\@-t site.exp\n");
4067 }
4068 }
4069 else
4070 {
4071 local ($c);
4072 foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
4073 {
4074 if (&variable_defined ($c))
4075 {
4076 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
4077 }
4078 }
4079 }
4081 if (&variable_defined ('TESTS'))
4082 {
4083 push (@check_tests, 'check-TESTS');
4084 push (@phony, 'check-TESTS');
4086 # Note: Solaris 2.7 seems to expand TESTS using VPATH. That's
4087 # why we also try `dir='
4088 $output_rules .= 'check-TESTS: $(TESTS)
4089 @failed=0; all=0; xfail=0; xpass=0; \\
4090 srcdir=$(srcdir); export srcdir; \\
4091 list=' . "'\$(TESTS)'; \\" . '
4092 if test -n "$$list"; then \\
4093 for tst in $$list; do \\
4094 if test -f ./$$tst; then dir=./; \\
4095 elif test -f $$tst; then dir=; \\
4096 else dir="$(srcdir)/"; fi; \\
4097 if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \\
4098 all=`expr $$all + 1`; \\
4099 case " $(XFAIL_TESTS) " in \\
4100 *" $$tst "*) \\
4101 xpass=`expr $$xpass + 1`; \\
4102 failed=`expr $$failed + 1`; \\
4103 echo "XPASS: $$tst"; \\
4104 ;; \\
4105 *) \\
4106 echo "PASS: $$tst"; \\
4107 ;; \\
4108 esac; \\
4109 elif test $$? -ne 77; then \\
4110 all=`expr $$all + 1`; \\
4111 case " $(XFAIL_TESTS) " in \\
4112 *" $$tst "*) \\
4113 xfail=`expr $$xfail + 1`; \\
4114 echo "XFAIL: $$tst"; \\
4115 ;; \\
4116 *) \\
4117 failed=`expr $$failed + 1`; \\
4118 echo "FAIL: $$tst"; \\
4119 ;; \\
4120 esac; \\
4121 fi; \\
4122 done; \\
4123 if test "$$failed" -eq 0; then \\
4124 if test "$$xfail" -eq 0; then \\
4125 banner="All $$all tests passed"; \\
4126 else \\
4127 banner="All $$all tests behaved as expected ($$xfail expected failures)"; \\
4128 fi; \\
4129 else \\
4130 if test "$$xpass" -eq 0; then \\
4131 banner="$$failed of $$all tests failed"; \\
4132 else \\
4133 banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \\
4134 fi; \\
4135 fi; \\
4136 dashes=`echo "$$banner" | sed s/./=/g`; \\
4137 echo "$$dashes"; \\
4138 echo "$$banner"; \\
4139 echo "$$dashes"; \\
4140 test "$$failed" -eq 0; \\
4141 fi
4142 ';
4143 }
4144 }
4146 # Handle Emacs Lisp.
4147 sub handle_emacs_lisp
4148 {
4149 local (@elfiles) = &am_install_var ('-candist', 'lisp', 'LISP',
4150 'lisp', 'noinst');
4152 if (@elfiles)
4153 {
4154 # Found some lisp.
4155 &define_configure_variable ('lispdir');
4156 &define_configure_variable ('EMACS');
4157 $output_rules .= (".el.elc:\n"
4158 . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
4159 . "\tif test \$(EMACS) != no; then \\\n"
4160 . "\t EMACS=\$(EMACS) \$(SHELL) \$(srcdir)/elisp-comp \$<; \\\n"
4161 . "\tfi\n");
4162 push (@suffixes, '.el', '.elc');
4164 # Generate .elc files.
4165 grep ($_ .= 'c', @elfiles);
4166 &define_pretty_variable ('ELCFILES', '', @elfiles);
4168 $output_rules .= &file_contents ('lisp-clean');
4169 push (@clean, 'lisp');
4170 &push_phony_cleaners ('lisp');
4172 push (@all, '$(ELCFILES)');
4174 local ($varname);
4175 if (&variable_defined ('lisp_LISP'))
4176 {
4177 $varname = 'lisp_LISP';
4178 &am_error ("\`lisp_LISP' defined but \`AM_PATH_LISPDIR' not in \`configure.in'")
4179 if ! $seen_lispdir;
4180 }
4181 else
4182 {
4183 $varname = 'noinst_LISP';
4184 }
4186 &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
4187 }
4188 }
4190 # Handle Python
4191 sub handle_python
4192 {
4193 local (@pyfiles) = &am_install_var ('-defaultdist', 'python', 'PYTHON',
4194 'python', 'noinst');
4195 return if ! @pyfiles;
4197 # Found some python.
4198 &define_configure_variable ('pythondir');
4199 &define_configure_variable ('PYTHON');
4201 $output_rules .= &file_contents ('python-clean');
4202 push (@clean, 'python');
4204 &am_error ("\`python_PYTHON' defined but \`AM_CHECK_PYTHON' not in \`configure.in'")
4205 if ! $seen_pythondir && &variable_defined ('python_PYTHON');
4207 if ($config_aux_dir eq '.' || $config_aux_dir eq '')
4208 {
4209 &define_variable ('py_compile', '$(top_srcdir)/py-compile');
4210 }
4211 else
4212 {
4213 &define_variable ('py_compile', $config_aux_dir . '/py-compile');
4214 }
4215 }
4217 # Handle Java.
4218 sub handle_java
4219 {
4220 local (@sourcelist) = &am_install_var ('-candist', '-clean',
4221 'java', 'JAVA',
4222 'java', 'noinst', 'check');
4223 return if ! @sourcelist;
4225 &define_variable ('JAVAC', 'javac');
4226 &define_variable ('JAVACFLAGS', '');
4227 &define_variable ('CLASSPATH_ENV',
4228 'CLASSPATH=$(JAVAROOT):$(srcdir)/$(JAVAROOT):$$CLASSPATH');
4229 &define_variable ('JAVAROOT', '$(top_builddir)');
4231 local (%valid) = &am_primary_prefixes ('JAVA', 1,
4232 'java', 'noinst', 'check');
4234 local ($dir, $curs);
4235 foreach $curs (keys %valid)
4236 {
4237 if (! &variable_defined ($curs . '_JAVA') || $curs eq 'noinst'
4238 || $curs eq 'EXTRA')
4239 {
4240 next;
4241 }
4243 if (defined $dir)
4244 {
4245 &am_line_error ($curs . '_JAVA',
4246 "multiple _JAVA primaries in use");
4247 }
4248 $dir = $curs;
4249 }
4251 $output_rules .= ('class' . $dir . '.stamp: $(' . $dir . '_JAVA)' . "\n"
4252 . "\t" . '$(CLASSPATH_ENV) $(JAVAC) -d $(JAVAROOT) '
4253 . '$(JAVACFLAGS) $?' . "\n"
4254 . "\t" . 'echo timestamp > class' . $dir . '.stamp'
4255 . "\n");
4256 push (@all, 'class' . $dir . '.stamp');
4257 &push_dist_common ('$(' . $dir . '_JAVA)');
4258 }
4260 # Handle some of the minor options.
4261 sub handle_minor_options
4262 {
4263 if (defined $options{'readme-alpha'})
4264 {
4265 if ($relative_dir eq '.')
4266 {
4267 if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
4268 {
4269 # FIXME: allow real filename.
4270 &am_conf_line_error ('configure.in',
4271 $package_version_line,
4272 "version \`$package_version' doesn't follow Gnits standards");
4273 }
4274 elsif (defined $1 && -f 'README-alpha')
4275 {
4276 # This means we have an alpha release. See
4277 # GNITS_VERSION_PATTERN for details.
4278 &require_file ($FOREIGN, 'README-alpha');
4279 }
4280 }
4281 }
4282 }
4284 ################################################################
4286 # Scan one file for interesting things. Subroutine of scan_configure.
4287 sub scan_one_configure_file
4288 {
4289 local ($filename) = @_;
4290 local (*CONFIGURE);
4292 open (CONFIGURE, $filename)
4293 || die "automake: couldn't open \`$filename': $!\n";
4294 print "automake: reading $filename\n" if $verbose;
4296 while (<CONFIGURE>)
4297 {
4298 # Remove comments from current line.
4299 s/\bdnl\b.*$//;
4300 s/\#.*$//;
4302 # Skip macro definitions. Otherwise we might be confused into
4303 # thinking that a macro that was only defined was actually
4304 # used.
4305 next if /AC_DEFUN/;
4307 # Follow includes. This is a weirdness commonly in use at
4308 # Cygnus and hopefully nowhere else.
4309 if (/sinclude\((.*)\)/ && -f $1)
4310 {
4311 &scan_one_configure_file ($1);
4312 }
4314 # Populate libobjs array.
4315 if (/AC_FUNC_ALLOCA/)
4316 {
4317 $libsources{'alloca.c'} = 1;
4318 }
4319 elsif (/AC_FUNC_GETLOADAVG/)
4320 {
4321 $libsources{'getloadavg.c'} = 1;
4322 }
4323 elsif (/AC_FUNC_MEMCMP/)
4324 {
4325 $libsources{'memcmp.c'} = 1;
4326 }
4327 elsif (/AC_STRUCT_ST_BLOCKS/)
4328 {
4329 $libsources{'fileblocks.c'} = 1;
4330 }
4331 elsif (/A[CM]_REPLACE_GNU_GETOPT/)
4332 {
4333 $libsources{'getopt.c'} = 1;
4334 $libsources{'getopt1.c'} = 1;
4335 }
4336 elsif (/AM_FUNC_STRTOD/)
4337 {
4338 $libsources{'strtod.c'} = 1;
4339 }
4340 elsif (/AM_WITH_REGEX/)
4341 {
4342 $libsources{'rx.c'} = 1;
4343 $libsources{'rx.h'} = 1;
4344 $libsources{'regex.c'} = 1;
4345 $libsources{'regex.h'} = 1;
4346 $omit_dependencies{'rx.h'} = 1;
4347 $omit_dependencies{'regex.h'} = 1;
4348 }
4349 elsif (/AC_FUNC_MKTIME/)
4350 {
4351 $libsources{'mktime.c'} = 1;
4352 }
4353 elsif (/AM_FUNC_ERROR_AT_LINE/)
4354 {
4355 $libsources{'error.c'} = 1;
4356 $libsources{'error.h'} = 1;
4357 }
4358 elsif (/AM_FUNC_OBSTACK/)
4359 {
4360 $libsources{'obstack.c'} = 1;
4361 $libsources{'obstack.h'} = 1;
4362 }
4363 elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
4364 || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
4365 {
4366 foreach $libobj_iter (split (' ', $1))
4367 {
4368 if ($libobj_iter =~ /^(.*)\.o(bj)?$/
4369 || $libobj_iter =~ /^(.*)\.\$ac_objext$/
4370 || $libobj_iter =~ /^(.*)\.\$\{ac_objext\}$/)
4371 {
4372 $libsources{$1 . '.c'} = 1;
4373 }
4374 }
4375 }
4376 elsif (/AC_LIBOBJ\(([^)]+)\)/)
4377 {
4378 $libsources{"$1.c"} = 1;
4379 }
4381 if (! $in_ac_replace && s/AC_REPLACE_FUNCS\s*\(\[?//)
4382 {
4383 $in_ac_replace = 1;
4384 }
4385 if ($in_ac_replace)
4386 {
4387 $in_ac_replace = 0 if s/[\]\)].*$//;
4388 # Remove trailing backslash.
4389 s/\\$//;
4390 foreach (split)
4391 {
4392 # Need to skip empty elements for Perl 4.
4393 next if $_ eq '';
4394 $libsources{$_ . '.c'} = 1;
4395 }
4396 }
4398 if (/$obsolete_rx/o)
4399 {
4400 local ($hint) = '';
4401 if ($obsolete_macros{$1} ne '')
4402 {
4403 $hint = '; ' . $obsolete_macros{$1};
4404 }
4405 &am_conf_line_error ($filename, $., "\`$1' is obsolete$hint");
4406 }
4408 # Process the AC_OUTPUT and AC_CONFIG_FILES macros.
4409 if (! $in_ac_output && s/AC_(OUTPUT|CONFIG_FILES)\s*\(\[?//)
4410 {
4411 $in_ac_output = 1;
4412 $ac_output_line = $.;
4413 }
4414 if ($in_ac_output)
4415 {
4416 local ($closing) = 0;
4417 if (s/[\]\),].*$//)
4418 {
4419 $in_ac_output = 0;
4420 $closing = 1;
4421 }
4423 # Look at potential Makefile.am's.
4424 foreach (split)
4425 {
4426 # Must skip empty string for Perl 4.
4427 next if $_ eq "\\" || $_ eq '';
4429 # Handle $local:$input syntax. Note that we ignore
4430 # every input file past the first, though we keep
4431 # those around for later.
4432 local ($local, $input, @rest) = split (/:/);
4433 if (! $input)
4434 {
4435 $input = $local;
4436 }
4437 else
4438 {
4439 # FIXME: should be error if .in is missing.
4440 $input =~ s/\.in$//;
4441 }
4443 if (-f $input . '.am')
4444 {
4445 # We have a file that automake should generate.
4446 push (@make_input_list, $input);
4447 $make_list{$input} = join (':', ($local, @rest));
4448 }
4449 else
4450 {
4451 # We have a file that automake should cause to be
4452 # rebuilt, but shouldn't generate itself.
4453 push (@other_input_files, $_);
4454 }
4455 }
4457 if ($closing && @make_input_list == 0 && @other_input_files == 0)
4458 {
4459 &am_conf_line_error ($filename, $ac_output_line,
4460 "No files mentioned in \`AC_OUTPUT'");
4461 exit 1;
4462 }
4463 }
4465 if (/$AC_CONFIG_AUX_DIR_PATTERN/o)
4466 {
4467 @config_aux_path = $1;
4468 }
4470 # Check for ansi2knr.
4471 $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
4473 # Check for exe extension stuff.
4474 if (/AC_EXEEXT/)
4475 {
4476 $seen_exeext = 1;
4477 $configure_vars{'EXEEXT'} = $filename . ':' . $.;
4478 }
4480 if (/AC_OBJEXT/)
4481 {
4482 $seen_objext = 1;
4483 $configure_vars{'OBJEXT'} = $filename . ':' . $.;
4484 }
4486 # Check for `-c -o' code.
4487 $seen_cc_c_o = 1 if /AM_PROG_CC_C_O/;
4489 # Check for NLS support.
4490 if (/AM_GNU_GETTEXT/)
4491 {
4492 $seen_gettext = 1;
4493 $ac_gettext_line = $.;
4494 $omit_dependencies{'libintl.h'} = 1;
4495 }
4497 # Look for ALL_LINGUAS.
4498 if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
4499 {
4500 $seen_linguas = 1;
4501 $all_linguas = $1;
4502 $all_linguas_line = $.;
4503 }
4505 # Handle configuration headers. A config header of `[$1]'
4506 # means we are actually scanning AM_CONFIG_HEADER from
4507 # aclocal.m4.
4508 if (/A([CM])_CONFIG_HEADERS?\s*\((.*)\)/
4509 && $2 ne '[$1]')
4510 {
4511 &am_conf_line_error
4512 ($filename, $., "\`automake requires \`AM_CONFIG_HEADER', not \`AC_CONFIG_HEADER'")
4513 if $1 eq 'C';
4515 $config_header_line = $.;
4516 local ($one_hdr);
4517 foreach $one_hdr (split (' ', $2))
4518 {
4519 push (@config_fullnames, $one_hdr);
4520 if ($one_hdr =~ /^([^:]+):(.+)$/)
4521 {
4522 push (@config_names, $1);
4523 push (@config_headers, $2);
4524 }
4525 else
4526 {
4527 push (@config_names, $one_hdr);
4528 push (@config_headers, $one_hdr . '.in');
4529 }
4530 }
4531 }
4533 # Handle AC_CANONICAL_*. Always allow upgrading to
4534 # AC_CANONICAL_SYSTEM, but never downgrading.
4535 $seen_canonical = $AC_CANONICAL_HOST
4536 if ! $seen_canonical
4537 && (/AC_CANONICAL_HOST/ || /AC_CHECK_TOOL/);
4538 $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
4540 $seen_path_xtra = 1 if /AC_PATH_XTRA/;
4542 # This macro handles several different things.
4543 if (/$AM_INIT_AUTOMAKE_PATTERN/o)
4544 {
4545 $seen_make_set = 1;
4546 $seen_arg_prog = 1;
4547 $seen_prog_install = 1;
4548 ($package_version = $1) =~ s/$AM_PACKAGE_VERSION_PATTERN/$1/o;
4549 $package_version_line = $.;
4550 $seen_init_automake = 1;
4551 }
4553 # Some things required by Automake.
4554 $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
4555 $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
4557 if (/AM_PROG_LEX/)
4558 {
4559 $configure_vars{'LEX'} = $filename . ':' . $.;
4560 $seen_decl_yytext = 1;
4561 }
4562 if (/AC_DECL_YYTEXT/ && $filename =~ /configure\.in$/)
4563 {
4564 &am_conf_line_warning ($filename, $., "\`AC_DECL_YYTEXT' is covered by \`AM_PROG_LEX'");
4565 }
4566 if (/AC_PROG_LEX/ && $filename =~ /configure\.in$/)
4567 {
4568 &am_conf_line_warning ($filename, $., "automake requires \`AM_PROG_LEX', not \`AC_PROG_LEX'");
4569 }
4571 if (/AC_PROG_(F77|YACC|RANLIB|CC|CXXCPP|CXX|LEX|AWK|CPP|LN_S)/)
4572 {
4573 $configure_vars{$1} = $filename . ':' . $.;
4574 }
4575 if (/$AC_CHECK_PATTERN/o)
4576 {
4577 $configure_vars{$3} = $filename . ':' . $.;
4578 }
4579 if (/$AM_MISSING_PATTERN/o
4580 && $1 ne 'ACLOCAL'
4581 && $1 ne 'AUTOCONF'
4582 && $1 ne 'AUTOMAKE'
4583 && $1 ne 'AUTOHEADER')
4584 {
4585 $configure_vars{$1} = $filename . ':' . $.;
4586 }
4588 # Explicitly avoid ANSI2KNR -- we AC_SUBST that in protos.m4,
4589 # but later define it elsewhere. This is pretty hacky. We
4590 # also explicitly avoid INSTALL_SCRIPT and some other
4591 # variables because they are defined in header-vars.am.
4592 # FIXME.
4593 if (/$AC_SUBST_PATTERN/o
4594 && $1 ne 'ANSI2KNR'
4595 && $1 ne 'INSTALL_SCRIPT'
4596 && $1 ne 'INSTALL_DATA')
4597 {
4598 $configure_vars{$1} = $filename . ':' . $.;
4599 }
4601 $seen_decl_yytext = 1 if /AC_DECL_YYTEXT/;
4602 if (/AM_MAINTAINER_MODE/)
4603 {
4604 $seen_maint_mode = 1;
4605 $configure_cond{'MAINTAINER_MODE'} = 1;
4606 }
4608 $seen_prog_install = 1 if /AC_PROG_INSTALL/;
4609 $seen_lispdir = 1 if /AM_PATH_LISPDIR/;
4610 $seen_pythondir = 1 if /AM_PATH_PYTHON/;
4612 if (/A(C|M)_PROG_LIBTOOL/)
4613 {
4614 if (/AM_PROG_LIBTOOL/)
4615 {
4616 &am_conf_line_warning ($filename, $., "\`AM_PROG_LIBTOOL' is obsolete, use \`AC_PROG_LIBTOOL' instead");
4617 }
4618 $seen_libtool = 1;
4619 $libtool_line = $.;
4620 $configure_vars{'LIBTOOL'} = $filename . ':' . $.;
4621 $configure_vars{'RANLIB'} = $filename . ':' . $.;
4622 $configure_vars{'CC'} = $filename . ':' . $.;
4623 # AC_PROG_LIBTOOL runs AC_CANONICAL_HOST. Make sure we
4624 # never downgrade (if we've seen AC_CANONICAL_SYSTEM).
4625 $seen_canonical = $AC_CANONICAL_HOST if ! $seen_canonical;
4626 }
4628 $seen_multilib = 1 if (/AM_ENABLE_MULTILIB/);
4630 if (/$AM_CONDITIONAL_PATTERN/o)
4631 {
4632 $configure_cond{$1} = 1;
4633 }
4635 # Check for Fortran 77 intrinsic and run-time libraries.
4636 if (/AC_F77_LIBRARY_LDFLAGS/)
4637 {
4638 $configure_vars{'FLIBS'} = $filename . ':' . $.;
4639 }
4640 }
4642 close (CONFIGURE);
4643 }
4645 # Scan configure.in and aclocal.m4 for interesting things. We must
4646 # scan aclocal.m4 because there might be AC_SUBSTs and such there.
4647 sub scan_configure
4648 {
4649 # Reinitialize libsources here. This isn't really necessary,
4650 # since we currently assume there is only one configure.in. But
4651 # that won't always be the case.
4652 %libsources = ();
4654 local ($in_ac_output, $in_ac_replace) = (0, 0);
4655 local (%make_list, @make_input_list);
4656 local ($libobj_iter);
4658 &scan_one_configure_file ('configure.in');
4659 &scan_one_configure_file ('aclocal.m4')
4660 if -f 'aclocal.m4';
4662 # Set input and output files if not specified by user.
4663 if (! @input_files)
4664 {
4665 @input_files = @make_input_list;
4666 %output_files = %make_list;
4667 }
4669 @configure_input_files = @make_input_list;
4671 &am_conf_error ("\`AM_INIT_AUTOMAKE' must be used in configure.in")
4672 if ! $seen_init_automake;
4674 # Always require AC_PROG_MAKE_SET. We might randomly use $(MAKE)
4675 # for our own reasons.
4676 &am_conf_error ("\`AC_PROG_MAKE_SET' must be used in configure.in")
4677 if ! $seen_make_set;
4679 # Look for some files we need. Always check for these. This
4680 # check must be done for every run, even those where we are only
4681 # looking at a subdir Makefile. We must set relative_dir so that
4682 # the file-finding machinery works.
4683 local ($relative_dir) = '.';
4684 &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs', 'missing');
4685 &am_error ("\`install.sh' is an anachronism; use \`install-sh' instead")
4686 if -f $config_aux_path[0] . '/install.sh';
4688 &require_config_file ($FOREIGN, 'py-compile')
4689 if $seen_pythondir;
4691 # Preserve dist_common for later.
4692 %configure_dist_common = %dist_common;
4693 }
4695 ################################################################
4697 # Set up for Cygnus mode.
4698 sub check_cygnus
4699 {
4700 return unless $cygnus_mode;
4702 &set_strictness ('foreign');
4703 $options{'no-installinfo'} = 1;
4704 $options{'no-dependencies'} = 1;
4705 $use_dependencies = 0;
4707 if (! $seen_maint_mode)
4708 {
4709 &am_conf_error ("\`AM_MAINTAINER_MODE' required when --cygnus specified");
4710 }
4712 if (! $seen_exeext)
4713 {
4714 &am_conf_error ("\`AC_EXEEXT' required when --cygnus specified");
4715 }
4716 }
4718 # Do any extra checking for GNU standards.
4719 sub check_gnu_standards
4720 {
4721 if ($relative_dir eq '.')
4722 {
4723 # In top level (or only) directory.
4724 &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
4725 'AUTHORS', 'ChangeLog');
4726 }
4728 if ($strictness >= $GNU)
4729 {
4730 if (defined $options{'no-installman'})
4731 {
4732 &am_line_error ('AUTOMAKE_OPTIONS',
4733 "option \`no-installman' disallowed by GNU standards");
4734 }
4736 if (defined $options{'no-installinfo'})
4737 {
4738 &am_line_error ('AUTOMAKE_OPTIONS',
4739 "option \`no-installinfo' disallowed by GNU standards");
4740 }
4741 }
4742 }
4744 # Do any extra checking for GNITS standards.
4745 sub check_gnits_standards
4746 {
4747 if ($relative_dir eq '.')
4748 {
4749 # In top level (or only) directory.
4750 &require_file ($GNITS, 'THANKS');
4751 }
4752 }
4754 ################################################################
4755 #
4756 # Functions to handle files of each language.
4758 # Each `lang_X_rewrite' function follows a simple formula:
4759 # * Args are the directory, base name and extension of the file.
4760 # * Return value is 1 if file is to be dealt with, 0 otherwise.
4761 # Much of the actual processing is handled in handle_single_transform_list.
4762 # These functions exist so that auxiliary information can be recorded
4763 # for a later cleanup pass. Note that the calls to these functions
4764 # are computed, so don't bother searching for their precise names
4765 # in the source.
4767 # This is just a convenience function that can be used to determine
4768 # when a subdir object should be used.
4769 sub lang_sub_obj
4770 {
4771 return defined $options{'subdir-objects'} ? $LANG_SUBDIR : $LANG_PROCESS;
4772 }
4774 # Rewrite a single C source file.
4775 sub lang_c_rewrite
4776 {
4777 local ($directory, $base, $ext) = @_;
4779 if (defined $options{'ansi2knr'} && $base =~ /_$/)
4780 {
4781 # FIXME: include line number in error.
4782 &am_error ("C source file \`$base.c' would be deleted by ansi2knr rules");
4783 }
4785 local ($r) = $LANG_PROCESS;
4786 if (defined $options{'subdir-objects'})
4787 {
4788 $r = $LANG_SUBDIR;
4789 $base = $directory . '/' . $base;
4791 if (! $seen_cc_c_o)
4792 {
4793 # Only give error once.
4794 $seen_cc_c_o = 1;
4795 # FIXME: line number.
4796 &am_error ("C objects in subdir but \`AM_PROG_CC_C_O' not in \`configure.in'");
4797 }
4799 &require_file ($FOREIGN, 'compile')
4800 if $relative_dir eq '.';
4801 }
4803 $de_ansi_files{$base} = 1;
4804 return $r;
4805 }
4807 # Rewrite a single C++ source file.
4808 sub lang_cxx_rewrite
4809 {
4810 return &lang_sub_obj;
4811 }
4813 # Rewrite a single header file.
4814 sub lang_header_rewrite
4815 {
4816 # Header files are simply ignored.
4817 return $LANG_IGNORE;
4818 }
4820 # Rewrite a single yacc file.
4821 sub lang_yacc_rewrite
4822 {
4823 local ($directory, $base, $ext) = @_;
4825 local ($r) = &lang_c_rewrite ($directory, $base, $ext);
4826 local ($pfx) = '';
4827 if ($r == $LANG_SUBDIR)
4828 {
4829 $pfx = $directory . '/';
4830 }
4831 $yacc_sources{$pfx . $base . '.' . $ext} = 1;
4832 $ext =~ tr/y/c/;
4833 &saw_extension ('c');
4834 # FIXME: nodist.
4835 &push_dist_common ($pfx . $base . '.' . $ext);
4836 return $r;
4837 }
4839 # Rewrite a single yacc++ file.
4840 sub lang_yaccxx_rewrite
4841 {
4842 local ($directory, $base, $ext) = @_;
4844 local ($r) = $LANG_PROCESS;
4845 local ($pfx) = '';
4846 if (defined $options{'subdir-objects'})
4847 {
4848 $pfx = $directory . '/';
4849 $r = $LANG_SUBDIR;
4850 }
4851 $yacc_sources{$pfx . $base . '.' . $ext} = 1;
4852 $ext =~ tr/y/c/;
4853 &saw_extension ($ext);
4854 # FIXME: nodist.
4855 &push_dist_common ($pfx . $base . '.' . $ext);
4856 return $r;
4857 }
4859 # Rewrite a single lex file.
4860 sub lang_lex_rewrite
4861 {
4862 local ($directory, $base, $ext) = @_;
4864 local ($r) = &lang_c_rewrite ($directory, $base, $ext);
4865 local ($pfx) = '';
4866 if ($r == $LANG_SUBDIR)
4867 {
4868 $pfx = $directory . '/';
4869 }
4870 $lex_sources{$pfx . $base . '.' . $ext} = 1;
4871 $ext =~ tr/l/c/;
4872 &saw_extension ('c');
4873 # FIXME: nodist.
4874 &push_dist_common ($pfx . $base . '.' . $ext);
4875 return $r;
4876 }
4878 # Rewrite a single lex++ file.
4879 sub lang_lexxx_rewrite
4880 {
4881 local ($directory, $base, $ext) = @_;
4883 local ($r) = $LANG_PROCESS;
4884 local ($pfx) = '';
4885 if (defined $options{'subdir-objects'})
4886 {
4887 $pfx = $directory . '/';
4888 $r = $LANG_SUBDIR;
4889 }
4890 $lex_sources{$pfx . $base . '.' . $ext} = 1;
4891 $ext =~ tr/l/c/;
4892 &saw_extension ($ext);
4893 # FIXME: nodist.
4894 &push_dist_common ($pfx . $base . '.' . $ext);
4895 return $r;
4896 }
4898 # Rewrite a single assembly file.
4899 sub lang_asm_rewrite
4900 {
4901 return &lang_sub_obj;
4902 }
4904 # Rewrite a single Fortran 77 file.
4905 sub lang_f77_rewrite
4906 {
4907 return $LANG_PROCESS;
4908 }
4910 # Rewrite a single preprocessed Fortran 77 file.
4911 sub lang_ppf77_rewrite
4912 {
4913 return $LANG_PROCESS;
4914 }
4916 # Rewrite a single ratfor file.
4917 sub lang_ratfor_rewrite
4918 {
4919 return $LANG_PROCESS;
4920 }
4922 # Rewrite a single Objective C file.
4923 sub lang_objc_rewrite
4924 {
4925 return &lang_sub_obj;
4926 }
4928 # Rewrite a single Java file.
4929 sub lang_java_rewrite
4930 {
4931 return $LANG_SUBDIR;
4932 }
4934 # The lang_X_finish functions are called after all source file
4935 # processing is done. Each should handle defining rules for the
4936 # language, etc. A finish function is only called if a source file of
4937 # the appropriate type has been seen.
4939 sub lang_c_finish
4940 {
4941 # Push all libobjs files onto de_ansi_files. We actually only
4942 # push files which exist in the current directory, and which are
4943 # genuine source files.
4944 local ($file);
4945 foreach $file (keys %libsources)
4946 {
4947 if ($file =~ /^(.*)\.[cly]$/ && -f "$relative_dir/$file")
4948 {
4949 $de_ansi_files{$1} = 1;
4950 }
4951 }
4953 if (defined $options{'ansi2knr'} && keys %de_ansi_files)
4954 {
4955 # Make all _.c files depend on their corresponding .c files.
4956 local ($base, @objects);
4957 foreach $base (sort keys %de_ansi_files)
4958 {
4959 # Each _.c file must depend on ansi2knr; otherwise it
4960 # might be used in a parallel build before it is built.
4961 # We need to support files in the srcdir and in the build
4962 # dir (because these files might be auto-generated. But
4963 # we can't use $< -- some makes only define $< during a
4964 # suffix rule.
4965 $output_rules .= ($base . "_.c: $base.c \$(ANSI2KNR)\n\t"
4966 . '$(CPP) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) '
4967 . '`if test -f $(srcdir)/' . $base . '.c'
4968 . '; then echo $(srcdir)/' . $base . '.c'
4969 . '; else echo ' . $base . '.c; fi` '
4970 . "| sed 's/^# \\([0-9]\\)/#line \\1/' "
4971 . '| $(ANSI2KNR) > ' . $base . "_.c\n");
4972 push (@objects, $base . '_'
4973 . ($seen_objext ? '.$(OBJEXT)' : '.o'));
4974 push (@objects, $base . '_.lo') if $seen_libtool;
4975 }
4977 # Make all _.o (and _.lo) files depend on ansi2knr.
4978 # Use a sneaky little hack to make it print nicely.
4979 &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
4980 }
4982 if (! defined $configure_vars{'CC'})
4983 {
4984 # FIXME: line number.
4985 &am_error ("C source seen but \`CC' not defined in \`configure.in'");
4986 }
4987 }
4989 sub lang_cxx_finish
4990 {
4991 local ($ltcompile, $ltlink) = &libtool_compiler;
4993 &define_variable ('CXXLD', '$(CXX)');
4994 &define_variable ('CXXLINK', $ltlink . '$(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
4996 if (! defined $configure_vars{'CXX'})
4997 {
4998 &am_error ("C++ source seen but \`CXX' not defined in \`configure.in'");
4999 }
5000 }
5002 sub lang_header_finish
5003 {
5004 # Nothing to do.
5005 }
5007 # This is a helper for both lex and yacc.
5008 sub yacc_lex_finish_helper
5009 {
5010 return if defined $language_scratch{'lex-yacc-done'};
5011 $language_scratch{'lex-yacc-done'} = 1;
5013 # If there is more than one distinct yacc (resp lex) source file
5014 # in a given directory, then the `ylwrap' program is required to
5015 # allow parallel builds to work correctly. FIXME: for now, no
5016 # line number.
5017 &require_config_file ($FOREIGN, 'ylwrap');
5018 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
5019 {
5020 &define_variable ('YLWRAP', $config_aux_dir . "/ylwrap");
5021 }
5022 else
5023 {
5024 &define_variable ('YLWRAP', '$(srcdir)/ylwrap');
5025 }
5026 }
5028 sub lang_yacc_finish
5029 {
5030 return if defined $language_scratch{'yacc-done'};
5031 $language_scratch{'yacc-done'} = 1;
5033 local ($file, $base, $hname, $cname);
5034 local (%seen_suffix) = ();
5035 local (@yacc_files) = sort keys %yacc_sources;
5036 local ($yacc_count) = scalar (@yacc_files);
5037 foreach $file (@yacc_files)
5038 {
5039 $file =~ /(\..*)$/;
5040 &output_yacc_build_rule ($1, $yacc_count > 1)
5041 if ! defined $seen_suffix{$1};
5042 $seen_suffix{$1} = 1;
5044 $file =~ /^(.*)\.(y|yy|y\+\+|yxx|ypp)$/;
5045 $base = $1;
5046 $hname = 'h'; # Always use `.h' for header file.
5047 ($cname = $2) =~ tr/y/c/;
5049 if ((&variable_defined ('AM_YFLAGS')
5050 && &variable_value ('AM_YFLAGS') =~ /(^|\s)-d(\s|$)/)
5051 || (&variable_defined ('YFLAGS')
5052 && &variable_value ('YFLAGS') =~ /(^|\s)-d(\s|$)/)) {
5053 # Now generate rule to make the header file. This should only
5054 # be generated if `yacc -d' specified.
5055 $output_rules .= "${base}.${hname}: ${base}.${cname}\n";
5057 # If the files are built in the build directory, then we want
5058 # to remove them with `make clean'. If they are in srcdir
5059 # they shouldn't be touched. However, we can't determine this
5060 # statically, and the GNU rules say that yacc/lex output files
5061 # should be removed by maintainer-clean. So that's what we
5062 # do.
5063 push (@maintainer_clean_files, "${base}.${hname}");
5065 &push_dist_common ("${base}.${hname}");
5066 }
5067 push (@maintainer_clean_files, "${base}.${cname}");
5068 }
5069 $output_rules .= "\n";
5071 if (! defined $configure_vars{'YACC'})
5072 {
5073 &am_error ("yacc source seen but \`YACC' not defined in \`configure.in'");
5074 }
5075 if (&variable_defined ('YACCFLAGS'))
5076 {
5077 &am_line_error ('YACCFLAGS',
5078 "\`YACCFLAGS' obsolete; use \`YFLAGS' instead");
5079 }
5081 if ($yacc_count > 1)
5082 {
5083 &yacc_lex_finish_helper;
5084 }
5085 }
5087 sub lang_yaccxx_finish
5088 {
5089 &lang_yacc_finish;
5090 }
5092 sub lang_lex_finish
5093 {
5094 return if defined $language_scratch{'lex-done'};
5095 $language_scratch{'lex-done'} = 1;
5097 local (%seen_suffix) = ();
5098 local ($file, $cname);
5099 local ($lex_count) = scalar (keys %lex_sources);
5100 foreach $file (sort keys %lex_sources)
5101 {
5102 $file =~ /(\..*)$/;
5103 &output_lex_build_rule ($1, $lex_count > 1)
5104 if (! defined $seen_suffix{$1});
5105 $seen_suffix{$1} = 1;
5107 # If the files are built in the build directory, then we want
5108 # to remove them with `make clean'. If they are in srcdir
5109 # they shouldn't be touched. However, we can't determine this
5110 # statically, and the GNU rules say that yacc/lex output files
5111 # should be removed by maintainer-clean. So that's what we
5112 # do.
5113 $file =~ /^(.*)\.(l|ll|l\+\+|lxx|lpp)$/;
5114 ($cname = $2) =~ tr/l/c/;
5115 push (@maintainer_clean_files, "${1}.${cname}");
5116 }
5118 if (! defined $configure_vars{'LEX'})
5119 {
5120 &am_error ("lex source seen but \`LEX' not defined in \`configure.in'");
5121 }
5122 if (! $seen_decl_yytext)
5123 {
5124 &am_error ("lex source seen but \`AC_DECL_YYTEXT' not in \`configure.in'");
5125 }
5127 if ($lex_count > 1)
5128 {
5129 &yacc_lex_finish_helper;
5130 }
5131 }
5133 sub lang_lexxx_finish
5134 {
5135 &lang_lex_finish;
5136 }
5138 sub lang_asm_finish
5139 {
5140 # We need the C code for assembly.
5141 &lang_c_finish;
5142 }
5144 sub lang_f77_finish
5145 {
5146 # FIXME: this function can be called more than once. We should
5147 # arrange for it to only do anything the first time through.
5149 local ($ltcompile, $ltlink) = &libtool_compiler;
5151 &define_variable ('F77LD', '$(F77)');
5152 &define_variable ('F77LINK', $ltlink . '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5154 if (! defined $configure_vars{'F77'})
5155 {
5156 &am_error ("Fortran 77 source seen but \`F77' not defined in \`configure.in'");
5157 }
5158 }
5160 # Preprocessed Fortran 77
5161 #
5162 # The current support for preprocessing Fortran 77 just involves passing
5163 # `$(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS)' as additional flags
5164 # to the Fortran 77 compiler, since this is how GNU Make does it; see
5165 # the `GNU Make Manual, Edition 0.51 for `make' Version 3.76 Beta'
5166 # (specifically, from info file `(make)Catalogue of Rules').
5167 #
5168 # A better approach would be to write an Autoconf test
5169 # (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
5170 # Fortran 77 compilers know how to do preprocessing. The Autoconf macro
5171 # AC_PROG_FPP should test the Fortran 77 compiler first for
5172 # preprocessing capabilities, and then fall back on cpp (if cpp were
5173 # available).
5174 sub lang_ppf77_finish
5175 {
5176 &lang_f77_finish;
5178 # We also handle the case of preprocessing `.F' files into `.f'
5179 # files.
5180 $output_rules .= (".F.f:\n"
5181 . "\t\$(F77COMPILE) -F \$<\n");
5182 }
5184 sub lang_ratfor_finish
5185 {
5186 &lang_f77_finish;
5188 # We also handle the case of preprocessing `.r' files into `.f'
5189 # files.
5190 $output_rules .= (".r.f:\n"
5191 . "\t\$(RCOMPILE) -F \$<\n");
5192 }
5194 sub lang_objc_finish
5195 {
5196 local ($ltcompile, $ltlink) = &libtool_compiler;
5198 &define_variable ('OBJCLD', '$(OBJC)');
5199 &define_variable ('OBJCLINK', $ltlink . '$(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5201 if (! defined $configure_vars{'OBJC'})
5202 {
5203 &am_error ("Objective C source seen but \`OBJC' not defined in \`configure.in'");
5204 }
5205 }
5207 sub lang_java_finish
5208 {
5209 local ($ltcompile, $ltlink) = &libtool_compiler;
5211 &define_variable ('GCJLD', '$(GCJ)');
5212 &define_variable ('GCJLINK', $ltlink . '$(GCJLD) $(AM_GCJFLAGS) $(GCJFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5214 if (! defined $configure_vars{'GCJ'})
5215 {
5216 &am_error ("Java source seen but \`GCJ' not defined in \`configure.in'");
5217 }
5218 }
5220 # A helper which computes a sorted list of all extensions for LANG.
5221 sub lang_extensions
5222 {
5223 local ($lang) = @_;
5224 local ($key, @r);
5225 foreach $key (sort keys %extension_seen)
5226 {
5227 push (@r, '.' . $key) if $extension_map{$key} eq $lang;
5228 }
5229 return @r;
5230 }
5232 # A helper which decides whether libtool is needed. Returns prefix
5233 # for compiler and linker.
5234 sub libtool_compiler
5235 {
5236 local ($ltcompile, $ltlink) = ('', '');
5237 if ($seen_libtool)
5238 {
5239 &define_configure_variable ("LIBTOOL");
5240 $ltcompile = '$(LIBTOOL) --mode=compile ';
5241 $ltlink = '$(LIBTOOL) --mode=link ';
5242 }
5243 return ($ltcompile, $ltlink);
5244 }
5246 # Given a hash table of linker names, pick the name that has the most
5247 # precedence. This is lame, but something has to have global
5248 # knowledge in order to eliminate the conflict. Add more linkers as
5249 # required.
5250 sub resolve_linker
5251 {
5252 local (%linkers) = @_;
5254 return 'GCJLINK'
5255 if defined $linkers{'GCJLINK'};
5256 return 'CXXLINK'
5257 if defined $linkers{'CXXLINK'};
5258 return 'F77LINK'
5259 if defined $linkers{'F77LINK'};
5260 return 'OBJCLINK'
5261 if defined $linkers{'OBJCLINK'};
5262 return 'LINK';
5263 }
5265 # Called to indicate that an extension was used.
5266 sub saw_extension
5267 {
5268 local ($ext) = @_;
5269 $extension_seen{$ext} = 1;
5270 }
5272 # Called to ask whether source files have been seen . If HEADERS is 1,
5273 # headers can be included.
5274 sub saw_sources_p
5275 {
5276 local ($headers) = @_;
5278 if ($headers)
5279 {
5280 $headers = 0;
5281 }
5282 else
5283 {
5284 local (@exts) = &lang_extensions ('header');
5285 $headers = @exts;
5286 }
5288 return scalar keys %extension_seen > $headers;
5289 }
5291 # Register a single language. LANGUAGE is the name of the language.
5292 # Each OPTION is either of the form NAME=VALUE, or is a file extension
5293 # (sans `.').
5294 sub register_language
5295 {
5296 local ($language, @options) = @_;
5298 # Set the defaults.
5299 $language_map{$language . '-ansi-p'} = 0;
5300 $language_map{$language . '-linker'} = '';
5301 $language_map{$language . '-autodep'} = 'no';
5303 local ($iter);
5304 foreach $iter (@options)
5305 {
5306 if ($iter =~ /^(.*)=(.*)$/)
5307 {
5308 $language_map{$language . '-' . $1} = $2;
5309 }
5310 elsif (defined $extension_map{$iter})
5311 {
5312 print STDERR
5313 "automake: programming error: duplicate extension $iter\n";
5314 exit 1;
5315 }
5316 else
5317 {
5318 $extension_map{$iter} = $language;
5319 }
5320 }
5321 }
5323 # This function is used to find a path from a user-specified suffix to
5324 # `o' or to some other suffix we recognize internally, eg `cc'.
5325 sub derive_suffix
5326 {
5327 local ($source_ext) = @_;
5329 # FIXME: hard-coding `o' is a mistake. Doing something
5330 # intelligent is harder.
5331 while ($extension_map{$source_ext} eq ''
5332 && $source_ext ne 'o'
5333 && defined $suffix_rules{$source_ext})
5334 {
5335 $source_ext = $suffix_rules{$source_ext};
5336 }
5338 return $source_ext;
5339 }
5342 ################################################################
5344 # Pretty-print something. HEAD is what should be printed at the
5345 # beginning of the first line, FILL is what should be printed at the
5346 # beginning of every subsequent line.
5347 sub pretty_print_internal
5348 {
5349 local ($head, $fill, @values) = @_;
5351 local ($column) = length ($head);
5352 local ($result) = $head;
5354 # Fill length is number of characters. However, each Tab
5355 # character counts for eight. So we count the number of Tabs and
5356 # multiply by 7.
5357 local ($fill_length) = length ($fill);
5358 $fill_length += 7 * ($fill =~ tr/\t/\t/d);
5360 local ($bol) = ($head eq '');
5361 foreach (@values)
5362 {
5363 # "71" because we also print a space.
5364 if ($column + length ($_) > 71)
5365 {
5366 $result .= " \\\n" . $fill;
5367 $column = $fill_length;
5368 $bol = 1;
5369 }
5371 $result .= ' ' unless ($bol);
5372 $result .= $_;
5373 $column += length ($_) + 1;
5374 $bol = 0;
5375 }
5377 $result .= "\n";
5378 return $result;
5379 }
5381 # Pretty-print something and append to output_vars.
5382 sub pretty_print
5383 {
5384 $output_vars .= &pretty_print_internal (@_);
5385 }
5387 # Pretty-print something and append to output_rules.
5388 sub pretty_print_rule
5389 {
5390 $output_rules .= &pretty_print_internal (@_);
5391 }
5394 ################################################################
5396 # See if a target exists.
5397 sub target_defined
5398 {
5399 local ($target) = @_;
5400 return defined $targets{$target};
5401 }
5403 # See if two conditionals are the same.
5404 sub conditional_same
5405 {
5406 local ($cond1, $cond2) = @_;
5408 return (&conditional_true_when ($cond1, $cond2)
5409 && &conditional_true_when ($cond2, $cond1));
5410 }
5412 # See if a conditional is true. Both arguments are conditional
5413 # strings. This returns true if the first conditional is true when
5414 # the second conditional is true.
5415 sub conditional_true_when
5416 {
5417 local ($cond, $when) = @_;
5419 # Check the easy case first.
5420 if ($cond eq $when)
5421 {
5422 return 1;
5423 }
5425 # Check each component of $cond, which looks @COND1@@COND2@.
5426 foreach $comp (split ('@', $cond))
5427 {
5428 # The way we split will give null strings between each
5429 # condition.
5430 next if ! $comp;
5432 if (index ($when, '@' . $comp . '@') == -1)
5433 {
5434 return 0;
5435 }
5436 }
5438 return 1;
5439 }
5441 # Check for an ambiguous conditional. This is called when a variable
5442 # or target is being defined conditionally. If we already know about
5443 # a definition that is true under the same conditions, then we have an
5444 # ambiguity.
5445 sub check_ambiguous_conditional
5446 {
5447 local ($var_name, $cond) = @_;
5448 local (@cond_vals) = split (' ', $conditional{$var_name});
5449 while (@cond_vals)
5450 {
5451 local ($vcond) = shift (@cond_vals);
5452 shift (@cond_vals);
5453 if (&conditional_true_when ($vcond, $cond)
5454 || &conditional_true_when ($cond, $vcond))
5455 {
5456 &am_line_error ($var_name,
5457 "$var_name multiply defined in condition");
5458 }
5459 }
5460 }
5462 # See if a variable exists. The first argument is the variable name,
5463 # and the optional second argument is the condition which we should
5464 # check. If no condition is given, we currently return true if the
5465 # variable is defined under any condition.
5466 sub variable_defined
5467 {
5468 local ($var, $cond) = @_;
5469 if (defined $targets{$var})
5470 {
5471 &am_line_error ($var, "\`$var' is target; expected variable");
5472 return 0;
5473 }
5474 elsif (defined $contents{$var})
5475 {
5476 if ($cond && $conditional{$var})
5477 {
5478 # We have been asked to check for a particular condition,
5479 # and the variable is defined conditionally. We need to
5480 # look through the conditions under which the variable is
5481 # defined, and see if any of them match the conditional we
5482 # have been asked to check.
5483 local (@cond_vars) = split (' ', $conditional{$var});
5484 while (@cond_vars)
5485 {
5486 if (&conditional_same ($cond, shift (@cond_vars)))
5487 {
5488 # Even a conditional examination is good enough
5489 # for us. FIXME: really should maintain examined
5490 # status on a per-condition basis.
5491 $content_seen{$var} = 1;
5492 return 1;
5493 }
5494 shift (@cond_vars);
5495 }
5497 # The variable is not defined for the given condition.
5498 return 0;
5499 }
5501 $content_seen{$var} = 1;
5502 return 1;
5503 }
5504 return 0;
5505 }
5507 # Mark a variable as examined.
5508 sub examine_variable
5509 {
5510 local ($var) = @_;
5511 &variable_defined ($var);
5512 }
5514 # Quote a value in order to put it in $conditional. We need to quote
5515 # spaces, and we need to handle null strings, so that we can later
5516 # retrieve values by splitting on space.
5517 sub quote_cond_val
5518 {
5519 local ($val) = @_;
5520 $val =~ tr/ \t\n/\001\003\004/;
5521 $val = "\002" if $val eq '';
5522 return $val;
5523 }
5525 # Unquote a value in $conditional.
5526 sub unquote_cond_val
5527 {
5528 local ($val) = @_;
5529 $val =~ tr/\001\003\004/ \t\n/;
5530 $val =~ s/\002//g;
5531 return $val;
5532 }
5534 # Return the set of conditions for which a variable is defined.
5536 # If the variable is not defined conditionally, and is not defined in
5537 # terms of any variables which are defined conditionally, then this
5538 # returns the empty list.
5540 # If the variable is defined conditionally, but is not defined in
5541 # terms of any variables which are defined conditionally, then this
5542 # returns the list of conditions for which the variable is defined.
5544 # If the variable is defined in terms of any variables which are
5545 # defined conditionally, then this returns a full set of permutations
5546 # of the subvariable conditions. For example, if the variable is
5547 # defined in terms of a variable which is defined for @COND_TRUE@,
5548 # then this returns both @COND_TRUE@ and @COND_FALSE@. This is
5549 # because we will need to define the variable under both conditions.
5551 sub variable_conditions
5552 {
5553 local ($var) = @_;
5554 local (%uniqify);
5555 local (@uniq_list);
5556 local ($cond);
5558 %vars_scanned = ();
5559 foreach $cond (&variable_conditions_sub ($var, '', ()))
5560 {
5561 $uniqify{$cond} = 1;
5562 }
5564 @uniq_list = sort keys %uniqify;
5565 # Note we cannot just do `return sort keys %uniqify', because this
5566 # function is sometimes used in a scalar context.
5567 return @uniq_list;
5568 }
5570 # A subroutine of variable_conditions. We only return conditions
5571 # which are true for all the conditions in @PARENT_CONDS.
5572 sub variable_conditions_sub
5573 {
5574 local ($var, $parent, @parent_conds) = @_;
5575 local (@new_conds) = ();
5577 if (defined $vars_scanned{$var})
5578 {
5579 &am_line_error ($parent, "variable \`$var' recursively defined");
5580 return ();
5581 }
5582 $vars_scanned{$var} = 1;
5584 if (! $conditional{$var})
5585 {
5586 foreach (split (' ', $contents{$var}))
5587 {
5588 # If a comment seen, just leave.
5589 last if /^#/;
5591 # Handle variable substitutions.
5592 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
5593 {
5594 push (@new_conds,
5595 &variable_conditions_sub ($1, $var, @parent_conds));
5596 }
5597 }
5599 # Now we want to return all permutations of the subvariable
5600 # conditions.
5601 local (%allconds, $item);
5602 foreach $item (@new_conds)
5603 {
5604 foreach (split ('@', $item))
5605 {
5606 next if ! $_;
5607 s/_(TRUE|FALSE)$//;
5608 $allconds{$_ . '_TRUE'} = 1;
5609 }
5610 }
5612 # Unset our entry in vars_scanned. We only care about recursive
5613 # definitions.
5614 delete $vars_scanned{$var};
5616 return &variable_conditions_permutations (sort keys %allconds);
5617 }
5619 local (@this_conds) = ();
5620 local (@condvals) = split (' ', $conditional{$var});
5621 while (@condvals)
5622 {
5623 local ($cond) = shift (@condvals);
5624 local ($val) = &unquote_cond_val (shift (@condvals));
5626 if (@parent_conds)
5627 {
5628 local ($ok) = 1;
5629 local ($parent_cond);
5630 foreach $parent_cond (@parent_conds)
5631 {
5632 if (! &conditional_true_when ($parent_cond, $cond))
5633 {
5634 $ok = 0;
5635 last;
5636 }
5637 }
5639 next if ! $ok;
5640 }
5642 push (@this_conds, $cond);
5644 push (@parent_conds, $cond);
5645 local (@subvar_conds) = ();
5646 foreach (split (' ', $val))
5647 {
5648 # If a comment seen, just leave.
5649 last if /^#/;
5651 # Handle variable substitutions.
5652 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
5653 {
5654 push (@subvar_conds,
5655 &variable_conditions_sub ($1, $var, @parent_conds));
5656 }
5657 }
5658 pop (@parent_conds);
5660 # If there are no conditional subvariables, then we want to
5661 # return this condition. Otherwise, we want to return the
5662 # permutations of the subvariables.
5663 if (! @subvar_conds)
5664 {
5665 push (@new_conds, $cond);
5666 }
5667 else
5668 {
5669 push (@new_conds, &variable_conditions_reduce (@subvar_conds));
5670 }
5671 }
5673 # Unset our entry in vars_scanned. We only care about recursive
5674 # definitions.
5675 delete $vars_scanned{$var};
5677 return @new_conds
5678 if ! $parent;
5680 # If we are being called on behalf of another variable, we need to
5681 # return all possible permutations of the conditions. We have
5682 # already handled everything in @this_conds along with their
5683 # subvariables. We now need to add any permutations that are not
5684 # in @this_conds.
5685 local ($this_cond);
5686 foreach $this_cond (@this_conds)
5687 {
5688 local (@perms) =
5689 &variable_conditions_permutations (split('@', $this_cond));
5690 local ($perm);
5691 foreach $perm (@perms)
5692 {
5693 local ($scan);
5694 local ($ok) = 1;
5695 foreach $scan (@this_conds)
5696 {
5697 if (&conditional_true_when ($perm, $scan)
5698 || &conditional_true_when ($scan, $perm))
5699 {
5700 $ok = 0;
5701 last;
5702 }
5703 }
5704 next if ! $ok;
5706 if (@parent_conds)
5707 {
5708 local ($ok) = 1;
5709 local ($parent_cond);
5710 foreach $parent_cond (@parent_conds)
5711 {
5712 if (! &conditional_true_when ($parent_cond, $perm))
5713 {
5714 $ok = 0;
5715 last;
5716 }
5717 }
5719 next if ! $ok;
5720 }
5722 # This permutation was not already handled, and is valid
5723 # for the parents.
5724 push (@new_conds, $perm);
5725 }
5726 }
5728 return @new_conds;
5729 }
5731 # Subroutine for variable_conditions_sort
5732 sub variable_conditions_cmp
5733 {
5734 local ($as) = $a;
5735 $as =~ s/[^@]//g;
5736 local ($bs) = $b;
5737 $bs =~ s/[^@]//g;
5738 return (length ($as) <=> length ($bs)
5739 || $a cmp $b);
5740 }
5742 # Sort a list of conditionals so that only the exclusive ones are
5743 # retained. For example, if both @COND1_TRUE@@COND2_TRUE@ and
5744 # @COND1_TRUE@ are in the list, discard the latter.
5745 sub variable_conditions_reduce
5746 {
5747 local (@conds) = @_;
5748 local (@ret) = ();
5749 local ($cond);
5750 foreach $cond (sort variable_conditions_cmp @conds)
5751 {
5752 local ($ok) = 1;
5753 local ($scan);
5754 foreach $scan (@ret)
5755 {
5756 if (&conditional_true_when ($cond, $scan))
5757 {
5758 $ok = 0;
5759 last;
5760 }
5761 }
5762 next if ! $ok;
5763 push (@ret, $cond);
5764 }
5766 return @ret;
5767 }
5769 # Return a list of permutations of a conditional string.
5770 sub variable_conditions_permutations
5771 {
5772 local (@comps) = @_;
5773 return ()
5774 if ! @comps;
5775 local ($comp) = shift (@comps);
5776 return &variable_conditions_permutations (@comps)
5777 if $comp eq '';
5778 local ($neg) = $comp;
5779 $neg =~ s/TRUE$/TRUEO/;
5780 $neg =~ s/FALSE$/TRUE/;
5781 $neg =~ s/TRUEO$/FALSE/;
5782 local (@ret);
5783 local ($sub);
5784 foreach $sub (&variable_conditions_permutations (@comps))
5785 {
5786 push (@ret, '@' . $comp . '@' . $sub);
5787 push (@ret, '@' . $neg . '@' . $sub);
5788 }
5789 if (! @ret)
5790 {
5791 push (@ret, '@' . $comp . '@');
5792 push (@ret, '@' . $neg . '@');
5793 }
5794 return @ret;
5795 }
5797 # Warn if a variable is conditionally defined. This is called if we
5798 # are using the value of a variable.
5799 sub variable_conditionally_defined
5800 {
5801 local ($var, $parent) = @_;
5802 if ($conditional{$var})
5803 {
5804 if ($parent)
5805 {
5806 &am_line_error ($parent,
5807 "warning: automake does not support conditional definition of $var in $parent");
5808 }
5809 else
5810 {
5811 &am_line_error ($parent,
5812 "warning: automake does not support $var being defined conditionally")
5813 }
5814 }
5815 }
5817 # Get the value of a variable. This just returns $contents, but warns
5818 # if the variable is conditionally defined.
5819 sub variable_value
5820 {
5821 local ($var) = @_;
5822 &variable_conditionally_defined ($var);
5823 return $contents{$var};
5824 }
5826 # Convert a variable value to a list, split as whitespace. This will
5827 # recursively follow $(...) and ${...} inclusions. It preserves @...@
5828 # substitutions. If COND is 'all', then all values under all
5829 # conditions should be returned; if COND is a particular condition
5830 # (all conditions are surrounded by @...@) then only the value for
5831 # that condition should be returned; otherwise, warn if VAR is
5832 # conditionally defined. SCANNED is a global hash listing whose keys
5833 # are all the variables already scanned; it is an error to rescan a
5834 # variable.
5835 sub value_to_list
5836 {
5837 local ($var, $val, $cond) = @_;
5838 local (@result);
5840 # Strip backslashes
5841 $val =~ s/\\(\n|$)/ /g;
5843 foreach (split (' ', $val))
5844 {
5845 # If a comment seen, just leave.
5846 last if /^#/;
5848 # Handle variable substitutions.
5849 if (/^\$\{([^}]*)\}$/ || /^\$\(([^)]*)\)$/)
5850 {
5851 local ($varname) = $1;
5853 # If the user uses a losing variable name, just ignore it.
5854 # This isn't ideal, but people have requested it.
5855 next if ($varname =~ /\@.*\@/);
5857 local ($from, $to);
5858 local (@temp_list);
5859 if ($varname =~ /^([^:]*):([^=]*)=(.*)$/)
5860 {
5861 $varname = $1;
5862 $to = $3;
5863 ($from = $2) =~ s/(\W)/\\$1/g;
5864 }
5866 # Find the value.
5867 @temp_list = &variable_value_as_list_worker ($1, $cond, $var);
5869 # Now rewrite the value if appropriate.
5870 if ($from)
5871 {
5872 grep (s/$from$/$to/, @temp_list);
5873 }
5875 push (@result, @temp_list);
5876 }
5877 else
5878 {
5879 push (@result, $_);
5880 }
5881 }
5883 return @result;
5884 }
5886 # Return contents of variable as list, split as whitespace. This will
5887 # recursively follow $(...) and ${...} inclusions. It preserves @...@
5888 # substitutions. If COND is 'all', then all values under all
5889 # conditions should be returned; if COND is a particular condition
5890 # (all conditions are surrounded by @...@) then only the value for
5891 # that condition should be returned; otherwise, warn if VAR is
5892 # conditionally defined. If PARENT is specified, it is the name of
5893 # the including variable; this is only used for error reports.
5894 sub variable_value_as_list_worker
5895 {
5896 local ($var, $cond, $parent) = @_;
5897 local (@result);
5899 if (defined $targets{$var})
5900 {
5901 &am_line_error ($var, "\`$var' is target; expected variable");
5902 }
5903 elsif (! defined $contents{$var})
5904 {
5905 &am_line_error ($parent, "variable \`$var' not defined");
5906 }
5907 elsif (defined $vars_scanned{$var})
5908 {
5909 # `vars_scanned' is a global we use to keep track of which
5910 # variables we've already examined.
5911 &am_line_error ($parent, "variable \`$var' recursively defined");
5912 }
5913 elsif ($cond eq 'all' && $conditional{$var})
5914 {
5915 $vars_scanned{$var} = 1;
5916 local (@condvals) = split (' ', $conditional{$var});
5917 while (@condvals)
5918 {
5919 shift (@condvals);
5920 local ($val) = &unquote_cond_val (shift (@condvals));
5921 push (@result, &value_to_list ($var, $val, $cond));
5922 }
5923 }
5924 elsif ($cond && $conditional{$var})
5925 {
5926 $vars_scanned{$var} = 1;
5927 local (@condvals) = split (' ', $conditional{$var});
5928 local ($onceflag);
5929 while (@condvals)
5930 {
5931 local ($vcond) = shift (@condvals);
5932 local ($val) = &unquote_cond_val (shift (@condvals));
5933 if (&conditional_true_when ($vcond, $cond))
5934 {
5935 # Warn if we have an ambiguity. It's hard to know how
5936 # to handle this case correctly.
5937 &variable_conditionally_defined ($var, $parent)
5938 if $onceflag;
5939 $onceflag = 1;
5940 push (@result, &value_to_list ($var, $val, $cond));
5941 }
5942 }
5943 }
5944 else
5945 {
5946 $vars_scanned{$var} = 1;
5947 &variable_conditionally_defined ($var, $parent);
5948 $content_seen{$var} = 1;
5949 push (@result, &value_to_list ($var, $contents{$var}, $cond));
5950 }
5952 # Unset our entry in vars_scanned. We only care about recursive
5953 # definitions.
5954 delete $vars_scanned{$var};
5956 return @result;
5957 }
5959 # This is just a wrapper for variable_value_as_list_worker that
5960 # initializes the global hash `vars_scanned'. This hash is used to
5961 # avoid infinite recursion.
5962 sub variable_value_as_list
5963 {
5964 local ($var, $cond, $parent) = @_;
5965 %vars_scanned = ();
5966 return &variable_value_as_list_worker ($var, $cond, $parent);
5967 }
5969 # Define a new variable, but only if not already defined.
5970 sub define_variable
5971 {
5972 local ($var, $value) = @_;
5974 if (! defined $contents{$var})
5975 {
5976 $output_vars .= $var . ' = ' . $value . "\n";
5977 $contents{$var} = $value;
5978 $content_seen{$var} = 1;
5979 }
5980 elsif ($var_was_plus_eq{$var})
5981 {
5982 &am_line_error ($var, "internally generated variable \`$var' was set with \`+='");
5983 }
5984 }
5986 # Like define_variable, but the value is a list, and the variable may
5987 # be defined conditionally. The second argument is the conditional
5988 # under which the value should be defined; this should be the empty
5989 # string to define the variable unconditionally. The third argument
5990 # is a list holding the values to use for the variable. The value is
5991 # pretty printed in the output file.
5992 sub define_pretty_variable
5993 {
5994 local ($var, $cond, @value) = @_;
5995 if (! defined $contents{$var}
5996 || ($cond && ! &variable_defined ($var, $cond)))
5997 {
5998 $contents{$var} = join (' ', @value);
5999 if ($cond)
6000 {
6001 if ($conditional{$var})
6002 {
6003 $conditional{$var} .= ' ';
6004 }
6005 else
6006 {
6007 $conditional{$var} = '';
6008 }
6009 $conditional{$var} .= ($cond
6010 . ' '
6011 . "e_cond_val ($contents{$var}));
6012 }
6013 &pretty_print ($cond . $var . ' = ', $cond, @value);
6014 $content_seen{$var} = 1;
6015 }
6016 }
6018 # Like define_variable, but define a variable to be the configure
6019 # substitution by the same name.
6020 sub define_configure_variable
6021 {
6022 local ($var) = @_;
6023 local ($value) = '@' . $var . '@';
6024 &define_variable ($var, $value);
6025 }
6027 # Define a compiler variable. We also handle defining the `LT'
6028 # version of the command when using libtool.
6029 sub define_compiler_variable
6030 {
6031 local ($var, $ltcompile, $value) = @_;
6032 local ($name) = $var;
6033 &define_variable ($name, $value);
6034 &define_variable ('LT' . $name, $ltcompile . $value)
6035 if $seen_libtool;
6036 }
6038 # Define a variable that represents a program to run. If in Cygnus
6039 # mode, the program is searched for in the build (or source) tree.
6040 # Otherwise no searching is done at all. Arguments are:
6041 # * VAR Name of variable to define
6042 # * WHATDIR Either `src' or `build', depending on where program should
6043 # be found. (runtest is in srcdir!)
6044 # * SUBDIR Subdir of top-level dir
6045 # * PROGRAM Name of program
6046 # * OVERRIDE If specified, the name of the program to use when not in
6047 # Cygnus mode. Defaults to PROGRAM.
6048 sub define_program_variable
6049 {
6050 local ($var, $whatdir, $subdir, $program, $override) = @_;
6052 if (! $override)
6053 {
6054 $override = $program;
6055 }
6057 if ($cygnus_mode)
6058 {
6059 local ($full) = ('$(top_' . $whatdir . 'dir)/../'
6060 . $subdir . '/' . $program);
6061 &define_variable ($var, ('`if test -f ' . $full
6062 . '; then echo ' . $full . '; else echo '
6063 . $program . '; fi`'));
6064 }
6065 else
6066 {
6067 &define_variable ($var, $override);
6068 }
6069 }
6072 ################################################################
6074 # Read Makefile.am and set up %contents. Simultaneously copy lines
6075 # from Makefile.am into $output_trailer or $output_vars as
6076 # appropriate. NOTE we put rules in the trailer section. We want
6077 # user rules to come after our generated stuff.
6078 sub read_am_file
6079 {
6080 local ($amfile) = @_;
6081 local (*AM_FILE);
6083 open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
6084 print "automake: reading $amfile\n" if $verbose;
6086 local ($saw_bk) = 0;
6087 local ($was_rule) = 0;
6088 local ($spacing) = '';
6089 local ($comment) = '';
6090 local ($last_var_name) = '';
6091 local ($blank) = 0;
6093 # We save the conditional stack on entry, and then check to make
6094 # sure it is the same on exit. This lets us conditonally include
6095 # other files.
6096 local (@saved_cond_stack) = @conditional_stack;
6098 while (<AM_FILE>)
6099 {
6100 if (/$IGNORE_PATTERN/o)
6101 {
6102 # Merely delete comments beginning with two hashes.
6103 }
6104 elsif (/$WHITE_PATTERN/o)
6105 {
6106 # Stick a single white line before the incoming macro or rule.
6107 $spacing = "\n";
6108 $blank = 1;
6109 }
6110 elsif (/$COMMENT_PATTERN/o)
6111 {
6112 # Stick comments before the incoming macro or rule. Make
6113 # sure a blank line preceeds first block of comments.
6114 $spacing = "\n" unless $blank;
6115 $blank = 1;
6116 $comment .= $spacing . $_;
6117 $spacing = '';
6118 }
6119 else
6120 {
6121 last;
6122 }
6123 }
6125 $output_vars .= $comment . "\n";
6126 $comment = '';
6127 $spacing = "\n";
6129 local ($is_ok_macro);
6130 while ($_)
6131 {
6132 $_ .= "\n"
6133 unless substr ($_, -1, 1) eq "\n";
6135 # Don't look at MAINTAINER_MODE_TRUE here. That shouldn't be
6136 # used by users. @MAINT@ is an anachronism now.
6137 $_ =~ s/\@MAINT\@//g
6138 unless $seen_maint_mode;
6140 if (/$IGNORE_PATTERN/o)
6141 {
6142 # Merely delete comments beginning with two hashes.
6143 }
6144 elsif (/$WHITE_PATTERN/o)
6145 {
6146 # Stick a single white line before the incoming macro or rule.
6147 $spacing = "\n";
6148 &am_line_error ($., "blank line following trailing backslash")
6149 if $saw_bk;
6150 }
6151 elsif (/$COMMENT_PATTERN/o)
6152 {
6153 # Stick comments before the incoming macro or rule.
6154 $comment .= $spacing . $_;
6155 $spacing = '';
6156 &am_line_error ($., "comment following trailing backslash")
6157 if $saw_bk;
6158 }
6159 elsif ($saw_bk)
6160 {
6161 if ($was_rule)
6162 {
6163 $output_trailer .= join ('', @conditional_stack) . $_;
6164 $saw_bk = /\\$/;
6165 }
6166 else
6167 {
6168 $saw_bk = /\\$/;
6169 $contents{$last_var_name} .= ' '
6170 unless $contents{$last_var_name} =~ /\s$/;
6171 $contents{$last_var_name} .= $_;
6172 if (@conditional_stack)
6173 {
6174 $conditional{$last_var_name} .= "e_cond_val ($_);
6175 }
6176 }
6177 }
6178 elsif (/$IF_PATTERN/o)
6179 {
6180 &am_line_error ($., "$1 does not appear in AM_CONDITIONAL")
6181 if (! $configure_cond{$1});
6182 push (@conditional_stack, "\@" . $1 . "_TRUE\@");
6183 }
6184 elsif (/$ELSE_PATTERN/o)
6185 {
6186 if (! @conditional_stack)
6187 {
6188 &am_line_error ($., "else without if");
6189 }
6190 elsif ($conditional_stack[$#conditional_stack] =~ /_FALSE\@$/)
6191 {
6192 &am_line_error ($., "else after else");
6193 }
6194 else
6195 {
6196 $conditional_stack[$#conditional_stack]
6197 =~ s/_TRUE\@$/_FALSE\@/;
6198 }
6199 }
6200 elsif (/$ENDIF_PATTERN/o)
6201 {
6202 if (! @conditional_stack)
6203 {
6204 &am_line_error ($., "endif without if");
6205 }
6206 else
6207 {
6208 pop @conditional_stack;
6209 }
6210 }
6211 elsif (/$RULE_PATTERN/o)
6212 {
6213 # Found a rule.
6214 $was_rule = 1;
6215 if (defined $contents{$1}
6216 && (@conditional_stack
6217 ? ! defined $conditional{$1}
6218 : defined $conditional{$1}))
6219 {
6220 &am_line_error ($1,
6221 "$1 defined both conditionally and unconditionally");
6222 }
6223 # Value here doesn't matter; for targets we only note
6224 # existence.
6225 $contents{$1} = 1;
6226 $targets{$1} = 1;
6227 local ($cond_string) = join ('', @conditional_stack);
6228 if (@conditional_stack)
6229 {
6230 if ($conditional{$1})
6231 {
6232 &check_ambiguous_conditional ($1, $cond_string);
6233 $conditional{$1} .= ' ';
6234 }
6235 else
6236 {
6237 $conditional{$1} = '';
6238 }
6239 $conditional{$1} .= $cond_string . ' 1';
6240 }
6241 $content_lines{$1} = $.;
6242 $output_trailer .= $comment . $spacing . $cond_string . $_;
6243 $comment = $spacing = '';
6244 $saw_bk = /\\$/;
6246 # Check the rule for being a suffix rule. If so, store in
6247 # a hash.
6249 local ($source_suffix);
6250 local ($object_suffix);
6252 if (($source_suffix, $object_suffix) = ($1 =~ $SUFFIX_RULE_PATTERN))
6253 {
6254 $suffix_rules{$source_suffix} = $object_suffix;
6255 print "Sources ending in .$source_suffix become .$object_suffix\n" if $verbose;
6256 $source_suffix_pattern = "(" . join ('|', keys %suffix_rules) . ")";
6257 }
6259 # FIXME: make sure both suffixes are in SUFFIXES? Or set
6260 # SUFFIXES from suffix_rules?
6261 }
6262 elsif (($is_ok_macro = /$MACRO_PATTERN/o)
6263 || /$BOGUS_MACRO_PATTERN/o)
6264 {
6265 # Found a macro definition.
6266 $was_rule = 0;
6267 $last_var_name = $1;
6268 if (defined $contents{$1}
6269 && (@conditional_stack
6270 ? ! defined $conditional{$1}
6271 : defined $conditional{$1}))
6272 {
6273 &am_line_error ($1,
6274 "$1 defined both conditionally and unconditionally");
6275 }
6276 local ($value);
6277 if ($3 ne '' && substr ($3, -1) eq "\\")
6278 {
6279 # We preserve the `\' because otherwise the long lines
6280 # that are generated will be truncated by broken
6281 # `sed's.
6282 $value = $3 . "\n";
6283 }
6284 else
6285 {
6286 $value = $3;
6287 }
6288 local ($type) = $2;
6290 if (! defined $contents{$last_var_name})
6291 {
6292 # The first assignment to a macro sets the line
6293 # number. Ideally I suppose we would associate line
6294 # numbers with random bits of text.
6295 $content_lines{$last_var_name} = $.;
6297 # If first assignment, set `+=' indicator.
6298 $var_was_plus_eq{$last_var_name} =
6299 ($type eq '+'
6300 && ! defined $am_var_defs{$last_var_name});
6301 }
6303 if ($type eq '+')
6304 {
6305 if (! defined $contents{$last_var_name}
6306 && defined $am_var_defs{$last_var_name})
6307 {
6308 $contents{$last_var_name} = $am_var_defs{$last_var_name};
6309 }
6310 if (substr ($contents{$last_var_name}, -1) eq "\n")
6311 {
6312 # Insert a backslash before a trailing newline.
6313 $contents{$last_var_name}
6314 = substr ($contents{$last_var_name}, 0, -1) . "\\\n";
6315 }
6316 $contents{$last_var_name} .= ' ' . $value;
6317 }
6318 else
6319 {
6320 $contents{$last_var_name} = $value;
6321 }
6322 local ($cond_string) = join ('', @conditional_stack);
6323 if (@conditional_stack)
6324 {
6325 local ($found) = 0;
6326 local ($val);
6327 if ($conditional{$last_var_name})
6328 {
6329 if ($type eq '+')
6330 {
6331 # If we're adding to the conditional, and it
6332 # exists, then we might want to simply replace
6333 # the old value with the new one.
6334 local (@new_vals, @cond_vals);
6335 @cond_vals = split (' ', $conditional{$last_var_name});
6336 while (@cond_vals)
6337 {
6338 local ($vcond) = shift (@cond_vals);
6339 push (@new_vals, $vcond);
6340 if (&conditional_same ($vcond, $cond_string))
6341 {
6342 $found = 1;
6343 $val = (&unquote_cond_val (shift (@cond_vals))
6344 . ' ' . $value);
6345 push (@new_vals, "e_cond_val ($val));
6346 }
6347 else
6348 {
6349 push (@new_vals, shift (@cond_vals));
6350 }
6351 }
6352 if ($found)
6353 {
6354 $conditional{$last_var_name}
6355 = join (' ', @new_vals);
6356 }
6357 }
6359 if (! $found)
6360 {
6361 &check_ambiguous_conditional ($last_var_name,
6362 $cond_string);
6363 $conditional{$last_var_name} .= ' ';
6364 $val = $value;
6365 }
6366 }
6367 else
6368 {
6369 $conditional{$last_var_name} = '';
6370 $val = $contents{$last_var_name};
6371 }
6372 if (! $found)
6373 {
6374 $conditional{$last_var_name} .= ($cond_string
6375 . ' '
6376 . "e_cond_val ($val));
6377 }
6378 }
6380 # FIXME: this doesn't always work correctly; it will group
6381 # all comments for a given variable, no matter where
6382 # defined.
6383 $am_vars{$last_var_name} = $comment . $spacing;
6384 $def_type{$last_var_name} = ($type eq ':') ? ':' : '';
6385 push (@var_list, $last_var_name);
6386 $comment = $spacing = '';
6387 $saw_bk = /\\$/;
6389 # Error if bogus.
6390 &am_line_error ($., "bad macro name \`$last_var_name'")
6391 if ! $is_ok_macro;
6392 }
6393 elsif (/$INCLUDE_PATTERN/o)
6394 {
6395 local ($path) = $1;
6397 if ($path =~ s/^\$\(top_srcdir\)\///)
6398 {
6399 push (@include_stack, "\$\(top_srcdir\)/$path");
6400 }
6401 else
6402 {
6403 $path =~ s/\$\(srcdir\)\///;
6404 push (@include_stack, "\$\(srcdir\)/$path");
6405 $path = $relative_dir . "/" . $path;
6406 }
6407 &read_am_file ($path);
6408 }
6409 else
6410 {
6411 # This isn't an error; it is probably a continued rule.
6412 # In fact, this is what we assume.
6413 $was_rule = 1;
6414 $output_trailer .= ($comment . $spacing
6415 . join ('', @conditional_stack) . $_);
6416 $comment = $spacing = '';
6417 $saw_bk = /\\$/;
6418 }
6420 $_ = <AM_FILE>;
6421 }
6423 $output_trailer .= $comment;
6425 if (join (' ', @saved_cond_stack) ne join (' ', @conditional_stack))
6426 {
6427 if (@conditional_stack)
6428 {
6429 &am_error ("unterminated conditionals: " . join (' ', @conditional_stack));
6430 }
6431 else
6432 {
6433 # FIXME: better error message here.
6434 &am_error ("conditionals not nested in include file");
6435 }
6436 }
6437 }
6439 # A helper for read_main_am_file which initializes configure variables
6440 # and variables from header-vars.am. This is a subr so we can call it
6441 # twice.
6442 sub define_standard_variables
6443 {
6444 # Compute relative location of the top object directory.
6445 local (@topdir) = ();
6446 foreach (split (/\//, $relative_dir))
6447 {
6448 next if $_ eq '.' || $_ eq '';
6449 if ($_ eq '..')
6450 {
6451 pop @topdir;
6452 }
6453 else
6454 {
6455 push (@topdir, '..');
6456 }
6457 }
6458 @topdir = ('.') if ! @topdir;
6460 $top_builddir = join ('/', @topdir);
6461 local ($build_rx);
6462 ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
6463 $output_vars .= &file_contents_with_transform
6464 ('s/\@top_builddir\@/' . $build_rx . '/g;',
6465 'header-vars');
6467 # Generate some useful variables when AC_CANONICAL_* used. FIXME:
6468 # this should use generic %configure_vars method.
6469 if ($seen_canonical)
6470 {
6471 local ($curs, %vars);
6472 $vars{'host_alias'} = 'host_alias';
6473 $vars{'host_triplet'} = 'host';
6474 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
6475 {
6476 $vars{'build_alias'} = 'build_alias';
6477 $vars{'build_triplet'} = 'build';
6478 $vars{'target_alias'} = 'target_alias';
6479 $vars{'target_triplet'} = 'target';
6480 }
6481 foreach $curs (sort keys %vars)
6482 {
6483 $output_vars .= "$curs = \@$vars{$curs}\@\n";
6484 $contents{$curs} = "\@$vars{$curs}\@";
6485 }
6486 }
6488 local ($curs);
6489 foreach $curs (sort keys %configure_vars)
6490 {
6491 &define_configure_variable ($curs);
6492 }
6493 }
6495 # Read main am file.
6496 sub read_main_am_file
6497 {
6498 local ($amfile) = @_;
6500 # The keys here are variables we want to dump at the end of this
6501 # function. The values are corresponding comments.
6502 local (%am_vars) = ();
6503 local (@var_list) = ();
6504 local (%def_type) = ();
6506 # This supports the strange variable tricks we are about to play.
6507 if (scalar keys %contents > 0)
6508 {
6509 print STDERR "automake: programming error: variable defined before read_main_am_file\n";
6510 exit 1;
6511 }
6513 # We want to predefine as many variables as possible. This lets
6514 # the user set them with `+=' in Makefile.am. However, we don't
6515 # want these initial definitions to end up in the output quite
6516 # yet. So we adopt a hack: read the `.am' file twice, throwing
6517 # away the output the first time. We also squirrel away a list of
6518 # all the variables defined by the .am file so that we know which
6519 # ones to remove from the content list.
6521 # First pass.
6522 &define_standard_variables;
6523 local (%saved_contents) = %contents;
6525 # Read user file, but discard text of variable assignments we just
6526 # made.
6527 $output_vars = '';
6528 &read_am_file ($amfile);
6530 # Now dump the variables that were defined. We do it in the same
6531 # order in which they were defined (skipping duplicates).
6532 local (%done);
6533 foreach $curs (@var_list)
6534 {
6535 next if $done{$curs};
6536 $done{$curs} = 1;
6538 $output_vars .= $am_vars{$curs};
6539 if ($conditional{$curs})
6540 {
6541 local (@cond_vals) = split (' ', $conditional{$curs});
6542 while (@cond_vals)
6543 {
6544 local ($vcond) = shift (@cond_vals);
6545 local ($val) = &unquote_cond_val (shift (@cond_vals));
6546 $output_vars .= ($vcond . $curs . ' '
6547 . $def_type{$curs} . "= ");
6548 local ($line);
6549 foreach $line (split ("\n", $val))
6550 {
6551 $output_vars .= $vcond . $line . "\n";
6552 }
6553 $output_vars .= "\n"
6554 if $val eq '';
6555 }
6556 }
6557 else
6558 {
6559 $output_vars .= ($curs . ' ' . $def_type{$curs} . '= '
6560 . $contents{$curs} . "\n");
6561 }
6562 }
6564 # Generate copyright header for generated Makefile.in.
6565 local ($ov) = $output_vars;
6566 $output_vars = ("# $in_file_name generated automatically by automake "
6567 . $VERSION . " from $am_file_name\n");
6568 $output_vars .= $gen_copyright;
6570 # Now go through and delete all the variables that the user did
6571 # not change.
6572 local ($var);
6573 foreach $var (keys %saved_contents)
6574 {
6575 if ($contents{$var} eq $saved_contents{$var})
6576 {
6577 delete $contents{$var};
6578 }
6579 }
6581 # Re-read the standard variables, and this time keep their
6582 # contributions to the output. Then add the user's output to the
6583 # end.
6584 &define_standard_variables;
6585 $output_vars .= $ov;
6587 }
6589 ################################################################
6591 sub initialize_global_constants
6592 {
6593 # Values for AC_CANONICAL_*
6594 $AC_CANONICAL_HOST = 1;
6595 $AC_CANONICAL_SYSTEM = 2;
6597 # Associative array of standard directory names. Entry is TRUE if
6598 # corresponding directory should be installed during
6599 # 'install-exec' phase.
6600 %exec_dir_p =
6601 ('bin', 1,
6602 'sbin', 1,
6603 'libexec', 1,
6604 'data', 0,
6605 'sysconf', 1,
6606 'localstate', 1,
6607 'lib', 1,
6608 'info', 0,
6609 'man', 0,
6610 'include', 0,
6611 'oldinclude', 0,
6612 'pkgdata', 0,
6613 'pkglib', 1,
6614 'pkginclude', 0
6615 );
6617 # Commonly found files we look for and automatically include in
6618 # DISTFILES.
6619 @common_files =
6620 (
6621 "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
6622 "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
6623 "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
6624 "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
6625 'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp',
6626 'ylwrap', 'acinclude.m4', @libtoolize_files,
6627 'missing', 'depcomp', 'compile', 'py-compile'
6628 );
6630 # Commonly used files we auto-include, but only sometimes.
6631 @common_sometimes =
6632 (
6633 "aclocal.m4", "acconfig.h", "config.h.top",
6634 "config.h.bot", "stamp-h.in", 'stamp-vti'
6635 );
6637 $USAGE = "\
6638 -a, --add-missing add missing standard files to package
6639 --amdir=DIR directory storing config files
6640 -c, --copy with -a, copy missing files (default is symlink)
6641 --cygnus assume program is part of Cygnus-style tree
6642 --force-missing force update of standard files
6643 --foreign set strictness to foreign
6644 --gnits set strictness to gnits
6645 --gnu set strictness to gnu
6646 --help print this help, then exit
6647 -i, --ignore-deps disable dependency tracking code
6648 --include-deps enable dependency tracking code
6649 --no-force only update Makefile.in's that are out of date
6650 -o DIR, --output-dir=DIR
6651 put generated Makefile.in's into DIR
6652 -v, --verbose verbosely list files processed
6653 --version print version number, then exit\n";
6655 # Copyright on generated Makefile.ins.
6656 $gen_copyright = "\
6657 # Copyright (C) 1994, 1995-9, 2000 Free Software Foundation, Inc.
6658 # This Makefile.in is free software; the Free Software Foundation
6659 # gives unlimited permission to copy and/or distribute it,
6660 # with or without modifications, as long as this notice is preserved.
6662 # This program is distributed in the hope that it will be useful,
6663 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
6664 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
6665 # PARTICULAR PURPOSE.
6666 ";
6668 # This complex find command will try to avoid changing the modes of
6669 # links into the source tree, in case they're hard-linked. It will
6670 # also make directories writable by everybody, because some
6671 # brain-dead tar implementations change ownership and permissions of
6672 # a directory before extracting the files, thus becoming unable to
6673 # extract them.
6674 # Ignore return result from chmod, because it might give an error
6675 # if we chmod a symlink.
6676 # Another nastiness: if the file is unreadable by us, we make it
6677 # readable regardless of the number of links to it. This only
6678 # happens in perverse cases.
6679 # We use $(install_sh) because that is a known-portable way to
6680 # modify the file in place in the source tree.
6681 $dist_header = ' -find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \\
6682 ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \\
6683 ! -type d ! -perm -400 -exec chmod a+r {} \; -o \\
6684 ! -type d ! -perm -444 -exec $(SHELL) $(install_sh) -c -m a+r {} {} \; \\
6685 || chmod -R a+r $(distdir)
6686 ';
6687 $dist{'dist-bzip2'} = ("\t"
6688 . '$(AMTAR) chof - $(distdir) | bzip2 -9 -c > $(distdir).bz2'
6689 . "\n");
6690 $dist{'dist-tarZ'} = ("\t"
6691 . '$(AMTAR) chof - $(distdir) | compress -c > $(distdir).tar.Z'
6692 . "\n");
6693 $dist{'dist-shar'} = ("\t"
6694 . 'shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c > $(distdir).shar.gz'
6695 . "\n");
6696 $dist{'dist-zip'} = ("\t" . '-rm -f $(distdir).zip' . "\n" .
6697 "\t" . 'zip -rq $(distdir).zip $(distdir)' . "\n");
6699 # Note that we don't use GNU tar's `-z' option. One reason (but
6700 # not the only reason) is that some versions of tar (e.g., OSF1)
6701 # interpret `-z' differently.
6702 $dist{'dist'} = ("\t"
6703 . '$(AMTAR) chof - $(distdir) | GZIP=$(GZIP_ENV) gzip -c > $(distdir).tar.gz'
6704 . "\n");
6705 $dist_trailer = "\t" . '-chmod -R a+w $(distdir) > /dev/null 2>&1; rm -rf $(distdir)' . "\n";
6706 }
6708 # (Re)-Initialize per-Makefile.am variables.
6709 sub initialize_per_input
6710 {
6711 # These two variables are used when generating each Makefile.in.
6712 # They hold the Makefile.in until it is ready to be printed.
6713 $output_rules = '';
6714 $output_vars = '';
6715 $output_trailer = '';
6716 $output_all = '';
6717 $output_header = '';
6719 # Suffixes found during a run.
6720 @suffixes = ();
6722 # This holds the contents of a Makefile.am, as parsed by
6723 # read_am_file.
6724 %contents = ();
6726 # This holds the names which are targets. These also appear in
6727 # %contents.
6728 %targets = ();
6730 # This maps a variable name onto a flag. The flag is true iff the
6731 # variable was first defined with `+='.
6732 %var_was_plus_eq = ();
6734 # This holds definitions of all variables defined in .am files.
6735 # This is used during startup to determine which variables can be
6736 # assigned with `+='.
6737 %am_var_defs = ();
6739 # For a variable or target which is defined conditionally, this
6740 # holds an array of the conditional values. The array is composed
6741 # of pairs of condition strings (the variables which configure
6742 # will substitute) and values (the value of a target is
6743 # meaningless). For an unconditional variable, this is empty.
6744 %conditional = ();
6746 # This holds the line numbers at which various elements of
6747 # %contents are defined.
6748 %content_lines = ();
6750 # This holds a 1 if a particular variable was examined.
6751 %content_seen = ();
6753 # This is the conditional stack.
6754 @conditional_stack = ();
6756 # This holds the set of included files.
6757 @include_stack = ();
6759 # This holds the "relative directory" of the current Makefile.in.
6760 # Eg for src/Makefile.in, this is "src".
6761 $relative_dir = '';
6763 # This holds a list of files that are included in the
6764 # distribution.
6765 %dist_common = ();
6767 # List of dependencies for the obvious targets.
6768 @install_data = ();
6769 @install_exec = ();
6770 @uninstall = ();
6771 @installdirs = ();
6773 @info = ();
6774 @dvi = ();
6775 @all = ();
6776 @check = ();
6777 @check_tests = ();
6778 @installcheck = ();
6779 @clean = ();
6781 @phony = ();
6783 # A list of files deleted by `maintainer-clean'.
6784 @maintainer_clean_files = ();
6786 # These are pretty obvious, too. They are used to define the
6787 # SOURCES and OBJECTS variables.
6788 @sources = ();
6789 @objects = ();
6790 # Sources which go in the distribution.
6791 @dist_sources = ();
6793 # This hash maps object file names onto their corresponding source
6794 # file names. This is used to ensure that each object is created
6795 # by a single source file.
6796 %object_map = ();
6798 # This keeps track of the directories for which we've already
6799 # created `.dirstamp' code.
6800 %directory_map = ();
6802 # These variables track inclusion of various compile-related .am
6803 # files. $included_generic_compile is TRUE if the basic code has
6804 # been included. $included_knr_compile is TRUE if the ansi2knr
6805 # code has been included. $included_libtool_compile is TRUE if
6806 # libtool support has been included.
6807 $included_generic_compile = 0;
6808 $included_knr_compile = 0;
6809 $included_libtool_compile = 0;
6811 # TRUE if install targets should work recursively.
6812 $recursive_install = 0;
6814 # All .P files.
6815 %dep_files = ();
6817 # Strictness levels.
6818 $strictness = $default_strictness;
6819 $strictness_name = $default_strictness_name;
6821 # Options from AUTOMAKE_OPTIONS.
6822 %options = ();
6824 # Whether or not dependencies are handled. Can be further changed
6825 # in handle_options.
6826 $use_dependencies = $cmdline_use_dependencies;
6828 # Per Makefile.am.
6829 $local_maint_charset = $maint_charset;
6831 # All yacc and lex source filenames for this directory. Use
6832 # filenames instead of raw count so that multiple instances are
6833 # counted correctly (eg one yacc file can appear in multiple
6834 # programs without harm).
6835 %yacc_sources = ();
6836 %lex_sources = ();
6838 # This is a list of all targets to run during "make dist".
6839 @dist_targets = ();
6841 # Keys in this hash are the basenames of files which must depend
6842 # on ansi2knr.
6843 %de_ansi_files = ();
6845 # This maps the source extension of a suffix rule to its
6846 # corresponding output extension.
6847 %suffix_rules = ();
6849 # This is a regular expression which matches all the known source
6850 # suffix. A source suffix is one that appears in the first
6851 # position of a suffix rule.
6852 $source_suffix_pattern = '';
6854 # This is the name of the recursive `all' target to use.
6855 $all_target = 'all-recursive';
6857 # This keeps track of which extensions we've seen (that we care
6858 # about).
6859 %extension_seen = ();
6861 # This is random scratch space for the language finish functions.
6862 # Don't randomly overwrite it; examine other uses of keys first.
6863 %language_scratch = ();
6865 # We keep track of which objects need special (per-executable)
6866 # handling on a per-language basis.
6867 %lang_specific_files = ();
6869 # This is set when `handle_dist' has finished. Once this happens,
6870 # we should no longer push on dist_common.
6871 $handle_dist_run = 0;
6872 }
6875 ################################################################
6877 # Return contents of a file from $am_dir, automatically skipping
6878 # macros or rules which are already known. Runs command on each line
6879 # as it is read; this command can modify $_.
6880 sub file_contents_with_transform
6881 {
6882 local ($command, $basename) = @_;
6883 local ($file) = $am_dir . '/' . $basename . '.am';
6885 if ($command ne '' && substr ($command, -1) ne ';')
6886 {
6887 die "automake: programming error in file_contents_with_transform: $command\n";
6888 }
6890 open (FC_FILE, $file)
6891 || die "automake: installation error: cannot open \`$file'\n";
6892 # Looks stupid?
6893 # print "automake: reading $file\n" if $verbose;
6895 local ($was_rule) = 0;
6896 local ($result_vars) = '';
6897 local ($result_rules) = '';
6898 local ($comment) = '';
6899 local ($spacing) = "\n";
6900 local ($skipping) = 0;
6901 local ($had_chars);
6903 while (<FC_FILE>)
6904 {
6905 $_ =~ s/\@MAINTAINER_MODE_TRUE\@//g
6906 unless $seen_maint_mode;
6908 $had_chars = length ($_) && $_ ne "\n";
6909 eval $command;
6910 # If the transform caused all the characters to go away, then
6911 # ignore the line. Why do this? Because in Perl 4, a "next"
6912 # inside of an eval doesn't affect a loop outside the eval.
6913 # So we can't pass in a "transform" that uses next. We used
6914 # to do this. "Empty" also means consisting of a single
6915 # newline.
6916 next if $had_chars && ($_ eq '' || $_ eq "\n");
6918 if (/$IGNORE_PATTERN/o)
6919 {
6920 # Merely delete comments beginning with two hashes.
6921 }
6922 elsif (/$WHITE_PATTERN/o)
6923 {
6924 # Stick a single white line before the incoming macro or rule.
6925 $spacing = "\n";
6926 &am_line_error ($., "blank line following trailing backslash")
6927 if $saw_bk;
6928 }
6929 elsif (/$COMMENT_PATTERN/o)
6930 {
6931 # Stick comments before the incoming macro or rule.
6932 $comment .= $spacing . $_;
6933 $spacing = '';
6934 &am_line_error ($., "comment following trailing backslash")
6935 if $saw_bk;
6936 }
6937 elsif ($saw_bk)
6938 {
6939 if ($was_rule)
6940 {
6941 $result_rules .= $_ if ! $skipping;
6942 }
6943 else
6944 {
6945 $result_vars .= $_ if ! $skipping;
6946 }
6947 $saw_bk = /\\$/;
6948 }
6949 elsif (/$RULE_PATTERN/o)
6950 {
6951 # Found a rule.
6952 $was_rule = 1;
6953 $skipping = defined $contents{$1};
6954 $result_rules .= $comment . $spacing . $_ if ! $skipping;
6955 $comment = $spacing = '';
6956 $saw_bk = /\\$/;
6957 }
6958 elsif (/$MACRO_PATTERN/o)
6959 {
6960 # Found a variable reference.
6961 $was_rule = 0;
6962 $skipping = defined $contents{$1};
6963 $result_vars .= $comment . $spacing . $_ if ! $skipping;
6964 $comment = $spacing = '';
6965 $saw_bk = /\\$/;
6966 print STDERR "automake: programming error: .am macro \`$1' with trailing backslash\n"
6967 if $saw_bk;
6968 $am_var_defs{$1} = $3;
6969 }
6970 else
6971 {
6972 # This isn't an error; it is probably a continued rule.
6973 # In fact, this is what we assume.
6974 $was_rule = 1;
6975 $result_rules .= $comment . $spacing . $_ if ! $skipping;
6976 $comment = $spacing = '';
6977 $saw_bk = /\\$/;
6978 }
6979 }
6981 close (FC_FILE);
6982 return $result_vars . $result_rules . $comment;
6983 }
6985 # Like file_contents_with_transform, but no transform.
6986 sub file_contents
6987 {
6988 return &file_contents_with_transform ('', @_);
6989 }
6991 # Find all variable prefixes that are used for install directories. A
6992 # prefix `zar' qualifies iff:
6993 # * `zardir' is a variable.
6994 # * `zar_PRIMARY' is a variable.
6995 sub am_primary_prefixes
6996 {
6997 local ($primary, $can_dist, @prefixes) = @_;
6999 local (%valid, $varname);
7000 grep ($valid{$_} = 0, @prefixes);
7001 $valid{'EXTRA'} = 0;
7002 foreach $varname (keys %contents)
7003 {
7004 if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_$primary$/)
7005 {
7006 if (($2 ne '' && ! $can_dist)
7007 || (! defined $valid{$3}
7008 && ! &variable_defined ($3 . 'dir')
7009 # Note that a configure variable is always
7010 # legitimate. It is natural to name such
7011 # variables after the primary, so we explicitly
7012 # allow it.
7013 && ! defined $configure_vars{$varname}))
7014 {
7015 &am_line_error ($varname, "invalid variable \`$varname'");
7016 }
7017 else
7018 {
7019 # Ensure all extended prefixes are actually used.
7020 $valid{$1 . $2 . $3} = 1;
7021 }
7022 }
7023 }
7025 return %valid;
7026 }
7028 # Handle `where_HOW' variable magic. Does all lookups, generates
7029 # install code, and possibly generates code to define the primary
7030 # variable. The first argument is the name of the .am file to munge,
7031 # the second argument is the primary variable (eg HEADERS), and all
7032 # subsequent arguments are possible installation locations. Returns
7033 # list of all values of all _HOW targets.
7034 #
7035 # FIXME: this should be rewritten to be cleaner. It should be broken
7036 # up into multiple functions.
7037 #
7038 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7039 sub am_install_var
7040 {
7041 local (@args) = @_;
7043 local ($do_clean) = 0;
7044 local ($do_require) = 1;
7045 local ($can_dist) = 0;
7046 local ($default_dist) = 0;
7048 local ($ltxform);
7049 if (defined $configure_vars{'LIBTOOL'})
7050 {
7051 # Transform '@LIBTOOL ...@' to '$(LIBTOOL) ...'
7052 $ltxform = 's/\@LIBTOOL([^\@]*)\@/\$(LIBTOOL) $1/;';
7053 }
7054 else
7055 {
7056 # Delete '@LIBTOOL ...@'
7057 $ltxform = 's/\@LIBTOOL([^\@]*)\@//;';
7058 }
7060 local ($cygxform);
7061 if (! $seen_exeext)
7062 {
7063 $cygxform = 's/\@EXEEXT\@//g;';
7064 }
7065 else
7066 {
7067 $cygxform = 's/\@EXEEXT\@/\$(EXEEXT)/g;';
7068 }
7070 while (@args)
7071 {
7072 if ($args[0] eq '-clean')
7073 {
7074 $do_clean = 1;
7075 }
7076 elsif ($args[0] eq '-noextra')
7077 {
7078 $do_require = 0;
7079 }
7080 elsif ($args[0] eq '-candist')
7081 {
7082 $can_dist = 1;
7083 }
7084 elsif ($args[0] eq '-defaultdist')
7085 {
7086 $default_dist = 1;
7087 $can_dist = 1;
7088 }
7089 elsif ($args[0] !~ /^-/)
7090 {
7091 last;
7092 }
7093 shift (@args);
7094 }
7096 local ($file, $primary, @prefixes) = @args;
7098 local (@used) = ();
7099 local (@result) = ();
7101 # Now that configure substitutions are allowed in where_HOW
7102 # variables, it is an error to actually define the primary. We
7103 # allow `JAVA', as it is customarily used to mean the Java
7104 # interpreter. This is but one of several Java hacks. Similarly,
7105 # `PYTHON' is customarily used to mean the Python interpreter.
7106 &am_line_error ($primary, "\`$primary' is an anachronism")
7107 if &variable_defined ($primary)
7108 && ($primary ne 'JAVA' && $primary ne 'PYTHON');
7111 # Look for misspellings. It is an error to have a variable ending
7112 # in a "reserved" suffix whose prefix is unknown, eg
7113 # "bni_PROGRAMS". However, unusual prefixes are allowed if a
7114 # variable of the same name (with "dir" appended) exists. For
7115 # instance, if the variable "zardir" is defined, then
7116 # "zar_PROGRAMS" becomes valid. This is to provide a little extra
7117 # flexibility in those cases which need it.
7118 local (%valid) = &am_primary_prefixes ($primary, $can_dist, @prefixes);
7120 # If a primary includes a configure substitution, then the EXTRA_
7121 # form is required. Otherwise we can't properly do our job.
7122 local ($require_extra);
7123 local ($warned_about_extra) = 0;
7125 local ($clean_file) = $file . '-clean';
7126 local ($one_name);
7127 local ($X);
7128 local ($nodir_name);
7129 local ($strip_subdir) = 1;
7130 foreach $X (sort keys %valid)
7131 {
7132 $one_name = $X . '_' . $primary;
7133 if (&variable_defined ($one_name))
7134 {
7135 # If subdir prefix should be preserved, do so.
7136 if ($X =~ /^nobase_/)
7137 {
7138 $strip_subdir = 0;
7139 $X =~ s/^nobase_//;
7140 }
7142 # If files should be distributed, do so.
7143 if ($can_dist)
7144 {
7145 if (($default_dist && $one_name !~ /^nodist_/)
7146 || (! $default_dist && $one_name =~ /^dist_/))
7147 {
7148 &push_dist_common ('$(' . $one_name . ')');
7149 }
7150 ($nodir_name = $X) =~ s/^(dist|nodist)_//;
7151 }
7152 else
7153 {
7154 $nodir_name = $X;
7155 }
7157 # Append actual contents of where_PRIMARY variable to
7158 # result.
7159 local ($rcurs);
7160 foreach $rcurs (&variable_value_as_list ($one_name, 'all'))
7161 {
7162 # Skip configure substitutions. Possibly bogus.
7163 if ($rcurs =~ /^\@.*\@$/)
7164 {
7165 if ($X eq 'EXTRA')
7166 {
7167 if (! $warned_about_extra)
7168 {
7169 $warned_about_extra = 1;
7170 {
7171 &am_line_error ($one_name,
7172 "\`$one_name' contains configure substitution, but shouldn't");
7173 }
7174 }
7175 }
7176 # Check here to make sure variables defined in
7177 # configure.in do not imply that EXTRA_PRIMARY
7178 # must be defined.
7179 elsif (! defined $configure_vars{$one_name})
7180 {
7181 $require_extra = $one_name
7182 if $do_require;
7183 }
7185 next;
7186 }
7188 push (@result, $rcurs);
7189 }
7191 # A blatant hack: we rewrite each _PROGRAMS primary to
7192 # include EXEEXT when in Cygwin32 mode.
7193 if ($seen_exeext && $primary eq 'PROGRAMS')
7194 {
7195 local (@conds) = &variable_conditions ($one_name);
7196 local (@one_binlist);
7198 # FIXME: this definitely loses aesthetically; it
7199 # redefines $ONE_NAME. Instead we should arrange for
7200 # variable definitions to be output later, instead of
7201 # at scan time.
7203 if (! @conds)
7204 {
7205 @one_binlist = ();
7206 foreach $rcurs (&variable_value_as_list ($one_name, ''))
7207 {
7208 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
7209 {
7210 push (@one_binlist, $rcurs);
7211 }
7212 else
7213 {
7214 push (@one_binlist, $rcurs . '$(EXEEXT)');
7215 }
7216 }
7218 delete $contents{$one_name};
7219 &define_pretty_variable ($one_name, '', @one_binlist);
7220 }
7221 else
7222 {
7223 local ($cond);
7224 local ($condvals) = '';
7225 foreach $cond (@conds)
7226 {
7227 @one_binlist = ();
7228 local (@condval) = &variable_value_as_list ($one_name,
7229 $cond);
7230 foreach $rcurs (@condval)
7231 {
7232 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
7233 {
7234 push (@one_binlist, $rcurs);
7235 }
7236 else
7237 {
7238 push (@one_binlist, $rcurs . '$(EXEEXT)');
7239 }
7240 }
7242 push (@condvals, $cond);
7243 push (@condvals, join (' ', @one_binlist));
7244 }
7246 delete $contents{$one_name};
7248 while (@condvals)
7249 {
7250 $cond = shift (@condvals);
7251 local (@val) = split (' ', shift (@condvals));
7252 &define_pretty_variable ($one_name, $cond, @val);
7253 }
7254 }
7255 }
7257 # "EXTRA" shouldn't be used when generating clean targets,
7258 # all, or install targets.
7259 if ($X eq 'EXTRA')
7260 {
7261 # We used to warn if EXTRA_FOO was defined uselessly,
7262 # but this was annoying.
7263 next;
7264 }
7266 if ($do_clean)
7267 {
7268 $output_rules .=
7269 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go;'
7270 . $cygxform,
7271 $clean_file);
7273 push (@clean, $X . $primary);
7274 &push_phony_cleaners ($X . $primary);
7275 }
7277 if ($X eq 'check')
7278 {
7279 push (@check, '$(' . $one_name . ')');
7280 }
7281 else
7282 {
7283 push (@used, '$(' . $one_name . ')');
7284 }
7285 if ($X eq 'noinst' || $X eq 'check')
7286 {
7287 # Objects which don't get installed by default.
7288 next;
7289 }
7291 local ($subdir_xform);
7292 if ($strip_subdir)
7293 {
7294 $subdir_xform = 's/^NOBASE.*$//; s/^BASE//;';
7295 }
7296 else
7297 {
7298 $subdir_xform = 's/^BASE.*$//; s/^NOBASE//;';
7299 }
7301 $output_rules .=
7302 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/g;'
7303 . 's/\@NDIR\@/' . $nodir_name . '/go;'
7304 . $ltxform . $cygxform
7305 . $subdir_xform,
7306 $file);
7308 push (@uninstall, 'uninstall-' . $X . $primary);
7309 push (@phony, 'uninstall-' . $X . $primary);
7310 push (@installdirs, '$(DESTDIR)$(' . $X . 'dir)');
7311 if (defined $exec_dir_p{$X} ? $exec_dir_p{$X} : ($X =~ /exec/))
7312 {
7313 push (@install_exec, 'install-' . $X . $primary);
7314 push (@phony, 'install-' . $X . $primary);
7315 }
7316 else
7317 {
7318 push (@install_data, 'install-' . $X . $primary);
7319 push (@phony, 'install-' . $X . $primary);
7320 }
7321 }
7322 }
7324 # The JAVA variable is used as the name of the Java interpreter.
7325 # The PYTHON variable is used as the name of the Python interpreter.
7326 if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7327 {
7328 # Define it.
7329 &define_pretty_variable ($primary, '', @used);
7330 $output_vars .= "\n";
7331 }
7333 if ($require_extra && ! &variable_defined ('EXTRA_' . $primary))
7334 {
7335 &am_line_error ($require_extra,
7336 "\`$require_extra' contains configure substitution, but \`EXTRA_$primary' not defined");
7337 }
7339 # Push here because PRIMARY might be configure time determined.
7340 push (@all, '$(' . $primary . ')')
7341 if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7343 # Make the result unique. This lets the user use conditionals in
7344 # a natural way, but still lets us program lazily -- we don't have
7345 # to worry about handling a particular object more than once.
7346 local (%uniquify) = ();
7347 grep ($uniquify{$_} = 1, @result);
7348 return sort keys %uniquify;
7349 }
7352 ################################################################
7354 # Each key in this hash is the name of a directory holding a
7355 # Makefile.in. These variables are local to `is_make_dir'.
7356 %make_dirs = ();
7357 $make_dirs_set = 0;
7359 sub is_make_dir
7360 {
7361 local ($dir) = @_;
7362 if (! $make_dirs_set)
7363 {
7364 foreach $iter (@configure_input_files)
7365 {
7366 $make_dirs{&dirname ($iter)} = 1;
7367 }
7368 # We also want to notice Makefile.in's.
7369 foreach $iter (@other_input_files)
7370 {
7371 if ($iter =~ /Makefile\.in$/)
7372 {
7373 $make_dirs{&dirname ($iter)} = 1;
7374 }
7375 }
7376 $make_dirs_set = 1;
7377 }
7378 return defined $make_dirs{$dir};
7379 }
7381 ################################################################
7383 # This variable is local to the "require file" set of functions.
7384 @require_file_paths = ();
7386 # If a file name appears as a key in this hash, then it has already
7387 # been checked for. This variable is local to the "require file"
7388 # functions.
7389 %require_file_found = ();
7391 # See if we want to push this file onto dist_common. This function
7392 # encodes the rules for deciding when to do so.
7393 sub maybe_push_required_file
7394 {
7395 local ($dir, $file, $fullfile) = @_;
7397 # FIXME: Once again, special-case `.'.
7398 if ($dir eq $relative_dir || $dir eq '.')
7399 {
7400 &push_dist_common ($file);
7401 }
7402 elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7403 {
7404 # If we are doing the topmost directory, and the file is in a
7405 # subdir which does not have a Makefile, then we distribute it
7406 # here.
7407 &push_dist_common ($fullfile);
7408 }
7409 }
7411 # Verify that the file must exist in the current directory. Usage:
7412 # require_file (isconfigure, line_number, strictness, file) strictness
7413 # is the strictness level at which this file becomes required. Must
7414 # set require_file_paths before calling this function.
7415 # require_file_paths is set to hold a single directory (the one in
7416 # which the first file was found) before return.
7417 sub require_file_internal
7418 {
7419 local ($is_configure, $line, $mystrict, @files) = @_;
7420 local ($file, $fullfile);
7421 local ($found_it, $dangling_sym, $errfile, $errdir);
7422 local ($save_dir);
7424 foreach $file (@files)
7425 {
7426 # If we've already looked for it, we're done.
7427 next if defined $require_file_found{$file};
7428 $require_file_found{$file} = 1;
7430 $found_it = 0;
7431 $dangling_sym = 0;
7432 foreach $dir (@require_file_paths)
7433 {
7434 if ($dir eq '.')
7435 {
7436 $fullfile = $relative_dir . "/" . $file;
7437 $errdir = $relative_dir unless $errdir;
7438 }
7439 else
7440 {
7441 $fullfile = $dir . "/" . $file;
7442 $errdir = $dir unless $errdir;
7443 }
7445 # Use different name for "error filename". Otherwise on
7446 # an error the bad file will be reported as eg
7447 # `../../install-sh' when using the default
7448 # config_aux_path.
7449 $errfile = $errdir . '/' . $file;
7451 if (-l $fullfile && ! -f readlink ($fullfile))
7452 {
7453 $dangling_sym = 1;
7454 last;
7455 }
7456 elsif (-f $fullfile)
7457 {
7458 $found_it = 1;
7459 &maybe_push_required_file ($dir, $file, $fullfile);
7460 $save_dir = $dir;
7461 last;
7462 }
7463 }
7465 if ($found_it && ! $force_missing)
7466 {
7467 # Prune the path list.
7468 @require_file_paths = $save_dir;
7469 }
7470 else
7471 {
7472 if ($strictness >= $mystrict)
7473 {
7474 if ($dangling_sym && ($force_missing || $add_missing))
7475 {
7476 unlink ($fullfile);
7477 }
7479 local ($trailer) = '';
7480 local ($suppress) = 0;
7482 # Only install missing files according to our desired
7483 # strictness level.
7484 local ($message) = "required file \`$errfile' not found";
7485 if ($add_missing)
7486 {
7487 $suppress = 1;
7489 # Maybe run libtoolize.
7490 local @syslist = ('libtoolize', '--automake');
7491 push @syslist, '--copy'
7492 if $copy_missing;
7493 if ($seen_libtool
7494 && grep ($_ eq $file, @libtoolize_files)
7495 && system (@syslist))
7496 {
7497 $message = "installing \`$errfile'";
7498 $suppress = 0;
7499 $trailer = "; cannot run \`libtoolize': $!";
7500 }
7501 elsif (-f ($am_dir . '/' . $file))
7502 {
7503 # Install the missing file. Symlink if we
7504 # can, copy if we must. Note: delete the file
7505 # first, in case it is a dangling symlink.
7506 $message = "installing \`$errfile'";
7507 # Windows Perl will hang if we try to delete a
7508 # file that doesn't exist.
7509 unlink ($errfile) if -f $errfile;
7510 if ($symlink_exists && ! $copy_missing)
7511 {
7512 if (! symlink ($am_dir . '/' . $file, $errfile))
7513 {
7514 $suppress = 0;
7515 $trailer = "; error while making link: $!";
7516 }
7517 }
7518 elsif (system ('cp', $am_dir . '/' . $file, $errfile))
7519 {
7520 $suppress = 0;
7521 $trailer = "\n error while copying";
7522 }
7523 }
7525 &maybe_push_required_file (&dirname ($errfile),
7526 $errfile, $errfile);
7527 }
7529 local ($save) = $exit_status;
7530 if ($is_configure)
7531 {
7532 # FIXME: allow actual file to be specified.
7533 &am_conf_line_error ('configure.in', $line,
7534 "$message$trailer");
7535 }
7536 else
7537 {
7538 &am_line_error ($line, "$message$trailer");
7539 }
7540 $exit_status = $save if $suppress;
7541 }
7542 }
7543 }
7544 }
7546 # Like require_file_with_line, but error messages refer to
7547 # configure.in, not the current Makefile.am.
7548 sub require_file_with_conf_line
7549 {
7550 @require_file_paths = '.';
7551 &require_file_internal (1, @_);
7552 }
7554 sub require_file_with_line
7555 {
7556 @require_file_paths = '.';
7557 &require_file_internal (0, @_);
7558 }
7560 sub require_file
7561 {
7562 @require_file_paths = '.';
7563 &require_file_internal (0, '', @_);
7564 }
7566 # Require a file that is also required by Autoconf. Looks in
7567 # configuration path, as specified by AC_CONFIG_AUX_DIR.
7568 sub require_config_file
7569 {
7570 @require_file_paths = @config_aux_path;
7571 &require_file_internal (1, '', @_);
7572 local ($dir) = $require_file_paths[0];
7573 @config_aux_path = @require_file_paths;
7574 if ($dir eq '.')
7575 {
7576 $config_aux_dir = '.';
7577 }
7578 else
7579 {
7580 $config_aux_dir = '$(top_srcdir)/' . $dir;
7581 }
7582 }
7584 # Assumes that the line number is in Makefile.am.
7585 sub require_conf_file_with_line
7586 {
7587 @require_file_paths = @config_aux_path;
7588 &require_file_internal (0, @_);
7589 local ($dir) = $require_file_paths[0];
7590 @config_aux_path = @require_file_paths;
7591 if ($dir eq '.')
7592 {
7593 $config_aux_dir = '.';
7594 }
7595 else
7596 {
7597 $config_aux_dir = '$(top_srcdir)/' . $dir;
7598 }
7599 }
7601 # Assumes that the line number is in configure.in.
7602 sub require_conf_file_with_conf_line
7603 {
7604 @require_file_paths = @config_aux_path;
7605 &require_file_internal (1, @_);
7606 local ($dir) = $require_file_paths[0];
7607 @config_aux_path = @require_file_paths;
7608 if ($dir eq '.')
7609 {
7610 $config_aux_dir = '.';
7611 }
7612 else
7613 {
7614 $config_aux_dir = '$(top_srcdir)/' . $dir;
7615 }
7616 }
7618 ################################################################
7620 # Push a list of files onto dist_common.
7621 sub push_dist_common
7622 {
7623 local (@files) = @_;
7624 local ($file);
7626 foreach $file (@files)
7627 {
7628 if (! defined $dist_common{$file})
7629 {
7630 if ($handle_dist_run)
7631 {
7632 print STDERR
7633 "automake: programming error: push_dist_common run after handle_dist\n";
7634 exit 1;
7635 }
7636 $dist_common{$file} = 1;
7637 }
7638 }
7639 }
7641 # Push a list of clean targets onto phony.
7642 sub push_phony_cleaners
7643 {
7644 local ($base) = @_;
7645 local ($target);
7646 foreach $target ('mostly', 'dist', '', 'maintainer-')
7647 {
7648 push (@phony, $target . 'clean-' . $base);
7649 }
7650 }
7652 # Set strictness.
7653 sub set_strictness
7654 {
7655 $strictness_name = $_[0];
7656 if ($strictness_name eq 'gnu')
7657 {
7658 $strictness = $GNU;
7659 }
7660 elsif ($strictness_name eq 'gnits')
7661 {
7662 $strictness = $GNITS;
7663 }
7664 elsif ($strictness_name eq 'foreign')
7665 {
7666 $strictness = $FOREIGN;
7667 }
7668 else
7669 {
7670 die "automake: level \`$strictness_name' not recognized\n";
7671 }
7672 }
7675 ################################################################
7677 # Return directory name of file.
7678 sub dirname
7679 {
7680 local ($file) = @_;
7681 local ($sub);
7683 ($sub = $file) =~ s,/+[^/]+$,,g;
7684 $sub = '.' if $sub eq $file;
7685 return $sub;
7686 }
7688 # Return file name of a file.
7689 sub basename
7690 {
7691 local ($file) = @_;
7692 local ($sub);
7694 ($sub = $file) =~s,^.*/+,,g;
7695 return $sub;
7696 }
7698 # Ensure a file exists.
7699 sub create
7700 {
7701 local ($file) = @_;
7703 open (TOUCH, ">> $file");
7704 close (TOUCH);
7705 }
7707 # Glob something. Do this to avoid indentation screwups everywhere we
7708 # want to glob. Gross!
7709 sub my_glob
7710 {
7711 local ($pat) = @_;
7712 return <${pat}>;
7713 }
7715 ################################################################
7717 # Print an error message and set exit status.
7718 sub am_error
7719 {
7720 warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
7721 $exit_status = 1;
7722 }
7724 sub am_line_error
7725 {
7726 local ($symbol, @args) = @_;
7728 if ($symbol && "$symbol" ne '-1')
7729 {
7730 local ($file) = "${am_file}.am";
7732 if ($symbol =~ /^\d+$/)
7733 {
7734 # SYMBOL is a line number, so just add the colon.
7735 $file .= ':' . $symbol;
7736 }
7737 elsif (defined $content_lines{$symbol})
7738 {
7739 # SYMBOL is a variable defined in Makefile.am, so add the
7740 # line number we saved from there.
7741 $file .= ':' . $content_lines{$symbol};
7742 }
7743 elsif (defined $configure_vars{$symbol})
7744 {
7745 # SYMBOL is a variable defined in configure.in, so add the
7746 # appropriate line number.
7747 $file = $configure_vars{$symbol};
7748 }
7749 else
7750 {
7751 # Couldn't find the line number.
7752 }
7753 warn $file, ": ", join (' ', @args), "\n";
7754 $exit_status = 1;
7755 }
7756 else
7757 {
7758 &am_error (@args);
7759 }
7760 }
7762 # Like am_error, but while scanning configure.in.
7763 sub am_conf_error
7764 {
7765 # FIXME: can run in subdirs.
7766 warn "automake: configure.in: ", join (' ', @_), "\n";
7767 $exit_status = 1;
7768 }
7770 # Error message with line number referring to configure.in.
7771 sub am_conf_line_error
7772 {
7773 local ($file, $line, @args) = @_;
7775 if ($line)
7776 {
7777 warn "$file: $line: ", join (' ', @args), "\n";
7778 $exit_status = 1;
7779 }
7780 else
7781 {
7782 &am_conf_error (@args);
7783 }
7784 }
7786 # Warning message with line number referring to configure.in.
7787 # Does not affect exit_status
7788 sub am_conf_line_warning
7789 {
7790 local ($saved_exit_status) = $exit_status;
7791 &am_conf_line_error (@_);
7792 $exit_status = $saved_exit_status;
7793 }
7795 # Tell user where our aclocal.m4 is, but only once.
7796 sub keyed_aclocal_warning
7797 {
7798 local ($key) = @_;
7799 warn "automake: macro \`$key' can be generated by \`aclocal'\n";
7800 }
7802 # Print usage information.
7803 sub usage
7804 {
7805 print "Usage: automake [OPTION] ... [Makefile]...\n\n";
7806 print "Generate Makefile.in for autoconf from Makefile.am\n";
7807 print $USAGE;
7808 print "\nFiles which are automatically distributed, if found:\n";
7809 $~ = "USAGE_FORMAT";
7810 local ($last, $iter, @lcomm);
7811 $last = '';
7812 foreach $iter (sort ((@common_files, @common_sometimes)))
7813 {
7814 push (@lcomm, $iter) unless $iter eq $last;
7815 $last = $iter;
7816 }
7818 local ($one, $two, $three, $four, $i, $max);
7819 $max = int (($#lcomm + 1) / 4);
7821 for ($i = 0; $i < $max; ++$i)
7822 {
7823 $one = $lcomm[$i];
7824 $two = $lcomm[$max + $i];
7825 $three = $lcomm[2 * $max + $i];
7826 $four = $lcomm[3 * $max + $i];
7827 write;
7828 }
7830 local ($mod) = ($#lcomm + 1) % 4;
7831 if ($mod != 0)
7832 {
7833 $one = $lcomm[$max];
7834 $two = ($mod > 1) ? $lcomm[2 * $max] : '';
7835 $three = ($mod > 2) ? $lcomm[3 * $max] : '';
7836 $four = ($mod > 3) ? $lcomm[4 * $max] : '';
7837 write;
7838 }
7840 print "\nReport bugs to <bug-automake\@gnu.org>.\n";
7842 exit 0;
7843 }
7845 format USAGE_FORMAT =
7846 @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<
7847 $one, $two, $three, $four
7848 .