| blob | 7ffefe2a5ef2a855ec7a143ac94e94757230a7b8 |
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 local ($config_aux_dir_specified) = ($config_aux_dir ne '.'
3020 && $config_aux_dir ne '');
3022 # Set $require_file_found{'depcomp'} if the depcomp file exists,
3023 # before calling require_config_file on `depcomp'. This makes
3024 # require_file_internal skip its buggy existence test that would
3025 # make automake fail (with `required file `lib/depcomp' not found')
3026 # when AC_CONFIG_AUX_DIR is not set. See tests/subdir4.test.
3027 local ($depcomp_dir) = ($config_aux_dir_specified ? $config_aux_dir
3028 : '.');
3029 $require_file_found{'depcomp'} = 1 if -f "$depcomp_dir/depcomp";
3031 # Set location of depcomp.
3032 local ($prefix) = ($config_aux_dir_specified ? $config_aux_dir
3033 : '$(top_srcdir)');
3035 &define_variable ('depcomp', "\$(SHELL) $prefix/depcomp");
3037 &require_config_file ($FOREIGN, 'depcomp');
3039 local ($iter);
3040 local (@deplist) = sort keys %dep_files;
3042 &define_pretty_variable ('DEP_FILES', '', ("\@AMDEP\@", @deplist));
3044 # Generate each `include' individually. Irix 6 make will
3045 # not properly include several files resulting from a
3046 # variable expansion; generating many separate includes
3047 # seems safest.
3048 $output_rules .= "\n";
3049 foreach $iter (@deplist)
3050 {
3051 $output_rules .= "\@AMDEP\@" . 'include ' . $iter . "\n";
3052 }
3054 $output_rules .= &file_contents ('depend');
3055 push (@clean, 'depend');
3056 &push_phony_cleaners ('depend');
3057 }
3058 }
3059 else
3060 {
3061 &define_variable ('depcomp', '');
3062 }
3064 local ($key, $lang, $ext, $xform);
3065 foreach $key (sort keys %language_map)
3066 {
3067 next unless $key =~ /^(.*)-autodep$/;
3068 next if $language_map{$key} eq 'no';
3069 &add_depend2 ($1);
3070 }
3071 }
3073 # Handle subdirectories.
3074 sub handle_subdirs
3075 {
3076 return if ! &variable_defined ('SUBDIRS');
3078 # Make sure each directory mentioned in SUBDIRS actually exists.
3079 local ($dir);
3080 foreach $dir (&variable_value_as_list ('SUBDIRS', 'all'))
3081 {
3082 # Skip directories substituted by configure.
3083 next if $dir =~ /^\@.*\@$/;
3085 if (! -d $am_relative_dir . '/' . $dir)
3086 {
3087 &am_line_error ('SUBDIRS',
3088 "required directory $am_relative_dir/$dir does not exist");
3089 next;
3090 }
3092 &am_line_error ('SUBDIRS', "directory should not contain \`/'")
3093 if $dir =~ /\//;
3094 }
3096 local ($xform) = ('s/\@INSTALLINFO\@/' .
3097 (defined $options{'no-installinfo'}
3098 ? 'install-info-recursive'
3099 : '')
3100 . '/;');
3101 $output_rules .= &file_contents_with_transform ($xform, 'subdirs');
3103 # Push a bunch of phony targets.
3104 local ($phonies);
3105 foreach $phonies ('', '-data', '-exec', 'dirs')
3106 {
3107 push (@phony, 'install' . $phonies . '-recursive');
3108 push (@phony, 'uninstall' . $phonies . '-recursive');
3109 }
3110 foreach $phonies ('all', 'check', 'installcheck', 'info', 'dvi')
3111 {
3112 push (@phony, $phonies . '-recursive');
3113 }
3114 &push_phony_cleaners ('recursive');
3116 $recursive_install = 1;
3117 }
3119 # Handle aclocal.m4.
3120 sub handle_aclocal_m4
3121 {
3122 local ($regen_aclocal) = 0;
3123 if (-f 'aclocal.m4')
3124 {
3125 &define_variable ("ACLOCAL_M4", '$(top_srcdir)/aclocal.m4');
3126 &push_dist_common ('aclocal.m4');
3128 if (open (ACLOCAL, '< aclocal.m4'))
3129 {
3130 local ($line);
3131 $line = <ACLOCAL>;
3132 close (ACLOCAL);
3134 if ($line =~ 'generated automatically by aclocal')
3135 {
3136 $regen_aclocal = 1;
3137 }
3138 }
3139 }
3141 local ($acinclude) = 0;
3142 if (-f 'acinclude.m4')
3143 {
3144 $regen_aclocal = 1;
3145 $acinclude = 1;
3146 }
3148 # Note that it might be possible that aclocal.m4 doesn't exist but
3149 # should be auto-generated. This case probably isn't very
3150 # important.
3151 if ($regen_aclocal)
3152 {
3153 local (@ac_deps) = (
3154 ($seen_maint_mode
3155 ? "\@MAINTAINER_MODE_TRUE\@"
3156 : "") ,
3157 "configure.in",
3158 ($acinclude ? ' acinclude.m4' : '')
3159 );
3161 # Scan all -I directories for m4 files. These are our
3162 # dependencies.
3163 if (&variable_defined ('ACLOCAL_AMFLAGS'))
3164 {
3165 local ($examine_next, $amdir) = 0;
3166 foreach $amdir (&variable_value_as_list ('ACLOCAL_AMFLAGS', ''))
3167 {
3168 if ($examine_next)
3169 {
3170 $examine_next = 0;
3171 if ($amdir !~ /^\// && -d $amdir)
3172 {
3173 push (@ac_deps, &my_glob ($amdir . '/*.m4'));
3174 }
3175 }
3176 elsif ($amdir eq '-I')
3177 {
3178 $examine_next = 1;
3179 }
3180 }
3181 }
3183 &pretty_print_rule ("\$(ACLOCAL_M4):", "\t\t", @ac_deps);
3185 $output_rules .= ("\t"
3186 . 'cd $(srcdir) && $(ACLOCAL)'
3187 . (&variable_defined ('ACLOCAL_AMFLAGS')
3188 ? ' $(ACLOCAL_AMFLAGS)' : '')
3189 . "\n");
3190 }
3191 }
3193 # Rewrite a list of input files into a form suitable to put on a
3194 # dependency list. The idea is that if an input file has a directory
3195 # part the same as the current directory, then the directory part is
3196 # simply removed. But if the directory part is different, then
3197 # $(top_srcdir) is prepended. Among other things, this is used to
3198 # generate the dependency list for the output files generated by
3199 # AC_OUTPUT. Consider what the dependencies should look like in this
3200 # case:
3201 # AC_OUTPUT(src/out:src/in1:lib/in2)
3202 # The first argument, ADD_SRCDIR, is 1 if $(top_srcdir) should be added.
3203 # If 0 then files that require this addition will simply be ignored.
3204 sub rewrite_inputs_into_dependencies
3205 {
3206 local ($add_srcdir, @inputs) = @_;
3207 local ($single, @newinputs);
3209 foreach $single (@inputs)
3210 {
3211 if (&dirname ($single) eq $relative_dir)
3212 {
3213 push (@newinputs, &basename ($single));
3214 }
3215 elsif ($add_srcdir)
3216 {
3217 push (@newinputs, '$(top_srcdir)/' . $single);
3218 }
3219 }
3221 return @newinputs;
3222 }
3224 # Handle remaking and configure stuff.
3225 # We need the name of the input file, to do proper remaking rules.
3226 sub handle_configure
3227 {
3228 local ($local, $input, @secondary_inputs) = @_;
3230 local ($top_reldir);
3232 local ($input_base) = &basename ($input);
3233 local ($local_base) = &basename ($local);
3235 local ($amfile) = $input_base . '.am';
3236 # We know we can always add '.in' because it really should be an
3237 # error if the .in was missing originally.
3238 local ($infile) = '$(srcdir)/' . $input_base . '.in';
3239 local ($colon_infile);
3240 if ($local ne $input || @secondary_inputs)
3241 {
3242 $colon_infile = ':' . $input . '.in';
3243 }
3244 $colon_infile .= ':' . join (':', @secondary_inputs)
3245 if @secondary_inputs;
3247 local (@rewritten) = &rewrite_inputs_into_dependencies (1,
3248 @secondary_inputs);
3250 # This rule remakes the Makefile.in. Note use of
3251 # @MAINTAINER_MODE_TRUE@ forces us to abandon pretty-printing.
3252 # Sigh.
3253 $output_rules .= ($infile
3254 # NOTE perl 5.003 (with -w) gives a
3255 # uninitialized value error on the next line.
3256 # Don't know why.
3257 . ': '
3258 . ($seen_maint_mode ? "\@MAINTAINER_MODE_TRUE\@ " : '')
3259 . $amfile . ' '
3260 . '$(top_srcdir)/configure.in $(ACLOCAL_M4)'
3261 . ' ' . join (' ', @include_stack)
3262 . "\n"
3263 . "\tcd \$(top_srcdir) && \$(AUTOMAKE) "
3264 . ($cygnus_mode ? '--cygnus' : ('--' . $strictness_name))
3265 . ($cmdline_use_dependencies ? '' : ' --ignore-deps')
3266 . ' ' . $input . $colon_infile . "\n\n");
3268 # This rule remakes the Makefile.
3269 $output_rules .= ($local_base
3270 # NOTE: bogus uninit value error on next line;
3271 # see comment above.
3272 . ': '
3273 . $infile . ' '
3274 . join (' ', @rewritten)
3275 . ' $(top_builddir)/config.status'
3276 . "\n"
3277 . "\tcd \$(top_builddir) \\\n"
3278 . "\t && CONFIG_FILES="
3279 . (($relative_dir eq '.') ? '$@' : '$(subdir)/$@')
3280 . $colon_infile
3281 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
3282 . "\n\n");
3284 if ($relative_dir ne '.')
3285 {
3286 # In subdirectory.
3287 $top_reldir = '../';
3288 }
3289 else
3290 {
3291 &handle_aclocal_m4;
3292 $output_rules .= &file_contents ('remake');
3293 &examine_variable ('CONFIG_STATUS_DEPENDENCIES');
3294 &examine_variable ('CONFIGURE_DEPENDENCIES');
3295 $top_reldir = '';
3297 &push_dist_common ('acconfig.h')
3298 if -f 'acconfig.h';
3299 }
3301 # If we have a configure header, require it.
3302 local ($one_hdr);
3303 local (@local_fullnames) = @config_fullnames;
3304 local (@local_names) = @config_names;
3305 local ($hdr_index) = 0;
3306 local ($distclean_config) = '';
3307 foreach $one_hdr (@config_headers)
3308 {
3309 local ($one_fullname) = shift (@local_fullnames);
3310 local ($one_name) = shift (@local_names);
3311 $hdr_index += 1;
3312 local ($header_dir) = &dirname ($one_name);
3314 # If the header is in the current directory we want to build
3315 # the header here. Otherwise, if we're at the topmost
3316 # directory and the header's directory doesn't have a
3317 # Makefile, then we also want to build the header.
3318 if ($relative_dir eq $header_dir
3319 || ($relative_dir eq '.' && ! &is_make_dir ($header_dir)))
3320 {
3321 local ($ch_sans_dir, $cn_sans_dir, $stamp_dir);
3322 if ($relative_dir eq $header_dir)
3323 {
3324 $cn_sans_dir = &basename ($one_name);
3325 $stamp_dir = '';
3326 }
3327 else
3328 {
3329 $cn_sans_dir = $one_name;
3330 if ($header_dir eq '.')
3331 {
3332 $stamp_dir = '';
3333 }
3334 else
3335 {
3336 $stamp_dir = $header_dir . '/';
3337 }
3338 }
3340 # Compute relative path from directory holding output
3341 # header to directory holding input header. FIXME:
3342 # doesn't handle case where we have multiple inputs.
3343 if (&dirname ($one_hdr) eq $relative_dir)
3344 {
3345 $ch_sans_dir = &basename ($one_hdr);
3346 }
3347 else
3348 {
3349 local (@rel_out_path);
3350 # FIXME this chunk of code should be its own sub.
3351 # It is used elsewhere.
3352 foreach (split (/\//, $relative_dir))
3353 {
3354 next if $_ eq '' || $_ eq '.';
3355 if ($_ eq '..')
3356 {
3357 # FIXME: actually this is an error.
3358 pop @rel_out_path;
3359 }
3360 else
3361 {
3362 push (@rel_out_path, '..');
3363 }
3364 }
3365 if (@rel_out_path)
3366 {
3367 $ch_sans_dir = join ('/', @rel_out_path) . '/' . $one_hdr;
3368 }
3369 else
3370 {
3371 $ch_sans_dir = $one_hdr;
3372 }
3373 }
3375 &require_file_with_conf_line ($config_header_line,
3376 $FOREIGN, $ch_sans_dir);
3378 # Header defined and in this directory.
3379 local (@files);
3380 if (-f $one_name . '.top')
3381 {
3382 push (@files, "${cn_sans_dir}.top");
3383 }
3384 if (-f $one_name . '.bot')
3385 {
3386 push (@files, "${cn_sans_dir}.bot");
3387 }
3389 &push_dist_common (@files);
3391 # For now, acconfig.h can only appear in the top srcdir.
3392 if (-f 'acconfig.h')
3393 {
3394 if ($relative_dir eq '.')
3395 {
3396 push (@files, 'acconfig.h');
3397 }
3398 else
3399 {
3400 # Strange quoting because this gets fed through
3401 # Perl.
3402 push (@files, '\$(top_srcdir)/acconfig.h');
3403 }
3404 }
3406 local ($stamp_name) = 'stamp-h';
3407 $stamp_name .= "${hdr_index}" if scalar (@config_headers) > 1;
3409 local ($xform) = '';
3411 $xform = 's,\@FILES\@,' . join (' ', @files) . ',;';
3412 $xform .= 's,\@CONFIG_HEADER\@,' . "${cn_sans_dir}" . ',;';
3413 $xform .= 's,\@CONFIG_HEADER_IN\@,' . "${ch_sans_dir}" . ',;';
3414 $xform .= 's,\@CONFIG_HEADER_FULL\@,' . "${one_fullname}" . ',;';
3415 $xform .= 's,\@STAMP\@,' . "${stamp_dir}${stamp_name}" . ',g;';
3417 local ($out_dir) = &dirname ($ch_sans_dir);
3418 $xform .= 's,\@SRC_STAMP\@,' . "${out_dir}/${stamp_name}" . ',g;';
3419 $output_rules .= &file_contents_with_transform ($xform,
3420 'remake-hdr');
3422 &create ("${relative_dir}/${out_dir}/${stamp_name}.in");
3423 &require_file_with_conf_line ($config_header_line, $FOREIGN,
3424 "${out_dir}/${stamp_name}.in");
3426 $distclean_config .= ' ' if $distclean_config;
3427 $distclean_config .= $cn_sans_dir;
3428 }
3429 }
3431 if ($distclean_config)
3432 {
3433 $output_rules .= &file_contents_with_transform ('s,\@FILES\@,'
3434 . $distclean_config
3435 . ',;',
3436 'clean-hdr');
3437 push (@clean, 'hdr');
3438 &push_phony_cleaners ('hdr');
3439 }
3441 # Set location of mkinstalldirs.
3442 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
3443 {
3444 &define_variable ('mkinstalldirs', ('$(SHELL) ' . $config_aux_dir
3445 . '/mkinstalldirs'));
3446 }
3447 else
3448 {
3449 &define_variable ('mkinstalldirs',
3450 '$(SHELL) $(top_srcdir)/mkinstalldirs');
3451 }
3453 &am_line_error ('CONFIG_HEADER',
3454 "\`CONFIG_HEADER' is an anachronism; now determined from \`configure.in'")
3455 if &variable_defined ('CONFIG_HEADER');
3457 local ($one_name);
3458 local ($config_header) = '';
3459 foreach $one_name (@config_names)
3460 {
3461 # Generate CONFIG_HEADER define.
3462 local ($one_hdr);
3463 if ($relative_dir eq &dirname ($one_name))
3464 {
3465 $one_hdr = &basename ($one_name);
3466 }
3467 else
3468 {
3469 $one_hdr = "${top_builddir}/${one_name}";
3470 }
3472 $config_header .= ' ' if $config_header;
3473 $config_header .= $one_hdr;
3474 }
3475 if ($config_header)
3476 {
3477 &define_variable ("CONFIG_HEADER", $config_header);
3478 }
3480 # Now look for other files in this directory which must be remade
3481 # by config.status, and generate rules for them.
3482 local (@actual_other_files) = ();
3483 local ($file, $local);
3484 local (@inputs, @rewritten_inputs, $single);
3485 local ($need_rewritten);
3486 foreach $file (@other_input_files)
3487 {
3488 if ($file =~ /^([^:]*):(.*)$/)
3489 {
3490 # This is the ":" syntax of AC_OUTPUT.
3491 $file = $1;
3492 $local = &basename ($file);
3493 @inputs = split (':', $2);
3494 @rewritten_inputs = &rewrite_inputs_into_dependencies (1, @inputs);
3495 $need_rewritten = 1;
3496 }
3497 else
3498 {
3499 # Normal usage.
3500 $local = &basename ($file);
3501 @inputs = ($local . '.in');
3502 @rewritten_inputs =
3503 &rewrite_inputs_into_dependencies (1, $file . '.in');
3504 $need_rewritten = 0;
3505 }
3507 # Skip files not in this directory.
3508 next unless &dirname ($file) eq $relative_dir;
3510 # Skip any file that is an automake input.
3511 next if -f $file . '.am';
3513 # Some users have been tempted to put `stamp-h' in the
3514 # AC_OUTPUT line. This won't do the right thing, so we
3515 # explicitly fail here.
3516 if ($local eq 'stamp-h')
3517 {
3518 # FIXME: allow real filename.
3519 &am_conf_error ('configure.in', $ac_output_line,
3520 'stamp-h should not appear in AC_OUTPUT');
3521 next;
3522 }
3524 $output_rules .= ($local . ': '
3525 . '$(top_builddir)/config.status '
3526 . join (' ', @rewritten_inputs) . "\n"
3527 . "\t"
3528 . 'cd $(top_builddir) && CONFIG_FILES='
3529 . ($relative_dir eq '.' ? '' : '$(subdir)/')
3530 . '$@' . ($need_rewritten
3531 ? (':' . join (':', @inputs))
3532 : '')
3533 . ' CONFIG_HEADERS= $(SHELL) ./config.status'
3534 . "\n");
3535 &push_dist_common (@inputs);
3536 push (@actual_other_files, $local);
3538 # Require all input files.
3539 &require_file_with_conf_line ($ac_output_line, $FOREIGN,
3540 &rewrite_inputs_into_dependencies (0, @inputs));
3541 }
3543 # These files get removed by "make clean".
3544 &define_pretty_variable ('CONFIG_CLEAN_FILES', '', @actual_other_files);
3545 }
3547 # Handle C headers.
3548 sub handle_headers
3549 {
3550 local (@r);
3551 @r = &am_install_var ('-defaultdist', 'header', 'HEADERS', 'include',
3552 'oldinclude', 'pkginclude',
3553 'noinst', 'check');
3554 foreach (@r)
3555 {
3556 next unless /\.(.*)$/;
3557 &saw_extension ($1);
3558 }
3559 }
3561 sub handle_gettext
3562 {
3563 return if ! $seen_gettext || $relative_dir ne '.';
3565 if (! &variable_defined ('SUBDIRS'))
3566 {
3567 &am_conf_error
3568 ("AM_GNU_GETTEXT in configure.in but SUBDIRS not defined");
3569 return;
3570 }
3572 &require_file_with_conf_line ($ac_gettext_line, $GNU, 'ABOUT-NLS');
3574 if (&variable_defined ('SUBDIRS'))
3575 {
3576 &am_line_error
3577 ('SUBDIRS',
3578 "AM_GNU_GETTEXT in configure.in but \`po' not in SUBDIRS")
3579 if $contents{'SUBDIRS'} !~ /\bpo\b/;
3580 &am_line_error
3581 ('SUBDIRS',
3582 "AM_GNU_GETTEXT in configure.in but \`intl' not in SUBDIRS")
3583 if $contents{'SUBDIRS'} !~ /\bintl\b/;
3584 }
3586 # Ensure that each language in ALL_LINGUAS has a .po file, and
3587 # each po file is mentioned in ALL_LINGUAS.
3588 if ($seen_linguas)
3589 {
3590 local (%linguas) = ();
3591 grep ($linguas{$_} = 1, split (' ', $all_linguas));
3593 foreach (<po/*.po>)
3594 {
3595 s/^po\///;
3596 s/\.po$//;
3598 &am_line_error ($all_linguas_line,
3599 ("po/$_.po exists but \`$_' not in \`ALL_LINGUAS'"))
3600 if ! $linguas{$_};
3601 }
3603 foreach (keys %linguas)
3604 {
3605 &am_line_error ($all_linguas_line,
3606 "$_ in \`ALL_LINGUAS' but po/$_.po does not exist")
3607 if ! -f "po/$_.po";
3608 }
3609 }
3610 else
3611 {
3612 &am_error ("AM_GNU_GETTEXT in configure.in but \`ALL_LINGUAS' not defined");
3613 }
3614 }
3616 # Handle footer elements.
3617 sub handle_footer
3618 {
3619 if ($contents{'SOURCES'})
3620 {
3621 # NOTE don't use define_pretty_variable here, because
3622 # $contents{...} is already defined.
3623 $output_vars .= 'SOURCES = ' . $contents{'SOURCES'} . "\n";
3624 }
3625 if ($contents{'OBJECTS'})
3626 {
3627 # NOTE don't use define_pretty_variable here, because
3628 # $contents{...} is already defined.
3629 $output_vars .= 'OBJECTS = ' . $contents{'OBJECTS'} . "\n";
3630 }
3631 if ($contents{'SOURCES'} || $contents{'OBJECTS'})
3632 {
3633 $output_vars .= "\n";
3634 }
3636 if (&variable_defined ('SUFFIXES'))
3637 {
3638 # Push actual suffixes, and not $(SUFFIXES). Some versions of
3639 # make do not like variable substitutions on the .SUFFIXES
3640 # line.
3641 push (@suffixes, &variable_value_as_list ('SUFFIXES', ''));
3642 }
3643 if (&target_defined ('.SUFFIXES'))
3644 {
3645 &am_line_error ('.SUFFIXES',
3646 "use variable \`SUFFIXES', not target \`.SUFFIXES'");
3647 }
3649 # Note: AIX 4.1 /bin/make will fail if any suffix rule appears
3650 # before .SUFFIXES. So we make sure that .SUFFIXES appears before
3651 # anything else, by sticking it right after the default: target.
3652 $output_header .= ".SUFFIXES:\n";
3653 if (@suffixes)
3654 {
3655 # Make sure suffixes has unique elements. Sort them to ensure
3656 # the output remains consistent.
3657 local (%suffixes);
3659 grep ($suffixes{$_} = 1, @suffixes);
3661 $output_header .= (".SUFFIXES: "
3662 . join (' ', sort keys %suffixes)
3663 . "\n");
3664 }
3665 $output_trailer .= &file_contents ('footer');
3666 }
3668 # Deal with installdirs target.
3669 sub handle_installdirs
3670 {
3671 # GNU Makefile standards recommend this.
3672 if ($recursive_install)
3673 {
3674 # We create a separate `-am' target so that the -recursive
3675 # rule will work correctly.
3676 $output_rules .= ("installdirs: installdirs-recursive\n"
3677 . "installdirs-am:\n");
3678 push (@phony, 'installdirs-am');
3679 }
3680 else
3681 {
3682 $output_rules .= "installdirs:\n";
3683 }
3684 push (@phony, 'installdirs');
3685 if (@installdirs)
3686 {
3687 &pretty_print_rule ("\t" . '$(mkinstalldirs) ', "\t\t",
3688 @installdirs);
3689 }
3690 $output_rules .= "\n";
3691 }
3693 # There are several targets which need to be merged. This is because
3694 # their complete definition is compiled from many parts. Note that we
3695 # avoid double colon rules, otherwise we'd use them instead.
3696 sub handle_merge_targets
3697 {
3698 local ($makefile) = @_;
3700 # There are a few install-related variables that you should not define.
3701 local ($var);
3702 foreach $var ('PRE_INSTALL', 'POST_INSTALL', 'NORMAL_INSTALL')
3703 {
3704 if (&variable_defined ($var))
3705 {
3706 &am_line_error ($var, "\`$var' should not be defined");
3707 }
3708 }
3710 # Put this at the beginning for the sake of non-GNU makes. This
3711 # is still wrong if these makes can run parallel jobs. But it is
3712 # right enough.
3713 unshift (@all, &basename ($makefile));
3715 local ($one_name);
3716 foreach $one_name (@config_names)
3717 {
3718 push (@all, &basename ($one_name))
3719 if &dirname ($one_name) eq $relative_dir;
3720 }
3722 &do_one_merge_target ('info', @info);
3723 &do_one_merge_target ('dvi', @dvi);
3724 &do_check_merge_target;
3725 &do_one_merge_target ('installcheck', @installcheck);
3727 if (defined $options{'no-installinfo'})
3728 {
3729 &do_one_merge_target ('install-info', '');
3730 }
3731 elsif (&target_defined ('install-info-local'))
3732 {
3733 &am_line_error ('install-info-local',
3734 "\`install-info-local' target defined but \`no-installinfo' option not in use");
3735 }
3737 local ($utarg);
3738 foreach $utarg ('uninstall-data-local', 'uninstall-data-hook',
3739 'uninstall-exec-local', 'uninstall-exec-hook')
3740 {
3741 if (&target_defined ($utarg))
3742 {
3743 local ($x);
3744 ($x = $utarg) =~ s/(data|exec)-//;
3745 &am_line_error ($utarg, "use \`$x', not \`$utarg'");
3746 }
3747 }
3749 if (&target_defined ('install-local'))
3750 {
3751 &am_line_error ('install-local',
3752 "use \`install-data-local' or \`install-exec-local', not \`install-local'");
3753 }
3755 if (@all)
3756 {
3757 local ($one_name);
3758 local ($local_headers) = '';
3759 foreach $one_name (@config_names)
3760 {
3761 if (&dirname ($one_name) eq $relative_dir)
3762 {
3763 $local_headers .= ' ' if $local_headers;
3764 $local_headers .= &basename ($one_name);
3765 }
3766 }
3767 if ($local_headers)
3768 {
3769 # This is kind of a hack, but I couldn't see a better way
3770 # to handle it. In this particular case, we need to make
3771 # sure config.h is built before we recurse. We can't do
3772 # this by changing the order of dependencies to the "all"
3773 # because that breaks when using parallel makes. Instead
3774 # we handle things explicitly.
3775 $output_rules .= ("all-recursive-am: ${local_headers}"
3776 . "\n\t"
3777 . '$(MAKE) $(AM_MAKEFLAGS)'
3778 . " all-recursive"
3779 . "\n\n");
3780 $all_target = 'all-recursive-am';
3781 push (@phony, 'all-recursive-am');
3782 }
3783 }
3785 # Print definitions users can use.
3786 &do_one_merge_target ('install-exec', @install_exec);
3787 $output_rules .= "\n";
3789 &do_one_merge_target ('install-data', @install_data);
3790 $output_rules .= "\n";
3792 &do_one_merge_target ('install', 'all-am');
3793 &do_one_merge_target ('uninstall', @uninstall);
3795 &do_one_merge_target ('all', @all);
3797 # Generate the new 'install-strip' target. We can't just set
3798 # INSTALL_PROGRAM because that might be a relative path.
3799 $output_rules .= ("install-strip:\n\t"
3800 . '$(MAKE) $(AM_MAKEFLAGS) INSTALL_STRIP_FLAG=-s install'
3801 . "\n");
3802 push (@phony, 'install-strip');
3803 }
3805 # Helper for handle_merge_targets. Note that handle_merge_targets
3806 # relies on the fact that this doesn't add an extra \n at the end.
3807 sub do_one_merge_target
3808 {
3809 local ($name, @values) = @_;
3811 if (&target_defined ($name . '-local'))
3812 {
3813 # User defined local form of target. So include it.
3814 push (@values, $name . '-local');
3815 push (@phony, $name . '-local');
3816 }
3818 &pretty_print_rule ($name . "-am:", "\t\t", @values);
3819 if ($name eq 'install')
3820 {
3821 # Special-case `install-am' to run install-exec-am and
3822 # install-data-am after all-am is built.
3823 &pretty_print_rule ("\t\@\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3824 'install-exec-am', 'install-data-am');
3825 }
3826 elsif ($name eq 'install-exec' && &target_defined ('install-exec-hook'))
3827 {
3828 $output_rules .= ("\t\@\$(NORMAL_INSTALL)\n"
3829 . "\t" . '$(MAKE) $(AM_MAKEFLAGS) install-exec-hook'
3830 . "\n");
3831 }
3832 elsif ($name eq 'install-data' && &target_defined ('install-data-hook'))
3833 {
3834 $output_rules .= ("\t\@\$(NORMAL_INSTALL)\n"
3835 . "\t" . '$(MAKE) $(AM_MAKEFLAGS) install-data-hook'
3836 . "\n");
3837 }
3839 local ($lname) = $name . ($recursive_install ? '-recursive' : '-am');
3840 local ($tname) = $name;
3841 # To understand this special case, see handle_merge_targets.
3842 if ($name eq 'all')
3843 {
3844 $tname = 'all-redirect';
3845 $lname = $all_target if $recursive_install;
3846 push (@phony, 'all-redirect');
3847 $output_all = "all: all-redirect\n";
3848 }
3849 &pretty_print_rule ($tname . ":", "\t\t", $lname);
3850 push (@phony, $name . '-am', $name);
3851 }
3853 # Handle check merge target specially.
3854 sub do_check_merge_target
3855 {
3856 if (&target_defined ('check-local'))
3857 {
3858 # User defined local form of target. So include it.
3859 push (@check_tests, 'check-local');
3860 push (@phony, 'check-local');
3861 }
3863 # In --cygnus mode, check doesn't depend on all.
3864 if ($cygnus_mode)
3865 {
3866 # Just run the local check rules.
3867 &pretty_print_rule ('check-am:', "\t\t", @check);
3868 }
3869 else
3870 {
3871 # The check target must depend on the local equivalent of
3872 # `all', to ensure all the primary targets are built. Then it
3873 # must build the local check rules.
3874 $output_rules .= "check-am: all-am\n";
3875 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3876 @check)
3877 if @check;
3878 }
3879 &pretty_print_rule ("\t\$(MAKE) \$(AM_MAKEFLAGS)", "\t ",
3880 @check_tests)
3881 if @check_tests;
3883 push (@phony, 'check', 'check-am');
3884 $output_rules .= ("check: "
3885 . ($recursive_install ? 'check-recursive' : 'check-am')
3886 . "\n");
3887 }
3889 # Handle all 'clean' targets.
3890 sub handle_clean
3891 {
3892 local ($xform) = '';
3893 local ($name);
3895 # Don't include `MAINTAINER'; it is handled specially below.
3896 foreach $name ('MOSTLY', '', 'DIST')
3897 {
3898 if (! &variable_defined ($name . 'CLEANFILES'))
3899 {
3900 $xform .= 's/^' . $name . 'CLEAN.*$//;';
3901 }
3902 else
3903 {
3904 $xform .= 's/^' . $name . 'CLEAN//;';
3905 }
3906 }
3908 # Built sources are automatically removed by maintainer-clean.
3909 push (@maintainer_clean_files, '\$(BUILT_SOURCES)')
3910 if &variable_defined ('BUILT_SOURCES');
3911 push (@maintainer_clean_files, '\$(MAINTAINERCLEANFILES)')
3912 if &variable_defined ('MAINTAINERCLEANFILES');
3913 if (! @maintainer_clean_files)
3914 {
3915 $xform .= 's/^MAINTAINERCLEAN.*$//;';
3916 }
3917 else
3918 {
3919 $xform .= ('s/^MAINTAINERCLEAN//;'
3920 # Join with no space to avoid spurious `test -z'
3921 # success at runtime.
3922 . 's,\@MCFILES\@,' . join ('', @maintainer_clean_files)
3923 . ',;'
3924 # A space is required in the join here.
3925 . 's,\@MFILES\@,' . join (' ', @maintainer_clean_files)
3926 . ',;');
3927 }
3929 $output_rules .= &file_contents_with_transform ($xform, 'clean');
3931 push (@clean, 'generic');
3932 &push_phony_cleaners ('generic');
3934 &do_one_clean_target ('clean', 'mostly', '', @clean);
3935 &do_one_clean_target ('clean', '', 'mostly', @clean);
3936 &do_one_clean_target ('clean', 'dist', '', @clean);
3937 &do_one_clean_target ('clean', 'maintainer-', 'dist', @clean);
3939 push (@phony, 'clean', 'mostlyclean', 'distclean', 'maintainer-clean');
3940 }
3942 # Helper for handle_clean.
3943 sub do_one_clean_target
3944 {
3945 local ($target, $name, $last_name, @deps) = @_;
3947 # Change each dependency `BLARG' into `clean-BLARG'.
3948 grep (($_ = $name . 'clean-' . $_) && 0, @deps);
3950 # Push the previous clean target. There is no previous clean
3951 # target if we're doing mostlyclean.
3952 push (@deps, $last_name . $target . '-am')
3953 unless $name eq 'mostly';
3955 # If a -local version of the rule is given, add it to the list.
3956 if (&target_defined ($name . $target . '-local'))
3957 {
3958 push (@deps, $name . $target . '-local');
3959 }
3961 # Print the target and the dependencies.
3962 &pretty_print_rule ($name . $target . "-am: ", "\t\t", @deps);
3964 # FIXME: shouldn't we really print these messages before running
3965 # the dependencies?
3966 if ($name . $target eq 'maintainer-clean')
3967 {
3968 # Print a special warning.
3969 $output_rules .=
3970 ("\t\@echo \"This command is intended for maintainers to use;\"\n"
3971 . "\t\@echo \"it deletes files that may require special "
3972 . "tools to rebuild.\"\n");
3973 }
3974 elsif ($name . $target eq 'distclean')
3975 {
3976 $output_rules .= "\t-rm -f libtool\n" if $seen_libtool;
3977 }
3978 $output_rules .= "\n";
3980 # Now generate the actual clean target.
3981 $output_rules .= ($name . $target . ": " . $name . $target
3982 . ($recursive_install ? '-recursive' : '-am')
3983 . "\n");
3985 # We special-case config.status here. If we do it as part of the
3986 # normal clean processing for this directory, then it might be
3987 # removed before some subdir is cleaned. However, that subdir's
3988 # Makefile depends on config.status.
3989 if (($name . $target eq 'maintainer-clean'
3990 || $name . $target eq 'distclean')
3991 && $relative_dir eq '.')
3992 {
3993 $output_rules .= "\t-rm -f config.status\n";
3994 }
3995 $output_rules .= "\n";
3996 }
3998 # Handle .PHONY target.
3999 sub handle_phony
4000 {
4001 &pretty_print_rule ('.PHONY:', "", @phony);
4002 $output_rules .= "\n";
4003 }
4005 # Handle TESTS variable and other checks.
4006 sub handle_tests
4007 {
4008 if (defined $options{'dejagnu'})
4009 {
4010 push (@check_tests, 'check-DEJAGNU');
4011 push (@phony, 'check-DEJAGNU');
4013 local ($xform);
4014 if ($cygnus_mode)
4015 {
4016 $xform = 's/^CYGNUS//;';
4017 }
4018 else
4019 {
4020 $xform = 's/^CYGNUS.*$//;';
4021 }
4022 $output_rules .= &file_contents_with_transform ($xform, 'dejagnu');
4024 # In Cygnus mode, these are found in the build tree.
4025 # Otherwise they are looked for in $PATH.
4026 &define_program_variable ('EXPECT', 'build', 'expect', 'expect');
4027 &define_program_variable ('RUNTEST', 'src', 'dejagnu', 'runtest');
4029 # Only create site.exp rule if user hasn't already written
4030 # one.
4031 if (! &target_defined ('site.exp'))
4032 {
4033 # Note that in the rule we don't directly generate
4034 # site.exp to avoid the possibility of a corrupted
4035 # site.exp if make is interrupted. Jim Meyering has some
4036 # useful text on this topic.
4037 $output_rules .= ("site.exp: Makefile\n"
4038 . "\t\@echo 'Making a new site.exp file...'\n"
4039 . "\t\@test ! -f site.bak || rm -f site.bak\n"
4040 . "\t\@echo '## these variables are automatically generated by make ##' > \$\@-t\n"
4041 . "\t\@echo '# Do not edit here. If you wish to override these values' >> \$\@-t\n"
4042 . "\t\@echo '# edit the last section' >> \$\@-t\n"
4043 . "\t\@echo 'set tool \$(DEJATOOL)' >> \$\@-t\n"
4044 . "\t\@echo 'set srcdir \$(srcdir)' >> \$\@-t\n"
4045 . "\t\@echo 'set objdir' \`pwd\` >> \$\@-t\n");
4047 # Extra stuff for AC_CANONICAL_*
4048 local (@whatlist) = ();
4049 if ($seen_canonical)
4050 {
4051 push (@whatlist, 'host');
4052 }
4054 # Extra stuff only for AC_CANONICAL_SYSTEM.
4055 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
4056 {
4057 push (@whatlist, 'target', 'build');
4058 }
4060 local ($c1, $c2);
4061 foreach $c1 (@whatlist)
4062 {
4063 foreach $c2 ('alias', 'triplet')
4064 {
4065 $output_rules .= "\t\@echo 'set ${c1}_${c2} \$(${c1}_${c2})' >> \$\@-t\n";
4066 }
4067 }
4069 $output_rules .= ("\t\@echo '## All variables above are generated by configure. Do Not Edit ##' >> \$\@-t\n"
4070 . "\t\@test ! -f site.exp || sed '1,/^## All variables above are.*##/ d' site.exp >> \$\@-t\n"
4071 . "\t\@test ! -f site.exp || mv site.exp site.bak\n"
4072 . "\t\@mv \$\@-t site.exp\n");
4073 }
4074 }
4075 else
4076 {
4077 local ($c);
4078 foreach $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
4079 {
4080 if (&variable_defined ($c))
4081 {
4082 &am_line_error ($c, "\`$c' defined but \`dejagnu' not in \`AUTOMAKE_OPTIONS'");
4083 }
4084 }
4085 }
4087 if (&variable_defined ('TESTS'))
4088 {
4089 push (@check_tests, 'check-TESTS');
4090 push (@phony, 'check-TESTS');
4092 # Note: Solaris 2.7 seems to expand TESTS using VPATH. That's
4093 # why we also try `dir='
4094 $output_rules .= 'check-TESTS: $(TESTS)
4095 @failed=0; all=0; xfail=0; xpass=0; \\
4096 srcdir=$(srcdir); export srcdir; \\
4097 list=' . "'\$(TESTS)'; \\" . '
4098 if test -n "$$list"; then \\
4099 for tst in $$list; do \\
4100 if test -f ./$$tst; then dir=./; \\
4101 elif test -f $$tst; then dir=; \\
4102 else dir="$(srcdir)/"; fi; \\
4103 if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \\
4104 all=`expr $$all + 1`; \\
4105 case " $(XFAIL_TESTS) " in \\
4106 *" $$tst "*) \\
4107 xpass=`expr $$xpass + 1`; \\
4108 failed=`expr $$failed + 1`; \\
4109 echo "XPASS: $$tst"; \\
4110 ;; \\
4111 *) \\
4112 echo "PASS: $$tst"; \\
4113 ;; \\
4114 esac; \\
4115 elif test $$? -ne 77; then \\
4116 all=`expr $$all + 1`; \\
4117 case " $(XFAIL_TESTS) " in \\
4118 *" $$tst "*) \\
4119 xfail=`expr $$xfail + 1`; \\
4120 echo "XFAIL: $$tst"; \\
4121 ;; \\
4122 *) \\
4123 failed=`expr $$failed + 1`; \\
4124 echo "FAIL: $$tst"; \\
4125 ;; \\
4126 esac; \\
4127 fi; \\
4128 done; \\
4129 if test "$$failed" -eq 0; then \\
4130 if test "$$xfail" -eq 0; then \\
4131 banner="All $$all tests passed"; \\
4132 else \\
4133 banner="All $$all tests behaved as expected ($$xfail expected failures)"; \\
4134 fi; \\
4135 else \\
4136 if test "$$xpass" -eq 0; then \\
4137 banner="$$failed of $$all tests failed"; \\
4138 else \\
4139 banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \\
4140 fi; \\
4141 fi; \\
4142 dashes=`echo "$$banner" | sed s/./=/g`; \\
4143 echo "$$dashes"; \\
4144 echo "$$banner"; \\
4145 echo "$$dashes"; \\
4146 test "$$failed" -eq 0; \\
4147 fi
4148 ';
4149 }
4150 }
4152 # Handle Emacs Lisp.
4153 sub handle_emacs_lisp
4154 {
4155 local (@elfiles) = &am_install_var ('-candist', 'lisp', 'LISP',
4156 'lisp', 'noinst');
4158 if (@elfiles)
4159 {
4160 # Found some lisp.
4161 &define_configure_variable ('lispdir');
4162 &define_configure_variable ('EMACS');
4163 $output_rules .= (".el.elc:\n"
4164 . "\t\@echo 'WARNING: Warnings can be ignored. :-)'\n"
4165 . "\tif test \$(EMACS) != no; then \\\n"
4166 . "\t EMACS=\$(EMACS) \$(SHELL) \$(srcdir)/elisp-comp \$<; \\\n"
4167 . "\tfi\n");
4168 push (@suffixes, '.el', '.elc');
4170 # Generate .elc files.
4171 grep ($_ .= 'c', @elfiles);
4172 &define_pretty_variable ('ELCFILES', '', @elfiles);
4174 $output_rules .= &file_contents ('lisp-clean');
4175 push (@clean, 'lisp');
4176 &push_phony_cleaners ('lisp');
4178 push (@all, '$(ELCFILES)');
4180 local ($varname);
4181 if (&variable_defined ('lisp_LISP'))
4182 {
4183 $varname = 'lisp_LISP';
4184 &am_error ("\`lisp_LISP' defined but \`AM_PATH_LISPDIR' not in \`configure.in'")
4185 if ! $seen_lispdir;
4186 }
4187 else
4188 {
4189 $varname = 'noinst_LISP';
4190 }
4192 &require_file_with_line ($varname, $FOREIGN, 'elisp-comp');
4193 }
4194 }
4196 # Handle Python
4197 sub handle_python
4198 {
4199 local (@pyfiles) = &am_install_var ('-defaultdist', 'python', 'PYTHON',
4200 'python', 'noinst');
4201 return if ! @pyfiles;
4203 # Found some python.
4204 &define_configure_variable ('pythondir');
4205 &define_configure_variable ('PYTHON');
4207 $output_rules .= &file_contents ('python-clean');
4208 push (@clean, 'python');
4210 &am_error ("\`python_PYTHON' defined but \`AM_CHECK_PYTHON' not in \`configure.in'")
4211 if ! $seen_pythondir && &variable_defined ('python_PYTHON');
4213 if ($config_aux_dir eq '.' || $config_aux_dir eq '')
4214 {
4215 &define_variable ('py_compile', '$(top_srcdir)/py-compile');
4216 }
4217 else
4218 {
4219 &define_variable ('py_compile', $config_aux_dir . '/py-compile');
4220 }
4221 }
4223 # Handle Java.
4224 sub handle_java
4225 {
4226 local (@sourcelist) = &am_install_var ('-candist', '-clean',
4227 'java', 'JAVA',
4228 'java', 'noinst', 'check');
4229 return if ! @sourcelist;
4231 &define_variable ('JAVAC', 'javac');
4232 &define_variable ('JAVACFLAGS', '');
4233 &define_variable ('CLASSPATH_ENV',
4234 'CLASSPATH=$(JAVAROOT):$(srcdir)/$(JAVAROOT):$$CLASSPATH');
4235 &define_variable ('JAVAROOT', '$(top_builddir)');
4237 local (%valid) = &am_primary_prefixes ('JAVA', 1,
4238 'java', 'noinst', 'check');
4240 local ($dir, $curs);
4241 foreach $curs (keys %valid)
4242 {
4243 if (! &variable_defined ($curs . '_JAVA') || $curs eq 'noinst'
4244 || $curs eq 'EXTRA')
4245 {
4246 next;
4247 }
4249 if (defined $dir)
4250 {
4251 &am_line_error ($curs . '_JAVA',
4252 "multiple _JAVA primaries in use");
4253 }
4254 $dir = $curs;
4255 }
4257 $output_rules .= ('class' . $dir . '.stamp: $(' . $dir . '_JAVA)' . "\n"
4258 . "\t" . '$(CLASSPATH_ENV) $(JAVAC) -d $(JAVAROOT) '
4259 . '$(JAVACFLAGS) $?' . "\n"
4260 . "\t" . 'echo timestamp > class' . $dir . '.stamp'
4261 . "\n");
4262 push (@all, 'class' . $dir . '.stamp');
4263 &push_dist_common ('$(' . $dir . '_JAVA)');
4264 }
4266 # Handle some of the minor options.
4267 sub handle_minor_options
4268 {
4269 if (defined $options{'readme-alpha'})
4270 {
4271 if ($relative_dir eq '.')
4272 {
4273 if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
4274 {
4275 # FIXME: allow real filename.
4276 &am_conf_line_error ('configure.in',
4277 $package_version_line,
4278 "version \`$package_version' doesn't follow Gnits standards");
4279 }
4280 elsif (defined $1 && -f 'README-alpha')
4281 {
4282 # This means we have an alpha release. See
4283 # GNITS_VERSION_PATTERN for details.
4284 &require_file ($FOREIGN, 'README-alpha');
4285 }
4286 }
4287 }
4288 }
4290 ################################################################
4292 # Scan one file for interesting things. Subroutine of scan_configure.
4293 sub scan_one_configure_file
4294 {
4295 local ($filename) = @_;
4296 local (*CONFIGURE);
4298 open (CONFIGURE, $filename)
4299 || die "automake: couldn't open \`$filename': $!\n";
4300 print "automake: reading $filename\n" if $verbose;
4302 while (<CONFIGURE>)
4303 {
4304 # Remove comments from current line.
4305 s/\bdnl\b.*$//;
4306 s/\#.*$//;
4308 # Skip macro definitions. Otherwise we might be confused into
4309 # thinking that a macro that was only defined was actually
4310 # used.
4311 next if /AC_DEFUN/;
4313 # Follow includes. This is a weirdness commonly in use at
4314 # Cygnus and hopefully nowhere else.
4315 if (/sinclude\((.*)\)/ && -f $1)
4316 {
4317 &scan_one_configure_file ($1);
4318 }
4320 # Populate libobjs array.
4321 if (/AC_FUNC_ALLOCA/)
4322 {
4323 $libsources{'alloca.c'} = 1;
4324 }
4325 elsif (/AC_FUNC_GETLOADAVG/)
4326 {
4327 $libsources{'getloadavg.c'} = 1;
4328 }
4329 elsif (/AC_FUNC_MEMCMP/)
4330 {
4331 $libsources{'memcmp.c'} = 1;
4332 }
4333 elsif (/AC_STRUCT_ST_BLOCKS/)
4334 {
4335 $libsources{'fileblocks.c'} = 1;
4336 }
4337 elsif (/A[CM]_REPLACE_GNU_GETOPT/)
4338 {
4339 $libsources{'getopt.c'} = 1;
4340 $libsources{'getopt1.c'} = 1;
4341 }
4342 elsif (/AM_FUNC_STRTOD/)
4343 {
4344 $libsources{'strtod.c'} = 1;
4345 }
4346 elsif (/AM_WITH_REGEX/)
4347 {
4348 $libsources{'rx.c'} = 1;
4349 $libsources{'rx.h'} = 1;
4350 $libsources{'regex.c'} = 1;
4351 $libsources{'regex.h'} = 1;
4352 $omit_dependencies{'rx.h'} = 1;
4353 $omit_dependencies{'regex.h'} = 1;
4354 }
4355 elsif (/AC_FUNC_MKTIME/)
4356 {
4357 $libsources{'mktime.c'} = 1;
4358 }
4359 elsif (/AM_FUNC_ERROR_AT_LINE/)
4360 {
4361 $libsources{'error.c'} = 1;
4362 $libsources{'error.h'} = 1;
4363 }
4364 elsif (/AM_FUNC_OBSTACK/)
4365 {
4366 $libsources{'obstack.c'} = 1;
4367 $libsources{'obstack.h'} = 1;
4368 }
4369 elsif (/LIBOBJS="(.*)\s+\$LIBOBJS"/
4370 || /LIBOBJS="\$LIBOBJS\s+(.*)"/)
4371 {
4372 foreach $libobj_iter (split (' ', $1))
4373 {
4374 if ($libobj_iter =~ /^(.*)\.o(bj)?$/
4375 || $libobj_iter =~ /^(.*)\.\$ac_objext$/
4376 || $libobj_iter =~ /^(.*)\.\$\{ac_objext\}$/)
4377 {
4378 $libsources{$1 . '.c'} = 1;
4379 }
4380 }
4381 }
4382 elsif (/AC_LIBOBJ\(([^)]+)\)/)
4383 {
4384 $libsources{"$1.c"} = 1;
4385 }
4387 if (! $in_ac_replace && s/AC_REPLACE_FUNCS\s*\(\[?//)
4388 {
4389 $in_ac_replace = 1;
4390 }
4391 if ($in_ac_replace)
4392 {
4393 $in_ac_replace = 0 if s/[\]\)].*$//;
4394 # Remove trailing backslash.
4395 s/\\$//;
4396 foreach (split)
4397 {
4398 # Need to skip empty elements for Perl 4.
4399 next if $_ eq '';
4400 $libsources{$_ . '.c'} = 1;
4401 }
4402 }
4404 if (/$obsolete_rx/o)
4405 {
4406 local ($hint) = '';
4407 if ($obsolete_macros{$1} ne '')
4408 {
4409 $hint = '; ' . $obsolete_macros{$1};
4410 }
4411 &am_conf_line_error ($filename, $., "\`$1' is obsolete$hint");
4412 }
4414 # Process the AC_OUTPUT and AC_CONFIG_FILES macros.
4415 if (! $in_ac_output && s/AC_(OUTPUT|CONFIG_FILES)\s*\(\[?//)
4416 {
4417 $in_ac_output = 1;
4418 $ac_output_line = $.;
4419 }
4420 if ($in_ac_output)
4421 {
4422 local ($closing) = 0;
4423 if (s/[\]\),].*$//)
4424 {
4425 $in_ac_output = 0;
4426 $closing = 1;
4427 }
4429 # Look at potential Makefile.am's.
4430 foreach (split)
4431 {
4432 # Must skip empty string for Perl 4.
4433 next if $_ eq "\\" || $_ eq '';
4435 # Handle $local:$input syntax. Note that we ignore
4436 # every input file past the first, though we keep
4437 # those around for later.
4438 local ($local, $input, @rest) = split (/:/);
4439 if (! $input)
4440 {
4441 $input = $local;
4442 }
4443 else
4444 {
4445 # FIXME: should be error if .in is missing.
4446 $input =~ s/\.in$//;
4447 }
4449 if (-f $input . '.am')
4450 {
4451 # We have a file that automake should generate.
4452 push (@make_input_list, $input);
4453 $make_list{$input} = join (':', ($local, @rest));
4454 }
4455 else
4456 {
4457 # We have a file that automake should cause to be
4458 # rebuilt, but shouldn't generate itself.
4459 push (@other_input_files, $_);
4460 }
4461 }
4463 if ($closing && @make_input_list == 0 && @other_input_files == 0)
4464 {
4465 &am_conf_line_error ($filename, $ac_output_line,
4466 "No files mentioned in \`AC_OUTPUT'");
4467 exit 1;
4468 }
4469 }
4471 if (/$AC_CONFIG_AUX_DIR_PATTERN/o)
4472 {
4473 @config_aux_path = $1;
4474 }
4476 # Check for ansi2knr.
4477 $am_c_prototypes = 1 if /AM_C_PROTOTYPES/;
4479 # Check for exe extension stuff.
4480 if (/AC_EXEEXT/)
4481 {
4482 $seen_exeext = 1;
4483 $configure_vars{'EXEEXT'} = $filename . ':' . $.;
4484 }
4486 if (/AC_OBJEXT/)
4487 {
4488 $seen_objext = 1;
4489 $configure_vars{'OBJEXT'} = $filename . ':' . $.;
4490 }
4492 # Check for `-c -o' code.
4493 $seen_cc_c_o = 1 if /AM_PROG_CC_C_O/;
4495 # Check for NLS support.
4496 if (/AM_GNU_GETTEXT/)
4497 {
4498 $seen_gettext = 1;
4499 $ac_gettext_line = $.;
4500 $omit_dependencies{'libintl.h'} = 1;
4501 }
4503 # Look for ALL_LINGUAS.
4504 if (/ALL_LINGUAS="(.*)"$/ || /ALL_LINGUAS=(.*)$/)
4505 {
4506 $seen_linguas = 1;
4507 $all_linguas = $1;
4508 $all_linguas_line = $.;
4509 }
4511 # Handle configuration headers. A config header of `[$1]'
4512 # means we are actually scanning AM_CONFIG_HEADER from
4513 # aclocal.m4.
4514 if (/A([CM])_CONFIG_HEADERS?\s*\((.*)\)/
4515 && $2 ne '[$1]')
4516 {
4517 &am_conf_line_error
4518 ($filename, $., "\`automake requires \`AM_CONFIG_HEADER', not \`AC_CONFIG_HEADER'")
4519 if $1 eq 'C';
4521 $config_header_line = $.;
4522 local ($one_hdr);
4523 foreach $one_hdr (split (' ', $2))
4524 {
4525 push (@config_fullnames, $one_hdr);
4526 if ($one_hdr =~ /^([^:]+):(.+)$/)
4527 {
4528 push (@config_names, $1);
4529 push (@config_headers, $2);
4530 }
4531 else
4532 {
4533 push (@config_names, $one_hdr);
4534 push (@config_headers, $one_hdr . '.in');
4535 }
4536 }
4537 }
4539 # Handle AC_CANONICAL_*. Always allow upgrading to
4540 # AC_CANONICAL_SYSTEM, but never downgrading.
4541 $seen_canonical = $AC_CANONICAL_HOST
4542 if ! $seen_canonical
4543 && (/AC_CANONICAL_HOST/ || /AC_CHECK_TOOL/);
4544 $seen_canonical = $AC_CANONICAL_SYSTEM if /AC_CANONICAL_SYSTEM/;
4546 $seen_path_xtra = 1 if /AC_PATH_XTRA/;
4548 # This macro handles several different things.
4549 if (/$AM_INIT_AUTOMAKE_PATTERN/o)
4550 {
4551 $seen_make_set = 1;
4552 $seen_arg_prog = 1;
4553 $seen_prog_install = 1;
4554 ($package_version = $1) =~ s/$AM_PACKAGE_VERSION_PATTERN/$1/o;
4555 $package_version_line = $.;
4556 $seen_init_automake = 1;
4557 }
4559 # Some things required by Automake.
4560 $seen_make_set = 1 if /AC_PROG_MAKE_SET/;
4561 $seen_arg_prog = 1 if /AC_ARG_PROGRAM/;
4563 if (/AM_PROG_LEX/)
4564 {
4565 $configure_vars{'LEX'} = $filename . ':' . $.;
4566 $seen_decl_yytext = 1;
4567 }
4568 if (/AC_DECL_YYTEXT/ && $filename =~ /configure\.in$/)
4569 {
4570 &am_conf_line_warning ($filename, $., "\`AC_DECL_YYTEXT' is covered by \`AM_PROG_LEX'");
4571 }
4572 if (/AC_PROG_LEX/ && $filename =~ /configure\.in$/)
4573 {
4574 &am_conf_line_warning ($filename, $., "automake requires \`AM_PROG_LEX', not \`AC_PROG_LEX'");
4575 }
4577 if (/AC_PROG_(F77|YACC|RANLIB|CC|CXXCPP|CXX|LEX|AWK|CPP|LN_S)/)
4578 {
4579 $configure_vars{$1} = $filename . ':' . $.;
4580 }
4581 if (/$AC_CHECK_PATTERN/o)
4582 {
4583 $configure_vars{$3} = $filename . ':' . $.;
4584 }
4585 if (/$AM_MISSING_PATTERN/o
4586 && $1 ne 'ACLOCAL'
4587 && $1 ne 'AUTOCONF'
4588 && $1 ne 'AUTOMAKE'
4589 && $1 ne 'AUTOHEADER')
4590 {
4591 $configure_vars{$1} = $filename . ':' . $.;
4592 }
4594 # Explicitly avoid ANSI2KNR -- we AC_SUBST that in protos.m4,
4595 # but later define it elsewhere. This is pretty hacky. We
4596 # also explicitly avoid INSTALL_SCRIPT and some other
4597 # variables because they are defined in header-vars.am.
4598 # FIXME.
4599 if (/$AC_SUBST_PATTERN/o
4600 && $1 ne 'ANSI2KNR'
4601 && $1 ne 'INSTALL_SCRIPT'
4602 && $1 ne 'INSTALL_DATA')
4603 {
4604 $configure_vars{$1} = $filename . ':' . $.;
4605 }
4607 $seen_decl_yytext = 1 if /AC_DECL_YYTEXT/;
4608 if (/AM_MAINTAINER_MODE/)
4609 {
4610 $seen_maint_mode = 1;
4611 $configure_cond{'MAINTAINER_MODE'} = 1;
4612 }
4614 $seen_prog_install = 1 if /AC_PROG_INSTALL/;
4615 $seen_lispdir = 1 if /AM_PATH_LISPDIR/;
4616 $seen_pythondir = 1 if /AM_PATH_PYTHON/;
4618 if (/A(C|M)_PROG_LIBTOOL/)
4619 {
4620 if (/AM_PROG_LIBTOOL/)
4621 {
4622 &am_conf_line_warning ($filename, $., "\`AM_PROG_LIBTOOL' is obsolete, use \`AC_PROG_LIBTOOL' instead");
4623 }
4624 $seen_libtool = 1;
4625 $libtool_line = $.;
4626 $configure_vars{'LIBTOOL'} = $filename . ':' . $.;
4627 $configure_vars{'RANLIB'} = $filename . ':' . $.;
4628 $configure_vars{'CC'} = $filename . ':' . $.;
4629 # AC_PROG_LIBTOOL runs AC_CANONICAL_HOST. Make sure we
4630 # never downgrade (if we've seen AC_CANONICAL_SYSTEM).
4631 $seen_canonical = $AC_CANONICAL_HOST if ! $seen_canonical;
4632 }
4634 $seen_multilib = 1 if (/AM_ENABLE_MULTILIB/);
4636 if (/$AM_CONDITIONAL_PATTERN/o)
4637 {
4638 $configure_cond{$1} = 1;
4639 }
4641 # Check for Fortran 77 intrinsic and run-time libraries.
4642 if (/AC_F77_LIBRARY_LDFLAGS/)
4643 {
4644 $configure_vars{'FLIBS'} = $filename . ':' . $.;
4645 }
4646 }
4648 close (CONFIGURE);
4649 }
4651 # Scan configure.in and aclocal.m4 for interesting things. We must
4652 # scan aclocal.m4 because there might be AC_SUBSTs and such there.
4653 sub scan_configure
4654 {
4655 # Reinitialize libsources here. This isn't really necessary,
4656 # since we currently assume there is only one configure.in. But
4657 # that won't always be the case.
4658 %libsources = ();
4660 local ($in_ac_output, $in_ac_replace) = (0, 0);
4661 local (%make_list, @make_input_list);
4662 local ($libobj_iter);
4664 &scan_one_configure_file ('configure.in');
4665 &scan_one_configure_file ('aclocal.m4')
4666 if -f 'aclocal.m4';
4668 # Set input and output files if not specified by user.
4669 if (! @input_files)
4670 {
4671 @input_files = @make_input_list;
4672 %output_files = %make_list;
4673 }
4675 @configure_input_files = @make_input_list;
4677 &am_conf_error ("\`AM_INIT_AUTOMAKE' must be used in configure.in")
4678 if ! $seen_init_automake;
4680 # Always require AC_PROG_MAKE_SET. We might randomly use $(MAKE)
4681 # for our own reasons.
4682 &am_conf_error ("\`AC_PROG_MAKE_SET' must be used in configure.in")
4683 if ! $seen_make_set;
4685 # Look for some files we need. Always check for these. This
4686 # check must be done for every run, even those where we are only
4687 # looking at a subdir Makefile. We must set relative_dir so that
4688 # the file-finding machinery works.
4689 local ($relative_dir) = '.';
4690 &require_config_file ($FOREIGN, 'install-sh', 'mkinstalldirs', 'missing');
4691 &am_error ("\`install.sh' is an anachronism; use \`install-sh' instead")
4692 if -f $config_aux_path[0] . '/install.sh';
4694 &require_config_file ($FOREIGN, 'py-compile')
4695 if $seen_pythondir;
4697 # Preserve dist_common for later.
4698 %configure_dist_common = %dist_common;
4699 }
4701 ################################################################
4703 # Set up for Cygnus mode.
4704 sub check_cygnus
4705 {
4706 return unless $cygnus_mode;
4708 &set_strictness ('foreign');
4709 $options{'no-installinfo'} = 1;
4710 $options{'no-dependencies'} = 1;
4711 $use_dependencies = 0;
4713 if (! $seen_maint_mode)
4714 {
4715 &am_conf_error ("\`AM_MAINTAINER_MODE' required when --cygnus specified");
4716 }
4718 if (! $seen_exeext)
4719 {
4720 &am_conf_error ("\`AC_EXEEXT' required when --cygnus specified");
4721 }
4722 }
4724 # Do any extra checking for GNU standards.
4725 sub check_gnu_standards
4726 {
4727 if ($relative_dir eq '.')
4728 {
4729 # In top level (or only) directory.
4730 &require_file ($GNU, 'INSTALL', 'NEWS', 'README', 'COPYING',
4731 'AUTHORS', 'ChangeLog');
4732 }
4734 if ($strictness >= $GNU)
4735 {
4736 if (defined $options{'no-installman'})
4737 {
4738 &am_line_error ('AUTOMAKE_OPTIONS',
4739 "option \`no-installman' disallowed by GNU standards");
4740 }
4742 if (defined $options{'no-installinfo'})
4743 {
4744 &am_line_error ('AUTOMAKE_OPTIONS',
4745 "option \`no-installinfo' disallowed by GNU standards");
4746 }
4747 }
4748 }
4750 # Do any extra checking for GNITS standards.
4751 sub check_gnits_standards
4752 {
4753 if ($relative_dir eq '.')
4754 {
4755 # In top level (or only) directory.
4756 &require_file ($GNITS, 'THANKS');
4757 }
4758 }
4760 ################################################################
4761 #
4762 # Functions to handle files of each language.
4764 # Each `lang_X_rewrite' function follows a simple formula:
4765 # * Args are the directory, base name and extension of the file.
4766 # * Return value is 1 if file is to be dealt with, 0 otherwise.
4767 # Much of the actual processing is handled in handle_single_transform_list.
4768 # These functions exist so that auxiliary information can be recorded
4769 # for a later cleanup pass. Note that the calls to these functions
4770 # are computed, so don't bother searching for their precise names
4771 # in the source.
4773 # This is just a convenience function that can be used to determine
4774 # when a subdir object should be used.
4775 sub lang_sub_obj
4776 {
4777 return defined $options{'subdir-objects'} ? $LANG_SUBDIR : $LANG_PROCESS;
4778 }
4780 # Rewrite a single C source file.
4781 sub lang_c_rewrite
4782 {
4783 local ($directory, $base, $ext) = @_;
4785 if (defined $options{'ansi2knr'} && $base =~ /_$/)
4786 {
4787 # FIXME: include line number in error.
4788 &am_error ("C source file \`$base.c' would be deleted by ansi2knr rules");
4789 }
4791 local ($r) = $LANG_PROCESS;
4792 if (defined $options{'subdir-objects'})
4793 {
4794 $r = $LANG_SUBDIR;
4795 $base = $directory . '/' . $base;
4797 if (! $seen_cc_c_o)
4798 {
4799 # Only give error once.
4800 $seen_cc_c_o = 1;
4801 # FIXME: line number.
4802 &am_error ("C objects in subdir but \`AM_PROG_CC_C_O' not in \`configure.in'");
4803 }
4805 &require_file ($FOREIGN, 'compile')
4806 if $relative_dir eq '.';
4807 }
4809 $de_ansi_files{$base} = 1;
4810 return $r;
4811 }
4813 # Rewrite a single C++ source file.
4814 sub lang_cxx_rewrite
4815 {
4816 return &lang_sub_obj;
4817 }
4819 # Rewrite a single header file.
4820 sub lang_header_rewrite
4821 {
4822 # Header files are simply ignored.
4823 return $LANG_IGNORE;
4824 }
4826 # Rewrite a single yacc file.
4827 sub lang_yacc_rewrite
4828 {
4829 local ($directory, $base, $ext) = @_;
4831 local ($r) = &lang_c_rewrite ($directory, $base, $ext);
4832 local ($pfx) = '';
4833 if ($r == $LANG_SUBDIR)
4834 {
4835 $pfx = $directory . '/';
4836 }
4837 $yacc_sources{$pfx . $base . '.' . $ext} = 1;
4838 $ext =~ tr/y/c/;
4839 &saw_extension ('c');
4840 # FIXME: nodist.
4841 &push_dist_common ($pfx . $base . '.' . $ext);
4842 return $r;
4843 }
4845 # Rewrite a single yacc++ file.
4846 sub lang_yaccxx_rewrite
4847 {
4848 local ($directory, $base, $ext) = @_;
4850 local ($r) = $LANG_PROCESS;
4851 local ($pfx) = '';
4852 if (defined $options{'subdir-objects'})
4853 {
4854 $pfx = $directory . '/';
4855 $r = $LANG_SUBDIR;
4856 }
4857 $yacc_sources{$pfx . $base . '.' . $ext} = 1;
4858 $ext =~ tr/y/c/;
4859 &saw_extension ($ext);
4860 # FIXME: nodist.
4861 &push_dist_common ($pfx . $base . '.' . $ext);
4862 return $r;
4863 }
4865 # Rewrite a single lex file.
4866 sub lang_lex_rewrite
4867 {
4868 local ($directory, $base, $ext) = @_;
4870 local ($r) = &lang_c_rewrite ($directory, $base, $ext);
4871 local ($pfx) = '';
4872 if ($r == $LANG_SUBDIR)
4873 {
4874 $pfx = $directory . '/';
4875 }
4876 $lex_sources{$pfx . $base . '.' . $ext} = 1;
4877 $ext =~ tr/l/c/;
4878 &saw_extension ('c');
4879 # FIXME: nodist.
4880 &push_dist_common ($pfx . $base . '.' . $ext);
4881 return $r;
4882 }
4884 # Rewrite a single lex++ file.
4885 sub lang_lexxx_rewrite
4886 {
4887 local ($directory, $base, $ext) = @_;
4889 local ($r) = $LANG_PROCESS;
4890 local ($pfx) = '';
4891 if (defined $options{'subdir-objects'})
4892 {
4893 $pfx = $directory . '/';
4894 $r = $LANG_SUBDIR;
4895 }
4896 $lex_sources{$pfx . $base . '.' . $ext} = 1;
4897 $ext =~ tr/l/c/;
4898 &saw_extension ($ext);
4899 # FIXME: nodist.
4900 &push_dist_common ($pfx . $base . '.' . $ext);
4901 return $r;
4902 }
4904 # Rewrite a single assembly file.
4905 sub lang_asm_rewrite
4906 {
4907 return &lang_sub_obj;
4908 }
4910 # Rewrite a single Fortran 77 file.
4911 sub lang_f77_rewrite
4912 {
4913 return $LANG_PROCESS;
4914 }
4916 # Rewrite a single preprocessed Fortran 77 file.
4917 sub lang_ppf77_rewrite
4918 {
4919 return $LANG_PROCESS;
4920 }
4922 # Rewrite a single ratfor file.
4923 sub lang_ratfor_rewrite
4924 {
4925 return $LANG_PROCESS;
4926 }
4928 # Rewrite a single Objective C file.
4929 sub lang_objc_rewrite
4930 {
4931 return &lang_sub_obj;
4932 }
4934 # Rewrite a single Java file.
4935 sub lang_java_rewrite
4936 {
4937 return $LANG_SUBDIR;
4938 }
4940 # The lang_X_finish functions are called after all source file
4941 # processing is done. Each should handle defining rules for the
4942 # language, etc. A finish function is only called if a source file of
4943 # the appropriate type has been seen.
4945 sub lang_c_finish
4946 {
4947 # Push all libobjs files onto de_ansi_files. We actually only
4948 # push files which exist in the current directory, and which are
4949 # genuine source files.
4950 local ($file);
4951 foreach $file (keys %libsources)
4952 {
4953 if ($file =~ /^(.*)\.[cly]$/ && -f "$relative_dir/$file")
4954 {
4955 $de_ansi_files{$1} = 1;
4956 }
4957 }
4959 if (defined $options{'ansi2knr'} && keys %de_ansi_files)
4960 {
4961 # Make all _.c files depend on their corresponding .c files.
4962 local ($base, @objects);
4963 foreach $base (sort keys %de_ansi_files)
4964 {
4965 # Each _.c file must depend on ansi2knr; otherwise it
4966 # might be used in a parallel build before it is built.
4967 # We need to support files in the srcdir and in the build
4968 # dir (because these files might be auto-generated. But
4969 # we can't use $< -- some makes only define $< during a
4970 # suffix rule.
4971 $output_rules .= ($base . "_.c: $base.c \$(ANSI2KNR)\n\t"
4972 . '$(CPP) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) '
4973 . '`if test -f $(srcdir)/' . $base . '.c'
4974 . '; then echo $(srcdir)/' . $base . '.c'
4975 . '; else echo ' . $base . '.c; fi` '
4976 . "| sed 's/^# \\([0-9]\\)/#line \\1/' "
4977 . '| $(ANSI2KNR) > ' . $base . "_.c\n");
4978 push (@objects, $base . '_'
4979 . ($seen_objext ? '.$(OBJEXT)' : '.o'));
4980 push (@objects, $base . '_.lo') if $seen_libtool;
4981 }
4983 # Make all _.o (and _.lo) files depend on ansi2knr.
4984 # Use a sneaky little hack to make it print nicely.
4985 &pretty_print_rule ('', '', @objects, ':', '$(ANSI2KNR)');
4986 }
4988 if (! defined $configure_vars{'CC'})
4989 {
4990 # FIXME: line number.
4991 &am_error ("C source seen but \`CC' not defined in \`configure.in'");
4992 }
4993 }
4995 sub lang_cxx_finish
4996 {
4997 local ($ltcompile, $ltlink) = &libtool_compiler;
4999 &define_variable ('CXXLD', '$(CXX)');
5000 &define_variable ('CXXLINK', $ltlink . '$(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5002 if (! defined $configure_vars{'CXX'})
5003 {
5004 &am_error ("C++ source seen but \`CXX' not defined in \`configure.in'");
5005 }
5006 }
5008 sub lang_header_finish
5009 {
5010 # Nothing to do.
5011 }
5013 # This is a helper for both lex and yacc.
5014 sub yacc_lex_finish_helper
5015 {
5016 return if defined $language_scratch{'lex-yacc-done'};
5017 $language_scratch{'lex-yacc-done'} = 1;
5019 # If there is more than one distinct yacc (resp lex) source file
5020 # in a given directory, then the `ylwrap' program is required to
5021 # allow parallel builds to work correctly. FIXME: for now, no
5022 # line number.
5023 &require_config_file ($FOREIGN, 'ylwrap');
5024 if ($config_aux_dir ne '.' && $config_aux_dir ne '')
5025 {
5026 &define_variable ('YLWRAP', $config_aux_dir . "/ylwrap");
5027 }
5028 else
5029 {
5030 &define_variable ('YLWRAP', '$(srcdir)/ylwrap');
5031 }
5032 }
5034 sub lang_yacc_finish
5035 {
5036 return if defined $language_scratch{'yacc-done'};
5037 $language_scratch{'yacc-done'} = 1;
5039 local ($file, $base, $hname, $cname);
5040 local (%seen_suffix) = ();
5041 local (@yacc_files) = sort keys %yacc_sources;
5042 local ($yacc_count) = scalar (@yacc_files);
5043 foreach $file (@yacc_files)
5044 {
5045 $file =~ /(\..*)$/;
5046 &output_yacc_build_rule ($1, $yacc_count > 1)
5047 if ! defined $seen_suffix{$1};
5048 $seen_suffix{$1} = 1;
5050 $file =~ /^(.*)\.(y|yy|y\+\+|yxx|ypp)$/;
5051 $base = $1;
5052 $hname = 'h'; # Always use `.h' for header file.
5053 ($cname = $2) =~ tr/y/c/;
5055 if ((&variable_defined ('AM_YFLAGS')
5056 && &variable_value ('AM_YFLAGS') =~ /(^|\s)-d(\s|$)/)
5057 || (&variable_defined ('YFLAGS')
5058 && &variable_value ('YFLAGS') =~ /(^|\s)-d(\s|$)/)) {
5059 # Now generate rule to make the header file. This should only
5060 # be generated if `yacc -d' specified.
5061 $output_rules .= "${base}.${hname}: ${base}.${cname}\n";
5063 # If the files are built in the build directory, then we want
5064 # to remove them with `make clean'. If they are in srcdir
5065 # they shouldn't be touched. However, we can't determine this
5066 # statically, and the GNU rules say that yacc/lex output files
5067 # should be removed by maintainer-clean. So that's what we
5068 # do.
5069 push (@maintainer_clean_files, "${base}.${hname}");
5071 &push_dist_common ("${base}.${hname}");
5072 }
5073 push (@maintainer_clean_files, "${base}.${cname}");
5074 }
5075 $output_rules .= "\n";
5077 if (! defined $configure_vars{'YACC'})
5078 {
5079 &am_error ("yacc source seen but \`YACC' not defined in \`configure.in'");
5080 }
5081 if (&variable_defined ('YACCFLAGS'))
5082 {
5083 &am_line_error ('YACCFLAGS',
5084 "\`YACCFLAGS' obsolete; use \`YFLAGS' instead");
5085 }
5087 if ($yacc_count > 1)
5088 {
5089 &yacc_lex_finish_helper;
5090 }
5091 }
5093 sub lang_yaccxx_finish
5094 {
5095 &lang_yacc_finish;
5096 }
5098 sub lang_lex_finish
5099 {
5100 return if defined $language_scratch{'lex-done'};
5101 $language_scratch{'lex-done'} = 1;
5103 local (%seen_suffix) = ();
5104 local ($file, $cname);
5105 local ($lex_count) = scalar (keys %lex_sources);
5106 foreach $file (sort keys %lex_sources)
5107 {
5108 $file =~ /(\..*)$/;
5109 &output_lex_build_rule ($1, $lex_count > 1)
5110 if (! defined $seen_suffix{$1});
5111 $seen_suffix{$1} = 1;
5113 # If the files are built in the build directory, then we want
5114 # to remove them with `make clean'. If they are in srcdir
5115 # they shouldn't be touched. However, we can't determine this
5116 # statically, and the GNU rules say that yacc/lex output files
5117 # should be removed by maintainer-clean. So that's what we
5118 # do.
5119 $file =~ /^(.*)\.(l|ll|l\+\+|lxx|lpp)$/;
5120 ($cname = $2) =~ tr/l/c/;
5121 push (@maintainer_clean_files, "${1}.${cname}");
5122 }
5124 if (! defined $configure_vars{'LEX'})
5125 {
5126 &am_error ("lex source seen but \`LEX' not defined in \`configure.in'");
5127 }
5128 if (! $seen_decl_yytext)
5129 {
5130 &am_error ("lex source seen but \`AC_DECL_YYTEXT' not in \`configure.in'");
5131 }
5133 if ($lex_count > 1)
5134 {
5135 &yacc_lex_finish_helper;
5136 }
5137 }
5139 sub lang_lexxx_finish
5140 {
5141 &lang_lex_finish;
5142 }
5144 sub lang_asm_finish
5145 {
5146 # We need the C code for assembly.
5147 &lang_c_finish;
5148 }
5150 sub lang_f77_finish
5151 {
5152 # FIXME: this function can be called more than once. We should
5153 # arrange for it to only do anything the first time through.
5155 local ($ltcompile, $ltlink) = &libtool_compiler;
5157 &define_variable ('F77LD', '$(F77)');
5158 &define_variable ('F77LINK', $ltlink . '$(F77LD) $(AM_FFLAGS) $(FFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5160 if (! defined $configure_vars{'F77'})
5161 {
5162 &am_error ("Fortran 77 source seen but \`F77' not defined in \`configure.in'");
5163 }
5164 }
5166 # Preprocessed Fortran 77
5167 #
5168 # The current support for preprocessing Fortran 77 just involves passing
5169 # `$(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS)' as additional flags
5170 # to the Fortran 77 compiler, since this is how GNU Make does it; see
5171 # the `GNU Make Manual, Edition 0.51 for `make' Version 3.76 Beta'
5172 # (specifically, from info file `(make)Catalogue of Rules').
5173 #
5174 # A better approach would be to write an Autoconf test
5175 # (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
5176 # Fortran 77 compilers know how to do preprocessing. The Autoconf macro
5177 # AC_PROG_FPP should test the Fortran 77 compiler first for
5178 # preprocessing capabilities, and then fall back on cpp (if cpp were
5179 # available).
5180 sub lang_ppf77_finish
5181 {
5182 &lang_f77_finish;
5184 # We also handle the case of preprocessing `.F' files into `.f'
5185 # files.
5186 $output_rules .= (".F.f:\n"
5187 . "\t\$(F77COMPILE) -F \$<\n");
5188 }
5190 sub lang_ratfor_finish
5191 {
5192 &lang_f77_finish;
5194 # We also handle the case of preprocessing `.r' files into `.f'
5195 # files.
5196 $output_rules .= (".r.f:\n"
5197 . "\t\$(RCOMPILE) -F \$<\n");
5198 }
5200 sub lang_objc_finish
5201 {
5202 local ($ltcompile, $ltlink) = &libtool_compiler;
5204 &define_variable ('OBJCLD', '$(OBJC)');
5205 &define_variable ('OBJCLINK', $ltlink . '$(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5207 if (! defined $configure_vars{'OBJC'})
5208 {
5209 &am_error ("Objective C source seen but \`OBJC' not defined in \`configure.in'");
5210 }
5211 }
5213 sub lang_java_finish
5214 {
5215 local ($ltcompile, $ltlink) = &libtool_compiler;
5217 &define_variable ('GCJLD', '$(GCJ)');
5218 &define_variable ('GCJLINK', $ltlink . '$(GCJLD) $(AM_GCJFLAGS) $(GCJFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@');
5220 if (! defined $configure_vars{'GCJ'})
5221 {
5222 &am_error ("Java source seen but \`GCJ' not defined in \`configure.in'");
5223 }
5224 }
5226 # A helper which computes a sorted list of all extensions for LANG.
5227 sub lang_extensions
5228 {
5229 local ($lang) = @_;
5230 local ($key, @r);
5231 foreach $key (sort keys %extension_seen)
5232 {
5233 push (@r, '.' . $key) if $extension_map{$key} eq $lang;
5234 }
5235 return @r;
5236 }
5238 # A helper which decides whether libtool is needed. Returns prefix
5239 # for compiler and linker.
5240 sub libtool_compiler
5241 {
5242 local ($ltcompile, $ltlink) = ('', '');
5243 if ($seen_libtool)
5244 {
5245 &define_configure_variable ("LIBTOOL");
5246 $ltcompile = '$(LIBTOOL) --mode=compile ';
5247 $ltlink = '$(LIBTOOL) --mode=link ';
5248 }
5249 return ($ltcompile, $ltlink);
5250 }
5252 # Given a hash table of linker names, pick the name that has the most
5253 # precedence. This is lame, but something has to have global
5254 # knowledge in order to eliminate the conflict. Add more linkers as
5255 # required.
5256 sub resolve_linker
5257 {
5258 local (%linkers) = @_;
5260 return 'GCJLINK'
5261 if defined $linkers{'GCJLINK'};
5262 return 'CXXLINK'
5263 if defined $linkers{'CXXLINK'};
5264 return 'F77LINK'
5265 if defined $linkers{'F77LINK'};
5266 return 'OBJCLINK'
5267 if defined $linkers{'OBJCLINK'};
5268 return 'LINK';
5269 }
5271 # Called to indicate that an extension was used.
5272 sub saw_extension
5273 {
5274 local ($ext) = @_;
5275 $extension_seen{$ext} = 1;
5276 }
5278 # Called to ask whether source files have been seen . If HEADERS is 1,
5279 # headers can be included.
5280 sub saw_sources_p
5281 {
5282 local ($headers) = @_;
5284 if ($headers)
5285 {
5286 $headers = 0;
5287 }
5288 else
5289 {
5290 local (@exts) = &lang_extensions ('header');
5291 $headers = @exts;
5292 }
5294 return scalar keys %extension_seen > $headers;
5295 }
5297 # Register a single language. LANGUAGE is the name of the language.
5298 # Each OPTION is either of the form NAME=VALUE, or is a file extension
5299 # (sans `.').
5300 sub register_language
5301 {
5302 local ($language, @options) = @_;
5304 # Set the defaults.
5305 $language_map{$language . '-ansi-p'} = 0;
5306 $language_map{$language . '-linker'} = '';
5307 $language_map{$language . '-autodep'} = 'no';
5309 local ($iter);
5310 foreach $iter (@options)
5311 {
5312 if ($iter =~ /^(.*)=(.*)$/)
5313 {
5314 $language_map{$language . '-' . $1} = $2;
5315 }
5316 elsif (defined $extension_map{$iter})
5317 {
5318 print STDERR
5319 "automake: programming error: duplicate extension $iter\n";
5320 exit 1;
5321 }
5322 else
5323 {
5324 $extension_map{$iter} = $language;
5325 }
5326 }
5327 }
5329 # This function is used to find a path from a user-specified suffix to
5330 # `o' or to some other suffix we recognize internally, eg `cc'.
5331 sub derive_suffix
5332 {
5333 local ($source_ext) = @_;
5335 # FIXME: hard-coding `o' is a mistake. Doing something
5336 # intelligent is harder.
5337 while ($extension_map{$source_ext} eq ''
5338 && $source_ext ne 'o'
5339 && defined $suffix_rules{$source_ext})
5340 {
5341 $source_ext = $suffix_rules{$source_ext};
5342 }
5344 return $source_ext;
5345 }
5348 ################################################################
5350 # Pretty-print something. HEAD is what should be printed at the
5351 # beginning of the first line, FILL is what should be printed at the
5352 # beginning of every subsequent line.
5353 sub pretty_print_internal
5354 {
5355 local ($head, $fill, @values) = @_;
5357 local ($column) = length ($head);
5358 local ($result) = $head;
5360 # Fill length is number of characters. However, each Tab
5361 # character counts for eight. So we count the number of Tabs and
5362 # multiply by 7.
5363 local ($fill_length) = length ($fill);
5364 $fill_length += 7 * ($fill =~ tr/\t/\t/d);
5366 local ($bol) = ($head eq '');
5367 foreach (@values)
5368 {
5369 # "71" because we also print a space.
5370 if ($column + length ($_) > 71)
5371 {
5372 $result .= " \\\n" . $fill;
5373 $column = $fill_length;
5374 $bol = 1;
5375 }
5377 $result .= ' ' unless ($bol);
5378 $result .= $_;
5379 $column += length ($_) + 1;
5380 $bol = 0;
5381 }
5383 $result .= "\n";
5384 return $result;
5385 }
5387 # Pretty-print something and append to output_vars.
5388 sub pretty_print
5389 {
5390 $output_vars .= &pretty_print_internal (@_);
5391 }
5393 # Pretty-print something and append to output_rules.
5394 sub pretty_print_rule
5395 {
5396 $output_rules .= &pretty_print_internal (@_);
5397 }
5400 ################################################################
5402 # See if a target exists.
5403 sub target_defined
5404 {
5405 local ($target) = @_;
5406 return defined $targets{$target};
5407 }
5409 # See if two conditionals are the same.
5410 sub conditional_same
5411 {
5412 local ($cond1, $cond2) = @_;
5414 return (&conditional_true_when ($cond1, $cond2)
5415 && &conditional_true_when ($cond2, $cond1));
5416 }
5418 # See if a conditional is true. Both arguments are conditional
5419 # strings. This returns true if the first conditional is true when
5420 # the second conditional is true.
5421 sub conditional_true_when
5422 {
5423 local ($cond, $when) = @_;
5425 # Check the easy case first.
5426 if ($cond eq $when)
5427 {
5428 return 1;
5429 }
5431 # Check each component of $cond, which looks @COND1@@COND2@.
5432 foreach $comp (split ('@', $cond))
5433 {
5434 # The way we split will give null strings between each
5435 # condition.
5436 next if ! $comp;
5438 if (index ($when, '@' . $comp . '@') == -1)
5439 {
5440 return 0;
5441 }
5442 }
5444 return 1;
5445 }
5447 # Check for an ambiguous conditional. This is called when a variable
5448 # or target is being defined conditionally. If we already know about
5449 # a definition that is true under the same conditions, then we have an
5450 # ambiguity.
5451 sub check_ambiguous_conditional
5452 {
5453 local ($var_name, $cond) = @_;
5454 local (@cond_vals) = split (' ', $conditional{$var_name});
5455 while (@cond_vals)
5456 {
5457 local ($vcond) = shift (@cond_vals);
5458 shift (@cond_vals);
5459 if (&conditional_true_when ($vcond, $cond)
5460 || &conditional_true_when ($cond, $vcond))
5461 {
5462 &am_line_error ($var_name,
5463 "$var_name multiply defined in condition");
5464 }
5465 }
5466 }
5468 # See if a variable exists. The first argument is the variable name,
5469 # and the optional second argument is the condition which we should
5470 # check. If no condition is given, we currently return true if the
5471 # variable is defined under any condition.
5472 sub variable_defined
5473 {
5474 local ($var, $cond) = @_;
5475 if (defined $targets{$var})
5476 {
5477 &am_line_error ($var, "\`$var' is target; expected variable");
5478 return 0;
5479 }
5480 elsif (defined $contents{$var})
5481 {
5482 if ($cond && $conditional{$var})
5483 {
5484 # We have been asked to check for a particular condition,
5485 # and the variable is defined conditionally. We need to
5486 # look through the conditions under which the variable is
5487 # defined, and see if any of them match the conditional we
5488 # have been asked to check.
5489 local (@cond_vars) = split (' ', $conditional{$var});
5490 while (@cond_vars)
5491 {
5492 if (&conditional_same ($cond, shift (@cond_vars)))
5493 {
5494 # Even a conditional examination is good enough
5495 # for us. FIXME: really should maintain examined
5496 # status on a per-condition basis.
5497 $content_seen{$var} = 1;
5498 return 1;
5499 }
5500 shift (@cond_vars);
5501 }
5503 # The variable is not defined for the given condition.
5504 return 0;
5505 }
5507 $content_seen{$var} = 1;
5508 return 1;
5509 }
5510 return 0;
5511 }
5513 # Mark a variable as examined.
5514 sub examine_variable
5515 {
5516 local ($var) = @_;
5517 &variable_defined ($var);
5518 }
5520 # Quote a value in order to put it in $conditional. We need to quote
5521 # spaces, and we need to handle null strings, so that we can later
5522 # retrieve values by splitting on space.
5523 sub quote_cond_val
5524 {
5525 local ($val) = @_;
5526 $val =~ tr/ \t\n/\001\003\004/;
5527 $val = "\002" if $val eq '';
5528 return $val;
5529 }
5531 # Unquote a value in $conditional.
5532 sub unquote_cond_val
5533 {
5534 local ($val) = @_;
5535 $val =~ tr/\001\003\004/ \t\n/;
5536 $val =~ s/\002//g;
5537 return $val;
5538 }
5540 # Return the set of conditions for which a variable is defined.
5542 # If the variable is not defined conditionally, and is not defined in
5543 # terms of any variables which are defined conditionally, then this
5544 # returns the empty list.
5546 # If the variable is defined conditionally, but is not defined in
5547 # terms of any variables which are defined conditionally, then this
5548 # returns the list of conditions for which the variable is defined.
5550 # If the variable is defined in terms of any variables which are
5551 # defined conditionally, then this returns a full set of permutations
5552 # of the subvariable conditions. For example, if the variable is
5553 # defined in terms of a variable which is defined for @COND_TRUE@,
5554 # then this returns both @COND_TRUE@ and @COND_FALSE@. This is
5555 # because we will need to define the variable under both conditions.
5557 sub variable_conditions
5558 {
5559 local ($var) = @_;
5560 local (%uniqify);
5561 local (@uniq_list);
5562 local ($cond);
5564 %vars_scanned = ();
5565 foreach $cond (&variable_conditions_sub ($var, '', ()))
5566 {
5567 $uniqify{$cond} = 1;
5568 }
5570 @uniq_list = sort keys %uniqify;
5571 # Note we cannot just do `return sort keys %uniqify', because this
5572 # function is sometimes used in a scalar context.
5573 return @uniq_list;
5574 }
5576 # A subroutine of variable_conditions. We only return conditions
5577 # which are true for all the conditions in @PARENT_CONDS.
5578 sub variable_conditions_sub
5579 {
5580 local ($var, $parent, @parent_conds) = @_;
5581 local (@new_conds) = ();
5583 if (defined $vars_scanned{$var})
5584 {
5585 &am_line_error ($parent, "variable \`$var' recursively defined");
5586 return ();
5587 }
5588 $vars_scanned{$var} = 1;
5590 if (! $conditional{$var})
5591 {
5592 foreach (split (' ', $contents{$var}))
5593 {
5594 # If a comment seen, just leave.
5595 last if /^#/;
5597 # Handle variable substitutions.
5598 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
5599 {
5600 push (@new_conds,
5601 &variable_conditions_sub ($1, $var, @parent_conds));
5602 }
5603 }
5605 # Now we want to return all permutations of the subvariable
5606 # conditions.
5607 local (%allconds, $item);
5608 foreach $item (@new_conds)
5609 {
5610 foreach (split ('@', $item))
5611 {
5612 next if ! $_;
5613 s/_(TRUE|FALSE)$//;
5614 $allconds{$_ . '_TRUE'} = 1;
5615 }
5616 }
5618 # Unset our entry in vars_scanned. We only care about recursive
5619 # definitions.
5620 delete $vars_scanned{$var};
5622 return &variable_conditions_permutations (sort keys %allconds);
5623 }
5625 local (@this_conds) = ();
5626 local (@condvals) = split (' ', $conditional{$var});
5627 while (@condvals)
5628 {
5629 local ($cond) = shift (@condvals);
5630 local ($val) = &unquote_cond_val (shift (@condvals));
5632 if (@parent_conds)
5633 {
5634 local ($ok) = 1;
5635 local ($parent_cond);
5636 foreach $parent_cond (@parent_conds)
5637 {
5638 if (! &conditional_true_when ($parent_cond, $cond))
5639 {
5640 $ok = 0;
5641 last;
5642 }
5643 }
5645 next if ! $ok;
5646 }
5648 push (@this_conds, $cond);
5650 push (@parent_conds, $cond);
5651 local (@subvar_conds) = ();
5652 foreach (split (' ', $val))
5653 {
5654 # If a comment seen, just leave.
5655 last if /^#/;
5657 # Handle variable substitutions.
5658 if (/^\$\{(.*)\}$/ || /^\$\((.*)\)$/)
5659 {
5660 push (@subvar_conds,
5661 &variable_conditions_sub ($1, $var, @parent_conds));
5662 }
5663 }
5664 pop (@parent_conds);
5666 # If there are no conditional subvariables, then we want to
5667 # return this condition. Otherwise, we want to return the
5668 # permutations of the subvariables.
5669 if (! @subvar_conds)
5670 {
5671 push (@new_conds, $cond);
5672 }
5673 else
5674 {
5675 push (@new_conds, &variable_conditions_reduce (@subvar_conds));
5676 }
5677 }
5679 # Unset our entry in vars_scanned. We only care about recursive
5680 # definitions.
5681 delete $vars_scanned{$var};
5683 return @new_conds
5684 if ! $parent;
5686 # If we are being called on behalf of another variable, we need to
5687 # return all possible permutations of the conditions. We have
5688 # already handled everything in @this_conds along with their
5689 # subvariables. We now need to add any permutations that are not
5690 # in @this_conds.
5691 local ($this_cond);
5692 foreach $this_cond (@this_conds)
5693 {
5694 local (@perms) =
5695 &variable_conditions_permutations (split('@', $this_cond));
5696 local ($perm);
5697 foreach $perm (@perms)
5698 {
5699 local ($scan);
5700 local ($ok) = 1;
5701 foreach $scan (@this_conds)
5702 {
5703 if (&conditional_true_when ($perm, $scan)
5704 || &conditional_true_when ($scan, $perm))
5705 {
5706 $ok = 0;
5707 last;
5708 }
5709 }
5710 next if ! $ok;
5712 if (@parent_conds)
5713 {
5714 local ($ok) = 1;
5715 local ($parent_cond);
5716 foreach $parent_cond (@parent_conds)
5717 {
5718 if (! &conditional_true_when ($parent_cond, $perm))
5719 {
5720 $ok = 0;
5721 last;
5722 }
5723 }
5725 next if ! $ok;
5726 }
5728 # This permutation was not already handled, and is valid
5729 # for the parents.
5730 push (@new_conds, $perm);
5731 }
5732 }
5734 return @new_conds;
5735 }
5737 # Subroutine for variable_conditions_sort
5738 sub variable_conditions_cmp
5739 {
5740 local ($as) = $a;
5741 $as =~ s/[^@]//g;
5742 local ($bs) = $b;
5743 $bs =~ s/[^@]//g;
5744 return (length ($as) <=> length ($bs)
5745 || $a cmp $b);
5746 }
5748 # Sort a list of conditionals so that only the exclusive ones are
5749 # retained. For example, if both @COND1_TRUE@@COND2_TRUE@ and
5750 # @COND1_TRUE@ are in the list, discard the latter.
5751 sub variable_conditions_reduce
5752 {
5753 local (@conds) = @_;
5754 local (@ret) = ();
5755 local ($cond);
5756 foreach $cond (sort variable_conditions_cmp @conds)
5757 {
5758 local ($ok) = 1;
5759 local ($scan);
5760 foreach $scan (@ret)
5761 {
5762 if (&conditional_true_when ($cond, $scan))
5763 {
5764 $ok = 0;
5765 last;
5766 }
5767 }
5768 next if ! $ok;
5769 push (@ret, $cond);
5770 }
5772 return @ret;
5773 }
5775 # Return a list of permutations of a conditional string.
5776 sub variable_conditions_permutations
5777 {
5778 local (@comps) = @_;
5779 return ()
5780 if ! @comps;
5781 local ($comp) = shift (@comps);
5782 return &variable_conditions_permutations (@comps)
5783 if $comp eq '';
5784 local ($neg) = $comp;
5785 $neg =~ s/TRUE$/TRUEO/;
5786 $neg =~ s/FALSE$/TRUE/;
5787 $neg =~ s/TRUEO$/FALSE/;
5788 local (@ret);
5789 local ($sub);
5790 foreach $sub (&variable_conditions_permutations (@comps))
5791 {
5792 push (@ret, '@' . $comp . '@' . $sub);
5793 push (@ret, '@' . $neg . '@' . $sub);
5794 }
5795 if (! @ret)
5796 {
5797 push (@ret, '@' . $comp . '@');
5798 push (@ret, '@' . $neg . '@');
5799 }
5800 return @ret;
5801 }
5803 # Warn if a variable is conditionally defined. This is called if we
5804 # are using the value of a variable.
5805 sub variable_conditionally_defined
5806 {
5807 local ($var, $parent) = @_;
5808 if ($conditional{$var})
5809 {
5810 if ($parent)
5811 {
5812 &am_line_error ($parent,
5813 "warning: automake does not support conditional definition of $var in $parent");
5814 }
5815 else
5816 {
5817 &am_line_error ($parent,
5818 "warning: automake does not support $var being defined conditionally")
5819 }
5820 }
5821 }
5823 # Get the value of a variable. This just returns $contents, but warns
5824 # if the variable is conditionally defined.
5825 sub variable_value
5826 {
5827 local ($var) = @_;
5828 &variable_conditionally_defined ($var);
5829 return $contents{$var};
5830 }
5832 # Convert a variable value to a list, split as whitespace. This will
5833 # recursively follow $(...) and ${...} inclusions. It preserves @...@
5834 # substitutions. If COND is 'all', then all values under all
5835 # conditions should be returned; if COND is a particular condition
5836 # (all conditions are surrounded by @...@) then only the value for
5837 # that condition should be returned; otherwise, warn if VAR is
5838 # conditionally defined. SCANNED is a global hash listing whose keys
5839 # are all the variables already scanned; it is an error to rescan a
5840 # variable.
5841 sub value_to_list
5842 {
5843 local ($var, $val, $cond) = @_;
5844 local (@result);
5846 # Strip backslashes
5847 $val =~ s/\\(\n|$)/ /g;
5849 foreach (split (' ', $val))
5850 {
5851 # If a comment seen, just leave.
5852 last if /^#/;
5854 # Handle variable substitutions.
5855 if (/^\$\{([^}]*)\}$/ || /^\$\(([^)]*)\)$/)
5856 {
5857 local ($varname) = $1;
5859 # If the user uses a losing variable name, just ignore it.
5860 # This isn't ideal, but people have requested it.
5861 next if ($varname =~ /\@.*\@/);
5863 local ($from, $to);
5864 local (@temp_list);
5865 if ($varname =~ /^([^:]*):([^=]*)=(.*)$/)
5866 {
5867 $varname = $1;
5868 $to = $3;
5869 ($from = $2) =~ s/(\W)/\\$1/g;
5870 }
5872 # Find the value.
5873 @temp_list = &variable_value_as_list_worker ($1, $cond, $var);
5875 # Now rewrite the value if appropriate.
5876 if ($from)
5877 {
5878 grep (s/$from$/$to/, @temp_list);
5879 }
5881 push (@result, @temp_list);
5882 }
5883 else
5884 {
5885 push (@result, $_);
5886 }
5887 }
5889 return @result;
5890 }
5892 # Return contents of variable as list, split as whitespace. This will
5893 # recursively follow $(...) and ${...} inclusions. It preserves @...@
5894 # substitutions. If COND is 'all', then all values under all
5895 # conditions should be returned; if COND is a particular condition
5896 # (all conditions are surrounded by @...@) then only the value for
5897 # that condition should be returned; otherwise, warn if VAR is
5898 # conditionally defined. If PARENT is specified, it is the name of
5899 # the including variable; this is only used for error reports.
5900 sub variable_value_as_list_worker
5901 {
5902 local ($var, $cond, $parent) = @_;
5903 local (@result);
5905 if (defined $targets{$var})
5906 {
5907 &am_line_error ($var, "\`$var' is target; expected variable");
5908 }
5909 elsif (! defined $contents{$var})
5910 {
5911 &am_line_error ($parent, "variable \`$var' not defined");
5912 }
5913 elsif (defined $vars_scanned{$var})
5914 {
5915 # `vars_scanned' is a global we use to keep track of which
5916 # variables we've already examined.
5917 &am_line_error ($parent, "variable \`$var' recursively defined");
5918 }
5919 elsif ($cond eq 'all' && $conditional{$var})
5920 {
5921 $vars_scanned{$var} = 1;
5922 local (@condvals) = split (' ', $conditional{$var});
5923 while (@condvals)
5924 {
5925 shift (@condvals);
5926 local ($val) = &unquote_cond_val (shift (@condvals));
5927 push (@result, &value_to_list ($var, $val, $cond));
5928 }
5929 }
5930 elsif ($cond && $conditional{$var})
5931 {
5932 $vars_scanned{$var} = 1;
5933 local (@condvals) = split (' ', $conditional{$var});
5934 local ($onceflag);
5935 while (@condvals)
5936 {
5937 local ($vcond) = shift (@condvals);
5938 local ($val) = &unquote_cond_val (shift (@condvals));
5939 if (&conditional_true_when ($vcond, $cond))
5940 {
5941 # Warn if we have an ambiguity. It's hard to know how
5942 # to handle this case correctly.
5943 &variable_conditionally_defined ($var, $parent)
5944 if $onceflag;
5945 $onceflag = 1;
5946 push (@result, &value_to_list ($var, $val, $cond));
5947 }
5948 }
5949 }
5950 else
5951 {
5952 $vars_scanned{$var} = 1;
5953 &variable_conditionally_defined ($var, $parent);
5954 $content_seen{$var} = 1;
5955 push (@result, &value_to_list ($var, $contents{$var}, $cond));
5956 }
5958 # Unset our entry in vars_scanned. We only care about recursive
5959 # definitions.
5960 delete $vars_scanned{$var};
5962 return @result;
5963 }
5965 # This is just a wrapper for variable_value_as_list_worker that
5966 # initializes the global hash `vars_scanned'. This hash is used to
5967 # avoid infinite recursion.
5968 sub variable_value_as_list
5969 {
5970 local ($var, $cond, $parent) = @_;
5971 %vars_scanned = ();
5972 return &variable_value_as_list_worker ($var, $cond, $parent);
5973 }
5975 # Define a new variable, but only if not already defined.
5976 sub define_variable
5977 {
5978 local ($var, $value) = @_;
5980 if (! defined $contents{$var})
5981 {
5982 $output_vars .= $var . ' = ' . $value . "\n";
5983 $contents{$var} = $value;
5984 $content_seen{$var} = 1;
5985 }
5986 elsif ($var_was_plus_eq{$var})
5987 {
5988 &am_line_error ($var, "internally generated variable \`$var' was set with \`+='");
5989 }
5990 }
5992 # Like define_variable, but the value is a list, and the variable may
5993 # be defined conditionally. The second argument is the conditional
5994 # under which the value should be defined; this should be the empty
5995 # string to define the variable unconditionally. The third argument
5996 # is a list holding the values to use for the variable. The value is
5997 # pretty printed in the output file.
5998 sub define_pretty_variable
5999 {
6000 local ($var, $cond, @value) = @_;
6001 if (! defined $contents{$var}
6002 || ($cond && ! &variable_defined ($var, $cond)))
6003 {
6004 $contents{$var} = join (' ', @value);
6005 if ($cond)
6006 {
6007 if ($conditional{$var})
6008 {
6009 $conditional{$var} .= ' ';
6010 }
6011 else
6012 {
6013 $conditional{$var} = '';
6014 }
6015 $conditional{$var} .= ($cond
6016 . ' '
6017 . "e_cond_val ($contents{$var}));
6018 }
6019 &pretty_print ($cond . $var . ' = ', $cond, @value);
6020 $content_seen{$var} = 1;
6021 }
6022 }
6024 # Like define_variable, but define a variable to be the configure
6025 # substitution by the same name.
6026 sub define_configure_variable
6027 {
6028 local ($var) = @_;
6029 local ($value) = '@' . $var . '@';
6030 &define_variable ($var, $value);
6031 }
6033 # Define a compiler variable. We also handle defining the `LT'
6034 # version of the command when using libtool.
6035 sub define_compiler_variable
6036 {
6037 local ($var, $ltcompile, $value) = @_;
6038 local ($name) = $var;
6039 &define_variable ($name, $value);
6040 &define_variable ('LT' . $name, $ltcompile . $value)
6041 if $seen_libtool;
6042 }
6044 # Define a variable that represents a program to run. If in Cygnus
6045 # mode, the program is searched for in the build (or source) tree.
6046 # Otherwise no searching is done at all. Arguments are:
6047 # * VAR Name of variable to define
6048 # * WHATDIR Either `src' or `build', depending on where program should
6049 # be found. (runtest is in srcdir!)
6050 # * SUBDIR Subdir of top-level dir
6051 # * PROGRAM Name of program
6052 # * OVERRIDE If specified, the name of the program to use when not in
6053 # Cygnus mode. Defaults to PROGRAM.
6054 sub define_program_variable
6055 {
6056 local ($var, $whatdir, $subdir, $program, $override) = @_;
6058 if (! $override)
6059 {
6060 $override = $program;
6061 }
6063 if ($cygnus_mode)
6064 {
6065 local ($full) = ('$(top_' . $whatdir . 'dir)/../'
6066 . $subdir . '/' . $program);
6067 &define_variable ($var, ('`if test -f ' . $full
6068 . '; then echo ' . $full . '; else echo '
6069 . $program . '; fi`'));
6070 }
6071 else
6072 {
6073 &define_variable ($var, $override);
6074 }
6075 }
6078 ################################################################
6080 # Read Makefile.am and set up %contents. Simultaneously copy lines
6081 # from Makefile.am into $output_trailer or $output_vars as
6082 # appropriate. NOTE we put rules in the trailer section. We want
6083 # user rules to come after our generated stuff.
6084 sub read_am_file
6085 {
6086 local ($amfile) = @_;
6087 local (*AM_FILE);
6089 open (AM_FILE, $amfile) || die "automake: couldn't open \`$amfile': $!\n";
6090 print "automake: reading $amfile\n" if $verbose;
6092 local ($saw_bk) = 0;
6093 local ($was_rule) = 0;
6094 local ($spacing) = '';
6095 local ($comment) = '';
6096 local ($last_var_name) = '';
6097 local ($blank) = 0;
6099 # We save the conditional stack on entry, and then check to make
6100 # sure it is the same on exit. This lets us conditonally include
6101 # other files.
6102 local (@saved_cond_stack) = @conditional_stack;
6104 while (<AM_FILE>)
6105 {
6106 if (/$IGNORE_PATTERN/o)
6107 {
6108 # Merely delete comments beginning with two hashes.
6109 }
6110 elsif (/$WHITE_PATTERN/o)
6111 {
6112 # Stick a single white line before the incoming macro or rule.
6113 $spacing = "\n";
6114 $blank = 1;
6115 }
6116 elsif (/$COMMENT_PATTERN/o)
6117 {
6118 # Stick comments before the incoming macro or rule. Make
6119 # sure a blank line preceeds first block of comments.
6120 $spacing = "\n" unless $blank;
6121 $blank = 1;
6122 $comment .= $spacing . $_;
6123 $spacing = '';
6124 }
6125 else
6126 {
6127 last;
6128 }
6129 }
6131 $output_vars .= $comment . "\n";
6132 $comment = '';
6133 $spacing = "\n";
6135 local ($is_ok_macro);
6136 while ($_)
6137 {
6138 $_ .= "\n"
6139 unless substr ($_, -1, 1) eq "\n";
6141 # Don't look at MAINTAINER_MODE_TRUE here. That shouldn't be
6142 # used by users. @MAINT@ is an anachronism now.
6143 $_ =~ s/\@MAINT\@//g
6144 unless $seen_maint_mode;
6146 if (/$IGNORE_PATTERN/o)
6147 {
6148 # Merely delete comments beginning with two hashes.
6149 }
6150 elsif (/$WHITE_PATTERN/o)
6151 {
6152 # Stick a single white line before the incoming macro or rule.
6153 $spacing = "\n";
6154 &am_line_error ($., "blank line following trailing backslash")
6155 if $saw_bk;
6156 }
6157 elsif (/$COMMENT_PATTERN/o)
6158 {
6159 # Stick comments before the incoming macro or rule.
6160 $comment .= $spacing . $_;
6161 $spacing = '';
6162 &am_line_error ($., "comment following trailing backslash")
6163 if $saw_bk;
6164 }
6165 elsif ($saw_bk)
6166 {
6167 if ($was_rule)
6168 {
6169 $output_trailer .= join ('', @conditional_stack) . $_;
6170 $saw_bk = /\\$/;
6171 }
6172 else
6173 {
6174 $saw_bk = /\\$/;
6175 $contents{$last_var_name} .= ' '
6176 unless $contents{$last_var_name} =~ /\s$/;
6177 $contents{$last_var_name} .= $_;
6178 if (@conditional_stack)
6179 {
6180 $conditional{$last_var_name} .= "e_cond_val ($_);
6181 }
6182 }
6183 }
6184 elsif (/$IF_PATTERN/o)
6185 {
6186 &am_line_error ($., "$1 does not appear in AM_CONDITIONAL")
6187 if (! $configure_cond{$1});
6188 push (@conditional_stack, "\@" . $1 . "_TRUE\@");
6189 }
6190 elsif (/$ELSE_PATTERN/o)
6191 {
6192 if (! @conditional_stack)
6193 {
6194 &am_line_error ($., "else without if");
6195 }
6196 elsif ($conditional_stack[$#conditional_stack] =~ /_FALSE\@$/)
6197 {
6198 &am_line_error ($., "else after else");
6199 }
6200 else
6201 {
6202 $conditional_stack[$#conditional_stack]
6203 =~ s/_TRUE\@$/_FALSE\@/;
6204 }
6205 }
6206 elsif (/$ENDIF_PATTERN/o)
6207 {
6208 if (! @conditional_stack)
6209 {
6210 &am_line_error ($., "endif without if");
6211 }
6212 else
6213 {
6214 pop @conditional_stack;
6215 }
6216 }
6217 elsif (/$RULE_PATTERN/o)
6218 {
6219 # Found a rule.
6220 $was_rule = 1;
6221 if (defined $contents{$1}
6222 && (@conditional_stack
6223 ? ! defined $conditional{$1}
6224 : defined $conditional{$1}))
6225 {
6226 &am_line_error ($1,
6227 "$1 defined both conditionally and unconditionally");
6228 }
6229 # Value here doesn't matter; for targets we only note
6230 # existence.
6231 $contents{$1} = 1;
6232 $targets{$1} = 1;
6233 local ($cond_string) = join ('', @conditional_stack);
6234 if (@conditional_stack)
6235 {
6236 if ($conditional{$1})
6237 {
6238 &check_ambiguous_conditional ($1, $cond_string);
6239 $conditional{$1} .= ' ';
6240 }
6241 else
6242 {
6243 $conditional{$1} = '';
6244 }
6245 $conditional{$1} .= $cond_string . ' 1';
6246 }
6247 $content_lines{$1} = $.;
6248 $output_trailer .= $comment . $spacing . $cond_string . $_;
6249 $comment = $spacing = '';
6250 $saw_bk = /\\$/;
6252 # Check the rule for being a suffix rule. If so, store in
6253 # a hash.
6255 local ($source_suffix);
6256 local ($object_suffix);
6258 if (($source_suffix, $object_suffix) = ($1 =~ $SUFFIX_RULE_PATTERN))
6259 {
6260 $suffix_rules{$source_suffix} = $object_suffix;
6261 print "Sources ending in .$source_suffix become .$object_suffix\n" if $verbose;
6262 $source_suffix_pattern = "(" . join ('|', keys %suffix_rules) . ")";
6263 }
6265 # FIXME: make sure both suffixes are in SUFFIXES? Or set
6266 # SUFFIXES from suffix_rules?
6267 }
6268 elsif (($is_ok_macro = /$MACRO_PATTERN/o)
6269 || /$BOGUS_MACRO_PATTERN/o)
6270 {
6271 # Found a macro definition.
6272 $was_rule = 0;
6273 $last_var_name = $1;
6274 if (defined $contents{$1}
6275 && (@conditional_stack
6276 ? ! defined $conditional{$1}
6277 : defined $conditional{$1}))
6278 {
6279 &am_line_error ($1,
6280 "$1 defined both conditionally and unconditionally");
6281 }
6282 local ($value);
6283 if ($3 ne '' && substr ($3, -1) eq "\\")
6284 {
6285 # We preserve the `\' because otherwise the long lines
6286 # that are generated will be truncated by broken
6287 # `sed's.
6288 $value = $3 . "\n";
6289 }
6290 else
6291 {
6292 $value = $3;
6293 }
6294 local ($type) = $2;
6296 if (! defined $contents{$last_var_name})
6297 {
6298 # The first assignment to a macro sets the line
6299 # number. Ideally I suppose we would associate line
6300 # numbers with random bits of text.
6301 $content_lines{$last_var_name} = $.;
6303 # If first assignment, set `+=' indicator.
6304 $var_was_plus_eq{$last_var_name} =
6305 ($type eq '+'
6306 && ! defined $am_var_defs{$last_var_name});
6307 }
6309 if ($type eq '+')
6310 {
6311 if (! defined $contents{$last_var_name}
6312 && defined $am_var_defs{$last_var_name})
6313 {
6314 $contents{$last_var_name} = $am_var_defs{$last_var_name};
6315 }
6316 if (substr ($contents{$last_var_name}, -1) eq "\n")
6317 {
6318 # Insert a backslash before a trailing newline.
6319 $contents{$last_var_name}
6320 = substr ($contents{$last_var_name}, 0, -1) . "\\\n";
6321 }
6322 $contents{$last_var_name} .= ' ' . $value;
6323 }
6324 else
6325 {
6326 $contents{$last_var_name} = $value;
6327 }
6328 local ($cond_string) = join ('', @conditional_stack);
6329 if (@conditional_stack)
6330 {
6331 local ($found) = 0;
6332 local ($val);
6333 if ($conditional{$last_var_name})
6334 {
6335 if ($type eq '+')
6336 {
6337 # If we're adding to the conditional, and it
6338 # exists, then we might want to simply replace
6339 # the old value with the new one.
6340 local (@new_vals, @cond_vals);
6341 @cond_vals = split (' ', $conditional{$last_var_name});
6342 while (@cond_vals)
6343 {
6344 local ($vcond) = shift (@cond_vals);
6345 push (@new_vals, $vcond);
6346 if (&conditional_same ($vcond, $cond_string))
6347 {
6348 $found = 1;
6349 $val = (&unquote_cond_val (shift (@cond_vals))
6350 . ' ' . $value);
6351 push (@new_vals, "e_cond_val ($val));
6352 }
6353 else
6354 {
6355 push (@new_vals, shift (@cond_vals));
6356 }
6357 }
6358 if ($found)
6359 {
6360 $conditional{$last_var_name}
6361 = join (' ', @new_vals);
6362 }
6363 }
6365 if (! $found)
6366 {
6367 &check_ambiguous_conditional ($last_var_name,
6368 $cond_string);
6369 $conditional{$last_var_name} .= ' ';
6370 $val = $value;
6371 }
6372 }
6373 else
6374 {
6375 $conditional{$last_var_name} = '';
6376 $val = $contents{$last_var_name};
6377 }
6378 if (! $found)
6379 {
6380 $conditional{$last_var_name} .= ($cond_string
6381 . ' '
6382 . "e_cond_val ($val));
6383 }
6384 }
6386 # FIXME: this doesn't always work correctly; it will group
6387 # all comments for a given variable, no matter where
6388 # defined.
6389 $am_vars{$last_var_name} = $comment . $spacing;
6390 $def_type{$last_var_name} = ($type eq ':') ? ':' : '';
6391 push (@var_list, $last_var_name);
6392 $comment = $spacing = '';
6393 $saw_bk = /\\$/;
6395 # Error if bogus.
6396 &am_line_error ($., "bad macro name \`$last_var_name'")
6397 if ! $is_ok_macro;
6398 }
6399 elsif (/$INCLUDE_PATTERN/o)
6400 {
6401 local ($path) = $1;
6403 if ($path =~ s/^\$\(top_srcdir\)\///)
6404 {
6405 push (@include_stack, "\$\(top_srcdir\)/$path");
6406 }
6407 else
6408 {
6409 $path =~ s/\$\(srcdir\)\///;
6410 push (@include_stack, "\$\(srcdir\)/$path");
6411 $path = $relative_dir . "/" . $path;
6412 }
6413 &read_am_file ($path);
6414 }
6415 else
6416 {
6417 # This isn't an error; it is probably a continued rule.
6418 # In fact, this is what we assume.
6419 $was_rule = 1;
6420 $output_trailer .= ($comment . $spacing
6421 . join ('', @conditional_stack) . $_);
6422 $comment = $spacing = '';
6423 $saw_bk = /\\$/;
6424 }
6426 $_ = <AM_FILE>;
6427 }
6429 $output_trailer .= $comment;
6431 if (join (' ', @saved_cond_stack) ne join (' ', @conditional_stack))
6432 {
6433 if (@conditional_stack)
6434 {
6435 &am_error ("unterminated conditionals: " . join (' ', @conditional_stack));
6436 }
6437 else
6438 {
6439 # FIXME: better error message here.
6440 &am_error ("conditionals not nested in include file");
6441 }
6442 }
6443 }
6445 # A helper for read_main_am_file which initializes configure variables
6446 # and variables from header-vars.am. This is a subr so we can call it
6447 # twice.
6448 sub define_standard_variables
6449 {
6450 # Compute relative location of the top object directory.
6451 local (@topdir) = ();
6452 foreach (split (/\//, $relative_dir))
6453 {
6454 next if $_ eq '.' || $_ eq '';
6455 if ($_ eq '..')
6456 {
6457 pop @topdir;
6458 }
6459 else
6460 {
6461 push (@topdir, '..');
6462 }
6463 }
6464 @topdir = ('.') if ! @topdir;
6466 $top_builddir = join ('/', @topdir);
6467 local ($build_rx);
6468 ($build_rx = $top_builddir) =~ s/(\W)/\\$1/g;
6469 $output_vars .= &file_contents_with_transform
6470 ('s/\@top_builddir\@/' . $build_rx . '/g;',
6471 'header-vars');
6473 # Generate some useful variables when AC_CANONICAL_* used. FIXME:
6474 # this should use generic %configure_vars method.
6475 if ($seen_canonical)
6476 {
6477 local ($curs, %vars);
6478 $vars{'host_alias'} = 'host_alias';
6479 $vars{'host_triplet'} = 'host';
6480 if ($seen_canonical == $AC_CANONICAL_SYSTEM)
6481 {
6482 $vars{'build_alias'} = 'build_alias';
6483 $vars{'build_triplet'} = 'build';
6484 $vars{'target_alias'} = 'target_alias';
6485 $vars{'target_triplet'} = 'target';
6486 }
6487 foreach $curs (sort keys %vars)
6488 {
6489 $output_vars .= "$curs = \@$vars{$curs}\@\n";
6490 $contents{$curs} = "\@$vars{$curs}\@";
6491 }
6492 }
6494 local ($curs);
6495 foreach $curs (sort keys %configure_vars)
6496 {
6497 &define_configure_variable ($curs);
6498 }
6499 }
6501 # Read main am file.
6502 sub read_main_am_file
6503 {
6504 local ($amfile) = @_;
6506 # The keys here are variables we want to dump at the end of this
6507 # function. The values are corresponding comments.
6508 local (%am_vars) = ();
6509 local (@var_list) = ();
6510 local (%def_type) = ();
6512 # This supports the strange variable tricks we are about to play.
6513 if (scalar keys %contents > 0)
6514 {
6515 print STDERR "automake: programming error: variable defined before read_main_am_file\n";
6516 exit 1;
6517 }
6519 # We want to predefine as many variables as possible. This lets
6520 # the user set them with `+=' in Makefile.am. However, we don't
6521 # want these initial definitions to end up in the output quite
6522 # yet. So we adopt a hack: read the `.am' file twice, throwing
6523 # away the output the first time. We also squirrel away a list of
6524 # all the variables defined by the .am file so that we know which
6525 # ones to remove from the content list.
6527 # First pass.
6528 &define_standard_variables;
6529 local (%saved_contents) = %contents;
6531 # Read user file, but discard text of variable assignments we just
6532 # made.
6533 $output_vars = '';
6534 &read_am_file ($amfile);
6536 # Now dump the variables that were defined. We do it in the same
6537 # order in which they were defined (skipping duplicates).
6538 local (%done);
6539 foreach $curs (@var_list)
6540 {
6541 next if $done{$curs};
6542 $done{$curs} = 1;
6544 $output_vars .= $am_vars{$curs};
6545 if ($conditional{$curs})
6546 {
6547 local (@cond_vals) = split (' ', $conditional{$curs});
6548 while (@cond_vals)
6549 {
6550 local ($vcond) = shift (@cond_vals);
6551 local ($val) = &unquote_cond_val (shift (@cond_vals));
6552 $output_vars .= ($vcond . $curs . ' '
6553 . $def_type{$curs} . "= ");
6554 local ($line);
6555 foreach $line (split ("\n", $val))
6556 {
6557 $output_vars .= $vcond . $line . "\n";
6558 }
6559 $output_vars .= "\n"
6560 if $val eq '';
6561 }
6562 }
6563 else
6564 {
6565 $output_vars .= ($curs . ' ' . $def_type{$curs} . '= '
6566 . $contents{$curs} . "\n");
6567 }
6568 }
6570 # Generate copyright header for generated Makefile.in.
6571 local ($ov) = $output_vars;
6572 $output_vars = ("# $in_file_name generated automatically by automake "
6573 . $VERSION . " from $am_file_name\n");
6574 $output_vars .= $gen_copyright;
6576 # Now go through and delete all the variables that the user did
6577 # not change.
6578 local ($var);
6579 foreach $var (keys %saved_contents)
6580 {
6581 if ($contents{$var} eq $saved_contents{$var})
6582 {
6583 delete $contents{$var};
6584 }
6585 }
6587 # Re-read the standard variables, and this time keep their
6588 # contributions to the output. Then add the user's output to the
6589 # end.
6590 &define_standard_variables;
6591 $output_vars .= $ov;
6593 }
6595 ################################################################
6597 sub initialize_global_constants
6598 {
6599 # Values for AC_CANONICAL_*
6600 $AC_CANONICAL_HOST = 1;
6601 $AC_CANONICAL_SYSTEM = 2;
6603 # Associative array of standard directory names. Entry is TRUE if
6604 # corresponding directory should be installed during
6605 # 'install-exec' phase.
6606 %exec_dir_p =
6607 ('bin', 1,
6608 'sbin', 1,
6609 'libexec', 1,
6610 'data', 0,
6611 'sysconf', 1,
6612 'localstate', 1,
6613 'lib', 1,
6614 'info', 0,
6615 'man', 0,
6616 'include', 0,
6617 'oldinclude', 0,
6618 'pkgdata', 0,
6619 'pkglib', 1,
6620 'pkginclude', 0
6621 );
6623 # Commonly found files we look for and automatically include in
6624 # DISTFILES.
6625 @common_files =
6626 (
6627 "README", "THANKS", "TODO", "NEWS", "COPYING", "COPYING.LIB",
6628 "INSTALL", "ABOUT-NLS", "ChangeLog", "configure", "configure.in",
6629 "config.guess", "config.sub", "AUTHORS", "BACKLOG", "ABOUT-GNU",
6630 "libversion.in", "mdate-sh", "mkinstalldirs", "install-sh",
6631 'texinfo.tex', "ansi2knr.c", "ansi2knr.1", 'elisp-comp',
6632 'ylwrap', 'acinclude.m4', @libtoolize_files,
6633 'missing', 'depcomp', 'compile', 'py-compile'
6634 );
6636 # Commonly used files we auto-include, but only sometimes.
6637 @common_sometimes =
6638 (
6639 "aclocal.m4", "acconfig.h", "config.h.top",
6640 "config.h.bot", "stamp-h.in", 'stamp-vti'
6641 );
6643 $USAGE = "\
6644 -a, --add-missing add missing standard files to package
6645 --amdir=DIR directory storing config files
6646 -c, --copy with -a, copy missing files (default is symlink)
6647 --cygnus assume program is part of Cygnus-style tree
6648 --force-missing force update of standard files
6649 --foreign set strictness to foreign
6650 --gnits set strictness to gnits
6651 --gnu set strictness to gnu
6652 --help print this help, then exit
6653 -i, --ignore-deps disable dependency tracking code
6654 --include-deps enable dependency tracking code
6655 --no-force only update Makefile.in's that are out of date
6656 -o DIR, --output-dir=DIR
6657 put generated Makefile.in's into DIR
6658 -v, --verbose verbosely list files processed
6659 --version print version number, then exit\n";
6661 # Copyright on generated Makefile.ins.
6662 $gen_copyright = "\
6663 # Copyright (C) 1994, 1995-9, 2000 Free Software Foundation, Inc.
6664 # This Makefile.in is free software; the Free Software Foundation
6665 # gives unlimited permission to copy and/or distribute it,
6666 # with or without modifications, as long as this notice is preserved.
6668 # This program is distributed in the hope that it will be useful,
6669 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
6670 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
6671 # PARTICULAR PURPOSE.
6672 ";
6674 # This complex find command will try to avoid changing the modes of
6675 # links into the source tree, in case they're hard-linked. It will
6676 # also make directories writable by everybody, because some
6677 # brain-dead tar implementations change ownership and permissions of
6678 # a directory before extracting the files, thus becoming unable to
6679 # extract them.
6680 # Ignore return result from chmod, because it might give an error
6681 # if we chmod a symlink.
6682 # Another nastiness: if the file is unreadable by us, we make it
6683 # readable regardless of the number of links to it. This only
6684 # happens in perverse cases.
6685 # We use $(install_sh) because that is a known-portable way to
6686 # modify the file in place in the source tree.
6687 $dist_header = ' -find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \\
6688 ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \\
6689 ! -type d ! -perm -400 -exec chmod a+r {} \; -o \\
6690 ! -type d ! -perm -444 -exec $(SHELL) $(install_sh) -c -m a+r {} {} \; \\
6691 || chmod -R a+r $(distdir)
6692 ';
6693 $dist{'dist-bzip2'} = ("\t"
6694 . '$(AMTAR) chof - $(distdir) | bzip2 -9 -c > $(distdir).bz2'
6695 . "\n");
6696 $dist{'dist-tarZ'} = ("\t"
6697 . '$(AMTAR) chof - $(distdir) | compress -c > $(distdir).tar.Z'
6698 . "\n");
6699 $dist{'dist-shar'} = ("\t"
6700 . 'shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c > $(distdir).shar.gz'
6701 . "\n");
6702 $dist{'dist-zip'} = ("\t" . '-rm -f $(distdir).zip' . "\n" .
6703 "\t" . 'zip -rq $(distdir).zip $(distdir)' . "\n");
6705 # Note that we don't use GNU tar's `-z' option. One reason (but
6706 # not the only reason) is that some versions of tar (e.g., OSF1)
6707 # interpret `-z' differently.
6708 $dist{'dist'} = ("\t"
6709 . '$(AMTAR) chof - $(distdir) | GZIP=$(GZIP_ENV) gzip -c > $(distdir).tar.gz'
6710 . "\n");
6711 $dist_trailer = "\t" . '-chmod -R a+w $(distdir) > /dev/null 2>&1; rm -rf $(distdir)' . "\n";
6712 }
6714 # (Re)-Initialize per-Makefile.am variables.
6715 sub initialize_per_input
6716 {
6717 # These two variables are used when generating each Makefile.in.
6718 # They hold the Makefile.in until it is ready to be printed.
6719 $output_rules = '';
6720 $output_vars = '';
6721 $output_trailer = '';
6722 $output_all = '';
6723 $output_header = '';
6725 # Suffixes found during a run.
6726 @suffixes = ();
6728 # This holds the contents of a Makefile.am, as parsed by
6729 # read_am_file.
6730 %contents = ();
6732 # This holds the names which are targets. These also appear in
6733 # %contents.
6734 %targets = ();
6736 # This maps a variable name onto a flag. The flag is true iff the
6737 # variable was first defined with `+='.
6738 %var_was_plus_eq = ();
6740 # This holds definitions of all variables defined in .am files.
6741 # This is used during startup to determine which variables can be
6742 # assigned with `+='.
6743 %am_var_defs = ();
6745 # For a variable or target which is defined conditionally, this
6746 # holds an array of the conditional values. The array is composed
6747 # of pairs of condition strings (the variables which configure
6748 # will substitute) and values (the value of a target is
6749 # meaningless). For an unconditional variable, this is empty.
6750 %conditional = ();
6752 # This holds the line numbers at which various elements of
6753 # %contents are defined.
6754 %content_lines = ();
6756 # This holds a 1 if a particular variable was examined.
6757 %content_seen = ();
6759 # This is the conditional stack.
6760 @conditional_stack = ();
6762 # This holds the set of included files.
6763 @include_stack = ();
6765 # This holds the "relative directory" of the current Makefile.in.
6766 # Eg for src/Makefile.in, this is "src".
6767 $relative_dir = '';
6769 # This holds a list of files that are included in the
6770 # distribution.
6771 %dist_common = ();
6773 # List of dependencies for the obvious targets.
6774 @install_data = ();
6775 @install_exec = ();
6776 @uninstall = ();
6777 @installdirs = ();
6779 @info = ();
6780 @dvi = ();
6781 @all = ();
6782 @check = ();
6783 @check_tests = ();
6784 @installcheck = ();
6785 @clean = ();
6787 @phony = ();
6789 # A list of files deleted by `maintainer-clean'.
6790 @maintainer_clean_files = ();
6792 # These are pretty obvious, too. They are used to define the
6793 # SOURCES and OBJECTS variables.
6794 @sources = ();
6795 @objects = ();
6796 # Sources which go in the distribution.
6797 @dist_sources = ();
6799 # This hash maps object file names onto their corresponding source
6800 # file names. This is used to ensure that each object is created
6801 # by a single source file.
6802 %object_map = ();
6804 # This keeps track of the directories for which we've already
6805 # created `.dirstamp' code.
6806 %directory_map = ();
6808 # These variables track inclusion of various compile-related .am
6809 # files. $included_generic_compile is TRUE if the basic code has
6810 # been included. $included_knr_compile is TRUE if the ansi2knr
6811 # code has been included. $included_libtool_compile is TRUE if
6812 # libtool support has been included.
6813 $included_generic_compile = 0;
6814 $included_knr_compile = 0;
6815 $included_libtool_compile = 0;
6817 # TRUE if install targets should work recursively.
6818 $recursive_install = 0;
6820 # All .P files.
6821 %dep_files = ();
6823 # Strictness levels.
6824 $strictness = $default_strictness;
6825 $strictness_name = $default_strictness_name;
6827 # Options from AUTOMAKE_OPTIONS.
6828 %options = ();
6830 # Whether or not dependencies are handled. Can be further changed
6831 # in handle_options.
6832 $use_dependencies = $cmdline_use_dependencies;
6834 # Per Makefile.am.
6835 $local_maint_charset = $maint_charset;
6837 # All yacc and lex source filenames for this directory. Use
6838 # filenames instead of raw count so that multiple instances are
6839 # counted correctly (eg one yacc file can appear in multiple
6840 # programs without harm).
6841 %yacc_sources = ();
6842 %lex_sources = ();
6844 # This is a list of all targets to run during "make dist".
6845 @dist_targets = ();
6847 # Keys in this hash are the basenames of files which must depend
6848 # on ansi2knr.
6849 %de_ansi_files = ();
6851 # This maps the source extension of a suffix rule to its
6852 # corresponding output extension.
6853 %suffix_rules = ();
6855 # This is a regular expression which matches all the known source
6856 # suffix. A source suffix is one that appears in the first
6857 # position of a suffix rule.
6858 $source_suffix_pattern = '';
6860 # This is the name of the recursive `all' target to use.
6861 $all_target = 'all-recursive';
6863 # This keeps track of which extensions we've seen (that we care
6864 # about).
6865 %extension_seen = ();
6867 # This is random scratch space for the language finish functions.
6868 # Don't randomly overwrite it; examine other uses of keys first.
6869 %language_scratch = ();
6871 # We keep track of which objects need special (per-executable)
6872 # handling on a per-language basis.
6873 %lang_specific_files = ();
6875 # This is set when `handle_dist' has finished. Once this happens,
6876 # we should no longer push on dist_common.
6877 $handle_dist_run = 0;
6878 }
6881 ################################################################
6883 # Return contents of a file from $am_dir, automatically skipping
6884 # macros or rules which are already known. Runs command on each line
6885 # as it is read; this command can modify $_.
6886 sub file_contents_with_transform
6887 {
6888 local ($command, $basename) = @_;
6889 local ($file) = $am_dir . '/' . $basename . '.am';
6891 if ($command ne '' && substr ($command, -1) ne ';')
6892 {
6893 die "automake: programming error in file_contents_with_transform: $command\n";
6894 }
6896 open (FC_FILE, $file)
6897 || die "automake: installation error: cannot open \`$file'\n";
6898 # Looks stupid?
6899 # print "automake: reading $file\n" if $verbose;
6901 local ($was_rule) = 0;
6902 local ($result_vars) = '';
6903 local ($result_rules) = '';
6904 local ($comment) = '';
6905 local ($spacing) = "\n";
6906 local ($skipping) = 0;
6907 local ($had_chars);
6909 while (<FC_FILE>)
6910 {
6911 $_ =~ s/\@MAINTAINER_MODE_TRUE\@//g
6912 unless $seen_maint_mode;
6914 $had_chars = length ($_) && $_ ne "\n";
6915 eval $command;
6916 # If the transform caused all the characters to go away, then
6917 # ignore the line. Why do this? Because in Perl 4, a "next"
6918 # inside of an eval doesn't affect a loop outside the eval.
6919 # So we can't pass in a "transform" that uses next. We used
6920 # to do this. "Empty" also means consisting of a single
6921 # newline.
6922 next if $had_chars && ($_ eq '' || $_ eq "\n");
6924 if (/$IGNORE_PATTERN/o)
6925 {
6926 # Merely delete comments beginning with two hashes.
6927 }
6928 elsif (/$WHITE_PATTERN/o)
6929 {
6930 # Stick a single white line before the incoming macro or rule.
6931 $spacing = "\n";
6932 &am_line_error ($., "blank line following trailing backslash")
6933 if $saw_bk;
6934 }
6935 elsif (/$COMMENT_PATTERN/o)
6936 {
6937 # Stick comments before the incoming macro or rule.
6938 $comment .= $spacing . $_;
6939 $spacing = '';
6940 &am_line_error ($., "comment following trailing backslash")
6941 if $saw_bk;
6942 }
6943 elsif ($saw_bk)
6944 {
6945 if ($was_rule)
6946 {
6947 $result_rules .= $_ if ! $skipping;
6948 }
6949 else
6950 {
6951 $result_vars .= $_ if ! $skipping;
6952 }
6953 $saw_bk = /\\$/;
6954 }
6955 elsif (/$RULE_PATTERN/o)
6956 {
6957 # Found a rule.
6958 $was_rule = 1;
6959 $skipping = defined $contents{$1};
6960 $result_rules .= $comment . $spacing . $_ if ! $skipping;
6961 $comment = $spacing = '';
6962 $saw_bk = /\\$/;
6963 }
6964 elsif (/$MACRO_PATTERN/o)
6965 {
6966 # Found a variable reference.
6967 $was_rule = 0;
6968 $skipping = defined $contents{$1};
6969 $result_vars .= $comment . $spacing . $_ if ! $skipping;
6970 $comment = $spacing = '';
6971 $saw_bk = /\\$/;
6972 print STDERR "automake: programming error: .am macro \`$1' with trailing backslash\n"
6973 if $saw_bk;
6974 $am_var_defs{$1} = $3;
6975 }
6976 else
6977 {
6978 # This isn't an error; it is probably a continued rule.
6979 # In fact, this is what we assume.
6980 $was_rule = 1;
6981 $result_rules .= $comment . $spacing . $_ if ! $skipping;
6982 $comment = $spacing = '';
6983 $saw_bk = /\\$/;
6984 }
6985 }
6987 close (FC_FILE);
6988 return $result_vars . $result_rules . $comment;
6989 }
6991 # Like file_contents_with_transform, but no transform.
6992 sub file_contents
6993 {
6994 return &file_contents_with_transform ('', @_);
6995 }
6997 # Find all variable prefixes that are used for install directories. A
6998 # prefix `zar' qualifies iff:
6999 # * `zardir' is a variable.
7000 # * `zar_PRIMARY' is a variable.
7001 sub am_primary_prefixes
7002 {
7003 local ($primary, $can_dist, @prefixes) = @_;
7005 local (%valid, $varname);
7006 grep ($valid{$_} = 0, @prefixes);
7007 $valid{'EXTRA'} = 0;
7008 foreach $varname (keys %contents)
7009 {
7010 if ($varname =~ /^(nobase_)?(dist_|nodist_)?(.*)_$primary$/)
7011 {
7012 if (($2 ne '' && ! $can_dist)
7013 || (! defined $valid{$3}
7014 && ! &variable_defined ($3 . 'dir')
7015 # Note that a configure variable is always
7016 # legitimate. It is natural to name such
7017 # variables after the primary, so we explicitly
7018 # allow it.
7019 && ! defined $configure_vars{$varname}))
7020 {
7021 &am_line_error ($varname, "invalid variable \`$varname'");
7022 }
7023 else
7024 {
7025 # Ensure all extended prefixes are actually used.
7026 $valid{$1 . $2 . $3} = 1;
7027 }
7028 }
7029 }
7031 return %valid;
7032 }
7034 # Handle `where_HOW' variable magic. Does all lookups, generates
7035 # install code, and possibly generates code to define the primary
7036 # variable. The first argument is the name of the .am file to munge,
7037 # the second argument is the primary variable (eg HEADERS), and all
7038 # subsequent arguments are possible installation locations. Returns
7039 # list of all values of all _HOW targets.
7040 #
7041 # FIXME: this should be rewritten to be cleaner. It should be broken
7042 # up into multiple functions.
7043 #
7044 # Usage is: am_install_var (OPTION..., file, HOW, where...)
7045 sub am_install_var
7046 {
7047 local (@args) = @_;
7049 local ($do_clean) = 0;
7050 local ($do_require) = 1;
7051 local ($can_dist) = 0;
7052 local ($default_dist) = 0;
7054 local ($ltxform);
7055 if (defined $configure_vars{'LIBTOOL'})
7056 {
7057 # Transform '@LIBTOOL ...@' to '$(LIBTOOL) ...'
7058 $ltxform = 's/\@LIBTOOL([^\@]*)\@/\$(LIBTOOL) $1/;';
7059 }
7060 else
7061 {
7062 # Delete '@LIBTOOL ...@'
7063 $ltxform = 's/\@LIBTOOL([^\@]*)\@//;';
7064 }
7066 local ($cygxform);
7067 if (! $seen_exeext)
7068 {
7069 $cygxform = 's/\@EXEEXT\@//g;';
7070 }
7071 else
7072 {
7073 $cygxform = 's/\@EXEEXT\@/\$(EXEEXT)/g;';
7074 }
7076 while (@args)
7077 {
7078 if ($args[0] eq '-clean')
7079 {
7080 $do_clean = 1;
7081 }
7082 elsif ($args[0] eq '-noextra')
7083 {
7084 $do_require = 0;
7085 }
7086 elsif ($args[0] eq '-candist')
7087 {
7088 $can_dist = 1;
7089 }
7090 elsif ($args[0] eq '-defaultdist')
7091 {
7092 $default_dist = 1;
7093 $can_dist = 1;
7094 }
7095 elsif ($args[0] !~ /^-/)
7096 {
7097 last;
7098 }
7099 shift (@args);
7100 }
7102 local ($file, $primary, @prefixes) = @args;
7104 local (@used) = ();
7105 local (@result) = ();
7107 # Now that configure substitutions are allowed in where_HOW
7108 # variables, it is an error to actually define the primary. We
7109 # allow `JAVA', as it is customarily used to mean the Java
7110 # interpreter. This is but one of several Java hacks. Similarly,
7111 # `PYTHON' is customarily used to mean the Python interpreter.
7112 &am_line_error ($primary, "\`$primary' is an anachronism")
7113 if &variable_defined ($primary)
7114 && ($primary ne 'JAVA' && $primary ne 'PYTHON');
7117 # Look for misspellings. It is an error to have a variable ending
7118 # in a "reserved" suffix whose prefix is unknown, eg
7119 # "bni_PROGRAMS". However, unusual prefixes are allowed if a
7120 # variable of the same name (with "dir" appended) exists. For
7121 # instance, if the variable "zardir" is defined, then
7122 # "zar_PROGRAMS" becomes valid. This is to provide a little extra
7123 # flexibility in those cases which need it.
7124 local (%valid) = &am_primary_prefixes ($primary, $can_dist, @prefixes);
7126 # If a primary includes a configure substitution, then the EXTRA_
7127 # form is required. Otherwise we can't properly do our job.
7128 local ($require_extra);
7129 local ($warned_about_extra) = 0;
7131 local ($clean_file) = $file . '-clean';
7132 local ($one_name);
7133 local ($X);
7134 local ($nodir_name);
7135 local ($strip_subdir) = 1;
7136 foreach $X (sort keys %valid)
7137 {
7138 $one_name = $X . '_' . $primary;
7139 if (&variable_defined ($one_name))
7140 {
7141 # If subdir prefix should be preserved, do so.
7142 if ($X =~ /^nobase_/)
7143 {
7144 $strip_subdir = 0;
7145 $X =~ s/^nobase_//;
7146 }
7148 # If files should be distributed, do so.
7149 if ($can_dist)
7150 {
7151 if (($default_dist && $one_name !~ /^nodist_/)
7152 || (! $default_dist && $one_name =~ /^dist_/))
7153 {
7154 &push_dist_common ('$(' . $one_name . ')');
7155 }
7156 ($nodir_name = $X) =~ s/^(dist|nodist)_//;
7157 }
7158 else
7159 {
7160 $nodir_name = $X;
7161 }
7163 # Append actual contents of where_PRIMARY variable to
7164 # result.
7165 local ($rcurs);
7166 foreach $rcurs (&variable_value_as_list ($one_name, 'all'))
7167 {
7168 # Skip configure substitutions. Possibly bogus.
7169 if ($rcurs =~ /^\@.*\@$/)
7170 {
7171 if ($X eq 'EXTRA')
7172 {
7173 if (! $warned_about_extra)
7174 {
7175 $warned_about_extra = 1;
7176 {
7177 &am_line_error ($one_name,
7178 "\`$one_name' contains configure substitution, but shouldn't");
7179 }
7180 }
7181 }
7182 # Check here to make sure variables defined in
7183 # configure.in do not imply that EXTRA_PRIMARY
7184 # must be defined.
7185 elsif (! defined $configure_vars{$one_name})
7186 {
7187 $require_extra = $one_name
7188 if $do_require;
7189 }
7191 next;
7192 }
7194 push (@result, $rcurs);
7195 }
7197 # A blatant hack: we rewrite each _PROGRAMS primary to
7198 # include EXEEXT when in Cygwin32 mode.
7199 if ($seen_exeext && $primary eq 'PROGRAMS')
7200 {
7201 local (@conds) = &variable_conditions ($one_name);
7202 local (@one_binlist);
7204 # FIXME: this definitely loses aesthetically; it
7205 # redefines $ONE_NAME. Instead we should arrange for
7206 # variable definitions to be output later, instead of
7207 # at scan time.
7209 if (! @conds)
7210 {
7211 @one_binlist = ();
7212 foreach $rcurs (&variable_value_as_list ($one_name, ''))
7213 {
7214 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
7215 {
7216 push (@one_binlist, $rcurs);
7217 }
7218 else
7219 {
7220 push (@one_binlist, $rcurs . '$(EXEEXT)');
7221 }
7222 }
7224 delete $contents{$one_name};
7225 &define_pretty_variable ($one_name, '', @one_binlist);
7226 }
7227 else
7228 {
7229 local ($cond);
7230 local ($condvals) = '';
7231 foreach $cond (@conds)
7232 {
7233 @one_binlist = ();
7234 local (@condval) = &variable_value_as_list ($one_name,
7235 $cond);
7236 foreach $rcurs (@condval)
7237 {
7238 if ($rcurs =~ /\./ || $rcurs =~ /^\@.*\@$/)
7239 {
7240 push (@one_binlist, $rcurs);
7241 }
7242 else
7243 {
7244 push (@one_binlist, $rcurs . '$(EXEEXT)');
7245 }
7246 }
7248 push (@condvals, $cond);
7249 push (@condvals, join (' ', @one_binlist));
7250 }
7252 delete $contents{$one_name};
7254 while (@condvals)
7255 {
7256 $cond = shift (@condvals);
7257 local (@val) = split (' ', shift (@condvals));
7258 &define_pretty_variable ($one_name, $cond, @val);
7259 }
7260 }
7261 }
7263 # "EXTRA" shouldn't be used when generating clean targets,
7264 # all, or install targets.
7265 if ($X eq 'EXTRA')
7266 {
7267 # We used to warn if EXTRA_FOO was defined uselessly,
7268 # but this was annoying.
7269 next;
7270 }
7272 if ($do_clean)
7273 {
7274 $output_rules .=
7275 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/go;'
7276 . $cygxform,
7277 $clean_file);
7279 push (@clean, $X . $primary);
7280 &push_phony_cleaners ($X . $primary);
7281 }
7283 if ($X eq 'check')
7284 {
7285 push (@check, '$(' . $one_name . ')');
7286 }
7287 else
7288 {
7289 push (@used, '$(' . $one_name . ')');
7290 }
7291 if ($X eq 'noinst' || $X eq 'check')
7292 {
7293 # Objects which don't get installed by default.
7294 next;
7295 }
7297 local ($subdir_xform);
7298 if ($strip_subdir)
7299 {
7300 $subdir_xform = 's/^NOBASE.*$//; s/^BASE//;';
7301 }
7302 else
7303 {
7304 $subdir_xform = 's/^BASE.*$//; s/^NOBASE//;';
7305 }
7307 $output_rules .=
7308 &file_contents_with_transform ('s/\@DIR\@/' . $X . '/g;'
7309 . 's/\@NDIR\@/' . $nodir_name . '/go;'
7310 . $ltxform . $cygxform
7311 . $subdir_xform,
7312 $file);
7314 push (@uninstall, 'uninstall-' . $X . $primary);
7315 push (@phony, 'uninstall-' . $X . $primary);
7316 push (@installdirs, '$(DESTDIR)$(' . $X . 'dir)');
7317 if (defined $exec_dir_p{$X} ? $exec_dir_p{$X} : ($X =~ /exec/))
7318 {
7319 push (@install_exec, 'install-' . $X . $primary);
7320 push (@phony, 'install-' . $X . $primary);
7321 }
7322 else
7323 {
7324 push (@install_data, 'install-' . $X . $primary);
7325 push (@phony, 'install-' . $X . $primary);
7326 }
7327 }
7328 }
7330 # The JAVA variable is used as the name of the Java interpreter.
7331 # The PYTHON variable is used as the name of the Python interpreter.
7332 if (@used && $primary ne 'JAVA' && $primary ne 'PYTHON')
7333 {
7334 # Define it.
7335 &define_pretty_variable ($primary, '', @used);
7336 $output_vars .= "\n";
7337 }
7339 if ($require_extra && ! &variable_defined ('EXTRA_' . $primary))
7340 {
7341 &am_line_error ($require_extra,
7342 "\`$require_extra' contains configure substitution, but \`EXTRA_$primary' not defined");
7343 }
7345 # Push here because PRIMARY might be configure time determined.
7346 push (@all, '$(' . $primary . ')')
7347 if @used && $primary ne 'JAVA' && $primary ne 'PYTHON';
7349 # Make the result unique. This lets the user use conditionals in
7350 # a natural way, but still lets us program lazily -- we don't have
7351 # to worry about handling a particular object more than once.
7352 local (%uniquify) = ();
7353 grep ($uniquify{$_} = 1, @result);
7354 return sort keys %uniquify;
7355 }
7358 ################################################################
7360 # Each key in this hash is the name of a directory holding a
7361 # Makefile.in. These variables are local to `is_make_dir'.
7362 %make_dirs = ();
7363 $make_dirs_set = 0;
7365 sub is_make_dir
7366 {
7367 local ($dir) = @_;
7368 if (! $make_dirs_set)
7369 {
7370 foreach $iter (@configure_input_files)
7371 {
7372 $make_dirs{&dirname ($iter)} = 1;
7373 }
7374 # We also want to notice Makefile.in's.
7375 foreach $iter (@other_input_files)
7376 {
7377 if ($iter =~ /Makefile\.in$/)
7378 {
7379 $make_dirs{&dirname ($iter)} = 1;
7380 }
7381 }
7382 $make_dirs_set = 1;
7383 }
7384 return defined $make_dirs{$dir};
7385 }
7387 ################################################################
7389 # This variable is local to the "require file" set of functions.
7390 @require_file_paths = ();
7392 # If a file name appears as a key in this hash, then it has already
7393 # been checked for. This variable is local to the "require file"
7394 # functions.
7395 %require_file_found = ();
7397 # See if we want to push this file onto dist_common. This function
7398 # encodes the rules for deciding when to do so.
7399 sub maybe_push_required_file
7400 {
7401 local ($dir, $file, $fullfile) = @_;
7403 # FIXME: Once again, special-case `.'.
7404 if ($dir eq $relative_dir || $dir eq '.')
7405 {
7406 &push_dist_common ($file);
7407 }
7408 elsif ($relative_dir eq '.' && ! &is_make_dir ($dir))
7409 {
7410 # If we are doing the topmost directory, and the file is in a
7411 # subdir which does not have a Makefile, then we distribute it
7412 # here.
7413 &push_dist_common ($fullfile);
7414 }
7415 }
7417 # Verify that the file must exist in the current directory. Usage:
7418 # require_file (isconfigure, line_number, strictness, file) strictness
7419 # is the strictness level at which this file becomes required. Must
7420 # set require_file_paths before calling this function.
7421 # require_file_paths is set to hold a single directory (the one in
7422 # which the first file was found) before return.
7423 sub require_file_internal
7424 {
7425 local ($is_configure, $line, $mystrict, @files) = @_;
7426 local ($file, $fullfile);
7427 local ($found_it, $dangling_sym, $errfile, $errdir);
7428 local ($save_dir);
7430 foreach $file (@files)
7431 {
7432 # If we've already looked for it, we're done.
7433 next if defined $require_file_found{$file};
7434 $require_file_found{$file} = 1;
7436 $found_it = 0;
7437 $dangling_sym = 0;
7438 foreach $dir (@require_file_paths)
7439 {
7440 if ($dir eq '.')
7441 {
7442 $fullfile = $relative_dir . "/" . $file;
7443 $errdir = $relative_dir unless $errdir;
7444 }
7445 else
7446 {
7447 $fullfile = $dir . "/" . $file;
7448 $errdir = $dir unless $errdir;
7449 }
7451 # Use different name for "error filename". Otherwise on
7452 # an error the bad file will be reported as eg
7453 # `../../install-sh' when using the default
7454 # config_aux_path.
7455 $errfile = $errdir . '/' . $file;
7457 if (-l $fullfile && ! -f readlink ($fullfile))
7458 {
7459 $dangling_sym = 1;
7460 last;
7461 }
7462 elsif (-f $fullfile)
7463 {
7464 $found_it = 1;
7465 &maybe_push_required_file ($dir, $file, $fullfile);
7466 $save_dir = $dir;
7467 last;
7468 }
7469 }
7471 if ($found_it && ! $force_missing)
7472 {
7473 # Prune the path list.
7474 @require_file_paths = $save_dir;
7475 }
7476 else
7477 {
7478 if ($strictness >= $mystrict)
7479 {
7480 if ($dangling_sym && ($force_missing || $add_missing))
7481 {
7482 unlink ($fullfile);
7483 }
7485 local ($trailer) = '';
7486 local ($suppress) = 0;
7488 # Only install missing files according to our desired
7489 # strictness level.
7490 local ($message) = "required file \`$errfile' not found";
7491 if ($add_missing)
7492 {
7493 $suppress = 1;
7495 # Maybe run libtoolize.
7496 local @syslist = ('libtoolize', '--automake');
7497 push @syslist, '--copy'
7498 if $copy_missing;
7499 if ($seen_libtool
7500 && grep ($_ eq $file, @libtoolize_files)
7501 && system (@syslist))
7502 {
7503 $message = "installing \`$errfile'";
7504 $suppress = 0;
7505 $trailer = "; cannot run \`libtoolize': $!";
7506 }
7507 elsif (-f ($am_dir . '/' . $file))
7508 {
7509 # Install the missing file. Symlink if we
7510 # can, copy if we must. Note: delete the file
7511 # first, in case it is a dangling symlink.
7512 $message = "installing \`$errfile'";
7513 # Windows Perl will hang if we try to delete a
7514 # file that doesn't exist.
7515 unlink ($errfile) if -f $errfile;
7516 if ($symlink_exists && ! $copy_missing)
7517 {
7518 if (! symlink ($am_dir . '/' . $file, $errfile))
7519 {
7520 $suppress = 0;
7521 $trailer = "; error while making link: $!";
7522 }
7523 }
7524 elsif (system ('cp', $am_dir . '/' . $file, $errfile))
7525 {
7526 $suppress = 0;
7527 $trailer = "\n error while copying";
7528 }
7529 }
7531 &maybe_push_required_file (&dirname ($errfile),
7532 $errfile, $errfile);
7533 }
7535 local ($save) = $exit_status;
7536 if ($is_configure)
7537 {
7538 # FIXME: allow actual file to be specified.
7539 &am_conf_line_error ('configure.in', $line,
7540 "$message$trailer");
7541 }
7542 else
7543 {
7544 &am_line_error ($line, "$message$trailer");
7545 }
7546 $exit_status = $save if $suppress;
7547 }
7548 }
7549 }
7550 }
7552 # Like require_file_with_line, but error messages refer to
7553 # configure.in, not the current Makefile.am.
7554 sub require_file_with_conf_line
7555 {
7556 @require_file_paths = '.';
7557 &require_file_internal (1, @_);
7558 }
7560 sub require_file_with_line
7561 {
7562 @require_file_paths = '.';
7563 &require_file_internal (0, @_);
7564 }
7566 sub require_file
7567 {
7568 @require_file_paths = '.';
7569 &require_file_internal (0, '', @_);
7570 }
7572 # Require a file that is also required by Autoconf. Looks in
7573 # configuration path, as specified by AC_CONFIG_AUX_DIR.
7574 sub require_config_file
7575 {
7576 @require_file_paths = @config_aux_path;
7577 &require_file_internal (1, '', @_);
7578 local ($dir) = $require_file_paths[0];
7579 @config_aux_path = @require_file_paths;
7580 if ($dir eq '.')
7581 {
7582 $config_aux_dir = '.';
7583 }
7584 else
7585 {
7586 $config_aux_dir = '$(top_srcdir)/' . $dir;
7587 }
7588 }
7590 # Assumes that the line number is in Makefile.am.
7591 sub require_conf_file_with_line
7592 {
7593 @require_file_paths = @config_aux_path;
7594 &require_file_internal (0, @_);
7595 local ($dir) = $require_file_paths[0];
7596 @config_aux_path = @require_file_paths;
7597 if ($dir eq '.')
7598 {
7599 $config_aux_dir = '.';
7600 }
7601 else
7602 {
7603 $config_aux_dir = '$(top_srcdir)/' . $dir;
7604 }
7605 }
7607 # Assumes that the line number is in configure.in.
7608 sub require_conf_file_with_conf_line
7609 {
7610 @require_file_paths = @config_aux_path;
7611 &require_file_internal (1, @_);
7612 local ($dir) = $require_file_paths[0];
7613 @config_aux_path = @require_file_paths;
7614 if ($dir eq '.')
7615 {
7616 $config_aux_dir = '.';
7617 }
7618 else
7619 {
7620 $config_aux_dir = '$(top_srcdir)/' . $dir;
7621 }
7622 }
7624 ################################################################
7626 # Push a list of files onto dist_common.
7627 sub push_dist_common
7628 {
7629 local (@files) = @_;
7630 local ($file);
7632 foreach $file (@files)
7633 {
7634 if (! defined $dist_common{$file})
7635 {
7636 if ($handle_dist_run)
7637 {
7638 print STDERR
7639 "automake: programming error: push_dist_common run after handle_dist\n";
7640 exit 1;
7641 }
7642 $dist_common{$file} = 1;
7643 }
7644 }
7645 }
7647 # Push a list of clean targets onto phony.
7648 sub push_phony_cleaners
7649 {
7650 local ($base) = @_;
7651 local ($target);
7652 foreach $target ('mostly', 'dist', '', 'maintainer-')
7653 {
7654 push (@phony, $target . 'clean-' . $base);
7655 }
7656 }
7658 # Set strictness.
7659 sub set_strictness
7660 {
7661 $strictness_name = $_[0];
7662 if ($strictness_name eq 'gnu')
7663 {
7664 $strictness = $GNU;
7665 }
7666 elsif ($strictness_name eq 'gnits')
7667 {
7668 $strictness = $GNITS;
7669 }
7670 elsif ($strictness_name eq 'foreign')
7671 {
7672 $strictness = $FOREIGN;
7673 }
7674 else
7675 {
7676 die "automake: level \`$strictness_name' not recognized\n";
7677 }
7678 }
7681 ################################################################
7683 # Return directory name of file.
7684 sub dirname
7685 {
7686 local ($file) = @_;
7687 local ($sub);
7689 ($sub = $file) =~ s,/+[^/]+$,,g;
7690 $sub = '.' if $sub eq $file;
7691 return $sub;
7692 }
7694 # Return file name of a file.
7695 sub basename
7696 {
7697 local ($file) = @_;
7698 local ($sub);
7700 ($sub = $file) =~s,^.*/+,,g;
7701 return $sub;
7702 }
7704 # Ensure a file exists.
7705 sub create
7706 {
7707 local ($file) = @_;
7709 open (TOUCH, ">> $file");
7710 close (TOUCH);
7711 }
7713 # Glob something. Do this to avoid indentation screwups everywhere we
7714 # want to glob. Gross!
7715 sub my_glob
7716 {
7717 local ($pat) = @_;
7718 return <${pat}>;
7719 }
7721 ################################################################
7723 # Print an error message and set exit status.
7724 sub am_error
7725 {
7726 warn "automake: ${am_file}.am: ", join (' ', @_), "\n";
7727 $exit_status = 1;
7728 }
7730 sub am_line_error
7731 {
7732 local ($symbol, @args) = @_;
7734 if ($symbol && "$symbol" ne '-1')
7735 {
7736 local ($file) = "${am_file}.am";
7738 if ($symbol =~ /^\d+$/)
7739 {
7740 # SYMBOL is a line number, so just add the colon.
7741 $file .= ':' . $symbol;
7742 }
7743 elsif (defined $content_lines{$symbol})
7744 {
7745 # SYMBOL is a variable defined in Makefile.am, so add the
7746 # line number we saved from there.
7747 $file .= ':' . $content_lines{$symbol};
7748 }
7749 elsif (defined $configure_vars{$symbol})
7750 {
7751 # SYMBOL is a variable defined in configure.in, so add the
7752 # appropriate line number.
7753 $file = $configure_vars{$symbol};
7754 }
7755 else
7756 {
7757 # Couldn't find the line number.
7758 }
7759 warn $file, ": ", join (' ', @args), "\n";
7760 $exit_status = 1;
7761 }
7762 else
7763 {
7764 &am_error (@args);
7765 }
7766 }
7768 # Like am_error, but while scanning configure.in.
7769 sub am_conf_error
7770 {
7771 # FIXME: can run in subdirs.
7772 warn "automake: configure.in: ", join (' ', @_), "\n";
7773 $exit_status = 1;
7774 }
7776 # Error message with line number referring to configure.in.
7777 sub am_conf_line_error
7778 {
7779 local ($file, $line, @args) = @_;
7781 if ($line)
7782 {
7783 warn "$file: $line: ", join (' ', @args), "\n";
7784 $exit_status = 1;
7785 }
7786 else
7787 {
7788 &am_conf_error (@args);
7789 }
7790 }
7792 # Warning message with line number referring to configure.in.
7793 # Does not affect exit_status
7794 sub am_conf_line_warning
7795 {
7796 local ($saved_exit_status) = $exit_status;
7797 &am_conf_line_error (@_);
7798 $exit_status = $saved_exit_status;
7799 }
7801 # Tell user where our aclocal.m4 is, but only once.
7802 sub keyed_aclocal_warning
7803 {
7804 local ($key) = @_;
7805 warn "automake: macro \`$key' can be generated by \`aclocal'\n";
7806 }
7808 # Print usage information.
7809 sub usage
7810 {
7811 print "Usage: automake [OPTION] ... [Makefile]...\n\n";
7812 print "Generate Makefile.in for autoconf from Makefile.am\n";
7813 print $USAGE;
7814 print "\nFiles which are automatically distributed, if found:\n";
7815 $~ = "USAGE_FORMAT";
7816 local ($last, $iter, @lcomm);
7817 $last = '';
7818 foreach $iter (sort ((@common_files, @common_sometimes)))
7819 {
7820 push (@lcomm, $iter) unless $iter eq $last;
7821 $last = $iter;
7822 }
7824 local ($one, $two, $three, $four, $i, $max);
7825 $max = int (($#lcomm + 1) / 4);
7827 for ($i = 0; $i < $max; ++$i)
7828 {
7829 $one = $lcomm[$i];
7830 $two = $lcomm[$max + $i];
7831 $three = $lcomm[2 * $max + $i];
7832 $four = $lcomm[3 * $max + $i];
7833 write;
7834 }
7836 local ($mod) = ($#lcomm + 1) % 4;
7837 if ($mod != 0)
7838 {
7839 $one = $lcomm[$max];
7840 $two = ($mod > 1) ? $lcomm[2 * $max] : '';
7841 $three = ($mod > 2) ? $lcomm[3 * $max] : '';
7842 $four = ($mod > 3) ? $lcomm[4 * $max] : '';
7843 write;
7844 }
7846 print "\nReport bugs to <bug-automake\@gnu.org>.\n";
7848 exit 0;
7849 }
7851 format USAGE_FORMAT =
7852 @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<
7853 $one, $two, $three, $four
7854 .