diff options
Diffstat (limited to 'lib')
53 files changed, 32174 insertions, 0 deletions
diff --git a/lib/Autom4te/C4che.pm b/lib/Autom4te/C4che.pm new file mode 100644 index 0000000..b91a5e8 --- /dev/null +++ b/lib/Autom4te/C4che.pm @@ -0,0 +1,242 @@ +# autoconf -- create `configure' using m4 macros +# Copyright (C) 2003, 2006, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +package Autom4te::C4che; + +=head1 NAME + +Autom4te::C4che - a single m4 run request + +=head1 SYNOPSIS + + use Autom4te::C4che; + +=head1 DESCRIPTION + +This Perl module handles the cache of M4 runs used by autom4te. + +=cut + +use Data::Dumper; +use Autom4te::Request; +use Carp; +use strict; + +=over 4 + +=item @request + +List of requests. + +We cannot declare it "my" as the loading, performed via "do", would +refer to another scope, and @request would not be updated. It used to +work with "my" vars, and I do not know whether the current behavior +(5.6) is wanted or not. + +=cut + +use vars qw(@request); + +=item C<$req = Autom4te::C4che-E<gt>retrieve (%attr)> + +Find a request with the same path and input. + +=cut + +sub retrieve($%) +{ + my ($self, %attr) = @_; + + foreach (@request) + { + # Same path. + next + if join ("\n", @{$_->path}) ne join ("\n", @{$attr{path}}); + + # Same inputs. + next + if join ("\n", @{$_->input}) ne join ("\n", @{$attr{input}}); + + # Found it. + return $_; + } + + return undef; +} + +=item C<$req = Autom4te::C4che-E<gt>register (%attr)> + +Create and register a request for these path and input. + +=cut + +# $REQUEST-OBJ +# register ($SELF, %ATTR) +# ----------------------- +# NEW should not be called directly. +# Private. +sub register ($%) +{ + my ($self, %attr) = @_; + + # path and input are the only ID for a request object. + my $obj = new Autom4te::Request ('path' => $attr{path}, + 'input' => $attr{input}); + push @request, $obj; + + # Assign an id for cache file. + $obj->id ("$#request"); + + return $obj; +} + + +=item C<$req = Autom4te::C4che-E<gt>request (%request)> + +Get (retrieve or create) a request for the path C<$request{path}> and +the input C<$request{input}>. + +=cut + +# $REQUEST-OBJ +# request($SELF, %REQUEST) +# ------------------------ +sub request ($%) +{ + my ($self, %request) = @_; + + my $req = + Autom4te::C4che->retrieve (%request) + || Autom4te::C4che->register (%request); + + # If there are new traces to produce, then we are not valid. + foreach (@{$request{'macro'}}) + { + if (! exists ${$req->macro}{$_}) + { + ${$req->macro}{$_} = 1; + $req->valid (0); + } + } + + # It would be great to have $REQ check that it is up to date wrt + # its dependencies, but that requires getting traces (to fetch the + # included files), which is out of the scope of Request (currently?). + + return $req; +} + + +=item C<$string = Autom4te::C4che-E<gt>marshall ()> + +Serialize all the current requests. + +=cut + + +# marshall($SELF) +# --------------- +sub marshall ($) +{ + my ($caller) = @_; + my $res = ''; + + my $marshall = Data::Dumper->new ([\@request], [qw (*request)]); + $marshall->Indent(2)->Terse(0); + $res = $marshall->Dump . "\n"; + + return $res; +} + + +=item C<Autom4te::C4che-E<gt>save ($file)> + +Save the cache in the C<$file> file object. + +=cut + +# SAVE ($FILE) +# ------------ +sub save ($$) +{ + my ($self, $file) = @_; + + confess "cannot save a single request\n" + if ref ($self); + + $file->seek (0, 0); + $file->truncate (0); + print $file + "# This file was generated.\n", + "# It contains the lists of macros which have been traced.\n", + "# It can be safely removed.\n", + "\n", + $self->marshall; +} + + +=item C<Autom4te::C4che-E<gt>load ($file)> + +Load the cache from the C<$file> file object. + +=cut + +# LOAD ($FILE) +# ------------ +sub load ($$) +{ + my ($self, $file) = @_; + my $fname = $file->name; + + confess "cannot load a single request\n" + if ref ($self); + + my $contents = join "", $file->getlines; + + eval $contents; + + confess "cannot eval $fname: $@\n" if $@; +} + + +=head1 SEE ALSO + +L<Autom4te::Request> + +=head1 HISTORY + +Written by Akim Demaille E<lt>F<akim@freefriends.org>E<gt>. + +=cut + +1; # for require + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/ChannelDefs.pm b/lib/Autom4te/ChannelDefs.pm new file mode 100644 index 0000000..0d5b5c4 --- /dev/null +++ b/lib/Autom4te/ChannelDefs.pm @@ -0,0 +1,390 @@ +# Copyright (C) 2002-2003, 2006, 2008-2012 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +package Autom4te::ChannelDefs; + +use Autom4te::Channels; + +=head1 NAME + +Autom4te::ChannelDefs - channel definitions for Automake and helper functions + +=head1 SYNOPSIS + + use Autom4te::ChannelDefs; + + print Autom4te::ChannelDefs::usage (), "\n"; + prog_error ($MESSAGE, [%OPTIONS]); + error ($WHERE, $MESSAGE, [%OPTIONS]); + error ($MESSAGE); + fatal ($WHERE, $MESSAGE, [%OPTIONS]); + fatal ($MESSAGE); + verb ($MESSAGE, [%OPTIONS]); + switch_warning ($CATEGORY); + parse_WARNINGS (); + parse_warnings ($OPTION, @ARGUMENT); + Autom4te::ChannelDefs::set_strictness ($STRICTNESS_NAME); + +=head1 DESCRIPTION + +This package defines channels that can be used in Automake to +output diagnostics and other messages (via C<msg()>). It also defines +some helper function to enable or disable these channels, and some +shorthand function to output on specific channels. + +=cut + +use 5.006; +use strict; +use Exporter; + +use vars qw (@ISA @EXPORT); + +@ISA = qw (Exporter); +@EXPORT = qw (&prog_error &error &fatal &verb + &switch_warning &parse_WARNINGS &parse_warnings); + +=head2 CHANNELS + +The following channels can be used as the first argument of +C<Autom4te::Channel::msg>. For some of them we list a shorthand +function that makes the code more readable. + +=over 4 + +=item C<fatal> + +Fatal errors. Use C<&fatal> to send messages over this channel. + +=item C<error> + +Common errors. Use C<&error> to send messages over this channel. + +=item C<error-gnu> + +Errors related to GNU Standards. + +=item C<error-gnu/warn> + +Errors related to GNU Standards that should be warnings in "foreign" mode. + +=item C<error-gnits> + +Errors related to GNITS Standards (silent by default). + +=item C<automake> + +Internal errors. Use C<&prog_error> to send messages over this channel. + +=item C<cross> + +Constructs compromising the cross-compilation of the package. + +=item C<gnu> + +Warnings related to GNU Coding Standards. + +=item C<obsolete> + +Warnings about obsolete features (silent by default). + +=item C<override> + +Warnings about user redefinitions of Automake rules or +variables (silent by default). + +=item C<portability> + +Warnings about non-portable constructs. + +=item C<syntax> + +Warnings about weird syntax, unused variables, typos ... + +=item C<unsupported> + +Warnings about unsupported (or mis-supported) features. + +=item C<verb> + +Messages output in C<--verbose> mode. Use C<&verb> to send such messages. + +=item C<note> + +Informative messages. + +=back + +=cut + +# Initialize our list of error/warning channels. +# Do not forget to update &usage and the manual +# if you add or change a warning channel. + +register_channel 'fatal', type => 'fatal', ordered => 0; +register_channel 'error', type => 'error'; +register_channel 'error-gnu', type => 'error'; +register_channel 'error-gnu/warn', type => 'error'; +register_channel 'error-gnits', type => 'error', silent => 1; +register_channel 'automake', type => 'fatal', backtrace => 1, + header => ("####################\n" . + "## Internal Error ##\n" . + "####################\n"), + footer => "\nPlease contact <bug-automake\@gnu.org>.", + ordered => 0; + +register_channel 'cross', type => 'warning', silent => 1; +register_channel 'gnu', type => 'warning'; +register_channel 'obsolete', type => 'warning', silent => 1; +register_channel 'override', type => 'warning', silent => 1; +register_channel 'portability', type => 'warning', silent => 1; +register_channel 'syntax', type => 'warning'; +register_channel 'unsupported', type => 'warning'; + +register_channel 'verb', type => 'debug', silent => 1, ordered => 0; +register_channel 'note', type => 'debug', silent => 0; + +=head2 FUNCTIONS + +=over 4 + +=item C<usage ()> + +Return the warning category descriptions. + +=cut + +sub usage () +{ + return "Warning categories include: + `cross' cross compilation issues + `gnu' GNU coding standards (default in gnu and gnits modes) + `obsolete' obsolete features or constructions + `override' user redefinitions of Automake rules or variables + `portability' portability issues (default in gnu and gnits modes) + `syntax' dubious syntactic constructs (default) + `unsupported' unsupported or incomplete features (default) + `all' all the warnings + `no-CATEGORY' turn off warnings in CATEGORY + `none' turn off all the warnings + `error' treat warnings as errors"; +} + +=item C<prog_error ($MESSAGE, [%OPTIONS])> + +Signal a programming error (on channel C<automake>), +display C<$MESSAGE>, and exit 1. + +=cut + +sub prog_error ($;%) +{ + my ($msg, %opts) = @_; + msg 'automake', '', $msg, %opts; +} + +=item C<error ($WHERE, $MESSAGE, [%OPTIONS])> + +=item C<error ($MESSAGE)> + +Uncategorized errors. + +=cut + +sub error ($;$%) +{ + my ($where, $msg, %opts) = @_; + msg ('error', $where, $msg, %opts); +} + +=item C<fatal ($WHERE, $MESSAGE, [%OPTIONS])> + +=item C<fatal ($MESSAGE)> + +Fatal errors. + +=cut + +sub fatal ($;$%) +{ + my ($where, $msg, %opts) = @_; + msg ('fatal', $where, $msg, %opts); +} + +=item C<verb ($MESSAGE, [%OPTIONS])> + +C<--verbose> messages. + +=cut + +sub verb ($;%) +{ + my ($msg, %opts) = @_; + msg 'verb', '', $msg, %opts; +} + +=item C<switch_warning ($CATEGORY)> + +If C<$CATEGORY> is C<mumble>, turn on channel C<mumble>. +If it is C<no-mumble>, turn C<mumble> off. +Else handle C<all> and C<none> for completeness. + +=cut + +sub switch_warning ($) +{ + my ($cat) = @_; + my $has_no = 0; + + if ($cat =~ /^no-(.*)$/) + { + $cat = $1; + $has_no = 1; + } + + if ($cat eq 'all') + { + setup_channel_type 'warning', silent => $has_no; + } + elsif ($cat eq 'none') + { + setup_channel_type 'warning', silent => ! $has_no; + } + elsif ($cat eq 'error') + { + $warnings_are_errors = ! $has_no; + # Set exit code if Perl warns about something + # (like uninitialized variables). + $SIG{"__WARN__"} = + $has_no ? 'DEFAULT' : sub { print STDERR @_; $exit_code = 1; }; + } + elsif (channel_type ($cat) eq 'warning') + { + setup_channel $cat, silent => $has_no; + } + else + { + return 1; + } + return 0; +} + +=item C<parse_WARNINGS ()> + +Parse the WARNINGS environment variable. + +=cut + +sub parse_WARNINGS () +{ + if (exists $ENV{'WARNINGS'}) + { + # Ignore unknown categories. This is required because WARNINGS + # should be honored by many tools. + switch_warning $_ foreach (split (',', $ENV{'WARNINGS'})); + } +} + +=item C<parse_warnings ($OPTION, @ARGUMENT)> + +Parse the argument of C<--warning=CATEGORY> or C<-WCATEGORY>. + +C<$OPTIONS> is C<"--warning"> or C<"-W">, C<@ARGUMENT> is a list of +C<CATEGORY>. + +This can be used as an argument to C<Getopt>. + +=cut + +sub parse_warnings ($@) +{ + my ($opt, @categories) = @_; + + foreach my $cat (map { split ',' } @categories) + { + msg 'unsupported', "unknown warning category `$cat'" + if switch_warning $cat; + } +} + +=item C<set_strictness ($STRICTNESS_NAME)> + +Configure channels for strictness C<$STRICTNESS_NAME>. + +=cut + +sub set_strictness ($) +{ + my ($name) = @_; + + if ($name eq 'gnu') + { + setup_channel 'error-gnu', silent => 0; + setup_channel 'error-gnu/warn', silent => 0, type => 'error'; + setup_channel 'error-gnits', silent => 1; + setup_channel 'portability', silent => 0; + setup_channel 'gnu', silent => 0; + } + elsif ($name eq 'gnits') + { + setup_channel 'error-gnu', silent => 0; + setup_channel 'error-gnu/warn', silent => 0, type => 'error'; + setup_channel 'error-gnits', silent => 0; + setup_channel 'portability', silent => 0; + setup_channel 'gnu', silent => 0; + } + elsif ($name eq 'foreign') + { + setup_channel 'error-gnu', silent => 1; + setup_channel 'error-gnu/warn', silent => 0, type => 'warning'; + setup_channel 'error-gnits', silent => 1; + setup_channel 'portability', silent => 1; + setup_channel 'gnu', silent => 1; + } + else + { + prog_error "level `$name' not recognized\n"; + } +} + +=back + +=head1 SEE ALSO + +L<Autom4te::Channels> + +=head1 HISTORY + +Written by Alexandre Duret-Lutz E<lt>F<adl@gnu.org>E<gt>. + +=cut + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/Channels.pm b/lib/Autom4te/Channels.pm new file mode 100644 index 0000000..1f0fc1e --- /dev/null +++ b/lib/Autom4te/Channels.pm @@ -0,0 +1,836 @@ +# Copyright (C) 2002-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +############################################################### +# The main copy of this file is in Automake's git repository. # +# Updates should be sent to automake-patches@gnu.org. # +############################################################### + +package Autom4te::Channels; + +=head1 NAME + +Autom4te::Channels - support functions for error and warning management + +=head1 SYNOPSIS + + use Autom4te::Channels; + + # Register a channel to output warnings about unused variables. + register_channel 'unused', type => 'warning'; + + # Register a channel for system errors. + register_channel 'system', type => 'error', exit_code => 4; + + # Output a message on channel 'unused'. + msg 'unused', "$file:$line", "unused variable '$var'"; + + # Make the 'unused' channel silent. + setup_channel 'unused', silent => 1; + + # Turn on all channels of type 'warning'. + setup_channel_type 'warning', silent => 0; + + # Redirect all channels to push messages on a Thread::Queue using + # the specified serialization key. + setup_channel_queue $queue, $key; + + # Output a message pending in a Thread::Queue. + pop_channel_queue $queue; + + # Treat all warnings as errors. + $warnings_are_errors = 1; + + # Exit with the greatest exit code encountered so far. + exit $exit_code; + +=head1 DESCRIPTION + +This perl module provides support functions for handling diagnostic +channels in programs. Channels can be registered to convey fatal, +error, warning, or debug messages. Each channel has various options +(e.g. is the channel silent, should duplicate messages be removed, +etc.) that can also be overridden on a per-message basis. + +=cut + +use 5.006; +use strict; +use Exporter; +use Carp; +use File::Basename; + +use vars qw (@ISA @EXPORT %channels $me); + +@ISA = qw (Exporter); +@EXPORT = qw ($exit_code $warnings_are_errors + &reset_local_duplicates &reset_global_duplicates + ®ister_channel &msg &exists_channel &channel_type + &setup_channel &setup_channel_type + &dup_channel_setup &drop_channel_setup + &buffer_messages &flush_messages + &setup_channel_queue &pop_channel_queue + US_GLOBAL US_LOCAL + UP_NONE UP_TEXT UP_LOC_TEXT); + +$me = basename $0; + +=head2 Global Variables + +=over 4 + +=item C<$exit_code> + +The greatest exit code seen so far. C<$exit_code> is updated from +the C<exit_code> options of C<fatal> and C<error> channels. + +=cut + +use vars qw ($exit_code); +$exit_code = 0; + +=item C<$warnings_are_errors> + +Set this variable to 1 if warning messages should be treated as +errors (i.e. if they should update C<$exit_code>). + +=cut + +use vars qw ($warnings_are_errors); +$warnings_are_errors = 0; + +=back + +=head2 Constants + +=over 4 + +=item C<UP_NONE>, C<UP_TEXT>, C<UP_LOC_TEXT> + +Possible values for the C<uniq_part> options. This selects the part +of the message that should be considered when filtering out duplicates. +If C<UP_LOC_TEXT> is used, the location and the explanation message +are used for filtering. If C<UP_TEXT> is used, only the explanation +message is used (so the same message will be filtered out if it appears +at different locations). C<UP_NONE> means that duplicate messages +should be output. + +=cut + +use constant UP_NONE => 0; +use constant UP_TEXT => 1; +use constant UP_LOC_TEXT => 2; + +=item C<US_LOCAL>, C<US_GLOBAL> + +Possible values for the C<uniq_scope> options. +Use C<US_GLOBAL> for error messages that should be printed only +once during the execution of the program, C<US_LOCAL> for message that +should be printed only once per file. (Actually, C<Channels> does not +do this now when files are changed, it relies on you calling +C<reset_local_duplicates> when this happens.) + +=cut + +# possible values for uniq_scope +use constant US_LOCAL => 0; +use constant US_GLOBAL => 1; + +=back + +=head2 Options + +Channels accept the options described below. These options can be +passed as a hash to the C<register_channel>, C<setup_channel>, and C<msg> +functions. The possible keys, with their default value are: + +=over + +=item C<type =E<gt> 'warning'> + +The type of the channel. One of C<'debug'>, C<'warning'>, C<'error'>, or +C<'fatal'>. Fatal messages abort the program when they are output. +Error messages update the exit status. Debug and warning messages are +harmless, except that warnings are treated as errors if +C<$warnings_are_errors> is set. + +=item C<exit_code =E<gt> 1> + +The value to update C<$exit_code> with when a fatal or error message +is emitted. C<$exit_code> is also updated for warnings output +when C<$warnings_are_errors> is set. + +=item C<file =E<gt> \*STDERR> + +The file where the error should be output. + +=item C<silent =E<gt> 0> + +Whether the channel should be silent. Use this do disable a +category of warning, for instance. + +=item C<ordered =E<gt> 1> + +Whether, with multi-threaded execution, the message should be queued +for ordered output. + +=item C<uniq_part =E<gt> UP_LOC_TEXT> + +The part of the message subject to duplicate filtering. See the +documentation for the C<UP_NONE>, C<UP_TEXT>, and C<UP_LOC_TEXT> +constants above. + +C<uniq_part> can also be set to an arbitrary string that will be used +instead of the message when considering duplicates. + +=item C<uniq_scope =E<gt> US_LOCAL> + +The scope of duplicate filtering. See the documentation for the +C<US_LOCAL>, and C<US_GLOBAL> constants above. + +=item C<header =E<gt> ''> + +A string to prepend to each message emitted through this channel. +With partial messages, only the first part will have C<header> +prepended. + +=item C<footer =E<gt> ''> + +A string to append to each message emitted through this channel. +With partial messages, only the final part will have C<footer> +appended. + +=item C<backtrace =E<gt> 0> + +Die with a stack backtrace after displaying the message. + +=item C<partial =E<gt> 0> + +When set, indicates a partial message that should +be output along with the next message with C<partial> unset. +Several partial messages can be stacked this way. + +Duplicate filtering will apply to the I<global> message resulting from +all I<partial> messages, using the options from the last (non-partial) +message. Linking associated messages is the main reason to use this +option. + +For instance the following messages + + msg 'channel', 'foo:2', 'redefinition of A ...'; + msg 'channel', 'foo:1', '... A previously defined here'; + msg 'channel', 'foo:3', 'redefinition of A ...'; + msg 'channel', 'foo:1', '... A previously defined here'; + +will result in + + foo:2: redefinition of A ... + foo:1: ... A previously defined here + foo:3: redefinition of A ... + +where the duplicate "I<... A previously defined here>" has been +filtered out. + +Linking these messages using C<partial> as follows will prevent the +fourth message to disappear. + + msg 'channel', 'foo:2', 'redefinition of A ...', partial => 1; + msg 'channel', 'foo:1', '... A previously defined here'; + msg 'channel', 'foo:3', 'redefinition of A ...', partial => 1; + msg 'channel', 'foo:1', '... A previously defined here'; + +Note that because the stack of C<partial> messages is printed with the +first non-C<partial> message, most options of C<partial> messages will +be ignored. + +=back + +=cut + +use vars qw (%_default_options %_global_duplicate_messages + %_local_duplicate_messages); + +# Default options for a channel. +%_default_options = + ( + type => 'warning', + exit_code => 1, + file => \*STDERR, + silent => 0, + ordered => 1, + queue => 0, + queue_key => undef, + uniq_scope => US_LOCAL, + uniq_part => UP_LOC_TEXT, + header => '', + footer => '', + backtrace => 0, + partial => 0, + ); + +# Filled with output messages as keys, to detect duplicates. +# The value associated with each key is the number of occurrences +# filtered out. +%_local_duplicate_messages = (); +%_global_duplicate_messages = (); + +sub _reset_duplicates (\%) +{ + my ($ref) = @_; + my $dup = 0; + foreach my $k (keys %$ref) + { + $dup += $ref->{$k}; + } + %$ref = (); + return $dup; +} + + +=head2 Functions + +=over 4 + +=item C<reset_local_duplicates ()> + +Reset local duplicate messages (see C<US_LOCAL>), and +return the number of messages that have been filtered out. + +=cut + +sub reset_local_duplicates () +{ + return _reset_duplicates %_local_duplicate_messages; +} + +=item C<reset_global_duplicates ()> + +Reset local duplicate messages (see C<US_GLOBAL>), and +return the number of messages that have been filtered out. + +=cut + +sub reset_global_duplicates () +{ + return _reset_duplicates %_global_duplicate_messages; +} + +sub _merge_options (\%%) +{ + my ($hash, %options) = @_; + local $_; + + foreach (keys %options) + { + if (exists $hash->{$_}) + { + $hash->{$_} = $options{$_} + } + else + { + confess "unknown option '$_'"; + } + } + if ($hash->{'ordered'}) + { + confess "fatal messages cannot be ordered" + if $hash->{'type'} eq 'fatal'; + confess "backtrace cannot be output on ordered messages" + if $hash->{'backtrace'}; + } +} + +=item C<register_channel ($name, [%options])> + +Declare channel C<$name>, and override the default options +with those listed in C<%options>. + +=cut + +sub register_channel ($;%) +{ + my ($name, %options) = @_; + my %channel_opts = %_default_options; + _merge_options %channel_opts, %options; + $channels{$name} = \%channel_opts; +} + +=item C<exists_channel ($name)> + +Returns true iff channel C<$name> has been registered. + +=cut + +sub exists_channel ($) +{ + my ($name) = @_; + return exists $channels{$name}; +} + +=item C<channel_type ($name)> + +Returns the type of channel C<$name> if it has been registered. +Returns the empty string otherwise. + +=cut + +sub channel_type ($) +{ + my ($name) = @_; + return $channels{$name}{'type'} if exists_channel $name; + return ''; +} + +# _format_sub_message ($LEADER, $MESSAGE) +# --------------------------------------- +# Split $MESSAGE at new lines and add $LEADER to each line. +sub _format_sub_message ($$) +{ + my ($leader, $message) = @_; + return $leader . join ("\n" . $leader, split ("\n", $message)) . "\n"; +} + +# Store partial messages here. (See the 'partial' option.) +use vars qw ($partial); +$partial = ''; + +# _format_message ($LOCATION, $MESSAGE, %OPTIONS) +# ----------------------------------------------- +# Format the message. Return a string ready to print. +sub _format_message ($$%) +{ + my ($location, $message, %opts) = @_; + my $msg = ($partial eq '' ? $opts{'header'} : '') . $message + . ($opts{'partial'} ? '' : $opts{'footer'}); + if (ref $location) + { + # If $LOCATION is a reference, assume it's an instance of the + # Autom4te::Location class and display contexts. + my $loc = $location->get || $me; + $msg = _format_sub_message ("$loc: ", $msg); + for my $pair ($location->get_contexts) + { + $msg .= _format_sub_message ($pair->[0] . ": ", $pair->[1]); + } + } + else + { + $location ||= $me; + $msg = _format_sub_message ("$location: ", $msg); + } + return $msg; +} + +# _enqueue ($QUEUE, $KEY, $UNIQ_SCOPE, $TO_FILTER, $MSG, $FILE) +# ------------------------------------------------------------- +# Push message on a queue, to be processed by another thread. +sub _enqueue ($$$$$$) +{ + my ($queue, $key, $uniq_scope, $to_filter, $msg, $file) = @_; + $queue->enqueue ($key, $msg, $to_filter, $uniq_scope); + confess "message queuing works only for STDERR" + if $file ne \*STDERR; +} + +# _dequeue ($QUEUE) +# ----------------- +# Pop a message from a queue, and print, similarly to how +# _print_message would do it. Return 0 if the queue is +# empty. Note that the key has already been dequeued. +sub _dequeue ($) +{ + my ($queue) = @_; + my $msg = $queue->dequeue || return 0; + my $to_filter = $queue->dequeue; + my $uniq_scope = $queue->dequeue; + my $file = \*STDERR; + + if ($to_filter ne '') + { + # Do we want local or global uniqueness? + my $dups; + if ($uniq_scope == US_LOCAL) + { + $dups = \%_local_duplicate_messages; + } + elsif ($uniq_scope == US_GLOBAL) + { + $dups = \%_global_duplicate_messages; + } + else + { + confess "unknown value for uniq_scope: " . $uniq_scope; + } + + # Update the hash of messages. + if (exists $dups->{$to_filter}) + { + ++$dups->{$to_filter}; + return 1; + } + else + { + $dups->{$to_filter} = 0; + } + } + print $file $msg; + return 1; +} + + +# _print_message ($LOCATION, $MESSAGE, %OPTIONS) +# ---------------------------------------------- +# Format the message, check duplicates, and print it. +sub _print_message ($$%) +{ + my ($location, $message, %opts) = @_; + + return 0 if ($opts{'silent'}); + + my $msg = _format_message ($location, $message, %opts); + if ($opts{'partial'}) + { + # Incomplete message. Store, don't print. + $partial .= $msg; + return; + } + else + { + # Prefix with any partial message send so far. + $msg = $partial . $msg; + $partial = ''; + } + + msg ('note', '', 'warnings are treated as errors', uniq_scope => US_GLOBAL) + if ($opts{'type'} eq 'warning' && $warnings_are_errors); + + # Check for duplicate message if requested. + my $to_filter; + if ($opts{'uniq_part'} ne UP_NONE) + { + # Which part of the error should we match? + if ($opts{'uniq_part'} eq UP_TEXT) + { + $to_filter = $message; + } + elsif ($opts{'uniq_part'} eq UP_LOC_TEXT) + { + $to_filter = $msg; + } + else + { + $to_filter = $opts{'uniq_part'}; + } + + # Do we want local or global uniqueness? + my $dups; + if ($opts{'uniq_scope'} == US_LOCAL) + { + $dups = \%_local_duplicate_messages; + } + elsif ($opts{'uniq_scope'} == US_GLOBAL) + { + $dups = \%_global_duplicate_messages; + } + else + { + confess "unknown value for uniq_scope: " . $opts{'uniq_scope'}; + } + + # Update the hash of messages. + if (exists $dups->{$to_filter}) + { + ++$dups->{$to_filter}; + return 0; + } + else + { + $dups->{$to_filter} = 0; + } + } + my $file = $opts{'file'}; + if ($opts{'ordered'} && $opts{'queue'}) + { + _enqueue ($opts{'queue'}, $opts{'queue_key'}, $opts{'uniq_scope'}, + $to_filter, $msg, $file); + } + else + { + print $file $msg; + } + return 1; +} + +=item C<msg ($channel, $location, $message, [%options])> + +Emit a message on C<$channel>, overriding some options of the channel with +those specified in C<%options>. Obviously C<$channel> must have been +registered with C<register_channel>. + +C<$message> is the text of the message, and C<$location> is a location +associated to the message. + +For instance to complain about some unused variable C<mumble> +declared at line 10 in F<foo.c>, one could do: + + msg 'unused', 'foo.c:10', "unused variable 'mumble'"; + +If channel C<unused> is not silent (and if this message is not a duplicate), +the following would be output: + + foo.c:10: unused variable 'mumble' + +C<$location> can also be an instance of C<Autom4te::Location>. In this +case, the stack of contexts will be displayed in addition. + +If C<$message> contains newline characters, C<$location> is prepended +to each line. For instance, + + msg 'error', 'somewhere', "1st line\n2nd line"; + +becomes + + somewhere: 1st line + somewhere: 2nd line + +If C<$location> is an empty string, it is replaced by the name of the +program. Actually, if you don't use C<%options>, you can even +elide the empty C<$location>. Thus + + msg 'fatal', '', 'fatal error'; + msg 'fatal', 'fatal error'; + +both print + + progname: fatal error + +=cut + + +use vars qw (@backlog %buffering); + +# See buffer_messages() and flush_messages() below. +%buffering = (); # The map of channel types to buffer. +@backlog = (); # The buffer of messages. + +sub msg ($$;$%) +{ + my ($channel, $location, $message, %options) = @_; + + if (! defined $message) + { + $message = $location; + $location = ''; + } + + confess "unknown channel $channel" unless exists $channels{$channel}; + + my %opts = %{$channels{$channel}}; + _merge_options (%opts, %options); + + if (exists $buffering{$opts{'type'}}) + { + push @backlog, [$channel, $location->clone, $message, %options]; + return; + } + + # Print the message if needed. + if (_print_message ($location, $message, %opts)) + { + # Adjust exit status. + if ($opts{'type'} eq 'error' + || $opts{'type'} eq 'fatal' + || ($opts{'type'} eq 'warning' && $warnings_are_errors)) + { + my $es = $opts{'exit_code'}; + $exit_code = $es if $es > $exit_code; + } + + # Die on fatal messages. + confess if $opts{'backtrace'}; + if ($opts{'type'} eq 'fatal') + { + # flush messages explicitly here, needed in worker threads. + STDERR->flush; + exit $exit_code; + } + } +} + + +=item C<setup_channel ($channel, %options)> + +Override the options of C<$channel> with those specified by C<%options>. + +=cut + +sub setup_channel ($%) +{ + my ($name, %opts) = @_; + confess "unknown channel $name" unless exists $channels{$name}; + _merge_options %{$channels{$name}}, %opts; +} + +=item C<setup_channel_type ($type, %options)> + +Override the options of any channel of type C<$type> +with those specified by C<%options>. + +=cut + +sub setup_channel_type ($%) +{ + my ($type, %opts) = @_; + foreach my $channel (keys %channels) + { + setup_channel $channel, %opts + if $channels{$channel}{'type'} eq $type; + } +} + +=item C<dup_channel_setup ()>, C<drop_channel_setup ()> + +Sometimes it is necessary to make temporary modifications to channels. +For instance one may want to disable a warning while processing a +particular file, and then restore the initial setup. These two +functions make it easy: C<dup_channel_setup ()> saves a copy of the +current configuration for later restoration by +C<drop_channel_setup ()>. + +You can think of this as a stack of configurations whose first entry +is the active one. C<dup_channel_setup ()> duplicates the first +entry, while C<drop_channel_setup ()> just deletes it. + +=cut + +use vars qw (@_saved_channels @_saved_werrors); +@_saved_channels = (); +@_saved_werrors = (); + +sub dup_channel_setup () +{ + my %channels_copy; + foreach my $k1 (keys %channels) + { + $channels_copy{$k1} = {%{$channels{$k1}}}; + } + push @_saved_channels, \%channels_copy; + push @_saved_werrors, $warnings_are_errors; +} + +sub drop_channel_setup () +{ + my $saved = pop @_saved_channels; + %channels = %$saved; + $warnings_are_errors = pop @_saved_werrors; +} + +=item C<buffer_messages (@types)>, C<flush_messages ()> + +By default, when C<msg> is called, messages are processed immediately. + +Sometimes it is necessary to delay the output of messages. +For instance you might want to make diagnostics before +channels have been completely configured. + +After C<buffer_messages(@types)> has been called, messages sent with +C<msg> to a channel whose type is listed in C<@types> will be stored in a +list for later processing. + +This backlog of messages is processed when C<flush_messages> is +called, with the current channel options (not the options in effect, +at the time of C<msg>). So for instance, if some channel was silenced +in the meantime, messages to this channel will not be printed. + +C<flush_messages> cancels the effect of C<buffer_messages>. Following +calls to C<msg> are processed immediately as usual. + +=cut + +sub buffer_messages (@) +{ + foreach my $type (@_) + { + $buffering{$type} = 1; + } +} + +sub flush_messages () +{ + %buffering = (); + foreach my $args (@backlog) + { + &msg (@$args); + } + @backlog = (); +} + +=item C<setup_channel_queue ($queue, $key)> + +Set the queue to fill for each channel that is ordered, +and the key to use for serialization. + +=cut +sub setup_channel_queue ($$) +{ + my ($queue, $key) = @_; + foreach my $channel (keys %channels) + { + setup_channel $channel, queue => $queue, queue_key => $key + if $channels{$channel}{'ordered'}; + } +} + +=item C<pop_channel_queue ($queue)> + +pop a message off the $queue; the key has already been popped. + +=cut +sub pop_channel_queue ($) +{ + my ($queue) = @_; + return _dequeue ($queue); +} + +=back + +=head1 SEE ALSO + +L<Autom4te::Location> + +=head1 HISTORY + +Written by Alexandre Duret-Lutz E<lt>F<adl@gnu.org>E<gt>. + +=cut + +1; + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/Configure_ac.pm b/lib/Autom4te/Configure_ac.pm new file mode 100644 index 0000000..924b23c --- /dev/null +++ b/lib/Autom4te/Configure_ac.pm @@ -0,0 +1,127 @@ +# Copyright (C) 2003-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +############################################################### +# The main copy of this file is in Automake's git repository. # +# Updates should be sent to automake-patches@gnu.org. # +############################################################### + +package Autom4te::Configure_ac; + +use 5.006; +use strict; +use Exporter; +use Autom4te::Channels; +use Autom4te::ChannelDefs; + +use vars qw (@ISA @EXPORT); + +@ISA = qw (Exporter); +@EXPORT = qw (&find_configure_ac &require_configure_ac); + +=head1 NAME + +Autom4te::Configure_ac - Locate configure.ac or configure.in. + +=head1 SYNOPSIS + + use Autom4te::Configure_ac; + + # Try to locate configure.in or configure.ac in the current + # directory. It may be absent. Complain if both files exist. + my $file_name = find_configure_ac; + + # Likewise, but bomb out if the file does not exist. + my $file_name = require_configure_ac; + + # Likewise, but in $dir. + my $file_name = find_configure_ac ($dir); + my $file_name = require_configure_ac ($dir); + +=over 4 + +=back + +=head2 Functions + +=over 4 + +=item C<$configure_ac = find_configure_ac ([$directory])> + +Find a F<configure.ac> or F<configure.in> file in C<$directory>, +defaulting to the current directory. Complain if both files are present. +Return the name of the file found, or the former if neither is present. + +=cut + +sub find_configure_ac (;@) +{ + my ($directory) = @_; + $directory ||= '.'; + my $configure_ac = + File::Spec->canonpath (File::Spec->catfile ($directory, 'configure.ac')); + my $configure_in = + File::Spec->canonpath (File::Spec->catfile ($directory, 'configure.in')); + + if (-f $configure_ac) + { + if (-f $configure_in) + { + msg ('unsupported', + "'$configure_ac' and '$configure_in' both present.\n" + . "proceeding with '$configure_ac'"); + } + return $configure_ac + } + elsif (-f $configure_in) + { + return $configure_in; + } + return $configure_ac; +} + + +=item C<$configure_ac = require_configure_ac ([$directory])> + +Like C<find_configure_ac>, but fail if neither is present. + +=cut + +sub require_configure_ac (;$) +{ + my $res = find_configure_ac (@_); + fatal "'configure.ac' or 'configure.in' is required" + unless -f $res; + return $res +} + +1; + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/FileUtils.pm b/lib/Autom4te/FileUtils.pm new file mode 100644 index 0000000..30bbdb9 --- /dev/null +++ b/lib/Autom4te/FileUtils.pm @@ -0,0 +1,452 @@ +# Copyright (C) 2003-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +############################################################### +# The main copy of this file is in Automake's git repository. # +# Updates should be sent to automake-patches@gnu.org. # +############################################################### + +package Autom4te::FileUtils; + +=head1 NAME + +Autom4te::FileUtils - handling files + +=head1 SYNOPSIS + + use Autom4te::FileUtils + +=head1 DESCRIPTION + +This perl module provides various general purpose file handling functions. + +=cut + +use 5.006; +use strict; +use Exporter; +use File::stat; +use IO::File; +use Autom4te::Channels; +use Autom4te::ChannelDefs; + +use vars qw (@ISA @EXPORT); + +@ISA = qw (Exporter); +@EXPORT = qw (&open_quote &contents + &find_file &mtime + &update_file &up_to_date_p + &xsystem &xsystem_hint &xqx + &dir_has_case_matching_file &reset_dir_cache + &set_dir_cache_file); + + +=item C<open_quote ($file_name)> + +Quote C<$file_name> for open. + +=cut + +# $FILE_NAME +# open_quote ($FILE_NAME) +# ----------------------- +# If the string $S is a well-behaved file name, simply return it. +# If it starts with white space, prepend './', if it ends with +# white space, add '\0'. Return the new string. +sub open_quote($) +{ + my ($s) = @_; + if ($s =~ m/^\s/) + { + $s = "./$s"; + } + if ($s =~ m/\s$/) + { + $s = "$s\0"; + } + return $s; +} + +=item C<find_file ($file_name, @include)> + +Return the first path for a C<$file_name> in the C<include>s. + +We match exactly the behavior of GNU M4: first look in the current +directory (which includes the case of absolute file names), and then, +if the file name is not absolute, look in C<@include>. + +If the file is flagged as optional (ends with C<?>), then return undef +if absent, otherwise exit with error. + +=cut + +# $FILE_NAME +# find_file ($FILE_NAME, @INCLUDE) +# -------------------------------- +sub find_file ($@) +{ + use File::Spec; + + my ($file_name, @include) = @_; + my $optional = 0; + + $optional = 1 + if $file_name =~ s/\?$//; + + return File::Spec->canonpath ($file_name) + if -e $file_name; + + if (!File::Spec->file_name_is_absolute ($file_name)) + { + foreach my $path (@include) + { + return File::Spec->canonpath (File::Spec->catfile ($path, $file_name)) + if -e File::Spec->catfile ($path, $file_name) + } + } + + fatal "$file_name: no such file or directory" + unless $optional; + return undef; +} + +=item C<mtime ($file)> + +Return the mtime of C<$file>. Missing files, or C<-> standing for +C<STDIN> or C<STDOUT> are "obsolete", i.e., as old as possible. + +=cut + +# $MTIME +# MTIME ($FILE) +# ------------- +sub mtime ($) +{ + my ($file) = @_; + + return 0 + if $file eq '-' || ! -f $file; + + my $stat = stat ($file) + or fatal "cannot stat $file: $!"; + + return $stat->mtime; +} + + +=item C<update_file ($from, $to, [$force])> + +Rename C<$from> as C<$to>, preserving C<$to> timestamp if it has not +changed, unless C<$force> is true (defaults to false). Recognize +C<$to> = C<-> standing for C<STDIN>. C<$from> is always +removed/renamed. + +=cut + +# &update_file ($FROM, $TO; $FORCE) +# --------------------------------- +sub update_file ($$;$) +{ + my ($from, $to, $force) = @_; + $force = 0 + unless defined $force; + my $SIMPLE_BACKUP_SUFFIX = $ENV{'SIMPLE_BACKUP_SUFFIX'} || '~'; + use File::Compare; + use File::Copy; + + if ($to eq '-') + { + my $in = new IO::File ("< " . open_quote ($from)); + my $out = new IO::File (">-"); + while ($_ = $in->getline) + { + print $out $_; + } + $in->close; + unlink ($from) || fatal "cannot remove $from: $!"; + return; + } + + if (!$force && -f "$to" && compare ("$from", "$to") == 0) + { + # File didn't change, so don't update its mod time. + msg 'note', "'$to' is unchanged"; + unlink ($from) + or fatal "cannot remove $from: $!"; + return + } + + if (-f "$to") + { + # Back up and install the new one. + move ("$to", "$to$SIMPLE_BACKUP_SUFFIX") + or fatal "cannot backup $to: $!"; + move ("$from", "$to") + or fatal "cannot rename $from as $to: $!"; + msg 'note', "'$to' is updated"; + } + else + { + move ("$from", "$to") + or fatal "cannot rename $from as $to: $!"; + msg 'note', "'$to' is created"; + } +} + + +=item C<up_to_date_p ($file, @dep)> + +Is C<$file> more recent than C<@dep>? + +=cut + +# $BOOLEAN +# &up_to_date_p ($FILE, @DEP) +# --------------------------- +sub up_to_date_p ($@) +{ + my ($file, @dep) = @_; + my $mtime = mtime ($file); + + foreach my $dep (@dep) + { + if ($mtime < mtime ($dep)) + { + verb "up_to_date ($file): outdated: $dep"; + return 0; + } + } + + verb "up_to_date ($file): up to date"; + return 1; +} + + +=item C<handle_exec_errors ($command, [$expected_exit_code = 0], [$hint])> + +Display an error message for C<$command>, based on the content of +C<$?> and C<$!>. Be quiet if the command exited normally +with C<$expected_exit_code>. If C<$hint> is given, display that as well +if the command failed to run at all. + +=cut + +sub handle_exec_errors ($;$$) +{ + my ($command, $expected, $hint) = @_; + $expected = 0 unless defined $expected; + if (defined $hint) + { + $hint = "\n" . $hint; + } + else + { + $hint = ''; + } + + $command = (split (' ', $command))[0]; + if ($!) + { + fatal "failed to run $command: $!" . $hint; + } + else + { + use POSIX qw (WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG); + + if (WIFEXITED ($?)) + { + my $status = WEXITSTATUS ($?); + # Propagate exit codes. + fatal ('', + "$command failed with exit status: $status", + exit_code => $status) + unless $status == $expected; + } + elsif (WIFSIGNALED ($?)) + { + my $signal = WTERMSIG ($?); + fatal "$command terminated by signal: $signal"; + } + else + { + fatal "$command exited abnormally"; + } + } +} + +=item C<xqx ($command)> + +Same as C<qx> (but in scalar context), but fails on errors. + +=cut + +# xqx ($COMMAND) +# -------------- +sub xqx ($) +{ + my ($command) = @_; + + verb "running: $command"; + + $! = 0; + my $res = `$command`; + handle_exec_errors $command + if $?; + + return $res; +} + + +=item C<xsystem (@argv)> + +Same as C<system>, but fails on errors, and reports the C<@argv> +in verbose mode. + +=cut + +sub xsystem (@) +{ + my (@command) = @_; + + verb "running: @command"; + + $! = 0; + handle_exec_errors "@command" + if system @command; +} + + +=item C<xsystem_hint ($msg, @argv)> + +Same as C<xsystem>, but allows to pass a hint that will be displayed +in case the command failed to run at all. + +=cut + +sub xsystem_hint (@) +{ + my ($hint, @command) = @_; + + verb "running: @command"; + + $! = 0; + handle_exec_errors "@command", 0, $hint + if system @command; +} + + +=item C<contents ($file_name)> + +Return the contents of C<$file_name>. + +=cut + +# contents ($FILE_NAME) +# --------------------- +sub contents ($) +{ + my ($file) = @_; + verb "reading $file"; + local $/; # Turn on slurp-mode. + my $f = new Autom4te::XFile "< " . open_quote ($file); + my $contents = $f->getline; + $f->close; + return $contents; +} + + +=item C<dir_has_case_matching_file ($DIRNAME, $FILE_NAME)> + +Return true iff $DIR contains a file name that matches $FILE_NAME case +insensitively. + +We need to be cautious on case-insensitive case-preserving file +systems (e.g. Mac OS X's HFS+). On such systems C<-f 'Foo'> and C<-f +'foO'> answer the same thing. Hence if a package distributes its own +F<CHANGELOG> file, but has no F<ChangeLog> file, automake would still +try to distribute F<ChangeLog> (because it thinks it exists) in +addition to F<CHANGELOG>, although it is impossible for these two +files to be in the same directory (the two file names designate the +same file). + +=cut + +use vars '%_directory_cache'; +sub dir_has_case_matching_file ($$) +{ + # Note that print File::Spec->case_tolerant returns 0 even on MacOS + # X (with Perl v5.8.1-RC3 at least), so do not try to shortcut this + # function using that. + + my ($dirname, $file_name) = @_; + return 0 unless -f "$dirname/$file_name"; + + # The file appears to exist, however it might be a mirage if the + # system is case insensitive. Let's browse the directory and check + # whether the file is really in. We maintain a cache of directories + # so Automake doesn't spend all its time reading the same directory + # again and again. + if (!exists $_directory_cache{$dirname}) + { + error "failed to open directory '$dirname'" + unless opendir (DIR, $dirname); + $_directory_cache{$dirname} = { map { $_ => 1 } readdir (DIR) }; + closedir (DIR); + } + return exists $_directory_cache{$dirname}{$file_name}; +} + +=item C<reset_dir_cache ($dirname)> + +Clear C<dir_has_case_matching_file>'s cache for C<$dirname>. + +=cut + +sub reset_dir_cache ($) +{ + delete $_directory_cache{$_[0]}; +} + +=item C<set_dir_cache_file ($dirname, $file_name)> + +State that C<$dirname> contains C<$file_name> now. + +=cut + +sub set_dir_cache_file ($$) +{ + my ($dirname, $file_name) = @_; + $_directory_cache{$dirname}{$file_name} = 1 + if exists $_directory_cache{$dirname}; +} + +1; # for require + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/General.pm b/lib/Autom4te/General.pm new file mode 100644 index 0000000..ef1e987 --- /dev/null +++ b/lib/Autom4te/General.pm @@ -0,0 +1,426 @@ +# autoconf -- create `configure' using m4 macros +# Copyright (C) 2001-2004, 2006-2007, 2009-2012 Free Software +# Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +package Autom4te::General; + +=head1 NAME + +Autom4te::General - general support functions for Autoconf + +=head1 SYNOPSIS + + use Autom4te::General + +=head1 DESCRIPTION + +This perl module provides various general purpose support functions +used in several executables of the Autoconf package. + +=cut + +use 5.006; +use Exporter; +use Autom4te::ChannelDefs; +use Autom4te::Channels; +use Autom4te::Getopt (); +use File::Basename; +use File::Path (); +use File::stat; +use IO::File; +use Carp; +use strict; + +use vars qw (@ISA @EXPORT); + +@ISA = qw (Exporter); + +# Variables we define and export. +my @export_vars = + qw ($debug $force $help $me $tmp $verbose $version); + +# Functions we define and export. +my @export_subs = + qw (&debug + &getopt &shell_quote &mktmpdir + &uniq); + +# Functions we forward (coming from modules we use). +my @export_forward_subs = + qw (&basename &dirname &fileparse); + +@EXPORT = (@export_vars, @export_subs, @export_forward_subs); + + +# Variable we share with the main package. Be sure to have a single +# copy of them: using `my' together with multiple inclusion of this +# package would introduce several copies. + +=head2 Global Variables + +=over 4 + +=item C<$debug> + +Set this variable to 1 if debug messages should be enabled. Debug +messages are meant for developers only, or when tracking down an +incorrect execution. + +=cut + +use vars qw ($debug); +$debug = 0; + +=item C<$force> + +Set this variable to 1 to recreate all the files, or to consider all +the output files are obsolete. + +=cut + +use vars qw ($force); +$force = undef; + +=item C<$help> + +Set to the help message associated with the option C<--help>. + +=cut + +use vars qw ($help); +$help = undef; + +=item C<$me> + +The name of this application, for diagnostic messages. + +=cut + +use vars qw ($me); +$me = basename ($0); + +=item C<$tmp> + +The name of the temporary directory created by C<mktmpdir>. Left +C<undef> otherwise. + +=cut + +# Our tmp dir. +use vars qw ($tmp); +$tmp = undef; + +=item C<$verbose> + +Enable verbosity messages. These messages are meant for ordinary +users, and typically make explicit the steps being performed. + +=cut + +use vars qw ($verbose); +$verbose = 0; + +=item C<$version> + +Set to the version message associated to the option C<--version>. + +=cut + +use vars qw ($version); +$version = undef; + +=back + +=cut + + + +## ----- ## +## END. ## +## ----- ## + +=head2 Functions + +=over 4 + +=item C<END> + +Filter Perl's exit codes, delete any temporary directory (unless +C<$debug>), and exit nonzero whenever closing C<STDOUT> fails. + +=cut + +# END +# --- +sub END +{ + # $? contains the exit status we will return. + # It was set using one of the following ways: + # + # 1) normal termination + # this sets $? = 0 + # 2) calling `exit (n)' + # this sets $? = n + # 3) calling die or friends (croak, confess...): + # a) when $! is non-0 + # this set $? = $! + # b) when $! is 0 but $? is not + # this sets $? = ($? >> 8) (i.e., the exit code of the + # last program executed) + # c) when both $! and $? are 0 + # this sets $? = 255 + # + # Cases 1), 2), and 3b) are fine, but we prefer $? = 1 for 3a) and 3c). + my $status = $?; + $status = 1 if ($! && $! == $?) || $? == 255; + # (Note that we cannot safely distinguish calls to `exit (n)' + # from calls to die when `$! = n'. It's not big deal because + # we only call `exit (0)' or `exit (1)'.) + + if (!$debug && defined $tmp && -d $tmp) + { + local $SIG{__WARN__} = sub { $status = 1; warn $_[0] }; + File::Path::rmtree $tmp; + } + + # This is required if the code might send any output to stdout + # E.g., even --version or --help. So it's best to do it unconditionally. + if (! close STDOUT) + { + print STDERR "$me: closing standard output: $!\n"; + $? = 1; + return; + } + + $? = $status; +} + + +## ----------- ## +## Functions. ## +## ----------- ## + + +=item C<debug (@message)> + +If the debug mode is enabled (C<$debug> and C<$verbose>), report the +C<@message> on C<STDERR>, signed with the name of the program. + +=cut + +# &debug(@MESSAGE) +# ---------------- +# Messages displayed only if $DEBUG and $VERBOSE. +sub debug (@) +{ + print STDERR "$me: ", @_, "\n" + if $verbose && $debug; +} + + +=item C<getopt (%option)> + +Wrapper around C<Autom4te::Getopt::parse_options>. In addition to +the user C<option>s, support C<-h>/C<--help>, C<-V>/C<--version>, +C<-v>/C<--verbose>, C<-d>/C<--debug>, C<-f>/C<--force>. Conform to +the GNU Coding Standards for error messages. + +=cut + +# getopt (%OPTION) +# ---------------- +# Handle the %OPTION, plus all the common options. +sub getopt (%) +{ + my (%option) = @_; + %option = ("h|help" => sub { print $help; exit 0 }, + "V|version" => sub { print $version; exit 0 }, + + "v|verbose" => sub { ++$verbose }, + "d|debug" => sub { ++$debug }, + 'f|force' => \$force, + + # User options last, so that they have precedence. + %option); + Autom4te::Getopt::parse_options (%option); + + setup_channel 'note', silent => !$verbose; + setup_channel 'verb', silent => !$verbose; +} + + +=item C<shell_quote ($file_name)> + +Quote C<$file_name> for the shell. + +=cut + +# $FILE_NAME +# shell_quote ($FILE_NAME) +# ------------------------ +# If the string $S is a well-behaved file name, simply return it. +# If it contains white space, quotes, etc., quote it, and return +# the new string. +sub shell_quote($) +{ + my ($s) = @_; + if ($s =~ m![^\w+/.,-]!) + { + # Convert each single quote to '\'' + $s =~ s/\'/\'\\\'\'/g; + # Then single quote the string. + $s = "'$s'"; + } + return $s; +} + +=item C<mktmpdir ($signature)> + +Create a temporary directory which name is based on C<$signature>. +Store its name in C<$tmp>. C<END> is in charge of removing it, unless +C<$debug>. + +=cut + +# mktmpdir ($SIGNATURE) +# --------------------- +sub mktmpdir ($) +{ + my ($signature) = @_; + my $TMPDIR = $ENV{'TMPDIR'} || '/tmp'; + my $quoted_tmpdir = shell_quote ($TMPDIR); + + # If mktemp supports dirs, use it. + $tmp = `(umask 077 && + mktemp -d $quoted_tmpdir/"${signature}XXXXXX") 2>/dev/null`; + chomp $tmp; + + if (!$tmp || ! -d $tmp) + { + $tmp = "$TMPDIR/$signature" . int (rand 10000) . ".$$"; + mkdir $tmp, 0700 + or croak "$me: cannot create $tmp: $!\n"; + } + + print STDERR "$me:$$: working in $tmp\n" + if $debug; +} + + +=item C<uniq (@list)> + +Return C<@list> with no duplicates, keeping only the first +occurrences. + +=cut + +# @RES +# uniq (@LIST) +# ------------ +sub uniq (@) +{ + my @res = (); + my %seen = (); + foreach my $item (@_) + { + if (! exists $seen{$item}) + { + $seen{$item} = 1; + push (@res, $item); + } + } + return wantarray ? @res : "@res"; +} + + +=item C<handle_exec_errors ($command)> + +Display an error message for C<$command>, based on the content of +C<$?> and C<$!>. + +=cut + + +# handle_exec_errors ($COMMAND) +# ----------------------------- +sub handle_exec_errors ($) +{ + my ($command) = @_; + + $command = (split (' ', $command))[0]; + if ($!) + { + error "failed to run $command: $!"; + } + else + { + use POSIX qw (WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG); + + if (WIFEXITED ($?)) + { + my $status = WEXITSTATUS ($?); + # WIFEXITED and WEXITSTATUS can alter $!, reset it so that + # error() actually propagates the command's exit status, not $!. + $! = 0; + error "$command failed with exit status: $status"; + } + elsif (WIFSIGNALED ($?)) + { + my $signal = WTERMSIG ($?); + # In this case we prefer to exit with status 1. + $! = 1; + error "$command terminated by signal: $signal"; + } + else + { + error "$command exited abnormally"; + } + } +} + +=back + +=head1 SEE ALSO + +L<Autom4te::XFile> + +=head1 HISTORY + +Written by Alexandre Duret-Lutz E<lt>F<adl@gnu.org>E<gt> and Akim +Demaille E<lt>F<akim@freefriends.org>E<gt>. + +=cut + + + +1; # for require + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/Getopt.pm b/lib/Autom4te/Getopt.pm new file mode 100644 index 0000000..d73c5ef --- /dev/null +++ b/lib/Autom4te/Getopt.pm @@ -0,0 +1,115 @@ +# Copyright (C) 2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +package Autom4te::Getopt; + +=head1 NAME + +Autom4te::Getopt - GCS conforming parser for command line options + +=head1 SYNOPSIS + + use Autom4te::Getopt; + +=head1 DESCRIPTION + +Export a function C<parse_options>, performing parsing of command +line options in conformance to the GNU Coding standards. + +=cut + +use 5.006; +use strict; +use warnings FATAL => 'all'; +use Exporter (); +use Getopt::Long (); +use Autom4te::ChannelDefs qw/fatal/; +use Carp qw/croak confess/; + +use vars qw (@ISA @EXPORT); +@ISA = qw (Exporter); +@EXPORT= qw/getopt/; + +=item C<parse_options (%option)> + +Wrapper around C<Getopt::Long>, trying to conform to the GNU +Coding Standards for error messages. + +=cut + +sub parse_options (%) +{ + my %option = @_; + + Getopt::Long::Configure ("bundling", "pass_through"); + # Unrecognized options are passed through, so GetOption can only fail + # due to internal errors or misuse of options specification. + Getopt::Long::GetOptions (%option) + or confess "error in options specification (likely)"; + + if (@ARGV && $ARGV[0] =~ /^-./) + { + my %argopts; + for my $k (keys %option) + { + if ($k =~ /(.*)=s$/) + { + map { $argopts{(length ($_) == 1) + ? "-$_" : "--$_" } = 1; } (split (/\|/, $1)); + } + } + if ($ARGV[0] eq '--') + { + shift @ARGV; + } + elsif (exists $argopts{$ARGV[0]}) + { + fatal ("option '$ARGV[0]' requires an argument\n" + . "Try '$0 --help' for more information."); + } + else + { + fatal ("unrecognized option '$ARGV[0]'.\n" + . "Try '$0 --help' for more information."); + } + } +} + +=back + +=head1 SEE ALSO + +L<Getopt::Long> + +=cut + +1; # for require + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/Makefile.am b/lib/Autom4te/Makefile.am new file mode 100644 index 0000000..5d9bdac --- /dev/null +++ b/lib/Autom4te/Makefile.am @@ -0,0 +1,37 @@ +## Process this file with automake to create Makefile.in + +# Copyright (C) 2001, 2003, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +perllibdir = $(pkgdatadir)/Autom4te +dist_perllib_DATA = \ + C4che.pm \ + ChannelDefs.pm \ + Channels.pm \ + Configure_ac.pm \ + FileUtils.pm \ + General.pm \ + Getopt.pm \ + Request.pm \ + XFile.pm + + +## --------------- ## +## Building TAGS. ## +## --------------- ## + +TAGS_FILES = $(dist_perllib_DATA) + +ETAGS_ARGS = --lang=perl diff --git a/lib/Autom4te/Makefile.in b/lib/Autom4te/Makefile.in new file mode 100644 index 0000000..280af35 --- /dev/null +++ b/lib/Autom4te/Makefile.in @@ -0,0 +1,454 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Copyright (C) 2001, 2003, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = lib/Autom4te +DIST_COMMON = $(dist_perllib_DATA) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(perllibdir)" +DATA = $(dist_perllib_DATA) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +perllibdir = $(pkgdatadir)/Autom4te +dist_perllib_DATA = \ + C4che.pm \ + ChannelDefs.pm \ + Channels.pm \ + Configure_ac.pm \ + FileUtils.pm \ + General.pm \ + Getopt.pm \ + Request.pm \ + XFile.pm + +TAGS_FILES = $(dist_perllib_DATA) +ETAGS_ARGS = --lang=perl +all: all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/Autom4te/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/Autom4te/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-dist_perllibDATA: $(dist_perllib_DATA) + @$(NORMAL_INSTALL) + test -z "$(perllibdir)" || $(MKDIR_P) "$(DESTDIR)$(perllibdir)" + @list='$(dist_perllib_DATA)'; test -n "$(perllibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(perllibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(perllibdir)" || exit $$?; \ + done + +uninstall-dist_perllibDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_perllib_DATA)'; test -n "$(perllibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(perllibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(perllibdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(perllibdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_perllibDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_perllibDATA + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + ctags distclean distclean-generic distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dist_perllibDATA \ + install-dvi install-dvi-am install-exec install-exec-am \ + install-html install-html-am install-info install-info-am \ + install-man install-pdf install-pdf-am install-ps \ + install-ps-am install-strip installcheck installcheck-am \ + installdirs maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \ + uninstall uninstall-am uninstall-dist_perllibDATA + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/Autom4te/Request.pm b/lib/Autom4te/Request.pm new file mode 100644 index 0000000..c3cd050 --- /dev/null +++ b/lib/Autom4te/Request.pm @@ -0,0 +1,114 @@ +# autoconf -- create `configure' using m4 macros +# Copyright (C) 2001-2003, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +package Autom4te::Request; + +=head1 NAME + +Autom4te::Request - a single m4 run request + +=head1 SYNOPSIS + + use Autom4te::Request; + +=head1 DESCRIPTION + +This perl module provides various general purpose support functions +used in several executables of the Autoconf and Automake packages. + +=cut + +use strict; +use Class::Struct; +use Carp; +use Data::Dumper; + +struct + ( + # The key of the cache files. + 'id' => "\$", + # True iff %MACRO contains all the macros we want to trace. + 'valid' => "\$", + # The include path. + 'path' => '@', + # The set of input files. + 'input' => '@', + # The set of macros currently traced. + 'macro' => '%', + ); + + +# Serialize a request or all the current requests. +sub marshall($) +{ + my ($caller) = @_; + my $res = ''; + + # CALLER is an object: instance method. + my $marshall = Data::Dumper->new ([$caller]); + $marshall->Indent(2)->Terse(0); + $res = $marshall->Dump . "\n"; + + return $res; +} + + +# includes_p ($SELF, @MACRO) +# -------------------------- +# Does this request covers all the @MACRO. +sub includes_p +{ + my ($self, @macro) = @_; + + foreach (@macro) + { + return 0 + if ! exists ${$self->macro}{$_}; + } + return 1; +} + + +=head1 SEE ALSO + +L<Autom4te::C4che> + +=head1 HISTORY + +Written by Akim Demaille E<lt>F<akim@freefriends.org>E<gt>. + +=cut + + + +1; # for require + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Autom4te/XFile.pm b/lib/Autom4te/XFile.pm new file mode 100644 index 0000000..28d5bc6 --- /dev/null +++ b/lib/Autom4te/XFile.pm @@ -0,0 +1,319 @@ +# Copyright (C) 2001-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Written by Akim Demaille <akim@freefriends.org>. + +############################################################### +# The main copy of this file is in Automake's git repository. # +# Updates should be sent to automake-patches@gnu.org. # +############################################################### + +package Autom4te::XFile; + +=head1 NAME + +Autom4te::XFile - supply object methods for filehandles with error handling + +=head1 SYNOPSIS + + use Autom4te::XFile; + + $fh = new Autom4te::XFile; + $fh->open ("< file"); + # No need to check $FH: we died if open failed. + print <$fh>; + $fh->close; + # No need to check the return value of close: we died if it failed. + + $fh = new Autom4te::XFile "> file"; + # No need to check $FH: we died if new failed. + print $fh "bar\n"; + $fh->close; + + $fh = new Autom4te::XFile "file", "r"; + # No need to check $FH: we died if new failed. + defined $fh + print <$fh>; + undef $fh; # automatically closes the file and checks for errors. + + $fh = new Autom4te::XFile "file", O_WRONLY | O_APPEND; + # No need to check $FH: we died if new failed. + print $fh "corge\n"; + + $pos = $fh->getpos; + $fh->setpos ($pos); + + undef $fh; # automatically closes the file and checks for errors. + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +C<Autom4te::XFile> inherits from C<IO::File>. It provides the method +C<name> returning the file name. It provides dying versions of the +methods C<close>, C<lock> (corresponding to C<flock>), C<new>, +C<open>, C<seek>, and C<truncate>. It also overrides the C<getline> +and C<getlines> methods to translate C<\r\n> to C<\n>. + +=cut + +use 5.006; +use strict; +use vars qw($VERSION @EXPORT @EXPORT_OK $AUTOLOAD @ISA); +use Carp; +use Errno; +use IO::File; +use File::Basename; +use Autom4te::ChannelDefs; +use Autom4te::Channels qw(msg); +use Autom4te::FileUtils; + +require Exporter; +require DynaLoader; + +@ISA = qw(IO::File Exporter DynaLoader); + +$VERSION = "1.2"; + +@EXPORT = @IO::File::EXPORT; + +eval { + # Make all Fcntl O_XXX and LOCK_XXX constants available for importing + require Fcntl; + my @O = grep /^(LOCK|O)_/, @Fcntl::EXPORT, @Fcntl::EXPORT_OK; + Fcntl->import (@O); # first we import what we want to export + push (@EXPORT, @O); +}; + +=head2 Methods + +=over + +=item C<$fh = new Autom4te::XFile ([$expr, ...]> + +Constructor a new XFile object. Additional arguments +are passed to C<open>, if any. + +=cut + +sub new +{ + my $type = shift; + my $class = ref $type || $type || "Autom4te::XFile"; + my $fh = $class->SUPER::new (); + if (@_) + { + $fh->open (@_); + } + $fh; +} + +=item C<$fh-E<gt>open ([$file, ...])> + +Open a file, passing C<$file> and further arguments to C<IO::File::open>. +Die if opening fails. Store the name of the file. Use binmode for writing. + +=cut + +sub open +{ + my $fh = shift; + my ($file) = @_; + + # WARNING: Gross hack: $FH is a typeglob: use its hash slot to store + # the 'name' of the file we are opening. See the example with + # io_socket_timeout in IO::Socket for more, and read Graham's + # comment in IO::Handle. + ${*$fh}{'autom4te_xfile_file'} = "$file"; + + if (!$fh->SUPER::open (@_)) + { + fatal "cannot open $file: $!"; + } + + # In case we're running under MSWindows, don't write with CRLF. + # (This circumvents a bug in at least Cygwin bash where the shell + # parsing fails on lines ending with the continuation character '\' + # and CRLF). + binmode $fh if $file =~ /^\s*>/; +} + +=item C<$fh-E<gt>close> + +Close the file, handling errors. + +=cut + +sub close +{ + my $fh = shift; + if (!$fh->SUPER::close (@_)) + { + my $file = $fh->name; + Autom4te::FileUtils::handle_exec_errors $file + unless $!; + fatal "cannot close $file: $!"; + } +} + +=item C<$line = $fh-E<gt>getline> + +Read and return a line from the file. Ensure C<\r\n> is translated to +C<\n> on input files. + +=cut + +# Some native Windows/perl installations fail to translate \r\n to \n on +# input so we do that here. +sub getline +{ + local $_ = $_[0]->SUPER::getline; + # Perform a _global_ replacement: $_ may can contains many lines + # in slurp mode ($/ = undef). + s/\015\012/\n/gs if defined $_; + return $_; +} + +=item C<@lines = $fh-E<gt>getlines> + +Slurp lines from the files. + +=cut + +sub getlines +{ + my @res = (); + my $line; + push @res, $line while $line = $_[0]->getline; + return @res; +} + +=item C<$name = $fh-E<gt>name> + +Return the name of the file. + +=cut + +sub name +{ + my $fh = shift; + return ${*$fh}{'autom4te_xfile_file'}; +} + +=item C<$fh-E<gt>lock> + +Lock the file using C<flock>. If locking fails for reasons other than +C<flock> being unsupported, then error out if C<$ENV{'MAKEFLAGS'}> indicates +that we are spawned from a parallel C<make>. + +=cut + +sub lock +{ + my ($fh, $mode) = @_; + # Cannot use @_ here. + + # Unless explicitly configured otherwise, Perl implements its 'flock' with the + # first of flock(2), fcntl(2), or lockf(3) that works. These can fail on + # NFS-backed files, with ENOLCK (GNU/Linux) or EOPNOTSUPP (FreeBSD); we + # usually ignore these errors. If $ENV{MAKEFLAGS} suggests that a parallel + # invocation of 'make' has invoked the tool we serve, report all locking + # failures and abort. + # + # On Unicos, flock(2) and fcntl(2) over NFS hang indefinitely when 'lockd' is + # not running. NetBSD NFS clients silently grant all locks. We do not + # attempt to defend against these dangers. + # + # -j is for parallel BSD make, -P is for parallel HP-UX make. + if (!flock ($fh, $mode)) + { + my $make_j = (exists $ENV{'MAKEFLAGS'} + && " -$ENV{'MAKEFLAGS'}" =~ / (-[BdeikrRsSw]*[jP]|--[jP]|---?jobs)/); + my $note = "\nforgo \"make -j\" or use a file system that supports locks"; + my $file = $fh->name; + + msg ($make_j ? 'fatal' : 'unsupported', + "cannot lock $file with mode $mode: $!" . ($make_j ? $note : "")) + if $make_j || !($!{ENOLCK} || $!{EOPNOTSUPP}); + } +} + +=item C<$fh-E<gt>seek ($position, [$whence])> + +Seek file to C<$position>. Die if seeking fails. + +=cut + +sub seek +{ + my $fh = shift; + # Cannot use @_ here. + if (!seek ($fh, $_[0], $_[1])) + { + my $file = $fh->name; + fatal "cannot rewind $file with @_: $!"; + } +} + +=item C<$fh-E<gt>truncate ($len)> + +Truncate the file to length C<$len>. Die on failure. + +=cut + +sub truncate +{ + my ($fh, $len) = @_; + if (!truncate ($fh, $len)) + { + my $file = $fh->name; + fatal "cannot truncate $file at $len: $!"; + } +} + +=back + +=head1 SEE ALSO + +L<perlfunc>, +L<perlop/"I/O Operators">, +L<IO::File> +L<IO::Handle> +L<IO::Seekable> + +=head1 HISTORY + +Derived from IO::File.pm by Akim Demaille E<lt>F<akim@freefriends.org>E<gt>. + +=cut + +1; + +### Setup "GNU" style for perl-mode and cperl-mode. +## Local Variables: +## perl-indent-level: 2 +## perl-continued-statement-offset: 2 +## perl-continued-brace-offset: 0 +## perl-brace-offset: 0 +## perl-brace-imaginary-offset: 0 +## perl-label-offset: -2 +## cperl-indent-level: 2 +## cperl-brace-offset: 0 +## cperl-continued-brace-offset: 0 +## cperl-label-offset: -2 +## cperl-extra-newline-before-brace: t +## cperl-merge-trailing-else: nil +## cperl-continued-statement-offset: 2 +## End: diff --git a/lib/Makefile.am b/lib/Makefile.am new file mode 100644 index 0000000..2e2bc5f --- /dev/null +++ b/lib/Makefile.am @@ -0,0 +1,44 @@ +# Make Autoconf-related libraries. + +# Copyright (C) 2001-2005, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +SUBDIRS = Autom4te m4sugar autoconf autotest autoscan emacs +nodist_pkgdata_DATA = autom4te.cfg +EXTRA_DIST = autom4te.in freeze.mk + +edit = sed \ + -e 's|@SHELL[@]|$(SHELL)|g' \ + -e 's|@PERL[@]|$(PERL)|g' \ + -e 's|@bindir[@]|$(bindir)|g' \ + -e 's|@pkgdatadir[@]|$(pkgdatadir)|g' \ + -e 's|@prefix[@]|$(prefix)|g' \ + -e 's|@autoconf-name[@]|'`echo autoconf | sed '$(transform)'`'|g' \ + -e 's|@autoheader-name[@]|'`echo autoheader | sed '$(transform)'`'|g' \ + -e 's|@autom4te-name[@]|'`echo autom4te | sed '$(transform)'`'|g' \ + -e 's|@M4[@]|$(M4)|g' \ + -e 's|@AWK[@]|$(AWK)|g' \ + -e 's|@VERSION[@]|$(VERSION)|g' \ + -e 's|@PACKAGE_NAME[@]|$(PACKAGE_NAME)|g' + +# All the files below depend on Makefile so that they are rebuilt +# when the prefix, etc. changes. Unfortunately, suffix rules +# cannot have additional dependencies, so we have to use explicit rules. +CLEANFILES = autom4te.cfg +autom4te.cfg: $(srcdir)/autom4te.in Makefile + rm -f autom4te.cfg autom4te.tmp + $(edit) $(srcdir)/autom4te.in >autom4te.tmp + chmod a-w autom4te.tmp + mv autom4te.tmp autom4te.cfg diff --git a/lib/Makefile.in b/lib/Makefile.in new file mode 100644 index 0000000..2316f2d --- /dev/null +++ b/lib/Makefile.in @@ -0,0 +1,622 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autoconf-related libraries. + +# Copyright (C) 2001-2005, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = lib +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(pkgdatadir)" +DATA = $(nodist_pkgdata_DATA) +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ + $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \ + distdir +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +SUBDIRS = Autom4te m4sugar autoconf autotest autoscan emacs +nodist_pkgdata_DATA = autom4te.cfg +EXTRA_DIST = autom4te.in freeze.mk +edit = sed \ + -e 's|@SHELL[@]|$(SHELL)|g' \ + -e 's|@PERL[@]|$(PERL)|g' \ + -e 's|@bindir[@]|$(bindir)|g' \ + -e 's|@pkgdatadir[@]|$(pkgdatadir)|g' \ + -e 's|@prefix[@]|$(prefix)|g' \ + -e 's|@autoconf-name[@]|'`echo autoconf | sed '$(transform)'`'|g' \ + -e 's|@autoheader-name[@]|'`echo autoheader | sed '$(transform)'`'|g' \ + -e 's|@autom4te-name[@]|'`echo autom4te | sed '$(transform)'`'|g' \ + -e 's|@M4[@]|$(M4)|g' \ + -e 's|@AWK[@]|$(AWK)|g' \ + -e 's|@VERSION[@]|$(VERSION)|g' \ + -e 's|@PACKAGE_NAME[@]|$(PACKAGE_NAME)|g' + + +# All the files below depend on Makefile so that they are rebuilt +# when the prefix, etc. changes. Unfortunately, suffix rules +# cannot have additional dependencies, so we have to use explicit rules. +CLEANFILES = autom4te.cfg +all: all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-nodist_pkgdataDATA: $(nodist_pkgdata_DATA) + @$(NORMAL_INSTALL) + test -z "$(pkgdatadir)" || $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" + @list='$(nodist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgdatadir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgdatadir)" || exit $$?; \ + done + +uninstall-nodist_pkgdataDATA: + @$(NORMAL_UNINSTALL) + @list='$(nodist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(pkgdatadir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(pkgdatadir)" && rm -f $$files + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +$(RECURSIVE_CLEAN_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile $(DATA) +installdirs: installdirs-recursive +installdirs-am: + for dir in "$(DESTDIR)$(pkgdatadir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: install-nodist_pkgdataDATA + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: uninstall-nodist_pkgdataDATA + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) ctags-recursive \ + install-am install-strip tags-recursive + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am check check-am clean clean-generic ctags \ + ctags-recursive distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-nodist_pkgdataDATA install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs installdirs-am maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am tags tags-recursive uninstall uninstall-am \ + uninstall-nodist_pkgdataDATA + +autom4te.cfg: $(srcdir)/autom4te.in Makefile + rm -f autom4te.cfg autom4te.tmp + $(edit) $(srcdir)/autom4te.in >autom4te.tmp + chmod a-w autom4te.tmp + mv autom4te.tmp autom4te.cfg + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/autoconf/Makefile.am b/lib/autoconf/Makefile.am new file mode 100644 index 0000000..4a35a93 --- /dev/null +++ b/lib/autoconf/Makefile.am @@ -0,0 +1,54 @@ +# Make Autoconf library. + +# Copyright (C) 2001-2002, 2006, 2009-2012 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +autoconflibdir = $(pkgdatadir)/autoconf +dist_autoconflib_DATA = \ + autoconf.m4 \ + general.m4 status.m4 oldnames.m4 specific.m4 \ + autoheader.m4 autoupdate.m4 autotest.m4 autoscan.m4 \ + lang.m4 c.m4 erlang.m4 fortran.m4 \ + functions.m4 go.m4 headers.m4 types.m4 libs.m4 programs.m4 + +nodist_autoconflib_DATA = autoconf.m4f +CLEANFILES = $(nodist_autoconflib_DATA) + + +## --------------- ## +## Building TAGS. ## +## --------------- ## + +TAGS_FILES = $(dist_autoconflib_DATA) + +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) + + +## -------- ## +## Checks. ## +## -------- ## + +check-local: check-forbidden-patterns +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_autoconflib_DATA) + + +## ------------------ ## +## The frozen files. ## +## ------------------ ## + +autoconf.m4f: $(autoconf_m4f_dependencies) +include ../freeze.mk diff --git a/lib/autoconf/Makefile.in b/lib/autoconf/Makefile.in new file mode 100644 index 0000000..6ff3138 --- /dev/null +++ b/lib/autoconf/Makefile.in @@ -0,0 +1,606 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autoconf library. + +# Copyright (C) 2001-2002, 2006, 2009-2012 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Freeze M4 files. + +# Copyright (C) 2002, 2004, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(dist_autoconflib_DATA) $(srcdir)/../freeze.mk \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in +subdir = lib/autoconf +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(autoconflibdir)" \ + "$(DESTDIR)$(autoconflibdir)" +DATA = $(dist_autoconflib_DATA) $(nodist_autoconflib_DATA) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +autoconflibdir = $(pkgdatadir)/autoconf +dist_autoconflib_DATA = \ + autoconf.m4 \ + general.m4 status.m4 oldnames.m4 specific.m4 \ + autoheader.m4 autoupdate.m4 autotest.m4 autoscan.m4 \ + lang.m4 c.m4 erlang.m4 fortran.m4 \ + functions.m4 go.m4 headers.m4 types.m4 libs.m4 programs.m4 + +nodist_autoconflib_DATA = autoconf.m4f +CLEANFILES = $(nodist_autoconflib_DATA) +TAGS_FILES = $(dist_autoconflib_DATA) +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_autoconflib_DATA) +SUFFIXES = .m4 .m4f +AUTOM4TE_CFG = $(top_builddir)/lib/autom4te.cfg + +# Do not use AUTOM4TE here, since maint.mk (my-distcheck) +# checks if we are independent of Autoconf by defining AUTOM4TE (and +# others) to `false'. Autoconf provides autom4te, so that doesn't +# apply to us. +MY_AUTOM4TE = \ + autom4te_perllibdir='$(top_srcdir)'/lib \ + AUTOM4TE_CFG='$(AUTOM4TE_CFG)' $(top_builddir)/bin/autom4te \ + -B '$(top_builddir)'/lib -B '$(top_srcdir)'/lib # keep ` ' + + +# Factor the dependencies between all the frozen files. +# Some day we should explain to Automake how to use autom4te to compute +# the dependencies... +src_libdir = $(top_srcdir)/lib +build_libdir = $(top_builddir)/lib +m4f_dependencies = $(top_builddir)/bin/autom4te $(AUTOM4TE_CFG) +m4sugar_m4f_dependencies = \ + $(m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sugar.m4 \ + $(build_libdir)/m4sugar/version.m4 + +m4sh_m4f_dependencies = \ + $(m4sugar_m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sh.m4 + +autotest_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autotest/autotest.m4 \ + $(src_libdir)/autotest/general.m4 \ + $(src_libdir)/autotest/specific.m4 + +autoconf_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autoconf/autoscan.m4 \ + $(src_libdir)/autoconf/general.m4 \ + $(src_libdir)/autoconf/autoheader.m4 \ + $(src_libdir)/autoconf/autoupdate.m4 \ + $(src_libdir)/autoconf/autotest.m4 \ + $(src_libdir)/autoconf/status.m4 \ + $(src_libdir)/autoconf/oldnames.m4 \ + $(src_libdir)/autoconf/specific.m4 \ + $(src_libdir)/autoconf/lang.m4 \ + $(src_libdir)/autoconf/c.m4 \ + $(src_libdir)/autoconf/fortran.m4 \ + $(src_libdir)/autoconf/erlang.m4 \ + $(src_libdir)/autoconf/go.m4 \ + $(src_libdir)/autoconf/functions.m4 \ + $(src_libdir)/autoconf/headers.m4 \ + $(src_libdir)/autoconf/types.m4 \ + $(src_libdir)/autoconf/libs.m4 \ + $(src_libdir)/autoconf/programs.m4 \ + $(src_libdir)/autoconf/autoconf.m4 + +ETAGS_FOR_M4 = \ + --lang=none \ + --regex='/\(m4_define\|define\)(\[\([^]]*\)\]/\2/' + +ETAGS_FOR_M4SUGAR = \ + $(ETAGS_FOR_M4) \ + --regex='/m4_defun(\[\([^]]*\)\]/\1/' + +ETAGS_FOR_AUTOCONF = \ + $(ETAGS_FOR_M4SUGAR) \ + --regex='/\(A[CU]_DEFUN\|AU_ALIAS\)(\[\([^]]*\)\]/\2/' \ + --regex='/AN_\(FUNCTION\|HEADER\|IDENTIFIER\|LIBRARY\|MAKEVAR\|PROGRAM\)(\[\([^]]*\)\]/\2/' + +all: all-am + +.SUFFIXES: +.SUFFIXES: .m4 .m4f +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(srcdir)/../freeze.mk $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/autoconf/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/autoconf/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-dist_autoconflibDATA: $(dist_autoconflib_DATA) + @$(NORMAL_INSTALL) + test -z "$(autoconflibdir)" || $(MKDIR_P) "$(DESTDIR)$(autoconflibdir)" + @list='$(dist_autoconflib_DATA)'; test -n "$(autoconflibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(autoconflibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(autoconflibdir)" || exit $$?; \ + done + +uninstall-dist_autoconflibDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_autoconflib_DATA)'; test -n "$(autoconflibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(autoconflibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(autoconflibdir)" && rm -f $$files +install-nodist_autoconflibDATA: $(nodist_autoconflib_DATA) + @$(NORMAL_INSTALL) + test -z "$(autoconflibdir)" || $(MKDIR_P) "$(DESTDIR)$(autoconflibdir)" + @list='$(nodist_autoconflib_DATA)'; test -n "$(autoconflibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(autoconflibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(autoconflibdir)" || exit $$?; \ + done + +uninstall-nodist_autoconflibDATA: + @$(NORMAL_UNINSTALL) + @list='$(nodist_autoconflib_DATA)'; test -n "$(autoconflibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(autoconflibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(autoconflibdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-local +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(autoconflibdir)" "$(DESTDIR)$(autoconflibdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_autoconflibDATA \ + install-nodist_autoconflibDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_autoconflibDATA \ + uninstall-nodist_autoconflibDATA + +.MAKE: check-am install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am check-local clean \ + clean-generic ctags distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am \ + install-dist_autoconflibDATA install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man \ + install-nodist_autoconflibDATA install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am tags uninstall uninstall-am \ + uninstall-dist_autoconflibDATA \ + uninstall-nodist_autoconflibDATA + + +check-local: check-forbidden-patterns + +autoconf.m4f: $(autoconf_m4f_dependencies) +$(AUTOM4TE_CFG): $(top_srcdir)/lib/autom4te.in + cd $(top_builddir)/lib && $(MAKE) $(AM_MAKEFLAGS) autom4te.cfg + +# When processing the file with diversion disabled, there must be no +# output but comments and empty lines. +# If freezing produces output, something went wrong: a bad `divert', +# or an improper paren etc. +# It may happen that the output does not end with an end of line, hence +# force an end of line when reporting errors. +.m4.m4f: + $(MY_AUTOM4TE) \ + --language=$* \ + --freeze \ + --output=$@ + +# For parallel builds. +$(build_libdir)/m4sugar/version.m4: + cd $(build_libdir)/m4sugar && $(MAKE) $(AM_MAKEFLAGS) version.m4 + +check-forbidden-patterns: + @if (cd $(srcdir) && \ + $(GREP) $(forbidden_patterns) $(forbidden_patterns_files)) \ + >forbidden.log; then \ + echo "ERROR: forbidden patterns were found:" >&2; \ + sed "s|^|$*.m4: |" <forbidden.log >&2; \ + echo >&2; \ + exit 1; \ + else \ + rm -f forbidden.log; \ + fi + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/autoconf/autoconf.m4 b/lib/autoconf/autoconf.m4 new file mode 100644 index 0000000..2687255 --- /dev/null +++ b/lib/autoconf/autoconf.m4 @@ -0,0 +1,105 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Driver that loads the Autoconf macro files. +# +# Copyright (C) 1994, 1999-2002, 2006, 2008-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie and many others. +# +# Do not sinclude acsite.m4 here, because it may not be installed +# yet when Autoconf is frozen. +# Do not sinclude ./aclocal.m4 here, to prevent it from being frozen. + +# general includes some AU_DEFUN. +m4_include([autoconf/autoupdate.m4]) +m4_include([autoconf/autoscan.m4]) +m4_include([autoconf/general.m4]) +m4_include([autoconf/status.m4]) +m4_include([autoconf/autoheader.m4]) +m4_include([autoconf/autotest.m4]) +m4_include([autoconf/programs.m4]) +m4_include([autoconf/lang.m4]) +m4_include([autoconf/c.m4]) +m4_include([autoconf/erlang.m4]) +m4_include([autoconf/fortran.m4]) +m4_include([autoconf/go.m4]) +m4_include([autoconf/functions.m4]) +m4_include([autoconf/headers.m4]) +m4_include([autoconf/types.m4]) +m4_include([autoconf/libs.m4]) +m4_include([autoconf/specific.m4]) +m4_include([autoconf/oldnames.m4]) + +# We discourage the use of the non prefixed macro names: M4sugar maps +# all the builtins into `m4_'. Autoconf has been converted to these +# names too. But users may still depend upon these, so reestablish +# them. + +# In order to copy pushdef stacks, m4_copy temporarily destroys the +# current pushdef stack. But these builtins are so primitive that: +# 1. they should not have more than one pushdef definition +# 2. undefining the pushdef stack to copy breaks m4_copy +# Hence, we temporarily restore a simpler m4_copy. + +m4_pushdef([m4_copy], [m4_define([$2], m4_defn([$1]))]) + +m4_copy_unm4([m4_builtin]) +m4_copy_unm4([m4_changequote]) +m4_copy_unm4([m4_decr]) +m4_copy_unm4([m4_define]) +m4_copy_unm4([m4_defn]) +m4_copy_unm4([m4_divert]) +m4_copy_unm4([m4_divnum]) +m4_copy_unm4([m4_errprint]) +m4_copy_unm4([m4_esyscmd]) +m4_copy_unm4([m4_ifdef]) +m4_copy([m4_if], [ifelse]) +m4_copy_unm4([m4_incr]) +m4_copy_unm4([m4_index]) +m4_copy_unm4([m4_indir]) +m4_copy_unm4([m4_len]) +m4_copy([m4_bpatsubst], [patsubst]) +m4_copy_unm4([m4_popdef]) +m4_copy_unm4([m4_pushdef]) +m4_copy([m4_bregexp], [regexp]) +m4_copy_unm4([m4_sinclude]) +m4_copy_unm4([m4_syscmd]) +m4_copy_unm4([m4_sysval]) +m4_copy_unm4([m4_traceoff]) +m4_copy_unm4([m4_traceon]) +m4_copy_unm4([m4_translit]) +m4_copy_unm4([m4_undefine]) +m4_copy_unm4([m4_undivert]) + +m4_popdef([m4_copy]) + +# Yet some people have started to use m4_patsubst and m4_regexp. +m4_define([m4_patsubst], +[m4_expand_once([m4_warn([syntax], + [do not use m4_patsubst: use patsubst or m4_bpatsubst])])dnl +patsubst($@)]) + +m4_define([m4_regexp], +[m4_expand_once([m4_warn([syntax], + [do not use m4_regexp: use regexp or m4_bregexp])])dnl +regexp($@)]) diff --git a/lib/autoconf/autoheader.m4 b/lib/autoconf/autoheader.m4 new file mode 100644 index 0000000..14a91b9 --- /dev/null +++ b/lib/autoconf/autoheader.m4 @@ -0,0 +1,78 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Interface with autoheader. + +# Copyright (C) 1992-1996, 1998-2002, 2008-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# AH_OUTPUT(KEY, TEXT) +# -------------------- +# Pass TEXT to autoheader. +# This macro is `read' only via `autoconf --trace', it outputs nothing. +m4_define([AH_OUTPUT], []) + + +# AH_VERBATIM(KEY, TEMPLATE) +# -------------------------- +# If KEY is direct (i.e., no indirection such as in KEY=$my_func which +# may occur if there is AC_CHECK_FUNCS($my_func)), issue an autoheader +# TEMPLATE associated to the KEY. Otherwise, do nothing. TEMPLATE is +# output as is, with no formatting. +# +# Quote for Perl '' strings, which are those used by Autoheader. +m4_define([AH_VERBATIM], +[AS_LITERAL_WORD_IF([$1], + [AH_OUTPUT(_m4_expand([$1]), AS_ESCAPE([[$2]], [\']))])]) + + +# AH_TEMPLATE(KEY, DESCRIPTION) +# ----------------------------- +# Issue an autoheader template for KEY, i.e., a comment composed of +# DESCRIPTION (properly wrapped), and then #undef KEY. +m4_define([AH_TEMPLATE], +[AH_VERBATIM([$1], + m4_text_wrap([$2 */], [ ], [/* ])[ +@%:@undef ]_m4_expand([$1]))]) + + +# AH_TOP(TEXT) +# ------------ +# Output TEXT at the top of `config.h.in'. +m4_define([AH_TOP], +[m4_define([_AH_COUNTER], m4_incr(_AH_COUNTER))dnl +AH_VERBATIM([0000]_AH_COUNTER, [$1])]) + + +# AH_BOTTOM(TEXT) +# --------------- +# Output TEXT at the bottom of `config.h.in'. +m4_define([AH_BOTTOM], +[m4_define([_AH_COUNTER], m4_incr(_AH_COUNTER))dnl +AH_VERBATIM([zzzz]_AH_COUNTER, [$1])]) + +# Initialize. +m4_define([_AH_COUNTER], [0]) diff --git a/lib/autoconf/autoscan.m4 b/lib/autoconf/autoscan.m4 new file mode 100644 index 0000000..bad971e --- /dev/null +++ b/lib/autoconf/autoscan.m4 @@ -0,0 +1,50 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Interface with autoscan. + +# Copyright (C) 2002, 2009-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by Akim Demaille. + +# The prefix `AN' is chosen after `AutoscaN'. + +# AN_OUTPUT(KIND, WORD, MACROS) +# ----------------------------- +# Declare that the WORD, used as a KIND, requires triggering the MACROS. +m4_define([AN_OUTPUT], []) + + +# AN_FUNCTION(NAME, MACROS) +# AN_HEADER(NAME, MACROS) +# AN_IDENTIFIER(NAME, MACROS) +# AN_LIBRARY(NAME, MACROS) +# AN_MAKEVAR(NAME, MACROS) +# AN_PROGRAM(NAME, MACROS) +# --------------------------- +# If the FUNCTION/HEADER etc. is used in the package, then the MACROS +# should be invoked from configure.ac. +m4_define([AN_FUNCTION], [AN_OUTPUT([function], $@)]) +m4_define([AN_HEADER], [AN_OUTPUT([header], $@)]) +m4_define([AN_IDENTIFIER], [AN_OUTPUT([identifier], $@)]) +m4_define([AN_LIBRARY], [AN_OUTPUT([library], $@)]) +m4_define([AN_MAKEVAR], [AN_OUTPUT([makevar], $@)]) +m4_define([AN_PROGRAM], [AN_OUTPUT([program], $@)]) diff --git a/lib/autoconf/autotest.m4 b/lib/autoconf/autotest.m4 new file mode 100644 index 0000000..64e3d56 --- /dev/null +++ b/lib/autoconf/autotest.m4 @@ -0,0 +1,77 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Interface with Autotest. +# Copyright (C) 1992-1996, 1998-2005, 2009-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# AC_CONFIG_TESTDIR(TEST-DIRECTORY, [AUTOTEST-PATH = TEST-DIRECTORY]) +# ------------------------------------------------------------------- +# Configure an Autotest test suite directory. Invoke it once per dir, +# even if there are several test suites in there. +# +# AUTOTEST-PATH must help the test suite to find the executables. +# It is relative to the top level of the package, and is expanded +# into all the build dirs of AUTOTEST-PATH, then all the src dirs. +# +# Do not use _ACEOF as we are being dumped into config.status via +# an _ACEOF-heredoc. +AC_DEFUN([AC_CONFIG_TESTDIR], +[AC_CONFIG_COMMANDS([$1/atconfig], +[cat >$1/atconfig <<ATEOF +@%:@ Configurable variable values for building test suites. +@%:@ Generated by $[0]. +@%:@ Copyright (C) m4_PACKAGE_YEAR Free Software Foundation, Inc. + +# The test suite will define top_srcdir=$at_top_srcdir/../.. etc. +at_testdir='$1' +abs_builddir='$ac_abs_builddir' +at_srcdir='$ac_srcdir' +abs_srcdir='$ac_abs_srcdir' +at_top_srcdir='$ac_top_srcdir' +abs_top_srcdir='$ac_abs_top_srcdir' +at_top_build_prefix='$ac_top_build_prefix' +abs_top_builddir='$ac_abs_top_builddir' + +# Backward compatibility with Autotest <= 2.59b: +at_top_builddir=\$at_top_build_prefix + +AUTOTEST_PATH='m4_default([$2], [$1])' + +SHELL=\${CONFIG_SHELL-'$SHELL'} +m4_provide_if([AC_ERLANG_PATH_ERL], [ +ERL='$ERL' +])dnl +m4_provide_if([AC_ERLANG_PATH_ERLC], [ +ERLC='$ERLC' +ERLCFLAGS='$ERLCFLAGS' +])dnl +ATEOF +], +[m4_provide_if([AC_ERLANG_PATH_ERL], [ERL="$ERL" +])m4_provide_if([AC_ERLANG_PATH_ERLC], [ERLC="$ERLC" +ERLCFLAGS="$ERLCFLAGS" +])])])# AC_CONFIG_TESTDIR diff --git a/lib/autoconf/autoupdate.m4 b/lib/autoconf/autoupdate.m4 new file mode 100644 index 0000000..8866d33 --- /dev/null +++ b/lib/autoconf/autoupdate.m4 @@ -0,0 +1,108 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Interface with autoupdate. + +# Copyright (C) 1992-1996, 1998-2001, 2003-2004, 2006, 2009-2012 Free +# Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +## ---------------------------------- ## +## Macros to define obsolete macros. ## +## ---------------------------------- ## + + +# AU_DEFINE(NAME, CODE) +# --------------------- +# Define the macro NAME so that it expand to CODE only when +# autoupdate is running. This is achieved with traces in +# autoupdate itself, so this macro expands to nothing. +# +m4_define([AU_DEFINE], []) + +# AU_DEFUN(NAME, NEW-CODE, [MESSAGE]) +# ----------------------------------- +# Declare that the macro NAME is now obsoleted, and should be replaced +# by NEW-CODE. Tell the user she should run autoupdate, and when +# autoupdate is run, emit MESSAGE as a warning and include it in +# the updated configure.ac file. +# +# Also define NAME as a macro which code is NEW-CODE. +# +# This allows sharing the same code for both supporting obsoleted macros, +# and to update a configure.ac. +# See the end of `autoupdate.in' for a longer description. +m4_define([AU_DEFUN], +[# This is what autoupdate's m4 run will expand. It fires +# the warning (with _au_warn_XXX), outputs it into the +# updated configure.ac (with AC_DIAGNOSE), and then outputs +# the replacement expansion. +AU_DEFINE([$1], +[m4_ifval([$3], [_au_warn_$1([$3])AC_DIAGNOSE([obsolete], [$3])d[]nl +])dnl +$2]) + +# This is an auxiliary macro that is also run when +# autoupdate runs m4. It simply calls m4_warning, but +# we need a wrapper so that each warning is emitted only +# once. We break the quoting in m4_warning's argument in +# order to expand this macro's arguments, not AU_DEFUN's. +AU_DEFINE([_au_warn_$1], +[m4_warning($][@)dnl +m4_define([_au_warn_$1], [])]) + +# Finally, this is the expansion that is picked up by +# autoconf. It tells the user to run autoupdate, and +# then outputs the replacement expansion. We do not care +# about autoupdate's warning because that contains +# information on what to do *after* running autoupdate. +AC_DEFUN([$1], + [AC_DIAGNOSE([obsolete], [The macro `$1' is obsolete. +You should run autoupdate.])dnl +$2])]) + + +# AU_ALIAS(OLD-NAME, NEW-NAME) +# ---------------------------- +# The OLD-NAME is no longer used, just use NEW-NAME instead. There is +# little difference with using AU_DEFUN but the fact there is little +# interest in running the test suite on both OLD-NAME and NEW-NAME. +# This macro makes it possible to distinguish such cases. +# +# Do not use `defn' since then autoupdate would replace an old macro +# call with the new macro body instead of the new macro call. +# +# Moreover, we have to take care that calls without parameters are +# expanded to calls without parameters, not with one empty parameter. +# This is not only an aesthetic improvement of autoupdate, it also +# matters with poorly written macros which test for $# = 0. +# +m4_define([AU_ALIAS], +[AU_DEFUN([$1], _AU_ALIAS_BODY([$], [$2]))]) + +# The body for the AU_DEFUN above should look like: +# [m4_if($#, 0, [NEW-NAME], [NEW-NAME($@)])] +# Thus the helper macro is: +m4_define([_AU_ALIAS_BODY], [[m4_if($1#, 0, [$2], [$2($1@)])]]) diff --git a/lib/autoconf/c.m4 b/lib/autoconf/c.m4 new file mode 100644 index 0000000..a4fa5d6 --- /dev/null +++ b/lib/autoconf/c.m4 @@ -0,0 +1,2031 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Programming languages support. +# Copyright (C) 2001-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Akim Demaille, Paul Eggert, +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# Table of Contents: +# +# 1. Language selection +# 2. and routines to produce programs in a given language. +# 1a. C 2a. C +# 1b. C++ +# 1c. Objective C +# 1d. Objective C++ +# +# 3. Looking for a compiler +# And possibly the associated preprocessor. +# 3a. C 3b. C++ 3c. Objective C 3d. Objective C++ +# +# 4. Compilers' characteristics. +# 4a. C + + + +## ----------------------- ## +## 1a/2a. The C language. ## +## ----------------------- ## + + +# ------------------------ # +# 1a. Language selection. # +# ------------------------ # + +# AC_LANG(C) +# ---------- +# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. +AC_LANG_DEFINE([C], [c], [C], [CC], [], +[ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +]) + + +# AC_LANG_C +# --------- +AU_DEFUN([AC_LANG_C], [AC_LANG(C)]) + + +# ------------------------ # +# 2a. Producing programs. # +# ------------------------ # + + +# AC_LANG_CONFTEST(C)(BODY) +# ------------------------- +# We can't use '#line $LINENO "configure"' here, since +# Sun c89 (Sun WorkShop 6 update 2 C 5.3 Patch 111679-08 2002/05/09) +# rejects $LINENO greater than 32767, and some configure scripts +# are longer than 32767 lines. +m4_define([AC_LANG_CONFTEST(C)], +[cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$1 +_ACEOF]) + + +# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) +# -------------------------------------- +m4_define([AC_LANG_PROGRAM(C)], +[$1 +m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS])[]dnl +m4_ifdef([_AC_LANG_PROGRAM_C_FC_HOOKS], [_AC_LANG_PROGRAM_C_FC_HOOKS])[]dnl +int +main () +{ +dnl Do *not* indent the following line: there may be CPP directives. +dnl Don't move the `;' right after for the same reason. +$2 + ; + return 0; +}]) + + +# _AC_LANG_IO_PROGRAM(C) +# ---------------------- +# Produce source that performs I/O, necessary for proper +# cross-compiler detection. +m4_define([_AC_LANG_IO_PROGRAM(C)], +[AC_LANG_PROGRAM([@%:@include <stdio.h>], +[FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; +])]) + + +# AC_LANG_CALL(C)(PROLOGUE, FUNCTION) +# ----------------------------------- +# Avoid conflicting decl of main. +m4_define([AC_LANG_CALL(C)], +[AC_LANG_PROGRAM([$1 +m4_if([$2], [main], , +[/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 ();])], [return $2 ();])]) + + +# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION) +# ---------------------------------- +# Don't include <ctype.h> because on OSF/1 3.0 it includes +# <sys/types.h> which includes <sys/select.h> which contains a +# prototype for select. Similarly for bzero. +# +# This test used to merely assign f=$1 in main(), but that was +# optimized away by HP unbundled cc A.05.36 for ia64 under +O3, +# presumably on the basis that there's no need to do that store if the +# program is about to exit. Conversely, the AIX linker optimizes an +# unused external declaration that initializes f=$1. So this test +# program has both an external initialization of f, and a use of f in +# main that affects the exit status. +# +m4_define([AC_LANG_FUNC_LINK_TRY(C)], +[AC_LANG_PROGRAM( +[/* Define $1 to an innocuous variant, in case <limits.h> declares $1. + For example, HP-UX 11i <limits.h> declares gettimeofday. */ +#define $1 innocuous_$1 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $1 (); below. + Prefer <limits.h> to <assert.h> if __STDC__ is defined, since + <limits.h> exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include <limits.h> +#else +# include <assert.h> +#endif + +#undef $1 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $1 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$1 || defined __stub___$1 +choke me +#endif +], [return $1 ();])]) + + +# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION) +# ------------------------------------------------- +# Return a program that is valid if EXPRESSION is nonzero. +# EXPRESSION must be an integer constant expression. +# Be sure to use this array to avoid `unused' warnings, which are even +# errors with `-W error'. +m4_define([AC_LANG_BOOL_COMPILE_TRY(C)], +[AC_LANG_PROGRAM([$1], [static int test_array @<:@1 - 2 * !($2)@:>@; +test_array @<:@0@:>@ = 0; +return test_array @<:@0@:>@; +])]) + + +# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION) +# ----------------------------------------- +# We need `stdio.h' to open a `FILE' and `stdlib.h' for `exit'. +# But we include them only after the EXPRESSION has been evaluated. +m4_define([AC_LANG_INT_SAVE(C)], +[AC_LANG_PROGRAM([$1 +static long int longval () { return $2; } +static unsigned long int ulongval () { return $2; } +@%:@include <stdio.h> +@%:@include <stdlib.h>], +[ + FILE *f = fopen ("conftest.val", "w"); + if (! f) + return 1; + if (($2) < 0) + { + long int i = longval (); + if (i != ($2)) + return 1; + fprintf (f, "%ld", i); + } + else + { + unsigned long int i = ulongval (); + if (i != ($2)) + return 1; + fprintf (f, "%lu", i); + } + /* Do not output a trailing newline, as this causes \r\n confusion + on some platforms. */ + return ferror (f) || fclose (f) != 0; +])]) + + + +## ---------------------- ## +## 1b. The C++ language. ## +## ---------------------- ## + + +# AC_LANG(C++) +# ------------ +# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. +AC_LANG_DEFINE([C++], [cxx], [CXX], [CXX], [C], +[ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +]) + + +# AC_LANG_CPLUSPLUS +# ----------------- +AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) + + + +## ------------------------------ ## +## 1c. The Objective C language. ## +## ------------------------------ ## + + +# AC_LANG(Objective C) +# -------------------- +AC_LANG_DEFINE([Objective C], [objc], [OBJC], [OBJC], [C], +[ac_ext=m +ac_cpp='$OBJCPP $CPPFLAGS' +ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_objc_compiler_gnu +]) + + +# AC_LANG_OBJC +# ------------ +AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)]) + + + +## -------------------------------- ## +## 1d. The Objective C++ language. ## +## -------------------------------- ## + + +# AC_LANG(Objective C++) +# ---------------------- +AC_LANG_DEFINE([Objective C++], [objcxx], [OBJCXX], [OBJCXX], [C++], +[ac_ext=mm +ac_cpp='$OBJCXXCPP $CPPFLAGS' +ac_compile='$OBJCXX -c $OBJCXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$OBJCXX -o conftest$ac_exeext $OBJCXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_objcxx_compiler_gnu +]) + + + +## -------------------------------------------- ## +## 3. Looking for Compilers and Preprocessors. ## +## -------------------------------------------- ## + +# -------------------- # +# 3a. The C compiler. # +# -------------------- # + + +# _AC_ARG_VAR_CPPFLAGS +# -------------------- +# Document and register CPPFLAGS, which is used by +# AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP, OBJCXX, OBJCXXCPP}. +AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], +[AC_ARG_VAR([CPPFLAGS], + [(Objective) C/C++ preprocessor flags, e.g. -I<include dir> + if you have headers in a nonstandard directory <include dir>])]) + + +# _AC_ARG_VAR_LDFLAGS +# ------------------- +# Document and register LDFLAGS, which is used by +# AC_PROG_{CC, CXX, F77, FC, OBJC, OBJCXX}. +AC_DEFUN([_AC_ARG_VAR_LDFLAGS], +[AC_ARG_VAR([LDFLAGS], + [linker flags, e.g. -L<lib dir> if you have libraries in a + nonstandard directory <lib dir>])]) + + +# _AC_ARG_VAR_LIBS +# ---------------- +# Document and register LIBS, which is used by +# AC_PROG_{CC, CXX, F77, FC, OBJC, OBJCXX}. +AC_DEFUN([_AC_ARG_VAR_LIBS], +[AC_ARG_VAR([LIBS], + [libraries to pass to the linker, e.g. -l<library>])]) + + +# AC_LANG_PREPROC(C) +# ------------------ +# Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(C)], +[AC_REQUIRE([AC_PROG_CPP])]) + + +# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT) +# ----------------------------------------------- +# Check if $ac_cpp is a working preprocessor that can flag absent +# includes either by the exit status or by warnings. +# This macro is for all languages, not only C. +AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE], +[ac_preproc_ok=false +for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since + # <limits.h> exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__ +@%:@ include <limits.h> +@%:@else +@%:@ include <assert.h> +@%:@endif + Syntax error]])], + [], + [# Broken: fails on valid input. +continue]) + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])], + [# Broken: success on invalid input. +continue], + [# Passes both tests. +ac_preproc_ok=: +break]) + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +AS_IF([$ac_preproc_ok], [$1], [$2]) +])# _AC_PROG_PREPROC_WORKS_IFELSE + + +# AC_PROG_CPP +# ----------- +# Find a working C preprocessor. +# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency +# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC. +AN_MAKEVAR([CPP], [AC_PROG_CPP]) +AN_PROGRAM([cpp], [AC_PROG_CPP]) +AC_DEFUN([AC_PROG_CPP], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_ARG_VAR([CPP], [C preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(C)dnl +AC_MSG_CHECKING([how to run the C preprocessor]) +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + AC_CACHE_VAL([ac_cv_prog_CPP], + [dnl + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_CPP=$CPP + ])dnl + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +AC_MSG_RESULT([$CPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])]) +AC_SUBST(CPP)dnl +AC_LANG_POP(C)dnl +])# AC_PROG_CPP + +# AC_PROG_CPP_WERROR +# ------------------ +# Treat warnings from the preprocessor as errors. +AC_DEFUN([AC_PROG_CPP_WERROR], +[AC_REQUIRE([AC_PROG_CPP])dnl +ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR + +# AC_LANG_COMPILER(C) +# ------------------- +# Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(C)], +[AC_REQUIRE([AC_PROG_CC])]) + + +# ac_cv_prog_gcc +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([ac_cv_prog_gcc], +[ac_cv_c_compiler_gnu]) + + +# AC_PROG_CC([COMPILER ...]) +# -------------------------- +# COMPILER ... is a space separated list of C compilers to search for. +# This just gives the user an opportunity to specify an alternative +# search list for the C compiler. +AN_MAKEVAR([CC], [AC_PROG_CC]) +AN_PROGRAM([cc], [AC_PROG_CC]) +AN_PROGRAM([gcc], [AC_PROG_CC]) +AC_DEFUN([AC_PROG_CC], +[AC_LANG_PUSH(C)dnl +AC_ARG_VAR([CC], [C compiler command])dnl +AC_ARG_VAR([CFLAGS], [C compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +m4_ifval([$1], + [AC_CHECK_TOOLS(CC, [$1])], +[AC_CHECK_TOOL(CC, gcc) +if test -z "$CC"; then + dnl Here we want: + dnl AC_CHECK_TOOL(CC, cc) + dnl but without the check for a tool without the prefix. + dnl Until the check is removed from there, copy the code: + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc]) + fi +fi +if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) +fi +if test -z "$CC"; then + AC_CHECK_TOOLS(CC, cl.exe) +fi +]) + +test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH]) + +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +_AC_PROG_CC_G +_AC_PROG_CC_C89 +AC_LANG_POP(C)dnl +])# AC_PROG_CC + + +# _AC_PROG_CC_G +# ------------- +# Check whether -g works, even if CFLAGS is set, in case the package +# plays around with CFLAGS (such as to build both debugging and normal +# versions of a library), tasteless as that idea is. +# Don't consider -g to work if it generates warnings when plain compiles don't. +m4_define([_AC_PROG_CC_G], +[ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g, + [ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_cc_g=yes], + [CFLAGS="" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [], + [ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_cc_g=yes])])]) + ac_c_werror_flag=$ac_save_c_werror_flag]) +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi[]dnl +])# _AC_PROG_CC_G + + +# AC_PROG_GCC_TRADITIONAL +# ----------------------- +AC_DEFUN([AC_PROG_GCC_TRADITIONAL], +[AC_REQUIRE([AC_PROG_CC])dnl +if test $ac_cv_c_compiler_gnu = yes; then + AC_CACHE_CHECK(whether $CC needs -traditional, + ac_cv_prog_gcc_traditional, +[ ac_pattern="Autoconf.*'x'" + AC_EGREP_CPP($ac_pattern, [#include <sgtty.h> +Autoconf TIOCGETP], + ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no) + + if test $ac_cv_prog_gcc_traditional = no; then + AC_EGREP_CPP($ac_pattern, [#include <termio.h> +Autoconf TCGETA], + ac_cv_prog_gcc_traditional=yes) + fi]) + if test $ac_cv_prog_gcc_traditional = yes; then + CC="$CC -traditional" + fi +fi +])# AC_PROG_GCC_TRADITIONAL + + +# AC_PROG_CC_C_O +# -------------- +AC_DEFUN([AC_PROG_CC_C_O], +[AC_REQUIRE([AC_PROG_CC])dnl +if test "x$CC" != xcc; then + AC_MSG_CHECKING([whether $CC and cc understand -c and -o together]) +else + AC_MSG_CHECKING([whether cc understands -c and -o together]) +fi +set dummy $CC; ac_cc=`AS_ECHO(["$[2]"]) | + sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'` +AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o, +[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) +# Make sure it works both with $CC and with simple cc. +# We do the test twice because some compilers refuse to overwrite an +# existing .o file with -o, though they will create one. +ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' +rm -f conftest2.* +if _AC_DO_VAR(ac_try) && + test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try); +then + eval ac_cv_prog_cc_${ac_cc}_c_o=yes + if test "x$CC" != xcc; then + # Test first that cc exists at all. + if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then + ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' + rm -f conftest2.* + if _AC_DO_VAR(ac_try) && + test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try); + then + # cc works too. + : + else + # cc exists but doesn't like -o. + eval ac_cv_prog_cc_${ac_cc}_c_o=no + fi + fi + fi +else + eval ac_cv_prog_cc_${ac_cc}_c_o=no +fi +rm -f core conftest* +])dnl +if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) + AC_DEFINE(NO_MINUS_C_MINUS_O, 1, + [Define to 1 if your C compiler doesn't accept -c and -o together.]) +fi +])# AC_PROG_CC_C_O + + + +# ---------------------- # +# 3b. The C++ compiler. # +# ---------------------- # + + +# AC_LANG_PREPROC(C++) +# -------------------- +# Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(C++)], +[AC_REQUIRE([AC_PROG_CXXCPP])]) + + +# AC_PROG_CXXCPP +# -------------- +# Find a working C++ preprocessor. +# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency +# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX. +AC_DEFUN([AC_PROG_CXXCPP], +[AC_REQUIRE([AC_PROG_CXX])dnl +AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(C++)dnl +AC_MSG_CHECKING([how to run the C++ preprocessor]) +if test -z "$CXXCPP"; then + AC_CACHE_VAL(ac_cv_prog_CXXCPP, + [dnl + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_CXXCPP=$CXXCPP + ])dnl + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +AC_MSG_RESULT([$CXXCPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])]) +AC_SUBST(CXXCPP)dnl +AC_LANG_POP(C++)dnl +])# AC_PROG_CXXCPP + + +# AC_LANG_COMPILER(C++) +# --------------------- +# Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(C++)], +[AC_REQUIRE([AC_PROG_CXX])]) + + +# ac_cv_prog_gxx +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([ac_cv_prog_gxx], +[ac_cv_cxx_compiler_gnu]) + + +# AC_PROG_CXX([LIST-OF-COMPILERS]) +# -------------------------------- +# LIST-OF-COMPILERS is a space separated list of C++ compilers to search +# for (if not specified, a default list is used). This just gives the +# user an opportunity to specify an alternative search list for the C++ +# compiler. +# aCC HP-UX C++ compiler much better than `CC', so test before. +# FCC Fujitsu C++ compiler +# KCC KAI C++ compiler +# RCC Rational C++ +# xlC_r AIX C Set++ (with support for reentrant code) +# xlC AIX C Set++ +AN_MAKEVAR([CXX], [AC_PROG_CXX]) +AN_PROGRAM([CC], [AC_PROG_CXX]) +AN_PROGRAM([c++], [AC_PROG_CXX]) +AN_PROGRAM([g++], [AC_PROG_CXX]) +AC_DEFUN([AC_PROG_CXX], +[AC_LANG_PUSH(C++)dnl +AC_ARG_VAR([CXX], [C++ compiler command])dnl +AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +_AC_ARG_VAR_PRECIOUS([CCC])dnl +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + AC_CHECK_TOOLS(CXX, + [m4_default([$1], + [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])], + g++) + fi +fi +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +_AC_PROG_CXX_G +AC_LANG_POP(C++)dnl +])# AC_PROG_CXX + + +# _AC_PROG_CXX_G +# -------------- +# Check whether -g works, even if CXXFLAGS is set, in case the package +# plays around with CXXFLAGS (such as to build both debugging and +# normal versions of a library), tasteless as that idea is. +# Don't consider -g to work if it generates warnings when plain compiles don't. +m4_define([_AC_PROG_CXX_G], +[ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g, + [ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_cxx_g=yes], + [CXXFLAGS="" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [], + [ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_cxx_g=yes])])]) + ac_cxx_werror_flag=$ac_save_cxx_werror_flag]) +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi[]dnl +])# _AC_PROG_CXX_G + + +# AC_PROG_CXX_C_O +# --------------- +# Test if the C++ compiler accepts the options `-c' and `-o' +# simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not. +AC_DEFUN([AC_PROG_CXX_C_O], +[AC_REQUIRE([AC_PROG_CXX])dnl +AC_LANG_PUSH([C++])dnl +AC_CACHE_CHECK([whether $CXX understands -c and -o together], + [ac_cv_prog_cxx_c_o], +[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) +# We test twice because some compilers refuse to overwrite an existing +# `.o' file with `-o', although they will create one. +ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' +rm -f conftest2.* +if _AC_DO_VAR(ac_try) && + test -f conftest2.$ac_objext && + _AC_DO_VAR(ac_try); then + ac_cv_prog_cxx_c_o=yes +else + ac_cv_prog_cxx_c_o=no +fi +rm -f conftest*]) +if test $ac_cv_prog_cxx_c_o = no; then + AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1, + [Define to 1 if your C++ compiler doesn't accept + -c and -o together.]) +fi +AC_LANG_POP([C++])dnl +])# AC_PROG_CXX_C_O + + + +# ------------------------------ # +# 3c. The Objective C compiler. # +# ------------------------------ # + + +# AC_LANG_PREPROC(Objective C) +# ---------------------------- +# Find the Objective C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Objective C)], +[AC_REQUIRE([AC_PROG_OBJCPP])]) + + +# AC_PROG_OBJCPP +# -------------- +# Find a working Objective C preprocessor. +AC_DEFUN([AC_PROG_OBJCPP], +[AC_REQUIRE([AC_PROG_OBJC])dnl +AC_ARG_VAR([OBJCPP], [Objective C preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(Objective C)dnl +AC_MSG_CHECKING([how to run the Objective C preprocessor]) +if test -z "$OBJCPP"; then + AC_CACHE_VAL(ac_cv_prog_OBJCPP, + [dnl + # Double quotes because OBJCPP needs to be expanded + for OBJCPP in "$OBJC -E" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_OBJCPP=$OBJCPP + ])dnl + OBJCPP=$ac_cv_prog_OBJCPP +else + ac_cv_prog_OBJCPP=$OBJCPP +fi +AC_MSG_RESULT([$OBJCPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])]) +AC_SUBST(OBJCPP)dnl +AC_LANG_POP(Objective C)dnl +])# AC_PROG_OBJCPP + + +# AC_LANG_COMPILER(Objective C) +# ----------------------------- +# Find the Objective C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(Objective C)], +[AC_REQUIRE([AC_PROG_OBJC])]) + + + +# AC_PROG_OBJC([LIST-OF-COMPILERS]) +# --------------------------------- +# LIST-OF-COMPILERS is a space separated list of Objective C compilers to +# search for (if not specified, a default list is used). This just gives +# the user an opportunity to specify an alternative search list for the +# Objective C compiler. +# objcc StepStone Objective-C compiler (also "standard" name for OBJC) +# objc David Stes' POC. If you installed this, you likely want it. +# cc Native C compiler (for instance, Apple). +# CC You never know. +AN_MAKEVAR([OBJC], [AC_PROG_OBJC]) +AN_PROGRAM([objcc], [AC_PROG_OBJC]) +AN_PROGRAM([objc], [AC_PROG_OBJC]) +AC_DEFUN([AC_PROG_OBJC], +[AC_LANG_PUSH(Objective C)dnl +AC_ARG_VAR([OBJC], [Objective C compiler command])dnl +AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +_AC_ARG_VAR_PRECIOUS([OBJC])dnl +AC_CHECK_TOOLS(OBJC, + [m4_default([$1], [gcc objcc objc cc CC])], + gcc) +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GOBJC=yes +else + GOBJC= +fi +_AC_PROG_OBJC_G +AC_LANG_POP(Objective C)dnl +])# AC_PROG_OBJC + + +# _AC_PROG_OBJC_G +# --------------- +# Check whether -g works, even if OBJCFLAGS is set, in case the package +# plays around with OBJCFLAGS (such as to build both debugging and +# normal versions of a library), tasteless as that idea is. +# Don't consider -g to work if it generates warnings when plain compiles don't. +m4_define([_AC_PROG_OBJC_G], +[ac_test_OBJCFLAGS=${OBJCFLAGS+set} +ac_save_OBJCFLAGS=$OBJCFLAGS +AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g, + [ac_save_objc_werror_flag=$ac_objc_werror_flag + ac_objc_werror_flag=yes + ac_cv_prog_objc_g=no + OBJCFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_objc_g=yes], + [OBJCFLAGS="" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [], + [ac_objc_werror_flag=$ac_save_objc_werror_flag + OBJCFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_objc_g=yes])])]) + ac_objc_werror_flag=$ac_save_objc_werror_flag]) +if test "$ac_test_OBJCFLAGS" = set; then + OBJCFLAGS=$ac_save_OBJCFLAGS +elif test $ac_cv_prog_objc_g = yes; then + if test "$GOBJC" = yes; then + OBJCFLAGS="-g -O2" + else + OBJCFLAGS="-g" + fi +else + if test "$GOBJC" = yes; then + OBJCFLAGS="-O2" + else + OBJCFLAGS= + fi +fi[]dnl +])# _AC_PROG_OBJC_G + + + +# -------------------------------- # +# 3d. The Objective C++ compiler. # +# -------------------------------- # + + +# AC_LANG_PREPROC(Objective C++) +# ------------------------------ +# Find the Objective C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Objective C++)], +[AC_REQUIRE([AC_PROG_OBJCXXCPP])]) + + +# AC_PROG_OBJCXXCPP +# ----------------- +# Find a working Objective C++ preprocessor. +AC_DEFUN([AC_PROG_OBJCXXCPP], +[AC_REQUIRE([AC_PROG_OBJCXX])dnl +AC_ARG_VAR([OBJCXXCPP], [Objective C++ preprocessor])dnl +_AC_ARG_VAR_CPPFLAGS()dnl +AC_LANG_PUSH(Objective C++)dnl +AC_MSG_CHECKING([how to run the Objective C++ preprocessor]) +if test -z "$OBJCXXCPP"; then + AC_CACHE_VAL(ac_cv_prog_OBJCXXCPP, + [dnl + # Double quotes because OBJCXXCPP needs to be expanded + for OBJCXXCPP in "$OBJCXX -E" "/lib/cpp" + do + _AC_PROG_PREPROC_WORKS_IFELSE([break]) + done + ac_cv_prog_OBJCXXCPP=$OBJCXXCPP + ])dnl + OBJCXXCPP=$ac_cv_prog_OBJCXXCPP +else + ac_cv_prog_OBJCXXCPP=$OBJCXXCPP +fi +AC_MSG_RESULT([$OBJCXXCPP]) +_AC_PROG_PREPROC_WORKS_IFELSE([], + [AC_MSG_FAILURE([Objective C++ preprocessor "$OBJCXXCPP" fails sanity check])]) +AC_SUBST(OBJCXXCPP)dnl +AC_LANG_POP(Objective C++)dnl +])# AC_PROG_OBJCXXCPP + + +# AC_LANG_COMPILER(Objective C++) +# ------------------------------- +# Find the Objective C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(Objective C++)], +[AC_REQUIRE([AC_PROG_OBJCXX])]) + + + +# AC_PROG_OBJCXX([LIST-OF-COMPILERS]) +# ----------------------------------- +# LIST-OF-COMPILERS is a space separated list of Objective C++ compilers to +# search for (if not specified, a default list is used). This just gives +# the user an opportunity to specify an alternative search list for the +# Objective C++ compiler. +# FIXME: this list is pure guesswork +# objc++ StepStone Objective-C++ compiler (also "standard" name for OBJCXX) +# objcxx David Stes' POC. If you installed this, you likely want it. +# c++ Native C++ compiler (for instance, Apple). +# CXX You never know. +AN_MAKEVAR([OBJCXX], [AC_PROG_OBJCXX]) +AN_PROGRAM([objcxx], [AC_PROG_OBJCXX]) +AC_DEFUN([AC_PROG_OBJCXX], +[AC_LANG_PUSH(Objective C++)dnl +AC_ARG_VAR([OBJCXX], [Objective C++ compiler command])dnl +AC_ARG_VAR([OBJCXXFLAGS], [Objective C++ compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +_AC_ARG_VAR_PRECIOUS([OBJCXX])dnl +AC_CHECK_TOOLS(OBJCXX, + [m4_default([$1], [g++ objc++ objcxx c++ CXX])], + g++) +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GOBJCXX=yes +else + GOBJCXX= +fi +_AC_PROG_OBJCXX_G +AC_LANG_POP(Objective C++)dnl +])# AC_PROG_OBJCXX + + +# _AC_PROG_OBJCXX_G +# ----------------- +# Check whether -g works, even if OBJCFLAGS is set, in case the package +# plays around with OBJCFLAGS (such as to build both debugging and +# normal versions of a library), tasteless as that idea is. +# Don't consider -g to work if it generates warnings when plain compiles don't. +m4_define([_AC_PROG_OBJCXX_G], +[ac_test_OBJCXXFLAGS=${OBJCXXFLAGS+set} +ac_save_OBJCXXFLAGS=$OBJCXXFLAGS +AC_CACHE_CHECK(whether $OBJCXX accepts -g, ac_cv_prog_objcxx_g, + [ac_save_objcxx_werror_flag=$ac_objcxx_werror_flag + ac_objcxx_werror_flag=yes + ac_cv_prog_objcxx_g=no + OBJCXXFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_objcxx_g=yes], + [OBJCXXFLAGS="" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [], + [ac_objcxx_werror_flag=$ac_save_objcxx_werror_flag + OBJCXXFLAGS="-g" + _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], + [ac_cv_prog_objcxx_g=yes])])]) + ac_objcxx_werror_flag=$ac_save_objcx_werror_flag]) +if test "$ac_test_OBJCXXFLAGS" = set; then + OBJCXXFLAGS=$ac_save_OBJCXXFLAGS +elif test $ac_cv_prog_objcxx_g = yes; then + if test "$GOBJCXX" = yes; then + OBJCXXFLAGS="-g -O2" + else + OBJCXXFLAGS="-g" + fi +else + if test "$GOBJCXX" = yes; then + OBJCXXFLAGS="-O2" + else + OBJCXXFLAGS= + fi +fi[]dnl +])# _AC_PROG_OBJCXX_G + + + +## ------------------------------- ## +## 4. Compilers' characteristics. ## +## ------------------------------- ## + +# -------------------------------- # +# 4a. C compiler characteristics. # +# -------------------------------- # + + +# _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ---------------------------------------------------------------- +# If the C compiler is not in ANSI C89 (ISO C90) mode by default, try +# to add an option to output variable CC to make it so. This macro +# tries various options that select ANSI C89 on some system or +# another. It considers the compiler to be in ANSI C89 mode if it +# handles function prototypes correctly. +AC_DEFUN([_AC_PROG_CC_C89], +[_AC_C_STD_TRY([c89], +[[#include <stdarg.h> +#include <stdio.h> +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv;]], +[[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]], +dnl Don't try gcc -ansi; that turns off useful extensions and +dnl breaks some systems' header files. +dnl AIX circa 2003 -qlanglvl=extc89 +dnl old AIX -qlanglvl=ansi +dnl Ultrix, OSF/1, Tru64 -std +dnl HP-UX 10.20 and later -Ae +dnl HP-UX older versions -Aa -D_HPUX_SOURCE +dnl SVR4 -Xc -D__EXTENSIONS__ +[-qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl +])# _AC_PROG_CC_C89 + + +# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, +# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) +# -------------------------------------------------------------- +# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') +# by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails, +# try again with each compiler option in the space-separated OPTION-LIST; if one +# helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE, +# else ACTION-IF-UNAVAILABLE. +AC_DEFUN([_AC_C_STD_TRY], +[AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C])) +AC_CACHE_VAL(ac_cv_prog_cc_$1, +[ac_cv_prog_cc_$1=no +ac_save_CC=$CC +AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) +for ac_arg in '' $4 +do + CC="$ac_save_CC $ac_arg" + _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) + test "x$ac_cv_prog_cc_$1" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC +])# AC_CACHE_VAL +case "x$ac_cv_prog_cc_$1" in + x) + AC_MSG_RESULT([none needed]) ;; + xno) + AC_MSG_RESULT([unsupported]) ;; + *) + CC="$CC $ac_cv_prog_cc_$1" + AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;; +esac +AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6]) +])# _AC_C_STD_TRY + + +# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ---------------------------------------------------------------- +# If the C compiler is not in ISO C99 mode by default, try to add an +# option to output variable CC to make it so. This macro tries +# various options that select ISO C99 on some system or another. It +# considers the compiler to be in ISO C99 mode if it handles _Bool, +# // comments, flexible array members, inline, long long int, mixed +# code and declarations, named initialization of structs, restrict, +# va_copy, varargs macros, variable declarations in for loops and +# variable length arrays. +AC_DEFUN([_AC_PROG_CC_C99], +[_AC_C_STD_TRY([c99], +[[#include <stdarg.h> +#include <stdbool.h> +#include <stdlib.h> +#include <wchar.h> +#include <stdio.h> + +// Check varargs macros. These examples are taken from C99 6.10.3.5. +#define debug(...) fprintf (stderr, __VA_ARGS__) +#define showlist(...) puts (#__VA_ARGS__) +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) +static void +test_varargs_macros (void) +{ + int x = 1234; + int y = 5678; + debug ("Flag"); + debug ("X = %d\n", x); + showlist (The first, second, and third items.); + report (x>y, "x is %d but y is %d", x, y); +} + +// Check long long types. +#define BIG64 18446744073709551615ull +#define BIG32 4294967295ul +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) +#if !BIG_OK + your preprocessor is broken; +#endif +#if BIG_OK +#else + your preprocessor is broken; +#endif +static long long int bignum = -9223372036854775807LL; +static unsigned long long int ubignum = BIG64; + +struct incomplete_array +{ + int datasize; + double data[]; +}; + +struct named_init { + int number; + const wchar_t *name; + double average; +}; + +typedef const char *ccp; + +static inline int +test_restrict (ccp restrict text) +{ + // See if C++-style comments work. + // Iterate through items via the restricted pointer. + // Also check for declarations in for loops. + for (unsigned int i = 0; *(text+i) != '\0'; ++i) + continue; + return 0; +} + +// Check varargs and va_copy. +static void +test_varargs (const char *format, ...) +{ + va_list args; + va_start (args, format); + va_list args_copy; + va_copy (args_copy, args); + + const char *str; + int number; + float fnumber; + + while (*format) + { + switch (*format++) + { + case 's': // string + str = va_arg (args_copy, const char *); + break; + case 'd': // int + number = va_arg (args_copy, int); + break; + case 'f': // float + fnumber = va_arg (args_copy, double); + break; + default: + break; + } + } + va_end (args_copy); + va_end (args); +} +]], +[[ + // Check bool. + _Bool success = false; + + // Check restrict. + if (test_restrict ("String literal") == 0) + success = true; + char *restrict newvar = "Another string"; + + // Check varargs. + test_varargs ("s, d' f .", "string", 65, 34.234); + test_varargs_macros (); + + // Check flexible array members. + struct incomplete_array *ia = + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); + ia->datasize = 10; + for (int i = 0; i < ia->datasize; ++i) + ia->data[i] = i * 1.234; + + // Check named initializers. + struct named_init ni = { + .number = 34, + .name = L"Test wide string", + .average = 543.34343, + }; + + ni.number = 58; + + int dynamic_array[ni.number]; + dynamic_array[ni.number - 1] = 543; + + // work around unused variable warnings + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' + || dynamic_array[ni.number - 1] != 543); +]], +dnl Try +dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) +dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99) +dnl HP cc -AC99 +dnl Intel ICC -std=c99, -c99 (deprecated) +dnl IRIX -c99 +dnl Solaris -D_STDC_C99= +dnl cc's -xc99 option uses linker magic to define the external +dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 +dnl behavior for C library functions. This is not wanted here, +dnl because it means that a single module compiled with -xc99 +dnl alters C runtime behavior for the entire program, not for +dnl just the module. Instead, define the (private) symbol +dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>. +dnl The resulting compiler passes the test case here, and that's +dnl good enough. For more, please see the thread starting at: +dnl http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html +dnl Tru64 -c99 +dnl with extended modes being tried first. +[[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99]], [$1], [$2])[]dnl +])# _AC_PROG_CC_C99 + + +# AC_PROG_CC_C89 +# -------------- +AC_DEFUN([AC_PROG_CC_C89], +[ AC_REQUIRE([AC_PROG_CC])dnl + _AC_PROG_CC_C89 +]) + + +# AC_PROG_CC_C99 +# -------------- +AC_DEFUN([AC_PROG_CC_C99], +[ AC_REQUIRE([AC_PROG_CC])dnl + _AC_PROG_CC_C99 +]) + + +# AC_PROG_CC_STDC +# --------------- +AC_DEFUN([AC_PROG_CC_STDC], +[ AC_REQUIRE([AC_PROG_CC])dnl + AS_CASE([$ac_cv_prog_cc_stdc], + [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no], + [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99], + [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89], + [ac_cv_prog_cc_stdc=no])])]) + AC_MSG_CHECKING([for $CC option to accept ISO Standard C]) + AC_CACHE_VAL([ac_cv_prog_cc_stdc], []) + AS_CASE([$ac_cv_prog_cc_stdc], + [no], [AC_MSG_RESULT([unsupported])], + [''], [AC_MSG_RESULT([none needed])], + [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])]) +]) + + +# AC_C_BACKSLASH_A +# ---------------- +AC_DEFUN([AC_C_BACKSLASH_A], +[ + AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], + [[ +#if '\a' == 'a' + syntax error; +#endif + char buf['\a' == 'a' ? -1 : 1]; + buf[0] = '\a'; + return buf[0] != "\a"[0]; + ]])], + [ac_cv_c_backslash_a=yes], + [ac_cv_c_backslash_a=no])]) + if test $ac_cv_c_backslash_a = yes; then + AC_DEFINE(HAVE_C_BACKSLASH_A, 1, + [Define if backslash-a works in C strings.]) + fi +]) + + +# AC_C_CROSS +# ---------- +# Has been merged into AC_PROG_CC. +AU_DEFUN([AC_C_CROSS], []) + + +# AC_C_CHAR_UNSIGNED +# ------------------ +AC_DEFUN([AC_C_CHAR_UNSIGNED], +[AH_VERBATIM([__CHAR_UNSIGNED__], +[/* Define to 1 if type `char' is unsigned and you are not using gcc. */ +#ifndef __CHAR_UNSIGNED__ +# undef __CHAR_UNSIGNED__ +#endif])dnl +AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned, +[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])], + [((char) -1) < 0])], + ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)]) +if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then + AC_DEFINE(__CHAR_UNSIGNED__) +fi +])# AC_C_CHAR_UNSIGNED + + +# AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN], +# [ACTION-IF-UNIVERSAL]) +# ------------------------------------------------------------------------- +AC_DEFUN([AC_C_BIGENDIAN], +[AH_VERBATIM([WORDS_BIGENDIAN], +[/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most + significant byte first (like Motorola and SPARC, unlike Intel). */ +#if defined AC_APPLE_UNIVERSAL_BUILD +# if defined __BIG_ENDIAN__ +# define WORDS_BIGENDIAN 1 +# endif +#else +# ifndef WORDS_BIGENDIAN +# undef WORDS_BIGENDIAN +# endif +#endif])dnl + AC_CACHE_CHECK([whether byte ordering is bigendian], [ac_cv_c_bigendian], + [ac_cv_c_bigendian=unknown + # See if we're dealing with a universal compiler. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#ifndef __APPLE_CC__ + not a universal capable compiler + #endif + typedef int dummy; + ]])], + [ + # Check for potential -arch flags. It is not universal unless + # there are at least two -arch flags with different values. + ac_arch= + ac_prev= + for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do + if test -n "$ac_prev"; then + case $ac_word in + i?86 | x86_64 | ppc | ppc64) + if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then + ac_arch=$ac_word + else + ac_cv_c_bigendian=universal + break + fi + ;; + esac + ac_prev= + elif test "x$ac_word" = "x-arch"; then + ac_prev=arch + fi + done]) + if test $ac_cv_c_bigendian = unknown; then + # See if sys/param.h defines the BYTE_ORDER macro. + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[#include <sys/types.h> + #include <sys/param.h> + ]], + [[#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ + && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ + && LITTLE_ENDIAN) + bogus endian macros + #endif + ]])], + [# It does; now see whether it defined to BIG_ENDIAN or not. + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[#include <sys/types.h> + #include <sys/param.h> + ]], + [[#if BYTE_ORDER != BIG_ENDIAN + not big endian + #endif + ]])], + [ac_cv_c_bigendian=yes], + [ac_cv_c_bigendian=no])]) + fi + if test $ac_cv_c_bigendian = unknown; then + # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[#include <limits.h> + ]], + [[#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) + bogus endian macros + #endif + ]])], + [# It does; now see whether it defined to _BIG_ENDIAN or not. + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[#include <limits.h> + ]], + [[#ifndef _BIG_ENDIAN + not big endian + #endif + ]])], + [ac_cv_c_bigendian=yes], + [ac_cv_c_bigendian=no])]) + fi + if test $ac_cv_c_bigendian = unknown; then + # Compile a test program. + AC_RUN_IFELSE( + [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [[ + /* Are we little or big endian? From Harbison&Steele. */ + union + { + long int l; + char c[sizeof (long int)]; + } u; + u.l = 1; + return u.c[sizeof (long int) - 1] == 1; + ]])], + [ac_cv_c_bigendian=no], + [ac_cv_c_bigendian=yes], + [# Try to guess by grepping values from an object file. + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[short int ascii_mm[] = + { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; + short int ascii_ii[] = + { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; + int use_ascii (int i) { + return ascii_mm[i] + ascii_ii[i]; + } + short int ebcdic_ii[] = + { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; + short int ebcdic_mm[] = + { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; + int use_ebcdic (int i) { + return ebcdic_mm[i] + ebcdic_ii[i]; + } + extern int foo; + ]], + [[return use_ascii (foo) == use_ebcdic (foo);]])], + [if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then + ac_cv_c_bigendian=yes + fi + if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then + if test "$ac_cv_c_bigendian" = unknown; then + ac_cv_c_bigendian=no + else + # finding both strings is unlikely to happen, but who knows? + ac_cv_c_bigendian=unknown + fi + fi])]) + fi]) + case $ac_cv_c_bigendian in #( + yes) + m4_default([$1], + [AC_DEFINE([WORDS_BIGENDIAN], 1)]);; #( + no) + $2 ;; #( + universal) +dnl Note that AC_APPLE_UNIVERSAL_BUILD sorts less than WORDS_BIGENDIAN; +dnl this is a necessity for proper config header operation. Warn if +dnl the user did not specify a config header but is relying on the +dnl default behavior for universal builds. + m4_default([$4], + [AC_CONFIG_COMMANDS_PRE([m4_ifset([AH_HEADER], [], + [AC_DIAGNOSE([obsolete], + [AC_C_BIGENDIAN should be used with AC_CONFIG_HEADERS])])])dnl + AC_DEFINE([AC_APPLE_UNIVERSAL_BUILD],1, + [Define if building universal (internal helper macro)])]) + ;; #( + *) + m4_default([$3], + [AC_MSG_ERROR([unknown endianness + presetting ac_cv_c_bigendian=no (or yes) will help])]) ;; + esac +])# AC_C_BIGENDIAN + + +# AC_C_INLINE +# ----------- +# Do nothing if the compiler accepts the inline keyword. +# Otherwise define inline to __inline__ or __inline if one of those work, +# otherwise define inline to be empty. +# +# HP C version B.11.11.04 doesn't allow a typedef as the return value for an +# inline function, only builtin types. +# +AN_IDENTIFIER([inline], [AC_C_INLINE]) +AC_DEFUN([AC_C_INLINE], +[AC_CACHE_CHECK([for inline], ac_cv_c_inline, +[ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + AC_COMPILE_IFELSE([AC_LANG_SOURCE( +[#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif +])], + [ac_cv_c_inline=$ac_kw]) + test "$ac_cv_c_inline" != no && break +done +]) +AH_VERBATIM([inline], +[/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#ifndef __cplusplus +#undef inline +#endif]) +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac +])# AC_C_INLINE + + +# AC_C_CONST +# ---------- +AC_DEFUN([AC_C_CONST], +[AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const, +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], +[[ +#ifndef __cplusplus + /* Ultrix mips cc rejects this sort of thing. */ + typedef int charset[2]; + const charset cs = { 0, 0 }; + /* SunOS 4.1.1 cc rejects this. */ + char const *const *pcpcc; + char **ppc; + /* NEC SVR4.0.2 mips cc rejects this. */ + struct point {int x, y;}; + static struct point const zero = {0,0}; + /* AIX XL C 1.02.0.0 rejects this. + It does not let you subtract one const X* pointer from another in + an arm of an if-expression whose if-part is not a constant + expression */ + const char *g = "string"; + pcpcc = &g + (g ? g-g : 0); + /* HPUX 7.0 cc rejects these. */ + ++pcpcc; + ppc = (char**) pcpcc; + pcpcc = (char const *const *) ppc; + { /* SCO 3.2v4 cc rejects this sort of thing. */ + char tx; + char *t = &tx; + char const *s = 0 ? (char *) 0 : (char const *) 0; + + *t++ = 0; + if (s) return 0; + } + { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ + int x[] = {25, 17}; + const int *foo = &x[0]; + ++foo; + } + { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ + typedef const int *iptr; + iptr p = 0; + ++p; + } + { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying + "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ + struct s { int j; const int *ap[3]; } bx; + struct s *b = &bx; b->j = 5; + } + { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ + const int foo = 10; + if (!foo) return 0; + } + return !cs[0] && !zero.x; +#endif +]])], + [ac_cv_c_const=yes], + [ac_cv_c_const=no])]) +if test $ac_cv_c_const = no; then + AC_DEFINE(const,, + [Define to empty if `const' does not conform to ANSI C.]) +fi +])# AC_C_CONST + + +# AC_C_RESTRICT +# ------------- +# based on acx_restrict.m4, from the GNU Autoconf Macro Archive at: +# http://autoconf-archive.cryp.to/acx_restrict.html +# +# Determine whether the C/C++ compiler supports the "restrict" keyword +# introduced in ANSI C99, or an equivalent. Define "restrict" to the alternate +# spelling, if any; these are more likely to work in both C and C++ compilers of +# the same family, and in the presence of varying compiler options. If only +# plain "restrict" works, do nothing. Here are some variants: +# - GCC supports both __restrict and __restrict__ +# - older DEC Alpha C compilers support only __restrict +# - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C +# Otherwise, define "restrict" to be empty. +AN_IDENTIFIER([restrict], [AC_C_RESTRICT]) +AC_DEFUN([AC_C_RESTRICT], +[AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict, + [ac_cv_c_restrict=no + # The order here caters to the fact that C++ does not require restrict. + for ac_kw in __restrict __restrict__ _Restrict restrict; do + AC_COMPILE_IFELSE([AC_LANG_PROGRAM( + [[typedef int * int_ptr; + int foo (int_ptr $ac_kw ip) { + return ip[0]; + }]], + [[int s[1]; + int * $ac_kw t = s; + t[0] = 0; + return foo(t)]])], + [ac_cv_c_restrict=$ac_kw]) + test "$ac_cv_c_restrict" != no && break + done + ]) + AH_VERBATIM([restrict], +[/* Define to the equivalent of the C99 'restrict' keyword, or to + nothing if this is not supported. Do not define if restrict is + supported directly. */ +#undef restrict +/* Work around a bug in Sun C++: it does not support _Restrict or + __restrict__, even though the corresponding Sun C compiler ends up with + "#define restrict _Restrict" or "#define restrict __restrict__" in the + previous line. Perhaps some future version of Sun C++ will work with + restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ +#if defined __SUNPRO_CC && !defined __RESTRICT +# define _Restrict +# define __restrict__ +#endif]) + case $ac_cv_c_restrict in + restrict) ;; + no) AC_DEFINE([restrict], []) ;; + *) AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;; + esac +])# AC_C_RESTRICT + + +# AC_C_VOLATILE +# ------------- +# Note that, unlike const, #defining volatile to be the empty string can +# actually turn a correct program into an incorrect one, since removing +# uses of volatile actually grants the compiler permission to perform +# optimizations that could break the user's code. So, do not #define +# volatile away unless it is really necessary to allow the user's code +# to compile cleanly. Benign compiler failures should be tolerated. +AC_DEFUN([AC_C_VOLATILE], +[AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile, +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [ +volatile int x; +int * volatile y = (int *) 0; +return !x && !y;])], + [ac_cv_c_volatile=yes], + [ac_cv_c_volatile=no])]) +if test $ac_cv_c_volatile = no; then + AC_DEFINE(volatile,, + [Define to empty if the keyword `volatile' does not work. + Warning: valid code using `volatile' can become incorrect + without. Disable with care.]) +fi +])# AC_C_VOLATILE + + +# AC_C_STRINGIZE +# -------------- +# Checks if `#' can be used to glue strings together at the CPP level. +# Defines HAVE_STRINGIZE if positive. +AC_DEFUN([AC_C_STRINGIZE], +[AC_CACHE_CHECK([for preprocessor stringizing operator], + [ac_cv_c_stringize], +[AC_EGREP_CPP([@%:@teststring], + [@%:@define x(y) #y + +char *s = x(teststring);], + [ac_cv_c_stringize=no], + [ac_cv_c_stringize=yes])]) +if test $ac_cv_c_stringize = yes; then + AC_DEFINE(HAVE_STRINGIZE, 1, + [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.]) +fi +])# AC_C_STRINGIZE + + +# AC_C_PROTOTYPES +# --------------- +# Check if the C compiler supports prototypes, included if it needs +# options. +AC_DEFUN([AC_C_PROTOTYPES], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_MSG_CHECKING([for function prototypes]) +if test "$ac_cv_prog_cc_c89" != no; then + AC_MSG_RESULT([yes]) + AC_DEFINE(PROTOTYPES, 1, + [Define to 1 if the C compiler supports function prototypes.]) + AC_DEFINE(__PROTOTYPES, 1, + [Define like PROTOTYPES; this can be used by system headers.]) +else + AC_MSG_RESULT([no]) +fi +])# AC_C_PROTOTYPES + + +# AC_C_FLEXIBLE_ARRAY_MEMBER +# -------------------------- +# Check whether the C compiler supports flexible array members. +AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER], +[ + AC_CACHE_CHECK([for flexible array members], + ac_cv_c_flexmember, + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[#include <stdlib.h> + #include <stdio.h> + #include <stddef.h> + struct s { int n; double d[]; };]], + [[int m = getchar (); + struct s *p = malloc (offsetof (struct s, d) + + m * sizeof (double)); + p->d[0] = 0.0; + return p->d != (double *) NULL;]])], + [ac_cv_c_flexmember=yes], + [ac_cv_c_flexmember=no])]) + if test $ac_cv_c_flexmember = yes; then + AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], + [Define to nothing if C supports flexible array members, and to + 1 if it does not. That way, with a declaration like `struct s + { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack + can be used with pre-C99 compilers. + When computing the size of such an object, don't use 'sizeof (struct s)' + as it overestimates the size. Use 'offsetof (struct s, d)' instead. + Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with + MSVC and with C++ compilers.]) + else + AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1) + fi +]) + + +# AC_C_VARARRAYS +# -------------- +# Check whether the C compiler supports variable-length arrays. +AC_DEFUN([AC_C_VARARRAYS], +[ + AC_CACHE_CHECK([for variable-length arrays], + ac_cv_c_vararrays, + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([], + [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])], + [ac_cv_c_vararrays=yes], + [ac_cv_c_vararrays=no])]) + if test $ac_cv_c_vararrays = yes; then + AC_DEFINE([HAVE_C_VARARRAYS], 1, + [Define to 1 if C supports variable-length arrays.]) + fi +]) + + +# AC_C_TYPEOF +# ----------- +# Check if the C compiler supports GCC's typeof syntax. +# The test case provokes incompatibilities in the Sun C compilers +# (both Solaris 8 and Solaris 10). +AC_DEFUN([AC_C_TYPEOF], +[ + AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof, + [ac_cv_c_typeof=no + for ac_kw in typeof __typeof__ no; do + test $ac_kw = no && break + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], + [[ + int value; + typedef struct { + char a [1 + + ! (($ac_kw (value)) + (($ac_kw (value)) 0 < ($ac_kw (value)) -1 + ? ($ac_kw (value)) - 1 + : ~ (~ ($ac_kw (value)) 0 + << sizeof ($ac_kw (value)))))]; } + ac__typeof_type_; + return + (! ((void) ((ac__typeof_type_ *) 0), 0)); + ]])], + [ac_cv_c_typeof=$ac_kw]) + test $ac_cv_c_typeof != no && break + done]) + if test $ac_cv_c_typeof != no; then + AC_DEFINE([HAVE_TYPEOF], 1, + [Define to 1 if typeof works with your compiler.]) + if test $ac_cv_c_typeof != typeof; then + AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof], + [Define to __typeof__ if your compiler spells it that way.]) + fi + fi +]) + + +# _AC_LANG_OPENMP +# --------------- +# Expands to some language dependent source code for testing the presence of +# OpenMP. +AC_DEFUN([_AC_LANG_OPENMP], +[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) + +# _AC_LANG_OPENMP(C) +# ------------------ +m4_define([_AC_LANG_OPENMP(C)], +[ +#ifndef _OPENMP + choke me +#endif +#include <omp.h> +int main () { return omp_get_num_threads (); } +]) + +# _AC_LANG_OPENMP(C++) +# -------------------- +m4_copy([_AC_LANG_OPENMP(C)], [_AC_LANG_OPENMP(C++)]) + +# _AC_LANG_OPENMP(Fortran 77) +# --------------------------- +m4_define([_AC_LANG_OPENMP(Fortran 77)], +[ + program main + implicit none +!$ integer tid + tid = 42 + call omp_set_num_threads(2) + end +]) + +# _AC_LANG_OPENMP(Fortran) +# ------------------------ +m4_copy([_AC_LANG_OPENMP(Fortran 77)], [_AC_LANG_OPENMP(Fortran)]) + +# AC_OPENMP +# --------- +# Check which options need to be passed to the C compiler to support OpenMP. +# Set the OPENMP_CFLAGS / OPENMP_CXXFLAGS / OPENMP_FFLAGS variable to these +# options. +# The options are necessary at compile time (so the #pragmas are understood) +# and at link time (so the appropriate library is linked with). +# This macro takes care to not produce redundant options if $CC $CFLAGS already +# supports OpenMP. It also is careful to not pass options to compilers that +# misinterpret them; for example, most compilers accept "-openmp" and create +# an output file called 'penmp' rather than activating OpenMP support. +AC_DEFUN([AC_OPENMP], +[ + OPENMP_[]_AC_LANG_PREFIX[]FLAGS= + AC_ARG_ENABLE([openmp], + [AS_HELP_STRING([--disable-openmp], [do not use OpenMP])]) + if test "$enable_openmp" != no; then + AC_CACHE_CHECK([for $[]_AC_CC[] option to support OpenMP], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp], + [AC_LINK_IFELSE([_AC_LANG_OPENMP], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='none needed'], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='unsupported' + dnl Try these flags: + dnl GCC >= 4.2 -fopenmp + dnl SunPRO C -xopenmp + dnl Intel C -openmp + dnl SGI C, PGI C -mp + dnl Tru64 Compaq C -omp + dnl IBM C (AIX, Linux) -qsmp=omp + dnl Cray CCE -homp + dnl NEC SX -Popenmp + dnl Lahey Fortran (Linux) --openmp + dnl If in this loop a compiler is passed an option that it doesn't + dnl understand or that it misinterprets, the AC_LINK_IFELSE test + dnl will fail (since we know that it failed without the option), + dnl therefore the loop will continue searching for an option, and + dnl no output file called 'penmp' or 'mp' is created. + for ac_option in -fopenmp -xopenmp -openmp -mp -omp -qsmp=omp -homp \ + -Popenmp --openmp; do + ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS + _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $ac_option" + AC_LINK_IFELSE([_AC_LANG_OPENMP], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp=$ac_option]) + _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS + if test "$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp" != unsupported; then + break + fi + done])]) + case $ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp in #( + "none needed" | unsupported) + ;; #( + *) + OPENMP_[]_AC_LANG_PREFIX[]FLAGS=$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp ;; + esac + fi + AC_SUBST([OPENMP_]_AC_LANG_PREFIX[FLAGS]) +]) diff --git a/lib/autoconf/erlang.m4 b/lib/autoconf/erlang.m4 new file mode 100644 index 0000000..953ffb0 --- /dev/null +++ b/lib/autoconf/erlang.m4 @@ -0,0 +1,320 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Erlang/OTP language support. +# Copyright (C) 2006, 2008-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by Romain Lenglet. + + +# Table of Contents: +# +# 0. Utility macros +# +# 1. Language selection +# and routines to produce programs in a given language. +# +# 2. Producing programs in a given language. +# +# 3. Looking for a compiler +# And possibly the associated preprocessor. + + + +## ------------------- ## +## 0. Utility macros. ## +## ------------------- ## + + +# AC_ERLANG_PATH_ERLC([VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------- +AC_DEFUN([AC_ERLANG_PATH_ERLC], +[AC_ARG_VAR([ERLC], [Erlang/OTP compiler command [autodetected]])dnl +if test -n "$ERLC"; then + AC_MSG_CHECKING([for erlc]) + AC_MSG_RESULT([$ERLC]) +else + AC_PATH_TOOL(ERLC, erlc, [$1], [$2]) +fi +AC_ARG_VAR([ERLCFLAGS], [Erlang/OTP compiler flags [none]])dnl +]) + + +# AC_ERLANG_NEED_ERLC([PATH]) +# --------------------------- +AC_DEFUN([AC_ERLANG_NEED_ERLC], +[AC_ERLANG_PATH_ERLC([not found], [$1]) +if test "$ERLC" = "not found"; then + AC_MSG_ERROR([Erlang/OTP compiler (erlc) not found but required]) +fi +]) + + +# AC_ERLANG_PATH_ERL([VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------ +AC_DEFUN([AC_ERLANG_PATH_ERL], +[AC_ARG_VAR([ERL], [Erlang/OTP interpreter command [autodetected]])dnl +if test -n "$ERL"; then + AC_MSG_CHECKING([for erl]) + AC_MSG_RESULT([$ERL]) +else + AC_PATH_TOOL(ERL, erl, [$1], [$2])[]dnl +fi +]) + + +# AC_ERLANG_NEED_ERL([PATH]) +# -------------------------- +AC_DEFUN([AC_ERLANG_NEED_ERL], +[AC_ERLANG_PATH_ERL([not found], [$1]) +if test "$ERL" = "not found"; then + AC_MSG_ERROR([Erlang/OTP interpreter (erl) not found but required]) +fi +]) + + + +## ----------------------- ## +## 1. Language selection. ## +## ----------------------- ## + + +# AC_LANG(Erlang) +# --------------- +AC_LANG_DEFINE([Erlang], [erl], [ERL], [ERLC], [], +[ac_ext=erl +ac_compile='$ERLC $ERLCFLAGS -b beam conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$ERLC $ERLCFLAGS -b beam conftest.$ac_ext >&AS_MESSAGE_LOG_FD && echo "[#]!/bin/sh" > conftest$ac_exeext && AS_ECHO(["\"$ERL\" -run conftest start -run init stop -noshell"]) >> conftest$ac_exeext && chmod +x conftest$ac_exeext' +]) + + + +# AC_LANG_ERLANG +# -------------- +AU_DEFUN([AC_LANG_ERLANG], [AC_LANG(Erlang)]) + + + +## ----------------------- ## +## 2. Producing programs. ## +## ----------------------- ## + + +# AC_LANG_PROGRAM(Erlang)([PROLOGUE], [BODY]) +# ------------------------------------------- +m4_define([AC_LANG_PROGRAM(Erlang)], +[[-module(conftest). +-export([start/0]).]] +[$1 +start() -> +$2 +. +]) + + +# _AC_LANG_NULL_PROGRAM(Erlang) +# ----------------------------- +# Produce source that does nothing. +m4_define([_AC_LANG_NULL_PROGRAM(Erlang)], +[AC_LANG_PROGRAM([], [halt(0)])]) + + +# _AC_LANG_IO_PROGRAM(Erlang) +# --------------------------- +# Produce source that performs I/O. +m4_define([_AC_LANG_IO_PROGRAM(Erlang)], +[AC_LANG_PROGRAM([], [dnl + ReturnValue = case file:write_file("conftest.out", "") of + {error, _} -> 1; + ok -> 0 + end, + halt(ReturnValue)])]) + + +## -------------------------------------------- ## +## 3. Looking for Compilers and Preprocessors. ## +## -------------------------------------------- ## + + +# AC_LANG_PREPROC(Erlang) +# ----------------------- +# Find the Erlang preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Erlang)], +[m4_warn([syntax], + [$0: No preprocessor defined for ]_AC_LANG)]) + +# AC_LANG_COMPILER(Erlang) +# ------------------------ +# Find the Erlang compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(Erlang)], +[AC_REQUIRE([AC_ERLANG_PATH_ERLC])]) + + +# AC_ERLANG_CHECK_LIB(LIBRARY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ---------------------------------------------------------------------- +# Macro for checking if an Erlang library is installed, and to +# determine its version. +AC_DEFUN([AC_ERLANG_CHECK_LIB], +[AC_REQUIRE([AC_ERLANG_PATH_ERLC])[]dnl +AC_REQUIRE([AC_ERLANG_PATH_ERL])[]dnl +AC_CACHE_CHECK([for Erlang/OTP '$1' library subdirectory], + [ac_cv_erlang_lib_dir_$1], + [AC_LANG_PUSH(Erlang)[]dnl + AC_RUN_IFELSE( + [AC_LANG_PROGRAM([], [dnl + ReturnValue = case code:lib_dir("[$1]") of + {error, bad_name} -> + file:write_file("conftest.out", "not found\n"), + 1; + LibDir -> + file:write_file("conftest.out", LibDir), + 0 + end, + halt(ReturnValue)])], + [ac_cv_erlang_lib_dir_$1=`cat conftest.out` + rm -f conftest.out], + [if test ! -f conftest.out; then + AC_MSG_FAILURE([test Erlang program execution failed]) + else + ac_cv_erlang_lib_dir_$1="not found" + rm -f conftest.out + fi]) + AC_LANG_POP(Erlang)[]dnl + ]) +AC_CACHE_CHECK([for Erlang/OTP '$1' library version], + [ac_cv_erlang_lib_ver_$1], + [AS_IF([test "$ac_cv_erlang_lib_dir_$1" = "not found"], + [ac_cv_erlang_lib_ver_$1="not found"], + [ac_cv_erlang_lib_ver_$1=`AS_ECHO(["$ac_cv_erlang_lib_dir_$1"]) | sed -n -e 's,^.*-\([[^/-]]*\)$,\1,p'`])[]dnl + ]) +AC_SUBST([ERLANG_LIB_DIR_$1], [$ac_cv_erlang_lib_dir_$1]) +AC_SUBST([ERLANG_LIB_VER_$1], [$ac_cv_erlang_lib_ver_$1]) +AS_IF([test "$ac_cv_erlang_lib_dir_$1" = "not found"], [$3], [$2]) +])# AC_ERLANG_CHECK_LIB + + +# AC_ERLANG_SUBST_ROOT_DIR +# ------------------------ +# Determines the Erlang/OTP root directory. +AC_DEFUN([AC_ERLANG_SUBST_ROOT_DIR], +[AC_REQUIRE([AC_ERLANG_NEED_ERLC])[]dnl +AC_REQUIRE([AC_ERLANG_NEED_ERL])[]dnl +AC_CACHE_CHECK([for Erlang/OTP root directory], + [ac_cv_erlang_root_dir], + [AC_LANG_PUSH(Erlang)[]dnl + AC_RUN_IFELSE( + [AC_LANG_PROGRAM([], [dnl + RootDir = code:root_dir(), + file:write_file("conftest.out", RootDir), + ReturnValue = 0, + halt(ReturnValue)])], + [ac_cv_erlang_root_dir=`cat conftest.out` + rm -f conftest.out], + [rm -f conftest.out + AC_MSG_FAILURE([test Erlang program execution failed])]) + AC_LANG_POP(Erlang)[]dnl + ]) +AC_SUBST([ERLANG_ROOT_DIR], [$ac_cv_erlang_root_dir]) +])# AC_ERLANG_SUBST_ROOT_DIR + + +# AC_ERLANG_SUBST_LIB_DIR +# ----------------------- +AC_DEFUN([AC_ERLANG_SUBST_LIB_DIR], +[AC_REQUIRE([AC_ERLANG_NEED_ERLC])[]dnl +AC_REQUIRE([AC_ERLANG_NEED_ERL])[]dnl +AC_CACHE_CHECK([for Erlang/OTP library base directory], + [ac_cv_erlang_lib_dir], + [AC_LANG_PUSH(Erlang)[]dnl + AC_RUN_IFELSE( + [AC_LANG_PROGRAM([], [dnl + LibDir = code:lib_dir(), + file:write_file("conftest.out", LibDir), + ReturnValue = 0, + halt(ReturnValue)])], + [ac_cv_erlang_lib_dir=`cat conftest.out` + rm -f conftest.out], + [rm -f conftest.out + AC_MSG_FAILURE([test Erlang program execution failed])]) + AC_LANG_POP(Erlang)[]dnl + ]) +AC_SUBST([ERLANG_LIB_DIR], [$ac_cv_erlang_lib_dir]) +])# AC_ERLANG_SUBST_LIB_DIR + + +# AC_ERLANG_SUBST_INSTALL_LIB_DIR +# ------------------------------- +# Directories for installing Erlang/OTP packages are separated from the +# directories determined by running the Erlang/OTP installation that is used +# for building. +AC_DEFUN([AC_ERLANG_SUBST_INSTALL_LIB_DIR], +[AC_MSG_CHECKING([for Erlang/OTP library installation base directory]) +AC_ARG_VAR([ERLANG_INSTALL_LIB_DIR], + [Erlang/OTP library installation base directory [LIBDIR/erlang/lib]]) +if test -n "$ERLANG_INSTALL_LIB_DIR"; then + AC_MSG_RESULT([$ERLANG_INSTALL_LIB_DIR]) +else + AC_SUBST([ERLANG_INSTALL_LIB_DIR], ['${libdir}/erlang/lib']) + AC_MSG_RESULT([$libdir/erlang/lib]) +fi +])# AC_ERLANG_SUBST_INSTALL_LIB_DIR + + +# AC_ERLANG_SUBST_INSTALL_LIB_SUBDIR(PACKAGE_TARNAME, PACKAGE_VERSION) +# -------------------------------------------------------------------- +AC_DEFUN([AC_ERLANG_SUBST_INSTALL_LIB_SUBDIR], +[AC_REQUIRE([AC_ERLANG_SUBST_INSTALL_LIB_DIR])[]dnl +AC_MSG_CHECKING([for Erlang/OTP '$1' library installation subdirectory]) +AC_ARG_VAR([ERLANG_INSTALL_LIB_DIR_$1], + [Erlang/OTP '$1' library installation subdirectory + [ERLANG_INSTALL_LIB_DIR/$1-$2]]) +if test -n "$ERLANG_INSTALL_LIB_DIR_$1"; then + AC_MSG_RESULT([$ERLANG_INSTALL_LIB_DIR_$1]) +else + AC_SUBST([ERLANG_INSTALL_LIB_DIR_$1], ['${ERLANG_INSTALL_LIB_DIR}/$1-$2']) + AC_MSG_RESULT([$ERLANG_INSTALL_LIB_DIR/$1-$2]) +fi +])# AC_ERLANG_SUBST_INSTALL_LIB_SUBDIR + + +# AC_ERLANG_SUBST_ERTS_VER +# ------------------------ +# Determines the Erlang runtime system version. +AC_DEFUN([AC_ERLANG_SUBST_ERTS_VER], +[AC_REQUIRE([AC_ERLANG_NEED_ERLC])[]dnl +AC_REQUIRE([AC_ERLANG_NEED_ERL])[]dnl +AC_CACHE_CHECK([for Erlang/OTP ERTS version], + [ac_cv_erlang_erts_ver], + [AC_LANG_PUSH([Erlang])[]dnl + AC_RUN_IFELSE( + [AC_LANG_PROGRAM([], [dnl + Version = erlang:system_info(version), + file:write_file("conftest.out", Version), + ReturnValue = 0, + halt(ReturnValue)])], + [ac_cv_erlang_erts_ver=`cat conftest.out` + rm -f conftest.out], + [rm -f conftest.out + AC_MSG_FAILURE([test Erlang program execution failed])]) + AC_LANG_POP([Erlang])[]dnl + ]) +AC_SUBST([ERLANG_ERTS_VER], [$ac_cv_erlang_erts_ver]) +])# AC_ERLANG_SUBST_ERTS_VER diff --git a/lib/autoconf/fortran.m4 b/lib/autoconf/fortran.m4 new file mode 100644 index 0000000..3803595 --- /dev/null +++ b/lib/autoconf/fortran.m4 @@ -0,0 +1,1862 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Fortran languages support. +# Copyright (C) 2001, 2003-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# Table of Contents: +# +# Preamble +# +# 0. Utility macros +# +# 1. Language selection +# and routines to produce programs in a given language. +# +# 2. Producing programs in a given language. +# +# 3. Looking for a compiler +# And possibly the associated preprocessor. +# +# 4. Compilers' characteristics. + + + +## ---------- ## +## Preamble. ## +## ---------- ## + +# Fortran vs. Fortran 77: +# This file contains macros for both "Fortran 77" and "Fortran", where +# the former is the "classic" autoconf Fortran interface and is intended +# for legacy F77 codes, while the latter is intended to support newer Fortran +# dialects. Fortran 77 uses environment variables F77, FFLAGS, and FLIBS, +# while Fortran uses FC, FCFLAGS, and FCLIBS. For each user-callable AC_* +# macro, there is generally both an F77 and an FC version, where both versions +# share the same _AC_*_FC_* backend. This backend macro requires that +# the appropriate language be AC_LANG_PUSH'ed, and uses _AC_LANG_ABBREV and +# _AC_LANG_PREFIX in order to name cache and environment variables, etc. + + + +## ------------------- ## +## 0. Utility macros. ## +## ------------------- ## + + +# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# --------------------------------------------------------------------------- +# +# Processing the elements of a list is tedious in shell programming, +# as lists tend to be implemented as space delimited strings. +# +# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND +# if ELEMENT is a member of LIST, otherwise it executes +# ACTION-IF-NOT-FOUND. +AC_DEFUN([_AC_LIST_MEMBER_IF], +dnl Do some sanity checking of the arguments. +[m4_if([$1], , [m4_fatal([$0: missing argument 1])], + [$2], , [m4_fatal([$0: missing argument 2])])]dnl +[ ac_exists=false + for ac_i in $2; do + if test x"$1" = x"$ac_i"; then + ac_exists=true + break + fi + done + + AS_IF([test x"$ac_exists" = xtrue], [$3], [$4])[]dnl +])# _AC_LIST_MEMBER_IF + + +# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE) +# ------------------------------------------------- +# +# Specifying options to the compiler (whether it be the C, C++ or +# Fortran 77 compiler) that are meant for the linker is compiler +# dependent. This macro lets you give options to the compiler that +# are meant for the linker in a portable, compiler-independent way. +# +# This macro take two arguments, a list of linker options that the +# compiler should pass to the linker (LINKER-OPTIONS) and the name of +# a shell variable (SHELL-VARIABLE). The list of linker options are +# appended to the shell variable in a compiler-dependent way. +# +# For example, if the selected language is C, then this: +# +# _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS) +# +# will expand into this if the selected C compiler is gcc: +# +# foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo" +# +# otherwise, it will expand into this: +# +# foo_LDFLAGS"-R /usr/local/lib/foo" +# +# You are encouraged to add support for compilers that this macro +# doesn't currently support. +# FIXME: Get rid of this macro. +AC_DEFUN([_AC_LINKER_OPTION], +[if test "$ac_compiler_gnu" = yes; then + for ac_link_opt in $1; do + $2="[$]$2 -Xlinker $ac_link_opt" + done +else + $2="[$]$2 $1" +fi[]dnl +])# _AC_LINKER_OPTION + + + +## ------------------------ ## +## 1a. Language selection. ## +## ------------------------ ## + + +# AC_LANG(Fortran 77) +# ------------------- +AC_LANG_DEFINE([Fortran 77], [f77], [F], [F77], [], +[ac_ext=f +ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_f77_compiler_gnu +]) + + +# AC_LANG_FORTRAN77 +# ----------------- +AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)]) + + +# _AC_FORTRAN_ASSERT +# ------------------ +# Current language must be Fortran or Fortran 77. +m4_defun([_AC_FORTRAN_ASSERT], +[m4_if(_AC_LANG, [Fortran], [], + [m4_if(_AC_LANG, [Fortran 77], [], + [m4_fatal([$0: current language is not Fortran: ] _AC_LANG)])])]) + + +# _AC_FC +# ------ +# Return F77 or FC, depending upon the language. +AC_DEFUN([_AC_FC], +[_AC_FORTRAN_ASSERT()dnl +AC_LANG_CASE([Fortran 77], [F77], + [Fortran], [FC])]) + + + +## ----------------------- ## +## 2. Producing programs. ## +## ----------------------- ## + + +# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY]) +# ----------------------------------------------- +# Yes, we discard the PROLOGUE. +m4_define([AC_LANG_PROGRAM(Fortran 77)], +[m4_ifval([$1], + [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl + program main +$2 + end]) + + +# _AC_LANG_IO_PROGRAM(Fortran 77) +# ------------------------------- +# Produce source that performs I/O. +m4_define([_AC_LANG_IO_PROGRAM(Fortran 77)], +[AC_LANG_PROGRAM([], +[dnl + open(unit=9,file='conftest.out') + close(unit=9) +])]) + + +# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION) +# -------------------------------------------- +# FIXME: This is a guess, help! +m4_define([AC_LANG_CALL(Fortran 77)], +[AC_LANG_PROGRAM([$1], +[ call $2])]) + + +# AC_LANG_FUNC_LINK_TRY(Fortran 77)(FUNCTION) +# ------------------------------------------- +m4_define([AC_LANG_FUNC_LINK_TRY(Fortran 77)], +[AC_LANG_PROGRAM([], +[ call $1])]) + +## ------------------------ ## +## 1b. Language selection. ## +## ------------------------ ## + + +# AC_LANG(Fortran) +# ---------------- +AC_LANG_DEFINE([Fortran], [fc], [FC], [FC], [Fortran 77], +[ac_ext=${ac_fc_srcext-f} +ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=$ac_cv_fc_compiler_gnu +]) + + +## -------------------------------------------- ## +## 3. Looking for Compilers and Preprocessors. ## +## -------------------------------------------- ## + + +# AC_LANG_PREPROC(Fortran 77) +# --------------------------- +# Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Fortran 77)], +[m4_warn([syntax], + [$0: No preprocessor defined for ]_AC_LANG)]) + +# AC_LANG_PREPROC(Fortran) +# ------------------------ +# Find the Fortran preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. +AC_DEFUN([AC_LANG_PREPROC(Fortran)], +[m4_warn([syntax], + [$0: No preprocessor defined for ]_AC_LANG)]) + + +# AC_LANG_COMPILER(Fortran 77) +# ---------------------------- +# Find the Fortran 77 compiler. Must be AC_DEFUN'd to be +# AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(Fortran 77)], +[AC_REQUIRE([AC_PROG_F77])]) + +# AC_LANG_COMPILER(Fortran) +# ------------------------- +# Find the Fortran compiler. Must be AC_DEFUN'd to be +# AC_REQUIRE'able. +AC_DEFUN([AC_LANG_COMPILER(Fortran)], +[AC_REQUIRE([AC_PROG_FC])]) + + +# ac_cv_prog_g77 +# -------------- +# We used to name the cache variable this way. +AU_DEFUN([ac_cv_prog_g77], +[ac_cv_f77_compiler_gnu]) + + +# _AC_FC_DIALECT_YEAR([DIALECT]) +# ------------------------------ +# Given a Fortran DIALECT, which is Fortran [YY]YY or simply [YY]YY, +# convert to a 4-digit year. The dialect must be one of Fortran 77, +# 90, 95, or 2000, currently. If DIALECT is simply Fortran or the +# empty string, returns the empty string. +AC_DEFUN([_AC_FC_DIALECT_YEAR], +[m4_case(m4_bpatsubsts(m4_tolower([$1]), [fortran],[], [ *],[]), + [77],[1977], [1977],[1977], + [90],[1990], [1990],[1990], + [95],[1995], [1995],[1995], + [2000],[2000], + [],[], + [m4_fatal([unknown Fortran dialect])])]) + + +# _AC_PROG_FC([DIALECT], [COMPILERS...]) +# -------------------------------------- +# DIALECT is a Fortran dialect, given by Fortran [YY]YY or simply [YY]YY, +# and must be one of those supported by _AC_FC_DIALECT_YEAR +# +# If DIALECT is supplied, then we search for compilers of that dialect +# first, and then later dialects. Otherwise, we search for compilers +# of the newest dialect first, and then earlier dialects in increasing age. +# This search order is necessarily imperfect because the dialect cannot +# always be inferred from the compiler name. +# +# Known compilers: +# f77/f90/f95: generic compiler names +# g77: GNU Fortran 77 compiler +# gfortran: GNU Fortran 95+ compiler (released in gcc 4.0) +# g95: original gcc-based f95 compiler (gfortran is a fork) +# ftn: native Fortran 95 compiler on Cray X1 +# cf77: native F77 compiler under older Crays (prefer over fort77) +# fort77: native F77 compiler under HP-UX (and some older Crays) +# frt: Fujitsu F77 compiler +# pgf77/pgf90/pghpf/pgf95/pgfortran: Portland Group F77/F90/F95 compilers +# xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers +# Prefer xlf9x to the generic names because they do not reject files +# with extension `.f'. +# lf95: Lahey-Fujitsu F95 compiler +# fl32: Microsoft Fortran 77 "PowerStation" compiler +# af77: Apogee F77 compiler for Intergraph hardware running CLIX +# epcf90: "Edinburgh Portable Compiler" F90 +# fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha +# ifort, previously ifc: Intel Fortran 95 compiler for Linux/x86 +# efc: Intel Fortran 95 compiler for IA64 +# nagfor: NAGWare Fortran 77/90/95 compiler +m4_define([_AC_F95_FC], [gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor]) +m4_define([_AC_F90_FC], [xlf90 f90 pgf90 pghpf epcf90]) +m4_define([_AC_F77_FC], [g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77]) +AC_DEFUN([_AC_PROG_FC], +[_AC_FORTRAN_ASSERT()dnl +AC_CHECK_TOOLS([]_AC_FC[], + m4_default([$2], + m4_case(_AC_FC_DIALECT_YEAR([$1]), + [1995], [_AC_F95_FC], + [1990], [_AC_F90_FC _AC_F95_FC], + [1977], [_AC_F77_FC _AC_F90_FC _AC_F95_FC], + [_AC_F95_FC _AC_F90_FC _AC_F77_FC]))) + +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done +rm -f a.out + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +# If we don't use `.F' as extension, the preprocessor is not run on the +# input file. (Note that this only needs to work for GNU compilers.) +ac_save_ext=$ac_ext +ac_ext=F +_AC_LANG_COMPILER_GNU +ac_ext=$ac_save_ext +_AC_PROG_FC_G +])# _AC_PROG_FC + + +# AC_PROG_F77([COMPILERS...]) +# --------------------------- +# COMPILERS is a space separated list of Fortran 77 compilers to search +# for. See also _AC_PROG_FC. +AC_DEFUN([AC_PROG_F77], +[AC_LANG_PUSH(Fortran 77)dnl +AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl +AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_PROG_FC([Fortran 77], [$1]) +if test $ac_compiler_gnu = yes; then + G77=yes +else + G77= +fi +AC_LANG_POP(Fortran 77)dnl +])# AC_PROG_F77 + + +# AC_PROG_FC([COMPILERS...], [DIALECT]) +# ------------------------------------- +# COMPILERS is a space separated list of Fortran 77 compilers to search +# for, and [DIALECT] is an optional dialect. See also _AC_PROG_FC. +AC_DEFUN([AC_PROG_FC], +[AC_LANG_PUSH(Fortran)dnl +AC_ARG_VAR([FC], [Fortran compiler command])dnl +AC_ARG_VAR([FCFLAGS], [Fortran compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_PROG_FC([$2], [$1]) +if test $ac_compiler_gnu = yes; then + GFC=yes +else + GFC= +fi +AC_LANG_POP(Fortran)dnl +])# AC_PROG_FC + + +# _AC_PROG_FC_G +# ------------- +# Check whether -g works, even if F[C]FLAGS is set, in case the package +# plays around with F[C]FLAGS (such as to build both debugging and normal +# versions of a library), tasteless as that idea is. +m4_define([_AC_PROG_FC_G], +[_AC_FORTRAN_ASSERT()dnl +ac_test_[]_AC_LANG_PREFIX[]FLAGS=${[]_AC_LANG_PREFIX[]FLAGS+set} +ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS +_AC_LANG_PREFIX[]FLAGS= +AC_CACHE_CHECK(whether $[]_AC_FC[] accepts -g, ac_cv_prog_[]_AC_LANG_ABBREV[]_g, +[_AC_LANG_PREFIX[]FLAGS=-g +_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], +[ac_cv_prog_[]_AC_LANG_ABBREV[]_g=yes], +[ac_cv_prog_[]_AC_LANG_ABBREV[]_g=no]) +]) +if test "$ac_test_[]_AC_LANG_PREFIX[]FLAGS" = set; then + _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS +elif test $ac_cv_prog_[]_AC_LANG_ABBREV[]_g = yes; then + if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then + _AC_LANG_PREFIX[]FLAGS="-g -O2" + else + _AC_LANG_PREFIX[]FLAGS="-g" + fi +else + if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then + _AC_LANG_PREFIX[]FLAGS="-O2" + else + _AC_LANG_PREFIX[]FLAGS= + fi +fi[]dnl +])# _AC_PROG_FC_G + + +# _AC_PROG_FC_C_O +# --------------- +# Test if the Fortran compiler accepts the options `-c' and `-o' +# simultaneously, and define `[F77/FC]_NO_MINUS_C_MINUS_O' if it does not. +# +# The usefulness of this macro is questionable, as I can't really see +# why anyone would use it. The only reason I include it is for +# completeness, since a similar test exists for the C compiler. +# +# FIXME: it seems like we could merge the C/C++/Fortran versions of this. +AC_DEFUN([_AC_PROG_FC_C_O], +[_AC_FORTRAN_ASSERT()dnl +AC_CACHE_CHECK([whether $[]_AC_FC[] understands -c and -o together], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o], +[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) +# We test twice because some compilers refuse to overwrite an existing +# `.o' file with `-o', although they will create one. +ac_try='$[]_AC_FC[] $[]_AC_LANG_PREFIX[]FLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' +rm -f conftest2.* +if _AC_DO_VAR(ac_try) && + test -f conftest2.$ac_objext && + _AC_DO_VAR(ac_try); then + ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=yes +else + ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=no +fi +rm -f conftest*]) +if test $ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o = no; then + AC_DEFINE([]_AC_FC[]_NO_MINUS_C_MINUS_O, 1, + [Define to 1 if your Fortran compiler doesn't accept + -c and -o together.]) +fi +])# _AC_PROG_FC_C_O + + +# AC_PROG_F77_C_O +# --------------- +AC_DEFUN([AC_PROG_F77_C_O], +[AC_REQUIRE([AC_PROG_F77])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_PROG_FC_C_O +AC_LANG_POP(Fortran 77)dnl +])# AC_PROG_F77_C_O + + +# AC_PROG_FC_C_O +# -------------- +AC_DEFUN([AC_PROG_FC_C_O], +[AC_REQUIRE([AC_PROG_FC])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_PROG_FC_C_O +AC_LANG_POP(Fortran)dnl +])# AC_PROG_FC_C_O + + + +## ------------------------------- ## +## 4. Compilers' characteristics. ## +## ------------------------------- ## + + +# _AC_PROG_FC_V_OUTPUT([FLAG = $ac_cv_prog_{f77/fc}_v]) +# ----------------------------------------------------- +# Link a trivial Fortran program, compiling with a verbose output FLAG +# (whose default value, $ac_cv_prog_{f77/fc}_v, is computed by +# _AC_PROG_FC_V), and return the output in $ac_{f77/fc}_v_output. This +# output is processed in the way expected by _AC_FC_LIBRARY_LDFLAGS, +# so that any link flags that are echoed by the compiler appear as +# space-separated items. +AC_DEFUN([_AC_PROG_FC_V_OUTPUT], +[_AC_FORTRAN_ASSERT()dnl +AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) + +# Compile and link our simple test program by passing a flag (argument +# 1 to this macro) to the Fortran compiler in order to get +# "verbose" output that we can then parse for the Fortran linker +# flags. +ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS +_AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS m4_default([$1], [$ac_cv_prog_[]_AC_LANG_ABBREV[]_v])" +eval "set x $ac_link" +shift +_AS_ECHO_LOG([$[*]]) +# gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH, +# LIBRARY_PATH; skip all such settings. +ac_[]_AC_LANG_ABBREV[]_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | + sed '/^Driving:/d; /^Configured with:/d; + '"/^[[_$as_cr_Letters]][[_$as_cr_alnum]]*=/d"` +AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) >&AS_MESSAGE_LOG_FD +_AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS + +rm -rf conftest* + +# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where +# /foo, /bar, and /baz are search directories for the Fortran linker. +# Here, we change these into -L/foo -L/bar -L/baz (and put it first): +ac_[]_AC_LANG_ABBREV[]_v_output="`echo $ac_[]_AC_LANG_ABBREV[]_v_output | + grep 'LPATH is:' | + sed 's|.*LPATH is\(: *[[^ ]]*\).*|\1|;s|: */| -L/|g'` $ac_[]_AC_LANG_ABBREV[]_v_output" + +# FIXME: we keep getting bitten by quoted arguments; a more general fix +# that detects unbalanced quotes in FLIBS should be implemented +# and (ugh) tested at some point. +case $ac_[]_AC_LANG_ABBREV[]_v_output in + # With xlf replace commas with spaces, + # and remove "-link" and closing parenthesis. + *xlfentry*) + ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | + sed ' + s/,/ /g + s/ -link / /g + s/) *$// + ' + ` ;; + + # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted + # $LIBS confuse us, and the libraries appear later in the output anyway). + *mGLOB_options_string*) + ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed 's/"-mGLOB[[^"]]*"/ /g'` ;; + + # Portland Group compiler has singly- or doubly-quoted -cmdline argument + # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4. + # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2". + *-cmdline\ * | *-ignore\ * | *-def\ *) + ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed "\ + s/-cmdline *'[[^']]*'/ /g; s/-cmdline *\"[[^\"]]*\"/ /g + s/-ignore *'[[^']]*'/ /g; s/-ignore *\"[[^\"]]*\"/ /g + s/-def *'[[^']]*'/ /g; s/-def *\"[[^\"]]*\"/ /g"` ;; + + # If we are using fort77 (the f2c wrapper) then filter output and delete quotes. + *fort77*f2c*gcc*) + ac_[]_AC_LANG_ABBREV[]_v_output=`echo "$ac_[]_AC_LANG_ABBREV[]_v_output" | sed -n ' + /:[[ ]]\+Running[[ ]]\{1,\}"gcc"/{ + /"-c"/d + /[[.]]c"*/d + s/^.*"gcc"/"gcc"/ + s/"//gp + }'` ;; + + # If we are using Cray Fortran then delete quotes. + *cft90*) + ac_[]_AC_LANG_ABBREV[]_v_output=`echo $ac_[]_AC_LANG_ABBREV[]_v_output | sed 's/"//g'` ;; +esac + +])# _AC_PROG_FC_V_OUTPUT + + +# _AC_PROG_FC_V +# ------------- +# +# Determine the flag that causes the Fortran compiler to print +# information of library and object files (normally -v) +# Needed for _AC_FC_LIBRARY_FLAGS +# Some compilers don't accept -v (Lahey: (-)-verbose, xlf: -V, Fujitsu: -###) +AC_DEFUN([_AC_PROG_FC_V], +[_AC_FORTRAN_ASSERT()dnl +AC_CACHE_CHECK([how to get verbose linking output from $[]_AC_FC[]], + [ac_cv_prog_[]_AC_LANG_ABBREV[]_v], +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], +[ac_cv_prog_[]_AC_LANG_ABBREV[]_v= +# Try some options frequently used verbose output +for ac_verb in -v -verbose --verbose -V -\#\#\#; do + _AC_PROG_FC_V_OUTPUT($ac_verb) + # look for -l* and *.a constructs in the output + for ac_arg in $ac_[]_AC_LANG_ABBREV[]_v_output; do + case $ac_arg in + [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*) + ac_cv_prog_[]_AC_LANG_ABBREV[]_v=$ac_verb + break 2 ;; + esac + done +done +if test -z "$ac_cv_prog_[]_AC_LANG_ABBREV[]_v"; then + AC_MSG_WARN([cannot determine how to obtain linking information from $[]_AC_FC[]]) +fi], + [AC_MSG_WARN([compilation failed])]) +])])# _AC_PROG_FC_V + + +# _AC_FC_LIBRARY_LDFLAGS +# ---------------------- +# +# Determine the linker flags (e.g. "-L" and "-l") for the Fortran +# intrinsic and runtime libraries that are required to successfully +# link a Fortran program or shared library. The output variable +# FLIBS/FCLIBS is set to these flags. +# +# This macro is intended to be used in those situations when it is +# necessary to mix, e.g. C++ and Fortran, source code into a single +# program or shared library. +# +# For example, if object files from a C++ and Fortran compiler must +# be linked together, then the C++ compiler/linker must be used for +# linking (since special C++-ish things need to happen at link time +# like calling global constructors, instantiating templates, enabling +# exception support, etc.). +# +# However, the Fortran intrinsic and runtime libraries must be +# linked in as well, but the C++ compiler/linker doesn't know how to +# add these Fortran libraries. Hence, the macro +# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran +# libraries. +# +# This macro was packaged in its current form by Matthew D. Langston. +# However, nearly all of this macro came from the "OCTAVE_FLIBS" macro +# in "octave-2.0.13/aclocal.m4", and full credit should go to John +# W. Eaton for writing this extremely useful macro. Thank you John. +AC_DEFUN([_AC_FC_LIBRARY_LDFLAGS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +_AC_FORTRAN_ASSERT()dnl +_AC_PROG_FC_V +AC_CACHE_CHECK([for _AC_LANG libraries of $[]_AC_FC[]], ac_cv_[]_AC_LANG_ABBREV[]_libs, +[if test "x$[]_AC_LANG_PREFIX[]LIBS" != "x"; then + ac_cv_[]_AC_LANG_ABBREV[]_libs="$[]_AC_LANG_PREFIX[]LIBS" # Let the user override the test. +else + +_AC_PROG_FC_V_OUTPUT + +ac_cv_[]_AC_LANG_ABBREV[]_libs= + +# Save positional arguments (if any) +ac_save_positional="$[@]" + +set X $ac_[]_AC_LANG_ABBREV[]_v_output +while test $[@%:@] != 1; do + shift + ac_arg=$[1] + case $ac_arg in + [[\\/]]*.a | ?:[[\\/]]*.a) + _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , + ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg") + ;; + -bI:*) + _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , + [_AC_LINKER_OPTION([$ac_arg], ac_cv_[]_AC_LANG_ABBREV[]_libs)]) + ;; + # Ignore these flags. + -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -little \ + |-LANG:=* | -LIST:* | -LNO:* | -link) + ;; + -lkernel32) + case $host_os in + *cygwin*) ;; + *) ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg" + ;; + esac + ;; + -[[LRuYz]]) + # These flags, when seen by themselves, take an argument. + # We remove the space between option and argument and re-iterate + # unless we find an empty arg or a new option (starting with -) + case $[2] in + "" | -*);; + *) + ac_arg="$ac_arg$[2]" + shift; shift + set X $ac_arg "$[@]" + ;; + esac + ;; + -YP,*) + for ac_j in `AS_ECHO(["$ac_arg"]) | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do + _AC_LIST_MEMBER_IF($ac_j, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , + [ac_arg="$ac_arg $ac_j" + ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_j"]) + done + ;; + -[[lLR]]*) + _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, , + ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg") + ;; + -zallextract*| -zdefaultextract) + ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg" + ;; + # Ignore everything else. + esac +done +# restore positional arguments +set X $ac_save_positional; shift + +# We only consider "LD_RUN_PATH" on Solaris systems. If this is seen, +# then we insist that the "run path" must be an absolute path (i.e. it +# must begin with a "/"). +case `(uname -sr) 2>/dev/null` in + "SunOS 5"*) + ac_ld_run_path=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) | + sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'` + test "x$ac_ld_run_path" != x && + _AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_[]_AC_LANG_ABBREV[]_libs) + ;; +esac +fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x" +]) +[]_AC_LANG_PREFIX[]LIBS="$ac_cv_[]_AC_LANG_ABBREV[]_libs" +AC_SUBST([]_AC_LANG_PREFIX[]LIBS) +])# _AC_FC_LIBRARY_LDFLAGS + + +# AC_F77_LIBRARY_LDFLAGS +# ---------------------- +AC_DEFUN([AC_F77_LIBRARY_LDFLAGS], +[AC_REQUIRE([AC_PROG_F77])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_FC_LIBRARY_LDFLAGS +AC_LANG_POP(Fortran 77)dnl +])# AC_F77_LIBRARY_LDFLAGS + + +# AC_FC_LIBRARY_LDFLAGS +# --------------------- +AC_DEFUN([AC_FC_LIBRARY_LDFLAGS], +[AC_REQUIRE([AC_PROG_FC])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_FC_LIBRARY_LDFLAGS +AC_LANG_POP(Fortran)dnl +])# AC_FC_LIBRARY_LDFLAGS + + +# _AC_FC_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ----------------------------------------------------------- +# +# Detect name of dummy main routine required by the Fortran libraries, +# (if any) and define {F77,FC}_DUMMY_MAIN to this name (which should be +# used for a dummy declaration, if it is defined). On some systems, +# linking a C program to the Fortran library does not work unless you +# supply a dummy function called something like MAIN__. +# +# Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C +# program with the {F77,FC} libs is found; default to exiting with an error +# message. Execute ACTION-IF-FOUND if a dummy routine name is needed +# and found or if it is not needed (default to defining {F77,FC}_DUMMY_MAIN +# when needed). +# +# What is technically happening is that the Fortran libraries provide +# their own main() function, which usually initializes Fortran I/O and +# similar stuff, and then calls MAIN__, which is the entry point of +# your program. Usually, a C program will override this with its own +# main() routine, but the linker sometimes complain if you don't +# provide a dummy (never-called) MAIN__ routine anyway. +# +# Of course, programs that want to allow Fortran subroutines to do +# I/O, etcetera, should call their main routine MAIN__() (or whatever) +# instead of main(). A separate autoconf test (_AC_FC_MAIN) checks +# for the routine to use in this case (since the semantics of the test +# are slightly different). To link to e.g. purely numerical +# libraries, this is normally not necessary, however, and most C/C++ +# programs are reluctant to turn over so much control to Fortran. =) +# +# The name variants we check for are (in order): +# MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional) +# MAIN_, __main (SunOS) +# MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too) +AC_DEFUN([_AC_FC_DUMMY_MAIN], +[_AC_FORTRAN_ASSERT()dnl +m4_define(_AC_LANG_PROGRAM_C_[]_AC_FC[]_HOOKS, +[#ifdef ]_AC_FC[_DUMMY_MAIN +]AC_LANG_CASE([Fortran], [#ifndef FC_DUMMY_MAIN_EQ_F77]) +[# ifdef __cplusplus + extern "C" +# endif + int ]_AC_FC[_DUMMY_MAIN() { return 1; } +]AC_LANG_CASE([Fortran], [#endif]) +[#endif +]) +AC_CACHE_CHECK([for dummy main to link with _AC_LANG libraries], + ac_cv_[]_AC_LANG_ABBREV[]_dummy_main, +[ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS=$LIBS + LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS" + ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN + AC_LANG_PUSH(C)dnl + + # First, try linking without a dummy main: + AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], + [ac_cv_fortran_dummy_main=none], + [ac_cv_fortran_dummy_main=unknown]) + + if test $ac_cv_fortran_dummy_main = unknown; then + for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@define $ac_fortran_dm_var $ac_func]])], + [ac_cv_fortran_dummy_main=$ac_func; break]) + done + fi + AC_LANG_POP(C)dnl + ac_cv_[]_AC_LANG_ABBREV[]_dummy_main=$ac_cv_fortran_dummy_main + rm -rf conftest* + LIBS=$ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS +]) +[]_AC_FC[]_DUMMY_MAIN=$ac_cv_[]_AC_LANG_ABBREV[]_dummy_main +AS_IF([test "$[]_AC_FC[]_DUMMY_MAIN" != unknown], + [m4_default([$1], +[if test $[]_AC_FC[]_DUMMY_MAIN != none; then + AC_DEFINE_UNQUOTED([]_AC_FC[]_DUMMY_MAIN, $[]_AC_FC[]_DUMMY_MAIN, + [Define to dummy `main' function (if any) required to + link to the Fortran libraries.]) + if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then + AC_DEFINE([FC_DUMMY_MAIN_EQ_F77], 1, + [Define if F77 and FC dummy `main' functions are identical.]) + fi +fi])], + [m4_default([$2], + [AC_MSG_FAILURE([linking to Fortran libraries from C fails])])]) +])# _AC_FC_DUMMY_MAIN + + +# AC_F77_DUMMY_MAIN +# ----------------- +AC_DEFUN([AC_F77_DUMMY_MAIN], +[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_FC_DUMMY_MAIN($@) +AC_LANG_POP(Fortran 77)dnl +])# AC_F77_DUMMY_MAIN + + +# AC_FC_DUMMY_MAIN +# ---------------- +AC_DEFUN([AC_FC_DUMMY_MAIN], +[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_FC_DUMMY_MAIN($@) +AC_LANG_POP(Fortran)dnl +])# AC_FC_DUMMY_MAIN + + +# _AC_FC_MAIN +# ----------- +# Define {F77,FC}_MAIN to name of alternate main() function for use with +# the Fortran libraries. (Typically, the libraries may define their +# own main() to initialize I/O, etcetera, that then call your own +# routine called MAIN__ or whatever.) See _AC_FC_DUMMY_MAIN, above. +# If no such alternate name is found, just define {F77,FC}_MAIN to main. +# +AC_DEFUN([_AC_FC_MAIN], +[_AC_FORTRAN_ASSERT()dnl +AC_CACHE_CHECK([for alternate main to link with _AC_LANG libraries], + ac_cv_[]_AC_LANG_ABBREV[]_main, +[ac_[]_AC_LANG_ABBREV[]_m_save_LIBS=$LIBS + LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS" + ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN + AC_LANG_PUSH(C)dnl + ac_cv_fortran_main="main" # default entry point name + for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([@%:@ifdef FC_DUMMY_MAIN_EQ_F77 +@%:@ undef F77_DUMMY_MAIN +@%:@ undef FC_DUMMY_MAIN +@%:@else +@%:@ undef $ac_fortran_dm_var +@%:@endif +@%:@define main $ac_func])], + [ac_cv_fortran_main=$ac_func; break]) + done + AC_LANG_POP(C)dnl + ac_cv_[]_AC_LANG_ABBREV[]_main=$ac_cv_fortran_main + rm -rf conftest* + LIBS=$ac_[]_AC_LANG_ABBREV[]_m_save_LIBS +]) +AC_DEFINE_UNQUOTED([]_AC_FC[]_MAIN, $ac_cv_[]_AC_LANG_ABBREV[]_main, + [Define to alternate name for `main' routine that is + called from a `main' in the Fortran libraries.]) +])# _AC_FC_MAIN + + +# AC_F77_MAIN +# ----------- +AC_DEFUN([AC_F77_MAIN], +[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_FC_MAIN +AC_LANG_POP(Fortran 77)dnl +])# AC_F77_MAIN + + +# AC_FC_MAIN +# ---------- +AC_DEFUN([AC_FC_MAIN], +[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_FC_MAIN +AC_LANG_POP(Fortran)dnl +])# AC_FC_MAIN + + +# __AC_FC_NAME_MANGLING +# --------------------- +# Test for the name mangling scheme used by the Fortran compiler. +# +# Sets ac_cv_{f77,fc}_mangling. The value contains three fields, separated +# by commas: +# +# lower case / upper case: +# case translation of the Fortran symbols +# underscore / no underscore: +# whether the compiler appends "_" to symbol names +# extra underscore / no extra underscore: +# whether the compiler appends an extra "_" to symbol names already +# containing at least one underscore +# +AC_DEFUN([__AC_FC_NAME_MANGLING], +[_AC_FORTRAN_ASSERT()dnl +AC_CACHE_CHECK([for _AC_LANG name-mangling scheme], + ac_cv_[]_AC_LANG_ABBREV[]_mangling, +[AC_COMPILE_IFELSE( +[[ subroutine foobar() + return + end + subroutine foo_bar() + return + end]], +[mv conftest.$ac_objext cfortran_test.$ac_objext + + ac_save_LIBS=$LIBS + LIBS="cfortran_test.$ac_objext $LIBS $[]_AC_LANG_PREFIX[]LIBS" + + AC_LANG_PUSH(C)dnl + ac_success=no + for ac_foobar in foobar FOOBAR; do + for ac_underscore in "" "_"; do + ac_func="$ac_foobar$ac_underscore" + AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])], + [ac_success=yes; break 2]) + done + done + AC_LANG_POP(C)dnl + + if test "$ac_success" = "yes"; then + case $ac_foobar in + foobar) + ac_case=lower + ac_foo_bar=foo_bar + ;; + FOOBAR) + ac_case=upper + ac_foo_bar=FOO_BAR + ;; + esac + + AC_LANG_PUSH(C)dnl + ac_success_extra=no + for ac_extra in "" "_"; do + ac_func="$ac_foo_bar$ac_underscore$ac_extra" + AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])], + [ac_success_extra=yes; break]) + done + AC_LANG_POP(C)dnl + + if test "$ac_success_extra" = "yes"; then + ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_case case" + if test -z "$ac_underscore"; then + ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no underscore" + else + ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, underscore" + fi + if test -z "$ac_extra"; then + ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no extra underscore" + else + ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, extra underscore" + fi + else + ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown" + fi + else + ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown" + fi + + LIBS=$ac_save_LIBS + rm -rf conftest* + rm -f cfortran_test*], + [AC_MSG_FAILURE([cannot compile a simple Fortran program])]) +]) +])# __AC_FC_NAME_MANGLING + +# The replacement is empty. +AU_DEFUN([AC_F77_NAME_MANGLING], []) + + +# _AC_F77_NAME_MANGLING +# --------------------- +AC_DEFUN([_AC_F77_NAME_MANGLING], +[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl +AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl +AC_LANG_PUSH(Fortran 77)dnl +__AC_FC_NAME_MANGLING +AC_LANG_POP(Fortran 77)dnl +])# _AC_F77_NAME_MANGLING + + +# _AC_FC_NAME_MANGLING +# -------------------- +AC_DEFUN([_AC_FC_NAME_MANGLING], +[AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl +AC_REQUIRE([AC_FC_DUMMY_MAIN])dnl +AC_LANG_PUSH(Fortran)dnl +__AC_FC_NAME_MANGLING +AC_LANG_POP(Fortran)dnl +])# _AC_FC_NAME_MANGLING + + +# _AC_FC_WRAPPERS +# --------------- +# Defines C macros {F77,FC}_FUNC(name,NAME) and {F77,FC}_FUNC_(name,NAME) to +# properly mangle the names of C identifiers, and C identifiers with +# underscores, respectively, so that they match the name mangling +# scheme used by the Fortran compiler. +AC_DEFUN([_AC_FC_WRAPPERS], +[_AC_FORTRAN_ASSERT()dnl +AH_TEMPLATE(_AC_FC[_FUNC], + [Define to a macro mangling the given C identifier (in lower and upper + case), which must not contain underscores, for linking with Fortran.])dnl +AH_TEMPLATE(_AC_FC[_FUNC_], + [As ]_AC_FC[_FUNC, but for C identifiers containing underscores.])dnl +case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in + "lower case, no underscore, no extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name]) ;; + "lower case, no underscore, extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;; + "lower case, underscore, no extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;; + "lower case, underscore, extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] __]) ;; + "upper case, no underscore, no extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME]) ;; + "upper case, no underscore, extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;; + "upper case, underscore, no extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;; + "upper case, underscore, extra underscore") + AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _]) + AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] __]) ;; + *) + AC_MSG_WARN([unknown Fortran name-mangling scheme]) + ;; +esac +])# _AC_FC_WRAPPERS + + +# AC_F77_WRAPPERS +# --------------- +AC_DEFUN([AC_F77_WRAPPERS], +[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_FC_WRAPPERS +AC_LANG_POP(Fortran 77)dnl +])# AC_F77_WRAPPERS + + +# AC_FC_WRAPPERS +# -------------- +AC_DEFUN([AC_FC_WRAPPERS], +[AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_FC_WRAPPERS +AC_LANG_POP(Fortran)dnl +])# AC_FC_WRAPPERS + + +# _AC_FC_FUNC(NAME, [SHELLVAR = NAME]) +# ------------------------------------ +# For a Fortran subroutine of given NAME, define a shell variable +# $SHELLVAR to the Fortran-mangled name. If the SHELLVAR +# argument is not supplied, it defaults to NAME. +AC_DEFUN([_AC_FC_FUNC], +[_AC_FORTRAN_ASSERT()dnl +case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in + upper*) ac_val="m4_toupper([$1])" ;; + lower*) ac_val="m4_tolower([$1])" ;; + *) ac_val="unknown" ;; +esac +case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac +m4_if(m4_index([$1],[_]),-1,[], +[case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac +]) +m4_default([$2],[$1])="$ac_val" +])# _AC_FC_FUNC + + +# AC_F77_FUNC(NAME, [SHELLVAR = NAME]) +# ------------------------------------ +AC_DEFUN([AC_F77_FUNC], +[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl +AC_LANG_PUSH(Fortran 77)dnl +_AC_FC_FUNC([$1],[$2]) +AC_LANG_POP(Fortran 77)dnl +])# AC_F77_FUNC + + +# AC_FC_FUNC(NAME, [SHELLVAR = NAME]) +# ----------------------------------- +AC_DEFUN([AC_FC_FUNC], +[AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl +AC_LANG_PUSH(Fortran)dnl +_AC_FC_FUNC([$1],[$2]) +AC_LANG_POP(Fortran)dnl +])# AC_FC_FUNC + + +# AC_FC_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE]) +# ----------------------------------------------------------- +# Set the source-code extension used in Fortran (FC) tests to EXT (which +# defaults to f). Also, look for any necessary additional FCFLAGS needed +# to allow this extension, and store them in the output variable +# FCFLAGS_<EXT> (e.g. FCFLAGS_f90 for EXT=f90). If successful, +# call ACTION-IF-SUCCESS. If unable to compile source code with EXT, +# call ACTION-IF-FAILURE, which defaults to failing with an error +# message. +# +# (The flags for the current source-code extension, if any, are stored in +# $ac_fcflags_srcext and used automatically in subsequent autoconf tests.) +# +# For ordinary extensions like f90, etcetera, the modified FCFLAGS +# are currently needed for IBM's xlf* and Intel's ifc (grrr). Unfortunately, +# xlf* will only take flags to recognize one extension at a time, so if the +# user wants to compile multiple extensions (.f90 and .f95, say), she +# will need to use the FCFLAGS_F90 and FCFLAGS_F95 individually rather +# than just adding them all to FCFLAGS, for example. +# +# Also, for Intel's ifc compiler (which does not accept .f95 by default in +# some versions), the $FCFLAGS_<EXT> variable *must* go immediately before +# the source file on the command line, unlike other $FCFLAGS. Ugh. +# +# gfortran requires '-x f77' in order to recognize .f77 files. +AC_DEFUN([AC_FC_SRCEXT], +[AC_LANG_PUSH(Fortran)dnl +AC_CACHE_CHECK([for Fortran flag to compile .$1 files], + ac_cv_fc_srcext_$1, +[ac_ext=$1 +ac_fcflags_srcext_save=$ac_fcflags_srcext +ac_fcflags_srcext= +ac_cv_fc_srcext_$1=unknown +case $ac_ext in #( + [[fF]]77) ac_try=f77;; #( + *) ac_try=f95;; +esac +for ac_flag in none -qsuffix=f=$1 -Tf "-x $ac_try"; do + test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_fc_srcext_$1=$ac_flag; break]) +done +rm -f conftest.$ac_objext conftest.$1 +ac_fcflags_srcext=$ac_fcflags_srcext_save +]) +if test "x$ac_cv_fc_srcext_$1" = xunknown; then + m4_default([$3],[AC_MSG_ERROR([Fortran could not compile .$1 files])]) +else + ac_fc_srcext=$1 + if test "x$ac_cv_fc_srcext_$1" = xnone; then + ac_fcflags_srcext="" + FCFLAGS_[]$1[]="" + else + ac_fcflags_srcext=$ac_cv_fc_srcext_$1 + FCFLAGS_[]$1[]=$ac_cv_fc_srcext_$1 + fi + AC_SUBST(FCFLAGS_[]$1) + $2 +fi +AC_LANG_POP(Fortran)dnl +])# AC_FC_SRCEXT + + +# AC_FC_PP_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE]) +# -------------------------------------------------------------- +# Like AC_FC_SRCEXT, set the source-code extension used in Fortran (FC) tests +# to EXT (which defaults to f). Also, look for any necessary additional +# FCFLAGS needed to allow this extension for preprocessed Fortran, and store +# them in the output variable FCFLAGS_<EXT> (e.g. FCFLAGS_f90 for EXT=f90). +# If successful, call ACTION-IF-SUCCESS. If unable to compile preprocessed +# source code with EXT, call ACTION-IF-FAILURE, which defaults to failing with +# an error message. +# +# Some compilers allow preprocessing with either a Fortran preprocessor or +# with the C preprocessor (cpp). Prefer the Fortran preprocessor, to deal +# correctly with continuation lines, `//' (not a comment), and preserve white +# space (for fixed form). +# +# (The flags for the current source-code extension, if any, are stored in +# $ac_fcflags_srcext and used automatically in subsequent autoconf tests.) +# +# For ordinary extensions like f90, etcetera, the modified FCFLAGS +# are needed for IBM's xlf*. Also, for Intel's ifort compiler, the +# $FCFLAGS_<EXT> variable *must* go immediately before the source file on the +# command line, unlike other $FCFLAGS. Ugh. +# +# Known extensions that enable preprocessing by default, and flags to force it: +# GNU: .F .F90 .F95 .F03 .F08, -cpp for most others, +# -x f77-cpp-input for .f77 .F77; -x f95-cpp-input for gfortran < 4.4 +# SGI: .F .F90, -ftpp or -cpp for .f .f90, -E write preproc to stdout +# -macro_expand enable macro expansion everywhere (with -ftpp) +# -P preproc only, save in .i, no #line's +# SUN: .F .F95, -fpp for others; -xpp={fpp,cpp} for preprocessor selection +# -F preprocess only (save in lowercase extension) +# IBM: .F .F77 .F90 .F95 .F03, -qsuffix=cpp=EXT for extension .EXT to invoke cpp +# -WF,-qnofpp -WF,-qfpp=comment:linecont:nocomment:nolinecont +# -WF,-qlanglvl=classic or not -qnoescape (trigraph problems) +# -d no #line in output, -qnoobject for preprocessing only (output in .f) +# -q{no,}ppsuborigarg substitute original macro args before expansion +# HP: .F, +cpp={yes|no|default} use cpp, -cpp, +cpp_keep save in .i/.i90 +# PGI: -Mpreprocess +# Absoft: .F .FOR .F90 .F95, -cpp for others +# Cray: .F .F90 .FTN, -e Z for others; -F enable macro expansion everywhere +# Intel: .F .F90, -fpp for others, but except for .f and .f90, -Tf may also be +# needed right before the source file name +# PathScale: .F .F90 .F95, -ftpp or -cpp for .f .f90 .f95 +# -macro_expand for expansion everywhere, -P for no #line in output +# Lahey: .F .FOR .F90 .F95, -Cpp +# NAGWare: .F .F90 .F95, .ff .ff90 .ff95 (new), -fpp for others +# Compaq/Tru64: .F .F90, -cpp, -P keep .i file, -P keep .i file +# f2c: .F, -cpp +# g95: .F .FOR .F90 .F95 .F03, -cpp -no-cpp, -E for stdout +AC_DEFUN([AC_FC_PP_SRCEXT], +[AC_LANG_PUSH(Fortran)dnl +AC_CACHE_CHECK([for Fortran flag to compile preprocessed .$1 files], + ac_cv_fc_pp_srcext_$1, +[ac_ext=$1 +ac_fcflags_pp_srcext_save=$ac_fcflags_srcext +ac_fcflags_srcext= +ac_cv_fc_pp_srcext_$1=unknown +case $ac_ext in #( + [[fF]]77) ac_try=f77-cpp-input;; #( + *) ac_try=f95-cpp-input;; +esac +for ac_flag in none -ftpp -fpp -Tf "-fpp -Tf" -xpp=fpp -Mpreprocess "-e Z" \ + -cpp -xpp=cpp -qsuffix=cpp=$1 "-x $ac_try" +cpp -Cpp; do + test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ +#if 0 +#include <ac_nonexistent.h> + choke me +#endif]])], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ +#if 1 +#include <ac_nonexistent.h> + choke me +#endif]])], + [], + [ac_cv_fc_pp_srcext_$1=$ac_flag; break])]) +done +rm -f conftest.$ac_objext conftest.$1 +ac_fcflags_srcext=$ac_fcflags_pp_srcext_save +]) +if test "x$ac_cv_fc_pp_srcext_$1" = xunknown; then + m4_default([$3], + [AC_MSG_ERROR([Fortran could not compile preprocessed .$1 files])]) +else + ac_fc_srcext=$1 + if test "x$ac_cv_fc_pp_srcext_$1" = xnone; then + ac_fcflags_srcext="" + FCFLAGS_[]$1[]="" + else + ac_fcflags_srcext=$ac_cv_fc_pp_srcext_$1 + FCFLAGS_[]$1[]=$ac_cv_fc_pp_srcext_$1 + fi + AC_SUBST(FCFLAGS_[]$1) + $2 +fi +AC_LANG_POP(Fortran)dnl +])# AC_FC_PP_SRCEXT + + +# AC_FC_PP_DEFINE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------------------------- +# Find a flag to specify defines for preprocessed Fortran. Not all +# Fortran compilers use -D. Substitute FC_DEFINE with the result and +# call ACTION-IF-SUCCESS (defaults to nothing) if successful, and +# ACTION-IF-FAILURE (defaults to failing with an error message) if not. +# +# Known flags: +# IBM: -WF,-D +# Lahey/Fujitsu: -Wp,-D older versions??? +# f2c: -D or -Wc,-D +# others: -D +AC_DEFUN([AC_FC_PP_DEFINE], +[AC_LANG_PUSH([Fortran])dnl +ac_fc_pp_define_srcext_save=$ac_fc_srcext +AC_FC_PP_SRCEXT([F]) +AC_CACHE_CHECK([how to define symbols for preprocessed Fortran], + [ac_cv_fc_pp_define], +[ac_fc_pp_define_srcext_save=$ac_fc_srcext +ac_cv_fc_pp_define=unknown +ac_fc_pp_define_FCFLAGS_save=$FCFLAGS +for ac_flag in -D -WF,-D -Wp,-D -Wc,-D +do + FCFLAGS="$ac_fc_pp_define_FCFLAGS_save ${ac_flag}FOOBAR ${ac_flag}ZORK=42" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ +#ifndef FOOBAR + choke me +#endif +#if ZORK != 42 + choke me +#endif]])], + [ac_cv_fc_pp_define=$ac_flag]) + test x"$ac_cv_fc_pp_define" != xunknown && break +done +FCFLAGS=$ac_fc_pp_define_FCFLAGS_save +]) +ac_fc_srcext=$ac_fc_pp_define_srcext_save +if test "x$ac_cv_fc_pp_define" = xunknown; then + FC_DEFINE= + m4_default([$2], + [AC_MSG_ERROR([Fortran does not allow to define preprocessor symbols], 77)]) +else + FC_DEFINE=$ac_cv_fc_pp_define + $1 +fi +AC_SUBST([FC_DEFINE])dnl +AC_LANG_POP([Fortran])dnl +]) + + +# AC_FC_FREEFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------------------------ +# Look for a compiler flag to make the Fortran (FC) compiler accept +# free-format source code, and adds it to FCFLAGS. Call +# ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can +# compile code using new extension) and ACTION-IF-FAILURE (defaults to +# failing with an error message) if not. (Defined via DEFUN_ONCE to +# prevent flag from being added to FCFLAGS multiple times.) +# +# The known flags are: +# -ffree-form: GNU g77, gfortran, g95 +# -FR, -free: Intel compiler (icc, ecc, ifort) +# -free: Compaq compiler (fort), Sun compiler (f95) +# -qfree: IBM compiler (xlf) +# -Mfree, -Mfreeform: Portland Group compiler +# -freeform: SGI compiler +# -8, -f free: Absoft Fortran +# +source=free: HP Fortran +# (-)-nfix, -Free: Lahey/Fujitsu Fortran +# -free: NAGWare +# -f, -Wf,-f: f2c (but only a weak form of "free-form" and long lines) +# We try to test the "more popular" flags first, by some prejudiced +# notion of popularity. +AC_DEFUN_ONCE([AC_FC_FREEFORM], +[AC_LANG_PUSH([Fortran])dnl +AC_CACHE_CHECK([for Fortran flag needed to accept free-form source], + [ac_cv_fc_freeform], +[ac_cv_fc_freeform=unknown +ac_fc_freeform_FCFLAGS_save=$FCFLAGS +for ac_flag in none -ffree-form -FR -free -qfree -Mfree -Mfreeform \ + -freeform "-f free" -8 +source=free -nfix --nfix -Free +do + test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_freeform_FCFLAGS_save $ac_flag" +dnl Use @&t@ below to ensure that editors don't turn 8+ spaces into tab. + AC_COMPILE_IFELSE([[ + program freeform + ! FIXME: how to best confuse non-freeform compilers? + print *, 'Hello ', & + @&t@ 'world.' + end]], + [ac_cv_fc_freeform=$ac_flag; break]) +done +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +FCFLAGS=$ac_fc_freeform_FCFLAGS_save +]) +if test "x$ac_cv_fc_freeform" = xunknown; then + m4_default([$2], + [AC_MSG_ERROR([Fortran does not accept free-form source], 77)]) +else + if test "x$ac_cv_fc_freeform" != xnone; then + FCFLAGS="$FCFLAGS $ac_cv_fc_freeform" + fi + $1 +fi +AC_LANG_POP([Fortran])dnl +])# AC_FC_FREEFORM + + +# AC_FC_FIXEDFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------------------------ +# Look for a compiler flag to make the Fortran (FC) compiler accept +# fixed-format source code, and adds it to FCFLAGS. Call +# ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can +# compile code using new extension) and ACTION-IF-FAILURE (defaults to +# failing with an error message) if not. (Defined via DEFUN_ONCE to +# prevent flag from being added to FCFLAGS multiple times.) +# +# The known flags are: +# -ffixed-form: GNU g77, gfortran, g95 +# -fixed: Intel compiler (ifort), Sun compiler (f95) +# -qfixed: IBM compiler (xlf*) +# -Mfixed: Portland Group compiler +# -fixedform: SGI compiler +# -f fixed: Absoft Fortran +# +source=fixed: HP Fortran +# (-)-fix, -Fixed: Lahey/Fujitsu Fortran +# -fixed: NAGWare +# Since compilers may accept fixed form based on file name extension, +# but users may want to use it with others as well, call AC_FC_SRCEXT +# with the respective source extension before calling this macro. +AC_DEFUN_ONCE([AC_FC_FIXEDFORM], +[AC_LANG_PUSH([Fortran])dnl +AC_CACHE_CHECK([for Fortran flag needed to accept fixed-form source], + [ac_cv_fc_fixedform], +[ac_cv_fc_fixedform=unknown +ac_fc_fixedform_FCFLAGS_save=$FCFLAGS +for ac_flag in none -ffixed-form -fixed -qfixed -Mfixed -fixedform "-f fixed" \ + +source=fixed -fix --fix -Fixed +do + test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_fixedform_FCFLAGS_save $ac_flag" + AC_COMPILE_IFELSE([[ +C This comment should confuse free-form compilers. + program main + end]], + [ac_cv_fc_fixedform=$ac_flag; break]) +done +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +FCFLAGS=$ac_fc_fixedform_FCFLAGS_save +]) +if test "x$ac_cv_fc_fixedform" = xunknown; then + m4_default([$2], + [AC_MSG_ERROR([Fortran does not accept fixed-form source], 77)]) +else + if test "x$ac_cv_fc_fixedform" != xnone; then + FCFLAGS="$FCFLAGS $ac_cv_fc_fixedform" + fi + $1 +fi +AC_LANG_POP([Fortran])dnl +])# AC_FC_FIXEDFORM + + +# AC_FC_LINE_LENGTH([LENGTH], [ACTION-IF-SUCCESS], +# [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------ +# Look for a compiler flag to make the Fortran (FC) compiler accept long lines +# in the current (free- or fixed-format) source code, and adds it to FCFLAGS. +# The optional LENGTH may be 80, 132 (default), or `unlimited' for longer +# lines. Note that line lengths above 254 columns are not portable, and some +# compilers (hello ifort) do not accept more than 132 columns at least for +# fixed format. Call ACTION-IF-SUCCESS (defaults to nothing) if successful +# (i.e. can compile code using new extension) and ACTION-IF-FAILURE (defaults +# to failing with an error message) if not. (Defined via DEFUN_ONCE to +# prevent flag from being added to FCFLAGS multiple times.) +# You should call AC_FC_FREEFORM or AC_FC_FIXEDFORM to set the desired format +# prior to using this macro. +# +# The known flags are: +# -f{free,fixed}-line-length-N with N 72, 80, 132, or 0 or none for none. +# -ffree-line-length-none: GNU gfortran +# -ffree-line-length-huge: g95 (also -ffixed-line-length-N as above) +# -qfixed=132 80 72: IBM compiler (xlf) +# -Mextend: Cray +# -132 -80 -72: Intel compiler (ifort) +# Needs to come before -extend_source because ifort +# accepts that as well with an optional parameter and +# doesn't fail but only warns about unknown arguments. +# -extend_source: SGI compiler +# -W, -WNN (132, 80, 72): Absoft Fortran +# +es, +extend_source: HP Fortran (254 in either form, default is 72 fixed, +# 132 free) +# -w, (-)-wide: Lahey/Fujitsu Fortran (255 cols in fixed form) +# -e: Sun Fortran compiler (132 characters) +# -132: NAGWare +# -72, -f, -Wf,-f: f2c (a weak form of "free-form" and long lines). +# /XLine: Open Watcom +AC_DEFUN_ONCE([AC_FC_LINE_LENGTH], +[AC_LANG_PUSH([Fortran])dnl +m4_case(m4_default([$1], [132]), + [unlimited], [ac_fc_line_len_string=unlimited + ac_fc_line_len=0 + ac_fc_line_length_test=' + subroutine longer_than_132(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,'\ +'arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19)'], + [132], [ac_fc_line_len=132 + ac_fc_line_length_test=' + subroutine longer_than_80(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,'\ +'arg10)'], + [80], [ac_fc_line_len=80 + ac_fc_line_length_test=' + subroutine longer_than_72(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)'], + [m4_warning([Invalid length argument `$1'])]) +: ${ac_fc_line_len_string=$ac_fc_line_len} +AC_CACHE_CHECK( +[for Fortran flag needed to accept $ac_fc_line_len_string column source lines], + [ac_cv_fc_line_length], +[ac_cv_fc_line_length=unknown +ac_fc_line_length_FCFLAGS_save=$FCFLAGS +for ac_flag in none \ + -ffree-line-length-none -ffixed-line-length-none \ + -ffree-line-length-huge \ + -ffree-line-length-$ac_fc_line_len \ + -ffixed-line-length-$ac_fc_line_len \ + -qfixed=$ac_fc_line_len -Mextend \ + -$ac_fc_line_len -extend_source \ + -W$ac_fc_line_len -W +extend_source +es -wide --wide -w -e \ + -f -Wf,-f -xline +do + test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_line_length_FCFLAGS_save $ac_flag" + AC_COMPILE_IFELSE([[$ac_fc_line_length_test + end subroutine]], + [ac_cv_fc_line_length=$ac_flag; break]) +done +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +FCFLAGS=$ac_fc_line_length_FCFLAGS_save +]) +if test "x$ac_cv_fc_line_length" = xunknown; then + m4_default([$3], + [AC_MSG_ERROR([Fortran does not accept long source lines], 77)]) +else + if test "x$ac_cv_fc_line_length" != xnone; then + FCFLAGS="$FCFLAGS $ac_cv_fc_line_length" + fi + $2 +fi +AC_LANG_POP([Fortran])dnl +])# AC_FC_LINE_LENGTH + + +# AC_FC_CHECK_BOUNDS([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ---------------------------------------------------------------------- +# Look for a compiler flag to turn on array bounds checking for the +# Fortran (FC) compiler, and adds it to FCFLAGS. Call +# ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can +# compile code using new extension) and ACTION-IF-FAILURE (defaults to +# failing with an error message) if not. (Defined via DEFUN_ONCE to +# prevent flag from being added to FCFLAGS multiple times.) +# +# The known flags are: +# -fcheck=all, -fbounds-check: gfortran +# -fbounds-check: g77, g95 +# -CB, -check bounds: Intel compiler (icc, ecc, ifort) +# -C: Sun/Oracle compiler (f95) +# -C, -qcheck: IBM compiler (xlf) +# -Mbounds: Portland Group compiler +# -C ,-Mbounds: Cray +# -C, -check_bounds: SGI compiler +# -check_bounds, +check=all: HP Fortran +# -C, -Rb -Rc: Absoft (-Rb: array boundaries, -Rc: array conformance) +# --chk e,s -chk (e,s): Lahey +# -C -C=all: NAGWare +# -C, -ffortran-bounds-check: PathScale pathf90 +# -C: f2c +# -BOunds: Open Watcom +AC_DEFUN_ONCE([AC_FC_CHECK_BOUNDS], +[AC_LANG_PUSH([Fortran])dnl +AC_CACHE_CHECK([for Fortran flag to enable array-bounds checking], + [ac_cv_fc_check_bounds], +[ac_cv_fc_check_bounds=unknown +ac_fc_check_bounds_FCFLAGS_save=$FCFLAGS +for ac_flag in -fcheck=bounds -fbounds-check -check_bounds -Mbounds -qcheck \ + '-check bounds' +check=all --check '-Rb -Rc' -CB -C=all -C \ + -ffortran-bounds-check "--chk e,s" "-chk e -chk s" -bounds +do + FCFLAGS="$ac_fc_check_bounds_FCFLAGS_save $ac_flag" + # We should be able to link a correct program. + AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], + [AC_LINK_IFELSE([[ + subroutine sub(a) + integer a(:) + a(8) = 0 + end subroutine + + program main + integer a(1:7) + interface + subroutine sub(a) + integer a(:) + end subroutine + end interface + + call sub(a) + end program]], + [# If we can run the program, require failure at run time. + # In cross-compiling mode, we rely on the compiler not accepting + # unknown options. + AS_IF([test "$cross_compiling" = yes], + [ac_cv_fc_check_bounds=$ac_flag; break], + [AS_IF([_AC_DO_TOKENS(./conftest$ac_exeext)], + [], + [ac_cv_fc_check_bounds=$ac_flag; break])])])]) +done +rm -f conftest$ac_exeext conftest.err conftest.$ac_objext conftest.$ac_ext \ + core *.core core.conftest.* +FCFLAGS=$ac_fc_check_bounds_FCFLAGS_save +]) +if test "x$ac_cv_fc_check_bounds" = xunknown; then + m4_default([$2], + [AC_MSG_ERROR([no Fortran flag for bounds checking found], 77)]) +else + if test "x$ac_cv_fc_check_bounds" != xnone; then + FCFLAGS="$FCFLAGS $ac_cv_fc_check_bounds" + fi + $1 +fi +AC_LANG_POP([Fortran])dnl +])# AC_FC_CHECK_BOUNDS + + +# _AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------------------------------ +# Look for a flag to disallow implicit declarations, and add it to FCFLAGS. +# Call ACTION-IF-SUCCESS (defaults to nothing) if successful and +# ACTION-IF-FAILURE (defaults to failing with an error message) if not. +# +# Known flags: +# GNU gfortran, g95: -fimplicit-none, g77: -Wimplicit +# Intel: -u, -implicitnone; might also need '-warn errors' to turn into error. +# Sun/Oracle: -u +# HP: +implicit_none +# IBM: -u, -qundef +# SGI: -u +# Compaq: -u, -warn declarations +# NAGWare: -u +# Lahey: -in, --in, -AT +# Cray: -Mdclchk -e I +# PGI: -Mcdlchk +# f2c: -u +AC_DEFUN([_AC_FC_IMPLICIT_NONE], +[_AC_FORTRAN_ASSERT()dnl +AC_CACHE_CHECK([for flag to disallow _AC_LANG implicit declarations], + [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none], +[ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=unknown +ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save=$[]_AC_LANG_PREFIX[]FLAGS +for ac_flag in none -fimplicit-none -u -Wimplicit -implicitnone +implicit_none \ + -qundef "-warn declarations" -in --in -AT "-e I" -Mdclchk \ + "-u -warn errors" +do + if test "x$ac_flag" != xnone; then + _AC_LANG_PREFIX[]FLAGS="$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save $ac_flag" + fi + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[ + i = 0 + print *, i]])], + [], + [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=$ac_flag; break])]) +done +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +_AC_LANG_PREFIX[]FLAGS=$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save +]) +if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" = xunknown; then + m4_default([$3], + [AC_MSG_ERROR([no Fortran flag to disallow implicit declarations found], 77)]) +else + if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" != xnone; then + _AC_LANG_PREFIX[]FLAGS="$_AC_LANG_PREFIX[]FLAGS $ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" + fi + $2 +fi +])# _AC_FC_IMPLICIT_NONE + + +# AC_F77_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ------------------------------------------------------------------------ +AC_DEFUN([AC_F77_IMPLICIT_NONE], +[AC_LANG_PUSH([Fortran 77])dnl +_AC_FC_IMPLICIT_NONE($@) +AC_LANG_POP([Fortran 77])dnl +])# AC_F77_IMPLICIT_NONE + + +# AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ----------------------------------------------------------------------- +AC_DEFUN([AC_FC_IMPLICIT_NONE], +[AC_LANG_PUSH([Fortran])dnl +_AC_FC_IMPLICIT_NONE($@) +AC_LANG_POP([Fortran])dnl +])# AC_FC_IMPLICIT_NONE + + +# AC_FC_MODULE_EXTENSION +# ---------------------- +# Find the Fortran 90 module file extension. The module extension is stored +# in the variable FC_MODEXT and empty if it cannot be determined. The result +# or "unknown" is cached in the cache variable ac_cv_fc_module_ext. +AC_DEFUN([AC_FC_MODULE_EXTENSION], +[AC_CACHE_CHECK([Fortran 90 module extension], [ac_cv_fc_module_ext], +[AC_LANG_PUSH(Fortran) +mkdir conftest.dir +cd conftest.dir +ac_cv_fc_module_ext=unknown +AC_COMPILE_IFELSE([[ + module conftest_module + contains + subroutine conftest_routine + write(*,'(a)') 'gotcha!' + end subroutine + end module]], + [ac_cv_fc_module_ext=`ls | sed -n 's,conftest_module\.,,p'` + if test x$ac_cv_fc_module_ext = x; then +dnl Some F90 compilers use upper case characters for the module file name. + ac_cv_fc_module_ext=`ls | sed -n 's,CONFTEST_MODULE\.,,p'` + fi]) +cd .. +rm -rf conftest.dir +AC_LANG_POP(Fortran) +]) +FC_MODEXT=$ac_cv_fc_module_ext +if test "$FC_MODEXT" = unknown; then + FC_MODEXT= +fi +AC_SUBST([FC_MODEXT])dnl +]) + + +# AC_FC_MODULE_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# --------------------------------------------------------------------- +# Find a flag to include Fortran 90 modules from another directory. +# If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise +# run ACTION-IF-FAILURE (defaults to failing with an error message). +# The module flag is cached in the ac_cv_fc_module_flag variable. +# It may contain significant trailing whitespace. +# +# Known flags: +# gfortran: -Idir, -I dir (-M dir, -Mdir (deprecated), -Jdir for writing) +# g95: -I dir (-fmod=dir for writing) +# SUN: -Mdir, -M dir (-moddir=dir for writing; +# -Idir for includes is also searched) +# HP: -Idir, -I dir (+moddir=dir for writing) +# IBM: -Idir (-qmoddir=dir for writing) +# Intel: -Idir -I dir (-mod dir for writing) +# Absoft: -pdir +# Lahey: -mod dir +# Cray: -module dir, -p dir (-J dir for writing) +# -e m is needed to enable writing .mod files at all +# Compaq: -Idir +# NAGWare: -I dir +# PathScale: -I dir (but -module dir is looked at first) +# Portland: -module dir (first -module also names dir for writing) +# Fujitsu: -Am -Idir (-Mdir for writing is searched first, then '.', then -I) +# (-Am indicates how module information is saved) +AC_DEFUN([AC_FC_MODULE_FLAG],[ +AC_CACHE_CHECK([Fortran 90 module inclusion flag], [ac_cv_fc_module_flag], +[AC_LANG_PUSH([Fortran]) +ac_cv_fc_module_flag=unknown +mkdir conftest.dir +cd conftest.dir +AC_COMPILE_IFELSE([[ + module conftest_module + contains + subroutine conftest_routine + write(*,'(a)') 'gotcha!' + end subroutine + end module]], + [cd .. + ac_fc_module_flag_FCFLAGS_save=$FCFLAGS + # Flag ordering is significant for gfortran and Sun. + for ac_flag in -M -I '-I ' '-M ' -p '-mod ' '-module ' '-Am -I'; do + # Add the flag twice to prevent matching an output flag. + FCFLAGS="$ac_fc_module_flag_FCFLAGS_save ${ac_flag}conftest.dir ${ac_flag}conftest.dir" + AC_COMPILE_IFELSE([[ + program main + use conftest_module + call conftest_routine + end program]], + [ac_cv_fc_module_flag="$ac_flag"]) + if test "$ac_cv_fc_module_flag" != unknown; then + break + fi + done + FCFLAGS=$ac_fc_module_flag_FCFLAGS_save +]) +rm -rf conftest.dir +AC_LANG_POP([Fortran]) +]) +if test "$ac_cv_fc_module_flag" != unknown; then + FC_MODINC=$ac_cv_fc_module_flag + $1 +else + FC_MODINC= + m4_default([$2], + [AC_MSG_ERROR([unable to find compiler flag for module search path])]) +fi +AC_SUBST([FC_MODINC]) +# Ensure trailing whitespace is preserved in a Makefile. +AC_SUBST([ac_empty], [""]) +AC_CONFIG_COMMANDS_PRE([case $FC_MODINC in #( + *\ ) FC_MODINC=$FC_MODINC'${ac_empty}' ;; +esac])dnl +]) + + +# AC_FC_MODULE_OUTPUT_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE]) +# ---------------------------------------------------------------------------- +# Find a flag to write Fortran 90 module information to another directory. +# If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise +# run ACTION-IF-FAILURE (defaults to failing with an error message). +# The module flag is cached in the ac_cv_fc_module_output_flag variable. +# It may contain significant trailing whitespace. +# +# For known flags, see the documentation of AC_FC_MODULE_FLAG above. +AC_DEFUN([AC_FC_MODULE_OUTPUT_FLAG],[ +AC_CACHE_CHECK([Fortran 90 module output flag], [ac_cv_fc_module_output_flag], +[AC_LANG_PUSH([Fortran]) +mkdir conftest.dir conftest.dir/sub +cd conftest.dir +ac_cv_fc_module_output_flag=unknown +ac_fc_module_output_flag_FCFLAGS_save=$FCFLAGS +# Flag ordering is significant: put flags late which some compilers use +# for the search path. +for ac_flag in -J '-J ' -fmod= -moddir= +moddir= -qmoddir= '-mod ' \ + '-module ' -M '-Am -M' '-e m -J '; do + FCFLAGS="$ac_fc_module_output_flag_FCFLAGS_save ${ac_flag}sub" + AC_COMPILE_IFELSE([[ + module conftest_module + contains + subroutine conftest_routine + write(*,'(a)') 'gotcha!' + end subroutine + end module]], + [cd sub + AC_COMPILE_IFELSE([[ + program main + use conftest_module + call conftest_routine + end program]], + [ac_cv_fc_module_output_flag="$ac_flag"]) + cd .. + if test "$ac_cv_fc_module_output_flag" != unknown; then + break + fi]) +done +FCFLAGS=$ac_fc_module_output_flag_FCFLAGS_save +cd .. +rm -rf conftest.dir +AC_LANG_POP([Fortran]) +]) +if test "$ac_cv_fc_module_output_flag" != unknown; then + FC_MODOUT=$ac_cv_fc_module_output_flag + $1 +else + FC_MODOUT= + m4_default([$2], + [AC_MSG_ERROR([unable to find compiler flag to write module information to])]) +fi +AC_SUBST([FC_MODOUT]) +# Ensure trailing whitespace is preserved in a Makefile. +AC_SUBST([ac_empty], [""]) +AC_CONFIG_COMMANDS_PRE([case $FC_MODOUT in #( + *\ ) FC_MODOUT=$FC_MODOUT'${ac_empty}' ;; +esac])dnl +]) diff --git a/lib/autoconf/functions.m4 b/lib/autoconf/functions.m4 new file mode 100644 index 0000000..6f21fd5 --- /dev/null +++ b/lib/autoconf/functions.m4 @@ -0,0 +1,2030 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Checking for functions. +# Copyright (C) 2000-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# Table of contents +# +# 1. Generic tests for functions. +# 2. Functions to check with AC_CHECK_FUNCS +# 3. Tests for specific functions. + + +## -------------------------------- ## +## 1. Generic tests for functions. ## +## -------------------------------- ## + +# _AC_CHECK_FUNC_BODY +# ------------------- +# Shell function body for AC_CHECK_FUNC. +m4_define([_AC_CHECK_FUNC_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for $[]2], [$[]3], + [AC_LINK_IFELSE([AC_LANG_FUNC_LINK_TRY($[]2)], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [no])])]) + AS_LINENO_POP +])# _AC_CHECK_FUNC_BODY + + +# AC_CHECK_FUNC(FUNCTION, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ----------------------------------------------------------------- +# Check whether FUNCTION links in the current language. Set the cache +# variable ac_cv_func_FUNCTION accordingly, then execute +# ACTION-IF-FOUND or ACTION-IF-NOT-FOUND. +AC_DEFUN([AC_CHECK_FUNC], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_func], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_func], + [LINENO FUNC VAR], + [Tests whether FUNC exists, setting the cache variable VAR accordingly])], + [_$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_var], [ac_cv_func_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_func "$LINENO" "$1" "ac_var" +AS_VAR_IF([ac_var], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_var])])# AC_CHECK_FUNC + + +# _AH_CHECK_FUNC(FUNCTION) +# ------------------------ +# Prepare the autoheader snippet for FUNCTION. +m4_define([_AH_CHECK_FUNC], +[AH_TEMPLATE(AS_TR_CPP([HAVE_$1]), + [Define to 1 if you have the `$1' function.])]) + + +# AC_CHECK_FUNCS(FUNCTION..., [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# --------------------------------------------------------------------- +# Check for each whitespace-separated FUNCTION, and perform +# ACTION-IF-FOUND or ACTION-IF-NOT-FOUND for each function. +# Additionally, make the preprocessor definition HAVE_FUNCTION +# available for each found function. Either ACTION may include +# `break' to stop the search. +AC_DEFUN([AC_CHECK_FUNCS], +[m4_map_args_w([$1], [_AH_CHECK_FUNC(], [)])]dnl +[AS_FOR([AC_func], [ac_func], [$1], +[AC_CHECK_FUNC(AC_func, + [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_]AC_func)) $2], + [$3])dnl]) +])# AC_CHECK_FUNCS + + +# _AC_CHECK_FUNC_ONCE(FUNCTION) +# ----------------------------- +# Check for a single FUNCTION once. +m4_define([_AC_CHECK_FUNC_ONCE], +[_AH_CHECK_FUNC([$1])AC_DEFUN([_AC_Func_$1], + [m4_divert_text([INIT_PREPARE], [AS_VAR_APPEND([ac_func_list], [" $1"])]) +_AC_FUNCS_EXPANSION])AC_REQUIRE([_AC_Func_$1])]) + +# AC_CHECK_FUNCS_ONCE(FUNCTION...) +# -------------------------------- +# Add each whitespace-separated name in FUNCTION to the list of functions +# to check once. +AC_DEFUN([AC_CHECK_FUNCS_ONCE], +[m4_map_args_w([$1], [_AC_CHECK_FUNC_ONCE(], [)])]) + +m4_define([_AC_FUNCS_EXPANSION], +[ + m4_divert_text([DEFAULTS], [ac_func_list=]) + AC_CHECK_FUNCS([$ac_func_list]) + m4_define([_AC_FUNCS_EXPANSION], []) +]) + + +# _AC_REPLACE_FUNC(FUNCTION) +# -------------------------- +# If FUNCTION exists, define HAVE_FUNCTION; else add FUNCTION.c +# to the list of library objects. FUNCTION must be literal. +m4_define([_AC_REPLACE_FUNC], +[AC_CHECK_FUNC([$1], + [_AH_CHECK_FUNC([$1])AC_DEFINE(AS_TR_CPP([HAVE_$1]))], + [_AC_LIBOBJ([$1])AC_LIBSOURCE([$1.c])])]) + +# AC_REPLACE_FUNCS(FUNCTION...) +# ----------------------------- +# For each FUNCTION in the whitespace separated list, perform the +# equivalent of AC_CHECK_FUNC, then call AC_LIBOBJ if the function +# was not found. +AC_DEFUN([AC_REPLACE_FUNCS], +[_$0(m4_flatten([$1]))]) + +m4_define([_AC_REPLACE_FUNCS], +[AS_LITERAL_IF([$1], +[m4_map_args_w([$1], [_AC_REPLACE_FUNC(], [) +])], +[AC_CHECK_FUNCS([$1], + [_AH_CHECK_FUNC([$ac_func])], + [_AC_LIBOBJ([$ac_func])])])]) + + +# AC_TRY_LINK_FUNC(FUNC, ACTION-IF-FOUND, ACTION-IF-NOT-FOUND) +# ------------------------------------------------------------ +# Try to link a program that calls FUNC, handling GCC builtins. If +# the link succeeds, execute ACTION-IF-FOUND; otherwise, execute +# ACTION-IF-NOT-FOUND. +AC_DEFUN([AC_TRY_LINK_FUNC], +[AC_LINK_IFELSE([AC_LANG_CALL([], [$1])], [$2], [$3])]) + + +# AU::AC_FUNC_CHECK +# ----------------- +AU_ALIAS([AC_FUNC_CHECK], [AC_CHECK_FUNC]) + + +# AU::AC_HAVE_FUNCS +# ----------------- +AU_ALIAS([AC_HAVE_FUNCS], [AC_CHECK_FUNCS]) + + + + +## ------------------------------------------- ## +## 2. Functions to check with AC_CHECK_FUNCS. ## +## ------------------------------------------- ## + +AN_FUNCTION([__argz_count], [AC_CHECK_FUNCS]) +AN_FUNCTION([__argz_next], [AC_CHECK_FUNCS]) +AN_FUNCTION([__argz_stringify], [AC_CHECK_FUNCS]) +AN_FUNCTION([__fpending], [AC_CHECK_FUNCS]) +AN_FUNCTION([acl], [AC_CHECK_FUNCS]) +AN_FUNCTION([alarm], [AC_CHECK_FUNCS]) +AN_FUNCTION([atexit], [AC_CHECK_FUNCS]) +AN_FUNCTION([btowc], [AC_CHECK_FUNCS]) +AN_FUNCTION([bzero], [AC_CHECK_FUNCS]) +AN_FUNCTION([clock_gettime], [AC_CHECK_FUNCS]) +AN_FUNCTION([doprnt], [AC_CHECK_FUNCS]) +AN_FUNCTION([dup2], [AC_CHECK_FUNCS]) +AN_FUNCTION([endgrent], [AC_CHECK_FUNCS]) +AN_FUNCTION([endpwent], [AC_CHECK_FUNCS]) +AN_FUNCTION([euidaccess], [AC_CHECK_FUNCS]) +AN_FUNCTION([fchdir], [AC_CHECK_FUNCS]) +AN_FUNCTION([fdatasync], [AC_CHECK_FUNCS]) +AN_FUNCTION([fesetround], [AC_CHECK_FUNCS]) +AN_FUNCTION([floor], [AC_CHECK_FUNCS]) +AN_FUNCTION([fs_stat_dev], [AC_CHECK_FUNCS]) +AN_FUNCTION([ftime], [AC_CHECK_FUNCS]) +AN_FUNCTION([ftruncate], [AC_CHECK_FUNCS]) +AN_FUNCTION([getcwd], [AC_CHECK_FUNCS]) +AN_FUNCTION([getdelim], [AC_CHECK_FUNCS]) +AN_FUNCTION([gethostbyaddr], [AC_CHECK_FUNCS]) +AN_FUNCTION([gethostbyname], [AC_CHECK_FUNCS]) +AN_FUNCTION([gethostname], [AC_CHECK_FUNCS]) +AN_FUNCTION([gethrtime], [AC_CHECK_FUNCS]) +AN_FUNCTION([getmntent], [AC_CHECK_FUNCS]) +AN_FUNCTION([getmntinfo], [AC_CHECK_FUNCS]) +AN_FUNCTION([getpagesize], [AC_CHECK_FUNCS]) +AN_FUNCTION([getpass], [AC_CHECK_FUNCS]) +AN_FUNCTION([getspnam], [AC_CHECK_FUNCS]) +AN_FUNCTION([gettimeofday], [AC_CHECK_FUNCS]) +AN_FUNCTION([getusershell], [AC_CHECK_FUNCS]) +AN_FUNCTION([hasmntopt], [AC_CHECK_FUNCS]) +AN_FUNCTION([inet_ntoa], [AC_CHECK_FUNCS]) +AN_FUNCTION([isascii], [AC_CHECK_FUNCS]) +AN_FUNCTION([iswprint], [AC_CHECK_FUNCS]) +AN_FUNCTION([lchown], [AC_CHECK_FUNCS]) +AN_FUNCTION([listmntent], [AC_CHECK_FUNCS]) +AN_FUNCTION([localeconv], [AC_CHECK_FUNCS]) +AN_FUNCTION([localtime_r], [AC_CHECK_FUNCS]) +AN_FUNCTION([mblen], [AC_CHECK_FUNCS]) +AN_FUNCTION([mbrlen], [AC_CHECK_FUNCS]) +AN_FUNCTION([memchr], [AC_CHECK_FUNCS]) +AN_FUNCTION([memmove], [AC_CHECK_FUNCS]) +AN_FUNCTION([mempcpy], [AC_CHECK_FUNCS]) +AN_FUNCTION([memset], [AC_CHECK_FUNCS]) +AN_FUNCTION([mkdir], [AC_CHECK_FUNCS]) +AN_FUNCTION([mkfifo], [AC_CHECK_FUNCS]) +AN_FUNCTION([modf], [AC_CHECK_FUNCS]) +AN_FUNCTION([munmap], [AC_CHECK_FUNCS]) +AN_FUNCTION([next_dev], [AC_CHECK_FUNCS]) +AN_FUNCTION([nl_langinfo], [AC_CHECK_FUNCS]) +AN_FUNCTION([pathconf], [AC_CHECK_FUNCS]) +AN_FUNCTION([pow], [AC_CHECK_FUNCS]) +AN_FUNCTION([pstat_getdynamic], [AC_CHECK_FUNCS]) +AN_FUNCTION([putenv], [AC_CHECK_FUNCS]) +AN_FUNCTION([re_comp], [AC_CHECK_FUNCS]) +AN_FUNCTION([realpath], [AC_CHECK_FUNCS]) +AN_FUNCTION([regcmp], [AC_CHECK_FUNCS]) +AN_FUNCTION([regcomp], [AC_CHECK_FUNCS]) +AN_FUNCTION([resolvepath], [AC_CHECK_FUNCS]) +AN_FUNCTION([rint], [AC_CHECK_FUNCS]) +AN_FUNCTION([rmdir], [AC_CHECK_FUNCS]) +AN_FUNCTION([rpmatch], [AC_CHECK_FUNCS]) +AN_FUNCTION([select], [AC_CHECK_FUNCS]) +AN_FUNCTION([setenv], [AC_CHECK_FUNCS]) +AN_FUNCTION([sethostname], [AC_CHECK_FUNCS]) +AN_FUNCTION([setlocale], [AC_CHECK_FUNCS]) +AN_FUNCTION([socket], [AC_CHECK_FUNCS]) +AN_FUNCTION([sqrt], [AC_CHECK_FUNCS]) +AN_FUNCTION([stime], [AC_CHECK_FUNCS]) +AN_FUNCTION([stpcpy], [AC_CHECK_FUNCS]) +AN_FUNCTION([strcasecmp], [AC_CHECK_FUNCS]) +AN_FUNCTION([strchr], [AC_CHECK_FUNCS]) +AN_FUNCTION([strcspn], [AC_CHECK_FUNCS]) +AN_FUNCTION([strdup], [AC_CHECK_FUNCS]) +AN_FUNCTION([strerror], [AC_CHECK_FUNCS]) +AN_FUNCTION([strncasecmp], [AC_CHECK_FUNCS]) +AN_FUNCTION([strndup], [AC_CHECK_FUNCS]) +AN_FUNCTION([strpbrk], [AC_CHECK_FUNCS]) +AN_FUNCTION([strrchr], [AC_CHECK_FUNCS]) +AN_FUNCTION([strspn], [AC_CHECK_FUNCS]) +AN_FUNCTION([strstr], [AC_CHECK_FUNCS]) +AN_FUNCTION([strtol], [AC_CHECK_FUNCS]) +AN_FUNCTION([strtoul], [AC_CHECK_FUNCS]) +AN_FUNCTION([strtoull], [AC_CHECK_FUNCS]) +AN_FUNCTION([strtoumax], [AC_CHECK_FUNCS]) +AN_FUNCTION([strverscmp], [AC_CHECK_FUNCS]) +AN_FUNCTION([sysinfo], [AC_CHECK_FUNCS]) +AN_FUNCTION([tzset], [AC_CHECK_FUNCS]) +AN_FUNCTION([uname], [AC_CHECK_FUNCS]) +AN_FUNCTION([utime], [AC_CHECK_FUNCS]) +AN_FUNCTION([utmpname], [AC_CHECK_FUNCS]) +AN_FUNCTION([utmpxname], [AC_CHECK_FUNCS]) +AN_FUNCTION([wcwidth], [AC_CHECK_FUNCS]) + + +AN_FUNCTION([dcgettext], [AM_GNU_GETTEXT]) +AN_FUNCTION([getwd], [warn: getwd is deprecated, use getcwd instead]) + + +## --------------------------------- ## +## 3. Tests for specific functions. ## +## --------------------------------- ## + + +# The macros are sorted: +# +# 1. AC_FUNC_* macros are sorted by alphabetical order. +# +# 2. Helping macros such as _AC_LIBOBJ_* are before the macro that +# uses it. +# +# 3. Obsolete macros are right after the modern macro. + + + +# _AC_LIBOBJ_ALLOCA +# ----------------- +# Set up the LIBOBJ replacement of `alloca'. Well, not exactly +# AC_LIBOBJ since we actually set the output variable `ALLOCA'. +# Nevertheless, for Automake, AC_LIBSOURCES it. +m4_define([_AC_LIBOBJ_ALLOCA], +[# The SVR3 libPW and SVR4 libucb both contain incompatible functions +# that cause trouble. Some versions do not even contain alloca or +# contain a buggy version. If you still want to use their alloca, +# use ar to extract alloca.o from them instead of compiling alloca.c. +AC_LIBSOURCES(alloca.c) +AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.$ac_objext])dnl +AC_DEFINE(C_ALLOCA, 1, [Define to 1 if using `alloca.c'.]) + +AC_CACHE_CHECK(whether `alloca.c' needs Cray hooks, ac_cv_os_cray, +[AC_EGREP_CPP(webecray, +[#if defined CRAY && ! defined CRAY2 +webecray +#else +wenotbecray +#endif +], ac_cv_os_cray=yes, ac_cv_os_cray=no)]) +if test $ac_cv_os_cray = yes; then + for ac_func in _getb67 GETB67 getb67; do + AC_CHECK_FUNC($ac_func, + [AC_DEFINE_UNQUOTED(CRAY_STACKSEG_END, $ac_func, + [Define to one of `_getb67', `GETB67', + `getb67' for Cray-2 and Cray-YMP + systems. This function is required for + `alloca.c' support on those systems.]) + break]) + done +fi + +AC_CACHE_CHECK([stack direction for C alloca], + [ac_cv_c_stack_direction], +[AC_RUN_IFELSE([AC_LANG_SOURCE( +[AC_INCLUDES_DEFAULT +int +find_stack_direction (int *addr, int depth) +{ + int dir, dummy = 0; + if (! addr) + addr = &dummy; + *addr = addr < &dummy ? 1 : addr == &dummy ? 0 : -1; + dir = depth ? find_stack_direction (addr, depth - 1) : 0; + return dir + dummy; +} + +int +main (int argc, char **argv) +{ + return find_stack_direction (0, argc + !argv + 20) < 0; +}])], + [ac_cv_c_stack_direction=1], + [ac_cv_c_stack_direction=-1], + [ac_cv_c_stack_direction=0])]) +AH_VERBATIM([STACK_DIRECTION], +[/* If using the C implementation of alloca, define if you know the + direction of stack growth for your system; otherwise it will be + automatically deduced at runtime. + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown */ +@%:@undef STACK_DIRECTION])dnl +AC_DEFINE_UNQUOTED(STACK_DIRECTION, $ac_cv_c_stack_direction) +])# _AC_LIBOBJ_ALLOCA + + +# AC_FUNC_ALLOCA +# -------------- +AN_FUNCTION([alloca], [AC_FUNC_ALLOCA]) +AN_HEADER([alloca.h], [AC_FUNC_ALLOCA]) +AC_DEFUN([AC_FUNC_ALLOCA], +[AC_REQUIRE([AC_TYPE_SIZE_T])]dnl +[# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works +# for constant arguments. Useless! +AC_CACHE_CHECK([for working alloca.h], ac_cv_working_alloca_h, +[AC_LINK_IFELSE( + [AC_LANG_PROGRAM([[@%:@include <alloca.h>]], + [[char *p = (char *) alloca (2 * sizeof (int)); + if (p) return 0;]])], + [ac_cv_working_alloca_h=yes], + [ac_cv_working_alloca_h=no])]) +if test $ac_cv_working_alloca_h = yes; then + AC_DEFINE(HAVE_ALLOCA_H, 1, + [Define to 1 if you have <alloca.h> and it should be used + (not on Ultrix).]) +fi + +AC_CACHE_CHECK([for alloca], ac_cv_func_alloca_works, +[AC_LINK_IFELSE([AC_LANG_PROGRAM( +[[#ifdef __GNUC__ +# define alloca __builtin_alloca +#else +# ifdef _MSC_VER +# include <malloc.h> +# define alloca _alloca +# else +# ifdef HAVE_ALLOCA_H +# include <alloca.h> +# else +# ifdef _AIX + #pragma alloca +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +void *alloca (size_t); +# endif +# endif +# endif +# endif +#endif +]], [[char *p = (char *) alloca (1); + if (p) return 0;]])], + [ac_cv_func_alloca_works=yes], + [ac_cv_func_alloca_works=no])]) + +if test $ac_cv_func_alloca_works = yes; then + AC_DEFINE(HAVE_ALLOCA, 1, + [Define to 1 if you have `alloca', as a function or macro.]) +else + _AC_LIBOBJ_ALLOCA +fi +])# AC_FUNC_ALLOCA + + +# AU::AC_ALLOCA +# ------------- +AU_ALIAS([AC_ALLOCA], [AC_FUNC_ALLOCA]) + + +# AC_FUNC_CHOWN +# ------------- +# Determine whether chown accepts arguments of -1 for uid and gid. +AN_FUNCTION([chown], [AC_FUNC_CHOWN]) +AC_DEFUN([AC_FUNC_CHOWN], +[AC_REQUIRE([AC_TYPE_UID_T])dnl +AC_CHECK_HEADERS(unistd.h) +AC_CACHE_CHECK([for working chown], ac_cv_func_chown_works, +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#include <fcntl.h> +], +[[ char *f = "conftest.chown"; + struct stat before, after; + + if (creat (f, 0600) < 0) + return 1; + if (stat (f, &before) < 0) + return 1; + if (chown (f, (uid_t) -1, (gid_t) -1) == -1) + return 1; + if (stat (f, &after) < 0) + return 1; + return ! (before.st_uid == after.st_uid && before.st_gid == after.st_gid); +]])], + [ac_cv_func_chown_works=yes], + [ac_cv_func_chown_works=no], + [ac_cv_func_chown_works=no]) +rm -f conftest.chown +]) +if test $ac_cv_func_chown_works = yes; then + AC_DEFINE(HAVE_CHOWN, 1, + [Define to 1 if your system has a working `chown' function.]) +fi +])# AC_FUNC_CHOWN + + +# AC_FUNC_CLOSEDIR_VOID +# --------------------- +# Check whether closedir returns void, and #define CLOSEDIR_VOID in +# that case. +AC_DEFUN([AC_FUNC_CLOSEDIR_VOID], +[AC_REQUIRE([AC_HEADER_DIRENT])dnl +AC_CACHE_CHECK([whether closedir returns void], + [ac_cv_func_closedir_void], +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT +#include <$ac_header_dirent> +#ifndef __cplusplus +int closedir (); +#endif +], + [[return closedir (opendir (".")) != 0;]])], + [ac_cv_func_closedir_void=no], + [ac_cv_func_closedir_void=yes], + [ac_cv_func_closedir_void=yes])]) +if test $ac_cv_func_closedir_void = yes; then + AC_DEFINE(CLOSEDIR_VOID, 1, + [Define to 1 if the `closedir' function returns void instead + of `int'.]) +fi +]) + + +# AC_FUNC_ERROR_AT_LINE +# --------------------- +AN_FUNCTION([error], [AC_FUNC_ERROR_AT_LINE]) +AN_FUNCTION([error_at_line], [AC_FUNC_ERROR_AT_LINE]) +AC_DEFUN([AC_FUNC_ERROR_AT_LINE], +[AC_LIBSOURCES([error.h, error.c])dnl +AC_CACHE_CHECK([for error_at_line], ac_cv_lib_error_at_line, +[AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <error.h>], + [error_at_line (0, 0, "", 0, "an error occurred");])], + [ac_cv_lib_error_at_line=yes], + [ac_cv_lib_error_at_line=no])]) +if test $ac_cv_lib_error_at_line = no; then + AC_LIBOBJ(error) +fi +]) + + +# AU::AM_FUNC_ERROR_AT_LINE +# ------------------------- +AU_ALIAS([AM_FUNC_ERROR_AT_LINE], [AC_FUNC_ERROR_AT_LINE]) + + +# _AC_FUNC_FNMATCH_IF(STANDARD = GNU | POSIX, CACHE_VAR, IF-TRUE, IF-FALSE) +# ------------------------------------------------------------------------- +# If a STANDARD compliant fnmatch is found, run IF-TRUE, otherwise +# IF-FALSE. Use CACHE_VAR. +AC_DEFUN([_AC_FUNC_FNMATCH_IF], +[AC_CACHE_CHECK( + [for working $1 fnmatch], + [$2], + [# Some versions of Solaris, SCO, and the GNU C Library + # have a broken or incompatible fnmatch. + # So we run a test program. If we are cross-compiling, take no chance. + # Thanks to John Oleynick, Franc,ois Pinard, and Paul Eggert for this test. + AC_RUN_IFELSE( + [AC_LANG_PROGRAM( + [#include <fnmatch.h> +# define y(a, b, c) (fnmatch (a, b, c) == 0) +# define n(a, b, c) (fnmatch (a, b, c) == FNM_NOMATCH) + ], + [return + (!(y ("a*", "abc", 0) + && n ("d*/*1", "d/s/1", FNM_PATHNAME) + && y ("a\\\\bc", "abc", 0) + && n ("a\\\\bc", "abc", FNM_NOESCAPE) + && y ("*x", ".x", 0) + && n ("*x", ".x", FNM_PERIOD) + && m4_if([$1], [GNU], + [y ("xxXX", "xXxX", FNM_CASEFOLD) + && y ("a++(x|yy)b", "a+xyyyyxb", FNM_EXTMATCH) + && n ("d*/*1", "d/s/1", FNM_FILE_NAME) + && y ("*", "x", FNM_FILE_NAME | FNM_LEADING_DIR) + && y ("x*", "x/y/z", FNM_FILE_NAME | FNM_LEADING_DIR) + && y ("*c*", "c/x", FNM_FILE_NAME | FNM_LEADING_DIR)], + 1)));])], + [$2=yes], + [$2=no], + [$2=cross])]) +AS_IF([test $$2 = yes], [$3], [$4]) +])# _AC_FUNC_FNMATCH_IF + + +# AC_FUNC_FNMATCH +# --------------- +AC_DEFUN([AC_FUNC_FNMATCH], +[_AC_FUNC_FNMATCH_IF([POSIX], [ac_cv_func_fnmatch_works], + [AC_DEFINE([HAVE_FNMATCH], 1, + [Define to 1 if your system has a working POSIX `fnmatch' + function.])]) +])# AC_FUNC_FNMATCH + + +# _AC_LIBOBJ_FNMATCH +# ------------------ +# Prepare the replacement of fnmatch. +AC_DEFUN([_AC_LIBOBJ_FNMATCH], +[AC_REQUIRE([AC_C_CONST])dnl +AC_REQUIRE([AC_FUNC_ALLOCA])dnl +AC_REQUIRE([AC_TYPE_MBSTATE_T])dnl +AC_CHECK_DECLS([getenv]) +AC_CHECK_FUNCS([btowc mbsrtowcs mempcpy wmempcpy]) +AC_CHECK_HEADERS([wchar.h wctype.h]) +AC_LIBOBJ([fnmatch]) +AC_CONFIG_LINKS([$ac_config_libobj_dir/fnmatch.h:$ac_config_libobj_dir/fnmatch_.h]) +AC_DEFINE(fnmatch, rpl_fnmatch, + [Define to rpl_fnmatch if the replacement function should be used.]) +])# _AC_LIBOBJ_FNMATCH + + +# AC_REPLACE_FNMATCH +# ------------------ +AC_DEFUN([AC_REPLACE_FNMATCH], +[_AC_FUNC_FNMATCH_IF([POSIX], [ac_cv_func_fnmatch_works], + [rm -f "$ac_config_libobj_dir/fnmatch.h"], + [_AC_LIBOBJ_FNMATCH]) +])# AC_REPLACE_FNMATCH + + +# AC_FUNC_FNMATCH_GNU +# ------------------- +AC_DEFUN([AC_FUNC_FNMATCH_GNU], +[AC_REQUIRE([AC_GNU_SOURCE]) +_AC_FUNC_FNMATCH_IF([GNU], [ac_cv_func_fnmatch_gnu], + [rm -f "$ac_config_libobj_dir/fnmatch.h"], + [_AC_LIBOBJ_FNMATCH]) +])# AC_FUNC_FNMATCH_GNU + + +# AU::AM_FUNC_FNMATCH +# AU::fp_FUNC_FNMATCH +# ------------------- +AU_ALIAS([AM_FUNC_FNMATCH], [AC_FUNC_FNMATCH]) +AU_ALIAS([fp_FUNC_FNMATCH], [AC_FUNC_FNMATCH]) + + +# AC_FUNC_FSEEKO +# -------------- +AN_FUNCTION([ftello], [AC_FUNC_FSEEKO]) +AN_FUNCTION([fseeko], [AC_FUNC_FSEEKO]) +AC_DEFUN([AC_FUNC_FSEEKO], +[_AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1, + [ac_cv_sys_largefile_source], + [Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2).], + [[#include <sys/types.h> /* for off_t */ + #include <stdio.h>]], + [[int (*fp) (FILE *, off_t, int) = fseeko; + return fseeko (stdin, 0, 0) && fp (stdin, 0, 0);]]) + +# We used to try defining _XOPEN_SOURCE=500 too, to work around a bug +# in glibc 2.1.3, but that breaks too many other things. +# If you want fseeko and ftello with glibc, upgrade to a fixed glibc. +if test $ac_cv_sys_largefile_source != unknown; then + AC_DEFINE(HAVE_FSEEKO, 1, + [Define to 1 if fseeko (and presumably ftello) exists and is declared.]) +fi +])# AC_FUNC_FSEEKO + + +# AC_FUNC_GETGROUPS +# ----------------- +# Try to find `getgroups', and check that it works. +# When cross-compiling, assume getgroups is broken. +AN_FUNCTION([getgroups], [AC_FUNC_GETGROUPS]) +AC_DEFUN([AC_FUNC_GETGROUPS], +[AC_REQUIRE([AC_TYPE_GETGROUPS])dnl +AC_REQUIRE([AC_TYPE_SIZE_T])dnl +AC_CHECK_FUNC(getgroups) + +# If we don't yet have getgroups, see if it's in -lbsd. +# This is reported to be necessary on an ITOS 3000WS running SEIUX 3.1. +ac_save_LIBS=$LIBS +if test $ac_cv_func_getgroups = no; then + AC_CHECK_LIB(bsd, getgroups, [GETGROUPS_LIB=-lbsd]) +fi + +# Run the program to test the functionality of the system-supplied +# getgroups function only if there is such a function. +if test $ac_cv_func_getgroups = yes; then + AC_CACHE_CHECK([for working getgroups], ac_cv_func_getgroups_works, + [AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [[/* On Ultrix 4.3, getgroups (0, 0) always fails. */ + return getgroups (0, 0) == -1;]])], + [ac_cv_func_getgroups_works=yes], + [ac_cv_func_getgroups_works=no], + [ac_cv_func_getgroups_works=no]) + ]) +else + ac_cv_func_getgroups_works=no +fi +if test $ac_cv_func_getgroups_works = yes; then + AC_DEFINE(HAVE_GETGROUPS, 1, + [Define to 1 if your system has a working `getgroups' function.]) +fi +LIBS=$ac_save_LIBS +])# AC_FUNC_GETGROUPS + + +# _AC_LIBOBJ_GETLOADAVG +# --------------------- +# Set up the AC_LIBOBJ replacement of `getloadavg'. +m4_define([_AC_LIBOBJ_GETLOADAVG], +[AC_LIBOBJ(getloadavg) +AC_DEFINE(C_GETLOADAVG, 1, [Define to 1 if using `getloadavg.c'.]) +# Figure out what our getloadavg.c needs. +ac_have_func=no +AC_CHECK_HEADER(sys/dg_sys_info.h, +[ac_have_func=yes + AC_DEFINE(DGUX, 1, [Define to 1 for DGUX with <sys/dg_sys_info.h>.]) + AC_CHECK_LIB(dgc, dg_sys_info)]) + +AC_CHECK_HEADER(locale.h) +AC_CHECK_FUNCS(setlocale) + +# We cannot check for <dwarf.h>, because Solaris 2 does not use dwarf (it +# uses stabs), but it is still SVR4. We cannot check for <elf.h> because +# Irix 4.0.5F has the header but not the library. +if test $ac_have_func = no && test "$ac_cv_lib_elf_elf_begin" = yes \ + && test "$ac_cv_lib_kvm_kvm_open" = yes; then + ac_have_func=yes + AC_DEFINE(SVR4, 1, [Define to 1 on System V Release 4.]) +fi + +if test $ac_have_func = no; then + AC_CHECK_HEADER(inq_stats/cpustats.h, + [ac_have_func=yes + AC_DEFINE(UMAX, 1, [Define to 1 for Encore UMAX.]) + AC_DEFINE(UMAX4_3, 1, + [Define to 1 for Encore UMAX 4.3 that has <inq_status/cpustats.h> + instead of <sys/cpustats.h>.])]) +fi + +if test $ac_have_func = no; then + AC_CHECK_HEADER(sys/cpustats.h, + [ac_have_func=yes; AC_DEFINE(UMAX)]) +fi + +if test $ac_have_func = no; then + AC_CHECK_HEADERS(mach/mach.h) +fi + +AC_CHECK_HEADERS(nlist.h, +[AC_CHECK_MEMBERS([struct nlist.n_un.n_name], + [AC_DEFINE(NLIST_NAME_UNION, 1, + [Define to 1 if your `struct nlist' has an + `n_un' member. Obsolete, depend on + `HAVE_STRUCT_NLIST_N_UN_N_NAME])], [], + [@%:@include <nlist.h>]) +])dnl +])# _AC_LIBOBJ_GETLOADAVG + + +# AC_FUNC_GETLOADAVG +# ------------------ +AC_DEFUN([AC_FUNC_GETLOADAVG], +[ac_have_func=no # yes means we've found a way to get the load average. + +# Make sure getloadavg.c is where it belongs, at configure-time. +test -f "$srcdir/$ac_config_libobj_dir/getloadavg.c" || + AC_MSG_ERROR([$srcdir/$ac_config_libobj_dir/getloadavg.c is missing]) + +ac_save_LIBS=$LIBS + +# Check for getloadavg, but be sure not to touch the cache variable. +(AC_CHECK_FUNC(getloadavg, exit 0, exit 1)) && ac_have_func=yes + +# On HPUX9, an unprivileged user can get load averages through this function. +AC_CHECK_FUNCS(pstat_getdynamic) + +# Solaris has libkstat which does not require root. +AC_CHECK_LIB(kstat, kstat_open) +test $ac_cv_lib_kstat_kstat_open = yes && ac_have_func=yes + +# Some systems with -lutil have (and need) -lkvm as well, some do not. +# On Solaris, -lkvm requires nlist from -lelf, so check that first +# to get the right answer into the cache. +# For kstat on solaris, we need libelf to force the definition of SVR4 below. +if test $ac_have_func = no; then + AC_CHECK_LIB(elf, elf_begin, LIBS="-lelf $LIBS") +fi +if test $ac_have_func = no; then + AC_CHECK_LIB(kvm, kvm_open, LIBS="-lkvm $LIBS") + # Check for the 4.4BSD definition of getloadavg. + AC_CHECK_LIB(util, getloadavg, + [LIBS="-lutil $LIBS" ac_have_func=yes ac_cv_func_getloadavg_setgid=yes]) +fi + +if test $ac_have_func = no; then + # There is a commonly available library for RS/6000 AIX. + # Since it is not a standard part of AIX, it might be installed locally. + ac_getloadavg_LIBS=$LIBS + LIBS="-L/usr/local/lib $LIBS" + AC_CHECK_LIB(getloadavg, getloadavg, + [LIBS="-lgetloadavg $LIBS"], [LIBS=$ac_getloadavg_LIBS]) +fi + +# Make sure it is really in the library, if we think we found it, +# otherwise set up the replacement function. +AC_CHECK_FUNCS(getloadavg, [], + [_AC_LIBOBJ_GETLOADAVG]) + +# Some definitions of getloadavg require that the program be installed setgid. +AC_CACHE_CHECK(whether getloadavg requires setgid, + ac_cv_func_getloadavg_setgid, +[AC_EGREP_CPP([Yowza Am I SETGID yet], +[#include "$srcdir/$ac_config_libobj_dir/getloadavg.c" +#ifdef LDAV_PRIVILEGED +Yowza Am I SETGID yet +@%:@endif], + ac_cv_func_getloadavg_setgid=yes, + ac_cv_func_getloadavg_setgid=no)]) +if test $ac_cv_func_getloadavg_setgid = yes; then + NEED_SETGID=true + AC_DEFINE(GETLOADAVG_PRIVILEGED, 1, + [Define to 1 if the `getloadavg' function needs to be run setuid + or setgid.]) +else + NEED_SETGID=false +fi +AC_SUBST(NEED_SETGID)dnl + +if test $ac_cv_func_getloadavg_setgid = yes; then + AC_CACHE_CHECK(group of /dev/kmem, ac_cv_group_kmem, +[ # On Solaris, /dev/kmem is a symlink. Get info on the real file. + ac_ls_output=`ls -lgL /dev/kmem 2>/dev/null` + # If we got an error (system does not support symlinks), try without -L. + test -z "$ac_ls_output" && ac_ls_output=`ls -lg /dev/kmem` + ac_cv_group_kmem=`AS_ECHO(["$ac_ls_output"]) \ + | sed -ne ['s/[ ][ ]*/ /g; + s/^.[sSrwx-]* *[0-9]* *\([^0-9]*\) *.*/\1/; + / /s/.* //;p;']` +]) + AC_SUBST(KMEM_GROUP, $ac_cv_group_kmem)dnl +fi +if test "x$ac_save_LIBS" = x; then + GETLOADAVG_LIBS=$LIBS +else + GETLOADAVG_LIBS=`AS_ECHO(["$LIBS"]) | sed "s|$ac_save_LIBS||"` +fi +LIBS=$ac_save_LIBS + +AC_SUBST(GETLOADAVG_LIBS)dnl +])# AC_FUNC_GETLOADAVG + + +# AU::AC_GETLOADAVG +# ----------------- +AU_ALIAS([AC_GETLOADAVG], [AC_FUNC_GETLOADAVG]) + + +# AC_FUNC_GETMNTENT +# ----------------- +AN_FUNCTION([getmntent], [AC_FUNC_GETMNTENT]) +AC_DEFUN([AC_FUNC_GETMNTENT], +[# getmntent is in the standard C library on UNICOS, in -lsun on Irix 4, +# -lseq on Dynix/PTX, -lgen on Unixware. +AC_SEARCH_LIBS(getmntent, [sun seq gen], + [ac_cv_func_getmntent=yes + AC_DEFINE([HAVE_GETMNTENT], 1, + [Define to 1 if you have the `getmntent' function.])], + [ac_cv_func_getmntent=no]) +]) + + +# AC_FUNC_GETPGRP +# --------------- +# Figure out whether getpgrp requires zero arguments. +AC_DEFUN([AC_FUNC_GETPGRP], +[AC_CACHE_CHECK(whether getpgrp requires zero arguments, + ac_cv_func_getpgrp_void, +[# Use it with a single arg. +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [getpgrp (0);])], + [ac_cv_func_getpgrp_void=no], + [ac_cv_func_getpgrp_void=yes]) +]) +if test $ac_cv_func_getpgrp_void = yes; then + AC_DEFINE(GETPGRP_VOID, 1, + [Define to 1 if the `getpgrp' function requires zero arguments.]) +fi +])# AC_FUNC_GETPGRP + + +# AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK +# ------------------------------------- +# When cross-compiling, be pessimistic so we will end up using the +# replacement version of lstat that checks for trailing slashes and +# calls lstat a second time when necessary. +AN_FUNCTION([lstat], [AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK]) +AC_DEFUN([AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK], +[AC_CACHE_CHECK( + [whether lstat correctly handles trailing slash], + [ac_cv_func_lstat_dereferences_slashed_symlink], +[rm -f conftest.sym conftest.file +echo >conftest.file +if test "$as_ln_s" = "ln -s" && ln -s conftest.file conftest.sym; then + AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [struct stat sbuf; + /* Linux will dereference the symlink and fail, as required by POSIX. + That is better in the sense that it means we will not + have to compile and use the lstat wrapper. */ + return lstat ("conftest.sym/", &sbuf) == 0;])], + [ac_cv_func_lstat_dereferences_slashed_symlink=yes], + [ac_cv_func_lstat_dereferences_slashed_symlink=no], + [ac_cv_func_lstat_dereferences_slashed_symlink=no]) +else + # If the `ln -s' command failed, then we probably don't even + # have an lstat function. + ac_cv_func_lstat_dereferences_slashed_symlink=no +fi +rm -f conftest.sym conftest.file +]) + +test $ac_cv_func_lstat_dereferences_slashed_symlink = yes && + AC_DEFINE_UNQUOTED([LSTAT_FOLLOWS_SLASHED_SYMLINK], [1], + [Define to 1 if `lstat' dereferences a symlink specified + with a trailing slash.]) + +if test "x$ac_cv_func_lstat_dereferences_slashed_symlink" = xno; then + AC_LIBOBJ([lstat]) +fi +]) + + +# _AC_FUNC_MALLOC_IF(IF-WORKS, IF-NOT) +# ------------------------------------ +# If `malloc (0)' properly handled, run IF-WORKS, otherwise, IF-NOT. +AC_DEFUN([_AC_FUNC_MALLOC_IF], +[AC_REQUIRE([AC_HEADER_STDC])dnl +AC_CHECK_HEADERS(stdlib.h) +AC_CACHE_CHECK([for GNU libc compatible malloc], ac_cv_func_malloc_0_nonnull, +[AC_RUN_IFELSE( +[AC_LANG_PROGRAM( +[[#if defined STDC_HEADERS || defined HAVE_STDLIB_H +# include <stdlib.h> +#else +char *malloc (); +#endif +]], + [return ! malloc (0);])], + [ac_cv_func_malloc_0_nonnull=yes], + [ac_cv_func_malloc_0_nonnull=no], + [ac_cv_func_malloc_0_nonnull=no])]) +AS_IF([test $ac_cv_func_malloc_0_nonnull = yes], [$1], [$2]) +])# _AC_FUNC_MALLOC_IF + + +# AC_FUNC_MALLOC +# -------------- +# Report whether `malloc (0)' properly handled, and replace malloc if +# needed. +AN_FUNCTION([malloc], [AC_FUNC_MALLOC]) +AC_DEFUN([AC_FUNC_MALLOC], +[_AC_FUNC_MALLOC_IF( + [AC_DEFINE([HAVE_MALLOC], 1, + [Define to 1 if your system has a GNU libc compatible `malloc' + function, and to 0 otherwise.])], + [AC_DEFINE([HAVE_MALLOC], 0) + AC_LIBOBJ(malloc) + AC_DEFINE([malloc], [rpl_malloc], + [Define to rpl_malloc if the replacement function should be used.])]) +])# AC_FUNC_MALLOC + + +# AC_FUNC_MBRTOWC +# --------------- +AN_FUNCTION([mbrtowc], [AC_FUNC_MBRTOWC]) +AC_DEFUN([AC_FUNC_MBRTOWC], +[ + AC_CACHE_CHECK([whether mbrtowc and mbstate_t are properly declared], + ac_cv_func_mbrtowc, + [AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[@%:@include <wchar.h>]], + [[wchar_t wc; + char const s[] = ""; + size_t n = 1; + mbstate_t state; + return ! (sizeof state && (mbrtowc) (&wc, s, n, &state));]])], + ac_cv_func_mbrtowc=yes, + ac_cv_func_mbrtowc=no)]) + if test $ac_cv_func_mbrtowc = yes; then + AC_DEFINE([HAVE_MBRTOWC], 1, + [Define to 1 if mbrtowc and mbstate_t are properly declared.]) + fi +]) + + +# AC_FUNC_MEMCMP +# -------------- +AC_DEFUN([AC_FUNC_MEMCMP], +[AC_CACHE_CHECK([for working memcmp], ac_cv_func_memcmp_working, +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [[ + /* Some versions of memcmp are not 8-bit clean. */ + char c0 = '\100', c1 = '\200', c2 = '\201'; + if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0) + return 1; + + /* The Next x86 OpenStep bug shows up only when comparing 16 bytes + or more and with at least one buffer not starting on a 4-byte boundary. + William Lewis provided this test program. */ + { + char foo[21]; + char bar[21]; + int i; + for (i = 0; i < 4; i++) + { + char *a = foo + i; + char *b = bar + i; + strcpy (a, "--------01111111"); + strcpy (b, "--------10000000"); + if (memcmp (a, b, 16) >= 0) + return 1; + } + return 0; + } +]])], + [ac_cv_func_memcmp_working=yes], + [ac_cv_func_memcmp_working=no], + [ac_cv_func_memcmp_working=no])]) +test $ac_cv_func_memcmp_working = no && AC_LIBOBJ([memcmp]) +])# AC_FUNC_MEMCMP + + +# AC_FUNC_MKTIME +# -------------- +AN_FUNCTION([mktime], [AC_FUNC_MKTIME]) +AC_DEFUN([AC_FUNC_MKTIME], +[AC_REQUIRE([AC_HEADER_TIME])dnl +AC_CHECK_HEADERS_ONCE(sys/time.h unistd.h) +AC_CHECK_FUNCS_ONCE(alarm) +AC_CACHE_CHECK([for working mktime], ac_cv_func_working_mktime, +[AC_RUN_IFELSE([AC_LANG_SOURCE( +[[/* Test program from Paul Eggert and Tony Leneis. */ +#ifdef TIME_WITH_SYS_TIME +# include <sys/time.h> +# include <time.h> +#else +# ifdef HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# include <time.h> +# endif +#endif + +#include <limits.h> +#include <stdlib.h> + +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif + +#ifndef HAVE_ALARM +# define alarm(X) /* empty */ +#endif + +/* Work around redefinition to rpl_putenv by other config tests. */ +#undef putenv + +static time_t time_t_max; +static time_t time_t_min; + +/* Values we'll use to set the TZ environment variable. */ +static const char *tz_strings[] = { + (const char *) 0, "TZ=GMT0", "TZ=JST-9", + "TZ=EST+3EDT+2,M10.1.0/00:00:00,M2.3.0/00:00:00" +}; +#define N_STRINGS (sizeof (tz_strings) / sizeof (tz_strings[0])) + +/* Return 0 if mktime fails to convert a date in the spring-forward gap. + Based on a problem report from Andreas Jaeger. */ +static int +spring_forward_gap () +{ + /* glibc (up to about 1998-10-07) failed this test. */ + struct tm tm; + + /* Use the portable POSIX.1 specification "TZ=PST8PDT,M4.1.0,M10.5.0" + instead of "TZ=America/Vancouver" in order to detect the bug even + on systems that don't support the Olson extension, or don't have the + full zoneinfo tables installed. */ + putenv ((char*) "TZ=PST8PDT,M4.1.0,M10.5.0"); + + tm.tm_year = 98; + tm.tm_mon = 3; + tm.tm_mday = 5; + tm.tm_hour = 2; + tm.tm_min = 0; + tm.tm_sec = 0; + tm.tm_isdst = -1; + return mktime (&tm) != (time_t) -1; +} + +static int +mktime_test1 (time_t now) +{ + struct tm *lt; + return ! (lt = localtime (&now)) || mktime (lt) == now; +} + +static int +mktime_test (time_t now) +{ + return (mktime_test1 (now) + && mktime_test1 ((time_t) (time_t_max - now)) + && mktime_test1 ((time_t) (time_t_min + now))); +} + +static int +irix_6_4_bug () +{ + /* Based on code from Ariel Faigon. */ + struct tm tm; + tm.tm_year = 96; + tm.tm_mon = 3; + tm.tm_mday = 0; + tm.tm_hour = 0; + tm.tm_min = 0; + tm.tm_sec = 0; + tm.tm_isdst = -1; + mktime (&tm); + return tm.tm_mon == 2 && tm.tm_mday == 31; +} + +static int +bigtime_test (int j) +{ + struct tm tm; + time_t now; + tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = j; + now = mktime (&tm); + if (now != (time_t) -1) + { + struct tm *lt = localtime (&now); + if (! (lt + && lt->tm_year == tm.tm_year + && lt->tm_mon == tm.tm_mon + && lt->tm_mday == tm.tm_mday + && lt->tm_hour == tm.tm_hour + && lt->tm_min == tm.tm_min + && lt->tm_sec == tm.tm_sec + && lt->tm_yday == tm.tm_yday + && lt->tm_wday == tm.tm_wday + && ((lt->tm_isdst < 0 ? -1 : 0 < lt->tm_isdst) + == (tm.tm_isdst < 0 ? -1 : 0 < tm.tm_isdst)))) + return 0; + } + return 1; +} + +static int +year_2050_test () +{ + /* The correct answer for 2050-02-01 00:00:00 in Pacific time, + ignoring leap seconds. */ + unsigned long int answer = 2527315200UL; + + struct tm tm; + time_t t; + tm.tm_year = 2050 - 1900; + tm.tm_mon = 2 - 1; + tm.tm_mday = 1; + tm.tm_hour = tm.tm_min = tm.tm_sec = 0; + tm.tm_isdst = -1; + + /* Use the portable POSIX.1 specification "TZ=PST8PDT,M4.1.0,M10.5.0" + instead of "TZ=America/Vancouver" in order to detect the bug even + on systems that don't support the Olson extension, or don't have the + full zoneinfo tables installed. */ + putenv ((char*) "TZ=PST8PDT,M4.1.0,M10.5.0"); + + t = mktime (&tm); + + /* Check that the result is either a failure, or close enough + to the correct answer that we can assume the discrepancy is + due to leap seconds. */ + return (t == (time_t) -1 + || (0 < t && answer - 120 <= t && t <= answer + 120)); +} + +int +main () +{ + time_t t, delta; + int i, j; + + /* This test makes some buggy mktime implementations loop. + Give up after 60 seconds; a mktime slower than that + isn't worth using anyway. */ + alarm (60); + + for (;;) + { + t = (time_t_max << 1) + 1; + if (t <= time_t_max) + break; + time_t_max = t; + } + time_t_min = - ((time_t) ~ (time_t) 0 == (time_t) -1) - time_t_max; + + delta = time_t_max / 997; /* a suitable prime number */ + for (i = 0; i < N_STRINGS; i++) + { + if (tz_strings[i]) + putenv ((char*) tz_strings[i]); + + for (t = 0; t <= time_t_max - delta; t += delta) + if (! mktime_test (t)) + return 1; + if (! (mktime_test ((time_t) 1) + && mktime_test ((time_t) (60 * 60)) + && mktime_test ((time_t) (60 * 60 * 24)))) + return 1; + + for (j = 1; ; j <<= 1) + if (! bigtime_test (j)) + return 1; + else if (INT_MAX / 2 < j) + break; + if (! bigtime_test (INT_MAX)) + return 1; + } + return ! (irix_6_4_bug () && spring_forward_gap () && year_2050_test ()); +}]])], + [ac_cv_func_working_mktime=yes], + [ac_cv_func_working_mktime=no], + [ac_cv_func_working_mktime=no])]) +if test $ac_cv_func_working_mktime = no; then + AC_LIBOBJ([mktime]) +fi +])# AC_FUNC_MKTIME + + +# AU::AM_FUNC_MKTIME +# ------------------ +AU_ALIAS([AM_FUNC_MKTIME], [AC_FUNC_MKTIME]) + + +# AC_FUNC_MMAP +# ------------ +AN_FUNCTION([mmap], [AC_FUNC_MMAP]) +AC_DEFUN([AC_FUNC_MMAP], +[AC_CHECK_HEADERS_ONCE([stdlib.h unistd.h sys/param.h]) +AC_CHECK_FUNCS([getpagesize]) +AC_CACHE_CHECK([for working mmap], [ac_cv_func_mmap_fixed_mapped], +[AC_RUN_IFELSE([AC_LANG_SOURCE([AC_INCLUDES_DEFAULT] +[[/* malloc might have been renamed as rpl_malloc. */ +#undef malloc + +/* Thanks to Mike Haertel and Jim Avera for this test. + Here is a matrix of mmap possibilities: + mmap private not fixed + mmap private fixed at somewhere currently unmapped + mmap private fixed at somewhere already mapped + mmap shared not fixed + mmap shared fixed at somewhere currently unmapped + mmap shared fixed at somewhere already mapped + For private mappings, we should verify that changes cannot be read() + back from the file, nor mmap's back from the file at a different + address. (There have been systems where private was not correctly + implemented like the infamous i386 svr4.0, and systems where the + VM page cache was not coherent with the file system buffer cache + like early versions of FreeBSD and possibly contemporary NetBSD.) + For shared mappings, we should conversely verify that changes get + propagated back to all the places they're supposed to be. + + Grep wants private fixed already mapped. + The main things grep needs to know about mmap are: + * does it exist and is it safe to write into the mmap'd area + * how to use it (BSD variants) */ + +#include <fcntl.h> +#include <sys/mman.h> + +#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H +char *malloc (); +#endif + +/* This mess was copied from the GNU getpagesize.h. */ +#ifndef HAVE_GETPAGESIZE +# ifdef _SC_PAGESIZE +# define getpagesize() sysconf(_SC_PAGESIZE) +# else /* no _SC_PAGESIZE */ +# ifdef HAVE_SYS_PARAM_H +# include <sys/param.h> +# ifdef EXEC_PAGESIZE +# define getpagesize() EXEC_PAGESIZE +# else /* no EXEC_PAGESIZE */ +# ifdef NBPG +# define getpagesize() NBPG * CLSIZE +# ifndef CLSIZE +# define CLSIZE 1 +# endif /* no CLSIZE */ +# else /* no NBPG */ +# ifdef NBPC +# define getpagesize() NBPC +# else /* no NBPC */ +# ifdef PAGESIZE +# define getpagesize() PAGESIZE +# endif /* PAGESIZE */ +# endif /* no NBPC */ +# endif /* no NBPG */ +# endif /* no EXEC_PAGESIZE */ +# else /* no HAVE_SYS_PARAM_H */ +# define getpagesize() 8192 /* punt totally */ +# endif /* no HAVE_SYS_PARAM_H */ +# endif /* no _SC_PAGESIZE */ + +#endif /* no HAVE_GETPAGESIZE */ + +int +main () +{ + char *data, *data2, *data3; + const char *cdata2; + int i, pagesize; + int fd, fd2; + + pagesize = getpagesize (); + + /* First, make a file with some known garbage in it. */ + data = (char *) malloc (pagesize); + if (!data) + return 1; + for (i = 0; i < pagesize; ++i) + *(data + i) = rand (); + umask (0); + fd = creat ("conftest.mmap", 0600); + if (fd < 0) + return 2; + if (write (fd, data, pagesize) != pagesize) + return 3; + close (fd); + + /* Next, check that the tail of a page is zero-filled. File must have + non-zero length, otherwise we risk SIGBUS for entire page. */ + fd2 = open ("conftest.txt", O_RDWR | O_CREAT | O_TRUNC, 0600); + if (fd2 < 0) + return 4; + cdata2 = ""; + if (write (fd2, cdata2, 1) != 1) + return 5; + data2 = (char *) mmap (0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0L); + if (data2 == MAP_FAILED) + return 6; + for (i = 0; i < pagesize; ++i) + if (*(data2 + i)) + return 7; + close (fd2); + if (munmap (data2, pagesize)) + return 8; + + /* Next, try to mmap the file at a fixed address which already has + something else allocated at it. If we can, also make sure that + we see the same garbage. */ + fd = open ("conftest.mmap", O_RDWR); + if (fd < 0) + return 9; + if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_FIXED, fd, 0L)) + return 10; + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data2 + i)) + return 11; + + /* Finally, make sure that changes to the mapped area do not + percolate back to the file as seen by read(). (This is a bug on + some variants of i386 svr4.0.) */ + for (i = 0; i < pagesize; ++i) + *(data2 + i) = *(data2 + i) + 1; + data3 = (char *) malloc (pagesize); + if (!data3) + return 12; + if (read (fd, data3, pagesize) != pagesize) + return 13; + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data3 + i)) + return 14; + close (fd); + return 0; +}]])], + [ac_cv_func_mmap_fixed_mapped=yes], + [ac_cv_func_mmap_fixed_mapped=no], + [ac_cv_func_mmap_fixed_mapped=no])]) +if test $ac_cv_func_mmap_fixed_mapped = yes; then + AC_DEFINE([HAVE_MMAP], [1], + [Define to 1 if you have a working `mmap' system call.]) +fi +rm -f conftest.mmap conftest.txt +])# AC_FUNC_MMAP + + +# AU::AC_MMAP +# ----------- +AU_ALIAS([AC_MMAP], [AC_FUNC_MMAP]) + + +# AC_FUNC_OBSTACK +# --------------- +# Ensure obstack support. Yeah, this is not exactly a `FUNC' check. +AN_FUNCTION([obstack_init], [AC_FUNC_OBSTACK]) +AN_IDENTIFIER([obstack], [AC_FUNC_OBSTACK]) +AC_DEFUN([AC_FUNC_OBSTACK], +[AC_LIBSOURCES([obstack.h, obstack.c])dnl +AC_CACHE_CHECK([for obstacks], ac_cv_func_obstack, +[AC_LINK_IFELSE( + [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT + [@%:@include "obstack.h"]], + [[struct obstack mem; + @%:@define obstack_chunk_alloc malloc + @%:@define obstack_chunk_free free + obstack_init (&mem); + obstack_free (&mem, 0);]])], + [ac_cv_func_obstack=yes], + [ac_cv_func_obstack=no])]) +if test $ac_cv_func_obstack = yes; then + AC_DEFINE(HAVE_OBSTACK, 1, [Define to 1 if libc includes obstacks.]) +else + AC_LIBOBJ(obstack) +fi +])# AC_FUNC_OBSTACK + + +# AU::AM_FUNC_OBSTACK +# ------------------- +AU_ALIAS([AM_FUNC_OBSTACK], [AC_FUNC_OBSTACK]) + + + +# _AC_FUNC_REALLOC_IF(IF-WORKS, IF-NOT) +# ------------------------------------- +# If `realloc (0, 0)' is properly handled, run IF-WORKS, otherwise, IF-NOT. +AC_DEFUN([_AC_FUNC_REALLOC_IF], +[AC_REQUIRE([AC_HEADER_STDC])dnl +AC_CHECK_HEADERS(stdlib.h) +AC_CACHE_CHECK([for GNU libc compatible realloc], ac_cv_func_realloc_0_nonnull, +[AC_RUN_IFELSE( +[AC_LANG_PROGRAM( +[[#if defined STDC_HEADERS || defined HAVE_STDLIB_H +# include <stdlib.h> +#else +char *realloc (); +#endif +]], + [return ! realloc (0, 0);])], + [ac_cv_func_realloc_0_nonnull=yes], + [ac_cv_func_realloc_0_nonnull=no], + [ac_cv_func_realloc_0_nonnull=no])]) +AS_IF([test $ac_cv_func_realloc_0_nonnull = yes], [$1], [$2]) +])# AC_FUNC_REALLOC + + +# AC_FUNC_REALLOC +# --------------- +# Report whether `realloc (0, 0)' is properly handled, and replace realloc if +# needed. +AN_FUNCTION([realloc], [AC_FUNC_REALLOC]) +AC_DEFUN([AC_FUNC_REALLOC], +[_AC_FUNC_REALLOC_IF( + [AC_DEFINE([HAVE_REALLOC], 1, + [Define to 1 if your system has a GNU libc compatible `realloc' + function, and to 0 otherwise.])], + [AC_DEFINE([HAVE_REALLOC], 0) + AC_LIBOBJ([realloc]) + AC_DEFINE([realloc], [rpl_realloc], + [Define to rpl_realloc if the replacement function should be used.])]) +])# AC_FUNC_REALLOC + + +# AC_FUNC_SELECT_ARGTYPES +# ----------------------- +# Determine the correct type to be passed to each of the `select' +# function's arguments, and define those types in `SELECT_TYPE_ARG1', +# `SELECT_TYPE_ARG234', and `SELECT_TYPE_ARG5'. +AC_DEFUN([AC_FUNC_SELECT_ARGTYPES], +[AC_CHECK_HEADERS(sys/select.h sys/socket.h) +AC_CACHE_CHECK([types of arguments for select], +[ac_cv_func_select_args], +[for ac_arg234 in 'fd_set *' 'int *' 'void *'; do + for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do + for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( +[AC_INCLUDES_DEFAULT +#ifdef HAVE_SYS_SELECT_H +# include <sys/select.h> +#endif +#ifdef HAVE_SYS_SOCKET_H +# include <sys/socket.h> +#endif +], + [extern int select ($ac_arg1, + $ac_arg234, $ac_arg234, $ac_arg234, + $ac_arg5);])], + [ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3]) + done + done +done +# Provide a safe default value. +: "${ac_cv_func_select_args=int,int *,struct timeval *}" +]) +ac_save_IFS=$IFS; IFS=',' +set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'` +IFS=$ac_save_IFS +shift +AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1, $[1], + [Define to the type of arg 1 for `select'.]) +AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234, ($[2]), + [Define to the type of args 2, 3 and 4 for `select'.]) +AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5, ($[3]), + [Define to the type of arg 5 for `select'.]) +rm -f conftest* +])# AC_FUNC_SELECT_ARGTYPES + + +# AC_FUNC_SETPGRP +# --------------- +AC_DEFUN([AC_FUNC_SETPGRP], +[AC_CACHE_CHECK(whether setpgrp takes no argument, ac_cv_func_setpgrp_void, +[AC_RUN_IFELSE( +[AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], +[/* If this system has a BSD-style setpgrp which takes arguments, + setpgrp(1, 1) will fail with ESRCH and return -1, in that case + exit successfully. */ + return setpgrp (1,1) != -1;])], + [ac_cv_func_setpgrp_void=no], + [ac_cv_func_setpgrp_void=yes], + [AC_MSG_ERROR([cannot check setpgrp when cross compiling])])]) +if test $ac_cv_func_setpgrp_void = yes; then + AC_DEFINE(SETPGRP_VOID, 1, + [Define to 1 if the `setpgrp' function takes no argument.]) +fi +])# AC_FUNC_SETPGRP + + +# _AC_FUNC_STAT(STAT | LSTAT) +# --------------------------- +# Determine whether stat or lstat have the bug that it succeeds when +# given the zero-length file name argument. The stat and lstat from +# SunOS4.1.4 and the Hurd (as of 1998-11-01) do this. +# +# If it does, then define HAVE_STAT_EMPTY_STRING_BUG (or +# HAVE_LSTAT_EMPTY_STRING_BUG) and arrange to compile the wrapper +# function. +m4_define([_AC_FUNC_STAT], +[AC_REQUIRE([AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK])dnl +AC_CACHE_CHECK([whether $1 accepts an empty string], + [ac_cv_func_$1_empty_string_bug], +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], +[[struct stat sbuf; + return $1 ("", &sbuf) == 0;]])], + [ac_cv_func_$1_empty_string_bug=no], + [ac_cv_func_$1_empty_string_bug=yes], + [ac_cv_func_$1_empty_string_bug=yes])]) +if test $ac_cv_func_$1_empty_string_bug = yes; then + AC_LIBOBJ([$1]) + AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$1_EMPTY_STRING_BUG]), 1, + [Define to 1 if `$1' has the bug that it succeeds when + given the zero-length file name argument.]) +fi +])# _AC_FUNC_STAT + + +# AC_FUNC_STAT & AC_FUNC_LSTAT +# ---------------------------- +AC_DEFUN([AC_FUNC_STAT], [_AC_FUNC_STAT(stat)]) +AC_DEFUN([AC_FUNC_LSTAT], [_AC_FUNC_STAT(lstat)]) + + +# _AC_LIBOBJ_STRTOD +# ----------------- +m4_define([_AC_LIBOBJ_STRTOD], +[AC_LIBOBJ(strtod) +AC_CHECK_FUNC(pow) +if test $ac_cv_func_pow = no; then + AC_CHECK_LIB(m, pow, + [POW_LIB=-lm], + [AC_MSG_WARN([cannot find library containing definition of pow])]) +fi +])# _AC_LIBOBJ_STRTOD + + +# AC_FUNC_STRTOD +# -------------- +AN_FUNCTION([strtod], [AC_FUNC_STRTOD]) +AC_DEFUN([AC_FUNC_STRTOD], +[AC_SUBST(POW_LIB)dnl +AC_CACHE_CHECK(for working strtod, ac_cv_func_strtod, +[AC_RUN_IFELSE([AC_LANG_SOURCE([[ +]AC_INCLUDES_DEFAULT[ +#ifndef strtod +double strtod (); +#endif +int +main() +{ + { + /* Some versions of Linux strtod mis-parse strings with leading '+'. */ + char *string = " +69"; + char *term; + double value; + value = strtod (string, &term); + if (value != 69 || term != (string + 4)) + return 1; + } + + { + /* Under Solaris 2.4, strtod returns the wrong value for the + terminating character under some conditions. */ + char *string = "NaN"; + char *term; + strtod (string, &term); + if (term != string && *(term - 1) == 0) + return 1; + } + return 0; +} +]])], + ac_cv_func_strtod=yes, + ac_cv_func_strtod=no, + ac_cv_func_strtod=no)]) +if test $ac_cv_func_strtod = no; then + _AC_LIBOBJ_STRTOD +fi +]) + + +# AC_FUNC_STRTOLD +# --------------- +AC_DEFUN([AC_FUNC_STRTOLD], +[ + AC_CACHE_CHECK([whether strtold conforms to C99], + [ac_cv_func_strtold], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[/* On HP-UX before 11.23, strtold returns a struct instead of + long double. Reject implementations like that, by requiring + compatibility with the C99 prototype. */ +# include <stdlib.h> + static long double (*p) (char const *, char **) = strtold; + static long double + test (char const *nptr, char **endptr) + { + long double r; + r = strtold (nptr, endptr); + return r; + }]], + [[return test ("1.0", NULL) != 1 || p ("1.0", NULL) != 1;]])], + [ac_cv_func_strtold=yes], + [ac_cv_func_strtold=no])]) + if test $ac_cv_func_strtold = yes; then + AC_DEFINE([HAVE_STRTOLD], 1, + [Define to 1 if strtold exists and conforms to C99.]) + fi +])# AC_FUNC_STRTOLD + + +# AU::AM_FUNC_STRTOD +# ------------------ +AU_ALIAS([AM_FUNC_STRTOD], [AC_FUNC_STRTOD]) + + +# AC_FUNC_STRERROR_R +# ------------------ +AN_FUNCTION([strerror_r], [AC_FUNC_STRERROR_R]) +AC_DEFUN([AC_FUNC_STRERROR_R], +[AC_CHECK_DECLS([strerror_r]) +AC_CHECK_FUNCS([strerror_r]) +AC_CACHE_CHECK([whether strerror_r returns char *], + ac_cv_func_strerror_r_char_p, + [ + ac_cv_func_strerror_r_char_p=no + if test $ac_cv_have_decl_strerror_r = yes; then + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [[ + char buf[100]; + char x = *strerror_r (0, buf, sizeof buf); + char *p = strerror_r (0, buf, sizeof buf); + return !p || x; + ]])], + ac_cv_func_strerror_r_char_p=yes) + else + # strerror_r is not declared. Choose between + # systems that have relatively inaccessible declarations for the + # function. BeOS and DEC UNIX 4.0 fall in this category, but the + # former has a strerror_r that returns char*, while the latter + # has a strerror_r that returns `int'. + # This test should segfault on the DEC system. + AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT + extern char *strerror_r ();], + [[char buf[100]; + char x = *strerror_r (0, buf, sizeof buf); + return ! isalpha (x);]])], + ac_cv_func_strerror_r_char_p=yes, , :) + fi + ]) +if test $ac_cv_func_strerror_r_char_p = yes; then + AC_DEFINE([STRERROR_R_CHAR_P], 1, + [Define to 1 if strerror_r returns char *.]) +fi +])# AC_FUNC_STRERROR_R + + +# AC_FUNC_STRFTIME +# ---------------- +AC_DEFUN([AC_FUNC_STRFTIME], +[AC_CHECK_FUNCS(strftime, [], +[# strftime is in -lintl on SCO UNIX. +AC_CHECK_LIB(intl, strftime, + [AC_DEFINE(HAVE_STRFTIME) +LIBS="-lintl $LIBS"])])dnl +])# AC_FUNC_STRFTIME + + +# AC_FUNC_STRNLEN +# --------------- +AN_FUNCTION([strnlen], [AC_FUNC_STRNLEN]) +AC_DEFUN([AC_FUNC_STRNLEN], +[AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])dnl +AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles +AC_CACHE_CHECK([for working strnlen], ac_cv_func_strnlen_working, +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [[ +#define S "foobar" +#define S_LEN (sizeof S - 1) + + /* At least one implementation is buggy: that of AIX 4.3 would + give strnlen (S, 1) == 3. */ + + int i; + for (i = 0; i < S_LEN + 1; ++i) + { + int expected = i <= S_LEN ? i : S_LEN; + if (strnlen (S, i) != expected) + return 1; + } + return 0; +]])], + [ac_cv_func_strnlen_working=yes], + [ac_cv_func_strnlen_working=no], + [# Guess no on AIX systems, yes otherwise. + case "$host_os" in + aix*) ac_cv_func_strnlen_working=no;; + *) ac_cv_func_strnlen_working=yes;; + esac])]) +test $ac_cv_func_strnlen_working = no && AC_LIBOBJ([strnlen]) +])# AC_FUNC_STRNLEN + + +# AC_FUNC_SETVBUF_REVERSED +# ------------------------ +AC_DEFUN([AC_FUNC_SETVBUF_REVERSED], +[AC_DIAGNOSE([obsolete], +[The macro `$0' is obsolete. Remove it and all references to SETVBUF_REVERSED.])dnl +AC_CACHE_VAL([ac_cv_func_setvbuf_reversed], [ac_cv_func_setvbuf_reversed=no]) +])# AC_FUNC_SETVBUF_REVERSED + + +# AU::AC_SETVBUF_REVERSED +# ----------------------- +AU_ALIAS([AC_SETVBUF_REVERSED], [AC_FUNC_SETVBUF_REVERSED]) + + +# AC_FUNC_STRCOLL +# --------------- +AN_FUNCTION([strcoll], [AC_FUNC_STRCOLL]) +AC_DEFUN([AC_FUNC_STRCOLL], +[AC_CACHE_CHECK(for working strcoll, ac_cv_func_strcoll_works, +[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [[return (strcoll ("abc", "def") >= 0 || + strcoll ("ABC", "DEF") >= 0 || + strcoll ("123", "456") >= 0)]])], + ac_cv_func_strcoll_works=yes, + ac_cv_func_strcoll_works=no, + ac_cv_func_strcoll_works=no)]) +if test $ac_cv_func_strcoll_works = yes; then + AC_DEFINE(HAVE_STRCOLL, 1, + [Define to 1 if you have the `strcoll' function and it is properly + defined.]) +fi +])# AC_FUNC_STRCOLL + + +# AU::AC_STRCOLL +# -------------- +AU_ALIAS([AC_STRCOLL], [AC_FUNC_STRCOLL]) + + +# AC_FUNC_UTIME_NULL +# ------------------ +AC_DEFUN([AC_FUNC_UTIME_NULL], +[AC_CHECK_HEADERS_ONCE(utime.h) +AC_CACHE_CHECK(whether utime accepts a null argument, ac_cv_func_utime_null, +[rm -f conftest.data; >conftest.data +# Sequent interprets utime(file, 0) to mean use start of epoch. Wrong. +AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT + #ifdef HAVE_UTIME_H + # include <utime.h> + #endif], +[[struct stat s, t; + return ! (stat ("conftest.data", &s) == 0 + && utime ("conftest.data", 0) == 0 + && stat ("conftest.data", &t) == 0 + && t.st_mtime >= s.st_mtime + && t.st_mtime - s.st_mtime < 120);]])], + ac_cv_func_utime_null=yes, + ac_cv_func_utime_null=no, + ac_cv_func_utime_null='guessing yes')]) +if test "x$ac_cv_func_utime_null" != xno; then + ac_cv_func_utime_null=yes + AC_DEFINE(HAVE_UTIME_NULL, 1, + [Define to 1 if `utime(file, NULL)' sets file's timestamp to the + present.]) +fi +rm -f conftest.data +])# AC_FUNC_UTIME_NULL + + +# AU::AC_UTIME_NULL +# ----------------- +AU_ALIAS([AC_UTIME_NULL], [AC_FUNC_UTIME_NULL]) + + +# AC_FUNC_FORK +# ------------ +AN_FUNCTION([fork], [AC_FUNC_FORK]) +AN_FUNCTION([vfork], [AC_FUNC_FORK]) +AC_DEFUN([AC_FUNC_FORK], +[AC_REQUIRE([AC_TYPE_PID_T])dnl +AC_CHECK_HEADERS(vfork.h) +AC_CHECK_FUNCS(fork vfork) +if test "x$ac_cv_func_fork" = xyes; then + _AC_FUNC_FORK +else + ac_cv_func_fork_works=$ac_cv_func_fork +fi +if test "x$ac_cv_func_fork_works" = xcross; then + case $host in + *-*-amigaos* | *-*-msdosdjgpp*) + # Override, as these systems have only a dummy fork() stub + ac_cv_func_fork_works=no + ;; + *) + ac_cv_func_fork_works=yes + ;; + esac + AC_MSG_WARN([result $ac_cv_func_fork_works guessed because of cross compilation]) +fi +ac_cv_func_vfork_works=$ac_cv_func_vfork +if test "x$ac_cv_func_vfork" = xyes; then + _AC_FUNC_VFORK +fi; +if test "x$ac_cv_func_fork_works" = xcross; then + ac_cv_func_vfork_works=$ac_cv_func_vfork + AC_MSG_WARN([result $ac_cv_func_vfork_works guessed because of cross compilation]) +fi + +if test "x$ac_cv_func_vfork_works" = xyes; then + AC_DEFINE(HAVE_WORKING_VFORK, 1, [Define to 1 if `vfork' works.]) +else + AC_DEFINE(vfork, fork, [Define as `fork' if `vfork' does not work.]) +fi +if test "x$ac_cv_func_fork_works" = xyes; then + AC_DEFINE(HAVE_WORKING_FORK, 1, [Define to 1 if `fork' works.]) +fi +])# AC_FUNC_FORK + + +# _AC_FUNC_FORK +# ------------- +AC_DEFUN([_AC_FUNC_FORK], + [AC_CACHE_CHECK(for working fork, ac_cv_func_fork_works, + [AC_RUN_IFELSE( + [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], + [ + /* By Ruediger Kuhlmann. */ + return fork () < 0; + ])], + [ac_cv_func_fork_works=yes], + [ac_cv_func_fork_works=no], + [ac_cv_func_fork_works=cross])])] +)# _AC_FUNC_FORK + + +# _AC_FUNC_VFORK +# -------------- +AC_DEFUN([_AC_FUNC_VFORK], +[AC_CACHE_CHECK(for working vfork, ac_cv_func_vfork_works, +[AC_RUN_IFELSE([AC_LANG_SOURCE([[/* Thanks to Paul Eggert for this test. */ +]AC_INCLUDES_DEFAULT[ +#include <sys/wait.h> +#ifdef HAVE_VFORK_H +# include <vfork.h> +#endif +/* On some sparc systems, changes by the child to local and incoming + argument registers are propagated back to the parent. The compiler + is told about this with #include <vfork.h>, but some compilers + (e.g. gcc -O) don't grok <vfork.h>. Test for this by using a + static variable whose address is put into a register that is + clobbered by the vfork. */ +static void +#ifdef __cplusplus +sparc_address_test (int arg) +# else +sparc_address_test (arg) int arg; +#endif +{ + static pid_t child; + if (!child) { + child = vfork (); + if (child < 0) { + perror ("vfork"); + _exit(2); + } + if (!child) { + arg = getpid(); + write(-1, "", 0); + _exit (arg); + } + } +} + +int +main () +{ + pid_t parent = getpid (); + pid_t child; + + sparc_address_test (0); + + child = vfork (); + + if (child == 0) { + /* Here is another test for sparc vfork register problems. This + test uses lots of local variables, at least as many local + variables as main has allocated so far including compiler + temporaries. 4 locals are enough for gcc 1.40.3 on a Solaris + 4.1.3 sparc, but we use 8 to be safe. A buggy compiler should + reuse the register of parent for one of the local variables, + since it will think that parent can't possibly be used any more + in this routine. Assigning to the local variable will thus + munge parent in the parent process. */ + pid_t + p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), + p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); + /* Convince the compiler that p..p7 are live; otherwise, it might + use the same hardware register for all 8 local variables. */ + if (p != p1 || p != p2 || p != p3 || p != p4 + || p != p5 || p != p6 || p != p7) + _exit(1); + + /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent + from child file descriptors. If the child closes a descriptor + before it execs or exits, this munges the parent's descriptor + as well. Test for this by closing stdout in the child. */ + _exit(close(fileno(stdout)) != 0); + } else { + int status; + struct stat st; + + while (wait(&status) != child) + ; + return ( + /* Was there some problem with vforking? */ + child < 0 + + /* Did the child fail? (This shouldn't happen.) */ + || status + + /* Did the vfork/compiler bug occur? */ + || parent != getpid() + + /* Did the file descriptor bug occur? */ + || fstat(fileno(stdout), &st) != 0 + ); + } +}]])], + [ac_cv_func_vfork_works=yes], + [ac_cv_func_vfork_works=no], + [ac_cv_func_vfork_works=cross])]) +])# _AC_FUNC_VFORK + + +# AU::AC_FUNC_VFORK +# ----------------- +AU_ALIAS([AC_FUNC_VFORK], [AC_FUNC_FORK]) + +# AU::AC_VFORK +# ------------ +AU_ALIAS([AC_VFORK], [AC_FUNC_FORK]) + + +# AC_FUNC_VPRINTF +# --------------- +# Why the heck is that _doprnt does not define HAVE__DOPRNT??? +# That the logical name! +AC_DEFUN([AC_FUNC_VPRINTF], +[AC_CHECK_FUNCS(vprintf, [] +[AC_CHECK_FUNC(_doprnt, + [AC_DEFINE(HAVE_DOPRNT, 1, + [Define to 1 if you don't have `vprintf' but do have + `_doprnt.'])])]) +]) + + +# AU::AC_VPRINTF +# -------------- +AU_ALIAS([AC_VPRINTF], [AC_FUNC_VPRINTF]) + + +# AC_FUNC_WAIT3 +# ------------- +# Don't bother too hard maintaining this macro, as it's obsoleted. +# We don't AU define it, since we don't have any alternative to propose, +# any invocation should be removed, and the code adjusted. +AN_FUNCTION([wait3], [AC_FUNC_WAIT3]) +AC_DEFUN([AC_FUNC_WAIT3], +[AC_DIAGNOSE([obsolete], +[$0: `wait3' has been removed from POSIX. +Remove this `AC_FUNC_WAIT3' and adjust your code to use `waitpid' instead.])dnl +AC_CACHE_CHECK([for wait3 that fills in rusage], + [ac_cv_func_wait3_rusage], +[AC_RUN_IFELSE([AC_LANG_SOURCE( +[AC_INCLUDES_DEFAULT[ +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/wait.h> +/* HP-UX has wait3 but does not fill in rusage at all. */ +int +main () +{ + struct rusage r; + int i; + /* Use a field that we can force nonzero -- + voluntary context switches. + For systems like NeXT and OSF/1 that don't set it, + also use the system CPU time. And page faults (I/O) for Linux. */ + r.ru_nvcsw = 0; + r.ru_stime.tv_sec = 0; + r.ru_stime.tv_usec = 0; + r.ru_majflt = r.ru_minflt = 0; + switch (fork ()) + { + case 0: /* Child. */ + sleep(1); /* Give up the CPU. */ + _exit(0); + break; + case -1: /* What can we do? */ + _exit(0); + break; + default: /* Parent. */ + wait3(&i, 0, &r); + /* Avoid "text file busy" from rm on fast HP-UX machines. */ + sleep(2); + return (r.ru_nvcsw == 0 && r.ru_majflt == 0 && r.ru_minflt == 0 + && r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0); + } +}]])], + [ac_cv_func_wait3_rusage=yes], + [ac_cv_func_wait3_rusage=no], + [ac_cv_func_wait3_rusage=no])]) +if test $ac_cv_func_wait3_rusage = yes; then + AC_DEFINE(HAVE_WAIT3, 1, + [Define to 1 if you have the `wait3' system call. + Deprecated, you should no longer depend upon `wait3'.]) +fi +])# AC_FUNC_WAIT3 + + +# AU::AC_WAIT3 +# ------------ +AU_ALIAS([AC_WAIT3], [AC_FUNC_WAIT3]) diff --git a/lib/autoconf/general.m4 b/lib/autoconf/general.m4 new file mode 100644 index 0000000..adfae1d --- /dev/null +++ b/lib/autoconf/general.m4 @@ -0,0 +1,3081 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Parameterized macros. +m4_define([_AC_COPYRIGHT_YEARS], [ +Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +]) + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +## ---------------- ## +## The diversions. ## +## ---------------- ## + + +# We heavily use m4's diversions both for the initializations and for +# required macros (see AC_REQUIRE), because in both cases we have to +# issue high in `configure' something which is discovered late. +# +# KILL is only used to suppress output. +# +# The layers of `configure'. We let m4 undivert them by itself, when +# it reaches the end of `configure.ac'. +# +# - BINSH +# #! /bin/sh +# - HEADER-REVISION +# Sent by AC_REVISION +# - HEADER-COMMENT +# Purpose of the script. +# - HEADER-COPYRIGHT +# Copyright notice(s) +# - M4SH-INIT +# Initialization of bottom layers. +# +# - DEFAULTS +# early initializations (defaults) +# - PARSE_ARGS +# initialization code, option handling loop. +# +# - HELP_BEGIN +# Handling `configure --help'. +# - HELP_CANON +# Help msg for AC_CANONICAL_* +# - HELP_ENABLE +# Help msg from AC_ARG_ENABLE. +# - HELP_WITH +# Help msg from AC_ARG_WITH. +# - HELP_VAR +# Help msg from AC_ARG_VAR. +# - HELP_VAR_END +# A small paragraph on the use of the variables. +# - HELP_END +# Tail of the handling of --help. +# +# - VERSION_BEGIN +# Head of the handling of --version. +# - VERSION_FSF +# FSF copyright notice for --version. +# - VERSION_USER +# User copyright notice for --version. +# - VERSION_END +# Tail of the handling of --version. +# +# - SHELL_FN +# Shell functions. +# +# - INIT_PREPARE +# Tail of initialization code. +# +# - BODY +# the tests and output code +# + + +# _m4_divert(DIVERSION-NAME) +# -------------------------- +# Convert a diversion name into its number. Otherwise, return +# DIVERSION-NAME which is supposed to be an actual diversion number. +# Of course it would be nicer to use m4_case here, instead of zillions +# of little macros, but it then takes twice longer to run `autoconf'! +# +# From M4sugar: +# -1. KILL +# 10000. GROW +# +# From M4sh: +# 0. BINSH +# 1. HEADER-REVISION +# 2. HEADER-COMMENT +# 3. HEADER-COPYRIGHT +# 4. M4SH-INIT +# 1000. BODY +m4_define([_m4_divert(DEFAULTS)], 10) +m4_define([_m4_divert(PARSE_ARGS)], 20) + +m4_define([_m4_divert(HELP_BEGIN)], 100) +m4_define([_m4_divert(HELP_CANON)], 101) +m4_define([_m4_divert(HELP_ENABLE)], 102) +m4_define([_m4_divert(HELP_WITH)], 103) +m4_define([_m4_divert(HELP_VAR)], 104) +m4_define([_m4_divert(HELP_VAR_END)], 105) +m4_define([_m4_divert(HELP_END)], 106) + +m4_define([_m4_divert(VERSION_BEGIN)], 200) +m4_define([_m4_divert(VERSION_FSF)], 201) +m4_define([_m4_divert(VERSION_USER)], 202) +m4_define([_m4_divert(VERSION_END)], 203) + +m4_define([_m4_divert(SHELL_FN)], 250) + +m4_define([_m4_divert(INIT_PREPARE)], 300) + + + +# AC_DIVERT_PUSH(DIVERSION-NAME) +# AC_DIVERT_POP +# ------------------------------ +m4_copy([m4_divert_push],[AC_DIVERT_PUSH]) +m4_copy([m4_divert_pop], [AC_DIVERT_POP]) + + + +## ------------------------------------ ## +## Defining/requiring Autoconf macros. ## +## ------------------------------------ ## + + +# AC_DEFUN(NAME, EXPANSION) +# AC_DEFUN_ONCE(NAME, EXPANSION) +# AC_BEFORE(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# AC_REQUIRE(STRING) +# AC_PROVIDE(MACRO-NAME) +# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ----------------------------------------------------------- +m4_copy([m4_defun], [AC_DEFUN]) +m4_copy([m4_defun_once], [AC_DEFUN_ONCE]) +m4_copy([m4_before], [AC_BEFORE]) +m4_copy([m4_require], [AC_REQUIRE]) +m4_copy([m4_provide], [AC_PROVIDE]) +m4_copy([m4_provide_if], [AC_PROVIDE_IFELSE]) + + +# AC_OBSOLETE(THIS-MACRO-NAME, [SUGGESTION]) +# ------------------------------------------ +m4_define([AC_OBSOLETE], +[AC_DIAGNOSE([obsolete], [$1 is obsolete$2])]) + + + +## ----------------------------- ## +## Implementing shell functions. ## +## ----------------------------- ## + + +# AC_REQUIRE_SHELL_FN(NAME-TO-CHECK, COMMENT, BODY, [DIVERSION = SHELL_FN] +# ------------------------------------------------------------------------ +# Same as AS_REQUIRE_SHELL_FN except that the default diversion comes +# later in the script (speeding up configure --help and --version). +AC_DEFUN([AC_REQUIRE_SHELL_FN], +[AS_REQUIRE_SHELL_FN([$1], [$2], [$3], m4_default_quoted([$4], [SHELL_FN]))]) + + + +## ----------------------------- ## +## Implementing Autoconf loops. ## +## ----------------------------- ## + + +# AU::AC_FOREACH(VARIABLE, LIST, EXPRESSION) +# ------------------------------------------ +AU_DEFUN([AC_FOREACH], [[m4_foreach_w($@)]]) +AC_DEFUN([AC_FOREACH], [m4_foreach_w($@)dnl +AC_DIAGNOSE([obsolete], [The macro `AC_FOREACH' is obsolete. +You should run autoupdate.])]) + + + +## ----------------------------------- ## +## Helping macros to display strings. ## +## ----------------------------------- ## + + +# AU::AC_HELP_STRING(LHS, RHS, [COLUMN]) +# -------------------------------------- +AU_ALIAS([AC_HELP_STRING], [AS_HELP_STRING]) + + + +## ---------------------------------------------- ## +## Information on the package being Autoconf'ed. ## +## ---------------------------------------------- ## + + +# It is suggested that the macros in this section appear before +# AC_INIT in `configure.ac'. Nevertheless, this is just stylistic, +# and from the implementation point of view, AC_INIT *must* be expanded +# beforehand: it puts data in diversions which must appear before the +# data provided by the macros of this section. + +# The solution is to require AC_INIT in each of these macros. AC_INIT +# has the needed magic so that it can't be expanded twice. + +# _AC_INIT_LITERAL(STRING) +# ------------------------ +# Reject STRING if it contains newline, or if it cannot be used as-is +# in single-quoted strings, double-quoted strings, and quoted and +# unquoted here-docs. +m4_define([_AC_INIT_LITERAL], +[m4_if(m4_index(m4_translit([[$1]], [ +""], ['']), ['])AS_LITERAL_HEREDOC_IF([$1], [-]), [-1-], [], + [m4_warn([syntax], [AC_INIT: not a literal: $1])])]) + +# _AC_INIT_PACKAGE(PACKAGE-NAME, VERSION, BUG-REPORT, [TARNAME], [URL]) +# --------------------------------------------------------------------- +m4_define([_AC_INIT_PACKAGE], +[_AC_INIT_LITERAL([$1]) +_AC_INIT_LITERAL([$2]) +_AC_INIT_LITERAL([$3]) +m4_ifndef([AC_PACKAGE_NAME], + [m4_define([AC_PACKAGE_NAME], [$1])]) +m4_ifndef([AC_PACKAGE_TARNAME], + [m4_define([AC_PACKAGE_TARNAME], + m4_default([$4], + [m4_bpatsubst(m4_tolower(m4_bpatsubst([[$1]], + [GNU ])), + [[^_abcdefghijklmnopqrstuvwxyz0123456789]], + [-])]))]) +m4_ifndef([AC_PACKAGE_VERSION], + [m4_define([AC_PACKAGE_VERSION], [$2])]) +m4_ifndef([AC_PACKAGE_STRING], + [m4_define([AC_PACKAGE_STRING], [$1 $2])]) +m4_ifndef([AC_PACKAGE_BUGREPORT], + [m4_define([AC_PACKAGE_BUGREPORT], [$3])]) +m4_ifndef([AC_PACKAGE_URL], + [m4_define([AC_PACKAGE_URL], + m4_if([$5], [], [m4_if(m4_index([$1], [GNU ]), [0], + [[http://www.gnu.org/software/]m4_defn([AC_PACKAGE_TARNAME])[/]])], + [[$5]]))]) +]) + + +# AC_COPYRIGHT(TEXT, [VERSION-DIVERSION = VERSION_USER], +# [FILTER = m4_newline]) +# ------------------------------------------------------ +# Emit TEXT, a copyright notice, in the top of `configure' and in +# --version output. Macros in TEXT are evaluated once. Process +# the --version output through FILTER (m4_newline, m4_do, and +# m4_copyright_condense are common filters). +m4_define([AC_COPYRIGHT], +[AS_COPYRIGHT([$1])[]]dnl +[m4_divert_text(m4_default_quoted([$2], [VERSION_USER]), +[m4_default([$3], [m4_newline])([$1])])])# AC_COPYRIGHT + + +# AC_REVISION(REVISION-INFO) +# -------------------------- +# The second quote in the translit is just to cope with font-lock-mode +# which sees the opening of a string. +m4_define([AC_REVISION], +[m4_divert_text([HEADER-REVISION], + [@%:@ From __file__ m4_translit([$1], [$""]).])dnl +]) + + + + +## ---------------------------------------- ## +## Requirements over the Autoconf version. ## +## ---------------------------------------- ## + + +# AU::AC_PREREQ(VERSION) +# ---------------------- +# Update this `AC_PREREQ' statement to require the current version of +# Autoconf. But fail if ever this autoupdate is too old. +# +# Note that `m4_defn([m4_PACKAGE_VERSION])' below are expanded before +# calling `AU_DEFUN', i.e., it is hard coded. Otherwise it would be +# quite complex for autoupdate to import the value of +# `m4_PACKAGE_VERSION'. We could `AU_DEFUN' `m4_PACKAGE_VERSION', but +# this would replace all its occurrences with the current version of +# Autoconf, which is certainly not what the user intended. +AU_DEFUN([AC_PREREQ], +[m4_version_prereq([$1])[]dnl +[AC_PREREQ(]]m4_dquote(m4_dquote(m4_defn([m4_PACKAGE_VERSION])))[[)]]) + + +# AC_PREREQ(VERSION) +# ------------------ +# Complain and exit if the Autoconf version is less than VERSION. +m4_undefine([AC_PREREQ]) +m4_copy([m4_version_prereq], [AC_PREREQ]) + + +# AC_AUTOCONF_VERSION +# ------------------- +# The current version of Autoconf parsing this file. +m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION]) + + + + + +## ---------------- ## +## Initialization. ## +## ---------------- ## + + +# All the following macros are used by AC_INIT. Ideally, they should +# be presented in the order in which they are output. Please, help us +# sorting it, or at least, don't augment the entropy. + + +# _AC_INIT_NOTICE +# --------------- +# Provide useful headers; override the HEADER-COMMENT created by M4sh. +m4_define([_AC_INIT_NOTICE], +[m4_cleardivert([HEADER-COMMENT])]dnl +[m4_divert_text([HEADER-COMMENT], +[@%:@ Guess values for system-dependent variables and create Makefiles. +@%:@ Generated by m4_PACKAGE_STRING[]dnl +m4_ifset([AC_PACKAGE_STRING], [ for AC_PACKAGE_STRING]).]) + +m4_ifset([AC_PACKAGE_BUGREPORT], + [m4_divert_text([HEADER-COMMENT], + [@%:@ +@%:@ Report bugs to <AC_PACKAGE_BUGREPORT>.])]) +]) + + +# _AC_INIT_COPYRIGHT +# ------------------ +# We dump to VERSION_FSF to make sure we are inserted before the +# user copyrights, and after the setup of the --version handling. +m4_define([_AC_INIT_COPYRIGHT], +[AC_COPYRIGHT(m4_defn([_AC_COPYRIGHT_YEARS]), [VERSION_FSF], [ +m4_copyright_condense])dnl +AC_COPYRIGHT( +[This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it.], + [VERSION_FSF], [m4_echo])]) + + +# File Descriptors +# ---------------- +# Set up the file descriptors used by `configure'. +# File descriptor usage: +# 0 standard input (/dev/null) +# 1 file creation +# 2 errors and warnings +# AS_MESSAGE_LOG_FD compiler messages saved in config.log +# AS_MESSAGE_FD checking for... messages and results +# AS_ORIGINAL_STDIN_FD original standard input (still open) +# +# stdin is /dev/null because checks that run programs may +# inadvertently run interactive ones, which would stop configuration +# until someone typed an EOF. +m4_define([AS_MESSAGE_FD], 6) +m4_define([AS_ORIGINAL_STDIN_FD], 7) +# That's how they used to be named. +AU_ALIAS([AC_FD_CC], [AS_MESSAGE_LOG_FD]) +AU_ALIAS([AC_FD_MSG], [AS_MESSAGE_FD]) + + +# _AC_INIT_DEFAULTS +# ----------------- +# Values which defaults can be set from `configure.ac'. +# `/bin/machine' is used in `glibcbug'. The others are used in config.* +m4_define([_AC_INIT_DEFAULTS], +[m4_divert_push([DEFAULTS])dnl + +test -n "$DJDIR" || exec AS_ORIGINAL_STDIN_FD<&0 </dev/null +exec AS_MESSAGE_FD>&1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIB@&t@OBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= +AC_SUBST([SHELL])dnl +AC_SUBST([PATH_SEPARATOR])dnl + +# Identity of this package. +AC_SUBST([PACKAGE_NAME], + [m4_ifdef([AC_PACKAGE_NAME], ['AC_PACKAGE_NAME'])])dnl +AC_SUBST([PACKAGE_TARNAME], + [m4_ifdef([AC_PACKAGE_TARNAME], ['AC_PACKAGE_TARNAME'])])dnl +AC_SUBST([PACKAGE_VERSION], + [m4_ifdef([AC_PACKAGE_VERSION], ['AC_PACKAGE_VERSION'])])dnl +AC_SUBST([PACKAGE_STRING], + [m4_ifdef([AC_PACKAGE_STRING], ['AC_PACKAGE_STRING'])])dnl +AC_SUBST([PACKAGE_BUGREPORT], + [m4_ifdef([AC_PACKAGE_BUGREPORT], ['AC_PACKAGE_BUGREPORT'])])dnl +AC_SUBST([PACKAGE_URL], + [m4_ifdef([AC_PACKAGE_URL], ['AC_PACKAGE_URL'])])dnl + +m4_divert_pop([DEFAULTS])dnl +m4_wrap_lifo([m4_divert_text([DEFAULTS], +[ac_subst_vars='m4_set_dump([_AC_SUBST_VARS], m4_newline)' +ac_subst_files='m4_ifdef([_AC_SUBST_FILES], [m4_defn([_AC_SUBST_FILES])])' +ac_user_opts=' +enable_option_checking +m4_ifdef([_AC_USER_OPTS], [m4_defn([_AC_USER_OPTS]) +])' +m4_ifdef([_AC_PRECIOUS_VARS], + [_AC_ARG_VAR_STORE[]dnl + _AC_ARG_VAR_VALIDATE[]dnl + ac_precious_vars='m4_defn([_AC_PRECIOUS_VARS])']) +m4_ifdef([_AC_LIST_SUBDIRS], + [ac_subdirs_all='m4_defn([_AC_LIST_SUBDIRS])'])dnl +])])dnl +])# _AC_INIT_DEFAULTS + + +# AC_PREFIX_DEFAULT(PREFIX) +# ------------------------- +AC_DEFUN([AC_PREFIX_DEFAULT], +[m4_divert_text([DEFAULTS], [ac_default_prefix=$1])]) + + +# AC_PREFIX_PROGRAM(PROGRAM) +# -------------------------- +# Guess the value for the `prefix' variable by looking for +# the argument program along PATH and taking its parent. +# Example: if the argument is `gcc' and we find /usr/local/gnu/bin/gcc, +# set `prefix' to /usr/local/gnu. +# This comes too late to find a site file based on the prefix, +# and it might use a cached value for the path. +# No big loss, I think, since most configures don't use this macro anyway. +AC_DEFUN([AC_PREFIX_PROGRAM], +[if test "x$prefix" = xNONE; then +dnl We reimplement AC_MSG_CHECKING (mostly) to avoid the ... in the middle. + _AS_ECHO_N([checking for prefix by ]) + AC_PATH_PROG(ac_prefix_program, [$1]) + if test -n "$ac_prefix_program"; then + prefix=`AS_DIRNAME(["$ac_prefix_program"])` + prefix=`AS_DIRNAME(["$prefix"])` + fi +fi +])# AC_PREFIX_PROGRAM + + +# AC_CONFIG_SRCDIR([UNIQUE-FILE-IN-SOURCE-DIR]) +# --------------------------------------------- +# UNIQUE-FILE-IN-SOURCE-DIR is a file name unique to this package, +# relative to the directory that configure is in, which we can look +# for to find out if srcdir is correct. +AC_DEFUN([AC_CONFIG_SRCDIR], +[m4_divert_text([DEFAULTS], [ac_unique_file="$1"])]) + + +# _AC_INIT_DIRCHECK +# ----------------- +# Set ac_pwd, and sanity-check it and the source and installation directories. +# +# (This macro is AC_REQUIREd by _AC_INIT_SRCDIR, so it has to be AC_DEFUNed.) +# +AC_DEFUN([_AC_INIT_DIRCHECK], +[m4_divert_push([PARSE_ARGS])dnl + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + AC_MSG_ERROR([working directory cannot be determined]) +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + AC_MSG_ERROR([pwd does not report name of working directory]) + +m4_divert_pop([PARSE_ARGS])dnl +])# _AC_INIT_DIRCHECK + +# _AC_INIT_SRCDIR +# --------------- +# Compute `srcdir' based on `$ac_unique_file'. +# +# (We have to AC_DEFUN it, since we use AC_REQUIRE.) +# +AC_DEFUN([_AC_INIT_SRCDIR], +[AC_REQUIRE([_AC_INIT_DIRCHECK])dnl +m4_divert_push([PARSE_ARGS])dnl + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`AS_DIRNAME(["$as_myself"])` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + AC_MSG_ERROR([cannot find sources ($ac_unique_file) in $srcdir]) +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || AC_MSG_ERROR([$ac_msg]) + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[[^/]]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +m4_divert_pop([PARSE_ARGS])dnl +])# _AC_INIT_SRCDIR + + +# _AC_INIT_PARSE_ARGS +# ------------------- +m4_define([_AC_INIT_PARSE_ARGS], +[m4_divert_push([PARSE_ARGS])dnl + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +AC_SUBST(exec_prefix, NONE)dnl +no_create= +no_recursion= +AC_SUBST(prefix, NONE)dnl +program_prefix=NONE +program_suffix=NONE +AC_SUBST(program_transform_name, [s,x,x,])dnl +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +AC_SUBST([bindir], ['${exec_prefix}/bin'])dnl +AC_SUBST([sbindir], ['${exec_prefix}/sbin'])dnl +AC_SUBST([libexecdir], ['${exec_prefix}/libexec'])dnl +AC_SUBST([datarootdir], ['${prefix}/share'])dnl +AC_SUBST([datadir], ['${datarootdir}'])dnl +AC_SUBST([sysconfdir], ['${prefix}/etc'])dnl +AC_SUBST([sharedstatedir], ['${prefix}/com'])dnl +AC_SUBST([localstatedir], ['${prefix}/var'])dnl +AC_SUBST([includedir], ['${prefix}/include'])dnl +AC_SUBST([oldincludedir], ['/usr/include'])dnl +AC_SUBST([docdir], [m4_ifset([AC_PACKAGE_TARNAME], + ['${datarootdir}/doc/${PACKAGE_TARNAME}'], + ['${datarootdir}/doc/${PACKAGE}'])])dnl +AC_SUBST([infodir], ['${datarootdir}/info'])dnl +AC_SUBST([htmldir], ['${docdir}'])dnl +AC_SUBST([dvidir], ['${docdir}'])dnl +AC_SUBST([pdfdir], ['${docdir}'])dnl +AC_SUBST([psdir], ['${docdir}'])dnl +AC_SUBST([libdir], ['${exec_prefix}/lib'])dnl +AC_SUBST([localedir], ['${datarootdir}/locale'])dnl +AC_SUBST([mandir], ['${datarootdir}/man'])dnl + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[[^=]]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + _AC_INIT_PARSE_ENABLE([disable]) + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + _AC_INIT_PARSE_ENABLE([enable]) + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + _AC_INIT_PARSE_ENABLE([with]) + + _AC_INIT_PARSE_ENABLE([without]) + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) AC_MSG_ERROR([unrecognized option: `$ac_option' +Try `$[0] --help' for more information]) + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([[^=]]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [[0-9]]* | *[[!_$as_cr_alnum]]* ) + AC_MSG_ERROR([invalid variable name: `$ac_envvar']) ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + AC_MSG_WARN([you should use --build, --host, --target]) + expr "x$ac_option" : "[.*[^-._$as_cr_alnum]]" >/dev/null && + AC_MSG_WARN([invalid host type: $ac_option]) + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + AC_MSG_ERROR([missing argument to $ac_option]) +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) AC_MSG_ERROR([unrecognized options: $ac_unrecognized_opts]) ;; + *) AC_MSG_WARN( [unrecognized options: $ac_unrecognized_opts]) ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[[^/]]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [[\\/$]]* | ?:[[\\/]]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + AC_MSG_ERROR([expected an absolute directory name for --$ac_var: $ac_val]) +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec AS_MESSAGE_FD>/dev/null + +m4_divert_pop([PARSE_ARGS])dnl +])# _AC_INIT_PARSE_ARGS + + +# _AC_INIT_PARSE_ENABLE(OPTION-NAME) +# ---------------------------------- +# A trivial front-end for _AC_INIT_PARSE_ENABLE2. +# +m4_define([_AC_INIT_PARSE_ENABLE], +[m4_bmatch([$1], [^with], + [_AC_INIT_PARSE_ENABLE2([$1], [with])], + [_AC_INIT_PARSE_ENABLE2([$1], [enable])])]) + + +# _AC_INIT_PARSE_ENABLE2(OPTION-NAME, POSITIVE-NAME) +# -------------------------------------------------- +# Handle an `--enable' or a `--with' option. +# +# OPTION-NAME is `enable', `disable', `with', or `without'. +# POSITIVE-NAME is the corresponding positive variant, i.e. `enable' or `with'. +# +# Positive variant of the option is recognized by the condition +# OPTION-NAME == POSITIVE-NAME . +# +m4_define([_AC_INIT_PARSE_ENABLE2], +[-$1-* | --$1-*) + ac_useropt=`expr "x$ac_option" : 'x-*$1-\(m4_if([$1], [$2], [[[^=]]], [.])*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : "[.*[^-+._$as_cr_alnum]]" >/dev/null && + AC_MSG_ERROR( + [invalid ]m4_if([$2], [with], [package], [feature])[ name: $ac_useropt]) + ac_useropt_orig=$ac_useropt + ac_useropt=`AS_ECHO(["$ac_useropt"]) | sed 's/[[-+.]]/_/g'` + case $ac_user_opts in + *" +"$2_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--$1-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval $2_$ac_useropt=m4_if([$1], [$2], [\$ac_optarg], [no]) ;;dnl +]) + + +# _AC_INIT_HELP +# ------------- +# Handle the `configure --help' message. +m4_define([_AC_INIT_HELP], +[m4_divert_push([HELP_BEGIN])dnl + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures m4_ifset([AC_PACKAGE_STRING], + [AC_PACKAGE_STRING], + [this package]) to adapt to many kinds of systems. + +Usage: $[0] [[OPTION]]... [[VAR=VALUE]]... + +[To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: +]AS_HELP_STRING([--prefix=PREFIX], + [install architecture-independent files in PREFIX [$ac_default_prefix]]) +AS_HELP_STRING([--exec-prefix=EPREFIX], + [install architecture-dependent files in EPREFIX [PREFIX]])[ + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] +]AS_HELP_STRING([--docdir=DIR], + [documentation root ]@<:@DATAROOTDIR/doc/m4_ifset([AC_PACKAGE_TARNAME], + [AC_PACKAGE_TARNAME], [PACKAGE])@:>@)[ + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF] +m4_divert_pop([HELP_BEGIN])dnl +dnl The order of the diversions here is +dnl - HELP_BEGIN +dnl which may be extended by extra generic options such as with X or +dnl AC_ARG_PROGRAM. Displayed only in long --help. +dnl +dnl - HELP_CANON +dnl Support for cross compilation (--build, --host and --target). +dnl Display only in long --help. +dnl +dnl - HELP_ENABLE +dnl which starts with the trailer of the HELP_BEGIN, HELP_CANON section, +dnl then implements the header of the non generic options. +dnl +dnl - HELP_WITH +dnl +dnl - HELP_VAR +dnl +dnl - HELP_VAR_END +dnl +dnl - HELP_END +dnl initialized below, in which we dump the trailer (handling of the +dnl recursion for instance). +m4_divert_push([HELP_ENABLE])dnl +_ACEOF +fi + +if test -n "$ac_init_help"; then +m4_ifset([AC_PACKAGE_STRING], +[ case $ac_init_help in + short | recursive ) echo "Configuration of AC_PACKAGE_STRING:";; + esac]) + cat <<\_ACEOF +m4_divert_pop([HELP_ENABLE])dnl +m4_divert_push([HELP_END])dnl + +Report bugs to m4_ifset([AC_PACKAGE_BUGREPORT], [<AC_PACKAGE_BUGREPORT>], + [the package provider]).dnl +m4_ifdef([AC_PACKAGE_NAME], [m4_ifset([AC_PACKAGE_URL], [ +AC_PACKAGE_NAME home page: <AC_PACKAGE_URL>.])dnl +m4_if(m4_index(m4_defn([AC_PACKAGE_NAME]), [GNU ]), [0], [ +General help using GNU software: <http://www.gnu.org/gethelp/>.])]) +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + _AC_SRCDIRS(["$ac_dir"]) + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + AC_MSG_WARN([no configuration information is in $ac_dir]) + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +m4_divert_pop([HELP_END])dnl +])# _AC_INIT_HELP + + +# _AC_INIT_VERSION +# ---------------- +# Handle the `configure --version' message. +m4_define([_AC_INIT_VERSION], +[m4_divert_text([VERSION_BEGIN], +[if $ac_init_version; then + cat <<\_ACEOF +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])configure[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +generated by m4_PACKAGE_STRING]) +m4_divert_text([VERSION_END], +[_ACEOF + exit +fi])dnl +])# _AC_INIT_VERSION + + +# _AC_INIT_CONFIG_LOG +# ------------------- +# Initialize the config.log file descriptor and write header to it. +m4_define([_AC_INIT_CONFIG_LOG], +[m4_divert_text([INIT_PREPARE], +[m4_define([AS_MESSAGE_LOG_FD], 5)dnl +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])dnl +$as_me[]m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]), which was +generated by m4_PACKAGE_STRING. Invocation command line was + + $ $[0] $[@] + +_ACEOF +exec AS_MESSAGE_LOG_FD>>config.log +AS_UNAME >&AS_MESSAGE_LOG_FD + +cat >&AS_MESSAGE_LOG_FD <<_ACEOF + + +m4_text_box([Core tests.]) + +_ACEOF +])])# _AC_INIT_CONFIG_LOG + + +# _AC_INIT_PREPARE +# ---------------- +# Called by AC_INIT to build the preamble of the `configure' scripts. +# 1. Trap and clean up various tmp files. +# 2. Set up the fd and output files +# 3. Remember the options given to `configure' for `config.status --recheck'. +# 4. Initiates confdefs.h +# 5. Loads site and cache files +m4_define([_AC_INIT_PREPARE], +[m4_divert_push([INIT_PREPARE])dnl + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`AS_ECHO(["$ac_arg"]) | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) AS_VAR_APPEND([ac_configure_args0], [" '$ac_arg'"]) ;; + 2) + AS_VAR_APPEND([ac_configure_args1], [" '$ac_arg'"]) +dnl If trying to remove duplicates, be sure to (i) keep the *last* +dnl value (e.g. --prefix=1 --prefix=2 --prefix=1 might keep 2 only), +dnl and (ii) not to strip long options (--prefix foo --prefix bar might +dnl give --prefix foo bar). + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in +dnl Use broad patterns, as arguments that would have already made configure +dnl exit don't matter. + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + AS_VAR_APPEND([ac_configure_args], [" '$ac_arg'"]) + ;; + esac + done +done +AS_UNSET(ac_configure_args0) +AS_UNSET(ac_configure_args1) + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + AS_BOX([Cache variables.]) + echo + m4_bpatsubsts(m4_defn([_AC_CACHE_DUMP]), + [^ *\(#.*\)? +], [], + ['], ['\\'']) + echo + + AS_BOX([Output variables.]) + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`AS_ECHO(["$ac_val"]) | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + AS_ECHO(["$ac_var='\''$ac_val'\''"]) + done | sort + echo + + if test -n "$ac_subst_files"; then + AS_BOX([File substitutions.]) + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`AS_ECHO(["$ac_val"]) | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + AS_ECHO(["$ac_var='\''$ac_val'\''"]) + done | sort + echo + fi + + if test -s confdefs.h; then + AS_BOX([confdefs.h.]) + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + AS_ECHO(["$as_me: caught signal $ac_signal"]) + AS_ECHO(["$as_me: exit $exit_status"]) + } >&AS_MESSAGE_LOG_FD + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$[$]* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; AS_EXIT([1])' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +dnl AIX cpp loses on an empty file, NextStep 3.3 (patch 3) loses on a file +dnl containing less than 14 bytes (including the newline). +AS_ECHO(["/* confdefs.h */"]) > confdefs.h + +# Predefined preprocessor variables. +AC_DEFINE_UNQUOTED([PACKAGE_NAME], ["$PACKAGE_NAME"], + [Define to the full name of this package.])dnl +AC_DEFINE_UNQUOTED([PACKAGE_TARNAME], ["$PACKAGE_TARNAME"], + [Define to the one symbol short name of this package.])dnl +AC_DEFINE_UNQUOTED([PACKAGE_VERSION], ["$PACKAGE_VERSION"], + [Define to the version of this package.])dnl +AC_DEFINE_UNQUOTED([PACKAGE_STRING], ["$PACKAGE_STRING"], + [Define to the full name and version of this package.])dnl +AC_DEFINE_UNQUOTED([PACKAGE_BUGREPORT], ["$PACKAGE_BUGREPORT"], + [Define to the address where bug reports for this package + should be sent.])dnl +AC_DEFINE_UNQUOTED([PACKAGE_URL], ["$PACKAGE_URL"], + [Define to the home page for this package.]) + +# Let the site file select an alternate cache file if it wants to. +AC_SITE_LOAD +AC_CACHE_LOAD +m4_divert_pop([INIT_PREPARE])dnl +])# _AC_INIT_PREPARE + + +# AU::AC_INIT([UNIQUE-FILE-IN-SOURCE-DIR]) +# ---------------------------------------- +# This macro is used only for Autoupdate. +AU_DEFUN([AC_INIT], +[m4_ifval([$2], [[AC_INIT($@)]], + [m4_ifval([$1], +[[AC_INIT] +AC_CONFIG_SRCDIR([$1])], [[AC_INIT]])])[]dnl +]) + + +# AC_INIT([PACKAGE, VERSION, [BUG-REPORT], [TARNAME], [URL]) +# ---------------------------------------------------------- +# Include the user macro files, prepare the diversions, and output the +# preamble of the `configure' script. +# +# If BUG-REPORT is omitted, do without (unless the user previously +# defined the m4 macro AC_PACKAGE_BUGREPORT). If TARNAME is omitted, +# use PACKAGE to seed it. If URL is omitted, use +# `http://www.gnu.org/software/TARNAME/' if PACKAGE begins with `GNU', +# otherwise, do without. +# +# Note that the order is important: first initialize, then set the +# AC_CONFIG_SRCDIR. +m4_define([AC_INIT], +[# Forbidden tokens and exceptions. +m4_pattern_forbid([^_?A[CHUM]_]) +m4_pattern_forbid([_AC_]) +m4_pattern_forbid([^LIBOBJS$], + [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS']) +# Actually reserved by M4sh. +m4_pattern_allow([^AS_FLAGS$]) +# So that the autoconf-generated scripts will always re-execute +# themselves with $CONFIG_SHELL, if that's set in the environment. +m4_define([_AS_FORCE_REEXEC_WITH_CONFIG_SHELL], [yes]) +AS_INIT[]dnl +AS_PREPARE[]dnl +m4_divert_push([KILL]) +m4_ifval([$2], [_AC_INIT_PACKAGE($@)]) +_AC_INIT_DEFAULTS +_AC_INIT_PARSE_ARGS +_AC_INIT_DIRCHECK +_AC_INIT_SRCDIR +_AC_INIT_HELP +_AC_INIT_VERSION +_AC_INIT_CONFIG_LOG +_AC_INIT_PREPARE +_AC_INIT_NOTICE +_AC_INIT_COPYRIGHT +m4_divert_text([SHELL_FN], [ +m4_text_box([Autoconf initialization.])]) +m4_divert_pop +m4_ifval([$2], , [m4_ifval([$1], [AC_CONFIG_SRCDIR([$1])])])dnl +dnl +dnl Substitute for predefined variables. +AC_SUBST([DEFS])dnl +AC_SUBST([ECHO_C])dnl +AC_SUBST([ECHO_N])dnl +AC_SUBST([ECHO_T])dnl +AC_SUBST([LIBS])dnl +_AC_ARG_VAR_PRECIOUS([build_alias])AC_SUBST([build_alias])dnl +_AC_ARG_VAR_PRECIOUS([host_alias])AC_SUBST([host_alias])dnl +_AC_ARG_VAR_PRECIOUS([target_alias])AC_SUBST([target_alias])dnl +dnl +AC_LANG_PUSH(C) +]) + + + + +## ------------------------------------------------------------- ## +## Selecting optional features, working with optional software. ## +## ------------------------------------------------------------- ## + +# AC_PRESERVE_HELP_ORDER +# ---------------------- +# Emit help strings in the order given, rather than grouping all --enable-FOO +# and all --with-BAR. +AC_DEFUN([AC_PRESERVE_HELP_ORDER], +[m4_divert_once([HELP_ENABLE], [[ +Optional Features and Packages: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)]]) +m4_define([_m4_divert(HELP_ENABLE)], _m4_divert(HELP_WITH)) +])# AC_PRESERVE_HELP_ORDER + +# _AC_ENABLE_IF(OPTION, FEATURE, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------------------------- +# Common code for AC_ARG_ENABLE and AC_ARG_WITH. +# OPTION is either "enable" or "with". +# +m4_define([_AC_ENABLE_IF], +[@%:@ Check whether --$1-$2 was given. +_AC_ENABLE_IF_ACTION([$1], m4_translit([$2], [-+.], [___]), [$3], [$4]) +]) + +m4_define([_AC_ENABLE_IF_ACTION], +[m4_append_uniq([_AC_USER_OPTS], [$1_$2], [ +])dnl +AS_IF([test "${$1_$2+set}" = set], [$1val=$$1_$2; $3], [$4])dnl +]) + +# AC_ARG_ENABLE(FEATURE, HELP-STRING, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------------------------------ +AC_DEFUN([AC_ARG_ENABLE], +[AC_PROVIDE_IFELSE([AC_PRESERVE_HELP_ORDER], +[], +[m4_divert_once([HELP_ENABLE], [[ +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes]]])])dnl +m4_divert_once([HELP_ENABLE], [$2])dnl +_AC_ENABLE_IF([enable], [$1], [$3], [$4])dnl +])# AC_ARG_ENABLE + + +AU_DEFUN([AC_ENABLE], +[AC_ARG_ENABLE([$1], [ --enable-$1], [$2], [$3])]) + + +# AC_ARG_WITH(PACKAGE, HELP-STRING, ACTION-IF-TRUE, [ACTION-IF-FALSE]) +# -------------------------------------------------------------------- +AC_DEFUN([AC_ARG_WITH], +[AC_PROVIDE_IFELSE([AC_PRESERVE_HELP_ORDER], +[], +[m4_divert_once([HELP_WITH], [[ +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)]])]) +m4_divert_once([HELP_WITH], [$2])dnl +_AC_ENABLE_IF([with], [$1], [$3], [$4])dnl +])# AC_ARG_WITH + +AU_DEFUN([AC_WITH], +[AC_ARG_WITH([$1], [ --with-$1], [$2], [$3])]) + +# AC_DISABLE_OPTION_CHECKING +# -------------------------- +AC_DEFUN([AC_DISABLE_OPTION_CHECKING], +[m4_divert_once([DEFAULTS], [enable_option_checking=no]) +])# AC_DISABLE_OPTION_CHECKING + + +## ----------------------------------------- ## +## Remembering variables for reconfiguring. ## +## ----------------------------------------- ## + + +# AC_ARG_VAR(VARNAME, DOCUMENTATION) +# ---------------------------------- +# Register VARNAME as a precious variable, and document it in +# `configure --help' (but only once). +AC_DEFUN([AC_ARG_VAR], +[m4_divert_once([HELP_VAR], [[ +Some influential environment variables:]])dnl +m4_divert_once([HELP_VAR_END], [[ +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations.]])dnl +m4_expand_once([m4_divert_text([HELP_VAR], + [AS_HELP_STRING([$1], [$2], [ ])])], + [$0($1)])dnl +AC_SUBST([$1])dnl +_AC_ARG_VAR_PRECIOUS([$1])dnl +])# AC_ARG_VAR + + +# _AC_ARG_VAR_PRECIOUS(VARNAME) +# ----------------------------- +# Declare VARNAME is precious. +m4_define([_AC_ARG_VAR_PRECIOUS], +[m4_append_uniq([_AC_PRECIOUS_VARS], [$1], [ +])dnl +]) + + +# _AC_ARG_VAR_STORE +# ----------------- +# We try to diagnose when precious variables have changed. To do this, +# make two early snapshots (after the option processing to take +# explicit variables into account) of those variables: one (ac_env_) +# which represents the current run, and a second (ac_cv_env_) which, +# at the first run, will be saved in the cache. As an exception to +# the cache mechanism, its loading will override these variables (non +# `ac_cv_env_' cache value are only set when unset). +# +# In subsequent runs, after having loaded the cache, compare +# ac_cv_env_foo against ac_env_foo. See _AC_ARG_VAR_VALIDATE. +m4_define([_AC_ARG_VAR_STORE], +[m4_divert_text([PARSE_ARGS], +[for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done])dnl +]) + + +# _AC_ARG_VAR_VALIDATE +# -------------------- +# The precious variables are saved twice at the beginning of +# configure. E.g., PRECIOUS is saved as `ac_env_PRECIOUS_set' and +# `ac_env_PRECIOUS_value' on the one hand and `ac_cv_env_PRECIOUS_set' +# and `ac_cv_env_PRECIOUS_value' on the other hand. +# +# Now the cache has just been loaded, so `ac_cv_env_' represents the +# content of the cached values, while `ac_env_' represents that of the +# current values. +# +# So we check that `ac_env_' and `ac_cv_env_' are consistent. If +# they aren't, die. +m4_define([_AC_ARG_VAR_VALIDATE], +[m4_divert_text([INIT_PREPARE], +[# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + AS_MESSAGE([error: `$ac_var' was set to `$ac_old_val' in the previous run], 2) + ac_cache_corrupted=: ;; + ,set) + AS_MESSAGE([error: `$ac_var' was not set in the previous run], 2) + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + AS_MESSAGE([error: `$ac_var' has changed since the previous run:], 2) + ac_cache_corrupted=: + else + AS_MESSAGE([warning: ignoring whitespace changes in `$ac_var' since the previous run:], 2) + eval $ac_var=\$ac_old_val + fi + AS_MESSAGE([ former value: `$ac_old_val'], 2) + AS_MESSAGE([ current value: `$ac_new_val'], 2) + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`AS_ECHO(["$ac_new_val"]) | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) AS_VAR_APPEND([ac_configure_args], [" '$ac_arg'"]) ;; + esac + fi +done +if $ac_cache_corrupted; then + AS_MESSAGE([error: in `$ac_pwd':], 2) + AS_MESSAGE([error: changes in the environment can compromise the build], 2) + AS_ERROR([run `make distclean' and/or `rm $cache_file' and start over]) +fi])dnl +])# _AC_ARG_VAR_VALIDATE + + + + + +## ---------------------------- ## +## Transforming program names. ## +## ---------------------------- ## + + +# AC_ARG_PROGRAM +# -------------- +# This macro is expanded only once, to avoid that `foo' ends up being +# installed as `ggfoo'. +AC_DEFUN_ONCE([AC_ARG_PROGRAM], +[dnl Document the options. +m4_divert_push([HELP_BEGIN])dnl + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names +m4_divert_pop([HELP_BEGIN])dnl +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +[ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'] +program_transform_name=`AS_ECHO(["$program_transform_name"]) | sed "$ac_script"` +])# AC_ARG_PROGRAM + + + + + +## ------------------------- ## +## Finding auxiliary files. ## +## ------------------------- ## + + +# AC_CONFIG_AUX_DIR(DIR) +# ---------------------- +# Find install-sh, config.sub, config.guess, and Cygnus configure +# in directory DIR. These are auxiliary files used in configuration. +# DIR can be either absolute or relative to $srcdir. +AC_DEFUN([AC_CONFIG_AUX_DIR], +[AC_CONFIG_AUX_DIRS($1 "$srcdir"/$1)]) + + +# AC_CONFIG_AUX_DIR_DEFAULT +# ------------------------- +# The default is `$srcdir' or `$srcdir/..' or `$srcdir/../..'. +# There's no need to call this macro explicitly; just AC_REQUIRE it. +AC_DEFUN([AC_CONFIG_AUX_DIR_DEFAULT], +[AC_CONFIG_AUX_DIRS("$srcdir" "$srcdir/.." "$srcdir/../..")]) + + +# AC_CONFIG_AUX_DIRS(DIR ...) +# --------------------------- +# Internal subroutine. +# Search for the configuration auxiliary files in directory list $1. +# We look only for install-sh, so users of AC_PROG_INSTALL +# do not automatically need to distribute the other auxiliary files. +AC_DEFUN([AC_CONFIG_AUX_DIRS], +[ac_aux_dir= +for ac_dir in $1; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + AC_MSG_ERROR([cannot find install-sh, install.sh, or shtool in $1]) +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + +AC_PROVIDE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +])# AC_CONFIG_AUX_DIRS + + + + +## ------------------------ ## +## Finding aclocal macros. ## +## ------------------------ ## + + +# AC_CONFIG_MACRO_DIR(DIR) +# ------------------------ +# Declare directory containing additional macros for aclocal. +AC_DEFUN([AC_CONFIG_MACRO_DIR], []) + + + +## --------------------- ## +## Requiring aux files. ## +## --------------------- ## + +# AC_REQUIRE_AUX_FILE(FILE) +# ------------------------- +# This macro does nothing, it's a hook to be read with `autoconf --trace'. +# It announces FILE is required in the auxdir. +m4_define([AC_REQUIRE_AUX_FILE], +[AS_LITERAL_WORD_IF([$1], [], + [m4_fatal([$0: requires a literal argument])])]) + + + +## ----------------------------------- ## +## Getting the canonical system type. ## +## ----------------------------------- ## + +# The inputs are: +# configure --host=HOST --target=TARGET --build=BUILD +# +# The rules are: +# 1. Build defaults to the current platform, as determined by config.guess. +# 2. Host defaults to build. +# 3. Target defaults to host. + + +# _AC_CANONICAL_SPLIT(THING) +# -------------------------- +# Generate the variables THING, THING_{alias cpu vendor os}. +m4_define([_AC_CANONICAL_SPLIT], +[case $ac_cv_$1 in +*-*-*) ;; +*) AC_MSG_ERROR([invalid value of canonical $1]);; +esac +AC_SUBST([$1], [$ac_cv_$1])dnl +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_$1 +shift +AC_SUBST([$1_cpu], [$[1]])dnl +AC_SUBST([$1_vendor], [$[2]])dnl +shift; shift +[# Remember, the first character of IFS is used to create $]*, +# except with old shells: +$1_os=$[*] +IFS=$ac_save_IFS +case $$1_os in *\ *) $1_os=`echo "$$1_os" | sed 's/ /-/g'`;; esac +AC_SUBST([$1_os])dnl +])# _AC_CANONICAL_SPLIT + + +# AC_CANONICAL_BUILD +# ------------------ +AC_DEFUN_ONCE([AC_CANONICAL_BUILD], +[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_REQUIRE_AUX_FILE([config.sub])dnl +AC_REQUIRE_AUX_FILE([config.guess])dnl +m4_divert_once([HELP_CANON], +[[ +System types: + --build=BUILD configure for building on BUILD [guessed]]])dnl +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + AC_MSG_ERROR([cannot run $SHELL $ac_aux_dir/config.sub]) + +AC_CACHE_CHECK([build system type], [ac_cv_build], +[ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + AC_MSG_ERROR([cannot guess build type; you must specify one]) +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + AC_MSG_ERROR([$SHELL $ac_aux_dir/config.sub $ac_build_alias failed]) +]) +_AC_CANONICAL_SPLIT(build) +])# AC_CANONICAL_BUILD + + +# AC_CANONICAL_HOST +# ----------------- +AC_DEFUN_ONCE([AC_CANONICAL_HOST], +[AC_REQUIRE([AC_CANONICAL_BUILD])dnl +m4_divert_once([HELP_CANON], +[[ --host=HOST cross-compile to build programs to run on HOST [BUILD]]])dnl +AC_CACHE_CHECK([host system type], [ac_cv_host], +[if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + AC_MSG_ERROR([$SHELL $ac_aux_dir/config.sub $host_alias failed]) +fi +]) +_AC_CANONICAL_SPLIT([host]) +])# AC_CANONICAL_HOST + + +# AC_CANONICAL_TARGET +# ------------------- +AC_DEFUN_ONCE([AC_CANONICAL_TARGET], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_BEFORE([$0], [AC_ARG_PROGRAM])dnl +m4_divert_once([HELP_CANON], +[[ --target=TARGET configure for building compilers for TARGET [HOST]]])dnl +AC_CACHE_CHECK([target system type], [ac_cv_target], +[if test "x$target_alias" = x; then + ac_cv_target=$ac_cv_host +else + ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || + AC_MSG_ERROR([$SHELL $ac_aux_dir/config.sub $target_alias failed]) +fi +]) +_AC_CANONICAL_SPLIT([target]) + +# The aliases save the names the user supplied, while $host etc. +# will get canonicalized. +test -n "$target_alias" && + test "$program_prefix$program_suffix$program_transform_name" = \ + NONENONEs,x,x, && + program_prefix=${target_alias}-[]dnl +])# AC_CANONICAL_TARGET + + +AU_ALIAS([AC_CANONICAL_SYSTEM], [AC_CANONICAL_TARGET]) + + +# AU::AC_VALIDATE_CACHED_SYSTEM_TUPLE([CMD]) +# ------------------------------------------ +# If the cache file is inconsistent with the current host, +# target and build system types, execute CMD or print a default +# error message. Now handled via _AC_ARG_VAR_PRECIOUS. +AU_DEFUN([AC_VALIDATE_CACHED_SYSTEM_TUPLE], []) + + +## ---------------------- ## +## Caching test results. ## +## ---------------------- ## + + +# AC_SITE_LOAD +# ------------ +# Look for site- or system-specific initialization scripts. +m4_define([AC_SITE_LOAD], +[# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in @%:@(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + AC_MSG_NOTICE([loading site script $ac_site_file]) + sed 's/^/| /' "$ac_site_file" >&AS_MESSAGE_LOG_FD + . "$ac_site_file" \ + || AC_MSG_FAILURE([failed to load site script $ac_site_file]) + fi +done +]) + + +# AC_CACHE_LOAD +# ------------- +m4_define([AC_CACHE_LOAD], +[if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + AC_MSG_NOTICE([loading cache $cache_file]) + case $cache_file in + [[\\/]]* | ?:[[\\/]]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + AC_MSG_NOTICE([creating cache $cache_file]) + >$cache_file +fi +])# AC_CACHE_LOAD + + +# _AC_CACHE_DUMP +# -------------- +# Dump the cache to stdout. It can be in a pipe (this is a requirement). +m4_define([_AC_CACHE_DUMP], +[# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n ['s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p']`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) AC_MSG_WARN([cache variable $ac_var contains a newline]) ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) AS_UNSET([$ac_var]) ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + ["s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"] + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n ["/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"] + ;; + esac | + sort +)dnl +])# _AC_CACHE_DUMP + + +# AC_CACHE_SAVE +# ------------- +# Save the cache. +# Allow a site initialization script to override cache values. +m4_define([AC_CACHE_SAVE], +[cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +_AC_CACHE_DUMP() | + sed [' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end'] >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + AC_MSG_NOTICE([updating cache $cache_file]) + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else +dnl Try to update the cache file atomically even on different mount points; +dnl at the same time, avoid filename limitation issues in the common case. + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + AC_MSG_NOTICE([not updating unwritable cache $cache_file]) + fi +fi +rm -f confcache[]dnl +])# AC_CACHE_SAVE + + +# AC_CACHE_VAL(CACHE-ID, COMMANDS-TO-SET-IT) +# ------------------------------------------ +# The name of shell var CACHE-ID must contain `_cv_' in order to get saved. +# Should be dnl'ed. Try to catch common mistakes. +m4_defun([AC_CACHE_VAL], +[AS_LITERAL_WORD_IF([$1], [m4_if(m4_index(m4_quote($1), [_cv_]), [-1], + [AC_DIAGNOSE([syntax], +[$0($1, ...): suspicious cache-id, must contain _cv_ to be cached])])])dnl +m4_if(m4_index([$2], [AC_DEFINE]), [-1], [], + [AC_DIAGNOSE([syntax], +[$0($1, ...): suspicious presence of an AC_DEFINE in the second argument, ]dnl +[where no actions should be taken])])dnl +m4_if(m4_index([$2], [AC_SUBST]), [-1], [], + [AC_DIAGNOSE([syntax], +[$0($1, ...): suspicious presence of an AC_SUBST in the second argument, ]dnl +[where no actions should be taken])])dnl +AS_VAR_SET_IF([$1], + [_AS_ECHO_N([(cached) ])], + [$2]) +]) + + +# AC_CACHE_CHECK(MESSAGE, CACHE-ID, COMMANDS) +# ------------------------------------------- +# Do not call this macro with a dnl right behind. +m4_defun([AC_CACHE_CHECK], +[AC_MSG_CHECKING([$1]) +AC_CACHE_VAL([$2], [$3])dnl +AS_LITERAL_WORD_IF([$2], + [AC_MSG_RESULT([$$2])], + [AS_VAR_COPY([ac_res], [$2]) + AC_MSG_RESULT([$ac_res])])dnl +]) + +# _AC_CACHE_CHECK_INT(MESSAGE, CACHE-ID, EXPRESSION, +# [PROLOGUE = DEFAULT-INCLUDES], [IF-FAILS]) +# -------------------------------------------------------------- +AC_DEFUN([_AC_CACHE_CHECK_INT], +[AC_CACHE_CHECK([$1], [$2], + [AC_COMPUTE_INT([$2], [$3], [$4], [$5])]) +])# _AC_CACHE_CHECK_INT + + + +## ---------------------- ## +## Defining CPP symbols. ## +## ---------------------- ## + + +# AC_DEFINE_TRACE_LITERAL(LITERAL-CPP-SYMBOL) +# ------------------------------------------- +# Used by --trace to collect the list of AC_DEFINEd macros. +m4_define([AC_DEFINE_TRACE_LITERAL], +[m4_pattern_allow([^$1$])dnl +AS_IDENTIFIER_IF([$1], [], + [m4_warn([syntax], [AC_DEFINE: not an identifier: $1])])dnl +])# AC_DEFINE_TRACE_LITERAL + + +# AC_DEFINE_TRACE(CPP-SYMBOL) +# --------------------------- +# This macro is a wrapper around AC_DEFINE_TRACE_LITERAL which filters +# out non literal symbols. CPP-SYMBOL must not include any parameters. +m4_define([AC_DEFINE_TRACE], +[AS_LITERAL_WORD_IF([$1], [AC_DEFINE_TRACE_LITERAL(_m4_expand([$1]))])]) + + +# AC_DEFINE(VARIABLE, [VALUE], [DESCRIPTION]) +# ------------------------------------------- +# Set VARIABLE to VALUE, verbatim, or 1. Remember the value +# and if VARIABLE is affected the same VALUE, do nothing, else +# die. The third argument is used by autoheader. +m4_define([AC_DEFINE], [_AC_DEFINE_Q([_$0], $@)]) + +# _AC_DEFINE(STRING) +# ------------------ +# Append the pre-expanded STRING and a newline to confdefs.h, as if by +# a quoted here-doc. +m4_define([_AC_DEFINE], +[AS_ECHO(["AS_ESCAPE([[$1]])"]) >>confdefs.h]) + + +# AC_DEFINE_UNQUOTED(VARIABLE, [VALUE], [DESCRIPTION]) +# ---------------------------------------------------- +# Similar, but perform shell substitutions $ ` \ once on VALUE, as +# in an unquoted here-doc. +m4_define([AC_DEFINE_UNQUOTED], [_AC_DEFINE_Q([_$0], $@)]) + +# _AC_DEFINE_UNQUOTED(STRING) +# --------------------------- +# Append the pre-expanded STRING and a newline to confdefs.h, as if +# with an unquoted here-doc, but avoiding a fork in the common case of +# no backslash, no command substitution, no complex variable +# substitution, and no quadrigraphs. +m4_define([_AC_DEFINE_UNQUOTED], +[m4_if(m4_bregexp([$1], [\\\|`\|\$(\|\${\|@]), [-1], + [AS_ECHO(["AS_ESCAPE([$1], [""])"]) >>confdefs.h], + [cat >>confdefs.h <<_ACEOF +[$1] +_ACEOF])]) + + +# _AC_DEFINE_Q(MACRO, VARIABLE, [VALUE], [DESCRIPTION]) +# ----------------------------------------------------- +# Internal function that performs common elements of AC_DEFINE{,_UNQUOTED}. +# MACRO must take one argument, which is the fully expanded string to +# append to confdefs.h as if by a possibly-quoted here-doc. +# +# m4_index is roughly 5 to 8 times faster than m4_bpatsubst, so we use +# m4_format rather than regex to grab prefix up to first (). AC_name +# is defined with over-quotation, so that we can avoid m4_defn; this +# is only safe because the name should not contain $. +# +# Guarantee a match in m4_index, so as to avoid a bug with precision +# -1 in m4_format in older m4. +m4_define([_AC_DEFINE_Q], +[m4_pushdef([AC_name], m4_format([[[%.*s]]], m4_index([$2(], [(]), [$2]))]dnl +[AC_DEFINE_TRACE(AC_name)]dnl +[m4_cond([m4_index([$3], [ +])], [-1], [], + [m4_bregexp([[$3]], [[^\\] +], [-])], [], [], + [m4_warn([syntax], [AC_DEFINE]m4_if([$1], [_AC_DEFINE], [], + [[_UNQUOTED]])[: `$3' is not a valid preprocessor define value])])]dnl +[m4_ifval([$4], [AH_TEMPLATE(AC_name, [$4]) +])_m4_popdef([AC_name])]dnl +[$1(m4_expand([[@%:@define] $2 ]m4_if([$#], 2, 1, + [$3], [], [/**/], [[$3]]))) +]) + + + +## -------------------------- ## +## Setting output variables. ## +## -------------------------- ## + + +# AC_SUBST_TRACE(VARIABLE) +# ------------------------ +# This macro is used with --trace to collect the list of substituted variables. +m4_define([AC_SUBST_TRACE]) + + +# AC_SUBST(VARIABLE, [VALUE]) +# --------------------------- +# Create an output variable from a shell VARIABLE. If VALUE is given +# assign it to VARIABLE. Use `""' if you want to set VARIABLE to an +# empty value, not an empty second argument. +# +m4_define([AC_SUBST], +[AS_IDENTIFIER_IF([$1], [], + [m4_fatal([$0: `$1' is not a valid shell variable name])])]dnl +[AC_SUBST_TRACE([$1])]dnl +[m4_pattern_allow([^$1$])]dnl +[m4_ifvaln([$2], [$1=$2])[]]dnl +[m4_set_add([_AC_SUBST_VARS], [$1])])# AC_SUBST + + +# AC_SUBST_FILE(VARIABLE) +# ----------------------- +# Read the comments of the preceding macro. +m4_define([AC_SUBST_FILE], +[m4_pattern_allow([^$1$])dnl +m4_append_uniq([_AC_SUBST_FILES], [$1], [ +])]) + + + +## --------------------------------------- ## +## Printing messages at autoconf runtime. ## +## --------------------------------------- ## + +# In fact, I think we should promote the use of m4_warn and m4_fatal +# directly. This will also avoid to some people to get it wrong +# between AC_FATAL and AC_MSG_ERROR. + + +# AC_DIAGNOSE(CATEGORY, MESSAGE) +# AC_FATAL(MESSAGE, [EXIT-STATUS]) +# -------------------------------- +m4_define([AC_DIAGNOSE], [m4_warn($@)]) +m4_define([AC_FATAL], [m4_fatal($@)]) + + +# AC_WARNING(MESSAGE) +# ------------------- +# Report a MESSAGE to the user of autoconf if `-W' or `-W all' was +# specified. +m4_define([AC_WARNING], +[AC_DIAGNOSE([syntax], [$1])]) + + + + +## ---------------------------------------- ## +## Printing messages at configure runtime. ## +## ---------------------------------------- ## + + +# AC_MSG_CHECKING(FEATURE) +# ------------------------ +m4_define([AC_MSG_CHECKING], +[{ _AS_ECHO_LOG([checking $1]) +_AS_ECHO_N([checking $1... ]); }dnl +]) + + +# AC_MSG_RESULT(RESULT) +# --------------------- +m4_define([AC_MSG_RESULT], +[{ _AS_ECHO_LOG([result: $1]) +_AS_ECHO([$1]); }dnl +]) + + +# AC_MSG_WARN(PROBLEM) +# AC_MSG_NOTICE(STRING) +# AC_MSG_ERROR(ERROR, [EXIT-STATUS = 1]) +# AC_MSG_FAILURE(ERROR, [EXIT-STATUS = 1]) +# ---------------------------------------- +m4_copy([AS_WARN], [AC_MSG_WARN]) +m4_copy([AS_MESSAGE], [AC_MSG_NOTICE]) +m4_copy([AS_ERROR], [AC_MSG_ERROR]) +m4_define([AC_MSG_FAILURE], +[{ AS_MESSAGE([error: in `$ac_pwd':], 2) +AC_MSG_ERROR([$1 +See `config.log' for more details], [$2]); }]) + + +# _AC_MSG_LOG_CONFTEST +# -------------------- +m4_define([_AC_MSG_LOG_CONFTEST], +[AS_ECHO(["$as_me: failed program was:"]) >&AS_MESSAGE_LOG_FD +sed 's/^/| /' conftest.$ac_ext >&AS_MESSAGE_LOG_FD +]) + + +# AU::AC_CHECKING(FEATURE) +# ------------------------ +AU_DEFUN([AC_CHECKING], +[AS_MESSAGE([checking $1...])]) + + +# AU::AC_MSG_RESULT_UNQUOTED(RESULT) +# ---------------------------------- +# No escaping, so it performed also backtick substitution. +AU_DEFUN([AC_MSG_RESULT_UNQUOTED], +[_AS_ECHO_UNQUOTED([$as_me:${as_lineno-$LINENO}: result: $1], AS_MESSAGE_LOG_FD) +_AS_ECHO_UNQUOTED([$1])[]dnl +]) + + +# AU::AC_VERBOSE(STRING) +# ---------------------- +AU_ALIAS([AC_VERBOSE], [AC_MSG_RESULT]) + + + + + + +## ---------------------------- ## +## Compiler-running mechanics. ## +## ---------------------------- ## + + +# _AC_RUN_LOG(COMMAND, LOG-COMMANDS) +# ---------------------------------- +# Eval COMMAND, save the exit status in ac_status, and log it. The return +# code is 0 if COMMAND succeeded, so that it can be used directly in AS_IF +# constructs. +AC_DEFUN([_AC_RUN_LOG], +[{ { $2; } >&AS_MESSAGE_LOG_FD + ($1) 2>&AS_MESSAGE_LOG_FD + ac_status=$? + _AS_ECHO_LOG([\$? = $ac_status]) + test $ac_status = 0; }]) + + +# _AC_RUN_LOG_STDERR(COMMAND, LOG-COMMANDS) +# ----------------------------------------- +# Run COMMAND, save its stderr into conftest.err, save the exit status +# in ac_status, and log it. Don't forget to clean up conftest.err after +# use. +# Note that when tracing, most shells will leave the traces in stderr +# starting with "+": that's what this macro tries to address. +# The return code is 0 if COMMAND succeeded, so that it can be used directly +# in AS_IF constructs. +AC_DEFUN([_AC_RUN_LOG_STDERR], +[{ { $2; } >&AS_MESSAGE_LOG_FD + ($1) 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&AS_MESSAGE_LOG_FD + mv -f conftest.er1 conftest.err + fi + _AS_ECHO_LOG([\$? = $ac_status]) + test $ac_status = 0; }]) + + +# _AC_RUN_LOG_LIMIT(COMMAND, LOG-COMMANDS, [LINES]) +# ------------------------------------------------- +# Like _AC_RUN_LOG, but only log LINES lines from stderr, +# defaulting to 10 lines. +AC_DEFUN([_AC_RUN_LOG_LIMIT], +[{ { $2; } >&AS_MESSAGE_LOG_FD + ($1) 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed 'm4_default([$3], [10])a\ +... rest of stderr output deleted ... + m4_default([$3], [10])q' conftest.err >conftest.er1 + cat conftest.er1 >&AS_MESSAGE_LOG_FD + fi + rm -f conftest.er1 conftest.err + _AS_ECHO_LOG([\$? = $ac_status]) + test $ac_status = 0; }]) + + +# _AC_DO_ECHO(COMMAND) +# -------------------- +# Echo COMMAND. This is designed to be used just before evaluating COMMAND. +AC_DEFUN([_AC_DO_ECHO], +[m4_if([$1], [$ac_try], [], [ac_try="$1" +])]dnl +dnl If the string contains '\"', '`', or '\\', then just echo it rather +dnl than expanding it. This is a hack, but it is safer, while also +dnl typically expanding simple substrings like '$CC', which is what we want. +dnl +dnl Much of this macro body is quoted, to work around misuses like +dnl `AC_CHECK_FUNC(sigblock, , AC_CHECK_LIB(bsd, sigblock))', +dnl which underquotes the 3rd arg and would misbehave if we didn't quote here. +dnl The "(($ac_try" instead of $ac_try avoids problems with even-worse +dnl underquoting misuses, such as +dnl `AC_CHECK_FUNC(foo, , AC_CHECK_LIB(a, foo, , AC_CHECK_LIB(b, foo)))'. +dnl We normally wouldn't bother with this kind of workaround for invalid code +dnl but this change was put in just before Autoconf 2.60 and we wanted to +dnl minimize the integration hassle. +[[case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""] +AS_ECHO(["$ac_try_echo"])]) + +# _AC_DO(COMMAND) +# --------------- +# Eval COMMAND, save the exit status in ac_status, and log it. +# For internal use only. +AC_DEFUN([_AC_DO], +[_AC_RUN_LOG([eval "$1"], + [_AC_DO_ECHO([$1])])]) + + +# _AC_DO_STDERR(COMMAND) +# ---------------------- +# Like _AC_RUN_LOG_STDERR, but eval (instead of running) COMMAND. +AC_DEFUN([_AC_DO_STDERR], +[_AC_RUN_LOG_STDERR([eval "$1"], + [_AC_DO_ECHO([$1])])]) + + +# _AC_DO_VAR(VARIABLE) +# -------------------- +# Evaluate "$VARIABLE", which should be a valid shell command. +# The purpose of this macro is to write "configure:123: command line" +# into config.log for every test run. +AC_DEFUN([_AC_DO_VAR], +[_AC_DO([$$1])]) + + +# _AC_DO_TOKENS(COMMAND) +# ---------------------- +# Like _AC_DO_VAR, but execute COMMAND instead, where COMMAND is a series of +# tokens of the shell command language. +AC_DEFUN([_AC_DO_TOKENS], +[{ ac_try='$1' + _AC_DO([$ac_try]); }]) + + +# _AC_DO_LIMIT(COMMAND, [LINES]) +# ------------------------------ +# Like _AC_DO, but limit the amount of stderr lines logged to LINES. +# For internal use only. +AC_DEFUN([_AC_DO_LIMIT], +[_AC_RUN_LOG_LIMIT([eval "$1"], + [_AC_DO_ECHO([$1])], [$2])]) + + +# _AC_EVAL(COMMAND) +# ----------------- +# Eval COMMAND, save the exit status in ac_status, and log it. +# Unlike _AC_DO, this macro mishandles quoted arguments in some cases. +# It is present only for backward compatibility with previous Autoconf versions. +AC_DEFUN([_AC_EVAL], +[_AC_RUN_LOG([eval $1], + [eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$1\""])]) + + +# _AC_EVAL_STDERR(COMMAND) +# ------------------------ +# Like _AC_RUN_LOG_STDERR, but eval (instead of running) COMMAND. +# Unlike _AC_DO_STDERR, this macro mishandles quoted arguments in some cases. +# It is present only for backward compatibility with previous Autoconf versions. +AC_DEFUN([_AC_EVAL_STDERR], +[_AC_RUN_LOG_STDERR([eval $1], + [eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$1\""])]) + + +# AC_TRY_EVAL(VARIABLE) +# --------------------- +# Evaluate $VARIABLE, which should be a valid shell command. +# The purpose of this macro is to write "configure:123: command line" +# into config.log for every test run. +# +# The AC_TRY_EVAL and AC_TRY_COMMAND macros are dangerous and +# undocumented, and should not be used. +# They may be removed or their API changed in a future release. +# Autoconf itself no longer uses these two macros; they are present +# only for backward compatibility with previous versions of Autoconf. +# Not every shell command will work due to problems with eval +# and quoting, and the rules for exactly what does work are tricky. +# Worse, due to double-expansion during evaluation, arbitrary unintended +# shell commands could be executed in some situations. +AC_DEFUN([AC_TRY_EVAL], +[_AC_EVAL([$$1])]) + + +# AC_TRY_COMMAND(COMMAND) +# ----------------------- +# Like AC_TRY_EVAL, but execute COMMAND instead, where COMMAND is a series of +# tokens of the shell command language. +# This macro should not be used; see the comments under AC_TRY_EVAL for why. +AC_DEFUN([AC_TRY_COMMAND], +[{ ac_try='$1' + _AC_EVAL([$ac_try]); }]) + + +# AC_RUN_LOG(COMMAND) +# ------------------- +AC_DEFUN([AC_RUN_LOG], +[_AC_RUN_LOG([$1], + [AS_ECHO(["$as_me:${as_lineno-$LINENO}: AS_ESCAPE([$1])"])])]) + + + + +## ------------------------ ## +## Examining declarations. ## +## ------------------------ ## + + +# _AC_PREPROC_IFELSE_BODY +# ----------------------- +# Shell function body for _AC_PREPROC_IFELSE. +m4_define([_AC_PREPROC_IFELSE_BODY], +[ AS_LINENO_PUSH([$[]1]) + AS_IF([_AC_DO_STDERR([$ac_cpp conftest.$ac_ext]) > conftest.i && { + test -z "$ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag$ac_[]_AC_LANG_ABBREV[]_werror_flag" || + test ! -s conftest.err + }], + [ac_retval=0], + [_AC_MSG_LOG_CONFTEST + ac_retval=1]) + AS_LINENO_POP + AS_SET_STATUS([$ac_retval]) +])# _AC_PREPROC_IFELSE_BODY + + +# _AC_PREPROC_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ---------------------------------------------------------------- +# Try to preprocess PROGRAM. +# +# This macro can be used during the selection of a preprocessor. +# eval is necessary to expand ac_cpp. +AC_DEFUN([_AC_PREPROC_IFELSE], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_try_cpp], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_try_cpp], [LINENO], + [Try to preprocess conftest.$ac_ext, and return whether this succeeded.])], + [$0_BODY])]dnl +[m4_ifvaln([$1], [AC_LANG_CONFTEST([$1])])]dnl +[AS_IF([ac_fn_[]_AC_LANG_ABBREV[]_try_cpp "$LINENO"], [$2], [$3]) +rm -f conftest.err conftest.i[]m4_ifval([$1], [ conftest.$ac_ext])[]dnl +])# _AC_PREPROC_IFELSE + +# AC_PREPROC_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# --------------------------------------------------------------- +# Try to preprocess PROGRAM. Requires that the preprocessor for the +# current language was checked for, hence do not use this macro in macros +# looking for a preprocessor. +AC_DEFUN([AC_PREPROC_IFELSE], +[AC_LANG_PREPROC_REQUIRE()dnl +_AC_PREPROC_IFELSE($@)]) + + +# AC_TRY_CPP(INCLUDES, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# --------------------------------------------------------- +# AC_TRY_CPP is used to check whether particular header files exist. +# (But it actually tests whether INCLUDES produces no CPP errors.) +# +# INCLUDES are not defaulted and are double quoted. +AU_DEFUN([AC_TRY_CPP], +[AC_PREPROC_IFELSE([AC_LANG_SOURCE([[$1]])], [$2], [$3])]) + + +# AC_EGREP_CPP(PATTERN, PROGRAM, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------ +# Because this macro is used by AC_PROG_GCC_TRADITIONAL, which must +# come early, it is not included in AC_BEFORE checks. +AC_DEFUN([AC_EGREP_CPP], +[AC_LANG_PREPROC_REQUIRE()dnl +AC_REQUIRE([AC_PROG_EGREP])dnl +AC_LANG_CONFTEST([AC_LANG_SOURCE([[$2]])]) +AS_IF([dnl eval is necessary to expand ac_cpp. +dnl Ultrix and Pyramid sh refuse to redirect output of eval, so use subshell. +(eval "$ac_cpp conftest.$ac_ext") 2>&AS_MESSAGE_LOG_FD | +dnl Quote $1 to prevent m4 from eating character classes + $EGREP "[$1]" >/dev/null 2>&1], + [$3], + [$4]) +rm -f conftest* +])# AC_EGREP_CPP + + +# AC_EGREP_HEADER(PATTERN, HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# --------------------------------------------------------- +AC_DEFUN([AC_EGREP_HEADER], +[AC_EGREP_CPP([$1], +[#include <$2> +], [$3], [$4])]) + + + + +## ------------------ ## +## Examining syntax. ## +## ------------------ ## + +# _AC_COMPILE_IFELSE_BODY +# ----------------------- +# Shell function body for _AC_COMPILE_IFELSE. +m4_define([_AC_COMPILE_IFELSE_BODY], +[ AS_LINENO_PUSH([$[]1]) + rm -f conftest.$ac_objext + AS_IF([_AC_DO_STDERR($ac_compile) && { + test -z "$ac_[]_AC_LANG_ABBREV[]_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext], + [ac_retval=0], + [_AC_MSG_LOG_CONFTEST + ac_retval=1]) + AS_LINENO_POP + AS_SET_STATUS([$ac_retval]) +])# _AC_COMPILE_IFELSE_BODY + + +# _AC_COMPILE_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ---------------------------------------------------------------- +# Try to compile PROGRAM. +# This macro can be used during the selection of a compiler. +AC_DEFUN([_AC_COMPILE_IFELSE], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_try_compile], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_try_compile], [LINENO], + [Try to compile conftest.$ac_ext, and return whether this succeeded.])], + [$0_BODY])]dnl +[m4_ifvaln([$1], [AC_LANG_CONFTEST([$1])])]dnl +[AS_IF([ac_fn_[]_AC_LANG_ABBREV[]_try_compile "$LINENO"], [$2], [$3]) +rm -f core conftest.err conftest.$ac_objext[]m4_ifval([$1], [ conftest.$ac_ext])[]dnl +])# _AC_COMPILE_IFELSE + + +# AC_COMPILE_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# --------------------------------------------------------------- +# Try to compile PROGRAM. Requires that the compiler for the current +# language was checked for, hence do not use this macro in macros looking +# for a compiler. +AC_DEFUN([AC_COMPILE_IFELSE], +[AC_LANG_COMPILER_REQUIRE()dnl +_AC_COMPILE_IFELSE($@)]) + + +# AC_TRY_COMPILE(INCLUDES, FUNCTION-BODY, +# [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# --------------------------------------------------- +AU_DEFUN([AC_TRY_COMPILE], +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[$1]], [[$2]])], [$3], [$4])]) + + + +## --------------------- ## +## Examining libraries. ## +## --------------------- ## + + +# _AC_LINK_IFELSE_BODY +# -------------------- +# Shell function body for _AC_LINK_IFELSE. +m4_define([_AC_LINK_IFELSE_BODY], +[ AS_LINENO_PUSH([$[]1]) + rm -f conftest.$ac_objext conftest$ac_exeext + AS_IF([_AC_DO_STDERR($ac_link) && { + test -z "$ac_[]_AC_LANG_ABBREV[]_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + AS_TEST_X([conftest$ac_exeext]) + }], + [ac_retval=0], + [_AC_MSG_LOG_CONFTEST + ac_retval=1]) + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + AS_LINENO_POP + AS_SET_STATUS([$ac_retval]) +])# _AC_LINK_IFELSE_BODY + + +# _AC_LINK_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------------------- +# Try to link PROGRAM. +# This macro can be used during the selection of a compiler. +# +# Test that resulting file is executable; see the problem reported by mwoehlke +# in <http://lists.gnu.org/archive/html/bug-coreutils/2006-10/msg00048.html>. +# But skip the test when cross-compiling, to prevent problems like the one +# reported by Chris Johns in +# <http://lists.gnu.org/archive/html/autoconf/2007-03/msg00085.html>. +# +AC_DEFUN([_AC_LINK_IFELSE], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_try_link], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_try_link], [LINENO], + [Try to link conftest.$ac_ext, and return whether this succeeded.])], + [$0_BODY])]dnl +[m4_ifvaln([$1], [AC_LANG_CONFTEST([$1])])]dnl +[AS_IF([ac_fn_[]_AC_LANG_ABBREV[]_try_link "$LINENO"], [$2], [$3]) +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext[]m4_ifval([$1], [ conftest.$ac_ext])[]dnl +])# _AC_LINK_IFELSE + + +# AC_LINK_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------------------ +# Try to link PROGRAM. Requires that the compiler for the current +# language was checked for, hence do not use this macro in macros looking +# for a compiler. +AC_DEFUN([AC_LINK_IFELSE], +[AC_LANG_COMPILER_REQUIRE()dnl +_AC_LINK_IFELSE($@)]) + + +# AC_TRY_LINK(INCLUDES, FUNCTION-BODY, +# [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------ +# Contrarily to AC_LINK_IFELSE, this macro double quote its first two args. +AU_DEFUN([AC_TRY_LINK], +[AC_LINK_IFELSE([AC_LANG_PROGRAM([[$1]], [[$2]])], [$3], [$4])]) + + +# AC_COMPILE_CHECK(ECHO-TEXT, INCLUDES, FUNCTION-BODY, +# ACTION-IF-TRUE, [ACTION-IF-FALSE]) +# --------------------------------------------------- +AU_DEFUN([AC_COMPILE_CHECK], +[m4_ifvaln([$1], [AC_MSG_CHECKING([for $1])])dnl +AC_LINK_IFELSE([AC_LANG_PROGRAM([[$2]], [[$3]])], [$4], [$5])]) + + + + +## ------------------------------- ## +## Checking for runtime features. ## +## ------------------------------- ## + + +# _AC_RUN_IFELSE_BODY +# ------------------- +# Shell function body for _AC_RUN_IFELSE. +m4_define([_AC_RUN_IFELSE_BODY], +[ AS_LINENO_PUSH([$[]1]) + AS_IF([_AC_DO_VAR(ac_link) && _AC_DO_TOKENS(./conftest$ac_exeext)], + [ac_retval=0], + [AS_ECHO(["$as_me: program exited with status $ac_status"]) >&AS_MESSAGE_LOG_FD + _AC_MSG_LOG_CONFTEST + ac_retval=$ac_status]) + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + AS_LINENO_POP + AS_SET_STATUS([$ac_retval]) +])# _AC_RUN_IFELSE_BODY + + +# _AC_RUN_IFELSE(PROGRAM, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# ------------------------------------------------------------ +# Compile, link, and run. +# This macro can be used during the selection of a compiler. +# We also remove conftest.o as if the compilation fails, some compilers +# don't remove it. We remove gmon.out and bb.out, which may be +# created during the run if the program is built with profiling support. +AC_DEFUN([_AC_RUN_IFELSE], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_try_run], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_try_run], [LINENO], + [Try to link conftest.$ac_ext, and return whether this succeeded. + Assumes that executables *can* be run.])], + [$0_BODY])]dnl +[m4_ifvaln([$1], [AC_LANG_CONFTEST([$1])])]dnl +[AS_IF([ac_fn_[]_AC_LANG_ABBREV[]_try_run "$LINENO"], [$2], [$3]) +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam[]m4_ifval([$1], [ conftest.$ac_ext])[]dnl +])# _AC_RUN_IFELSE + +# AC_RUN_IFELSE(PROGRAM, +# [ACTION-IF-TRUE], [ACTION-IF-FALSE], +# [ACTION-IF-CROSS-COMPILING = RUNTIME-ERROR]) +# ---------------------------------------------------------- +# Compile, link, and run. Requires that the compiler for the current +# language was checked for, hence do not use this macro in macros looking +# for a compiler. +AC_DEFUN([AC_RUN_IFELSE], +[AC_LANG_COMPILER_REQUIRE()dnl +m4_ifval([$4], [], + [AC_DIAGNOSE([cross], + [$0 called without default to allow cross compiling])])dnl +AS_IF([test "$cross_compiling" = yes], + [m4_default([$4], + [AC_MSG_FAILURE([cannot run test program while cross compiling])])], + [_AC_RUN_IFELSE($@)]) +]) + + +# AC_TRY_RUN(PROGRAM, +# [ACTION-IF-TRUE], [ACTION-IF-FALSE], +# [ACTION-IF-CROSS-COMPILING = RUNTIME-ERROR]) +# ------------------------------------------------------- +AU_DEFUN([AC_TRY_RUN], +[AC_RUN_IFELSE([AC_LANG_SOURCE([[$1]])], [$2], [$3], [$4])]) + + + +## ------------------------------------- ## +## Checking for the existence of files. ## +## ------------------------------------- ## + +# AC_CHECK_FILE(FILE, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ------------------------------------------------------------- +# +# Check for the existence of FILE. +AC_DEFUN([AC_CHECK_FILE], +[AC_DIAGNOSE([cross], + [cannot check for file existence when cross compiling])dnl +AS_VAR_PUSHDEF([ac_File], [ac_cv_file_$1])dnl +AC_CACHE_CHECK([for $1], [ac_File], +[test "$cross_compiling" = yes && + AC_MSG_ERROR([cannot check for file existence when cross compiling]) +if test -r "$1"; then + AS_VAR_SET([ac_File], [yes]) +else + AS_VAR_SET([ac_File], [no]) +fi]) +AS_VAR_IF([ac_File], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_File])dnl +])# AC_CHECK_FILE + + +# _AC_CHECK_FILES(FILE) +# --------------------- +# Helper to AC_CHECK_FILES, which generates two of the three arguments +# to AC_CHECK_FILE based on FILE. +m4_define([_AC_CHECK_FILES], +[[$1], [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$1]), [1], + [Define to 1 if you have the file `$1'.])]]) + + +# AC_CHECK_FILES(FILE..., [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# ----------------------------------------------------------------- +# For each word in the whitespace-separated FILE list, perform either +# ACTION-IF-FOUND or ACTION-IF-NOT-FOUND. For files that exist, also +# provide the preprocessor variable HAVE_FILE. +AC_DEFUN([AC_CHECK_FILES], +[m4_map_args_w([$1], [AC_CHECK_FILE(_$0(], [)[$2], [$3])])]) + + +## ------------------------------- ## +## Checking for declared symbols. ## +## ------------------------------- ## + + +# _AC_CHECK_DECL_BODY +# ------------------- +# Shell function body for AC_CHECK_DECL. +m4_define([_AC_CHECK_DECL_BODY], +[ AS_LINENO_PUSH([$[]1]) + [as_decl_name=`echo $][2|sed 's/ *(.*//'`] + [as_decl_use=`echo $][2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`] + AC_CACHE_CHECK([whether $as_decl_name is declared], [$[]3], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$[]4], +[@%:@ifndef $[]as_decl_name +@%:@ifdef __cplusplus + (void) $[]as_decl_use; +@%:@else + (void) $[]as_decl_name; +@%:@endif +@%:@endif +])], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [no])])]) + AS_LINENO_POP +])# _AC_CHECK_DECL_BODY + +# AC_CHECK_DECL(SYMBOL, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# ------------------------------------------------------- +# Check whether SYMBOL (a function, variable, or constant) is declared. +AC_DEFUN([AC_CHECK_DECL], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_decl], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_decl], + [LINENO SYMBOL VAR INCLUDES], + [Tests whether SYMBOL is declared in INCLUDES, setting cache variable + VAR accordingly.])], + [_$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_Symbol], [ac_cv_have_decl_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_decl ]dnl +["$LINENO" "$1" "ac_Symbol" "AS_ESCAPE([AC_INCLUDES_DEFAULT([$4])], [""])" +AS_VAR_IF([ac_Symbol], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Symbol])dnl +])# AC_CHECK_DECL + + +# _AC_CHECK_DECLS(SYMBOL, ACTION-IF_FOUND, ACTION-IF-NOT-FOUND, +# INCLUDES) +# ------------------------------------------------------------- +# Helper to AC_CHECK_DECLS, which generates the check for a single +# SYMBOL with INCLUDES, performs the AC_DEFINE, then expands +# ACTION-IF-FOUND or ACTION-IF-NOT-FOUND. +m4_define([_AC_CHECK_DECLS], +[AC_CHECK_DECL([$1], [ac_have_decl=1], [ac_have_decl=0], [$4])]dnl +[AC_DEFINE_UNQUOTED(AS_TR_CPP(m4_bpatsubst(HAVE_DECL_[$1],[ *(.*])), + [$ac_have_decl], + [Define to 1 if you have the declaration of `$1', + and to 0 if you don't.])]dnl +[m4_ifvaln([$2$3], [AS_IF([test $ac_have_decl = 1], [$2], [$3])])]) + +# AC_CHECK_DECLS(SYMBOLS, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# -------------------------------------------------------- +# Defines HAVE_DECL_SYMBOL to 1 if declared, 0 otherwise. See the +# documentation for a detailed explanation of this difference with +# other AC_CHECK_*S macros. SYMBOLS is an m4 list. +AC_DEFUN([AC_CHECK_DECLS], +[m4_map_args_sep([_$0(], [, [$2], [$3], [$4])], [], $1)]) + + +# _AC_CHECK_DECL_ONCE(SYMBOL) +# --------------------------- +# Check for a single SYMBOL once. +m4_define([_AC_CHECK_DECL_ONCE], +[AC_DEFUN([_AC_Check_Decl_$1], [_AC_CHECK_DECLS([$1])])]dnl +[AC_REQUIRE([_AC_Check_Decl_$1])]) + +# AC_CHECK_DECLS_ONCE(SYMBOLS) +# ---------------------------- +# Like AC_CHECK_DECLS(SYMBOLS), but do it at most once. +AC_DEFUN([AC_CHECK_DECLS_ONCE], +[m4_map_args_sep([_AC_CHECK_DECL_ONCE(], [)], [], $1)]) + + + +## ---------------------------------- ## +## Replacement of library functions. ## +## ---------------------------------- ## + + +# AC_CONFIG_LIBOBJ_DIR(DIRNAME) +# ----------------------------- +# Announce LIBOBJ replacement files are in $top_srcdir/DIRNAME. +AC_DEFUN_ONCE([AC_CONFIG_LIBOBJ_DIR], +[m4_divert_text([DEFAULTS], [ac_config_libobj_dir=$1])]) + + +# AC_LIBSOURCE(FILE-NAME) +# ----------------------- +# Announce we might need the file `FILE-NAME'. +m4_define([AC_LIBSOURCE], []) + + +# AC_LIBSOURCES([FILE-NAME1, ...]) +# -------------------------------- +# Announce we might need these files. +AC_DEFUN([AC_LIBSOURCES], +[m4_map_args([AC_LIBSOURCE], $1)]) + + +# _AC_LIBOBJ(FILE-NAME-NOEXT, ACTION-IF-INDIR) +# -------------------------------------------- +# We need `FILE-NAME-NOEXT.o', save this into `LIBOBJS'. +m4_define([_AC_LIBOBJ], +[case " $LIB@&t@OBJS " in + *" $1.$ac_objext "* ) ;; + *) AC_SUBST([LIB@&t@OBJS], ["$LIB@&t@OBJS $1.$ac_objext"]) ;; +esac +]) + + +# AC_LIBOBJ(FILE-NAME-NOEXT) +# -------------------------- +# We need `FILE-NAME-NOEXT.o', save this into `LIBOBJS'. +AC_DEFUN([AC_LIBOBJ], +[_AC_LIBOBJ([$1])]dnl +[AS_LITERAL_WORD_IF([$1], [AC_LIBSOURCE([$1.c])], + [AC_DIAGNOSE([syntax], [$0($1): you should use literals])])]) + + +# _AC_LIBOBJS_NORMALIZE +# --------------------- +# Clean up LIBOBJS and LTLIBOBJS so that they work with 1. ac_objext, +# 2. Automake's ANSI2KNR, 3. Libtool, 4. combination of the three. +# Used with AC_CONFIG_COMMANDS_PRE. +AC_DEFUN([_AC_LIBOBJS_NORMALIZE], +[ac_libobjs= +ac_ltlibobjs= +m4_ifndef([AM_C_PROTOTYPES], [U= +])dnl +for ac_i in : $LIB@&t@OBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`AS_ECHO(["$ac_i"]) | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + AS_VAR_APPEND([ac_libobjs], [" \${LIBOBJDIR}$ac_i\$U.$ac_objext"]) + AS_VAR_APPEND([ac_ltlibobjs], [" \${LIBOBJDIR}$ac_i"'$U.lo']) +done +AC_SUBST([LIB@&t@OBJS], [$ac_libobjs]) +AC_SUBST([LTLIBOBJS], [$ac_ltlibobjs]) +]) + + +## ----------------------------------- ## +## Checking compiler characteristics. ## +## ----------------------------------- ## + + +# _AC_COMPUTE_INT_COMPILE(EXPRESSION, VARIABLE, PROLOGUE, [IF-SUCCESS], +# [IF-FAILURE]) +# --------------------------------------------------------------------- +# Compute the integer EXPRESSION and store the result in the VARIABLE. +# Works OK if cross compiling, but assumes twos-complement arithmetic. +m4_define([_AC_COMPUTE_INT_COMPILE], +[# Depending upon the size, compute the lo and hi bounds. +_AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$3], [($1) >= 0])], + [ac_lo=0 ac_mid=0 + while :; do + _AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$3], [($1) <= $ac_mid])], + [ac_hi=$ac_mid; break], + [AS_VAR_ARITH([ac_lo], [$ac_mid + 1]) + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + AS_VAR_ARITH([ac_mid], [2 '*' $ac_mid + 1])]) + done], +[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$3], [($1) < 0])], + [ac_hi=-1 ac_mid=-1 + while :; do + _AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$3], [($1) >= $ac_mid])], + [ac_lo=$ac_mid; break], + [AS_VAR_ARITH([ac_hi], ['(' $ac_mid ')' - 1]) + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + AS_VAR_ARITH([ac_mid], [2 '*' $ac_mid])]) + done], + [ac_lo= ac_hi=])]) +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + AS_VAR_ARITH([ac_mid], ['(' $ac_hi - $ac_lo ')' / 2 + $ac_lo]) + _AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$3], [($1) <= $ac_mid])], + [ac_hi=$ac_mid], + [AS_VAR_ARITH([ac_lo], ['(' $ac_mid ')' + 1])]) +done +case $ac_lo in @%:@(( +?*) AS_VAR_SET([$2], [$ac_lo]); $4 ;; +'') $5 ;; +esac[]dnl +])# _AC_COMPUTE_INT_COMPILE + + +# _AC_COMPUTE_INT_RUN(EXPRESSION, VARIABLE, PROLOGUE, [IF-SUCCESS], +# [IF-FAILURE]) +# ----------------------------------------------------------------- +# Store the evaluation of the integer EXPRESSION in VARIABLE. +# +# AC_LANG_INT_SAVE intentionally does not end the file in a newline, so +# we must add one to make it a text file before passing it to read. +m4_define([_AC_COMPUTE_INT_RUN], +[_AC_RUN_IFELSE([AC_LANG_INT_SAVE([$3], [$1])], + [echo >>conftest.val; read $2 <conftest.val; $4], [$5]) +rm -f conftest.val +])# _AC_COMPUTE_INT_RUN + + +# _AC_COMPUTE_INT_BODY +# -------------------- +# Shell function body for AC_COMPUTE_INT. +m4_define([_AC_COMPUTE_INT_BODY], +[ AS_LINENO_PUSH([$[]1]) + if test "$cross_compiling" = yes; then + _AC_COMPUTE_INT_COMPILE([$[]2], [$[]3], [$[]4], + [ac_retval=0], [ac_retval=1]) + else + _AC_COMPUTE_INT_RUN([$[]2], [$[]3], [$[]4], + [ac_retval=0], [ac_retval=1]) + fi + AS_LINENO_POP + AS_SET_STATUS([$ac_retval]) +])# _AC_COMPUTE_INT_BODY + +# AC_COMPUTE_INT(VARIABLE, EXPRESSION, PROLOGUE, [IF-FAILS]) +# ---------------------------------------------------------- +# Store into the shell variable VARIABLE the value of the integer C expression +# EXPRESSION. The value should fit in an initializer in a C variable of type +# `signed long'. If no PROLOGUE are specified, the default includes are used. +# IF-FAILS is evaluated if the value cannot be found (which includes the +# case of cross-compilation, if EXPRESSION is not computable at compile-time. +AC_DEFUN([AC_COMPUTE_INT], +[AC_LANG_COMPILER_REQUIRE()]dnl +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_compute_int], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_compute_int], + [LINENO EXPR VAR INCLUDES], + [Tries to find the compile-time value of EXPR in a program that includes + INCLUDES, setting VAR accordingly. Returns whether the value could + be computed])], + [_$0_BODY])]dnl +[AS_IF([ac_fn_[]_AC_LANG_ABBREV[]_compute_int "$LINENO" "$2" "$1" ]dnl + ["AS_ESCAPE([$3], [""])"], + [], [$4]) +])# AC_COMPUTE_INT + +# _AC_COMPUTE_INT(EXPRESSION, VARIABLE, PROLOGUE, [IF-FAILS]) +# ----------------------------------------------------------- +# FIXME: this private interface was used by several packages. +# Give them time to transition to AC_COMPUTE_INT and then delete this one. +AC_DEFUN([_AC_COMPUTE_INT], +[AC_COMPUTE_INT([$2], [$1], [$3], [$4]) +AC_DIAGNOSE([obsolete], +[The macro `_AC_COMPUTE_INT' is obsolete and will be deleted in a +future version or Autoconf. Hence, it is suggested that you use +instead the public AC_COMPUTE_INT macro. Note that the arguments are +slightly different between the two.])dnl +])# _AC_COMPUTE_INT diff --git a/lib/autoconf/go.m4 b/lib/autoconf/go.m4 new file mode 100644 index 0000000..bf215bf --- /dev/null +++ b/lib/autoconf/go.m4 @@ -0,0 +1,177 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Go language support. +# Copyright (C) 2011-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Go support contributed by Ian Lance Taylor. + +# This currently only supports gccgo, not 6g/8g/5g. + +# ------------------- # +# Language selection. +# ------------------- # + +# AC_LANG(Go) +# ----------- +AC_LANG_DEFINE([Go], [go], [GO], [GOC], [], +[ac_ext=go +ac_compile='$GOC -c $GOFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' +ac_link='$GOC -o conftest$ac_exeext $GOFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' +ac_compiler_gnu=yes +]) + +# AC_LANG_GO +# ---------- +AU_DEFUN([AC_LANG_GO], [AC_LANG(Go)]) + +# ------------------- # +# Producing programs. +# ------------------- # + +# AC_LANG_PROGRAM(Go)([PROLOGUE], [BODY]) +# --------------------------------------- +m4_define([AC_LANG_PROGRAM(Go)], +[package main +$1 +func main() { +$2 +}]) + +# _AC_LANG_IO_PROGRAM(Go) +# ----------------------- +# Produce source that performs I/O. +m4_define([_AC_LANG_IO_PROGRAM(Go)], +[AC_LANG_PROGRAM([import ( "fmt"; "os" )], +[f, err := os.Open("conftest.out", os.O_CREATE|os.O_WRONLY, 0777) + if err != nil { + fmt.Println(err) + os.Exit(1) + } + if err = f.Close(); err != nil { + fmt.Println(err) + os.Exit(1) + } + os.Exit(0) +])]) + +# AC_LANG_CALL(Go)(PROLOGUE, FUNCTION) +# ------------------------------------ +# Avoid conflicting decl of main. +m4_define([AC_LANG_CALL(Go)], +[AC_LANG_PROGRAM([$1 +m4_if([$2], [main], , +[func $2()])],[$2()])]) + +# AC_LANG_FUNC_LINK_TRY(Go)(FUNCTION) +# ----------------------------------- +# Try to link a program which calls FUNCTION. +m4_define([AC_LANG_FUNC_LINK_TRY(Go)], +[AC_LANG_PROGRAM( +[func $1() int +var f = $1 +], [return f()])]) + +# AC_LANG_BOOL_COMPILE_TRY(Go)(PROLOGUE, EXPRESSION) +# -------------------------------------------------- +# Return a program which is valid if EXPRESSION is nonzero. +m4_define([AC_LANG_BOOL_COMPILE_TRY(Go)], +[AC_LANG_PROGRAM([$1], [var test_array @<:@1 - 2 * !($2)@:>@int +test_array @<:@0@:>@ = 0 +])]) + +# AC_LANG_INT_SAVE(Go)(PROLOGUE, EXPRESSION) +# ------------------------------------------ +m4_define([AC_LANG_INT_SAVE(Go)], +[AC_LANG_PROGRAM([$1 +import ( + "fmt" + "os" +) +], +[f, err := os.Open("conftest.val", os.O_CREATE|os.O_WRONLY, 0777) + if err != nil { + os.Exit(1) + } + if $2 < 0 { + int64 i = int64($2) + if i != $2 { + os.Exit(1) + } + if _, err := fmt.Print(f, i); err != nil { + os.Exit(1) + } + } else { + uint64 i = uint64($2) + if i != $2 { + os.Exit(1) + } + if _, err := fmt.Print(f, i); err != nil { + os.Exit(1) + } + } + if err = f.Close(); err != nil { + os.Exit(1) + } + os.Exit(0); +])]) + +# ---------------------- # +# Looking for compilers. # +# ---------------------- # + +# AC_LANG_COMPILER(Go) +# -------------------- +AC_DEFUN([AC_LANG_COMPILER(Go)], +[AC_REQUIRE([AC_PROG_GO])]) + +# AC_PROG_GO +# ---------- +AN_MAKEVAR([GOC], [AC_PROG_GO]) +AN_PROGRAM([gccgo], [AC_PROG_GO]) +AC_DEFUN([AC_PROG_GO], +[AC_LANG_PUSH(Go)dnl +AC_ARG_VAR([GOC], [Go compiler command])dnl +AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +m4_ifval([$1], + [AC_CHECK_TOOLS(GOC, [$1])], +[AC_CHECK_TOOL(GOC, gccgo) +if test -z "$GOC"; then + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [$ac_tool_prefix}gccgo]) + fi +fi +if test -z "$GOC"; then + AC_CHECK_PROG(GOC, gccgo, gccgo, , , false) +fi +]) + +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +_AC_DO_LIMIT([$ac_compiler --version >&AS_MESSAGE_LOG_FD]) +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +GOFLAGS="-g -O2" +AC_LANG_POP(Go)dnl +])# AC_PROG_GO diff --git a/lib/autoconf/headers.m4 b/lib/autoconf/headers.m4 new file mode 100644 index 0000000..81a7fa2 --- /dev/null +++ b/lib/autoconf/headers.m4 @@ -0,0 +1,895 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Checking for headers. +# +# Copyright (C) 1988, 1999-2004, 2006, 2008-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# Table of contents +# +# 1. Generic tests for headers +# 2. Default includes +# 3. Headers to tests with AC_CHECK_HEADERS +# 4. Tests for specific headers + + +## ------------------------------ ## +## 1. Generic tests for headers. ## +## ------------------------------ ## + + +# AC_CHECK_HEADER(HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES]) +# --------------------------------------------------------- +# We are slowly moving to checking headers with the compiler instead +# of the preproc, so that we actually learn about the usability of a +# header instead of its mere presence. But since users are used to +# the old semantics, they check for headers in random order and +# without providing prerequisite headers. This macro implements the +# transition phase, and should be cleaned up latter to use compilation +# only. +# +# If INCLUDES is empty, then check both via the compiler and preproc. +# If the results are different, issue a warning, but keep the preproc +# result. +# +# If INCLUDES is `-', keep only the old semantics. +# +# If INCLUDES is specified and different from `-', then use the new +# semantics only. +# +# The m4_indir allows for fewer expansions of $@. +AC_DEFUN([AC_CHECK_HEADER], +[m4_indir(m4_case([$4], + [], [[_AC_CHECK_HEADER_MONGREL]], + [-], [[_AC_CHECK_HEADER_PREPROC]], + [[_AC_CHECK_HEADER_COMPILE]]), $@) +])# AC_CHECK_HEADER + + +# _AC_CHECK_HEADER_MONGREL_BODY +# ----------------------------- +# Shell function body for _AC_CHECK_HEADER_MONGREL +m4_define([_AC_CHECK_HEADER_MONGREL_BODY], +[ AS_LINENO_PUSH([$[]1]) + AS_VAR_SET_IF([$[]3], + [AC_CACHE_CHECK([for $[]2], [$[]3], [])], + [# Is the header compilable? +AC_MSG_CHECKING([$[]2 usability]) +AC_COMPILE_IFELSE([AC_LANG_SOURCE([$[]4 +@%:@include <$[]2>])], + [ac_header_compiler=yes], + [ac_header_compiler=no]) +AC_MSG_RESULT([$ac_header_compiler]) + +# Is the header present? +AC_MSG_CHECKING([$[]2 presence]) +AC_PREPROC_IFELSE([AC_LANG_SOURCE([@%:@include <$[]2>])], + [ac_header_preproc=yes], + [ac_header_preproc=no]) +AC_MSG_RESULT([$ac_header_preproc]) + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in #(( + yes:no: ) + AC_MSG_WARN([$[]2: accepted by the compiler, rejected by the preprocessor!]) + AC_MSG_WARN([$[]2: proceeding with the compiler's result]) + ;; + no:yes:* ) + AC_MSG_WARN([$[]2: present but cannot be compiled]) + AC_MSG_WARN([$[]2: check for missing prerequisite headers?]) + AC_MSG_WARN([$[]2: see the Autoconf documentation]) + AC_MSG_WARN([$[]2: section "Present But Cannot Be Compiled"]) + AC_MSG_WARN([$[]2: proceeding with the compiler's result]) +m4_ifset([AC_PACKAGE_BUGREPORT], +[m4_n([( AS_BOX([Report this to ]AC_PACKAGE_BUGREPORT) + ) | sed "s/^/$as_me: WARNING: /" >&2])])dnl + ;; +esac + AC_CACHE_CHECK([for $[]2], [$[]3], + [AS_VAR_SET([$[]3], [$ac_header_compiler])])]) + AS_LINENO_POP +])#_AC_CHECK_HEADER_MONGREL_BODY + +# _AC_CHECK_HEADER_MONGREL(HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# ------------------------------------------------------------------ +# Check using both the compiler and the preprocessor. If they disagree, +# warn, and the preproc wins. +# +# This is not based on _AC_CHECK_HEADER_COMPILE and _AC_CHECK_HEADER_PREPROC +# because it obfuscate the code to try to factor everything, in particular +# because of the cache variables, and the `checking ...' messages. +AC_DEFUN([_AC_CHECK_HEADER_MONGREL], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_header_mongrel], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_header_mongrel], + [LINENO HEADER VAR INCLUDES], + [Tests whether HEADER exists, giving a warning if it cannot be compiled + using the include files in INCLUDES and setting the cache variable VAR + accordingly.])], + [$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_Header], [ac_cv_header_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_header_mongrel ]dnl +["$LINENO" "$1" "ac_Header" "AS_ESCAPE([AC_INCLUDES_DEFAULT([$4])], [""])" +AS_VAR_IF([ac_Header], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Header])])# _AC_CHECK_HEADER_MONGREL + + +# _AC_CHECK_HEADER_COMPILE_BODY +# ----------------------------- +# Shell function body for _AC_CHECK_HEADER_COMPILE +m4_define([_AC_CHECK_HEADER_COMPILE_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for $[]2], [$[]3], + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([$[]4 +@%:@include <$[]2>])], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [no])])]) + AS_LINENO_POP +])# _AC_CHECK_HEADER_COMPILE_BODY + +# _AC_CHECK_HEADER_COMPILE(HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# -------------------------------------------------------------- +# Check the compiler accepts HEADER-FILE. The INCLUDES are defaulted. +AC_DEFUN([_AC_CHECK_HEADER_COMPILE], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_header_compile], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_header_compile], + [LINENO HEADER VAR INCLUDES], + [Tests whether HEADER exists and can be compiled using the include files + in INCLUDES, setting the cache variable VAR accordingly.])], + [$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_Header], [ac_cv_header_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_header_compile ]dnl +["$LINENO" "$1" "ac_Header" "AS_ESCAPE([AC_INCLUDES_DEFAULT([$4])], [""])" +AS_VAR_IF([ac_Header], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Header])])# _AC_CHECK_HEADER_COMPILE + +# _AC_CHECK_HEADER_PREPROC_BODY +# ----------------------------- +# Shell function body for _AC_CHECK_HEADER_PREPROC. +m4_define([_AC_CHECK_HEADER_PREPROC_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for $[]2], [$[]3], + [AC_PREPROC_IFELSE([AC_LANG_SOURCE([@%:@include <$[]2>])], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [no])])]) + AS_LINENO_POP +])# _AC_CHECK_HEADER_PREPROC_BODY + + + +# _AC_CHECK_HEADER_PREPROC(HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# -------------------------------------------------------------- +# Check the preprocessor accepts HEADER-FILE. +AC_DEFUN([_AC_CHECK_HEADER_PREPROC], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_header_preproc], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_header_preproc], + [LINENO HEADER VAR], + [Tests whether HEADER is present, setting the cache variable VAR accordingly.])], + [$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_Header], [ac_cv_header_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_header_preproc "$LINENO" "$1" "ac_Header" +AS_VAR_IF([ac_Header], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Header])dnl +])# _AC_CHECK_HEADER_PREPROC + +# _AC_CHECK_HEADER_OLD(HEADER-FILE, [ACTION-IF-FOUND], +# [ACTION-IF-NOT-FOUND]) +# _AC_CHECK_HEADER_NEW(HEADER-FILE, [ACTION-IF-FOUND], +# [ACTION-IF-NOT-FOUND]) +# ---------------------------------------------------- +# Some packages used these undocumented macros. Even worse, gcc +# redefined AC_CHECK_HEADER in terms of _AC_CHECK_HEADER_OLD, so we +# can't do the simpler: +# AU_DEFUN([_AC_CHECK_HEADER_OLD], +# [AC_CHECK_HEADER([$1], [$2], [$3], [-])]) +AC_DEFUN([_AC_CHECK_HEADER_OLD], +[AC_DIAGNOSE([obsolete], [The macro `$0' is obsolete. +You should use AC_CHECK_HEADER with a fourth argument.])]dnl +[_AC_CHECK_HEADER_PREPROC($@)]) + +AC_DEFUN([_AC_CHECK_HEADER_NEW], +[AC_DIAGNOSE([obsolete], [The macro `$0' is obsolete. +You should use AC_CHECK_HEADER with a fourth argument.])]dnl +[_AC_CHECK_HEADER_COMPILE($@)]) + + +# _AH_CHECK_HEADER(HEADER-FILE) +# ----------------------------- +# Prepare the autoheader snippet for HEADER-FILE. +m4_define([_AH_CHECK_HEADER], +[AH_TEMPLATE(AS_TR_CPP([HAVE_$1]), + [Define to 1 if you have the <$1> header file.])]) + + +# AH_CHECK_HEADERS(HEADER-FILE...) +# -------------------------------- +m4_define([AH_CHECK_HEADERS], +[m4_foreach_w([AC_Header], [$1], [_AH_CHECK_HEADER(m4_defn([AC_Header]))])]) + + +# AC_CHECK_HEADERS(HEADER-FILE..., +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES]) +# ---------------------------------------------------------- +# Check for each whitespace-separated HEADER-FILE (omitting the <> or +# ""), and perform ACTION-IF-FOUND or ACTION-IF-NOT-FOUND for each +# header. INCLUDES is as for AC_CHECK_HEADER. Additionally, make the +# preprocessor definition HAVE_HEADER_FILE available for each found +# header. Either ACTION may include `break' to stop the search. +AC_DEFUN([AC_CHECK_HEADERS], +[m4_map_args_w([$1], [_AH_CHECK_HEADER(], [)])]dnl +[AS_FOR([AC_header], [ac_header], [$1], +[AC_CHECK_HEADER(AC_header, + [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_]AC_header)) $2], + [$3], [$4])dnl]) +])# AC_CHECK_HEADERS + + +# _AC_CHECK_HEADER_ONCE(HEADER-FILE) +# ---------------------------------- +# Check for a single HEADER-FILE once. +m4_define([_AC_CHECK_HEADER_ONCE], +[_AH_CHECK_HEADER([$1])AC_DEFUN([_AC_Header_]m4_translit([[$1]], + [./-], [___]), + [m4_divert_text([INIT_PREPARE], [AS_VAR_APPEND([ac_header_list], [" $1"])]) +_AC_HEADERS_EXPANSION])AC_REQUIRE([_AC_Header_]m4_translit([[$1]], + [./-], [___]))]) + + +# AC_CHECK_HEADERS_ONCE(HEADER-FILE...) +# ------------------------------------- +# Add each whitespace-separated name in HEADER-FILE to the list of +# headers to check once. +AC_DEFUN([AC_CHECK_HEADERS_ONCE], +[m4_map_args_w([$1], [_AC_CHECK_HEADER_ONCE(], [)])]) + +m4_define([_AC_HEADERS_EXPANSION], +[ + m4_divert_text([DEFAULTS], [ac_header_list=]) + AC_CHECK_HEADERS([$ac_header_list], [], [], [AC_INCLUDES_DEFAULT]) + m4_define([_AC_HEADERS_EXPANSION], []) +]) + + + + +## --------------------- ## +## 2. Default includes. ## +## --------------------- ## + +# Always use the same set of default headers for all the generic +# macros. It is easier to document, to extend, and to understand than +# having specific defaults for each macro. + +# _AC_INCLUDES_DEFAULT_REQUIREMENTS +# --------------------------------- +# Required when AC_INCLUDES_DEFAULT uses its default branch. +AC_DEFUN([_AC_INCLUDES_DEFAULT_REQUIREMENTS], +[m4_divert_text([DEFAULTS], +[# Factoring default headers for most tests. +dnl If ever you change this variable, please keep autoconf.texi in sync. +ac_includes_default="\ +#include <stdio.h> +#ifdef HAVE_SYS_TYPES_H +# include <sys/types.h> +#endif +#ifdef HAVE_SYS_STAT_H +# include <sys/stat.h> +#endif +#ifdef STDC_HEADERS +# include <stdlib.h> +# include <stddef.h> +#else +# ifdef HAVE_STDLIB_H +# include <stdlib.h> +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include <memory.h> +# endif +# include <string.h> +#endif +#ifdef HAVE_STRINGS_H +# include <strings.h> +#endif +#ifdef HAVE_INTTYPES_H +# include <inttypes.h> +#endif +#ifdef HAVE_STDINT_H +# include <stdint.h> +#endif +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif" +])dnl +AC_REQUIRE([AC_HEADER_STDC])dnl +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +AC_CHECK_HEADERS([sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h], + [], [], $ac_includes_default) +])# _AC_INCLUDES_DEFAULT_REQUIREMENTS + + +# AC_INCLUDES_DEFAULT([INCLUDES]) +# ------------------------------- +# If INCLUDES is empty, expand in default includes, otherwise in +# INCLUDES. +# In most cases INCLUDES is not double quoted as it should, and if +# for instance INCLUDES = `#include <stdio.h>' then unless we force +# a newline, the hash will swallow the closing paren etc. etc. +# The usual failure. +# Take no risk: for the newline. +AC_DEFUN([AC_INCLUDES_DEFAULT], +[m4_ifval([$1], [$1 +], + [AC_REQUIRE([_AC_INCLUDES_DEFAULT_REQUIREMENTS])dnl +$ac_includes_default])]) + + + + + +## ------------------------------------------- ## +## 3. Headers to check with AC_CHECK_HEADERS. ## +## ------------------------------------------- ## + +# errno.h is portable. + +AN_HEADER([OS.h], [AC_CHECK_HEADERS]) +AN_HEADER([argz.h], [AC_CHECK_HEADERS]) +AN_HEADER([arpa/inet.h], [AC_CHECK_HEADERS]) +AN_HEADER([fcntl.h], [AC_CHECK_HEADERS]) +AN_HEADER([fenv.h], [AC_CHECK_HEADERS]) +AN_HEADER([float.h], [AC_CHECK_HEADERS]) +AN_HEADER([fs_info.h], [AC_CHECK_HEADERS]) +AN_HEADER([inttypes.h], [AC_CHECK_HEADERS]) +AN_HEADER([langinfo.h], [AC_CHECK_HEADERS]) +AN_HEADER([libintl.h], [AC_CHECK_HEADERS]) +AN_HEADER([limits.h], [AC_CHECK_HEADERS]) +AN_HEADER([locale.h], [AC_CHECK_HEADERS]) +AN_HEADER([mach/mach.h], [AC_CHECK_HEADERS]) +AN_HEADER([malloc.h], [AC_CHECK_HEADERS]) +AN_HEADER([memory.h], [AC_CHECK_HEADERS]) +AN_HEADER([mntent.h], [AC_CHECK_HEADERS]) +AN_HEADER([mnttab.h], [AC_CHECK_HEADERS]) +AN_HEADER([netdb.h], [AC_CHECK_HEADERS]) +AN_HEADER([netinet/in.h], [AC_CHECK_HEADERS]) +AN_HEADER([nl_types.h], [AC_CHECK_HEADERS]) +AN_HEADER([nlist.h], [AC_CHECK_HEADERS]) +AN_HEADER([paths.h], [AC_CHECK_HEADERS]) +AN_HEADER([sgtty.h], [AC_CHECK_HEADERS]) +AN_HEADER([shadow.h], [AC_CHECK_HEADERS]) +AN_HEADER([stddef.h], [AC_CHECK_HEADERS]) +AN_HEADER([stdint.h], [AC_CHECK_HEADERS]) +AN_HEADER([stdio_ext.h], [AC_CHECK_HEADERS]) +AN_HEADER([stdlib.h], [AC_CHECK_HEADERS]) +AN_HEADER([string.h], [AC_CHECK_HEADERS]) +AN_HEADER([strings.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/acl.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/file.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/filsys.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/fs/s5param.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/fs_types.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/fstyp.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/ioctl.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/mntent.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/mount.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/param.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/socket.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/statfs.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/statvfs.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/systeminfo.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/time.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/timeb.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/vfs.h], [AC_CHECK_HEADERS]) +AN_HEADER([sys/window.h], [AC_CHECK_HEADERS]) +AN_HEADER([syslog.h], [AC_CHECK_HEADERS]) +AN_HEADER([termio.h], [AC_CHECK_HEADERS]) +AN_HEADER([termios.h], [AC_CHECK_HEADERS]) +AN_HEADER([unistd.h], [AC_CHECK_HEADERS]) +AN_HEADER([utime.h], [AC_CHECK_HEADERS]) +AN_HEADER([utmp.h], [AC_CHECK_HEADERS]) +AN_HEADER([utmpx.h], [AC_CHECK_HEADERS]) +AN_HEADER([values.h], [AC_CHECK_HEADERS]) +AN_HEADER([wchar.h], [AC_CHECK_HEADERS]) +AN_HEADER([wctype.h], [AC_CHECK_HEADERS]) + + + +## ------------------------------- ## +## 4. Tests for specific headers. ## +## ------------------------------- ## + +# AC_HEADER_ASSERT +# ---------------- +# Check whether to enable assertions. +AC_DEFUN_ONCE([AC_HEADER_ASSERT], +[ + AC_MSG_CHECKING([whether to enable assertions]) + AC_ARG_ENABLE([assert], + [AS_HELP_STRING([--disable-assert], [turn off assertions])], + [ac_enable_assert=$enableval + AS_IF(dnl + [test "x$enableval" = xno], + [AC_DEFINE([NDEBUG], [1], + [Define to 1 if assertions should be disabled.])], + [test "x$enableval" != xyes], + [AC_MSG_WARN([invalid argument supplied to --enable-assert]) + ac_enable_assert=yes])], + [ac_enable_assert=yes]) + AC_MSG_RESULT([$ac_enable_assert]) +]) + + +# _AC_CHECK_HEADER_DIRENT(HEADER-FILE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT_FOUND]) +# ----------------------------------------------------------------- +# Like AC_CHECK_HEADER, except also make sure that HEADER-FILE +# defines the type `DIR'. dirent.h on NextStep 3.2 doesn't. +m4_define([_AC_CHECK_HEADER_DIRENT], +[AS_VAR_PUSHDEF([ac_Header], [ac_cv_header_dirent_$1])dnl +AC_CACHE_CHECK([for $1 that defines DIR], [ac_Header], +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h> +#include <$1> +], + [if ((DIR *) 0) +return 0;])], + [AS_VAR_SET([ac_Header], [yes])], + [AS_VAR_SET([ac_Header], [no])])]) +AS_VAR_IF([ac_Header], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Header])dnl +])# _AC_CHECK_HEADER_DIRENT + + +# _AH_CHECK_HEADER_DIRENT(HEADERS) +# -------------------------------- +# Like _AH_CHECK_HEADER, but tuned to a dirent provider. +m4_define([_AH_CHECK_HEADER_DIRENT], +[AH_TEMPLATE(AS_TR_CPP([HAVE_$1]), + [Define to 1 if you have the <$1> header file, and it defines `DIR'.])]) + + +# AC_HEADER_DIRENT +# ---------------- +AC_DEFUN([AC_HEADER_DIRENT], +[m4_map_args([_AH_CHECK_HEADER_DIRENT], [dirent.h], [sys/ndir.h], + [sys/dir.h], [ndir.h])]dnl +[ac_header_dirent=no +for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do + _AC_CHECK_HEADER_DIRENT($ac_hdr, + [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_$ac_hdr), 1) +ac_header_dirent=$ac_hdr; break]) +done +# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. +if test $ac_header_dirent = dirent.h; then + AC_SEARCH_LIBS(opendir, dir) +else + AC_SEARCH_LIBS(opendir, x) +fi +])# AC_HEADER_DIRENT + + +# AC_HEADER_MAJOR +# --------------- +AN_FUNCTION([major], [AC_HEADER_MAJOR]) +AN_FUNCTION([makedev], [AC_HEADER_MAJOR]) +AN_FUNCTION([minor], [AC_HEADER_MAJOR]) +AN_HEADER([sys/mkdev.h], [AC_HEADER_MAJOR]) +AC_DEFUN([AC_HEADER_MAJOR], +[AC_CACHE_CHECK(whether sys/types.h defines makedev, + ac_cv_header_sys_types_h_makedev, +[AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <sys/types.h>]], + [[return makedev(0, 0);]])], + [ac_cv_header_sys_types_h_makedev=yes], + [ac_cv_header_sys_types_h_makedev=no]) +]) + +if test $ac_cv_header_sys_types_h_makedev = no; then +AC_CHECK_HEADER(sys/mkdev.h, + [AC_DEFINE(MAJOR_IN_MKDEV, 1, + [Define to 1 if `major', `minor', and `makedev' are + declared in <mkdev.h>.])]) + + if test $ac_cv_header_sys_mkdev_h = no; then + AC_CHECK_HEADER(sys/sysmacros.h, + [AC_DEFINE(MAJOR_IN_SYSMACROS, 1, + [Define to 1 if `major', `minor', and `makedev' + are declared in <sysmacros.h>.])]) + fi +fi +])# AC_HEADER_MAJOR + + +# AC_HEADER_RESOLV +# ---------------- +# According to http://www.mcsr.olemiss.edu/cgi-bin/man-cgi?resolver+3 +# (or http://www.chemie.fu-berlin.de/cgi-bin/man/sgi_irix?resolver+3), +# sys/types.h, netinet/in.h and arpa/nameser.h are required on IRIX. +# netinet/in.h is needed on Cygwin, too. +# With Solaris 9, netdb.h is required, to get symbols like HOST_NOT_FOUND. +# +AN_HEADER(resolv.h, [AC_HEADER_RESOLV]) +AC_DEFUN([AC_HEADER_RESOLV], +[AC_CHECK_HEADERS(sys/types.h netinet/in.h arpa/nameser.h netdb.h resolv.h, + [], [], +[[#ifdef HAVE_SYS_TYPES_H +# include <sys/types.h> +#endif +#ifdef HAVE_NETINET_IN_H +# include <netinet/in.h> /* inet_ functions / structs */ +#endif +#ifdef HAVE_ARPA_NAMESER_H +# include <arpa/nameser.h> /* DNS HEADER struct */ +#endif +#ifdef HAVE_NETDB_H +# include <netdb.h> +#endif]]) +])# AC_HEADER_RESOLV + + +# AC_HEADER_STAT +# -------------- +# FIXME: Shouldn't this be named AC_HEADER_SYS_STAT? +AC_DEFUN([AC_HEADER_STAT], +[AC_CACHE_CHECK(whether stat file-mode macros are broken, + ac_cv_header_stat_broken, +[AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <sys/types.h> +#include <sys/stat.h> + +#if defined S_ISBLK && defined S_IFDIR +extern char c1[S_ISBLK (S_IFDIR) ? -1 : 1]; +#endif + +#if defined S_ISBLK && defined S_IFCHR +extern char c2[S_ISBLK (S_IFCHR) ? -1 : 1]; +#endif + +#if defined S_ISLNK && defined S_IFREG +extern char c3[S_ISLNK (S_IFREG) ? -1 : 1]; +#endif + +#if defined S_ISSOCK && defined S_IFREG +extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; +#endif +]])], ac_cv_header_stat_broken=no, ac_cv_header_stat_broken=yes)]) +if test $ac_cv_header_stat_broken = yes; then + AC_DEFINE(STAT_MACROS_BROKEN, 1, + [Define to 1 if the `S_IS*' macros in <sys/stat.h> do not + work properly.]) +fi +])# AC_HEADER_STAT + + +# AC_CHECK_HEADER_STDBOOL +# ----------------- +# Check for stdbool.h that conforms to C99. +AN_IDENTIFIER([bool], [AC_CHECK_HEADER_STDBOOL]) +AN_IDENTIFIER([true], [AC_CHECK_HEADER_STDBOOL]) +AN_IDENTIFIER([false],[AC_CHECK_HEADER_STDBOOL]) +AC_DEFUN([AC_CHECK_HEADER_STDBOOL], + [AC_CACHE_CHECK([for stdbool.h that conforms to C99], + [ac_cv_header_stdbool_h], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[ + #include <stdbool.h> + #ifndef bool + "error: bool is not defined" + #endif + #ifndef false + "error: false is not defined" + #endif + #if false + "error: false is not 0" + #endif + #ifndef true + "error: true is not defined" + #endif + #if true != 1 + "error: true is not 1" + #endif + #ifndef __bool_true_false_are_defined + "error: __bool_true_false_are_defined is not defined" + #endif + + struct s { _Bool s: 1; _Bool t; } s; + + char a[true == 1 ? 1 : -1]; + char b[false == 0 ? 1 : -1]; + char c[__bool_true_false_are_defined == 1 ? 1 : -1]; + char d[(bool) 0.5 == true ? 1 : -1]; + /* See body of main program for 'e'. */ + char f[(_Bool) 0.0 == false ? 1 : -1]; + char g[true]; + char h[sizeof (_Bool)]; + char i[sizeof s.t]; + enum { j = false, k = true, l = false * true, m = true * 256 }; + /* The following fails for + HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */ + _Bool n[m]; + char o[sizeof n == m * sizeof n[0] ? 1 : -1]; + char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1]; + /* Catch a bug in an HP-UX C compiler. See + http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html + http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html + */ + _Bool q = true; + _Bool *pq = &q; + ]], + [[ + bool e = &s; + *pq |= q; + *pq |= ! q; + /* Refer to every declared value, to avoid compiler optimizations. */ + return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l + + !m + !n + !o + !p + !q + !pq); + ]])], + [ac_cv_header_stdbool_h=yes], + [ac_cv_header_stdbool_h=no])]) + AC_CHECK_TYPES([_Bool]) +])# AC_CHECK_HEADER_STDBOOL + + +# AC_HEADER_STDBOOL +# ----------------- +# Define HAVE_STDBOOL_H if tdbool.h that conforms to C99. +AC_DEFUN([AC_HEADER_STDBOOL], +[AC_CHECK_HEADER_STDBOOL +if test $ac_cv_header_stdbool_h = yes; then + AC_DEFINE(HAVE_STDBOOL_H, 1, [Define to 1 if stdbool.h conforms to C99.]) +fi +])# AC_HEADER_STDBOOL + + +# AC_HEADER_STDC +# -------------- +AC_DEFUN([AC_HEADER_STDC], +[AC_CACHE_CHECK(for ANSI C header files, ac_cv_header_stdc, +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#include <float.h> +]])], + [ac_cv_header_stdc=yes], + [ac_cv_header_stdc=no]) + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + AC_EGREP_HEADER(memchr, string.h, , ac_cv_header_stdc=no) +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + AC_EGREP_HEADER(free, stdlib.h, , ac_cv_header_stdc=no) +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + AC_RUN_IFELSE([AC_LANG_SOURCE( +[[#include <ctype.h> +#include <stdlib.h> +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +}]])], , ac_cv_header_stdc=no, :) +fi]) +if test $ac_cv_header_stdc = yes; then + AC_DEFINE(STDC_HEADERS, 1, + [Define to 1 if you have the ANSI C header files.]) +fi +])# AC_HEADER_STDC + + +# AC_HEADER_SYS_WAIT +# ------------------ +AC_DEFUN([AC_HEADER_SYS_WAIT], +[AC_CACHE_CHECK([for sys/wait.h that is POSIX.1 compatible], + ac_cv_header_sys_wait_h, +[AC_COMPILE_IFELSE( +[AC_LANG_PROGRAM([#include <sys/types.h> +#include <sys/wait.h> +#ifndef WEXITSTATUS +# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8) +#endif +#ifndef WIFEXITED +# define WIFEXITED(stat_val) (((stat_val) & 255) == 0) +#endif +], +[ int s; + wait (&s); + s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;])], + [ac_cv_header_sys_wait_h=yes], + [ac_cv_header_sys_wait_h=no])]) +if test $ac_cv_header_sys_wait_h = yes; then + AC_DEFINE(HAVE_SYS_WAIT_H, 1, + [Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible.]) +fi +])# AC_HEADER_SYS_WAIT + + +# AC_HEADER_TIME +# -------------- +AC_DEFUN([AC_HEADER_TIME], +[AC_CACHE_CHECK([whether time.h and sys/time.h may both be included], + ac_cv_header_time, +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h> +#include <sys/time.h> +#include <time.h> +], +[if ((struct tm *) 0) +return 0;])], + [ac_cv_header_time=yes], + [ac_cv_header_time=no])]) +if test $ac_cv_header_time = yes; then + AC_DEFINE(TIME_WITH_SYS_TIME, 1, + [Define to 1 if you can safely include both <sys/time.h> + and <time.h>.]) +fi +])# AC_HEADER_TIME + + +# _AC_HEADER_TIOCGWINSZ_IN_TERMIOS_H +# ---------------------------------- +m4_define([_AC_HEADER_TIOCGWINSZ_IN_TERMIOS_H], +[AC_CACHE_CHECK([whether termios.h defines TIOCGWINSZ], + ac_cv_sys_tiocgwinsz_in_termios_h, +[AC_EGREP_CPP([yes], + [#include <sys/types.h> +#include <termios.h> +#ifdef TIOCGWINSZ + yes +#endif +], + ac_cv_sys_tiocgwinsz_in_termios_h=yes, + ac_cv_sys_tiocgwinsz_in_termios_h=no)]) +])# _AC_HEADER_TIOCGWINSZ_IN_TERMIOS_H + + +# _AC_HEADER_TIOCGWINSZ_IN_SYS_IOCTL +# ---------------------------------- +m4_define([_AC_HEADER_TIOCGWINSZ_IN_SYS_IOCTL], +[AC_CACHE_CHECK([whether sys/ioctl.h defines TIOCGWINSZ], + ac_cv_sys_tiocgwinsz_in_sys_ioctl_h, +[AC_EGREP_CPP([yes], + [#include <sys/types.h> +#include <sys/ioctl.h> +#ifdef TIOCGWINSZ + yes +#endif +], + ac_cv_sys_tiocgwinsz_in_sys_ioctl_h=yes, + ac_cv_sys_tiocgwinsz_in_sys_ioctl_h=no)]) +])# _AC_HEADER_TIOCGWINSZ_IN_SYS_IOCTL + + +# AC_HEADER_TIOCGWINSZ +# -------------------- +# Look for a header that defines TIOCGWINSZ. +# FIXME: Is this the proper name? Is this the proper implementation? +# I need more help. +AC_DEFUN([AC_HEADER_TIOCGWINSZ], +[_AC_HEADER_TIOCGWINSZ_IN_TERMIOS_H +if test $ac_cv_sys_tiocgwinsz_in_termios_h != yes; then + _AC_HEADER_TIOCGWINSZ_IN_SYS_IOCTL + if test $ac_cv_sys_tiocgwinsz_in_sys_ioctl_h = yes; then + AC_DEFINE(GWINSZ_IN_SYS_IOCTL,1, + [Define to 1 if `TIOCGWINSZ' requires <sys/ioctl.h>.]) + fi +fi +])# AC_HEADER_TIOCGWINSZ + + +# AU::AC_UNISTD_H +# --------------- +AU_DEFUN([AC_UNISTD_H], +[AC_CHECK_HEADERS(unistd.h)]) + + +# AU::AC_USG +# ---------- +# Define `USG' if string functions are in strings.h. +AU_DEFUN([AC_USG], +[AC_MSG_CHECKING([for BSD string and memory functions]) +AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <strings.h>]], + [[rindex(0, 0); bzero(0, 0);]])], + [AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no) + AC_DEFINE(USG, 1, + [Define to 1 if you do not have <strings.h>, index, + bzero, etc... This symbol is obsolete, you should + not depend upon it.])]) +AC_CHECK_HEADERS(string.h)], +[Remove `AC_MSG_CHECKING', `AC_LINK_IFELSE' and this warning +when you adjust your code to use HAVE_STRING_H.]) + + +# AU::AC_MEMORY_H +# --------------- +# To be precise this macro used to be: +# +# | AC_MSG_CHECKING(whether string.h declares mem functions) +# | AC_EGREP_HEADER(memchr, string.h, ac_found=yes, ac_found=no) +# | AC_MSG_RESULT($ac_found) +# | if test $ac_found = no; then +# | AC_CHECK_HEADER(memory.h, [AC_DEFINE(NEED_MEMORY_H)]) +# | fi +# +# But it is better to check for both headers, and alias NEED_MEMORY_H to +# HAVE_MEMORY_H. +AU_DEFUN([AC_MEMORY_H], +[AC_CHECK_HEADER(memory.h, + [AC_DEFINE([NEED_MEMORY_H], 1, + [Same as `HAVE_MEMORY_H', don't depend on me.])]) +AC_CHECK_HEADERS(string.h memory.h)], +[Remove this warning and +`AC_CHECK_HEADER(memory.h, AC_DEFINE(...))' when you adjust your code to +use HAVE_STRING_H and HAVE_MEMORY_H, not NEED_MEMORY_H.]) + + +# AU::AC_DIR_HEADER +# ----------------- +# Like calling `AC_HEADER_DIRENT' and `AC_FUNC_CLOSEDIR_VOID', but +# defines a different set of C preprocessor macros to indicate which +# header file is found. +AU_DEFUN([AC_DIR_HEADER], +[AC_HEADER_DIRENT +AC_FUNC_CLOSEDIR_VOID +test ac_cv_header_dirent_dirent_h && + AC_DEFINE([DIRENT], 1, [Same as `HAVE_DIRENT_H', don't depend on me.]) +test ac_cv_header_dirent_sys_ndir_h && + AC_DEFINE([SYSNDIR], 1, [Same as `HAVE_SYS_NDIR_H', don't depend on me.]) +test ac_cv_header_dirent_sys_dir_h && + AC_DEFINE([SYSDIR], 1, [Same as `HAVE_SYS_DIR_H', don't depend on me.]) +test ac_cv_header_dirent_ndir_h && + AC_DEFINE([NDIR], 1, [Same as `HAVE_NDIR_H', don't depend on me.])], +[Remove this warning and the four `AC_DEFINE' when you +adjust your code to use `AC_HEADER_DIRENT'.]) diff --git a/lib/autoconf/lang.m4 b/lib/autoconf/lang.m4 new file mode 100644 index 0000000..19852b8 --- /dev/null +++ b/lib/autoconf/lang.m4 @@ -0,0 +1,721 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Programming languages support. +# Copyright (C) 2000-2002, 2004-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# Table of Contents: +# +# 1. Language selection +# and routines to produce programs in a given language. +# +# 2. Producing programs in a given language. +# +# 3. Looking for a compiler +# And possibly the associated preprocessor. +# +# 3a. Computing EXEEXT and OBJEXT. +# +# 4. Compilers' characteristics. + + + +## ----------------------- ## +## 1. Language selection. ## +## ----------------------- ## + + +# AC_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT) +# ------------------------------------------------------------ +# Expand into IF-LANG1 if the current language is LANG1 etc. else +# into default. +m4_define([AC_LANG_CASE], +[m4_case(_AC_LANG, $@)]) + + +# _AC_LANG_DISPATCH(MACRO, LANG, ARGS) +# ------------------------------------ +# Call the specialization of MACRO for LANG with ARGS. Complain if +# unavailable. +m4_define([_AC_LANG_DISPATCH], +[m4_ifdef([$1($2)], + [m4_indir([$1($2)], m4_shift2($@))], + [m4_fatal([$1: unknown language: $2])])]) + + +# _AC_LANG_SET(OLD, NEW) +# ---------------------- +# Output the shell code needed to switch from OLD language to NEW language. +# Do not try to optimize like this: +# +# m4_defun([_AC_LANG_SET], +# [m4_if([$1], [$2], [], +# [_AC_LANG_DISPATCH([AC_LANG], [$2])])]) +# +# as it can introduce differences between the sh-current language and the +# m4-current-language when m4_require is used. Something more subtle +# might be possible, but at least for the time being, play it safe. +m4_defun([_AC_LANG_SET], +[_AC_LANG_DISPATCH([AC_LANG], [$2])]) + + +# AC_LANG(LANG) +# ------------- +# Set the current language to LANG. +m4_defun([AC_LANG], +[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), + [$1])dnl +m4_define([_AC_LANG], [$1])]) + + +# AC_LANG_PUSH(LANG) +# ------------------ +# Save the current language, and use LANG. +m4_defun([AC_LANG_PUSH], +[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), + [$1])dnl +m4_pushdef([_AC_LANG], [$1])]) + + +# AC_LANG_POP([LANG]) +# ------------------- +# If given, check that the current language is LANG, and restore the +# previous language. +m4_defun([AC_LANG_POP], +[m4_ifval([$1], + [m4_if([$1], m4_defn([_AC_LANG]), [], + [m4_fatal([$0($1): unexpected current language: ]m4_defn([_AC_LANG]))])])dnl +m4_pushdef([$0 OLD], m4_defn([_AC_LANG]))dnl +m4_popdef([_AC_LANG])dnl +_AC_LANG_SET(m4_defn([$0 OLD]), m4_defn([_AC_LANG]))dnl +m4_popdef([$0 OLD])dnl +]) + + +# AC_LANG_SAVE +# ------------ +# Save the current language, but don't change language. +AU_DEFUN([AC_LANG_SAVE], +[[AC_LANG_SAVE]], +[Instead of using `AC_LANG', `AC_LANG_SAVE', and `AC_LANG_RESTORE', +you should use `AC_LANG_PUSH' and `AC_LANG_POP'.]) +AC_DEFUN([AC_LANG_SAVE], +[m4_pushdef([_AC_LANG], _AC_LANG)dnl +AC_DIAGNOSE([obsolete], [The macro `AC_LANG_SAVE' is obsolete. +You should run autoupdate.])]) + + +# AC_LANG_RESTORE +# --------------- +# Restore the current language from the stack. +AU_DEFUN([AC_LANG_RESTORE], [AC_LANG_POP($@)]) + + +# _AC_LANG_ABBREV +# --------------- +# Return a short signature of _AC_LANG which can be used in shell +# variable names, or in M4 macro names. +m4_defun([_AC_LANG_ABBREV], +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# _AC_LANG_PREFIX +# --------------- +# Return a short (upper case) signature of _AC_LANG that is used to +# prefix environment variables like FLAGS. +m4_defun([_AC_LANG_PREFIX], +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_ASSERT(LANG) +# -------------------- +# Current language must be LANG. +m4_defun([AC_LANG_ASSERT], +[m4_if(_AC_LANG, $1, [], + [m4_fatal([$0: current language is not $1: ] _AC_LANG)])]) + + + +# AC_LANG_DEFINE(NAME, ABBREV, PREFIX, COMPILER-VAR, COPY-FROM, SHELL-VARS) +# ------------------------------------------------------------------------- +# Define a language referenced by AC_LANG(NAME), with cache variable prefix +# ABBREV, Makefile variable prefix PREFIX and compiler variable COMPILER-VAR. +# AC_LANG(NAME) is defined to SHELL-VARS, other macros are copied from language +# COPY-FROM. Even if COPY-FROM is empty, a default definition is provided for +# language-specific macros AC_LANG_SOURCE(NAME) and AC_LANG_CONFTEST(NAME). +m4_define([AC_LANG_DEFINE], +[m4_define([AC_LANG($1)], [$6])] +[m4_define([_AC_LANG_ABBREV($1)], [$2])] +[m4_define([_AC_LANG_PREFIX($1)], [$3])] +[m4_define([_AC_CC($1)], [$4])] +[m4_copy([AC_LANG_CONFTEST($5)], [AC_LANG_CONFTEST($1)])] +[m4_copy([AC_LANG_SOURCE($5)], [AC_LANG_SOURCE($1)])] +[m4_copy([_AC_LANG_NULL_PROGRAM($5)], [_AC_LANG_NULL_PROGRAM($1)])] +[m4_ifval([$5], +[m4_copy([AC_LANG_PROGRAM($5)], [AC_LANG_PROGRAM($1)])] +[m4_copy([AC_LANG_CALL($5)], [AC_LANG_CALL($1)])] +[m4_copy([AC_LANG_FUNC_LINK_TRY($5)], [AC_LANG_FUNC_LINK_TRY($1)])] +[m4_copy([AC_LANG_BOOL_COMPILE_TRY($5)], [AC_LANG_BOOL_COMPILE_TRY($1)])] +[m4_copy([AC_LANG_INT_SAVE($5)], [AC_LANG_INT_SAVE($1)])] +[m4_copy([_AC_LANG_IO_PROGRAM($5)], [_AC_LANG_IO_PROGRAM($1)])])]) + +## ----------------------- ## +## 2. Producing programs. ## +## ----------------------- ## + + +# AC_LANG_CONFTEST(BODY) +# ---------------------- +# Save the BODY in `conftest.$ac_ext'. Add a trailing new line. +AC_DEFUN([AC_LANG_CONFTEST], +[m4_pushdef([_AC_LANG_DEFINES_PROVIDED], + [m4_warn([syntax], [$0: no AC_LANG_SOURCE call detected in body])])]dnl +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]dnl +[[]_AC_LANG_DEFINES_PROVIDED[]m4_popdef([_AC_LANG_DEFINES_PROVIDED])]) + + +# AC_LANG_CONFTEST()(BODY) +# ------------------------ +# Default implementation of AC_LANG_CONFTEST. +# This version assumes that you can't inline confdefs.h into your +# language, and as such, it is safe to blindly call +# AC_LANG_DEFINES_PROVIDED. Language-specific overrides should +# remove this call if AC_LANG_SOURCE does inline confdefs.h. +m4_define([AC_LANG_CONFTEST()], +[cat > conftest.$ac_ext <<_ACEOF +AC_LANG_DEFINES_PROVIDED[]$1 +_ACEOF]) + +# AC_LANG_DEFINES_PROVIDED +# ------------------------ +# Witness macro that all prior AC_DEFINE results have been output +# into the current expansion, to silence warning from AC_LANG_CONFTEST. +m4_define([AC_LANG_DEFINES_PROVIDED], +[m4_define([_$0])]) + + +# AC_LANG_SOURCE(BODY) +# -------------------- +# Produce a valid source for the current language, which includes the +# BODY, and as much as possible `confdefs.h'. +AC_DEFUN([AC_LANG_SOURCE], +[AC_LANG_DEFINES_PROVIDED[]_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_SOURCE()(BODY) +# ---------------------- +# Default implementation of AC_LANG_SOURCE. +m4_define([AC_LANG_SOURCE()], +[$1]) + + +# AC_LANG_PROGRAM([PROLOGUE], [BODY]) +# ----------------------------------- +# Produce a valid source for the current language. Prepend the +# PROLOGUE (typically CPP directives and/or declarations) to an +# execution the BODY (typically glued inside the `main' function, or +# equivalent). +AC_DEFUN([AC_LANG_PROGRAM], +[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) + + +# _AC_LANG_NULL_PROGRAM()() +# ------------------------- +# Default implementation of AC_LANG_NULL_PROGRAM +m4_define([_AC_LANG_NULL_PROGRAM()], +[AC_LANG_PROGRAM([], [])]) + + +# _AC_LANG_NULL_PROGRAM +# --------------------- +# Produce valid source for the current language that does +# nothing. +AC_DEFUN([_AC_LANG_NULL_PROGRAM], +[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) + + +# _AC_LANG_IO_PROGRAM +# ------------------- +# Produce valid source for the current language that creates +# a file. (This is used when detecting whether executables +# work, e.g. to detect cross-compiling.) +AC_DEFUN([_AC_LANG_IO_PROGRAM], +[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) + + +# AC_LANG_CALL(PROLOGUE, FUNCTION) +# -------------------------------- +# Call the FUNCTION. +AC_DEFUN([AC_LANG_CALL], +[m4_ifval([$2], [], [m4_warn([syntax], [$0: no function given])])dnl +_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_FUNC_LINK_TRY(FUNCTION) +# ------------------------------- +# Produce a source which links correctly iff the FUNCTION exists. +AC_DEFUN([AC_LANG_FUNC_LINK_TRY], +[m4_ifval([$1], [], [m4_warn([syntax], [$0: no function given])])dnl +_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_BOOL_COMPILE_TRY(PROLOGUE, EXPRESSION) +# ---------------------------------------------- +# Produce a program that compiles with success iff the boolean EXPRESSION +# evaluates to true at compile time. +AC_DEFUN([AC_LANG_BOOL_COMPILE_TRY], +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_INT_SAVE(PROLOGUE, EXPRESSION) +# -------------------------------------- +# Produce a program that saves the runtime evaluation of the integer +# EXPRESSION into `conftest.val'. +AC_DEFUN([AC_LANG_INT_SAVE], +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# _AC_CC +# ------ +# The variable name of the compiler. +m4_define([_AC_CC], +[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +## -------------------------------------------- ## +## 3. Looking for Compilers and Preprocessors. ## +## -------------------------------------------- ## + + +# AC_LANG_COMPILER +# ---------------- +# Find a compiler for the current LANG. Be sure to be run before +# AC_LANG_PREPROC. +# +# Note that because we might AC_REQUIRE `AC_LANG_COMPILER(C)' for +# instance, the latter must be AC_DEFUN'd, not just define'd. +m4_define([AC_LANG_COMPILER], +[AC_BEFORE([AC_LANG_COMPILER(]_AC_LANG[)], + [AC_LANG_PREPROC(]_AC_LANG[)])dnl +_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_COMPILER_REQUIRE +# ------------------------ +# Ensure we have a compiler for the current LANG. +AC_DEFUN([AC_LANG_COMPILER_REQUIRE], +[m4_require([AC_LANG_COMPILER(]_AC_LANG[)], + [AC_LANG_COMPILER])]) + + + +# _AC_LANG_COMPILER_GNU +# --------------------- +# Check whether the compiler for the current language is GNU. +# +# It doesn't seem necessary right now to have a different source +# according to the current language, since this works fine. Some day +# it might be needed. Nevertheless, pay attention to the fact that +# the position of `choke me' on the seventh column is meant: otherwise +# some Fortran compilers (e.g., SGI) might consider it's a +# continuation line, and warn instead of reporting an error. +m4_define([_AC_LANG_COMPILER_GNU], +[AC_CACHE_CHECK([whether we are using the GNU _AC_LANG compiler], + [ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu], +[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#ifndef __GNUC__ + choke me +#endif +]])], + [ac_compiler_gnu=yes], + [ac_compiler_gnu=no]) +ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu=$ac_compiler_gnu +])])# _AC_LANG_COMPILER_GNU + + +# AC_LANG_PREPROC +# --------------- +# Find a preprocessor for the current language. Note that because we +# might AC_REQUIRE `AC_LANG_PREPROC(C)' for instance, the latter must +# be AC_DEFUN'd, not just define'd. Since the preprocessor depends +# upon the compiler, look for the compiler. +m4_define([AC_LANG_PREPROC], +[AC_LANG_COMPILER_REQUIRE()dnl +_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) + + +# AC_LANG_PREPROC_REQUIRE +# ----------------------- +# Ensure we have a preprocessor for the current language. +AC_DEFUN([AC_LANG_PREPROC_REQUIRE], +[m4_require([AC_LANG_PREPROC(]_AC_LANG[)], + [AC_LANG_PREPROC])]) + + +# AC_REQUIRE_CPP +# -------------- +# Require the preprocessor for the current language. +# FIXME: AU_ALIAS once AC_LANG is officially documented (2.51?). +AC_DEFUN([AC_REQUIRE_CPP], +[AC_LANG_PREPROC_REQUIRE]) + + + +# AC_NO_EXECUTABLES +# ----------------- +# FIXME: The GCC team has specific needs which the current Autoconf +# framework cannot solve elegantly. This macro implements a dirty +# hack until Autoconf is able to provide the services its users +# need. +# +# Several of the support libraries that are often built with GCC can't +# assume the tool-chain is already capable of linking a program: the +# compiler often expects to be able to link with some of such +# libraries. +# +# In several of these libraries, workarounds have been introduced to +# avoid the AC_PROG_CC_WORKS test, that would just abort their +# configuration. The introduction of AC_EXEEXT, enabled either by +# libtool or by CVS autoconf, have just made matters worse. +# +# Unlike an earlier version of this macro, using AC_NO_EXECUTABLES does +# not disable link tests at autoconf time, but at configure time. +# This allows AC_NO_EXECUTABLES to be invoked conditionally. +AC_DEFUN_ONCE([AC_NO_EXECUTABLES], +[m4_divert_push([KILL]) +m4_divert_text([DEFAULTS], [ac_no_link=no]) + +AC_BEFORE([$0], [_AC_COMPILER_EXEEXT]) +AC_BEFORE([$0], [AC_LINK_IFELSE]) + +m4_define([_AC_COMPILER_EXEEXT], +[AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) +if _AC_DO_VAR(ac_link); then + ac_no_link=no + ]m4_defn([_AC_COMPILER_EXEEXT])[ +else + rm -f -r a.out a.exe b.out conftest.$ac_ext conftest.o conftest.obj conftest.dSYM + ac_no_link=yes + # Setting cross_compile will disable run tests; it will + # also disable AC_CHECK_FILE but that's generally + # correct if we can't link. + cross_compiling=yes + EXEEXT= + _AC_COMPILER_EXEEXT_CROSS +fi +]) + +m4_define([AC_LINK_IFELSE], +[if test x$ac_no_link = xyes; then + AC_MSG_ERROR([link tests are not allowed after AC@&t@_NO_EXECUTABLES]) +fi +]m4_defn([AC_LINK_IFELSE])) + +m4_divert_pop()dnl +])# AC_NO_EXECUTABLES + + + +# --------------------------------- # +# 3a. Computing EXEEXT and OBJEXT. # +# --------------------------------- # + + +# Files to ignore +# --------------- +# Ignore .d files produced by CFLAGS=-MD. +# +# On UWIN (which uses a cc wrapper for MSVC), the compiler also generates +# a .pdb file +# +# When the w32 free Borland C++ command line compiler links a program +# (conftest.exe), it also produces a file named `conftest.tds' in +# addition to `conftest.obj'. +# +# - *.bb, *.bbg +# Created per object by GCC when given -ftest-coverage. +# +# - *.xSYM +# Created on BeOS. Seems to be per executable. +# +# - *.map, *.inf +# Created by the Green Hills compiler. +# +# - *.dSYM +# Directory created on Mac OS X Leopard. + + +# _AC_COMPILER_OBJEXT_REJECT +# -------------------------- +# Case/esac pattern matching the files to be ignored when looking for +# compiled object files. +m4_define([_AC_COMPILER_OBJEXT_REJECT], +[*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM]) + + +# _AC_COMPILER_EXEEXT_REJECT +# -------------------------- +# Case/esac pattern matching the files to be ignored when looking for +# compiled executables. +m4_define([_AC_COMPILER_EXEEXT_REJECT], +[_AC_COMPILER_OBJEXT_REJECT | *.o | *.obj]) + + +# We must not AU define them, because autoupdate would then remove +# them, which is right, but Automake 1.4 would remove the support for +# $(EXEEXT) etc. +# FIXME: Remove this once Automake fixed. +AC_DEFUN([AC_EXEEXT], []) +AC_DEFUN([AC_OBJEXT], []) + + +# _AC_COMPILER_EXEEXT_DEFAULT +# --------------------------- +# Check for the extension used for the default name for executables. +# +# We do this in order to find out what is the extension we must add for +# creating executables (see _AC_COMPILER_EXEEXT's comments). +# +# On OpenVMS 7.1 system, the DEC C 5.5 compiler when called through a +# GNV (gnv.sourceforge.net) cc wrapper, produces the output file named +# `a_out.exe'. +# b.out is created by i960 compilers. +# +# Start with the most likely output file names, but: +# 1) Beware the clever `test -f' on Cygwin, try the DOS-like .exe names +# before the counterparts without the extension. +# 2) The algorithm is not robust to junk in `.', hence go to wildcards +# (conftest.*) only as a last resort. +# Beware of `expr' that may return `0' or `'. Since this macro is +# the first one in touch with the compiler, it should also check that +# it compiles properly. +# +# The IRIX 6 linker writes into existing files which may not be +# executable, retaining their permissions. Remove them first so a +# subsequent execution test works. +# +m4_define([_AC_COMPILER_EXEEXT_DEFAULT], +[# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +AC_MSG_CHECKING([whether the _AC_LANG compiler works]) +ac_link_default=`AS_ECHO(["$ac_link"]) | sed ['s/ -o *conftest[^ ]*//']` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + _AC_COMPILER_EXEEXT_REJECT ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +AS_IF([_AC_DO_VAR(ac_link_default)], +[# Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + _AC_COMPILER_EXEEXT_REJECT ) + ;; + [[ab]].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= +], + [ac_file='']) +AS_IF([test -z "$ac_file"], +[AC_MSG_RESULT([no]) +_AC_MSG_LOG_CONFTEST +AC_MSG_FAILURE([_AC_LANG compiler cannot create executables], 77)], +[AC_MSG_RESULT([yes])]) +AC_MSG_CHECKING([for _AC_LANG compiler default output file name]) +AC_MSG_RESULT([$ac_file]) +ac_exeext=$ac_cv_exeext +])# _AC_COMPILER_EXEEXT_DEFAULT + + +# _AC_COMPILER_EXEEXT_CROSS +# ------------------------- +# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 +# +# It is not sufficient to run a no-op program -- this succeeds and gives +# a false negative when cross-compiling for the compute nodes on the +# IBM Blue Gene/L. Instead, _AC_COMPILER_EXEEXT calls _AC_LANG_IO_PROGRAM +# to create a program that writes to a file, which is sufficient to +# detect cross-compiling on Blue Gene. Note also that AC_COMPUTE_INT +# requires programs that create files when not cross-compiling, so it +# is safe and not a bad idea to check for this capability in general. +m4_define([_AC_COMPILER_EXEEXT_CROSS], +[# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +AC_MSG_CHECKING([whether we are cross compiling]) +if test "$cross_compiling" != yes; then + _AC_DO_VAR(ac_link) + if _AC_DO_TOKENS([./conftest$ac_cv_exeext]); then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + AC_MSG_FAILURE([cannot run _AC_LANG compiled programs. +If you meant to cross compile, use `--host'.]) + fi + fi +fi +AC_MSG_RESULT([$cross_compiling]) +])# _AC_COMPILER_EXEEXT_CROSS + + +# _AC_COMPILER_EXEEXT_O +# --------------------- +# Check for the extension used when `-o foo'. Try to see if ac_cv_exeext, +# as computed by _AC_COMPILER_EXEEXT_DEFAULT is OK. +m4_define([_AC_COMPILER_EXEEXT_O], +[AC_MSG_CHECKING([for suffix of executables]) +AS_IF([_AC_DO_VAR(ac_link)], +[# If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + _AC_COMPILER_EXEEXT_REJECT ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` + break;; + * ) break;; + esac +done], + [AC_MSG_FAILURE([cannot compute suffix of executables: cannot compile and link])]) +rm -f conftest conftest$ac_cv_exeext +AC_MSG_RESULT([$ac_cv_exeext]) +])# _AC_COMPILER_EXEEXT_O + + +# _AC_COMPILER_EXEEXT +# ------------------- +# Check for the extension used for executables. It compiles a test +# executable. If this is called, the executable extensions will be +# automatically used by link commands run by the configure script. +# +# Note that some compilers (cross or not), strictly obey to `-o foo' while +# the host requires `foo.exe', so we should not depend upon `-o' to +# test EXEEXT. But then, be sure not to destroy user files. +# +# Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT +# checks whether the compiler works. +# +# Do not rename this macro; Automake decides whether EXEEXT is used +# by checking whether `_AC_COMPILER_EXEEXT' has been expanded. +# +# See _AC_COMPILER_EXEEXT_CROSS for why we need _AC_LANG_IO_PROGRAM. +m4_define([_AC_COMPILER_EXEEXT], +[AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +_AC_COMPILER_EXEEXT_DEFAULT +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +_AC_COMPILER_EXEEXT_O +rm -f conftest.$ac_ext +AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl +ac_exeext=$EXEEXT +AC_LANG_CONFTEST([_AC_LANG_IO_PROGRAM]) +ac_clean_files="$ac_clean_files conftest.out" +_AC_COMPILER_EXEEXT_CROSS +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +])# _AC_COMPILER_EXEEXT + + +# _AC_COMPILER_OBJEXT +# ------------------- +# Check the object extension used by the compiler: typically `.o' or +# `.obj'. If this is called, some other behavior will change, +# determined by ac_objext. +# +# This macro is called by AC_LANG_COMPILER, the latter being required +# by the AC_COMPILE_IFELSE macros, so use _AC_COMPILE_IFELSE. And in fact, +# don't, since _AC_COMPILE_IFELSE needs to know ac_objext for the `test -s' +# it includes. So do it by hand. +m4_define([_AC_COMPILER_OBJEXT], +[AC_CACHE_CHECK([for suffix of object files], ac_cv_objext, +[AC_LANG_CONFTEST([_AC_LANG_NULL_PROGRAM]) +rm -f conftest.o conftest.obj +AS_IF([_AC_DO_VAR(ac_compile)], +[for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + _AC_COMPILER_OBJEXT_REJECT ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done], + [_AC_MSG_LOG_CONFTEST +AC_MSG_FAILURE([cannot compute suffix of object files: cannot compile])]) +rm -f conftest.$ac_cv_objext conftest.$ac_ext]) +AC_SUBST([OBJEXT], [$ac_cv_objext])dnl +ac_objext=$OBJEXT +])# _AC_COMPILER_OBJEXT + + + + +## ------------------------------- ## +## 4. Compilers' characteristics. ## +## ------------------------------- ## + +# AC_LANG_WERROR +# -------------- +# Treat warnings from the current language's preprocessor, compiler, and +# linker as fatal errors. +AC_DEFUN([AC_LANG_WERROR], +[m4_divert_text([DEFAULTS], [ac_[]_AC_LANG_ABBREV[]_werror_flag=]) +ac_[]_AC_LANG_ABBREV[]_werror_flag=yes])# AC_LANG_WERROR diff --git a/lib/autoconf/libs.m4 b/lib/autoconf/libs.m4 new file mode 100644 index 0000000..934c50d --- /dev/null +++ b/lib/autoconf/libs.m4 @@ -0,0 +1,478 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Checking for libraries. +# Copyright (C) 1992-1996, 1998-2006, 2008-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + +# Table of contents +# +# 1. Generic tests for libraries +# 2. Tests for specific libraries + + +## --------------------------------- ## +## 1. Generic tests for libraries.## ## +## --------------------------------- ## + + + +# AC_SEARCH_LIBS(FUNCTION, SEARCH-LIBS, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [OTHER-LIBRARIES]) +# -------------------------------------------------------- +# Search for a library defining FUNC, if it's not already available. +AC_DEFUN([AC_SEARCH_LIBS], +[AS_VAR_PUSHDEF([ac_Search], [ac_cv_search_$1])dnl +AC_CACHE_CHECK([for library containing $1], [ac_Search], +[ac_func_search_save_LIBS=$LIBS +AC_LANG_CONFTEST([AC_LANG_CALL([], [$1])]) +for ac_lib in '' $2; do + if test -z "$ac_lib"; then + ac_res="none required" + else + ac_res=-l$ac_lib + LIBS="-l$ac_lib $5 $ac_func_search_save_LIBS" + fi + AC_LINK_IFELSE([], [AS_VAR_SET([ac_Search], [$ac_res])]) + AS_VAR_SET_IF([ac_Search], [break]) +done +AS_VAR_SET_IF([ac_Search], , [AS_VAR_SET([ac_Search], [no])]) +rm conftest.$ac_ext +LIBS=$ac_func_search_save_LIBS]) +AS_VAR_COPY([ac_res], [ac_Search]) +AS_IF([test "$ac_res" != no], + [test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + $3], + [$4]) +AS_VAR_POPDEF([ac_Search])dnl +]) + + + +# AC_CHECK_LIB(LIBRARY, FUNCTION, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [OTHER-LIBRARIES]) +# ------------------------------------------------------ +# +# Use a cache variable name containing both the library and function name, +# because the test really is for library $1 defining function $2, not +# just for library $1. Separate tests with the same $1 and different $2s +# may have different results. +# +# Note that using directly AS_VAR_PUSHDEF([ac_Lib], [ac_cv_lib_$1_$2]) +# is asking for troubles, since AC_CHECK_LIB($lib, fun) would give +# ac_cv_lib_$lib_fun, which is definitely not what was meant. Hence +# the AS_LITERAL_IF indirection. +# +# FIXME: This macro is extremely suspicious. It DEFINEs unconditionally, +# whatever the FUNCTION, in addition to not being a *S macro. Note +# that the cache does depend upon the function we are looking for. +# +# It is on purpose we used `ac_check_lib_save_LIBS' and not just +# `ac_save_LIBS': there are many macros which don't want to see `LIBS' +# changed but still want to use AC_CHECK_LIB, so they save `LIBS'. +# And ``ac_save_LIBS' is too tempting a name, so let's leave them some +# freedom. +AC_DEFUN([AC_CHECK_LIB], +[m4_ifval([$3], , [AH_CHECK_LIB([$1])])dnl +AS_LITERAL_WORD_IF([$1], + [AS_VAR_PUSHDEF([ac_Lib], [ac_cv_lib_$1_$2])], + [AS_VAR_PUSHDEF([ac_Lib], [ac_cv_lib_$1''_$2])])dnl +AC_CACHE_CHECK([for $2 in -l$1], [ac_Lib], +[ac_check_lib_save_LIBS=$LIBS +LIBS="-l$1 $5 $LIBS" +AC_LINK_IFELSE([AC_LANG_CALL([], [$2])], + [AS_VAR_SET([ac_Lib], [yes])], + [AS_VAR_SET([ac_Lib], [no])]) +LIBS=$ac_check_lib_save_LIBS]) +AS_VAR_IF([ac_Lib], [yes], + [m4_default([$3], [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_LIB$1)) + LIBS="-l$1 $LIBS" +])], + [$4]) +AS_VAR_POPDEF([ac_Lib])dnl +])# AC_CHECK_LIB + + +# AH_CHECK_LIB(LIBNAME) +# --------------------- +m4_define([AH_CHECK_LIB], +[AH_TEMPLATE(AS_TR_CPP([HAVE_LIB$1]), + [Define to 1 if you have the `$1' library (-l$1).])]) + + +# AC_HAVE_LIBRARY(LIBRARY, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [OTHER-LIBRARIES]) +# --------------------------------------------------------- +# +# This macro is equivalent to calling `AC_CHECK_LIB' with a FUNCTION +# argument of `main'. In addition, LIBRARY can be written as any of +# `foo', `-lfoo', or `libfoo.a'. In all of those cases, the compiler +# is passed `-lfoo'. However, LIBRARY cannot be a shell variable; +# it must be a literal name. +AU_DEFUN([AC_HAVE_LIBRARY], +[m4_pushdef([AC_Lib_Name], + m4_bpatsubst(m4_bpatsubst([[$1]], + [lib\([^\.]*\)\.a], [\1]), + [-l], []))dnl +AC_CHECK_LIB(AC_Lib_Name, main, [$2], [$3], [$4])dnl +ac_cv_lib_[]AC_Lib_Name()=ac_cv_lib_[]AC_Lib_Name()_main +m4_popdef([AC_Lib_Name])dnl +]) + + + + +## --------------------------------- ## +## 2. Tests for specific libraries. ## +## --------------------------------- ## + + + +# --------------------- # +# Checks for X window. # +# --------------------- # + + +# _AC_PATH_X_XMKMF +# ---------------- +# Internal subroutine of _AC_PATH_X. +# Set ac_x_includes and/or ac_x_libraries. +m4_define([_AC_PATH_X_XMKMF], +[AC_ARG_VAR(XMKMF, [Path to xmkmf, Makefile generator for X Window System])dnl +rm -f -r conftest.dir +if mkdir conftest.dir; then + cd conftest.dir + cat >Imakefile <<'_ACEOF' +incroot: + @echo incroot='${INCROOT}' +usrlibdir: + @echo usrlibdir='${USRLIBDIR}' +libdir: + @echo libdir='${LIBDIR}' +_ACEOF + if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then + # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. + for ac_var in incroot usrlibdir libdir; do + eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`" + done + # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR. + for ac_extension in a so sl dylib la dll; do + if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" && + test -f "$ac_im_libdir/libX11.$ac_extension"; then + ac_im_usrlibdir=$ac_im_libdir; break + fi + done + # Screen out bogus values from the imake configuration. They are + # bogus both because they are the default anyway, and because + # using them would break gcc on systems where it needs fixed includes. + case $ac_im_incroot in + /usr/include) ac_x_includes= ;; + *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;; + esac + case $ac_im_usrlibdir in + /usr/lib | /usr/lib64 | /lib | /lib64) ;; + *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;; + esac + fi + cd .. + rm -f -r conftest.dir +fi +])# _AC_PATH_X_XMKMF + + +# _AC_PATH_X_DIRECT +# ----------------- +# Internal subroutine of _AC_PATH_X. +# Set ac_x_includes and/or ac_x_libraries. +m4_define([_AC_PATH_X_DIRECT], +[# Standard set of common directories for X headers. +# Check X11 before X11Rn because it is often a symlink to the current release. +ac_x_header_dirs=' +/usr/X11/include +/usr/X11R7/include +/usr/X11R6/include +/usr/X11R5/include +/usr/X11R4/include + +/usr/include/X11 +/usr/include/X11R7 +/usr/include/X11R6 +/usr/include/X11R5 +/usr/include/X11R4 + +/usr/local/X11/include +/usr/local/X11R7/include +/usr/local/X11R6/include +/usr/local/X11R5/include +/usr/local/X11R4/include + +/usr/local/include/X11 +/usr/local/include/X11R7 +/usr/local/include/X11R6 +/usr/local/include/X11R5 +/usr/local/include/X11R4 + +/usr/X386/include +/usr/x386/include +/usr/XFree86/include/X11 + +/usr/include +/usr/local/include +/usr/unsupported/include +/usr/athena/include +/usr/local/x11r5/include +/usr/lpp/Xamples/include + +/usr/openwin/include +/usr/openwin/share/include' + +if test "$ac_x_includes" = no; then + # Guess where to find include files, by looking for Xlib.h. + # First, try using that file with no special directory specified. + AC_PREPROC_IFELSE([AC_LANG_SOURCE([@%:@include <X11/Xlib.h>])], +[# We can compile using X headers with no special include directory. +ac_x_includes=], +[for ac_dir in $ac_x_header_dirs; do + if test -r "$ac_dir/X11/Xlib.h"; then + ac_x_includes=$ac_dir + break + fi +done]) +fi # $ac_x_includes = no + +if test "$ac_x_libraries" = no; then + # Check for the libraries. + # See if we find them without any special options. + # Don't add to $LIBS permanently. + ac_save_LIBS=$LIBS + LIBS="-lX11 $LIBS" + AC_LINK_IFELSE([AC_LANG_PROGRAM([@%:@include <X11/Xlib.h>], + [XrmInitialize ()])], + [LIBS=$ac_save_LIBS +# We can link X programs with no special library path. +ac_x_libraries=], + [LIBS=$ac_save_LIBS +for ac_dir in `AS_ECHO(["$ac_x_includes $ac_x_header_dirs"]) | sed s/include/lib/g` +do + # Don't even attempt the hair of trying to link an X program! + for ac_extension in a so sl dylib la dll; do + if test -r "$ac_dir/libX11.$ac_extension"; then + ac_x_libraries=$ac_dir + break 2 + fi + done +done]) +fi # $ac_x_libraries = no +])# _AC_PATH_X_DIRECT + + +# _AC_PATH_X +# ---------- +# Compute ac_cv_have_x. +AC_DEFUN([_AC_PATH_X], +[AC_CACHE_VAL(ac_cv_have_x, +[# One or both of the vars are not set, and there is no cached value. +ac_x_includes=no ac_x_libraries=no +_AC_PATH_X_XMKMF +_AC_PATH_X_DIRECT +case $ac_x_includes,$ac_x_libraries in #( + no,* | *,no | *\'*) + # Didn't find X, or a directory has "'" in its name. + ac_cv_have_x="have_x=no";; #( + *) + # Record where we found X for the cache. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$ac_x_includes'\ + ac_x_libraries='$ac_x_libraries'" +esac])dnl +]) + + +# AC_PATH_X +# --------- +# If we find X, set shell vars x_includes and x_libraries to the +# paths, otherwise set no_x=yes. +# Uses ac_ vars as temps to allow command line to override cache and checks. +# --without-x overrides everything else, but does not touch the cache. +AN_HEADER([X11/Xlib.h], [AC_PATH_X]) +AC_DEFUN([AC_PATH_X], +[dnl Document the X abnormal options inherited from history. +m4_divert_once([HELP_BEGIN], [ +X features: + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR])dnl +AC_MSG_CHECKING([for X]) + +AC_ARG_WITH(x, [ --with-x use the X Window System]) +# $have_x is `yes', `no', `disabled', or empty when we do not yet know. +if test "x$with_x" = xno; then + # The user explicitly disabled X. + have_x=disabled +else + case $x_includes,$x_libraries in #( + *\'*) AC_MSG_ERROR([cannot use X directory names containing ']);; #( + *,NONE | NONE,*) _AC_PATH_X;; #( + *) have_x=yes;; + esac + eval "$ac_cv_have_x" +fi # $with_x != no + +if test "$have_x" != yes; then + AC_MSG_RESULT([$have_x]) + no_x=yes +else + # If each of the values was on the command line, it overrides each guess. + test "x$x_includes" = xNONE && x_includes=$ac_x_includes + test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries + # Update the cache value to reflect the command line values. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$x_includes'\ + ac_x_libraries='$x_libraries'" + AC_MSG_RESULT([libraries $x_libraries, headers $x_includes]) +fi +])# AC_PATH_X + + + +# AC_PATH_XTRA +# ------------ +# Find additional X libraries, magic flags, etc. +AC_DEFUN([AC_PATH_XTRA], +[AC_REQUIRE([AC_PATH_X])dnl +if test "$no_x" = yes; then + # Not all programs may use this symbol, but it does not hurt to define it. + AC_DEFINE([X_DISPLAY_MISSING], 1, + [Define to 1 if the X Window System is missing or not being used.]) + X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS= +else + if test -n "$x_includes"; then + X_CFLAGS="$X_CFLAGS -I$x_includes" + fi + + # It would also be nice to do this for all -L options, not just this one. + if test -n "$x_libraries"; then + X_LIBS="$X_LIBS -L$x_libraries" + # For Solaris; some versions of Sun CC require a space after -R and + # others require no space. Words are not sufficient . . . . + AC_MSG_CHECKING([whether -R must be followed by a space]) + ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries" + ac_xsave_[]_AC_LANG_ABBREV[]_werror_flag=$ac_[]_AC_LANG_ABBREV[]_werror_flag + ac_[]_AC_LANG_ABBREV[]_werror_flag=yes + AC_LINK_IFELSE([AC_LANG_PROGRAM()], + [AC_MSG_RESULT([no]) + X_LIBS="$X_LIBS -R$x_libraries"], + [LIBS="$ac_xsave_LIBS -R $x_libraries" + AC_LINK_IFELSE([AC_LANG_PROGRAM()], + [AC_MSG_RESULT([yes]) + X_LIBS="$X_LIBS -R $x_libraries"], + [AC_MSG_RESULT([neither works])])]) + ac_[]_AC_LANG_ABBREV[]_werror_flag=$ac_xsave_[]_AC_LANG_ABBREV[]_werror_flag + LIBS=$ac_xsave_LIBS + fi + + # Check for system-dependent libraries X programs must link with. + # Do this before checking for the system-independent R6 libraries + # (-lICE), since we may need -lsocket or whatever for X linking. + + if test "$ISC" = yes; then + X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet" + else + # Martyn Johnson says this is needed for Ultrix, if the X + # libraries were built with DECnet support. And Karl Berry says + # the Alpha needs dnet_stub (dnet does not exist). + ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11" + AC_LINK_IFELSE([AC_LANG_CALL([], [XOpenDisplay])], + [], + [AC_CHECK_LIB(dnet, dnet_ntoa, [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"]) + if test $ac_cv_lib_dnet_dnet_ntoa = no; then + AC_CHECK_LIB(dnet_stub, dnet_ntoa, + [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"]) + fi]) + LIBS="$ac_xsave_LIBS" + + # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT, + # to get the SysV transport functions. + # Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4) + # needs -lnsl. + # The nsl library prevents programs from opening the X display + # on Irix 5.2, according to T.E. Dickey. + # The functions gethostbyname, getservbyname, and inet_addr are + # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking. + AC_CHECK_FUNC(gethostbyname) + if test $ac_cv_func_gethostbyname = no; then + AC_CHECK_LIB(nsl, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl") + if test $ac_cv_lib_nsl_gethostbyname = no; then + AC_CHECK_LIB(bsd, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd") + fi + fi + + # lieder@skyler.mavd.honeywell.com says without -lsocket, + # socket/setsockopt and other routines are undefined under SCO ODT + # 2.0. But -lsocket is broken on IRIX 5.2 (and is not necessary + # on later versions), says Simon Leinen: it contains gethostby* + # variants that don't use the name server (or something). -lsocket + # must be given before -lnsl if both are needed. We assume that + # if connect needs -lnsl, so does gethostbyname. + AC_CHECK_FUNC(connect) + if test $ac_cv_func_connect = no; then + AC_CHECK_LIB(socket, connect, X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS", , + $X_EXTRA_LIBS) + fi + + # Guillermo Gomez says -lposix is necessary on A/UX. + AC_CHECK_FUNC(remove) + if test $ac_cv_func_remove = no; then + AC_CHECK_LIB(posix, remove, X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix") + fi + + # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay. + AC_CHECK_FUNC(shmat) + if test $ac_cv_func_shmat = no; then + AC_CHECK_LIB(ipc, shmat, X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc") + fi + fi + + # Check for libraries that X11R6 Xt/Xaw programs need. + ac_save_LDFLAGS=$LDFLAGS + test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries" + # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to + # check for ICE first), but we must link in the order -lSM -lICE or + # we get undefined symbols. So assume we have SM if we have ICE. + # These have to be linked with before -lX11, unlike the other + # libraries we check for below, so use a different variable. + # John Interrante, Karl Berry + AC_CHECK_LIB(ICE, IceConnectionNumber, + [X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"], , $X_EXTRA_LIBS) + LDFLAGS=$ac_save_LDFLAGS + +fi +AC_SUBST(X_CFLAGS)dnl +AC_SUBST(X_PRE_LIBS)dnl +AC_SUBST(X_LIBS)dnl +AC_SUBST(X_EXTRA_LIBS)dnl +])# AC_PATH_XTRA diff --git a/lib/autoconf/oldnames.m4 b/lib/autoconf/oldnames.m4 new file mode 100644 index 0000000..a04eec8 --- /dev/null +++ b/lib/autoconf/oldnames.m4 @@ -0,0 +1,92 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Support old macros, and provide automated updates. +# Copyright (C) 1994, 1999-2001, 2003, 2009-2012 Free Software +# Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Originally written by David J. MacKenzie. + + +## ---------------------------- ## +## General macros of Autoconf. ## +## ---------------------------- ## + +AU_ALIAS([AC_WARN], [AC_MSG_WARN]) +AU_ALIAS([AC_ERROR], [AC_MSG_ERROR]) +AU_ALIAS([AC_HAVE_HEADERS], [AC_CHECK_HEADERS]) +AU_ALIAS([AC_HEADER_CHECK], [AC_CHECK_HEADER]) +AU_ALIAS([AC_HEADER_EGREP], [AC_EGREP_HEADER]) +AU_ALIAS([AC_PREFIX], [AC_PREFIX_PROGRAM]) +AU_ALIAS([AC_PROGRAMS_CHECK], [AC_CHECK_PROGS]) +AU_ALIAS([AC_PROGRAMS_PATH], [AC_PATH_PROGS]) +AU_ALIAS([AC_PROGRAM_CHECK], [AC_CHECK_PROG]) +AU_ALIAS([AC_PROGRAM_EGREP], [AC_EGREP_CPP]) +AU_ALIAS([AC_PROGRAM_PATH], [AC_PATH_PROG]) +AU_ALIAS([AC_SIZEOF_TYPE], [AC_CHECK_SIZEOF]) +AU_ALIAS([AC_TEST_CPP], [AC_TRY_CPP]) +AU_ALIAS([AC_TEST_PROGRAM], [AC_TRY_RUN]) + + + +## ----------------------------- ## +## Specific macros of Autoconf. ## +## ----------------------------- ## + +AU_ALIAS([AC_CHAR_UNSIGNED], [AC_C_CHAR_UNSIGNED]) +AU_ALIAS([AC_CONST], [AC_C_CONST]) +AU_ALIAS([AC_CROSS_CHECK], [AC_C_CROSS]) +AU_ALIAS([AC_FIND_X], [AC_PATH_X]) +AU_ALIAS([AC_FIND_XTRA], [AC_PATH_XTRA]) +AU_ALIAS([AC_GCC_TRADITIONAL], [AC_PROG_GCC_TRADITIONAL]) +AU_ALIAS([AC_GETGROUPS_T], [AC_TYPE_GETGROUPS]) +AU_ALIAS([AC_INLINE], [AC_C_INLINE]) +AU_ALIAS([AC_LN_S], [AC_PROG_LN_S]) +AU_ALIAS([AC_LONG_DOUBLE], [AC_C_LONG_DOUBLE]) +AU_ALIAS([AC_LONG_FILE_NAMES], [AC_SYS_LONG_FILE_NAMES]) +AU_ALIAS([AC_MAJOR_HEADER], [AC_HEADER_MAJOR]) +AU_ALIAS([AC_MINUS_C_MINUS_O], [AC_PROG_CC_C_O]) +AU_ALIAS([AC_MODE_T], [AC_TYPE_MODE_T]) +AU_ALIAS([AC_OFF_T], [AC_TYPE_OFF_T]) +AU_ALIAS([AC_PID_T], [AC_TYPE_PID_T]) +AU_ALIAS([AC_RESTARTABLE_SYSCALLS], [AC_SYS_RESTARTABLE_SYSCALLS]) +AU_ALIAS([AC_RETSIGTYPE], [AC_TYPE_SIGNAL]) +AU_ALIAS([AC_SET_MAKE], [AC_PROG_MAKE_SET]) +AU_ALIAS([AC_SIZE_T], [AC_TYPE_SIZE_T]) +AU_ALIAS([AC_STAT_MACROS_BROKEN], [AC_HEADER_STAT]) +AU_ALIAS([AC_STDC_HEADERS], [AC_HEADER_STDC]) +AU_ALIAS([AC_ST_BLKSIZE], [AC_STRUCT_ST_BLKSIZE]) +AU_ALIAS([AC_ST_BLOCKS], [AC_STRUCT_ST_BLOCKS]) +AU_ALIAS([AC_ST_RDEV], [AC_STRUCT_ST_RDEV]) +AU_ALIAS([AC_SYS_SIGLIST_DECLARED], [AC_DECL_SYS_SIGLIST]) +AU_ALIAS([AC_TIMEZONE], [AC_STRUCT_TIMEZONE]) +AU_ALIAS([AC_TIME_WITH_SYS_TIME], [AC_HEADER_TIME]) +AU_ALIAS([AC_UID_T], [AC_TYPE_UID_T]) +AU_ALIAS([AC_WORDS_BIGENDIAN], [AC_C_BIGENDIAN]) +AU_ALIAS([AC_YYTEXT_POINTER], [AC_DECL_YYTEXT]) +AU_ALIAS([AM_CYGWIN32], [AC_CYGWIN32]) +AU_ALIAS([AC_CYGWIN32], [AC_CYGWIN]) +AU_ALIAS([AM_EXEEXT], [AC_EXEEXT]) +# We cannot do this, because in libtool.m4 yet they provide +# this update. Some solution is needed. +# AU_ALIAS([AM_PROG_LIBTOOL], [AC_PROG_LIBTOOL]) +AU_ALIAS([AM_MINGW32], [AC_MINGW32]) +AU_ALIAS([AM_PROG_INSTALL], [AC_PROG_INSTALL]) diff --git a/lib/autoconf/programs.m4 b/lib/autoconf/programs.m4 new file mode 100644 index 0000000..2013a7a --- /dev/null +++ b/lib/autoconf/programs.m4 @@ -0,0 +1,902 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Checking for programs. + +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +## ----------------------------- ## +## Generic checks for programs. ## +## ----------------------------- ## + + +# _AC_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR, +# [VALUE-IF-FOUND], [VALUE-IF-NOT-FOUND], +# [PATH], [REJECT]) +# ----------------------------------------------------- +AC_DEFUN([_AC_CHECK_PROG], +[# Extract the first word of "$2", so it can be a program name with args. +set dummy $2; ac_word=$[2] +AC_MSG_CHECKING([for $ac_word]) +AC_CACHE_VAL(ac_cv_prog_$1, +[if test -n "$$1"; then + ac_cv_prog_$1="$$1" # Let the user override the test. +else +m4_ifvaln([$6], +[ ac_prog_rejected=no])dnl +_AS_PATH_WALK([$5], +[for ac_exec_ext in '' $ac_executable_extensions; do + if AS_EXECUTABLE_P(["$as_dir/$ac_word$ac_exec_ext"]); then +m4_ifvaln([$6], +[ if test "$as_dir/$ac_word$ac_exec_ext" = "$6"; then + ac_prog_rejected=yes + continue + fi])dnl + ac_cv_prog_$1="$3" + _AS_ECHO_LOG([found $as_dir/$ac_word$ac_exec_ext]) + break 2 + fi +done]) +m4_ifvaln([$6], +[if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_$1 + shift + if test $[@%:@] != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set $1 to just the basename; use the full file name. + shift + ac_cv_prog_$1="$as_dir/$ac_word${1+' '}$[@]" +m4_if([$2], [$4], +[ else + # Default is a loser. + AC_MSG_ERROR([$1=$6 unacceptable, but no other $4 found in dnl +m4_default([$5], [\$PATH])]) +])dnl + fi +fi])dnl +dnl If no 4th arg is given, leave the cache variable unset, +dnl so AC_CHECK_PROGS will keep looking. +m4_ifvaln([$4], +[ test -z "$ac_cv_prog_$1" && ac_cv_prog_$1="$4"])dnl +fi])dnl +$1=$ac_cv_prog_$1 +if test -n "$$1"; then + AC_MSG_RESULT([$$1]) +else + AC_MSG_RESULT([no]) +fi +])# _AC_CHECK_PROG + + +# AC_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR, +# [VALUE-IF-FOUND], [VALUE-IF-NOT-FOUND], +# [PATH], [REJECT]) +# ----------------------------------------------------- +AC_DEFUN([AC_CHECK_PROG], +[_AC_CHECK_PROG($@) +AC_SUBST([$1])dnl +]) + + +# AC_CHECK_PROGS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], +# [PATH]) +# ------------------------------------------------------------------ +AC_DEFUN([AC_CHECK_PROGS], +[for ac_prog in $2 +do + AC_CHECK_PROG([$1], [$ac_prog], [$ac_prog], , [$4]) + test -n "$$1" && break +done +m4_ifvaln([$3], [test -n "$$1" || $1="$3"])]) + + +# _AC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------------------------------ +AC_DEFUN([_AC_PATH_PROG], +[# Extract the first word of "$2", so it can be a program name with args. +set dummy $2; ac_word=$[2] +AC_MSG_CHECKING([for $ac_word]) +AC_CACHE_VAL([ac_cv_path_$1], +[case $$1 in + [[\\/]]* | ?:[[\\/]]*) + ac_cv_path_$1="$$1" # Let the user override the test with a path. + ;; + *) + _AS_PATH_WALK([$4], +[for ac_exec_ext in '' $ac_executable_extensions; do + if AS_EXECUTABLE_P(["$as_dir/$ac_word$ac_exec_ext"]); then + ac_cv_path_$1="$as_dir/$ac_word$ac_exec_ext" + _AS_ECHO_LOG([found $as_dir/$ac_word$ac_exec_ext]) + break 2 + fi +done]) +dnl If no 3rd arg is given, leave the cache variable unset, +dnl so AC_PATH_PROGS will keep looking. +m4_ifvaln([$3], +[ test -z "$ac_cv_path_$1" && ac_cv_path_$1="$3"])dnl + ;; +esac])dnl +$1=$ac_cv_path_$1 +if test -n "$$1"; then + AC_MSG_RESULT([$$1]) +else + AC_MSG_RESULT([no]) +fi +])# _AC_PATH_PROG + + +# AC_PATH_PROG(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ----------------------------------------------------------------------- +AC_DEFUN([AC_PATH_PROG], +[_AC_PATH_PROG($@) +AC_SUBST([$1])dnl +]) + + +# AC_PATH_PROGS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], +# [PATH]) +# ----------------------------------------------------------------- +AC_DEFUN([AC_PATH_PROGS], +[for ac_prog in $2 +do + AC_PATH_PROG([$1], [$ac_prog], , [$4]) + test -n "$$1" && break +done +m4_ifvaln([$3], [test -n "$$1" || $1="$3"])dnl +]) + + + + +## -------------------------- ## +## Generic checks for tools. ## +## -------------------------- ## + + +# AC_CHECK_TOOL_PREFIX +# -------------------- +AU_DEFUN([AC_CHECK_TOOL_PREFIX]) + + +# _AC_TOOL_WARN +# ------------- +AC_DEFUN([_AC_TOOL_WARN], +[case $cross_compiling:$ac_tool_warned in +yes:) +AC_MSG_WARN([using cross tools not prefixed with host triplet]) +ac_tool_warned=yes ;; +esac]) + +# AC_PATH_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ----------------------------------------------------------------------- +# (Use different variables $1 and ac_pt_$1 so that cache vars don't conflict.) +AC_DEFUN([AC_PATH_TOOL], +[if test -n "$ac_tool_prefix"; then + AC_PATH_PROG([$1], [${ac_tool_prefix}$2], , [$4]) +fi +if test -z "$ac_cv_path_$1"; then + ac_pt_$1=$$1 + _AC_PATH_PROG([ac_pt_$1], [$2], [], [$4]) + if test "x$ac_pt_$1" = x; then + $1="$3" + else + _AC_TOOL_WARN + $1=$ac_pt_$1 + fi +else + $1="$ac_cv_path_$1" +fi +])# AC_PATH_TOOL + + +# AC_CHECK_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------------------------------ +# (Use different variables $1 and ac_ct_$1 so that cache vars don't conflict.) +AC_DEFUN([AC_CHECK_TOOL], +[if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG([$1], [${ac_tool_prefix}$2], [${ac_tool_prefix}$2], , [$4]) +fi +if test -z "$ac_cv_prog_$1"; then + ac_ct_$1=$$1 + _AC_CHECK_PROG([ac_ct_$1], [$2], [$2], [], [$4]) + if test "x$ac_ct_$1" = x; then + $1="$3" + else + _AC_TOOL_WARN + $1=$ac_ct_$1 + fi +else + $1="$ac_cv_prog_$1" +fi +])# AC_CHECK_TOOL + + +# AC_CHECK_TOOLS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], +# [PATH]) +# ------------------------------------------------------------------ +# Check for each tool in PROGS-TO-CHECK-FOR with the cross prefix. If +# none can be found with a cross prefix, then use the first one that +# was found without the cross prefix. +AC_DEFUN([AC_CHECK_TOOLS], +[if test -n "$ac_tool_prefix"; then + for ac_prog in $2 + do + AC_CHECK_PROG([$1], + [$ac_tool_prefix$ac_prog], [$ac_tool_prefix$ac_prog],, + [$4]) + test -n "$$1" && break + done +fi +if test -z "$$1"; then + ac_ct_$1=$$1 + AC_CHECK_PROGS([ac_ct_$1], [$2], [], [$4]) + if test "x$ac_ct_$1" = x; then + $1="$3" + else + _AC_TOOL_WARN + $1=$ac_ct_$1 + fi +fi +])# AC_CHECK_TOOLS + + +# AC_PATH_TARGET_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------------------------------------ +# (Use different variables $1 and ac_pt_$1 so that cache vars don't conflict.) +AC_DEFUN([AC_PATH_TARGET_TOOL], +[AC_REQUIRE([AC_CANONICAL_TARGET])dnl +AC_PATH_PROG([$1], [$target_alias-$2], , [$4]) +if test -z "$ac_cv_path_$1"; then + if test "$build" = "$target"; then + ac_pt_$1=$$1 + _AC_PATH_PROG([ac_pt_$1], [$2], [$3], [$4]) + $1=$ac_pt_$1 + else + $1="$3" + fi +else + $1="$ac_cv_path_$1" +fi +])# AC_PATH_TARGET_TOOL + + +# AC_CHECK_TARGET_TOOL(VARIABLE, PROG-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], [PATH]) +# ------------------------------------------------------------------------------- +# (Use different variables $1 and ac_ct_$1 so that cache vars don't conflict.) +AC_DEFUN([AC_CHECK_TARGET_TOOL], +[AC_REQUIRE([AC_CANONICAL_TARGET])dnl +AC_CHECK_PROG([$1], [$target_alias-$2], [$target_alias-$2], , [$4]) +if test -z "$ac_cv_prog_$1"; then + if test "$build" = "$target"; then + ac_ct_$1=$$1 + _AC_CHECK_PROG([ac_ct_$1], [$2], [$2], [$3], [$4]) + $1=$ac_ct_$1 + else + $1="$3" + fi +else + $1="$ac_cv_prog_$1" +fi +])# AC_CHECK_TARGET_TOOL + + +# AC_CHECK_TARGET_TOOLS(VARIABLE, PROGS-TO-CHECK-FOR, [VALUE-IF-NOT-FOUND], +# [PATH]) +# ------------------------------------------------------------------------- +# Check for each tool in PROGS-TO-CHECK-FOR with the cross prefix. If +# none can be found with a cross prefix, then use the first one that +# was found without the cross prefix. +AC_DEFUN([AC_CHECK_TARGET_TOOLS], +[AC_REQUIRE([AC_CANONICAL_TARGET])dnl +for ac_prog in $2 +do + AC_CHECK_PROG([$1], + [$target_alias-$ac_prog], [$target_alias-$ac_prog],, + [$4]) + test -n "$$1" && break +done +if test -z "$$1"; then + if test "$build" = "$target"; then + ac_ct_$1=$$1 + AC_CHECK_PROGS([ac_ct_$1], [$2], [$3], [$4]) + $1=$ac_ct_$1 + else + $1="$3" + fi +fi +])# AC_CHECK_TARGET_TOOLS + + + +## ---------------- ## +## Specific tests. ## +## ---------------- ## + +# Please, keep this section sorted. +# (But of course when keeping related things together). + +# Check for gawk first since it's generally better. +AN_MAKEVAR([AWK], [AC_PROG_AWK]) +AN_PROGRAM([awk], [AC_PROG_AWK]) +AN_PROGRAM([gawk], [AC_PROG_AWK]) +AN_PROGRAM([mawk], [AC_PROG_AWK]) +AN_PROGRAM([nawk], [AC_PROG_AWK]) +AC_DEFUN([AC_PROG_AWK], +[AC_CHECK_PROGS(AWK, gawk mawk nawk awk, )]) + + +# AC_PROG_EGREP +# ------------- +AC_DEFUN([AC_PROG_EGREP], +[AC_REQUIRE([AC_PROG_GREP])dnl +AC_CACHE_CHECK([for egrep], ac_cv_path_EGREP, + [if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + _AC_PROG_GREP(EGREP, egrep, ['EGREP$']) + fi]) + EGREP="$ac_cv_path_EGREP" + AC_SUBST([EGREP]) +])# AC_PROG_EGREP + + +# AC_PROG_FGREP +# ------------- +AC_DEFUN([AC_PROG_FGREP], +[AC_REQUIRE([AC_PROG_GREP])dnl +AC_CACHE_CHECK([for fgrep], ac_cv_path_FGREP, + [if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 + then ac_cv_path_FGREP="$GREP -F" + else + _AC_PROG_GREP(FGREP, fgrep, [FGREP]) + fi]) + FGREP="$ac_cv_path_FGREP" + AC_SUBST([FGREP]) +])# AC_PROG_FGREP + + +# AC_PROG_GREP +# ------------ +# Check for a fully functional grep program that handles +# the longest lines possible and which respects multiple -e options. +# Prefer GNU grep if found. +AC_DEFUN([AC_PROG_GREP], +[AC_CACHE_CHECK([for grep that handles long lines and -e], ac_cv_path_GREP, + [_$0(GREP, [grep ggrep], [-e 'GREP$' -e '-(cannot match)-'])]) + GREP="$ac_cv_path_GREP" + AC_SUBST([GREP]) +]) + + +# _AC_PROG_GREP(VARIABLE, PROGNAME-LIST, PROG-ARGUMENTS) +# ------------------------------------------------------ +# Solaris 9 /usr/xpg4/bin/*grep is suitable, but /usr/bin/*grep lacks -e. +# AIX silently truncates long lines before matching. +# NeXT understands only one -e and truncates long lines. +m4_define([_AC_PROG_GREP], +[_AC_PATH_PROGS_FEATURE_CHECK([$1], [$2], + [_AC_FEATURE_CHECK_LENGTH([ac_path_$1], [ac_cv_path_$1], + ["$ac_path_$1" $3], [$1])], [], + [$PATH$PATH_SEPARATOR/usr/xpg4/bin])dnl +]) + + +# _AC_PATH_PROGS_FEATURE_CHECK(VARIABLE, PROGNAME-LIST, FEATURE-TEST, +# [ACTION-IF-NOT-FOUND], [PATH=$PATH]) +# ------------------------------------------------------------------- +# FEATURE-TEST is called repeatedly with $ac_path_VARIABLE set to the +# name of a program in PROGNAME-LIST found in PATH. FEATURE-TEST must set +# $ac_cv_path_VARIABLE to the path of an acceptable program, or else +# ACTION-IF-NOT-FOUND is executed; the default action (for internal use +# only) issues a fatal error message. If a suitable $ac_path_VARIABLE is +# found in the FEATURE-TEST macro, it can set $ac_path_VARIABLE_found=':' +# to accept that value without any further checks. +m4_define([_AC_PATH_PROGS_FEATURE_CHECK], +[if test -z "$$1"; then + ac_path_$1_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + _AS_PATH_WALK([$5], + [for ac_prog in $2; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_$1="$as_dir/$ac_prog$ac_exec_ext" + AS_EXECUTABLE_P(["$ac_path_$1"]) || continue +$3 + $ac_path_$1_found && break 3 + done + done])dnl + if test -z "$ac_cv_path_$1"; then + m4_default([$4], + [AC_MSG_ERROR([no acceptable m4_bpatsubst([$2], [ .*]) could be dnl +found in m4_default([$5], [\$PATH])])]) + fi +else + ac_cv_path_$1=$$1 +fi +]) + + +# AC_PATH_PROGS_FEATURE_CHECK(VARIABLE, PROGNAME-LIST, +# FEATURE-TEST, [ACTION-IF-NOT-FOUND=:], +# [PATH=$PATH]) +# ------------------------------------------------------------------ +# Designed to be used inside AC_CACHE_VAL. It is recommended, +# but not required, that the user also use AC_ARG_VAR([VARIABLE]). +# If VARIABLE is not empty, set the cache variable +# $ac_cv_path_VARIABLE to VARIABLE without any further tests. +# Otherwise, call FEATURE_TEST repeatedly with $ac_path_VARIABLE +# set to the name of a program in PROGNAME-LIST found in PATH. If +# no invocation of FEATURE-TEST sets $ac_cv_path_VARIABLE to the +# path of an acceptable program, ACTION-IF-NOT-FOUND is executed. +# FEATURE-TEST is invoked even when $ac_cv_path_VARIABLE is set, +# in case a better candidate occurs later in PATH; to accept the +# current setting and bypass further checks, FEATURE-TEST can set +# $ac_path_VARIABLE_found=':'. Note that, unlike AC_CHECK_PROGS, +# this macro does not have any side effect on the current value +# of VARIABLE. +m4_define([AC_PATH_PROGS_FEATURE_CHECK], +[_$0([$1], [$2], [$3], m4_default([$4], [:]), [$5])dnl +]) + + +# _AC_FEATURE_CHECK_LENGTH(PROGPATH, CACHE-VAR, CHECK-CMD, [MATCH-STRING]) +# ------------------------------------------------------------------------ +# For use as the FEATURE-TEST argument to _AC_PATH_PROGS_FEATURE_TEST. +# On each iteration run CHECK-CMD on an input file, storing the value +# of PROGPATH in CACHE-VAR if the CHECK-CMD succeeds. The input file +# is always one line, starting with only 10 characters, and doubling +# in length at each iteration until approx 10000 characters or the +# feature check succeeds. The feature check is called at each +# iteration by appending (optionally, MATCH-STRING and) a newline +# to the file, and using the result as input to CHECK-CMD. +m4_define([_AC_FEATURE_CHECK_LENGTH], +[# Check for GNU $1 and select it if it is found. + _AC_PATH_PROG_FLAVOR_GNU([$$1], + [$2="$$1" $1_found=:], + [ac_count=0 + AS_ECHO_N([0123456789]) >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + AS_ECHO(['$4']) >> "conftest.nl" + $3 < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + AS_VAR_ARITH([ac_count], [$ac_count + 1]) + if test $ac_count -gt ${$1_max-0}; then + # Best one so far, save it but keep looking for a better one + $2="$$1" +dnl # Using $1_max so that each tool feature checked gets its +dnl # own variable. Don't reset it otherwise the implied search +dnl # for best performing tool in a list breaks down. + $1_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out])dnl +]) + + +# _AC_PATH_PROG_FLAVOR_GNU(PROGRAM-PATH, IF-SUCCESS, [IF-FAILURE]) +# ---------------------------------------------------------------- +m4_define([_AC_PATH_PROG_FLAVOR_GNU], +[# Check for GNU $1 +case `"$1" --version 2>&1` in +*GNU*) + $2;; +m4_ifval([$3], +[*) + $3;; +])esac +])# _AC_PATH_PROG_FLAVOR_GNU + + +# AC_PROG_INSTALL +# --------------- +AN_MAKEVAR([INSTALL], [AC_PROG_INSTALL]) +AN_PROGRAM([install], [AC_PROG_INSTALL]) +AC_DEFUN_ONCE([AC_PROG_INSTALL], +[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_REQUIRE_AUX_FILE([install-sh])dnl +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +AC_MSG_CHECKING([for a BSD-compatible install]) +if test -z "$INSTALL"; then +AC_CACHE_VAL(ac_cv_path_install, +[_AS_PATH_WALK([$PATH], +[[# Account for people who put trailing slashes in PATH elements. +case $as_dir/ in @%:@(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *)] + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if AS_EXECUTABLE_P(["$as_dir/$ac_prog$ac_exec_ext"]); then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac +]) +rm -rf conftest.one conftest.two conftest.dir +])dnl + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +dnl Do special magic for INSTALL instead of AC_SUBST, to get +dnl relative names right. +AC_MSG_RESULT([$INSTALL]) + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' +AC_SUBST(INSTALL_PROGRAM)dnl + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' +AC_SUBST(INSTALL_SCRIPT)dnl + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' +AC_SUBST(INSTALL_DATA)dnl +])# AC_PROG_INSTALL + + +# AC_PROG_MKDIR_P +# --------------- +# Check whether `mkdir -p' is known to be thread-safe, and fall back to +# install-sh -d otherwise. +# +# Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories +# created by `make install' are always world readable, even if the +# installer happens to have an overly restrictive umask (e.g. 077). +# This was a mistake. There are at least two reasons why we must not +# use `-m 0755': +# - it causes special bits like SGID to be ignored, +# - it may be too restrictive (some setups expect 775 directories). +# +# Do not use -m 0755 and let people choose whatever they expect by +# setting umask. +# +# We cannot accept any implementation of `mkdir' that recognizes `-p'. +# Some implementations (such as Solaris 8's) are vulnerable to race conditions: +# if a parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c' +# concurrently, both version can detect that a/ is missing, but only +# one can create it and the other will error out. Consequently we +# restrict ourselves to known race-free implementations. +# +# Automake used to define mkdir_p as `mkdir -p .', in order to +# allow $(mkdir_p) to be used without argument. As in +# $(mkdir_p) $(somedir) +# where $(somedir) is conditionally defined. However we don't do +# that for MKDIR_P. +# 1. before we restricted the check to GNU mkdir, `mkdir -p .' was +# reported to fail in read-only directories. The system where this +# happened has been forgotten. +# 2. in practice we call $(MKDIR_P) on directories such as +# $(MKDIR_P) "$(DESTDIR)$(somedir)" +# and we don't want to create $(DESTDIR) if $(somedir) is empty. +# To support the latter case, we have to write +# test -z "$(somedir)" || $(MKDIR_P) "$(DESTDIR)$(somedir)" +# so $(MKDIR_P) always has an argument. +# We will have better chances of detecting a missing test if +# $(MKDIR_P) complains about missing arguments. +# 3. $(MKDIR_P) is named after `mkdir -p' and we don't expect this +# to accept no argument. +# 4. having something like `mkdir .' in the output is unsightly. +# +# On NextStep and OpenStep, the `mkdir' command does not +# recognize any option. It will interpret all options as +# directories to create. +AN_MAKEVAR([MKDIR_P], [AC_PROG_MKDIR_P]) +AC_DEFUN_ONCE([AC_PROG_MKDIR_P], +[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_REQUIRE_AUX_FILE([install-sh])dnl +AC_MSG_CHECKING([for a thread-safe mkdir -p]) +if test -z "$MKDIR_P"; then + AC_CACHE_VAL([ac_cv_path_mkdir], + [_AS_PATH_WALK([$PATH$PATH_SEPARATOR/opt/sfw/bin], + [for ac_prog in mkdir gmkdir; do + for ac_exec_ext in '' $ac_executable_extensions; do + AS_EXECUTABLE_P(["$as_dir/$ac_prog$ac_exec_ext"]) || continue + case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( + 'mkdir (GNU coreutils) '* | \ + 'mkdir (coreutils) '* | \ + 'mkdir (fileutils) '4.1*) + ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext + break 3;; + esac + done + done])]) + test -d ./--version && rmdir ./--version + if test "${ac_cv_path_mkdir+set}" = set; then + MKDIR_P="$ac_cv_path_mkdir -p" + else + # As a last resort, use the slow shell script. Don't cache a + # value for MKDIR_P within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + MKDIR_P="$ac_install_sh -d" + fi +fi +dnl status.m4 does special magic for MKDIR_P instead of AC_SUBST, +dnl to get relative names right. However, also AC_SUBST here so +dnl that Automake versions before 1.10 will pick it up (they do not +dnl trace AC_SUBST_TRACE). +dnl FIXME: Remove this once we drop support for Automake < 1.10. +AC_SUBST([MKDIR_P])dnl +AC_MSG_RESULT([$MKDIR_P]) +])# AC_PROG_MKDIR_P + + +# AC_PROG_LEX +# ----------- +# Look for flex or lex. Set its associated library to LEXLIB. +# Check if lex declares yytext as a char * by default, not a char[]. +AN_MAKEVAR([LEX], [AC_PROG_LEX]) +AN_PROGRAM([lex], [AC_PROG_LEX]) +AN_PROGRAM([flex], [AC_PROG_LEX]) +AC_DEFUN_ONCE([AC_PROG_LEX], +[AC_CHECK_PROGS(LEX, flex lex, :) +if test "x$LEX" != "x:"; then + _AC_PROG_LEX_YYTEXT_DECL +fi]) + + +# _AC_PROG_LEX_YYTEXT_DECL +# ------------------------ +# Check for the Lex output root, the Lex library, and whether Lex +# declares yytext as a char * by default. +m4_define([_AC_PROG_LEX_YYTEXT_DECL], +[cat >conftest.l <<_ACEOF[ +%% +a { ECHO; } +b { REJECT; } +c { yymore (); } +d { yyless (1); } +e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument. */ + yyless ((input () != 0)); } +f { unput (yytext[0]); } +. { BEGIN INITIAL; } +%% +#ifdef YYTEXT_POINTER +extern char *yytext; +#endif +int +main (void) +{ + return ! yylex () + ! yywrap (); +} +]_ACEOF +_AC_DO_VAR(LEX conftest.l) +AC_CACHE_CHECK([lex output file root], [ac_cv_prog_lex_root], [ +if test -f lex.yy.c; then + ac_cv_prog_lex_root=lex.yy +elif test -f lexyy.c; then + ac_cv_prog_lex_root=lexyy +else + AC_MSG_ERROR([cannot find output from $LEX; giving up]) +fi]) +AC_SUBST([LEX_OUTPUT_ROOT], [$ac_cv_prog_lex_root])dnl + +if test -z "${LEXLIB+set}"; then + AC_CACHE_CHECK([lex library], [ac_cv_lib_lex], [ + ac_save_LIBS=$LIBS + ac_cv_lib_lex='none needed' + for ac_lib in '' -lfl -ll; do + LIBS="$ac_lib $ac_save_LIBS" + AC_LINK_IFELSE([AC_LANG_DEFINES_PROVIDED[`cat $LEX_OUTPUT_ROOT.c`]], + [ac_cv_lib_lex=$ac_lib]) + test "$ac_cv_lib_lex" != 'none needed' && break + done + LIBS=$ac_save_LIBS + ]) + test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex +fi +AC_SUBST(LEXLIB) + +AC_CACHE_CHECK(whether yytext is a pointer, ac_cv_prog_lex_yytext_pointer, +[# POSIX says lex can declare yytext either as a pointer or an array; the +# default is implementation-dependent. Figure out which it is, since +# not all implementations provide the %pointer and %array declarations. +ac_cv_prog_lex_yytext_pointer=no +ac_save_LIBS=$LIBS +LIBS="$LEXLIB $ac_save_LIBS" +AC_LINK_IFELSE([AC_LANG_DEFINES_PROVIDED + [#define YYTEXT_POINTER 1 +`cat $LEX_OUTPUT_ROOT.c`]], + [ac_cv_prog_lex_yytext_pointer=yes]) +LIBS=$ac_save_LIBS +]) +dnl +if test $ac_cv_prog_lex_yytext_pointer = yes; then + AC_DEFINE(YYTEXT_POINTER, 1, + [Define to 1 if `lex' declares `yytext' as a `char *' by default, + not a `char[]'.]) +fi +rm -f conftest.l $LEX_OUTPUT_ROOT.c +])# _AC_PROG_LEX_YYTEXT_DECL + + +# Require AC_PROG_LEX in case some people were just calling this macro. +AU_DEFUN([AC_DECL_YYTEXT], [AC_PROG_LEX]) + + +# AC_PROG_LN_S +# ------------ +AN_MAKEVAR([LN], [AC_PROG_LN_S]) +AN_PROGRAM([ln], [AC_PROG_LN_S]) +AC_DEFUN([AC_PROG_LN_S], +[AC_MSG_CHECKING([whether ln -s works]) +AC_SUBST([LN_S], [$as_ln_s])dnl +if test "$LN_S" = "ln -s"; then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no, using $LN_S]) +fi +])# AC_PROG_LN_S + + +# AC_PROG_MAKE_SET +# ---------------- +# Define SET_MAKE to set ${MAKE} if Make does not do so automatically. If Make +# does not run the test Makefile, we assume that the Make program the user will +# invoke does set $(MAKE). This is typical, and emitting `MAKE=foomake' is +# always wrong if `foomake' is not available or does not work. +AN_MAKEVAR([MAKE], [AC_PROG_MAKE_SET]) +AN_PROGRAM([make], [AC_PROG_MAKE_SET]) +AC_DEFUN([AC_PROG_MAKE_SET], +[AC_MSG_CHECKING([whether ${MAKE-make} sets \$(MAKE)]) +set x ${MAKE-make} +ac_make=`AS_ECHO(["$[2]"]) | sed 's/+/p/g; s/[[^a-zA-Z0-9_]]/_/g'` +AC_CACHE_VAL(ac_cv_prog_make_${ac_make}_set, +[cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make])dnl +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + AC_MSG_RESULT([yes]) + SET_MAKE= +else + AC_MSG_RESULT([no]) + SET_MAKE="MAKE=${MAKE-make}" +fi +AC_SUBST([SET_MAKE])dnl +])# AC_PROG_MAKE_SET + + +# AC_PROG_RANLIB +# -------------- +AN_MAKEVAR([RANLIB], [AC_PROG_RANLIB]) +AN_PROGRAM([ranlib], [AC_PROG_RANLIB]) +AC_DEFUN([AC_PROG_RANLIB], +[AC_CHECK_TOOL(RANLIB, ranlib, :)]) + + +# AC_RSH +# ------ +# I don't know what it used to do, but it no longer does. +AU_DEFUN([AC_RSH], [], +[$0 is no longer supported. Remove this warning when you +adjust the code.]) + + +# AC_PROG_SED +# ----------- +# Check for a fully functional sed program that truncates +# as few characters as possible. Prefer GNU sed if found. +AC_DEFUN([AC_PROG_SED], +[AC_CACHE_CHECK([for a sed that does not truncate output], ac_cv_path_SED, + [dnl ac_script should not contain more than 99 commands (for HP-UX sed), + dnl but more than about 7000 bytes, to catch a limit in Solaris 8 /usr/ucb/sed. + ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ + for ac_i in 1 2 3 4 5 6 7; do + ac_script="$ac_script$as_nl$ac_script" + done + echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed + AS_UNSET([ac_script]) + _AC_PATH_PROGS_FEATURE_CHECK(SED, [sed gsed], + [_AC_FEATURE_CHECK_LENGTH([ac_path_SED], [ac_cv_path_SED], + ["$ac_path_SED" -f conftest.sed])])]) + SED="$ac_cv_path_SED" + AC_SUBST([SED])dnl + rm -f conftest.sed +])# AC_PROG_SED + + +# AC_PROG_YACC +# ------------ +AN_MAKEVAR([BISON], [AC_PROG_YACC]) +AN_MAKEVAR([YACC], [AC_PROG_YACC]) +AN_MAKEVAR([YFLAGS], [AC_PROG_YACC]) +AN_PROGRAM([yacc], [AC_PROG_YACC]) +AN_PROGRAM([byacc], [AC_PROG_YACC]) +AN_PROGRAM([bison], [AC_PROG_YACC]) +AC_DEFUN([AC_PROG_YACC], +[AC_CHECK_PROGS(YACC, 'bison -y' byacc, yacc)dnl +AC_ARG_VAR(YACC, +[The `Yet Another Compiler Compiler' implementation to use. Defaults to +the first program found out of: `bison -y', `byacc', `yacc'.])dnl +AC_ARG_VAR(YFLAGS, +[The list of arguments that will be passed by default to $YACC. This script +will default YFLAGS to the empty string to avoid a default value of `-d' given +by some make applications.])]) diff --git a/lib/autoconf/specific.m4 b/lib/autoconf/specific.m4 new file mode 100644 index 0000000..7d6be57 --- /dev/null +++ b/lib/autoconf/specific.m4 @@ -0,0 +1,481 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Macros that test for specific, unclassified, features. +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +## ------------------------- ## +## Checks for declarations. ## +## ------------------------- ## + + +# AC_DECL_SYS_SIGLIST +# ------------------- +AN_IDENTIFIER([sys_siglist], [AC_CHECK_DECLS([sys_siglist])]) +AU_DEFUN([AC_DECL_SYS_SIGLIST], +[AC_CHECK_DECLS([sys_siglist],,, +[#include <signal.h> +/* NetBSD declares sys_siglist in unistd.h. */ +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif +]) +])# AC_DECL_SYS_SIGLIST + + + + +## -------------------------------------- ## +## Checks for operating system services. ## +## -------------------------------------- ## + + +# AC_SYS_INTERPRETER +# ------------------ +AC_DEFUN([AC_SYS_INTERPRETER], +[AC_CACHE_CHECK(whether @%:@! works in shell scripts, ac_cv_sys_interpreter, +[echo '#! /bin/cat +exit 69 +' >conftest +chmod u+x conftest +(SHELL=/bin/sh; export SHELL; ./conftest >/dev/null 2>&1) +if test $? -ne 69; then + ac_cv_sys_interpreter=yes +else + ac_cv_sys_interpreter=no +fi +rm -f conftest]) +interpval=$ac_cv_sys_interpreter +]) + + +AU_DEFUN([AC_HAVE_POUNDBANG], +[AC_SYS_INTERPRETER], +[Remove this warning when you adjust your code to use +`AC_SYS_INTERPRETER'.]) + + +AU_DEFUN([AC_ARG_ARRAY], [], +[$0 is no longer implemented: don't do unportable things +with arguments. Remove this warning when you adjust your code.]) + + +# _AC_SYS_LARGEFILE_TEST_INCLUDES +# ------------------------------- +m4_define([_AC_SYS_LARGEFILE_TEST_INCLUDES], +[@%:@include <sys/types.h> + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +@%:@define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]];[]dnl +]) + + +# _AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, +# CACHE-VAR, +# DESCRIPTION, +# PROLOGUE, [FUNCTION-BODY]) +# -------------------------------------------------------- +m4_define([_AC_SYS_LARGEFILE_MACRO_VALUE], +[AC_CACHE_CHECK([for $1 value needed for large files], [$3], +[while :; do + m4_ifval([$6], [AC_LINK_IFELSE], [AC_COMPILE_IFELSE])( + [AC_LANG_PROGRAM([$5], [$6])], + [$3=no; break]) + m4_ifval([$6], [AC_LINK_IFELSE], [AC_COMPILE_IFELSE])( + [AC_LANG_PROGRAM([@%:@define $1 $2 +$5], [$6])], + [$3=$2; break]) + $3=unknown + break +done]) +case $$3 in #( + no | unknown) ;; + *) AC_DEFINE_UNQUOTED([$1], [$$3], [$4]);; +esac +rm -rf conftest*[]dnl +])# _AC_SYS_LARGEFILE_MACRO_VALUE + + +# AC_SYS_LARGEFILE +# ---------------- +# By default, many hosts won't let programs access large files; +# one must use special compiler options to get large-file access to work. +# For more details about this brain damage please see: +# http://www.unix-systems.org/version2/whatsnew/lfs20mar.html +AC_DEFUN([AC_SYS_LARGEFILE], +[AC_ARG_ENABLE(largefile, + [ --disable-largefile omit support for large files]) +if test "$enable_largefile" != no; then + + AC_CACHE_CHECK([for special C compiler options needed for large files], + ac_cv_sys_largefile_CC, + [ac_cv_sys_largefile_CC=no + if test "$GCC" != yes; then + ac_save_CC=$CC + while :; do + # IRIX 6.2 and later do not support large files by default, + # so use the C compiler's -n32 option if that helps. + AC_LANG_CONFTEST([AC_LANG_PROGRAM([_AC_SYS_LARGEFILE_TEST_INCLUDES])]) + AC_COMPILE_IFELSE([], [break]) + CC="$CC -n32" + AC_COMPILE_IFELSE([], [ac_cv_sys_largefile_CC=' -n32'; break]) + break + done + CC=$ac_save_CC + rm -f conftest.$ac_ext + fi]) + if test "$ac_cv_sys_largefile_CC" != no; then + CC=$CC$ac_cv_sys_largefile_CC + fi + + _AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64, + ac_cv_sys_file_offset_bits, + [Number of bits in a file offset, on hosts where this is settable.], + [_AC_SYS_LARGEFILE_TEST_INCLUDES]) + if test $ac_cv_sys_file_offset_bits = unknown; then + _AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1, + ac_cv_sys_large_files, + [Define for large files, on AIX-style hosts.], + [_AC_SYS_LARGEFILE_TEST_INCLUDES]) + fi + + AH_VERBATIM([_DARWIN_USE_64_BIT_INODE], +[/* Enable large inode numbers on Mac OS X 10.5. */ +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif]) +fi +])# AC_SYS_LARGEFILE + + +# AC_SYS_LONG_FILE_NAMES +# ---------------------- +# Security: use a temporary directory as the most portable way of +# creating files in /tmp securely. Removing them leaves a race +# condition, set -C is not portably guaranteed to use O_EXCL, so still +# leaves a race, and not all systems have the `mktemp' utility. We +# still test for existence first in case of broken systems where the +# mkdir succeeds even when the directory exists. Broken systems may +# retain a race, but they probably have other security problems +# anyway; this should be secure on well-behaved systems. In any case, +# use of `mktemp' is probably inappropriate here since it would fail in +# attempting to create different file names differing after the 14th +# character on file systems without long file names. +AC_DEFUN([AC_SYS_LONG_FILE_NAMES], +[AC_CACHE_CHECK(for long file names, ac_cv_sys_long_file_names, +[ac_cv_sys_long_file_names=yes +# Test for long file names in all the places we know might matter: +# . the current directory, where building will happen +# $prefix/lib where we will be installing things +# $exec_prefix/lib likewise +# $TMPDIR if set, where it might want to write temporary files +# /tmp where it might want to write temporary files +# /var/tmp likewise +# /usr/tmp likewise +for ac_dir in . "$TMPDIR" /tmp /var/tmp /usr/tmp "$prefix/lib" "$exec_prefix/lib"; do + # Skip $TMPDIR if it is empty or bogus, and skip $exec_prefix/lib + # in the usual case where exec_prefix is '${prefix}'. + case $ac_dir in #( + . | /* | ?:[[\\/]]*) ;; #( + *) continue;; + esac + test -w "$ac_dir/." || continue # It is less confusing to not echo anything here. + ac_xdir=$ac_dir/cf$$ + (umask 077 && mkdir "$ac_xdir" 2>/dev/null) || continue + ac_tf1=$ac_xdir/conftest9012345 + ac_tf2=$ac_xdir/conftest9012346 + touch "$ac_tf1" 2>/dev/null && test -f "$ac_tf1" && test ! -f "$ac_tf2" || + ac_cv_sys_long_file_names=no + rm -f -r "$ac_xdir" 2>/dev/null + test $ac_cv_sys_long_file_names = no && break +done]) +if test $ac_cv_sys_long_file_names = yes; then + AC_DEFINE(HAVE_LONG_FILE_NAMES, 1, + [Define to 1 if you support file names longer than 14 characters.]) +fi +]) + + +# AC_SYS_RESTARTABLE_SYSCALLS +# --------------------------- +# If the system automatically restarts a system call that is +# interrupted by a signal, define `HAVE_RESTARTABLE_SYSCALLS'. +AC_DEFUN([AC_SYS_RESTARTABLE_SYSCALLS], +[AC_DIAGNOSE([obsolete], +[$0: AC_SYS_RESTARTABLE_SYSCALLS is useful only when supporting very +old systems that lack `sigaction' and `SA_RESTART'. Don't bother with +this macro unless you need to support very old systems like 4.2BSD and +SVR3.])dnl +AC_REQUIRE([AC_HEADER_SYS_WAIT])dnl +AC_CACHE_CHECK(for restartable system calls, ac_cv_sys_restartable_syscalls, +[AC_RUN_IFELSE([AC_LANG_SOURCE( +[/* Exit 0 (true) if wait returns something other than -1, + i.e. the pid of the child, which means that wait was restarted + after getting the signal. */ + +AC_INCLUDES_DEFAULT +#include <signal.h> +#ifdef HAVE_SYS_WAIT_H +# include <sys/wait.h> +#endif + +/* Some platforms explicitly require an extern "C" signal handler + when using C++. */ +#ifdef __cplusplus +extern "C" void ucatch (int dummy) { } +#else +void ucatch (dummy) int dummy; { } +#endif + +int +main () +{ + int i = fork (), status; + + if (i == 0) + { + sleep (3); + kill (getppid (), SIGINT); + sleep (3); + return 0; + } + + signal (SIGINT, ucatch); + + status = wait (&i); + if (status == -1) + wait (&i); + + return status == -1; +}])], + [ac_cv_sys_restartable_syscalls=yes], + [ac_cv_sys_restartable_syscalls=no])]) +if test $ac_cv_sys_restartable_syscalls = yes; then + AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS, 1, + [Define to 1 if system calls automatically restart after + interruption by a signal.]) +fi +])# AC_SYS_RESTARTABLE_SYSCALLS + + +# AC_SYS_POSIX_TERMIOS +# -------------------- +AC_DEFUN([AC_SYS_POSIX_TERMIOS], +[AC_CACHE_CHECK([POSIX termios], ac_cv_sys_posix_termios, +[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h> +#include <unistd.h> +#include <termios.h> +]], + [/* SunOS 4.0.3 has termios.h but not the library calls. */ + tcgetattr(0, 0);])], + ac_cv_sys_posix_termios=yes, + ac_cv_sys_posix_termios=no)]) +])# AC_SYS_POSIX_TERMIOS + + + + +## ------------------------------------ ## +## Checks for not-quite-Unix variants. ## +## ------------------------------------ ## + + +# AC_GNU_SOURCE +# ------------- +AU_DEFUN([AC_GNU_SOURCE], [AC_USE_SYSTEM_EXTENSIONS]) + + +# AC_CYGWIN +# --------- +# Check for Cygwin. This is a way to set the right value for +# EXEEXT. +AU_DEFUN([AC_CYGWIN], +[AC_CANONICAL_HOST +case $host_os in + *cygwin* ) CYGWIN=yes;; + * ) CYGWIN=no;; +esac +], [$0 is obsolete: use AC_CANONICAL_HOST and check if $host_os +matches *cygwin*])# AC_CYGWIN + + +# AC_EMXOS2 +# --------- +# Check for EMX on OS/2. This is another way to set the right value +# for EXEEXT. +AU_DEFUN([AC_EMXOS2], +[AC_CANONICAL_HOST +case $host_os in + *emx* ) EMXOS2=yes;; + * ) EMXOS2=no;; +esac +], [$0 is obsolete: use AC_CANONICAL_HOST and check if $host_os +matches *emx*])# AC_EMXOS2 + + +# AC_MINGW32 +# ---------- +# Check for mingw32. This is another way to set the right value for +# EXEEXT. +AU_DEFUN([AC_MINGW32], +[AC_CANONICAL_HOST +case $host_os in + *mingw32* ) MINGW32=yes;; + * ) MINGW32=no;; +esac +], [$0 is obsolete: use AC_CANONICAL_HOST and check if $host_os +matches *mingw32*])# AC_MINGW32 + + +# AC_USE_SYSTEM_EXTENSIONS +# ------------------------ +# Enable extensions on systems that normally disable them, +# typically due to standards-conformance issues. +# +# Remember that #undef in AH_VERBATIM gets replaced with #define by +# AC_DEFINE. The goal here is to define all known feature-enabling +# macros, then, if reports of conflicts are made, disable macros that +# cause problems on some platforms (such as __EXTENSIONS__). +AC_DEFUN_ONCE([AC_USE_SYSTEM_EXTENSIONS], +[AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl +AC_BEFORE([$0], [AC_RUN_IFELSE])dnl + + AC_CHECK_HEADER([minix/config.h], [MINIX=yes], [MINIX=]) + if test "$MINIX" = yes; then + AC_DEFINE([_POSIX_SOURCE], [1], + [Define to 1 if you need to in order for `stat' and other + things to work.]) + AC_DEFINE([_POSIX_1_SOURCE], [2], + [Define to 2 if the system does not provide POSIX.1 features + except with this defined.]) + AC_DEFINE([_MINIX], [1], + [Define to 1 if on MINIX.]) + fi + +dnl Use a different key than __EXTENSIONS__, as that name broke existing +dnl configure.ac when using autoheader 2.62. + AH_VERBATIM([USE_SYSTEM_EXTENSIONS], +[/* Enable extensions on AIX 3, Interix. */ +#ifndef _ALL_SOURCE +# undef _ALL_SOURCE +#endif +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# undef _GNU_SOURCE +#endif +/* Enable threading extensions on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# undef _POSIX_PTHREAD_SEMANTICS +#endif +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# undef _TANDEM_SOURCE +#endif +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# undef __EXTENSIONS__ +#endif +]) + AC_CACHE_CHECK([whether it is safe to define __EXTENSIONS__], + [ac_cv_safe_to_define___extensions__], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([[ +# define __EXTENSIONS__ 1 + ]AC_INCLUDES_DEFAULT])], + [ac_cv_safe_to_define___extensions__=yes], + [ac_cv_safe_to_define___extensions__=no])]) + test $ac_cv_safe_to_define___extensions__ = yes && + AC_DEFINE([__EXTENSIONS__]) + AC_DEFINE([_ALL_SOURCE]) + AC_DEFINE([_GNU_SOURCE]) + AC_DEFINE([_POSIX_PTHREAD_SEMANTICS]) + AC_DEFINE([_TANDEM_SOURCE]) +])# AC_USE_SYSTEM_EXTENSIONS + + + +## -------------------------- ## +## Checks for UNIX variants. ## +## -------------------------- ## + + +# These are kludges which should be replaced by a single POSIX check. +# They aren't cached, to discourage their use. + +# AC_AIX +# ------ +AU_DEFUN([AC_AIX], [AC_USE_SYSTEM_EXTENSIONS]) + + +# AC_MINIX +# -------- +AU_DEFUN([AC_MINIX], [AC_USE_SYSTEM_EXTENSIONS]) + + +# AC_ISC_POSIX +# ------------ +AU_DEFUN([AC_ISC_POSIX], [AC_SEARCH_LIBS([strerror], [cposix])]) + + +# AC_XENIX_DIR +# ------------ +AU_DEFUN([AC_XENIX_DIR], +[AC_MSG_CHECKING([for Xenix]) +AC_EGREP_CPP([yes], +[#if defined M_XENIX && ! defined M_UNIX + yes +@%:@endif], + [AC_MSG_RESULT([yes]); XENIX=yes], + [AC_MSG_RESULT([no]); XENIX=]) + +AC_HEADER_DIRENT[]dnl +], +[You shouldn't need to depend upon XENIX. Remove the +`AC_MSG_CHECKING', `AC_EGREP_CPP', and this warning if this part +of the test is useless.]) + + +# AC_DYNIX_SEQ +# ------------ +AU_DEFUN([AC_DYNIX_SEQ], [AC_FUNC_GETMNTENT]) + + +# AC_IRIX_SUN +# ----------- +AU_DEFUN([AC_IRIX_SUN], +[AC_FUNC_GETMNTENT +AC_CHECK_LIB([sun], [getpwnam])]) + + +# AC_SCO_INTL +# ----------- +AU_DEFUN([AC_SCO_INTL], [AC_FUNC_STRFTIME]) diff --git a/lib/autoconf/status.m4 b/lib/autoconf/status.m4 new file mode 100644 index 0000000..157fe6a --- /dev/null +++ b/lib/autoconf/status.m4 @@ -0,0 +1,1782 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Parameterizing and creating config.status. +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# This file handles about all the preparation aspects for +# `config.status': registering the configuration files, the headers, +# the links, and the commands `config.status' will run. There is a +# little mixture though of things actually handled by `configure', +# such as running the `configure' in the sub directories. Minor +# detail. +# +# There are two kinds of commands: +# +# COMMANDS: +# +# They are output into `config.status' via a quoted here doc. These +# commands are always associated to a tag which the user can use to +# tell `config.status' what are the commands she wants to run. +# +# INIT-CMDS: +# +# They are output via an *unquoted* here-doc. As a consequence $var +# will be output as the value of VAR. This is typically used by +# `configure' to give `config.status' some variables it needs to run +# the COMMANDS. At the difference of COMMANDS, the INIT-CMDS are +# always run. +# +# +# Honorable members of this family are AC_CONFIG_FILES, +# AC_CONFIG_HEADERS, AC_CONFIG_LINKS and AC_CONFIG_COMMANDS. Bad boys +# are AC_LINK_FILES, AC_OUTPUT_COMMANDS and AC_OUTPUT when used with +# arguments. False members are AC_CONFIG_SRCDIR, AC_CONFIG_SUBDIRS +# and AC_CONFIG_AUX_DIR. Cousins are AC_CONFIG_COMMANDS_PRE and +# AC_CONFIG_COMMANDS_POST. + + +## ------------------ ## +## Auxiliary macros. ## +## ------------------ ## + +# _AC_SRCDIRS(BUILD-DIR-NAME) +# --------------------------- +# Inputs: +# - BUILD-DIR-NAME is `top-build -> build' and `top-src -> src' +# - `$srcdir' is `top-build -> top-src' +# +# Outputs: +# - `ac_builddir' is `.', for symmetry only. +# - `ac_top_builddir_sub' is `build -> top_build'. +# This is used for @top_builddir@. +# - `ac_top_build_prefix' is `build -> top_build'. +# If not empty, has a trailing slash. +# - `ac_srcdir' is `build -> src'. +# - `ac_top_srcdir' is `build -> top-src'. +# and `ac_abs_builddir' etc., the absolute directory names. +m4_define([_AC_SRCDIRS], +[ac_builddir=. + +case $1 in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`AS_ECHO([$1]) | sed 's|^\.[[\\/]]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`AS_ECHO(["$ac_dir_suffix"]) | sed 's|/[[^\\/]]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [[\\/]]* | ?:[[\\/]]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix +])# _AC_SRCDIRS + + +# _AC_HAVE_TOP_BUILD_PREFIX +# ------------------------- +# Announce to the world (to Libtool) that we substitute @top_build_prefix@. +AC_DEFUN([_AC_HAVE_TOP_BUILD_PREFIX]) + + +## ---------------------- ## +## Registering the tags. ## +## ---------------------- ## + + +# _AC_CONFIG_COMMANDS_INIT([INIT-COMMANDS]) +# ----------------------------------------- +# +# Register INIT-COMMANDS as command pasted *unquoted* in +# `config.status'. This is typically used to pass variables from +# `configure' to `config.status'. Note that $[1] is not over quoted as +# was the case in AC_OUTPUT_COMMANDS. +m4_define([_AC_CONFIG_COMMANDS_INIT], +[m4_ifval([$1], + [m4_append([_AC_OUTPUT_COMMANDS_INIT], + [$1 +])])]) + + +# AC_FILE_DEPENDENCY_TRACE(DEST, SOURCE1, [SOURCE2...]) +# ----------------------------------------------------- +# This macro does nothing, it's a hook to be read with `autoconf --trace'. +# +# It announces DEST depends upon the SOURCE1 etc. +m4_define([AC_FILE_DEPENDENCY_TRACE], []) + + +# _AC_FILE_DEPENDENCY_TRACE_COLON(DEST:SOURCE1[:SOURCE2...]) +# ---------------------------------------------------------- +# Declare that DEST depends upon SOURCE1 etc. +# +m4_define([_AC_FILE_DEPENDENCY_TRACE_COLON], +[AC_FILE_DEPENDENCY_TRACE(m4_translit([$1], [:], [,]))]) + + +# _AC_CONFIG_DEPENDENCY(MODE, DEST[:SOURCE1...]) +# ---------------------------------------------- +# MODE is `FILES', `HEADERS', or `LINKS'. +# +# Be sure that a missing dependency is expressed as a dependency upon +# `DEST.in' (except with config links). +# +m4_define([_AC_CONFIG_DEPENDENCY], +[_AC_FILE_DEPENDENCY_TRACE_COLON([$2]_AC_CONFIG_DEPENDENCY_DEFAULT($@))dnl +]) + + +# _AC_CONFIG_DEPENDENCY_DEFAULT(MODE, DEST[:SOURCE1...]) +# ------------------------------------------------------ +# Expand to `:DEST.in' if appropriate, or to empty string otherwise. +# +# More detailed description: +# If the tag contains `:', expand to nothing. +# Otherwise, for a config file or header, add `:DEST.in'. +# For a config link, DEST.in is not appropriate: +# - if the tag is literal, complain. +# - otherwise, just expand to nothing and proceed with fingers crossed. +# (We get to this case from the obsolete AC_LINK_FILES, for example.) +# +m4_define([_AC_CONFIG_DEPENDENCY_DEFAULT], +[m4_if(m4_index([$2], [:]), [-1], + [m4_if([$1], [LINKS], + [AS_LITERAL_IF([$2], + [m4_fatal([Invalid AC_CONFIG_LINKS tag: `$2'])])], + [:$2.in])])]) + + +# _AC_CONFIG_UNIQUE(MODE, DEST) +# ----------------------------- +# MODE is `FILES', `HEADERS', `LINKS', `COMMANDS', or `SUBDIRS'. +# +# Verify that there is no double definition of an output file. +# +m4_define([_AC_CONFIG_UNIQUE], +[m4_ifdef([_AC_SEEN_TAG($2)], + [m4_fatal([`$2' is already registered with AC_CONFIG_]m4_defn( + [_AC_SEEN_TAG($2)]).)], + [m4_define([_AC_SEEN_TAG($2)], [$1])])dnl +]) + + +# _AC_CONFIG_FOOS(MODE, TAGS..., [COMMANDS], [INIT-CMDS]) +# ------------------------------------------------------- +# MODE is `FILES', `HEADERS', `LINKS', or `COMMANDS'. +# +# Associate the COMMANDS to each TAG, i.e., when config.status creates TAG, +# run COMMANDS afterwards. (This is done in _AC_CONFIG_REGISTER_DEST.) +# +# For COMMANDS, do not m4_normalize TAGS before adding it to ac_config_commands. +# This historical difference allows macro calls in TAGS. +# +m4_define([_AC_CONFIG_FOOS], +[m4_map_args_w([$2], [_AC_CONFIG_REGISTER([$1],], [, [$3])])]dnl +[m4_define([_AC_SEEN_CONFIG(ANY)])]dnl +[m4_define([_AC_SEEN_CONFIG($1)])]dnl +[_AC_CONFIG_COMMANDS_INIT([$4])]dnl +[ac_config_[]m4_tolower([$1])="$ac_config_[]m4_tolower([$1]) ]dnl +[m4_if([$1], [COMMANDS], [$2], [m4_normalize([$2])])" +]) + +# _AC_CONFIG_COMPUTE_DEST(STRING) +# ------------------------------- +# Compute the DEST from STRING by stripping any : and following +# characters. Guarantee a match in m4_index, so as to avoid a bug +# with precision -1 in m4_format in older m4. +m4_define([_AC_CONFIG_COMPUTE_DEST], +[m4_format([[%.*s]], m4_index([$1:], [:]), [$1])]) + +# _AC_CONFIG_REGISTER(MODE, TAG, [COMMANDS]) +# ------------------------------------------ +# MODE is `FILES', `HEADERS', `LINKS', or `COMMANDS'. +# +m4_define([_AC_CONFIG_REGISTER], +[m4_if([$1], [COMMANDS], + [], + [_AC_CONFIG_DEPENDENCY([$1], [$2])])]dnl +[_AC_CONFIG_REGISTER_DEST([$1], [$2], + _AC_CONFIG_COMPUTE_DEST([$2]), [$3])]) + + +# _AC_CONFIG_REGISTER_DEST(MODE, TAG, DEST, [COMMANDS]) +# ----------------------------------------------------- +# MODE is `FILES', `HEADERS', `LINKS', or `COMMANDS'. +# TAG is in the form DEST[:SOURCE...]. +# Thus parameter $3 is the first part of $2. +# +# With CONFIG_LINKS, reject DEST=., because it is makes it hard for ./config.status +# to guess the links to establish (`./config.status .'). +# +# Save the name of the first config header to AH_HEADER. +# +m4_define([_AC_CONFIG_REGISTER_DEST], +[_AC_CONFIG_UNIQUE([$1], [$3])]dnl +[m4_if([$1 $3], [LINKS .], + [m4_fatal([invalid destination of a config link: `.'])], + [$1], [HEADERS], + [m4_define_default([AH_HEADER], [$3])])]dnl +dnl +dnl Recognize TAG as an argument to config.status: +dnl +[m4_append([_AC_LIST_TAGS], +[ "$3") CONFIG_$1="$CONFIG_$1 $2" ;; +])]dnl +dnl +dnl Register the associated commands, if any: +dnl +[m4_ifval([$4], +[m4_append([_AC_LIST_TAG_COMMANDS], +[ "$3":]m4_format([[%.1s]], [$1])[) $4 ;; +])])])# _AC_CONFIG_REGISTER_DEST + + + + +## --------------------- ## +## Configuration files. ## +## --------------------- ## + + +# AC_CONFIG_FILES(FILE..., [COMMANDS], [INIT-CMDS]) +# ------------------------------------------------- +# Specify output files, i.e., files that are configured with AC_SUBST. +# +AC_DEFUN([AC_CONFIG_FILES], [_AC_CONFIG_FOOS([FILES], $@)]) + + +# _AC_SED_CMD_LIMIT +# ----------------- +# Evaluate to an m4 number equal to the maximum number of commands to put +# in any single sed program, not counting ":" commands. +# +# Some seds have small command number limits, like on Digital OSF/1 and HP-UX. +m4_define([_AC_SED_CMD_LIMIT], +dnl One cannot portably go further than 99 commands because of HP-UX. +[99]) + + +# _AC_AWK_LITERAL_LIMIT +# --------------------- +# Evaluate to the maximum number of characters to put in an awk +# string literal, not counting escape characters. +# +# Some awk's have small limits, such as Solaris and AIX awk. +m4_define([_AC_AWK_LITERAL_LIMIT], +[148]) + + +# _AC_OUTPUT_FILES_PREPARE +# ------------------------ +# Create the awk scripts needed for CONFIG_FILES. +# Support multiline substitutions and make sure that the substitutions are +# not evaluated recursively. +# The intention is to have readable config.status and configure, even +# though this m4 code might be scary. +# +# This code was written by Dan Manthey and rewritten by Ralf Wildenhues. +# +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +# +m4_define([_AC_OUTPUT_FILES_PREPARE], +[# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + +dnl For AC_SUBST_FILE, check for usable getline support in awk, +dnl at config.status execution time. +dnl Otherwise, do the interpolation in sh, which is slower. +dnl Without any AC_SUBST_FILE, omit all related code. +dnl Note the expansion is double-quoted for readability. +m4_ifdef([_AC_SUBST_FILES], +[[if $AWK 'BEGIN { getline <"/dev/null" }' </dev/null 2>/dev/null; then + ac_cs_awk_getline=: + ac_cs_awk_pipe_init= + ac_cs_awk_read_file=' + while ((getline aline < (F[key])) > 0) + print(aline) + close(F[key])' + ac_cs_awk_pipe_fini= +else + ac_cs_awk_getline=false + ac_cs_awk_pipe_init="print \"cat <<'|#_!!_#|' &&\"" + ac_cs_awk_read_file=' + print "|#_!!_#|" + print "cat " F[key] " &&" + '$ac_cs_awk_pipe_init + # The final `:' finishes the AND list. + ac_cs_awk_pipe_fini='END { print "|#_!!_#|"; print ":" }' +fi]]) +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi +dnl +dnl Define the pipe that does the substitution. +m4_ifdef([_AC_SUBST_FILES], +[m4_define([_AC_SUBST_CMDS], [| +if $ac_cs_awk_getline; then + $AWK -f "$ac_tmp/subs.awk" +else + $AWK -f "$ac_tmp/subs.awk" | $SHELL +fi])], +[m4_define([_AC_SUBST_CMDS], +[| $AWK -f "$ac_tmp/subs.awk"])])dnl + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + +m4_ifdef([_AC_SUBST_FILES], +[# Create commands to substitute file output variables. +{ + echo "cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1" && + echo 'cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&' && + echo "$ac_subst_files" | sed 's/.*/F@<:@"&"@:>@="$&"/' && + echo "_ACAWK" && + echo "_ACEOF" +} >conf$$files.sh && +. ./conf$$files.sh || + AC_MSG_ERROR([could not make $CONFIG_STATUS]) +rm -f conf$$files.sh +])dnl + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + AC_MSG_ERROR([could not make $CONFIG_STATUS]) +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + AC_MSG_ERROR([could not make $CONFIG_STATUS]) + +dnl Do not use grep on conf$$subs.awk, since AIX grep has a line length limit. + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + AC_MSG_ERROR([could not make $CONFIG_STATUS]) + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +dnl Initialize an awk array of substitutions, keyed by variable name. +dnl +dnl The initial line contains the variable name VAR, then a `!'. +dnl Construct `S["VAR"]=' from it. +dnl The rest of the line, and potentially further lines, contain the +dnl substituted value; the last of those ends with $ac_delim. We split +dnl the output both along those substituted newlines and at intervals of +dnl length _AC_AWK_LITERAL_LIMIT. The latter is done to comply with awk +dnl string literal limitations, the former for simplicity in doing so. +dnl +dnl We deal with one input line at a time to avoid sed pattern space +dnl limitations. We kill the delimiter $ac_delim before splitting the +dnl string (otherwise we risk splitting the delimiter). And we do the +dnl splitting before the quoting of awk special characters (otherwise we +dnl risk splitting an escape sequence). +dnl +dnl Output as separate string literals, joined with backslash-newline. +dnl Eliminate the newline after `=' in a second script, for readability. +dnl +dnl Notes to the main part of the awk script: +dnl - the unusual FS value helps prevent running into the limit of 99 fields, +dnl - we avoid sub/gsub because of the \& quoting issues, see +dnl http://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html +dnl - Writing `$ 0' prevents expansion by both the shell and m4 here. +dnl +dnl m4-double-quote most of the scripting for readability. +[cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{]_AC_AWK_LITERAL_LIMIT[\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{]_AC_AWK_LITERAL_LIMIT[\}// +t nl +:delim +h +s/\(.\{]_AC_AWK_LITERAL_LIMIT[\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{]_AC_AWK_LITERAL_LIMIT[\}// +t delim +' <conf$$subs.awk | sed ' +/^[^""]/{ + N + s/\n// +} +' >>$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" +]m4_ifdef([_AC_SUBST_FILES], +[ \$ac_cs_awk_pipe_init])[ +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } +]m4_ifdef([_AC_SUBST_FILES], +[[ if (nfields == 3 && !substed) { + key = field[2] + if (F[key] != "" && line ~ /^[ ]*@.*@[ ]*$/) { + \$ac_cs_awk_read_file + next + } + }]])[ + print line +} +]dnl end of double-quoted part +m4_ifdef([_AC_SUBST_FILES], +[\$ac_cs_awk_pipe_fini]) +_ACAWK +_ACEOF +dnl See if CR is the EOL marker. If not, remove any EOL-related +dnl ^M bytes and escape any remaining ones. If so, just use mv. +dnl In case you're wondering how ^M bytes can make it into subs1.awk, +dnl [from Ralf Wildenhues] one way is if you have e.g., +dnl AC_SUBST([variable_that_contains_cr], [" +dnl "]) +dnl The original aim was that users should be able to substitute any +dnl characters they like (except for \0). And the above is not so +dnl unlikely if the configure script itself happens to be converted +dnl to w32 text mode. +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || AC_MSG_ERROR([could not setup config files machinery]) +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub=['/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}'] +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +])# _AC_OUTPUT_FILES_PREPARE + +# _AC_OUTPUT_FILE_ADJUST_DIR(VAR) +# ------------------------------- +# Generate the sed snippet needed to output VAR relative to the +# top-level directory. +m4_define([_AC_OUTPUT_FILE_ADJUST_DIR], +[s&@$1@&$ac_$1&;t t[]AC_SUBST_TRACE([$1])]) + + +# _AC_OUTPUT_FILE +# --------------- +# Do the variable substitutions to create the Makefiles or whatever. +# +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +# +m4_define([_AC_OUTPUT_FILE], +[ + # + # CONFIG_FILE + # + +AC_PROVIDE_IFELSE([AC_PROG_INSTALL], +[ case $INSTALL in + [[\\/$]]* | ?:[[\\/]]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac +])dnl +AC_PROVIDE_IFELSE([AC_PROG_MKDIR_P], +[ ac_MKDIR_P=$MKDIR_P + case $MKDIR_P in + [[\\/$]]* | ?:[[\\/]]* ) ;; + */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; + esac +])dnl +_ACEOF + +m4_ifndef([AC_DATAROOTDIR_CHECKED], +[cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +m4_define([_AC_datarootdir_vars], + [datadir, docdir, infodir, localedir, mandir])]dnl +[m4_define([_AC_datarootdir_subst], [ s&@$][1@&$$][1&g])]dnl +[ac_sed_dataroot=' +/datarootdir/ { + p + q +} +m4_map_args_sep([/@], [@/p], [ +], _AC_datarootdir_vars)' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@[]m4_join([@*|*@], _AC_datarootdir_vars)@*) + AC_MSG_WARN([$ac_file_inputs seems to ignore the --datarootdir setting]) +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' +m4_map_args_sep([_AC_datarootdir_subst(], [)], [ +], _AC_datarootdir_vars) + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF +])dnl + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +[/@[a-zA-Z_][a-zA-Z_0-9]*@/!b] +dnl configure_input is a somewhat special, so we don't call AC_SUBST_TRACE. +dnl Note if you change the s||| delimiter here, don't forget to adjust +dnl ac_sed_conf_input accordingly. Using & is a bad idea if & appears in +dnl the replacement string. +s|@configure_input@|$ac_sed_conf_input|;t t +dnl During the transition period, this is a special case: +s&@top_builddir@&$ac_top_builddir_sub&;t t[]AC_SUBST_TRACE([top_builddir]) +dnl For this substitution see the witness macro _AC_HAVE_TOP_BUILD_PREFIX above. +s&@top_build_prefix@&$ac_top_build_prefix&;t t[]AC_SUBST_TRACE([top_build_prefix]) +m4_map_args_sep([$0_ADJUST_DIR(], [)], [ +], [srcdir], [abs_srcdir], [top_srcdir], [abs_top_srcdir], + [builddir], [abs_builddir], + [abs_top_builddir]AC_PROVIDE_IFELSE([AC_PROG_INSTALL], + [, [INSTALL]])AC_PROVIDE_IFELSE([AC_PROG_MKDIR_P], [, [MKDIR_P]])) +m4_ifndef([AC_DATAROOTDIR_CHECKED], [$ac_datarootdir_hack +])dnl +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" m4_defn([_AC_SUBST_CMDS]) \ + >$ac_tmp/out || AC_MSG_ERROR([could not create $ac_file]) + +m4_ifndef([AC_DATAROOTDIR_CHECKED], +[test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[[ ]]*datarootdir[[ ]]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + AC_MSG_WARN([$ac_file contains a reference to the variable `datarootdir' +which seems to be undefined. Please make sure it is defined]) +])dnl + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || AC_MSG_ERROR([could not create $ac_file]) +dnl This would break Makefile dependencies: +dnl if diff "$ac_file" "$ac_tmp/out" >/dev/null 2>&1; then +dnl echo "$ac_file is unchanged" +dnl else +dnl rm -f "$ac_file"; mv "$ac_tmp/out" "$ac_file" +dnl fi +])# _AC_OUTPUT_FILE + + + + +## ----------------------- ## +## Configuration headers. ## +## ----------------------- ## + + +# AC_CONFIG_HEADERS(HEADERS..., [COMMANDS], [INIT-CMDS]) +# ------------------------------------------------------ +# Specify that the HEADERS are to be created by instantiation of the +# AC_DEFINEs. +# +AC_DEFUN([AC_CONFIG_HEADERS], [_AC_CONFIG_FOOS([HEADERS], $@)]) + + +# AC_CONFIG_HEADER(HEADER-TO-CREATE ...) +# -------------------------------------- +# FIXME: Make it obsolete? +AC_DEFUN([AC_CONFIG_HEADER], +[AC_CONFIG_HEADERS([$1])]) + + +# _AC_OUTPUT_HEADERS_PREPARE +# -------------------------- +# Create the awk scripts needed for CONFIG_HEADERS. +# Support multiline #defines. +# +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +# +m4_define([_AC_OUTPUT_HEADERS_PREPARE], +[# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +dnl This `||' list is finished at the end of _AC_OUTPUT_HEADERS_PREPARE. +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + AC_MSG_ERROR([could not make $CONFIG_HEADERS]) + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. +dnl +dnl Structure of the sed script that reads confdefs.h: +dnl rset: main loop, searches for `#define' lines +dnl def: deal with a `#define' line +dnl bsnl: deal with a `#define' line that ends with backslash-newline +dnl cont: handle a continuation line +dnl bsnlc: handle a continuation line that ends with backslash-newline +dnl +dnl Each sub part escapes the awk special characters and outputs a statement +dnl inserting the macro value into the array D, keyed by name. If the macro +dnl uses parameters, they are added in the array P, keyed by name. +dnl +dnl Long values are split into several string literals with help of ac_delim. +dnl Assume nobody uses macro names of nearly 150 bytes length. +dnl +dnl The initial replace for `#define' lines inserts a leading space +dnl in order to ease later matching; otherwise, output lines may be +dnl repeatedly matched. +dnl +dnl m4-double-quote most of this for [, ], define, and substr: +[ +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{]_AC_AWK_LITERAL_LIMIT[\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{]_AC_AWK_LITERAL_LIMIT[\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' <confdefs.h | sed ' +s/'"$ac_delim"'/"\\\ +"/g' >>$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +]dnl End of double-quoted section +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +dnl finish `||' list indicating write error: + AC_MSG_ERROR([could not setup config headers machinery]) +fi # test -n "$CONFIG_HEADERS" + +])# _AC_OUTPUT_HEADERS_PREPARE + + +# _AC_OUTPUT_HEADER +# ----------------- +# +# Output the code which instantiates the `config.h' files from their +# `config.h.in'. +# +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +# +m4_define([_AC_OUTPUT_HEADER], +[ + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + AS_ECHO(["/* $configure_input */"]) \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || AC_MSG_ERROR([could not create $ac_file]) + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + AC_MSG_NOTICE([$ac_file is unchanged]) + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || AC_MSG_ERROR([could not create $ac_file]) + fi + else + AS_ECHO(["/* $configure_input */"]) \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || AC_MSG_ERROR([could not create -]) + fi +dnl If running for Automake, be ready to perform additional +dnl commands to set up the timestamp files. +m4_ifdef([_AC_AM_CONFIG_HEADER_HOOK], + [_AC_AM_CONFIG_HEADER_HOOK(["$ac_file"]) +])dnl +])# _AC_OUTPUT_HEADER + + + +## --------------------- ## +## Configuration links. ## +## --------------------- ## + + +# AC_CONFIG_LINKS(DEST:SOURCE..., [COMMANDS], [INIT-CMDS]) +# -------------------------------------------------------- +# Specify that config.status should establish a (symbolic if possible) +# link from TOP_SRCDIR/SOURCE to TOP_SRCDIR/DEST. +# Reject DEST=., because it is makes it hard for ./config.status +# to guess the links to establish (`./config.status .'). +# +AC_DEFUN([AC_CONFIG_LINKS], [_AC_CONFIG_FOOS([LINKS], $@)]) + + +# AC_LINK_FILES(SOURCE..., DEST...) +# --------------------------------- +# Link each of the existing files SOURCE... to the corresponding +# link name in DEST... +# +# Unfortunately we can't provide a very good autoupdate service here, +# since in `AC_LINK_FILES($from, $to)' it is possible that `$from' +# and `$to' are actually lists. It would then be completely wrong to +# replace it with `AC_CONFIG_LINKS($to:$from). It is possible in the +# case of literal values though, but because I don't think there is any +# interest in creating config links with literal values, no special +# mechanism is implemented to handle them. +# +# _AC_LINK_FILES_CNT is used to be robust to multiple calls. +AU_DEFUN([AC_LINK_FILES], +[m4_if($#, 2, , + [m4_fatal([$0: incorrect number of arguments])])dnl +m4_define_default([_AC_LINK_FILES_CNT], 0)dnl +m4_define([_AC_LINK_FILES_CNT], m4_incr(_AC_LINK_FILES_CNT))dnl +ac_sources="$1" +ac_dests="$2" +while test -n "$ac_sources"; do + set $ac_dests; ac_dest=$[1]; shift; ac_dests=$[*] + set $ac_sources; ac_source=$[1]; shift; ac_sources=$[*] + [ac_config_links_]_AC_LINK_FILES_CNT="$[ac_config_links_]_AC_LINK_FILES_CNT $ac_dest:$ac_source" +done +AC_CONFIG_LINKS($[ac_config_links_]_AC_LINK_FILES_CNT)dnl +], +[It is technically impossible to `autoupdate' cleanly from AC_LINK_FILES +to AC_CONFIG_LINKS. `autoupdate' provides a functional but inelegant +update, you should probably tune the result yourself.])# AC_LINK_FILES + + +# _AC_OUTPUT_LINK +# --------------- +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +m4_define([_AC_OUTPUT_LINK], +[ + # + # CONFIG_LINK + # + + if test "$ac_source" = "$ac_file" && test "$srcdir" = '.'; then + : + else + # Prefer the file from the source tree if names are identical. + if test "$ac_source" = "$ac_file" || test ! -r "$ac_source"; then + ac_source=$srcdir/$ac_source + fi + + AC_MSG_NOTICE([linking $ac_source to $ac_file]) + + if test ! -r "$ac_source"; then + AC_MSG_ERROR([$ac_source: file not found]) + fi + rm -f "$ac_file" + + # Try a relative symlink, then a hard link, then a copy. + case $ac_source in + [[\\/$]]* | ?:[[\\/]]* ) ac_rel_source=$ac_source ;; + *) ac_rel_source=$ac_top_build_prefix$ac_source ;; + esac + ln -s "$ac_rel_source" "$ac_file" 2>/dev/null || + ln "$ac_source" "$ac_file" 2>/dev/null || + cp -p "$ac_source" "$ac_file" || + AC_MSG_ERROR([cannot link or copy $ac_source to $ac_file]) + fi +])# _AC_OUTPUT_LINK + + + +## ------------------------ ## +## Configuration commands. ## +## ------------------------ ## + + +# AC_CONFIG_COMMANDS(NAME...,[COMMANDS], [INIT-CMDS]) +# --------------------------------------------------- +# +# Specify additional commands to be run by config.status. This +# commands must be associated with a NAME, which should be thought +# as the name of a file the COMMANDS create. +# +AC_DEFUN([AC_CONFIG_COMMANDS], [_AC_CONFIG_FOOS([COMMANDS], $@)]) + + +# AC_OUTPUT_COMMANDS(EXTRA-CMDS, INIT-CMDS) +# ----------------------------------------- +# +# Add additional commands for AC_OUTPUT to put into config.status. +# +# This macro is an obsolete version of AC_CONFIG_COMMANDS. The only +# difficulty in mapping AC_OUTPUT_COMMANDS to AC_CONFIG_COMMANDS is +# to give a unique key. The scheme we have chosen is `default-1', +# `default-2' etc. for each call. +# +# Unfortunately this scheme is fragile: bad things might happen +# if you update an included file and configure.ac: you might have +# clashes :( On the other hand, I'd like to avoid weird keys (e.g., +# depending upon __file__ or the pid). +AU_DEFUN([AC_OUTPUT_COMMANDS], +[m4_define_default([_AC_OUTPUT_COMMANDS_CNT], 0)dnl +m4_define([_AC_OUTPUT_COMMANDS_CNT], m4_incr(_AC_OUTPUT_COMMANDS_CNT))dnl +dnl Double quoted since that was the case in the original macro. +AC_CONFIG_COMMANDS([default-]_AC_OUTPUT_COMMANDS_CNT, [[$1]], [[$2]])dnl +]) + + +# _AC_OUTPUT_COMMAND +# ------------------ +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +m4_define([_AC_OUTPUT_COMMAND], +[ AC_MSG_NOTICE([executing $ac_file commands]) +]) + + + +## -------------------------------------- ## +## Pre- and post-config.status commands. ## +## -------------------------------------- ## + + +# AC_CONFIG_COMMANDS_PRE(CMDS) +# ---------------------------- +# Commands to run right before config.status is created. Accumulates. +AC_DEFUN([AC_CONFIG_COMMANDS_PRE], +[m4_append([AC_OUTPUT_COMMANDS_PRE], [$1 +])]) + + +# AC_OUTPUT_COMMANDS_PRE +# ---------------------- +# A *variable* in which we append all the actions that must be +# performed before *creating* config.status. For a start, clean +# up all the LIBOBJ mess. +m4_define([AC_OUTPUT_COMMANDS_PRE], +[_AC_LIBOBJS_NORMALIZE +]) + + +# AC_CONFIG_COMMANDS_POST(CMDS) +# ----------------------------- +# Commands to run after config.status was created. Accumulates. +AC_DEFUN([AC_CONFIG_COMMANDS_POST], +[m4_append([AC_OUTPUT_COMMANDS_POST], [$1 +])]) + +# Initialize. +m4_define([AC_OUTPUT_COMMANDS_POST]) + + + +## ----------------------- ## +## Configuration subdirs. ## +## ----------------------- ## + + +# AC_CONFIG_SUBDIRS(DIR ...) +# -------------------------- +# We define two variables: +# - _AC_LIST_SUBDIRS +# A statically built list, should contain *all* the arguments of +# AC_CONFIG_SUBDIRS. The final value is assigned to ac_subdirs_all in +# the `default' section, and used for --help=recursive. +# It makes no sense for arguments which are sh variables. +# - subdirs +# Shell variable built at runtime, so some of these dirs might not be +# included, if for instance the user refused a part of the tree. +# This is used in _AC_OUTPUT_SUBDIRS. +AC_DEFUN([AC_CONFIG_SUBDIRS], +[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])]dnl +[AC_REQUIRE([AC_DISABLE_OPTION_CHECKING])]dnl +[m4_map_args_w([$1], [_AC_CONFIG_UNIQUE([SUBDIRS], + _AC_CONFIG_COMPUTE_DEST(], [))])]dnl +[m4_append([_AC_LIST_SUBDIRS], [$1], [ +])]dnl +[AS_LITERAL_IF([$1], [], + [AC_DIAGNOSE([syntax], [$0: you should use literals])])]dnl +[AC_SUBST([subdirs], ["$subdirs m4_normalize([$1])"])]) + + +# _AC_OUTPUT_SUBDIRS +# ------------------ +# This is a subroutine of AC_OUTPUT, but it does not go into +# config.status, rather, it is called after running config.status. +m4_define([_AC_OUTPUT_SUBDIRS], +[ +# +# CONFIG_SUBDIRS section. +# +if test "$no_recursion" != yes; then + + # Remove --cache-file, --srcdir, and --disable-option-checking arguments + # so they do not pile up. + ac_sub_configure_args= + ac_prev= + eval "set x $ac_configure_args" + shift + for ac_arg + do + if test -n "$ac_prev"; then + ac_prev= + continue + fi + case $ac_arg in + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \ + | --c=*) + ;; + --config-cache | -C) + ;; + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + ;; + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + ;; + --disable-option-checking) + ;; + *) + case $ac_arg in + *\'*) ac_arg=`AS_ECHO(["$ac_arg"]) | sed "s/'/'\\\\\\\\''/g"` ;; + esac + AS_VAR_APPEND([ac_sub_configure_args], [" '$ac_arg'"]) ;; + esac + done + + # Always prepend --prefix to ensure using the same prefix + # in subdir configurations. + ac_arg="--prefix=$prefix" + case $ac_arg in + *\'*) ac_arg=`AS_ECHO(["$ac_arg"]) | sed "s/'/'\\\\\\\\''/g"` ;; + esac + ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args" + + # Pass --silent + if test "$silent" = yes; then + ac_sub_configure_args="--silent $ac_sub_configure_args" + fi + + # Always prepend --disable-option-checking to silence warnings, since + # different subdirs can have different --enable and --with options. + ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args" + + ac_popdir=`pwd` + for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue + + # Do not complain, so a configure script can configure whichever + # parts of a large source tree are present. + test -d "$srcdir/$ac_dir" || continue + + ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)" + _AS_ECHO_LOG([$ac_msg]) + _AS_ECHO([$ac_msg]) + AS_MKDIR_P(["$ac_dir"]) + _AC_SRCDIRS(["$ac_dir"]) + + cd "$ac_dir" + + # Check for guested configure; otherwise get Cygnus style configure. + if test -f "$ac_srcdir/configure.gnu"; then + ac_sub_configure=$ac_srcdir/configure.gnu + elif test -f "$ac_srcdir/configure"; then + ac_sub_configure=$ac_srcdir/configure + elif test -f "$ac_srcdir/configure.in"; then + # This should be Cygnus configure. + ac_sub_configure=$ac_aux_dir/configure + else + AC_MSG_WARN([no configuration information is in $ac_dir]) + ac_sub_configure= + fi + + # The recursion is here. + if test -n "$ac_sub_configure"; then + # Make the cache file name correct relative to the subdirectory. + case $cache_file in + [[\\/]]* | ?:[[\\/]]* ) ac_sub_cache_file=$cache_file ;; + *) # Relative name. + ac_sub_cache_file=$ac_top_build_prefix$cache_file ;; + esac + + AC_MSG_NOTICE([running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir]) + # The eval makes quoting arguments work. + eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \ + --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" || + AC_MSG_ERROR([$ac_sub_configure failed for $ac_dir]) + fi + + cd "$ac_popdir" + done +fi +])# _AC_OUTPUT_SUBDIRS + + + + +## -------------------------- ## +## Outputting config.status. ## +## -------------------------- ## + + +# AU::AC_OUTPUT([CONFIG_FILES...], [EXTRA-CMDS], [INIT-CMDS]) +# ----------------------------------------------------------- +# +# If there are arguments given to AC_OUTPUT, dispatch them to the +# proper modern macros. +AU_DEFUN([AC_OUTPUT], +[m4_ifvaln([$1], + [AC_CONFIG_FILES([$1])])dnl +m4_ifvaln([$2$3], + [AC_CONFIG_COMMANDS(default, [$2], [$3])])dnl +[AC_OUTPUT]]) + + +# AC_OUTPUT([CONFIG_FILES...], [EXTRA-CMDS], [INIT-CMDS]) +# ------------------------------------------------------- +# The big finish. +# Produce config.status, config.h, and links; and configure subdirs. +# +m4_define([AC_OUTPUT], +[dnl Dispatch the extra arguments to their native macros. +m4_ifvaln([$1], + [AC_CONFIG_FILES([$1])])dnl +m4_ifvaln([$2$3], + [AC_CONFIG_COMMANDS(default, [$2], [$3])])dnl +m4_ifval([$1$2$3], + [AC_DIAGNOSE([obsolete], + [$0 should be used without arguments. +You should run autoupdate.])])dnl +AC_CACHE_SAVE + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], [DEFS=-DHAVE_CONFIG_H], [AC_OUTPUT_MAKE_DEFS()]) + +dnl Commands to run before creating config.status. +AC_OUTPUT_COMMANDS_PRE()dnl + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +_AC_OUTPUT_CONFIG_STATUS()dnl +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + AC_MSG_ERROR([write failure creating $CONFIG_STATUS]) + +dnl Commands to run after config.status was created +AC_OUTPUT_COMMANDS_POST()dnl + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec AS_MESSAGE_LOG_FD>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec AS_MESSAGE_LOG_FD>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || AS_EXIT([1]) +fi +dnl config.status should not do recursion. +AC_PROVIDE_IFELSE([AC_CONFIG_SUBDIRS], [_AC_OUTPUT_SUBDIRS()])dnl +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + AC_MSG_WARN([unrecognized options: $ac_unrecognized_opts]) +fi +])# AC_OUTPUT + + +# _AC_OUTPUT_CONFIG_STATUS +# ------------------------ +# Produce config.status. Called by AC_OUTPUT. +# Pay special attention not to have too long here docs: some old +# shells die. Unfortunately the limit is not known precisely... +m4_define([_AC_OUTPUT_CONFIG_STATUS], +[AC_MSG_NOTICE([creating $CONFIG_STATUS]) +dnl AS_MESSAGE_LOG_FD is not available yet: +m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[AS_INIT_GENERATED([$CONFIG_STATUS], +[# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false +]) || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +[#] Save the log message, to keep $[0] and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])dnl +$as_me[]m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]), which was +generated by m4_PACKAGE_STRING. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $[0] $[@] + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +dnl remove any newlines from these variables. +m4_ifdef([_AC_SEEN_CONFIG(FILES)], +[case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$[*];; +esac +]) +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], +[case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$[*];; +esac +]) + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +m4_ifdef([_AC_SEEN_CONFIG(FILES)], +[config_files="$ac_config_files" +])dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], +[config_headers="$ac_config_headers" +])dnl +m4_ifdef([_AC_SEEN_CONFIG(LINKS)], +[config_links="$ac_config_links" +])dnl +m4_ifdef([_AC_SEEN_CONFIG(COMMANDS)], +[config_commands="$ac_config_commands" +])dnl + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $[0] [[OPTION]]... [[TAG]]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent +[] do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions +m4_ifdef([_AC_SEEN_CONFIG(FILES)], + [AS_HELP_STRING([[ --file=FILE[:TEMPLATE]]], + [instantiate the configuration file FILE], [ ]) +])dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], + [AS_HELP_STRING([[ --header=FILE[:TEMPLATE]]], + [instantiate the configuration header FILE], [ ]) +])dnl + +m4_ifdef([_AC_SEEN_CONFIG(FILES)], +[Configuration files: +$config_files + +])dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], +[Configuration headers: +$config_headers + +])dnl +m4_ifdef([_AC_SEEN_CONFIG(LINKS)], +[Configuration links: +$config_links + +])dnl +m4_ifdef([_AC_SEEN_CONFIG(COMMANDS)], +[Configuration commands: +$config_commands + +])dnl +Report bugs to m4_ifset([AC_PACKAGE_BUGREPORT], [<AC_PACKAGE_BUGREPORT>], + [the package provider]).dnl +m4_ifdef([AC_PACKAGE_NAME], [m4_ifset([AC_PACKAGE_URL], [ +AC_PACKAGE_NAME home page: <AC_PACKAGE_URL>.])dnl +m4_if(m4_index(m4_defn([AC_PACKAGE_NAME]), [GNU ]), [0], [ +General help using GNU software: <http://www.gnu.org/gethelp/>.])])" + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`AS_ECHO(["$ac_configure_args"]) | sed 's/^ //; s/[[\\""\`\$]]/\\\\&/g'`" +ac_cs_version="\\ +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.status[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +configured by $[0], generated by m4_PACKAGE_STRING, + with options \\"\$ac_cs_config\\" + +Copyright (C) m4_PACKAGE_YEAR Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +AC_PROVIDE_IFELSE([AC_PROG_INSTALL], +[INSTALL='$INSTALL' +])dnl +AC_PROVIDE_IFELSE([AC_PROG_MKDIR_P], +[MKDIR_P='$MKDIR_P' +])dnl +AC_PROVIDE_IFELSE([AC_PROG_AWK], +[AWK='$AWK' +])dnl +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $[#] != 0 +do + case $[1] in + --*=?*) + ac_option=`expr "X$[1]" : 'X\([[^=]]*\)='` + ac_optarg=`expr "X$[1]" : 'X[[^=]]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$[1]" : 'X\([[^=]]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$[1] + ac_optarg=$[2] + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + AS_ECHO(["$ac_cs_version"]); exit ;; + --config | --confi | --conf | --con | --co | --c ) + AS_ECHO(["$ac_cs_config"]); exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; +m4_ifdef([_AC_SEEN_CONFIG(FILES)], [dnl + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`AS_ECHO(["$ac_optarg"]) | sed "s/'/'\\\\\\\\''/g"` ;; + '') AC_MSG_ERROR([missing file argument]) ;; + esac + AS_VAR_APPEND([CONFIG_FILES], [" '$ac_optarg'"]) + ac_need_defaults=false;; +])dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], [dnl + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`AS_ECHO(["$ac_optarg"]) | sed "s/'/'\\\\\\\\''/g"` ;; + esac + AS_VAR_APPEND([CONFIG_HEADERS], [" '$ac_optarg'"]) + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + AC_MSG_ERROR([ambiguous option: `$[1]' +Try `$[0] --help' for more information.]);; +], [ --he | --h |])dnl + --help | --hel | -h ) + AS_ECHO(["$ac_cs_usage"]); exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) AC_MSG_ERROR([unrecognized option: `$[1]' +Try `$[0] --help' for more information.]) ;; + + *) AS_VAR_APPEND([ac_config_targets], [" $[1]"]) + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec AS_MESSAGE_FD>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +dnl Check this before opening the log, to avoid a bug on MinGW, +dnl which prohibits the recursive instance from truncating an open log. +if \$ac_cs_recheck; then + set X $SHELL '$[0]' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \AS_ECHO(["running CONFIG_SHELL=$SHELL \$[*]"]) >&AS_MESSAGE_FD + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$[@]" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +dnl Open the log: +m4_popdef([AS_MESSAGE_LOG_FD])dnl +exec AS_MESSAGE_LOG_FD>>config.log +{ + echo + AS_BOX([Running $as_me.]) + AS_ECHO(["$ac_log"]) +} >&AS_MESSAGE_LOG_FD + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +m4_ifdef([_AC_OUTPUT_COMMANDS_INIT], +[# +# INIT-COMMANDS +# +_AC_OUTPUT_COMMANDS_INIT +])dnl +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in +m4_ifdef([_AC_LIST_TAGS], [_AC_LIST_TAGS]) + *) AC_MSG_ERROR([invalid argument: `$ac_config_target']);; + esac +done + +m4_ifdef([_AC_SEEN_CONFIG(ANY)], [_AC_OUTPUT_MAIN_LOOP])[]dnl + +AS_EXIT(0) +_ACEOF +])# _AC_OUTPUT_CONFIG_STATUS + +# _AC_OUTPUT_MAIN_LOOP +# -------------------- +# The main loop in $CONFIG_STATUS. +# +# This macro is expanded inside a here document. If the here document is +# closed, it has to be reopened with +# "cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1". +# +AC_DEFUN([_AC_OUTPUT_MAIN_LOOP], +[ +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then +m4_ifdef([_AC_SEEN_CONFIG(FILES)], +[ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files +])dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], +[ test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers +])dnl +m4_ifdef([_AC_SEEN_CONFIG(LINKS)], +[ test "${CONFIG_LINKS+set}" = set || CONFIG_LINKS=$config_links +])dnl +m4_ifdef([_AC_SEEN_CONFIG(COMMANDS)], +[ test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +])dnl +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +dnl For historical reasons, AS_TMPDIR must continue to place the results +dnl in $tmp; but we swap to the namespace-clean $ac_tmp to avoid issues +dnl with any CONFIG_COMMANDS playing with the common variable name $tmp. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'AS_EXIT([1])' 1 2 13 15 +} +dnl The comment above AS_TMPDIR says at most 4 chars are allowed. +AS_TMPDIR([conf], [.]) +ac_tmp=$tmp + +m4_ifdef([_AC_SEEN_CONFIG(FILES)], [_AC_OUTPUT_FILES_PREPARE])[]dnl +m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], [_AC_OUTPUT_HEADERS_PREPARE])[]dnl + +eval set X "dnl + m4_ifdef([_AC_SEEN_CONFIG(FILES)], [:F $CONFIG_FILES])[]dnl + m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], [:H $CONFIG_HEADERS])[]dnl + m4_ifdef([_AC_SEEN_CONFIG(LINKS)], [:L $CONFIG_LINKS])[]dnl + m4_ifdef([_AC_SEEN_CONFIG(COMMANDS)], [:C $CONFIG_COMMANDS])[]dnl +" +shift +for ac_tag +do + case $ac_tag in + :[[FHLC]]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[[FHL]]*:*);; + :L* | :C*:*) AC_MSG_ERROR([invalid tag `$ac_tag']);; + :[[FH]]-) ac_tag=-:-;; + :[[FH]]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$[1] + shift + + case $ac_mode in + :L) ac_source=$[1];; + :[[FH]]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [[\\/$]]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + AC_MSG_ERROR([cannot find input file: `$ac_f'], [1]);; + esac + case $ac_f in *\'*) ac_f=`AS_ECHO(["$ac_f"]) | sed "s/'/'\\\\\\\\''/g"`;; esac + AS_VAR_APPEND([ac_file_inputs], [" '$ac_f'"]) + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + AS_ECHO(["$[*]"]) | sed ['s|^[^:]*/||;s|:[^:]*/|, |g'] + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + AC_MSG_NOTICE([creating $ac_file]) + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`AS_ECHO(["$configure_input"]) | + sed 's/[[\\\\&|]]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || AC_MSG_ERROR([could not create $ac_file]) ;; + esac + ;; + esac + + ac_dir=`AS_DIRNAME(["$ac_file"])` + AS_MKDIR_P(["$ac_dir"]) + _AC_SRCDIRS(["$ac_dir"]) + + case $ac_mode in + m4_ifdef([_AC_SEEN_CONFIG(FILES)], [:F)_AC_OUTPUT_FILE ;;]) + m4_ifdef([_AC_SEEN_CONFIG(HEADERS)], [:H)_AC_OUTPUT_HEADER ;;]) + m4_ifdef([_AC_SEEN_CONFIG(LINKS)], [:L)_AC_OUTPUT_LINK ;;]) + m4_ifdef([_AC_SEEN_CONFIG(COMMANDS)], [:C)_AC_OUTPUT_COMMAND ;;]) + esac + +dnl Some shells don't like empty case/esac +m4_ifdef([_AC_LIST_TAG_COMMANDS], [ + case $ac_file$ac_mode in +_AC_LIST_TAG_COMMANDS + esac +])dnl +done # for ac_tag + +])# _AC_OUTPUT_MAIN_LOOP + + +# AC_OUTPUT_MAKE_DEFS +# ------------------- +# Set the DEFS variable to the -D options determined earlier. +# This is a subroutine of AC_OUTPUT. +# It is called inside configure, outside of config.status. +m4_define([AC_OUTPUT_MAKE_DEFS], +[[# Transform confdefs.h into DEFS. +# Protect against shell expansion while executing Makefile rules. +# Protect against Makefile macro expansion. +# +# If the first sed substitution is executed (which looks for macros that +# take arguments), then branch to the quote section. Otherwise, +# look for a macro that doesn't take arguments. +ac_script=' +:mline +/\\$/{ + N + s,\\\n,, + b mline +} +t clear +:clear +s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g +t quote +s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g +t quote +b any +:quote +s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g +s/\[/\\&/g +s/\]/\\&/g +s/\$/$$/g +H +:any +${ + g + s/^\n// + s/\n/ /g + p +} +' +DEFS=`sed -n "$ac_script" confdefs.h` +]])# AC_OUTPUT_MAKE_DEFS diff --git a/lib/autoconf/types.m4 b/lib/autoconf/types.m4 new file mode 100644 index 0000000..18fc175 --- /dev/null +++ b/lib/autoconf/types.m4 @@ -0,0 +1,1077 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# Type related macros: existence, sizeof, and structure members. +# +# Copyright (C) 2000-2002, 2004-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +## ---------------- ## +## Type existence. ## +## ---------------- ## + +# ---------------- # +# General checks. # +# ---------------- # + +# Up to 2.13 included, Autoconf used to provide the macro +# +# AC_CHECK_TYPE(TYPE, DEFAULT) +# +# Since, it provides another version which fits better with the other +# AC_CHECK_ families: +# +# AC_CHECK_TYPE(TYPE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# +# In order to provide backward compatibility, the new scheme is +# implemented as _AC_CHECK_TYPE_NEW, the old scheme as _AC_CHECK_TYPE_OLD, +# and AC_CHECK_TYPE branches to one or the other, depending upon its +# arguments. + + +# _AC_CHECK_TYPE_NEW_BODY +# ----------------------- +# Shell function body for _AC_CHECK_TYPE_NEW. This macro implements the +# former task of AC_CHECK_TYPE, with one big difference though: AC_CHECK_TYPE +# used to grep in the headers, which, BTW, led to many problems until the +# extended regular expression was correct and did not give false positives. +# It turned out there are even portability issues with egrep... +# +# The most obvious way to check for a TYPE is just to compile a variable +# definition: +# +# TYPE my_var; +# +# (TYPE being the second parameter to the shell function, hence $[]2 in m4). +# Unfortunately this does not work for const qualified types in C++, where +# you need an initializer. So you think of +# +# TYPE my_var = (TYPE) 0; +# +# Unfortunately, again, this is not valid for some C++ classes. +# +# Then you look for another scheme. For instance you think of declaring +# a function which uses a parameter of type TYPE: +# +# int foo (TYPE param); +# +# but of course you soon realize this does not make it with K&R +# compilers. And by no means do you want to use this: +# +# int foo (param) +# TYPE param +# { ; } +# +# since C++ would complain loudly. +# +# Don't even think of using a function return type, since K&R cries +# there too. So you start thinking of declaring a *pointer* to this TYPE: +# +# TYPE *p; +# +# but you know fairly well that this is legal in C for aggregates which +# are unknown (TYPE = struct does-not-exist). +# +# Then you think of using sizeof to make sure the TYPE is really +# defined: +# +# sizeof (TYPE); +# +# That is great, but has one drawback: it succeeds when TYPE happens +# to be a variable: you'd get the size of the variable's type. +# Obviously, we must not accept a variable in place of a type name. +# +# So, to filter out the last possibility, we will require that this fail: +# +# sizeof ((TYPE)); +# +# This evokes a syntax error when TYPE is a type, but succeeds if TYPE +# is actually a variable. +# +# Also note that we use +# +# if (sizeof (TYPE)) +# +# to `read' sizeof (to avoid warnings), while not depending on its type +# (not necessarily size_t etc.). +# +# C++ disallows defining types inside `sizeof ()', but that's OK, +# since we don't want to consider unnamed structs to be types for C++, +# precisely because they don't work in cases like that. +m4_define([_AC_CHECK_TYPE_NEW_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for $[]2], [$[]3], + [AS_VAR_SET([$[]3], [no]) + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([$[]4], + [if (sizeof ($[]2)) + return 0;])], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([$[]4], + [if (sizeof (($[]2))) + return 0;])], + [], + [AS_VAR_SET([$[]3], [yes])])])]) + AS_LINENO_POP +])dnl + +# _AC_CHECK_TYPE_NEW(TYPE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# ------------------------------------------------------------ +# Check whether the type TYPE is supported by the system, maybe via the +# the provided includes. +AC_DEFUN([_AC_CHECK_TYPE_NEW], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_type], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_type], + [LINENO TYPE VAR INCLUDES], + [Tests whether TYPE exists after having included INCLUDES, setting + cache variable VAR accordingly.])], + [$0_BODY])]dnl +[AS_VAR_PUSHDEF([ac_Type], [ac_cv_type_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_type "$LINENO" "$1" "ac_Type" ]dnl +["AS_ESCAPE([AC_INCLUDES_DEFAULT([$4])], [""])" +AS_VAR_IF([ac_Type], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Type])dnl +])# _AC_CHECK_TYPE_NEW + + +# _AC_CHECK_TYPES(TYPE) +# --------------------- +# Helper to AC_CHECK_TYPES, which generates two of the four arguments +# to _AC_CHECK_TYPE_NEW that are based on TYPE. +m4_define([_AC_CHECK_TYPES], +[[$1], [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$1]), [1], + [Define to 1 if the system has the type `$1'.])]]) + + +# AC_CHECK_TYPES(TYPES, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# -------------------------------------------------------- +# TYPES is an m4 list. There are no ambiguities here, we mean the newer +# AC_CHECK_TYPE. +AC_DEFUN([AC_CHECK_TYPES], +[m4_map_args_sep([_AC_CHECK_TYPE_NEW(_$0(], [)[ +$2], [$3], [$4])], [], $1)]) + + +# _AC_CHECK_TYPE_OLD(TYPE, DEFAULT) +# --------------------------------- +# FIXME: This is an extremely badly chosen name, since this +# macro actually performs an AC_REPLACE_TYPE. Some day we +# have to clean this up. +m4_define([_AC_CHECK_TYPE_OLD], +[_AC_CHECK_TYPE_NEW([$1],, + [AC_DEFINE_UNQUOTED([$1], [$2], + [Define to `$2' if <sys/types.h> does not define.])])dnl +])# _AC_CHECK_TYPE_OLD + + +# _AC_CHECK_TYPE_REPLACEMENT_TYPE_P(STRING) +# ----------------------------------------- +# Return `1' if STRING seems to be a builtin C/C++ type, i.e., if it +# starts with `_Bool', `bool', `char', `double', `float', `int', +# `long', `short', `signed', or `unsigned' followed by characters +# that are defining types. +# Because many people have used `off_t' and `size_t' too, they are added +# for better common-use backward compatibility. +m4_define([_AC_CHECK_TYPE_REPLACEMENT_TYPE_P], +[m4_bmatch([$1], + [^\(_Bool\|bool\|char\|double\|float\|int\|long\|short\|\(un\)?signed\|[_a-zA-Z][_a-zA-Z0-9]*_t\)[][_a-zA-Z0-9() *]*$], + 1, 0)dnl +])# _AC_CHECK_TYPE_REPLACEMENT_TYPE_P + + +# _AC_CHECK_TYPE_MAYBE_TYPE_P(STRING) +# ----------------------------------- +# Return `1' if STRING looks like a C/C++ type. +m4_define([_AC_CHECK_TYPE_MAYBE_TYPE_P], +[m4_bmatch([$1], [^[_a-zA-Z0-9 ]+\([_a-zA-Z0-9() *]\|\[\|\]\)*$], + 1, 0)dnl +])# _AC_CHECK_TYPE_MAYBE_TYPE_P + + +# AC_CHECK_TYPE(TYPE, DEFAULT) +# or +# AC_CHECK_TYPE(TYPE, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# ------------------------------------------------------- +# +# Dispatch respectively to _AC_CHECK_TYPE_OLD or _AC_CHECK_TYPE_NEW. +# 1. More than two arguments => NEW +# 2. $2 seems to be replacement type => OLD +# See _AC_CHECK_TYPE_REPLACEMENT_TYPE_P for `replacement type'. +# 3. $2 seems to be a type => NEW plus a warning +# 4. default => NEW +AC_DEFUN([AC_CHECK_TYPE], +[m4_cond([$#], [3], + [_AC_CHECK_TYPE_NEW], + [$#], [4], + [_AC_CHECK_TYPE_NEW], + [_AC_CHECK_TYPE_REPLACEMENT_TYPE_P([$2])], [1], + [_AC_CHECK_TYPE_OLD], + [_AC_CHECK_TYPE_MAYBE_TYPE_P([$2])], [1], + [AC_DIAGNOSE([syntax], + [$0: assuming `$2' is not a type])_AC_CHECK_TYPE_NEW], + [_AC_CHECK_TYPE_NEW])($@)])# AC_CHECK_TYPE + + + +# ---------------------------- # +# Types that must be checked. # +# ---------------------------- # + +AN_IDENTIFIER([ptrdiff_t], [AC_CHECK_TYPES]) + + +# ----------------- # +# Specific checks. # +# ----------------- # + +# AC_TYPE_GETGROUPS +# ----------------- +AC_DEFUN([AC_TYPE_GETGROUPS], +[AC_REQUIRE([AC_TYPE_UID_T])dnl +AC_CACHE_CHECK(type of array argument to getgroups, ac_cv_type_getgroups, +[AC_RUN_IFELSE([AC_LANG_SOURCE( +[[/* Thanks to Mike Rendell for this test. */ +]AC_INCLUDES_DEFAULT[ +#define NGID 256 +#undef MAX +#define MAX(x, y) ((x) > (y) ? (x) : (y)) + +int +main () +{ + gid_t gidset[NGID]; + int i, n; + union { gid_t gval; long int lval; } val; + + val.lval = -1; + for (i = 0; i < NGID; i++) + gidset[i] = val.gval; + n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1, + gidset); + /* Exit non-zero if getgroups seems to require an array of ints. This + happens when gid_t is short int but getgroups modifies an array + of ints. */ + return n > 0 && gidset[n] != val.gval; +}]])], + [ac_cv_type_getgroups=gid_t], + [ac_cv_type_getgroups=int], + [ac_cv_type_getgroups=cross]) +if test $ac_cv_type_getgroups = cross; then + dnl When we can't run the test program (we are cross compiling), presume + dnl that <unistd.h> has either an accurate prototype for getgroups or none. + dnl Old systems without prototypes probably use int. + AC_EGREP_HEADER([getgroups.*int.*gid_t], unistd.h, + ac_cv_type_getgroups=gid_t, ac_cv_type_getgroups=int) +fi]) +AC_DEFINE_UNQUOTED(GETGROUPS_T, $ac_cv_type_getgroups, + [Define to the type of elements in the array set by + `getgroups'. Usually this is either `int' or `gid_t'.]) +])# AC_TYPE_GETGROUPS + + +# AU::AM_TYPE_PTRDIFF_T +# --------------------- +AU_DEFUN([AM_TYPE_PTRDIFF_T], +[AC_CHECK_TYPES(ptrdiff_t)]) + + +# AC_TYPE_INTMAX_T +# ---------------- +AC_DEFUN([AC_TYPE_INTMAX_T], +[ + AC_REQUIRE([AC_TYPE_LONG_LONG_INT]) + AC_CHECK_TYPE([intmax_t], + [AC_DEFINE([HAVE_INTMAX_T], 1, + [Define to 1 if the system has the type `intmax_t'.])], + [test $ac_cv_type_long_long_int = yes \ + && ac_type='long long int' \ + || ac_type='long int' + AC_DEFINE_UNQUOTED([intmax_t], [$ac_type], + [Define to the widest signed integer type + if <stdint.h> and <inttypes.h> do not define.])]) +]) + + +# AC_TYPE_UINTMAX_T +# ----------------- +AC_DEFUN([AC_TYPE_UINTMAX_T], +[ + AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT]) + AC_CHECK_TYPE([uintmax_t], + [AC_DEFINE([HAVE_UINTMAX_T], 1, + [Define to 1 if the system has the type `uintmax_t'.])], + [test $ac_cv_type_unsigned_long_long_int = yes \ + && ac_type='unsigned long long int' \ + || ac_type='unsigned long int' + AC_DEFINE_UNQUOTED([uintmax_t], [$ac_type], + [Define to the widest unsigned integer type + if <stdint.h> and <inttypes.h> do not define.])]) +]) + + +# AC_TYPE_INTPTR_T +# ---------------- +AC_DEFUN([AC_TYPE_INTPTR_T], +[ + AC_CHECK_TYPE([intptr_t], + [AC_DEFINE([HAVE_INTPTR_T], 1, + [Define to 1 if the system has the type `intptr_t'.])], + [for ac_type in 'int' 'long int' 'long long int'; do + AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [AC_INCLUDES_DEFAULT], + [[sizeof (void *) <= sizeof ($ac_type)]])], + [AC_DEFINE_UNQUOTED([intptr_t], [$ac_type], + [Define to the type of a signed integer type wide enough to + hold a pointer, if such a type exists, and if the system + does not define it.]) + ac_type=]) + test -z "$ac_type" && break + done]) +]) + + +# AC_TYPE_UINTPTR_T +# ----------------- +AC_DEFUN([AC_TYPE_UINTPTR_T], +[ + AC_CHECK_TYPE([uintptr_t], + [AC_DEFINE([HAVE_UINTPTR_T], 1, + [Define to 1 if the system has the type `uintptr_t'.])], + [for ac_type in 'unsigned int' 'unsigned long int' \ + 'unsigned long long int'; do + AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [AC_INCLUDES_DEFAULT], + [[sizeof (void *) <= sizeof ($ac_type)]])], + [AC_DEFINE_UNQUOTED([uintptr_t], [$ac_type], + [Define to the type of an unsigned integer type wide enough to + hold a pointer, if such a type exists, and if the system + does not define it.]) + ac_type=]) + test -z "$ac_type" && break + done]) +]) + + +# AC_TYPE_LONG_DOUBLE +# ------------------- +AC_DEFUN([AC_TYPE_LONG_DOUBLE], +[ + AC_CACHE_CHECK([for long double], [ac_cv_type_long_double], + [if test "$GCC" = yes; then + ac_cv_type_long_double=yes + else + AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [[/* The Stardent Vistra knows sizeof (long double), but does + not support it. */ + long double foo = 0.0L;]], + [[/* On Ultrix 4.3 cc, long double is 4 and double is 8. */ + sizeof (double) <= sizeof (long double)]])], + [ac_cv_type_long_double=yes], + [ac_cv_type_long_double=no]) + fi]) + if test $ac_cv_type_long_double = yes; then + AC_DEFINE([HAVE_LONG_DOUBLE], 1, + [Define to 1 if the system has the type `long double'.]) + fi +]) + + +# AC_TYPE_LONG_DOUBLE_WIDER +# ------------------------- +AC_DEFUN([AC_TYPE_LONG_DOUBLE_WIDER], +[ + AC_CACHE_CHECK( + [for long double with more range or precision than double], + [ac_cv_type_long_double_wider], + [AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [[#include <float.h> + long double const a[] = + { + 0.0L, DBL_MIN, DBL_MAX, DBL_EPSILON, + LDBL_MIN, LDBL_MAX, LDBL_EPSILON + }; + long double + f (long double x) + { + return ((x + (unsigned long int) 10) * (-1 / x) + a[0] + + (x ? f (x) : 'c')); + } + ]], + [[(0 < ((DBL_MAX_EXP < LDBL_MAX_EXP) + + (DBL_MANT_DIG < LDBL_MANT_DIG) + - (LDBL_MAX_EXP < DBL_MAX_EXP) + - (LDBL_MANT_DIG < DBL_MANT_DIG))) + && (int) LDBL_EPSILON == 0 + ]])], + ac_cv_type_long_double_wider=yes, + ac_cv_type_long_double_wider=no)]) + if test $ac_cv_type_long_double_wider = yes; then + AC_DEFINE([HAVE_LONG_DOUBLE_WIDER], 1, + [Define to 1 if the type `long double' works and has more range or + precision than `double'.]) + fi +])# AC_TYPE_LONG_DOUBLE_WIDER + + +# AC_C_LONG_DOUBLE +# ---------------- +AU_DEFUN([AC_C_LONG_DOUBLE], + [ + AC_TYPE_LONG_DOUBLE_WIDER + ac_cv_c_long_double=$ac_cv_type_long_double_wider + if test $ac_cv_c_long_double = yes; then + AC_DEFINE([HAVE_LONG_DOUBLE], 1, + [Define to 1 if the type `long double' works and has more range or + precision than `double'.]) + fi + ], + [The macro `AC_C_LONG_DOUBLE' is obsolete. +You should use `AC_TYPE_LONG_DOUBLE' or `AC_TYPE_LONG_DOUBLE_WIDER' instead.] +) + + +# _AC_TYPE_LONG_LONG_SNIPPET +# -------------------------- +# Expands to a C program that can be used to test for simultaneous support +# of 'long long' and 'unsigned long long'. We don't want to say that +# 'long long' is available if 'unsigned long long' is not, or vice versa, +# because too many programs rely on the symmetry between signed and unsigned +# integer types (excluding 'bool'). +AC_DEFUN([_AC_TYPE_LONG_LONG_SNIPPET], +[ + AC_LANG_PROGRAM( + [[/* For now, do not test the preprocessor; as of 2007 there are too many + implementations with broken preprocessors. Perhaps this can + be revisited in 2012. In the meantime, code should not expect + #if to work with literals wider than 32 bits. */ + /* Test literals. */ + long long int ll = 9223372036854775807ll; + long long int nll = -9223372036854775807LL; + unsigned long long int ull = 18446744073709551615ULL; + /* Test constant expressions. */ + typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) + ? 1 : -1)]; + typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 + ? 1 : -1)]; + int i = 63;]], + [[/* Test availability of runtime routines for shift and division. */ + long long int llmax = 9223372036854775807ll; + unsigned long long int ullmax = 18446744073709551615ull; + return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) + | (llmax / ll) | (llmax % ll) + | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) + | (ullmax / ull) | (ullmax % ull));]]) +]) + + +# AC_TYPE_LONG_LONG_INT +# --------------------- +AC_DEFUN([AC_TYPE_LONG_LONG_INT], +[ + AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT]) + AC_CACHE_CHECK([for long long int], [ac_cv_type_long_long_int], + [ac_cv_type_long_long_int=yes + if test "x${ac_cv_prog_cc_c99-no}" = xno; then + ac_cv_type_long_long_int=$ac_cv_type_unsigned_long_long_int + if test $ac_cv_type_long_long_int = yes; then + dnl Catch a bug in Tandem NonStop Kernel (OSS) cc -O circa 2004. + dnl If cross compiling, assume the bug is not important, since + dnl nobody cross compiles for this platform as far as we know. + AC_RUN_IFELSE( + [AC_LANG_PROGRAM( + [[@%:@include <limits.h> + @%:@ifndef LLONG_MAX + @%:@ define HALF \ + (1LL << (sizeof (long long int) * CHAR_BIT - 2)) + @%:@ define LLONG_MAX (HALF - 1 + HALF) + @%:@endif]], + [[long long int n = 1; + int i; + for (i = 0; ; i++) + { + long long int m = n << i; + if (m >> i != n) + return 1; + if (LLONG_MAX / 2 < m) + break; + } + return 0;]])], + [], + [ac_cv_type_long_long_int=no], + [:]) + fi + fi]) + if test $ac_cv_type_long_long_int = yes; then + AC_DEFINE([HAVE_LONG_LONG_INT], [1], + [Define to 1 if the system has the type `long long int'.]) + fi +]) + + +# AC_TYPE_UNSIGNED_LONG_LONG_INT +# ------------------------------ +AC_DEFUN([AC_TYPE_UNSIGNED_LONG_LONG_INT], +[ + AC_CACHE_CHECK([for unsigned long long int], + [ac_cv_type_unsigned_long_long_int], + [ac_cv_type_unsigned_long_long_int=yes + if test "x${ac_cv_prog_cc_c99-no}" = xno; then + AC_LINK_IFELSE( + [_AC_TYPE_LONG_LONG_SNIPPET], + [], + [ac_cv_type_unsigned_long_long_int=no]) + fi]) + if test $ac_cv_type_unsigned_long_long_int = yes; then + AC_DEFINE([HAVE_UNSIGNED_LONG_LONG_INT], [1], + [Define to 1 if the system has the type `unsigned long long int'.]) + fi +]) + + +# AC_TYPE_MBSTATE_T +# ----------------- +AC_DEFUN([AC_TYPE_MBSTATE_T], + [AC_CACHE_CHECK([for mbstate_t], ac_cv_type_mbstate_t, + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [AC_INCLUDES_DEFAULT +# include <wchar.h>], + [mbstate_t x; return sizeof x;])], + [ac_cv_type_mbstate_t=yes], + [ac_cv_type_mbstate_t=no])]) + if test $ac_cv_type_mbstate_t = yes; then + AC_DEFINE([HAVE_MBSTATE_T], 1, + [Define to 1 if <wchar.h> declares mbstate_t.]) + else + AC_DEFINE([mbstate_t], int, + [Define to a type if <wchar.h> does not define.]) + fi]) + + +# AC_TYPE_UID_T +# ------------- +# FIXME: Rewrite using AC_CHECK_TYPE. +AN_IDENTIFIER([gid_t], [AC_TYPE_UID_T]) +AN_IDENTIFIER([uid_t], [AC_TYPE_UID_T]) +AC_DEFUN([AC_TYPE_UID_T], +[AC_CACHE_CHECK(for uid_t in sys/types.h, ac_cv_type_uid_t, +[AC_EGREP_HEADER(uid_t, sys/types.h, + ac_cv_type_uid_t=yes, ac_cv_type_uid_t=no)]) +if test $ac_cv_type_uid_t = no; then + AC_DEFINE(uid_t, int, [Define to `int' if <sys/types.h> doesn't define.]) + AC_DEFINE(gid_t, int, [Define to `int' if <sys/types.h> doesn't define.]) +fi +]) + + +AN_IDENTIFIER([size_t], [AC_TYPE_SIZE_T]) +AC_DEFUN([AC_TYPE_SIZE_T], [AC_CHECK_TYPE(size_t, unsigned int)]) + +AN_IDENTIFIER([ssize_t], [AC_TYPE_SSIZE_T]) +AC_DEFUN([AC_TYPE_SSIZE_T], [AC_CHECK_TYPE(ssize_t, int)]) + +AN_IDENTIFIER([pid_t], [AC_TYPE_PID_T]) +AC_DEFUN([AC_TYPE_PID_T], [AC_CHECK_TYPE(pid_t, int)]) + +AN_IDENTIFIER([off_t], [AC_TYPE_OFF_T]) +AC_DEFUN([AC_TYPE_OFF_T], [AC_CHECK_TYPE(off_t, long int)]) + +AN_IDENTIFIER([mode_t], [AC_TYPE_MODE_T]) +AC_DEFUN([AC_TYPE_MODE_T], [AC_CHECK_TYPE(mode_t, int)]) + +AN_IDENTIFIER([int8_t], [AC_TYPE_INT8_T]) +AN_IDENTIFIER([int16_t], [AC_TYPE_INT16_T]) +AN_IDENTIFIER([int32_t], [AC_TYPE_INT32_T]) +AN_IDENTIFIER([int64_t], [AC_TYPE_INT64_T]) +AN_IDENTIFIER([uint8_t], [AC_TYPE_UINT8_T]) +AN_IDENTIFIER([uint16_t], [AC_TYPE_UINT16_T]) +AN_IDENTIFIER([uint32_t], [AC_TYPE_UINT32_T]) +AN_IDENTIFIER([uint64_t], [AC_TYPE_UINT64_T]) +AC_DEFUN([AC_TYPE_INT8_T], [_AC_TYPE_INT(8)]) +AC_DEFUN([AC_TYPE_INT16_T], [_AC_TYPE_INT(16)]) +AC_DEFUN([AC_TYPE_INT32_T], [_AC_TYPE_INT(32)]) +AC_DEFUN([AC_TYPE_INT64_T], [_AC_TYPE_INT(64)]) +AC_DEFUN([AC_TYPE_UINT8_T], [_AC_TYPE_UNSIGNED_INT(8)]) +AC_DEFUN([AC_TYPE_UINT16_T], [_AC_TYPE_UNSIGNED_INT(16)]) +AC_DEFUN([AC_TYPE_UINT32_T], [_AC_TYPE_UNSIGNED_INT(32)]) +AC_DEFUN([AC_TYPE_UINT64_T], [_AC_TYPE_UNSIGNED_INT(64)]) + +# _AC_TYPE_INT_BODY +# ----------------- +# Shell function body for _AC_TYPE_INT. +m4_define([_AC_TYPE_INT_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for int$[]2_t], [$[]3], + [AS_VAR_SET([$[]3], [no]) + # Order is important - never check a type that is potentially smaller + # than half of the expected target width. + for ac_type in int$[]2_t 'int' 'long int' \ + 'long long int' 'short int' 'signed char'; do + AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [AC_INCLUDES_DEFAULT + enum { N = $[]2 / 2 - 1 };], + [0 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1)])], + [AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [AC_INCLUDES_DEFAULT + enum { N = $[]2 / 2 - 1 };], + [($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1) + < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 2)])], + [], + [AS_CASE([$ac_type], [int$[]2_t], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [$ac_type])])])]) + AS_VAR_IF([$[]3], [no], [], [break]) + done]) + AS_LINENO_POP +])# _AC_TYPE_INT_BODY + +# _AC_TYPE_INT(NBITS) +# ------------------- +# Set a variable ac_cv_c_intNBITS_t to `yes' if intNBITS_t is available, +# `no' if it is not and no replacement types could be found, and a C type +# if it is not available but a replacement signed integer type of width +# exactly NBITS bits was found. In the third case, intNBITS_t is AC_DEFINEd +# to type, as well. +AC_DEFUN([_AC_TYPE_INT], +[AC_REQUIRE_SHELL_FN([ac_fn_c_find_intX_t], + [AS_FUNCTION_DESCRIBE([ac_fn_c_find_intX_t], [LINENO BITS VAR], + [Finds a signed integer type with width BITS, setting cache variable VAR + accordingly.])], + [$0_BODY])]dnl +[ac_fn_c_find_intX_t "$LINENO" "$1" "ac_cv_c_int$1_t" +case $ac_cv_c_int$1_t in #( + no|yes) ;; #( + *) + AC_DEFINE_UNQUOTED([int$1_t], [$ac_cv_c_int$1_t], + [Define to the type of a signed integer type of width exactly $1 bits + if such a type exists and the standard includes do not define it.]);; +esac +])# _AC_TYPE_INT + +# _AC_TYPE_UNSIGNED_INT_BODY +# -------------------------- +# Shell function body for _AC_TYPE_UNSIGNED_INT. +m4_define([_AC_TYPE_UNSIGNED_INT_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for uint$[]2_t], $[]3, + [AS_VAR_SET([$[]3], [no]) + # Order is important - never check a type that is potentially smaller + # than half of the expected target width. + for ac_type in uint$[]2_t 'unsigned int' 'unsigned long int' \ + 'unsigned long long int' 'unsigned short int' 'unsigned char'; do + AC_COMPILE_IFELSE( + [AC_LANG_BOOL_COMPILE_TRY( + [AC_INCLUDES_DEFAULT], + [(($ac_type) -1 >> ($[]2 / 2 - 1)) >> ($[]2 / 2 - 1) == 3])], + [AS_CASE([$ac_type], [uint$[]2_t], + [AS_VAR_SET([$[]3], [yes])], + [AS_VAR_SET([$[]3], [$ac_type])])]) + AS_VAR_IF([$[]3], [no], [], [break]) + done]) + AS_LINENO_POP +])# _AC_TYPE_UNSIGNED_INT_BODY + + +# _AC_TYPE_UNSIGNED_INT(NBITS) +# ---------------------------- +# Set a variable ac_cv_c_uintNBITS_t to `yes' if uintNBITS_t is available, +# `no' if it is not and no replacement types could be found, and a C type +# if it is not available but a replacement unsigned integer type of width +# exactly NBITS bits was found. In the third case, uintNBITS_t is AC_DEFINEd +# to type, as well. +AC_DEFUN([_AC_TYPE_UNSIGNED_INT], +[AC_REQUIRE_SHELL_FN([ac_fn_c_find_uintX_t], + [AS_FUNCTION_DESCRIBE([ac_fn_c_find_uintX_t], [LINENO BITS VAR], + [Finds an unsigned integer type with width BITS, setting cache variable VAR + accordingly.])], + [$0_BODY])]dnl +[ac_fn_c_find_uintX_t "$LINENO" "$1" "ac_cv_c_uint$1_t" +case $ac_cv_c_uint$1_t in #( + no|yes) ;; #( + *) + m4_bmatch([$1], [^\(8\|32\|64\)$], + [AC_DEFINE([_UINT$1_T], 1, + [Define for Solaris 2.5.1 so the uint$1_t typedef from + <sys/synch.h>, <pthread.h>, or <semaphore.h> is not used. + If the typedef were allowed, the #define below would cause a + syntax error.])]) + AC_DEFINE_UNQUOTED([uint$1_t], [$ac_cv_c_uint$1_t], + [Define to the type of an unsigned integer type of width exactly $1 bits + if such a type exists and the standard includes do not define it.]);; + esac +])# _AC_TYPE_UNSIGNED_INT + +# AC_TYPE_SIGNAL +# -------------- +# Note that identifiers starting with SIG are reserved by ANSI C. +# C89 requires signal handlers to return void; only K&R returned int; +# modern code does not need to worry about using this macro (not to +# mention that sigaction is better than signal). +AU_DEFUN([AC_TYPE_SIGNAL], +[AC_CACHE_CHECK([return type of signal handlers], ac_cv_type_signal, +[AC_COMPILE_IFELSE( +[AC_LANG_PROGRAM([#include <sys/types.h> +#include <signal.h> +], + [return *(signal (0, 0)) (0) == 1;])], + [ac_cv_type_signal=int], + [ac_cv_type_signal=void])]) +AC_DEFINE_UNQUOTED(RETSIGTYPE, $ac_cv_type_signal, + [Define as the return type of signal handlers + (`int' or `void').]) +], [your code may safely assume C89 semantics that RETSIGTYPE is void. +Remove this warning and the `AC_CACHE_CHECK' when you adjust the code.]) + + +## ------------------------ ## +## Checking size of types. ## +## ------------------------ ## + +# ---------------- # +# Generic checks. # +# ---------------- # + + +# AC_CHECK_SIZEOF(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES]) +# --------------------------------------------------------------- +AC_DEFUN([AC_CHECK_SIZEOF], +[AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [], + [m4_fatal([$0: requires literal arguments])])]dnl +[# The cast to long int works around a bug in the HP C Compiler +# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects +# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. +# This bug is HP SR number 8606223364. +_AC_CACHE_CHECK_INT([size of $1], [AS_TR_SH([ac_cv_sizeof_$1])], + [(long int) (sizeof ($1))], + [AC_INCLUDES_DEFAULT([$3])], + [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then + AC_MSG_FAILURE([cannot compute sizeof ($1)], 77) + else + AS_TR_SH([ac_cv_sizeof_$1])=0 + fi]) + +AC_DEFINE_UNQUOTED(AS_TR_CPP(sizeof_$1), $AS_TR_SH([ac_cv_sizeof_$1]), + [The size of `$1', as computed by sizeof.]) +])# AC_CHECK_SIZEOF + + +# AC_CHECK_ALIGNOF(TYPE, [INCLUDES = DEFAULT-INCLUDES]) +# ----------------------------------------------------- +# TYPE can include braces and semicolon, which AS_TR_CPP and AS_TR_SH +# (correctly) recognize as potential shell metacharacters. So we +# have to flatten problematic characters ourselves to guarantee that +# AC_DEFINE_UNQUOTED will see a literal. +AC_DEFUN([AC_CHECK_ALIGNOF], +[m4_if(m4_index(m4_translit([[$1]], [`\"], [$]), [$]), [-1], [], + [m4_fatal([$0: requires literal arguments])])]dnl +[_$0([$1], [$2], m4_translit([[$1]], [{;}], [___]))]) + +m4_define([_AC_CHECK_ALIGNOF], +[# The cast to long int works around a bug in the HP C Compiler, +# see AC_CHECK_SIZEOF for more information. +_AC_CACHE_CHECK_INT([alignment of $1], [AS_TR_SH([ac_cv_alignof_$3])], + [(long int) offsetof (ac__type_alignof_, y)], + [AC_INCLUDES_DEFAULT([$2]) +#ifndef offsetof +# define offsetof(type, member) ((char *) &((type *) 0)->member - (char *) 0) +#endif +typedef struct { char x; $1 y; } ac__type_alignof_;], + [if test "$AS_TR_SH([ac_cv_type_$3])" = yes; then + AC_MSG_FAILURE([cannot compute alignment of $1], 77) + else + AS_TR_SH([ac_cv_alignof_$3])=0 + fi]) + +AC_DEFINE_UNQUOTED(AS_TR_CPP(alignof_$3), $AS_TR_SH([ac_cv_alignof_$3]), + [The normal alignment of `$1', in bytes.]) +])# AC_CHECK_ALIGNOF + + +# AU::AC_INT_16_BITS +# ------------------ +# What a great name :) +AU_DEFUN([AC_INT_16_BITS], +[AC_CHECK_SIZEOF([int]) +test $ac_cv_sizeof_int = 2 && + AC_DEFINE(INT_16_BITS, 1, + [Define to 1 if `sizeof (int)' = 2. Obsolete, use `SIZEOF_INT'.]) +], [your code should no longer depend upon `INT_16_BITS', but upon +`SIZEOF_INT == 2'. Remove this warning and the `AC_DEFINE' when you +adjust the code.]) + + +# AU::AC_LONG_64_BITS +# ------------------- +AU_DEFUN([AC_LONG_64_BITS], +[AC_CHECK_SIZEOF([long int]) +test $ac_cv_sizeof_long_int = 8 && + AC_DEFINE(LONG_64_BITS, 1, + [Define to 1 if `sizeof (long int)' = 8. Obsolete, use + `SIZEOF_LONG_INT'.]) +], [your code should no longer depend upon `LONG_64_BITS', but upon +`SIZEOF_LONG_INT == 8'. Remove this warning and the `AC_DEFINE' when +you adjust the code.]) + + + +## -------------------------- ## +## Generic structure checks. ## +## -------------------------- ## + + +# ---------------- # +# Generic checks. # +# ---------------- # + +# _AC_CHECK_MEMBER_BODY +# --------------------- +# Shell function body for AC_CHECK_MEMBER. +m4_define([_AC_CHECK_MEMBER_BODY], +[ AS_LINENO_PUSH([$[]1]) + AC_CACHE_CHECK([for $[]2.$[]3], [$[]4], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$[]5], +[static $[]2 ac_aggr; +if (ac_aggr.$[]3) +return 0;])], + [AS_VAR_SET([$[]4], [yes])], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$[]5], +[static $[]2 ac_aggr; +if (sizeof ac_aggr.$[]3) +return 0;])], + [AS_VAR_SET([$[]4], [yes])], + [AS_VAR_SET([$[]4], [no])])])]) + AS_LINENO_POP +])dnl + +# AC_CHECK_MEMBER(AGGREGATE.MEMBER, +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# --------------------------------------------------------- +# AGGREGATE.MEMBER is for instance `struct passwd.pw_gecos', shell +# variables are not a valid argument. +AC_DEFUN([AC_CHECK_MEMBER], +[AC_REQUIRE_SHELL_FN([ac_fn_]_AC_LANG_ABBREV[_check_member], + [AS_FUNCTION_DESCRIBE([ac_fn_]_AC_LANG_ABBREV[_check_member], + [LINENO AGGR MEMBER VAR INCLUDES], + [Tries to find if the field MEMBER exists in type AGGR, after including + INCLUDES, setting cache variable VAR accordingly.])], + [_$0_BODY])]dnl +[AS_LITERAL_IF([$1], [], [m4_fatal([$0: requires literal arguments])])]dnl +[m4_if(m4_index([$1], [.]), [-1], + [m4_fatal([$0: Did not see any dot in `$1'])])]dnl +[AS_VAR_PUSHDEF([ac_Member], [ac_cv_member_$1])]dnl +[ac_fn_[]_AC_LANG_ABBREV[]_check_member "$LINENO" ]dnl +[m4_bpatsubst([$1], [^\([^.]*\)\.\(.*\)], ["\1" "\2"]) "ac_Member" ]dnl +["AS_ESCAPE([AC_INCLUDES_DEFAULT([$4])], [""])" +AS_VAR_IF([ac_Member], [yes], [$2], [$3]) +AS_VAR_POPDEF([ac_Member])dnl +])# AC_CHECK_MEMBER + + +# _AC_CHECK_MEMBERS(AGGREGATE.MEMBER) +# ----------------------------------- +# Helper to AC_CHECK_MEMBERS, which generates two of the four +# arguments to AC_CHECK_MEMBER that are based on AGGREGATE and MEMBER. +m4_define([_AC_CHECK_MEMBERS], +[[$1], [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_$1]), [1], + [Define to 1 if `]m4_bpatsubst([$1], + [^\([^.]*\)\.\(.*\)], [[\2' is a member of `\1]])['.])]]) + +# AC_CHECK_MEMBERS([AGGREGATE.MEMBER, ...], +# [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND], +# [INCLUDES = DEFAULT-INCLUDES]) +# ---------------------------------------------------------- +# The first argument is an m4 list. +AC_DEFUN([AC_CHECK_MEMBERS], +[m4_map_args_sep([AC_CHECK_MEMBER(_$0(], [)[ +$2], [$3], [$4])], [], $1)]) + + + +# ------------------------------------------------------- # +# Members that ought to be tested with AC_CHECK_MEMBERS. # +# ------------------------------------------------------- # + +AN_IDENTIFIER([st_blksize], [AC_CHECK_MEMBERS([struct stat.st_blksize])]) +AN_IDENTIFIER([st_rdev], [AC_CHECK_MEMBERS([struct stat.st_rdev])]) + + +# Alphabetic order, please. + +# _AC_STRUCT_DIRENT(MEMBER) +# ------------------------- +AC_DEFUN([_AC_STRUCT_DIRENT], +[ + AC_REQUIRE([AC_HEADER_DIRENT]) + AC_CHECK_MEMBERS([struct dirent.$1], [], [], + [[ +#include <sys/types.h> +#ifdef HAVE_DIRENT_H +# include <dirent.h> +#else +# define dirent direct +# ifdef HAVE_SYS_NDIR_H +# include <sys/ndir.h> +# endif +# ifdef HAVE_SYS_DIR_H +# include <sys/dir.h> +# endif +# ifdef HAVE_NDIR_H +# include <ndir.h> +# endif +#endif + ]]) +]) + +# AC_STRUCT_DIRENT_D_INO +# ---------------------- +AC_DEFUN([AC_STRUCT_DIRENT_D_INO], [_AC_STRUCT_DIRENT([d_ino])]) + +# AC_STRUCT_DIRENT_D_TYPE +# ----------------------- +AC_DEFUN([AC_STRUCT_DIRENT_D_TYPE], [_AC_STRUCT_DIRENT([d_type])]) + + +# AC_STRUCT_ST_BLKSIZE +# -------------------- +AU_DEFUN([AC_STRUCT_ST_BLKSIZE], +[AC_CHECK_MEMBERS([struct stat.st_blksize], + [AC_DEFINE(HAVE_ST_BLKSIZE, 1, + [Define to 1 if your `struct stat' has + `st_blksize'. Deprecated, use + `HAVE_STRUCT_STAT_ST_BLKSIZE' instead.])]) +], [your code should no longer depend upon `HAVE_ST_BLKSIZE', but +`HAVE_STRUCT_STAT_ST_BLKSIZE'. Remove this warning and +the `AC_DEFINE' when you adjust the code.])# AC_STRUCT_ST_BLKSIZE + + +# AC_STRUCT_ST_BLOCKS +# ------------------- +# If `struct stat' contains an `st_blocks' member, define +# HAVE_STRUCT_STAT_ST_BLOCKS. Otherwise, add `fileblocks.o' to the +# output variable LIBOBJS. We still define HAVE_ST_BLOCKS for backward +# compatibility. In the future, we will activate specializations for +# this macro, so don't obsolete it right now. +# +# AC_OBSOLETE([$0], [; replace it with +# AC_CHECK_MEMBERS([struct stat.st_blocks], +# [AC_LIBOBJ([fileblocks])]) +# Please note that it will define `HAVE_STRUCT_STAT_ST_BLOCKS', +# and not `HAVE_ST_BLOCKS'.])dnl +# +AN_IDENTIFIER([st_blocks], [AC_STRUCT_ST_BLOCKS]) +AC_DEFUN([AC_STRUCT_ST_BLOCKS], +[AC_CHECK_MEMBERS([struct stat.st_blocks], + [AC_DEFINE(HAVE_ST_BLOCKS, 1, + [Define to 1 if your `struct stat' has + `st_blocks'. Deprecated, use + `HAVE_STRUCT_STAT_ST_BLOCKS' instead.])], + [AC_LIBOBJ([fileblocks])]) +])# AC_STRUCT_ST_BLOCKS + + +# AC_STRUCT_ST_RDEV +# ----------------- +AU_DEFUN([AC_STRUCT_ST_RDEV], +[AC_CHECK_MEMBERS([struct stat.st_rdev], + [AC_DEFINE(HAVE_ST_RDEV, 1, + [Define to 1 if your `struct stat' has `st_rdev'. + Deprecated, use `HAVE_STRUCT_STAT_ST_RDEV' + instead.])]) +], [your code should no longer depend upon `HAVE_ST_RDEV', but +`HAVE_STRUCT_STAT_ST_RDEV'. Remove this warning and +the `AC_DEFINE' when you adjust the code.])# AC_STRUCT_ST_RDEV + + +# AC_STRUCT_TM +# ------------ +# FIXME: This macro is badly named, it should be AC_CHECK_TYPE_STRUCT_TM. +# Or something else, but what? AC_CHECK_TYPE_STRUCT_TM_IN_SYS_TIME? +AC_DEFUN([AC_STRUCT_TM], +[AC_CACHE_CHECK([whether struct tm is in sys/time.h or time.h], + ac_cv_struct_tm, +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h> +#include <time.h> +], + [struct tm tm; + int *p = &tm.tm_sec; + return !p;])], + [ac_cv_struct_tm=time.h], + [ac_cv_struct_tm=sys/time.h])]) +if test $ac_cv_struct_tm = sys/time.h; then + AC_DEFINE(TM_IN_SYS_TIME, 1, + [Define to 1 if your <sys/time.h> declares `struct tm'.]) +fi +])# AC_STRUCT_TM + + +# AC_STRUCT_TIMEZONE +# ------------------ +# Figure out how to get the current timezone. If `struct tm' has a +# `tm_zone' member, define `HAVE_TM_ZONE'. Otherwise, if the +# external array `tzname' is found, define `HAVE_TZNAME'. +AN_IDENTIFIER([tm_zone], [AC_STRUCT_TIMEZONE]) +AC_DEFUN([AC_STRUCT_TIMEZONE], +[AC_REQUIRE([AC_STRUCT_TM])dnl +AC_CHECK_MEMBERS([struct tm.tm_zone],,,[#include <sys/types.h> +#include <$ac_cv_struct_tm> +]) +if test "$ac_cv_member_struct_tm_tm_zone" = yes; then + AC_DEFINE(HAVE_TM_ZONE, 1, + [Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use + `HAVE_STRUCT_TM_TM_ZONE' instead.]) +else + AC_CHECK_DECLS([tzname], , , [#include <time.h>]) + AC_CACHE_CHECK(for tzname, ac_cv_var_tzname, +[AC_LINK_IFELSE([AC_LANG_PROGRAM( +[[#include <time.h> +#if !HAVE_DECL_TZNAME +extern char *tzname[]; +#endif +]], +[[return tzname[0][0];]])], + [ac_cv_var_tzname=yes], + [ac_cv_var_tzname=no])]) + if test $ac_cv_var_tzname = yes; then + AC_DEFINE(HAVE_TZNAME, 1, + [Define to 1 if you don't have `tm_zone' but do have the external + array `tzname'.]) + fi +fi +])# AC_STRUCT_TIMEZONE diff --git a/lib/autom4te.in b/lib/autom4te.in new file mode 100644 index 0000000..a560501 --- /dev/null +++ b/lib/autom4te.in @@ -0,0 +1,165 @@ +# Definition of Autom4te option sets. -*- Makefile -*- +# +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +## -------------------------- ## +## Autoheader preselections. ## +## -------------------------- ## + +begin-language: "Autoheader-preselections" +args: --preselect AC_CONFIG_HEADERS +args: --preselect AH_OUTPUT +args: --preselect AC_DEFINE_TRACE_LITERAL +end-language: "Autoheader-preselections" + + +## ------------------------ ## +## Automake-preselections. ## +## ------------------------ ## + +begin-language: "Automake-preselections" +args: --preselect AC_CANONICAL_BUILD +args: --preselect AC_CANONICAL_HOST +# AC_CANONICAL_SYSTEM was traced from Automake 1.7 to Automake 1.9. +# Later versions trace AC_CANONICAL_TARGET instead. +args: --preselect AC_CANONICAL_SYSTEM +args: --preselect AC_CANONICAL_TARGET +args: --preselect AC_CONFIG_AUX_DIR +args: --preselect AC_CONFIG_FILES +args: --preselect AC_CONFIG_HEADERS +args: --preselect AC_CONFIG_LIBOBJ_DIR +args: --preselect AC_CONFIG_LINKS +args: --preselect AC_FC_FREEFORM +args: --preselect AC_FC_SRCEXT +args: --preselect AC_FC_PP_DEFINE +args: --preselect AC_FC_PP_SRCEXT +args: --preselect AC_INIT +args: --preselect AC_LIBSOURCE +args: --preselect AC_REQUIRE_AUX_FILE +# Automake < 1.10 traces AC_SUBST. Automake >= 1.10 traces AC_SUBST_TRACE. +args: --preselect AC_SUBST +args: --preselect AC_SUBST_TRACE +args: --preselect AM_AUTOMAKE_VERSION +args: --preselect AM_CONDITIONAL +args: --preselect AM_ENABLE_MULTILIB +args: --preselect AM_GNU_GETTEXT +args: --preselect AM_GNU_GETTEXT_INTL_SUBDIR +args: --preselect AM_INIT_AUTOMAKE +args: --preselect AM_MAKEFILE_INCLUDE +args: --preselect AM_MAINTAINER_MODE +args: --preselect AM_NLS +args: --preselect AM_POT_TOOLS +args: --preselect AM_PATH_GUILE +args: --preselect AM_PROG_AR +args: --preselect AM_PROG_CC_C_O +args: --preselect AM_PROG_CXX_C_O +args: --preselect AM_PROG_F77_C_O +args: --preselect AM_PROG_FC_C_O +args: --preselect AM_PROG_MOC +args: --preselect AM_SILENT_RULES +args: --preselect AM_XGETTEXT_OPTION +args: --preselect _AM_MAKEFILE_INCLUDE +args: --preselect _AM_SUBST_NOTMAKE +args: --preselect _AM_COND_IF +args: --preselect _AM_COND_ELSE +args: --preselect _AM_COND_ENDIF +args: --preselect LT_SUPPORTED_TAG +args: --preselect _LT_AC_TAGCONFIG +args: --preselect m4_include +args: --preselect m4_sinclude +end-language: "Automake-preselections" + + +## -------------------------- ## +## Autoreconf-preselections. ## +## -------------------------- ## + +begin-language: "Autoreconf-preselections" +args: --preselect AC_CONFIG_AUX_DIR +args: --preselect AC_CONFIG_HEADERS +args: --preselect AC_CONFIG_SUBDIRS +args: --preselect AC_INIT +args: --preselect AC_PROG_LIBTOOL +args: --preselect LT_INIT +args: --preselect LT_CONFIG_LTDL_DIR +args: --preselect AM_GNU_GETTEXT +end-language: "Autoreconf-preselections" + + +## ----------------------------- ## +## Autoconf without aclocal.m4. ## +## ----------------------------- ## + +# This intermediate language is used by aclocal to build aclocal.m4. + +begin-language: "Autoconf-without-aclocal-m4" +args: --prepend-include '@pkgdatadir@' +args: --cache=autom4te.cache +args: autoconf/autoconf.m4f +args: acsite.m4? +args: --mode 777 +args: --language M4sh +end-language: "Autoconf-without-aclocal-m4" + + +## ---------- ## +## Autoconf. ## +## ---------- ## + +begin-language: "Autoconf" +args: --language Autoheader-preselections +args: --language Automake-preselections +args: --language Autoreconf-preselections +args: --language Autoconf-without-aclocal-m4 +args: aclocal.m4? +end-language: "Autoconf" + + +## -------- ## +## Autotest ## +## -------- ## + +begin-language: "Autotest" +args: --prepend-include '@pkgdatadir@' +args: autotest/autotest.m4f +args: package.m4? +args: local.at? +args: --mode 777 +args: --language M4sh +end-language: "Autotest" + + +## ---- ## +## M4sh ## +## ---- ## + +begin-language: "M4sh" +args: --prepend-include '@pkgdatadir@' +args: m4sugar/m4sh.m4f +args: --mode 777 +args: --language M4sugar +end-language: "M4sh" + + +## ------- ## +## M4sugar ## +## ------- ## + +begin-language: "M4sugar" +args: --prepend-include '@pkgdatadir@' +args: m4sugar/m4sugar.m4f +args: --warnings syntax +end-language: "M4sugar" diff --git a/lib/autoscan/Makefile.am b/lib/autoscan/Makefile.am new file mode 100644 index 0000000..f4a2dea --- /dev/null +++ b/lib/autoscan/Makefile.am @@ -0,0 +1,40 @@ +# Make Autoscan library. + +# Copyright (C) 2001-2002, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +autoscanlibdir = $(pkgdatadir)/autoscan + +EXTRA_DIST = autoscan.pre +nodist_autoscanlib_DATA = autoscan.list +CLEANFILES = autoscan.list + +## ------------------------ ## +## Building autoscan.list. ## +## ------------------------ ## + +## autoscan.list might change when autoconf.m4f sources change. +## Therefore we want the same dependencies as autoconf.m4f, which +## are listed in freeze.mk. It also ensure that tests/autom4te +## is built (we need it in the command below). +include ../freeze.mk + +autoscan.list: $(srcdir)/autoscan.pre $(autoconf_m4f_dependencies) Makefile.am + echo '# Automatically Generated: do not edit this file' >autoscan.list + sed '/^[#]/!q' $(srcdir)/autoscan.pre >>autoscan.list + ( \ + sed -n '/^[^#]/p' $(srcdir)/autoscan.pre; \ + $(MY_AUTOM4TE) --cache '' -M -l autoconf -t'AN_OUTPUT:$$1: $$2 $$3' \ + ) | LC_ALL=C sort >>autoscan.list diff --git a/lib/autoscan/Makefile.in b/lib/autoscan/Makefile.in new file mode 100644 index 0000000..ea2abef --- /dev/null +++ b/lib/autoscan/Makefile.in @@ -0,0 +1,524 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autoscan library. + +# Copyright (C) 2001-2002, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Freeze M4 files. + +# Copyright (C) 2002, 2004, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(srcdir)/../freeze.mk $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in +subdir = lib/autoscan +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(autoscanlibdir)" +DATA = $(nodist_autoscanlib_DATA) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +autoscanlibdir = $(pkgdatadir)/autoscan +EXTRA_DIST = autoscan.pre +nodist_autoscanlib_DATA = autoscan.list +CLEANFILES = autoscan.list +SUFFIXES = .m4 .m4f +AUTOM4TE_CFG = $(top_builddir)/lib/autom4te.cfg + +# Do not use AUTOM4TE here, since maint.mk (my-distcheck) +# checks if we are independent of Autoconf by defining AUTOM4TE (and +# others) to `false'. Autoconf provides autom4te, so that doesn't +# apply to us. +MY_AUTOM4TE = \ + autom4te_perllibdir='$(top_srcdir)'/lib \ + AUTOM4TE_CFG='$(AUTOM4TE_CFG)' $(top_builddir)/bin/autom4te \ + -B '$(top_builddir)'/lib -B '$(top_srcdir)'/lib # keep ` ' + + +# Factor the dependencies between all the frozen files. +# Some day we should explain to Automake how to use autom4te to compute +# the dependencies... +src_libdir = $(top_srcdir)/lib +build_libdir = $(top_builddir)/lib +m4f_dependencies = $(top_builddir)/bin/autom4te $(AUTOM4TE_CFG) +m4sugar_m4f_dependencies = \ + $(m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sugar.m4 \ + $(build_libdir)/m4sugar/version.m4 + +m4sh_m4f_dependencies = \ + $(m4sugar_m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sh.m4 + +autotest_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autotest/autotest.m4 \ + $(src_libdir)/autotest/general.m4 \ + $(src_libdir)/autotest/specific.m4 + +autoconf_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autoconf/autoscan.m4 \ + $(src_libdir)/autoconf/general.m4 \ + $(src_libdir)/autoconf/autoheader.m4 \ + $(src_libdir)/autoconf/autoupdate.m4 \ + $(src_libdir)/autoconf/autotest.m4 \ + $(src_libdir)/autoconf/status.m4 \ + $(src_libdir)/autoconf/oldnames.m4 \ + $(src_libdir)/autoconf/specific.m4 \ + $(src_libdir)/autoconf/lang.m4 \ + $(src_libdir)/autoconf/c.m4 \ + $(src_libdir)/autoconf/fortran.m4 \ + $(src_libdir)/autoconf/erlang.m4 \ + $(src_libdir)/autoconf/go.m4 \ + $(src_libdir)/autoconf/functions.m4 \ + $(src_libdir)/autoconf/headers.m4 \ + $(src_libdir)/autoconf/types.m4 \ + $(src_libdir)/autoconf/libs.m4 \ + $(src_libdir)/autoconf/programs.m4 \ + $(src_libdir)/autoconf/autoconf.m4 + +ETAGS_FOR_M4 = \ + --lang=none \ + --regex='/\(m4_define\|define\)(\[\([^]]*\)\]/\2/' + +ETAGS_FOR_M4SUGAR = \ + $(ETAGS_FOR_M4) \ + --regex='/m4_defun(\[\([^]]*\)\]/\1/' + +ETAGS_FOR_AUTOCONF = \ + $(ETAGS_FOR_M4SUGAR) \ + --regex='/\(A[CU]_DEFUN\|AU_ALIAS\)(\[\([^]]*\)\]/\2/' \ + --regex='/AN_\(FUNCTION\|HEADER\|IDENTIFIER\|LIBRARY\|MAKEVAR\|PROGRAM\)(\[\([^]]*\)\]/\2/' + +all: all-am + +.SUFFIXES: +.SUFFIXES: .m4 .m4f +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(srcdir)/../freeze.mk $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/autoscan/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/autoscan/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-nodist_autoscanlibDATA: $(nodist_autoscanlib_DATA) + @$(NORMAL_INSTALL) + test -z "$(autoscanlibdir)" || $(MKDIR_P) "$(DESTDIR)$(autoscanlibdir)" + @list='$(nodist_autoscanlib_DATA)'; test -n "$(autoscanlibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(autoscanlibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(autoscanlibdir)" || exit $$?; \ + done + +uninstall-nodist_autoscanlibDATA: + @$(NORMAL_UNINSTALL) + @list='$(nodist_autoscanlib_DATA)'; test -n "$(autoscanlibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(autoscanlibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(autoscanlibdir)" && rm -f $$files +tags: TAGS +TAGS: + +ctags: CTAGS +CTAGS: + + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(autoscanlibdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-nodist_autoscanlibDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-nodist_autoscanlibDATA + +.MAKE: install-am install-strip + +.PHONY: all all-am check check-am clean clean-generic distclean \ + distclean-generic distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-nodist_autoscanlibDATA install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am uninstall uninstall-am \ + uninstall-nodist_autoscanlibDATA + +$(AUTOM4TE_CFG): $(top_srcdir)/lib/autom4te.in + cd $(top_builddir)/lib && $(MAKE) $(AM_MAKEFLAGS) autom4te.cfg + +# When processing the file with diversion disabled, there must be no +# output but comments and empty lines. +# If freezing produces output, something went wrong: a bad `divert', +# or an improper paren etc. +# It may happen that the output does not end with an end of line, hence +# force an end of line when reporting errors. +.m4.m4f: + $(MY_AUTOM4TE) \ + --language=$* \ + --freeze \ + --output=$@ + +# For parallel builds. +$(build_libdir)/m4sugar/version.m4: + cd $(build_libdir)/m4sugar && $(MAKE) $(AM_MAKEFLAGS) version.m4 + +check-forbidden-patterns: + @if (cd $(srcdir) && \ + $(GREP) $(forbidden_patterns) $(forbidden_patterns_files)) \ + >forbidden.log; then \ + echo "ERROR: forbidden patterns were found:" >&2; \ + sed "s|^|$*.m4: |" <forbidden.log >&2; \ + echo >&2; \ + exit 1; \ + else \ + rm -f forbidden.log; \ + fi + +autoscan.list: $(srcdir)/autoscan.pre $(autoconf_m4f_dependencies) Makefile.am + echo '# Automatically Generated: do not edit this file' >autoscan.list + sed '/^[#]/!q' $(srcdir)/autoscan.pre >>autoscan.list + ( \ + sed -n '/^[^#]/p' $(srcdir)/autoscan.pre; \ + $(MY_AUTOM4TE) --cache '' -M -l autoconf -t'AN_OUTPUT:$$1: $$2 $$3' \ + ) | LC_ALL=C sort >>autoscan.list + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/autoscan/autoscan.pre b/lib/autoscan/autoscan.pre new file mode 100644 index 0000000..d7892bb --- /dev/null +++ b/lib/autoscan/autoscan.pre @@ -0,0 +1,16 @@ +# autoscan's mapping to Autoconf macros -*- Makefile -*- +# Copyright (C) 1992-1994, 1996, 1999-2002, 2009-2012 Free Software +# Foundation, Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. diff --git a/lib/autotest/Makefile.am b/lib/autotest/Makefile.am new file mode 100644 index 0000000..c70dafb --- /dev/null +++ b/lib/autotest/Makefile.am @@ -0,0 +1,46 @@ +# Make Autotest library. + +# Copyright (C) 2001-2002, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +autotestlibdir = $(pkgdatadir)/autotest +dist_autotestlib_DATA = autotest.m4 general.m4 specific.m4 +nodist_autotestlib_DATA = autotest.m4f +CLEANFILES = $(nodist_autotestlib_DATA) + +## --------------- ## +## Building TAGS. ## +## --------------- ## + +TAGS_FILES = $(dist_autotestlib_DATA) + +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) + + +## -------- ## +## Checks. ## +## -------- ## + +check-local: check-forbidden-patterns +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_autotestlib_DATA) + + +## ------------------ ## +## The frozen files. ## +## ------------------ ## + +autotest.m4f: $(autotest_m4f_dependencies) +include ../freeze.mk diff --git a/lib/autotest/Makefile.in b/lib/autotest/Makefile.in new file mode 100644 index 0000000..a31632a --- /dev/null +++ b/lib/autotest/Makefile.in @@ -0,0 +1,599 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autotest library. + +# Copyright (C) 2001-2002, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Freeze M4 files. + +# Copyright (C) 2002, 2004, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(dist_autotestlib_DATA) $(srcdir)/../freeze.mk \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in +subdir = lib/autotest +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(autotestlibdir)" \ + "$(DESTDIR)$(autotestlibdir)" +DATA = $(dist_autotestlib_DATA) $(nodist_autotestlib_DATA) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +autotestlibdir = $(pkgdatadir)/autotest +dist_autotestlib_DATA = autotest.m4 general.m4 specific.m4 +nodist_autotestlib_DATA = autotest.m4f +CLEANFILES = $(nodist_autotestlib_DATA) +TAGS_FILES = $(dist_autotestlib_DATA) +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_autotestlib_DATA) +SUFFIXES = .m4 .m4f +AUTOM4TE_CFG = $(top_builddir)/lib/autom4te.cfg + +# Do not use AUTOM4TE here, since maint.mk (my-distcheck) +# checks if we are independent of Autoconf by defining AUTOM4TE (and +# others) to `false'. Autoconf provides autom4te, so that doesn't +# apply to us. +MY_AUTOM4TE = \ + autom4te_perllibdir='$(top_srcdir)'/lib \ + AUTOM4TE_CFG='$(AUTOM4TE_CFG)' $(top_builddir)/bin/autom4te \ + -B '$(top_builddir)'/lib -B '$(top_srcdir)'/lib # keep ` ' + + +# Factor the dependencies between all the frozen files. +# Some day we should explain to Automake how to use autom4te to compute +# the dependencies... +src_libdir = $(top_srcdir)/lib +build_libdir = $(top_builddir)/lib +m4f_dependencies = $(top_builddir)/bin/autom4te $(AUTOM4TE_CFG) +m4sugar_m4f_dependencies = \ + $(m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sugar.m4 \ + $(build_libdir)/m4sugar/version.m4 + +m4sh_m4f_dependencies = \ + $(m4sugar_m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sh.m4 + +autotest_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autotest/autotest.m4 \ + $(src_libdir)/autotest/general.m4 \ + $(src_libdir)/autotest/specific.m4 + +autoconf_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autoconf/autoscan.m4 \ + $(src_libdir)/autoconf/general.m4 \ + $(src_libdir)/autoconf/autoheader.m4 \ + $(src_libdir)/autoconf/autoupdate.m4 \ + $(src_libdir)/autoconf/autotest.m4 \ + $(src_libdir)/autoconf/status.m4 \ + $(src_libdir)/autoconf/oldnames.m4 \ + $(src_libdir)/autoconf/specific.m4 \ + $(src_libdir)/autoconf/lang.m4 \ + $(src_libdir)/autoconf/c.m4 \ + $(src_libdir)/autoconf/fortran.m4 \ + $(src_libdir)/autoconf/erlang.m4 \ + $(src_libdir)/autoconf/go.m4 \ + $(src_libdir)/autoconf/functions.m4 \ + $(src_libdir)/autoconf/headers.m4 \ + $(src_libdir)/autoconf/types.m4 \ + $(src_libdir)/autoconf/libs.m4 \ + $(src_libdir)/autoconf/programs.m4 \ + $(src_libdir)/autoconf/autoconf.m4 + +ETAGS_FOR_M4 = \ + --lang=none \ + --regex='/\(m4_define\|define\)(\[\([^]]*\)\]/\2/' + +ETAGS_FOR_M4SUGAR = \ + $(ETAGS_FOR_M4) \ + --regex='/m4_defun(\[\([^]]*\)\]/\1/' + +ETAGS_FOR_AUTOCONF = \ + $(ETAGS_FOR_M4SUGAR) \ + --regex='/\(A[CU]_DEFUN\|AU_ALIAS\)(\[\([^]]*\)\]/\2/' \ + --regex='/AN_\(FUNCTION\|HEADER\|IDENTIFIER\|LIBRARY\|MAKEVAR\|PROGRAM\)(\[\([^]]*\)\]/\2/' + +all: all-am + +.SUFFIXES: +.SUFFIXES: .m4 .m4f +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(srcdir)/../freeze.mk $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/autotest/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/autotest/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-dist_autotestlibDATA: $(dist_autotestlib_DATA) + @$(NORMAL_INSTALL) + test -z "$(autotestlibdir)" || $(MKDIR_P) "$(DESTDIR)$(autotestlibdir)" + @list='$(dist_autotestlib_DATA)'; test -n "$(autotestlibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(autotestlibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(autotestlibdir)" || exit $$?; \ + done + +uninstall-dist_autotestlibDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_autotestlib_DATA)'; test -n "$(autotestlibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(autotestlibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(autotestlibdir)" && rm -f $$files +install-nodist_autotestlibDATA: $(nodist_autotestlib_DATA) + @$(NORMAL_INSTALL) + test -z "$(autotestlibdir)" || $(MKDIR_P) "$(DESTDIR)$(autotestlibdir)" + @list='$(nodist_autotestlib_DATA)'; test -n "$(autotestlibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(autotestlibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(autotestlibdir)" || exit $$?; \ + done + +uninstall-nodist_autotestlibDATA: + @$(NORMAL_UNINSTALL) + @list='$(nodist_autotestlib_DATA)'; test -n "$(autotestlibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(autotestlibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(autotestlibdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-local +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(autotestlibdir)" "$(DESTDIR)$(autotestlibdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_autotestlibDATA \ + install-nodist_autotestlibDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_autotestlibDATA \ + uninstall-nodist_autotestlibDATA + +.MAKE: check-am install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am check-local clean \ + clean-generic ctags distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am \ + install-dist_autotestlibDATA install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man \ + install-nodist_autotestlibDATA install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am tags uninstall uninstall-am \ + uninstall-dist_autotestlibDATA \ + uninstall-nodist_autotestlibDATA + + +check-local: check-forbidden-patterns + +autotest.m4f: $(autotest_m4f_dependencies) +$(AUTOM4TE_CFG): $(top_srcdir)/lib/autom4te.in + cd $(top_builddir)/lib && $(MAKE) $(AM_MAKEFLAGS) autom4te.cfg + +# When processing the file with diversion disabled, there must be no +# output but comments and empty lines. +# If freezing produces output, something went wrong: a bad `divert', +# or an improper paren etc. +# It may happen that the output does not end with an end of line, hence +# force an end of line when reporting errors. +.m4.m4f: + $(MY_AUTOM4TE) \ + --language=$* \ + --freeze \ + --output=$@ + +# For parallel builds. +$(build_libdir)/m4sugar/version.m4: + cd $(build_libdir)/m4sugar && $(MAKE) $(AM_MAKEFLAGS) version.m4 + +check-forbidden-patterns: + @if (cd $(srcdir) && \ + $(GREP) $(forbidden_patterns) $(forbidden_patterns_files)) \ + >forbidden.log; then \ + echo "ERROR: forbidden patterns were found:" >&2; \ + sed "s|^|$*.m4: |" <forbidden.log >&2; \ + echo >&2; \ + exit 1; \ + else \ + rm -f forbidden.log; \ + fi + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/autotest/autotest.m4 b/lib/autotest/autotest.m4 new file mode 100644 index 0000000..11a3443 --- /dev/null +++ b/lib/autotest/autotest.m4 @@ -0,0 +1,26 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# M4 macros used in building test suites. +# Copyright (C) 2000-2002, 2009-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +m4_include([autotest/general.m4]) +m4_include([autotest/specific.m4]) diff --git a/lib/autotest/general.m4 b/lib/autotest/general.m4 new file mode 100644 index 0000000..60c0352 --- /dev/null +++ b/lib/autotest/general.m4 @@ -0,0 +1,2215 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# M4 macros used in building test suites. +m4_define([_AT_COPYRIGHT_YEARS], [ +Copyright (C) 2000-2012 Free Software Foundation, Inc. +]) + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + + +# _m4_divert(DIVERSION-NAME) +# -------------------------- +# Convert a diversion name into its number. Otherwise, return +# DIVERSION-NAME which is supposed to be an actual diversion number. +# Of course it would be nicer to use m4_case here, instead of zillions +# of little macros, but it then takes twice longer to run `autoconf'! +# +# From M4sugar: +# -1. KILL +# 10000. GROW +# +# From M4sh: +# 0. BINSH +# 1. HEADER-REVISION +# 2. HEADER-COMMENT +# 3. HEADER-COPYRIGHT +# 4. M4SH-SANITIZE +# 5. M4SH-INIT +# 1000. BODY +# +# Defined below: +# - DEFAULTS +# Overall initialization, value of $at_groups_all. +# - PARSE_ARGS_BEGIN +# Setup defaults required for option processing. +# - PARSE_ARGS +# Option processing. After AT_INIT, user options can be entered here as +# cases of a case statement. +# - PARSE_ARGS_END +# Finish up the option processing. +# +# - HELP +# Start printing the help message. +# - HELP_MODES +# Modes help text. Additional modes can be appended as self-contained +# cat'd here-docs as generated by AS_HELP_STRING. +# - HELP_TUNING_BEGIN +# Tuning help text. This is for Autotest-provided text. +# - HELP_TUNING +# Additional tuning options' help text can be appended here as +# self-contained cat'd here-docs as generated by AS_HELP_STRING. +# - HELP_OTHER +# User help can be appended to this as self-contained cat'd here-docs. +# - HELP_END +# Finish up the help texts. +# +# - VERSION +# Head of the handling of --version. +# - VERSION_NOTICES +# Copyright notices for --version. +# - VERSION_END +# Tail of the handling of --version. +# +# - BANNERS +# Output shell initialization for the associative array of banner text. +# - TESTS_BEGIN +# Like DEFAULTS but run after argument processing for purposes of +# optimization. Do anything else that needs to be done to prepare for +# tests. Sets up verbose and log file descriptors. Sets and logs PATH. +# - PREPARE_TESTS +# Declares functions shared among the tests. Perform any user +# initialization to be shared among all tests. +# - TESTS +# The core of the test suite. +# +# - TEST_SCRIPT +# The collector for code for each test, the ``normal'' diversion, but +# undiverted into other locations before final output. +# +# - TEST_GROUPS +# Contents of each test group. The tests deliberately occur after the +# end of the shell script, so that the shell need not spend time parsing +# commands it will not execute. + +m4_define([_m4_divert(DEFAULTS)], 100) +m4_define([_m4_divert(PARSE_ARGS_BEGIN)], 200) +m4_define([_m4_divert(PARSE_ARGS)], 201) +m4_define([_m4_divert(PARSE_ARGS_END)], 202) +m4_define([_m4_divert(HELP)], 300) +m4_define([_m4_divert(HELP_MODES)], 301) +m4_define([_m4_divert(HELP_TUNING_BEGIN)], 302) +m4_define([_m4_divert(HELP_TUNING)], 303) +m4_define([_m4_divert(HELP_OTHER)], 304) +m4_define([_m4_divert(HELP_END)], 305) +m4_define([_m4_divert(VERSION)], 350) +m4_define([_m4_divert(VERSION_NOTICES)], 351) +m4_define([_m4_divert(VERSION_END)], 352) +m4_define([_m4_divert(BANNERS)], 400) +m4_define([_m4_divert(TESTS_BEGIN)], 401) +m4_define([_m4_divert(PREPARE_TESTS)], 402) +m4_define([_m4_divert(TESTS)], 403) +m4_define([_m4_divert(TEST_SCRIPT)], 450) +m4_define([_m4_divert(TEST_GROUPS)], 500) + + +# AT_LINE +# ------- +# Return the current file sans directory, a colon, and the current +# line. Be sure to return a _quoted_ file name, so if, for instance, +# the user is lunatic enough to have a file named `dnl' (and I, for +# one, love to be brainless and stubborn sometimes), then we return a +# quoted name. +# +# Gee, we can't use simply +# +# m4_bpatsubst(__file__, [^.*/\(.*\)], [[\1]]) +# +# since then, since `dnl' doesn't match the pattern, it is returned +# with once quotation level less, so you lose! And since GNU M4 +# is one of the biggest junk in the whole universe wrt regexp, don't +# even think about using `?' or `\?'. Bah, `*' will do. +# Pleeeeeeeease, Gary, provide us with dirname and ERE! +# +# M4 recompiles the regular expression for every m4_bpatsubst, but __file__ +# rarely changes. Be fast - only compute the dirname when necessary; for +# autoconf alone, this shaves off several seconds in building testsuite. +m4_define([_AT_LINE_file]) +m4_define([_AT_LINE_base]) +m4_define([AT_LINE], +[m4_if(m4_defn([_AT_LINE_file]), __file__, [], + [m4_do([m4_define([_AT_LINE_file], __file__)], + [m4_define([_AT_LINE_base], + m4_bregexp(/__file__, [/\([^/]*\)$], [[\1]]))])])dnl +m4_defn([_AT_LINE_base]):__line__]) + +# _AT_LINE_ESCAPED +# ---------------- +# Same as AT_LINE, but already escaped for the shell. +m4_define([_AT_LINE_ESCAPED], ["AS_ESCAPE(m4_dquote(AT_LINE))"]) + + +# _AT_NORMALIZE_TEST_GROUP_NUMBER(SHELL-VAR) +# ------------------------------------------ +# Normalize SHELL-VAR so that its value has the same number of digits as +# all the other test group numbers. +m4_define([_AT_NORMALIZE_TEST_GROUP_NUMBER], +[ + eval 'while :; do + case $$1 in #( + '"$at_format"'*) break;; + esac + $1=0$$1 + done' +]) + +# _AT_DEFINE_INIT(NAME, [DEFINITION]) +# ----------------------------------- +# Define macro NAME to die if invoked prior to AT_INIT, and to DEFINITION +# after AT_INIT. +m4_define([_AT_DEFINE_INIT], +[m4_define($@)m4_pushdef([$1], [m4_fatal([$1: missing AT_INIT detected])])dnl +m4_append([_AT_DEFINE_INIT_LIST], [[$1]], [,])]) + +# _AT_DEFINE_SETUP(NAME, [DEFINITION]) +# ------------------------------------ +# Define macro NAME to die if invoked outside AT_SETUP/AT_CLEANUP, and +# to DEFINITION otherwise. +m4_define([_AT_DEFINE_SETUP], +[m4_define([$1], [m4_ifndef([AT_ingroup], + [m4_fatal([$1: missing AT_SETUP detected])])$2])]) + + +# AT_INIT([TESTSUITE-NAME]) +# ------------------------- +# Begin test suite. +m4_define([AT_INIT], +[m4_pushdef([AT_INIT], [m4_fatal([$0: invoked multiple times])])] +[m4_pattern_forbid([^_?AT_])] +[m4_pattern_allow([^_ATEOF$])] +[m4_ifndef([AT_PACKAGE_BUGREPORT], [m4_fatal( + [$1: AT_PACKAGE_BUGREPORT is missing, consider writing package.m4])])] +[m4_define([AT_TESTSUITE_NAME], + m4_defn([AT_PACKAGE_STRING])[ test suite]m4_ifval([$1], + [m4_expand([: $1])]))] +[m4_define([AT_ordinal], 0)] +[m4_define([AT_banner_ordinal], 0)] +[m4_define([AT_help_all], [])] +[m4_map_args([_m4_popdef], _AT_DEFINE_INIT_LIST)] +[m4_wrap([_AT_FINISH])] +[AS_INIT[]]dnl +dnl We don't use m4sh's BODY diversion, but AS_INIT sticks a banner there. +dnl This trick removes that banner, since it adds nothing to autotest. +[m4_cleardivert([BODY])]dnl +[AS_ME_PREPARE[]]dnl +[m4_divert_push([DEFAULTS])]dnl +[AT_COPYRIGHT(m4_defn([_AT_COPYRIGHT_YEARS]), [ +m4_copyright_condense])] +[AT_COPYRIGHT( +[This test suite is free software; the Free Software Foundation gives +unlimited permission to copy, distribute and modify it.], [m4_echo])] +[AS_PREPARE + +SHELL=${CONFIG_SHELL-/bin/sh} + +# How were we run? +at_cli_args="$[@]" + +m4_divert_push([BANNERS])dnl + +# Should we print banners? Yes if more than one test is run. +case $at_groups in #( + *$as_nl* ) + at_print_banners=: ;; #( + * ) at_print_banners=false ;; +esac +# Text for banner N, set to a single space once printed. +m4_divert_pop([BANNERS])dnl back to DEFAULTS +m4_divert_push([PREPARE_TESTS])dnl + +m4_text_box([Autotest shell functions.]) + +AS_FUNCTION_DESCRIBE([at_fn_banner], [NUMBER], +[Output banner NUMBER, provided the testsuite is running multiple groups +and this particular banner has not yet been printed.]) +at_fn_banner () +{ + $at_print_banners || return 0 + eval at_banner_text=\$at_banner_text_$[1] + test "x$at_banner_text" = "x " && return 0 + eval "at_banner_text_$[1]=\" \"" + if test -z "$at_banner_text"; then + $at_first || echo + else + AS_ECHO(["$as_nl$at_banner_text$as_nl"]) + fi +} # at_fn_banner + +AS_FUNCTION_DESCRIBE([at_fn_check_prepare_notrace], [REASON LINE], +[Perform AT_CHECK preparations for the command at LINE for an +untraceable command; REASON is the reason for disabling tracing.]) +at_fn_check_prepare_notrace () +{ + $at_trace_echo "Not enabling shell tracing (command contains $[1])" + AS_ECHO(["$[2]"]) >"$at_check_line_file" + at_check_trace=: at_check_filter=: + : >"$at_stdout"; : >"$at_stderr" +} + +AS_FUNCTION_DESCRIBE([at_fn_check_prepare_trace], [LINE], +[Perform AT_CHECK preparations for the command at LINE for a traceable +command.]) +at_fn_check_prepare_trace () +{ + AS_ECHO(["$[1]"]) >"$at_check_line_file" + at_check_trace=$at_traceon at_check_filter=$at_check_filter_trace + : >"$at_stdout"; : >"$at_stderr" +} + +AS_FUNCTION_DESCRIBE([at_fn_check_prepare_dynamic], [COMMAND LINE], +[Decide if COMMAND at LINE is traceable at runtime, and call the +appropriate preparation function.]) +at_fn_check_prepare_dynamic () +{ + case $[1] in + *$as_nl*) + at_fn_check_prepare_notrace 'an embedded newline' "$[2]" ;; + *) + at_fn_check_prepare_trace "$[2]" ;; + esac +} + +AS_FUNCTION_DESCRIBE([at_fn_filter_trace], [], +[Remove the lines in the file "$at_stderr" generated by "set -x" and print +them to stderr.]) +at_fn_filter_trace () +{ + mv "$at_stderr" "$at_stder1" + grep '^ *+' "$at_stder1" >&2 + grep -v '^ *+' "$at_stder1" >"$at_stderr" +} + +AS_FUNCTION_DESCRIBE([at_fn_log_failure], [FILE-LIST], +[Copy the files in the list on stdout with a "> " prefix, and exit the shell +with a failure exit code.]) +at_fn_log_failure () +{ + for file + do AS_ECHO(["$file:"]); sed 's/^/> /' "$file"; done + echo 1 > "$at_status_file" + exit 1 +} + +AS_FUNCTION_DESCRIBE([at_fn_check_skip], [EXIT-CODE LINE], +[Check whether EXIT-CODE is a special exit code (77 or 99), and if so exit +the test group subshell with that same exit code. Use LINE in any report +about test failure.]) +at_fn_check_skip () +{ + case $[1] in + 99) echo 99 > "$at_status_file"; at_failed=: + AS_ECHO(["$[2]: hard failure"]); exit 99;; + 77) echo 77 > "$at_status_file"; exit 77;; + esac +} + +AS_FUNCTION_DESCRIBE([at_fn_check_status], [EXPECTED EXIT-CODE LINE], +[Check whether EXIT-CODE is the EXPECTED exit code, and if so do nothing. +Otherwise, if it is 77 or 99, exit the test group subshell with that same +exit code; if it is anything else print an error message referring to LINE, +and fail the test.]) +at_fn_check_status () +{ +dnl This order ensures that we don't `skip' if we are precisely checking +dnl $? = 77 or $? = 99. + case $[2] in + $[1] ) ;; + 77) echo 77 > "$at_status_file"; exit 77;; + 99) echo 99 > "$at_status_file"; at_failed=: + AS_ECHO(["$[3]: hard failure"]); exit 99;; + *) AS_ECHO(["$[3]: exit code was $[2], expected $[1]"]) + at_failed=:;; + esac +} + +AS_FUNCTION_DESCRIBE([at_fn_diff_devnull], [FILE], +[Emit a diff between /dev/null and FILE. Uses "test -s" to avoid useless +diff invocations.]) +at_fn_diff_devnull () +{ + test -s "$[1]" || return 0 + $at_diff "$at_devnull" "$[1]" +} + +AS_FUNCTION_DESCRIBE([at_fn_test], [NUMBER], +[Parse out test NUMBER from the tail of this file.]) +at_fn_test () +{ + eval at_sed=\$at_sed$[1] + sed "$at_sed" "$at_myself" > "$at_test_source" +} + +AS_FUNCTION_DESCRIBE([at_fn_create_debugging_script], [], +[Create the debugging script $at_group_dir/run which will reproduce the +current test group.]) +at_fn_create_debugging_script () +{ + { + echo "#! /bin/sh" && + echo 'test "${ZSH_VERSION+set}" = set dnl +&& alias -g '\''${1+"$[@]"}'\''='\''"$[@]"'\''' && + AS_ECHO(["cd '$at_dir'"]) && + AS_ECHO(["exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d ]dnl +[$at_debug_args $at_group \${1+\"\$[@]\"}"]) && + echo 'exit 1' + } >"$at_group_dir/run" && + chmod +x "$at_group_dir/run" +} + +m4_text_box([End of autotest shell functions.]) +m4_divert_pop([PREPARE_TESTS])dnl back to DEFAULTS + +# Not all shells have the 'times' builtin; the subshell is needed to make +# sure we discard the 'times: not found' message from the shell. +at_times_p=false +(times) >/dev/null 2>&1 && at_times_p=: + +# CLI Arguments to pass to the debugging scripts. +at_debug_args= +# -e sets to true +at_errexit_p=false +# Shall we be verbose? ':' means no, empty means yes. +at_verbose=: +at_quiet= +# Running several jobs in parallel, 0 means as many as test groups. +at_jobs=1 +at_traceon=: +at_trace_echo=: +at_check_filter_trace=: + +# Shall we keep the debug scripts? Must be `:' when the suite is +# run by a debug script, so that the script doesn't remove itself. +at_debug_p=false +# Display help message? +at_help_p=false +# Display the version message? +at_version_p=false +# List test groups? +at_list_p=false +# --clean +at_clean=false +# Test groups to run +at_groups= +# Whether to rerun failed tests. +at_recheck= +# Whether a write failure occurred +at_write_fail=0 + +# The directory we run the suite in. Default to . if no -C option. +at_dir=`pwd` +# An absolute reference to this testsuite script. +dnl m4-double quote, to preserve [] +[case $as_myself in + [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;; + * ) at_myself=$at_dir/$as_myself ;; +esac] +# Whether -C is in effect. +at_change_dir=false +m4_divert_pop([DEFAULTS])dnl +m4_define([_AT_FINISH], +[m4_ifdef([AT_ingroup], [m4_fatal([missing AT_CLEANUP detected])])dnl +m4_divert_text([DEFAULTS], +[ +# Whether to enable colored test results. +at_color=m4_ifdef([AT_color], [AT_color], [no]) +# List of the tested programs. +at_tested='m4_ifdef([AT_tested], + [m4_translit(m4_dquote(m4_defn([AT_tested])), [ ], m4_newline)])' +# As many question marks as there are digits in the last test group number. +# Used to normalize the test group numbers so that `ls' lists them in +# numerical order. +at_format='m4_bpatsubst(m4_defn([AT_ordinal]), [.], [?])' +# Description of all the test groups. +at_help_all="AS_ESCAPE(m4_dquote(m4_defn([AT_help_all])))" +# List of the all the test groups. +at_groups_all=`AS_ECHO(["$at_help_all"]) | sed 's/;.*//'` + +AS_FUNCTION_DESCRIBE([at_fn_validate_ranges], [NAME...], +[Validate and normalize the test group number contained in each +variable NAME. Leading zeroes are treated as decimal.]) +at_fn_validate_ranges () +{ + for at_grp + do + eval at_value=\$$at_grp + if test $at_value -lt 1 || test $at_value -gt AT_ordinal; then + AS_ECHO(["invalid test group: $at_value"]) >&2 + exit 1 + fi + case $at_value in + 0*) # We want to treat leading 0 as decimal, like expr and test, but + # AS_VAR_ARITH treats it as octal if it uses $(( )). + # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the + # expr fork, but it is not worth the effort to determine if the + # shell supports XSI when the user can just avoid leading 0. + eval $at_grp='`expr $at_value + 0`' ;; + esac + done +}])])dnl +m4_divert_push([PARSE_ARGS])dnl + +at_prev= +for at_option +do + # If the previous option needs an argument, assign it. + if test -n "$at_prev"; then + at_option=$at_prev=$at_option + at_prev= + fi + + case $at_option in + *=?*) at_optarg=`expr "X$at_option" : '[[^=]]*=\(.*\)'` ;; + *) at_optarg= ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $at_option in + --help | -h ) + at_help_p=: + ;; + + --list | -l ) + at_list_p=: + ;; + + --version | -V ) + at_version_p=: + ;; + + --clean | -c ) + at_clean=: + ;; + + --color ) + at_color=always + ;; + --color=* ) + case $at_optarg in + no | never | none) at_color=never ;; + auto | tty | if-tty) at_color=auto ;; + always | yes | force) at_color=always ;; + *) at_optname=`echo " $at_option" | sed 's/^ //; s/=.*//'` + AS_ERROR([unrecognized argument to $at_optname: $at_optarg]) ;; + esac + ;; + + --debug | -d ) + at_debug_p=: + ;; + + --errexit | -e ) + at_debug_p=: + at_errexit_p=: + ;; + + --verbose | -v ) + at_verbose=; at_quiet=: + ;; + + --trace | -x ) + at_traceon='set -x' + at_trace_echo=echo + at_check_filter_trace=at_fn_filter_trace + ;; + + [[0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9]]) + at_fn_validate_ranges at_option + AS_VAR_APPEND([at_groups], ["$at_option$as_nl"]) + ;; + + # Ranges + [[0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-]) + at_range_start=`echo $at_option |tr -d X-` + at_fn_validate_ranges at_range_start + at_range=`AS_ECHO(["$at_groups_all"]) | \ + sed -ne '/^'$at_range_start'$/,$p'` + AS_VAR_APPEND([at_groups], ["$at_range$as_nl"]) + ;; + + [-[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9]]) + at_range_end=`echo $at_option |tr -d X-` + at_fn_validate_ranges at_range_end + at_range=`AS_ECHO(["$at_groups_all"]) | \ + sed -ne '1,/^'$at_range_end'$/p'` + AS_VAR_APPEND([at_groups], ["$at_range$as_nl"]) + ;; + + [[0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9]] | \ + [[0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9]] | \ + [[0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9]] | \ + [[0-9][0-9][0-9]-[0-9][0-9][0-9]] | \ + [[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]] | \ + [[0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]] ) + at_range_start=`expr $at_option : '\(.*\)-'` + at_range_end=`expr $at_option : '.*-\(.*\)'` + if test $at_range_start -gt $at_range_end; then + at_tmp=$at_range_end + at_range_end=$at_range_start + at_range_start=$at_tmp + fi + at_fn_validate_ranges at_range_start at_range_end + at_range=`AS_ECHO(["$at_groups_all"]) | \ + sed -ne '/^'$at_range_start'$/,/^'$at_range_end'$/p'` + AS_VAR_APPEND([at_groups], ["$at_range$as_nl"]) + ;; + + # Directory selection. + --directory | -C ) + at_prev=--directory + ;; + --directory=* ) + at_change_dir=: + at_dir=$at_optarg + if test x- = "x$at_dir" ; then + at_dir=./- + fi + ;; + + # Parallel execution. + --jobs | -j ) + at_jobs=0 + ;; + --jobs=* | -j[[0-9]]* ) + if test -n "$at_optarg"; then + at_jobs=$at_optarg + else + at_jobs=`expr X$at_option : 'X-j\(.*\)'` + fi + case $at_jobs in *[[!0-9]]*) + at_optname=`echo " $at_option" | sed 's/^ //; s/[[0-9=]].*//'` + AS_ERROR([non-numeric argument to $at_optname: $at_jobs]) ;; + esac + ;; + + # Keywords. + --keywords | -k ) + at_prev=--keywords + ;; + --keywords=* ) + at_groups_selected=$at_help_all + at_save_IFS=$IFS + IFS=, + set X $at_optarg + shift + IFS=$at_save_IFS + for at_keyword + do + at_invert= + case $at_keyword in + '!'*) + at_invert="-v" + at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'` + ;; + esac + # It is on purpose that we match the test group titles too. + at_groups_selected=`AS_ECHO(["$at_groups_selected"]) | + grep -i $at_invert ["^[1-9][^;]*;.*[; ]$at_keyword[ ;]"]` + done + # Smash the keywords. + at_groups_selected=`AS_ECHO(["$at_groups_selected"]) | sed 's/;.*//'` + AS_VAR_APPEND([at_groups], ["$at_groups_selected$as_nl"]) + ;; + --recheck) + at_recheck=: + ;; +m4_divert_pop([PARSE_ARGS])dnl +dnl Process *=* last to allow for user specified --option=* type arguments. +m4_divert_push([PARSE_ARGS_END])dnl + + *=*) + at_envvar=`expr "x$at_option" : 'x\([[^=]]*\)='` + # Reject names that are not valid shell variable names. + case $at_envvar in + '' | [[0-9]]* | *[[!_$as_cr_alnum]]* ) + AS_ERROR([invalid variable name: `$at_envvar']) ;; + esac + at_value=`AS_ECHO(["$at_optarg"]) | sed "s/'/'\\\\\\\\''/g"` + # Export now, but save eval for later and for debug scripts. + export $at_envvar + AS_VAR_APPEND([at_debug_args], [" $at_envvar='$at_value'"]) + ;; + + *) AS_ECHO(["$as_me: invalid option: $at_option"]) >&2 + AS_ECHO(["Try \`$[0] --help' for more information."]) >&2 + exit 1 + ;; + esac +done + +# Verify our last option didn't require an argument +AS_IF([test -n "$at_prev"], [AS_ERROR([`$at_prev' requires an argument])]) + +# The file containing the suite. +at_suite_log=$at_dir/$as_me.log + +# Selected test groups. +if test -z "$at_groups$at_recheck"; then + at_groups=$at_groups_all +else + if test -n "$at_recheck" && test -r "$at_suite_log"; then + at_oldfails=`sed -n [' + /^Failed tests:$/,/^Skipped tests:$/{ + s/^[ ]*\([1-9][0-9]*\):.*/\1/p + } + /^Unexpected passes:$/,/^## Detailed failed tests/{ + s/^[ ]*\([1-9][0-9]*\):.*/\1/p + } + /^## Detailed failed tests/q + '] "$at_suite_log"` + AS_VAR_APPEND([at_groups], ["$at_oldfails$as_nl"]) + fi + # Sort the tests, removing duplicates. + at_groups=`AS_ECHO(["$at_groups"]) | sort -nu | sed '/^$/d'` +fi + +if test x"$at_color" = xalways \ + || { test x"$at_color" = xauto && test -t 1; }; then + at_red=`printf '\033@<:@0;31m'` + at_grn=`printf '\033@<:@0;32m'` + at_lgn=`printf '\033@<:@1;32m'` + at_blu=`printf '\033@<:@1;34m'` + at_std=`printf '\033@<:@m'` +else + at_red= at_grn= at_lgn= at_blu= at_std= +fi +m4_divert_pop([PARSE_ARGS_END])dnl +m4_divert_push([HELP])dnl + +# Help message. +if $at_help_p; then + cat <<_ATEOF || at_write_fail=1 +Usage: $[0] [[OPTION]... [VARIABLE=VALUE]... [TESTS]] + +Run all the tests, or the selected TESTS, given by numeric ranges, and +save a detailed log file. Upon failure, create debugging scripts. + +Do not change environment variables directly. Instead, set them via +command line arguments. Set \`AUTOTEST_PATH' to select the executables +to exercise. Each relative directory is expanded as build and source +directories relative to the top level of this distribution. +E.g., from within the build directory /tmp/foo-1.0, invoking this: + + $ $[0] AUTOTEST_PATH=bin + +is equivalent to the following, assuming the source directory is /src/foo-1.0: + + PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH $[0] +_ATEOF +m4_divert_pop([HELP])dnl +m4_divert_push([HELP_MODES])dnl +cat <<_ATEOF || at_write_fail=1 + +Operation modes: + -h, --help print the help message, then exit + -V, --version print version number, then exit + -c, --clean remove all the files this test suite might create and exit + -l, --list describes all the tests, or the selected TESTS +_ATEOF +m4_divert_pop([HELP_MODES])dnl +m4_wrap([m4_divert_push([HELP_TUNING_BEGIN])dnl +cat <<_ATEOF || at_write_fail=1 + +dnl extra quoting prevents emacs whitespace mode from putting tabs in output +Execution tuning: + -C, --directory=DIR +[ change to directory DIR before starting] + --color[[=never|auto|always]] +[ ]m4_ifdef([AT_color], + [disable colored test results, or enable even without terminal], + [enable colored test results on terminal, or always]) + -j, --jobs[[=N]] +[ Allow N jobs at once; infinite jobs with no arg (default 1)] + -k, --keywords=KEYWORDS +[ select the tests matching all the comma-separated KEYWORDS] +[ multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD] + --recheck select all tests that failed or passed unexpectedly last time + -e, --errexit abort as soon as a test fails; implies --debug + -v, --verbose force more detailed output +[ default for debugging scripts] + -d, --debug inhibit clean up and top-level logging +[ default for debugging scripts] + -x, --trace enable tests shell tracing +_ATEOF +m4_divert_pop([HELP_TUNING_BEGIN])])dnl +m4_divert_push([HELP_END])dnl +cat <<_ATEOF || at_write_fail=1 + +Report bugs to <AT_PACKAGE_BUGREPORT>.dnl +m4_ifdef([AT_PACKAGE_NAME], +[m4_ifset([AT_PACKAGE_URL], [ +m4_defn([AT_PACKAGE_NAME]) home page: <AT_PACKAGE_URL>.])dnl +m4_if(m4_index(m4_defn([AT_PACKAGE_NAME]), [GNU ]), [0], [ +General help using GNU software: <http://www.gnu.org/gethelp/>.])]) +_ATEOF + exit $at_write_fail +fi + +# List of tests. +if $at_list_p; then + cat <<_ATEOF || at_write_fail=1 +AT_TESTSUITE_NAME test groups: + + NUM: FILE-NAME:LINE TEST-GROUP-NAME + KEYWORDS + +_ATEOF + # Pass an empty line as separator between selected groups and help. + AS_ECHO(["$at_groups$as_nl$as_nl$at_help_all"]) | + awk 'NF == 1 && FS != ";" { + selected[[$ 1]] = 1 + next + } + /^$/ { FS = ";" } + NF > 0 { + if (selected[[$ 1]]) { + printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3 + if ($ 4) { + lmax = 79 + indent = " " + line = indent + len = length (line) + n = split ($ 4, a, " ") + for (i = 1; i <= n; i++) { + l = length (a[[i]]) + 1 + if (i > 1 && len + l > lmax) { + print line + line = indent " " a[[i]] + len = length (line) + } else { + line = line " " a[[i]] + len += l + } + } + if (n) + print line + } + } + }' || at_write_fail=1 + exit $at_write_fail +fi +m4_divert_pop([HELP_END])dnl +m4_divert_push([VERSION])dnl +if $at_version_p; then + AS_ECHO(["$as_me (AT_PACKAGE_STRING)"]) && + cat <<\_ATEOF || at_write_fail=1 +m4_divert_pop([VERSION])dnl +m4_divert_push([VERSION_END])dnl +_ATEOF + exit $at_write_fail +fi +m4_divert_pop([VERSION_END])dnl +m4_divert_push([TESTS_BEGIN])dnl + +# Take any -C into account. +if $at_change_dir ; then + test x != "x$at_dir" && cd "$at_dir" \ + || AS_ERROR([unable to change directory]) + at_dir=`pwd` +fi + +# Load the config files for any default variable assignments. +for at_file in atconfig atlocal +do + test -r $at_file || continue + . ./$at_file || AS_ERROR([invalid content: $at_file]) +done + +# Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix: +: "${at_top_build_prefix=$at_top_builddir}" + +# Perform any assignments requested during argument parsing. +eval "$at_debug_args" + +# atconfig delivers names relative to the directory the test suite is +# in, but the groups themselves are run in testsuite-dir/group-dir. +if test -n "$at_top_srcdir"; then + builddir=../.. + for at_dir_var in srcdir top_srcdir top_build_prefix + do + AS_VAR_COPY([at_val], [at_$at_dir_var]) + case $at_val in + [[\\/$]]* | ?:[[\\/]]* ) at_prefix= ;; + *) at_prefix=../../ ;; + esac + AS_VAR_SET([$at_dir_var], [$at_prefix$at_val]) + done +fi + +m4_text_box([Directory structure.]) + +# This is the set of directories and files used by this script +# (non-literals are capitalized): +# +# TESTSUITE - the testsuite +# TESTSUITE.log - summarizes the complete testsuite run +# TESTSUITE.dir/ - created during a run, remains after -d or failed test +# + at-groups/ - during a run: status of all groups in run +# | + NNN/ - during a run: meta-data about test group NNN +# | | + check-line - location (source file and line) of current AT_CHECK +# | | + status - exit status of current AT_CHECK +# | | + stdout - stdout of current AT_CHECK +# | | + stder1 - stderr, including trace +# | | + stderr - stderr, with trace filtered out +# | | + test-source - portion of testsuite that defines group +# | | + times - timestamps for computing duration +# | | + pass - created if group passed +# | | + xpass - created if group xpassed +# | | + fail - created if group failed +# | | + xfail - created if group xfailed +# | | + skip - created if group skipped +# + at-stop - during a run: end the run if this file exists +# + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction +# + 0..NNN/ - created for each group NNN, remains after -d or failed test +# | + TESTSUITE.log - summarizes the group results +# | + ... - files created during the group + +# The directory the whole suite works in. +# Should be absolute to let the user `cd' at will. +at_suite_dir=$at_dir/$as_me.dir +# The file containing the suite ($at_dir might have changed since earlier). +at_suite_log=$at_dir/$as_me.log +# The directory containing helper files per test group. +at_helper_dir=$at_suite_dir/at-groups +# Stop file: if it exists, do not start new jobs. +at_stop_file=$at_suite_dir/at-stop +# The fifo used for the job dispatcher. +at_job_fifo=$at_suite_dir/at-job-fifo + +if $at_clean; then + test -d "$at_suite_dir" && + find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; + rm -f -r "$at_suite_dir" "$at_suite_log" + exit $? +fi + +# Don't take risks: use only absolute directories in PATH. +# +# For stand-alone test suites (ie. atconfig was not found), +# AUTOTEST_PATH is relative to `.'. +# +# For embedded test suites, AUTOTEST_PATH is relative to the top level +# of the package. Then expand it into build/src parts, since users +# may create executables in both places. +AUTOTEST_PATH=`AS_ECHO(["$AUTOTEST_PATH"]) | sed "s|:|$PATH_SEPARATOR|g"` +at_path= +_AS_PATH_WALK([$AUTOTEST_PATH $PATH], +[test -n "$at_path" && AS_VAR_APPEND([at_path], [$PATH_SEPARATOR]) +case $as_dir in + [[\\/]]* | ?:[[\\/]]* ) + AS_VAR_APPEND([at_path], ["$as_dir"]) + ;; + * ) + if test -z "$at_top_build_prefix"; then + # Stand-alone test suite. + AS_VAR_APPEND([at_path], ["$as_dir"]) + else + # Embedded test suite. + AS_VAR_APPEND([at_path], ["$at_top_build_prefix$as_dir$PATH_SEPARATOR"]) + AS_VAR_APPEND([at_path], ["$at_top_srcdir/$as_dir"]) + fi + ;; +esac]) + +# Now build and simplify PATH. +# +# There might be directories that don't exist, but don't redirect +# builtins' (eg., cd) stderr directly: Ultrix's sh hates that. +at_new_path= +_AS_PATH_WALK([$at_path], +[test -d "$as_dir" || continue +case $as_dir in + [[\\/]]* | ?:[[\\/]]* ) ;; + * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;; +esac +case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in + *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;; + $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;; + *) AS_VAR_APPEND([at_new_path], ["$PATH_SEPARATOR$as_dir"]) ;; +esac]) +PATH=$at_new_path +export PATH + +# Setting up the FDs. +m4_define([AS_MESSAGE_LOG_FD], [5]) +dnl The parent needs two fds to the same fifo, otherwise, there is a race +dnl where the parent can read the fifo before a child opens it for writing +m4_define([AT_JOB_FIFO_IN_FD], [6]) +m4_define([AT_JOB_FIFO_OUT_FD], [7]) +[#] AS_MESSAGE_LOG_FD is the log file. Not to be overwritten if `-d'. +if $at_debug_p; then + at_suite_log=/dev/null +else + : >"$at_suite_log" +fi +exec AS_MESSAGE_LOG_FD>>"$at_suite_log" + +# Banners and logs. +AS_BOX(m4_defn([AT_TESTSUITE_NAME])[.]) +{ + AS_BOX(m4_defn([AT_TESTSUITE_NAME])[.]) + echo + + AS_ECHO(["$as_me: command line was:"]) + AS_ECHO([" \$ $[0] $at_cli_args"]) + echo + + # If ChangeLog exists, list a few lines in case it might help determining + # the exact version. + if test -n "$at_top_srcdir" && test -f "$at_top_srcdir/ChangeLog"; then + AS_BOX([ChangeLog.]) + echo + sed 's/^/| /;10q' "$at_top_srcdir/ChangeLog" + echo + fi + + AS_UNAME + echo + + # Contents of the config files. + for at_file in atconfig atlocal + do + test -r $at_file || continue + AS_ECHO(["$as_me: $at_file:"]) + sed 's/^/| /' $at_file + echo + done +} >&AS_MESSAGE_LOG_FD + +m4_divert_pop([TESTS_BEGIN])dnl +m4_divert_push([PREPARE_TESTS])dnl +{ + AS_BOX([Tested programs.]) + echo +} >&AS_MESSAGE_LOG_FD + +# Report what programs are being tested. +for at_program in : $at_tested +do + test "$at_program" = : && continue + case $at_program in + [[\\/]* | ?:[\\/]* ) $at_program_=$at_program ;;] + * ) + _AS_PATH_WALK([$PATH], [test -f "$as_dir/$at_program" && break]) + at_program_=$as_dir/$at_program ;; + esac + if test -f "$at_program_"; then + { + AS_ECHO(["$at_srcdir/AT_LINE: $at_program_ --version"]) + "$at_program_" --version </dev/null + echo + } >&AS_MESSAGE_LOG_FD 2>&1 + else + AS_ERROR([cannot find $at_program]) + fi +done + +{ + AS_BOX([Running the tests.]) +} >&AS_MESSAGE_LOG_FD + +at_start_date=`date` +at_start_time=`date +%s 2>/dev/null` +AS_ECHO(["$as_me: starting at: $at_start_date"]) >&AS_MESSAGE_LOG_FD +m4_divert_pop([PREPARE_TESTS])dnl +m4_divert_push([TESTS])dnl + +# Create the master directory if it doesn't already exist. +AS_MKDIR_P(["$at_suite_dir"]) || + AS_ERROR([cannot create `$at_suite_dir']) + +# Can we diff with `/dev/null'? DU 5.0 refuses. +if diff /dev/null /dev/null >/dev/null 2>&1; then + at_devnull=/dev/null +else + at_devnull=$at_suite_dir/devnull + >"$at_devnull" +fi + +# Use `diff -u' when possible. +if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff" +then + at_diff='diff -u' +else + at_diff=diff +fi + +# Get the last needed group. +for at_group in : $at_groups; do :; done + +# Extract the start and end lines of each test group at the tail +# of this file +awk ' +BEGIN { FS="" } +/^@%:@AT_START_/ { + start = NR +} +/^@%:@AT_STOP_/ { + test = substr ($ 0, 10) + print "at_sed" test "=\"1," start "d;" (NR-1) "q\"" + if (test == "'"$at_group"'") exit +}' "$at_myself" > "$at_suite_dir/at-source-lines" && +. "$at_suite_dir/at-source-lines" || + AS_ERROR([cannot create test line number cache]) +rm -f "$at_suite_dir/at-source-lines" + +# Set number of jobs for `-j'; avoid more jobs than test groups. +set X $at_groups; shift; at_max_jobs=$[@%:@] +if test $at_max_jobs -eq 0; then + at_jobs=1 +fi +if test $at_jobs -ne 1 && + { test $at_jobs -eq 0 || test $at_jobs -gt $at_max_jobs; }; then + at_jobs=$at_max_jobs +fi + +# If parallel mode, don't output banners, don't split summary lines. +if test $at_jobs -ne 1; then + at_print_banners=false + at_quiet=: +fi + +# Set up helper dirs. +rm -rf "$at_helper_dir" && +mkdir "$at_helper_dir" && +cd "$at_helper_dir" && +{ test -z "$at_groups" || mkdir $at_groups; } || +AS_ERROR([testsuite directory setup failed]) + +# Functions for running a test group. We leave the actual +# test group execution outside of a shell function in order +# to avoid hitting zsh 4.x exit status bugs. + +AS_FUNCTION_DESCRIBE([at_fn_group_prepare], [], +[Prepare for running a test group.]) +at_fn_group_prepare () +{ + # The directory for additional per-group helper files. + at_job_dir=$at_helper_dir/$at_group + # The file containing the location of the last AT_CHECK. + at_check_line_file=$at_job_dir/check-line + # The file containing the exit status of the last command. + at_status_file=$at_job_dir/status + # The files containing the output of the tested commands. + at_stdout=$at_job_dir/stdout + at_stder1=$at_job_dir/stder1 + at_stderr=$at_job_dir/stderr + # The file containing the code for a test group. + at_test_source=$at_job_dir/test-source + # The file containing dates. + at_times_file=$at_job_dir/times + + # Be sure to come back to the top test directory. + cd "$at_suite_dir" + + # Clearly separate the test groups when verbose. + $at_first || $at_verbose echo + + at_group_normalized=$at_group + _AT_NORMALIZE_TEST_GROUP_NUMBER(at_group_normalized) + + # Create a fresh directory for the next test group, and enter. + # If one already exists, the user may have invoked ./run from + # within that directory; we remove the contents, but not the + # directory itself, so that we aren't pulling the rug out from + # under the shell's notion of the current directory. + at_group_dir=$at_suite_dir/$at_group_normalized + at_group_log=$at_group_dir/$as_me.log + _AS_CLEAN_DIR("$at_group_dir") || + AS_WARN([test directory for $at_group_normalized could not be cleaned]) + # Be tolerant if the above `rm' was not able to remove the directory. + AS_MKDIR_P(["$at_group_dir"]) + + echo 0 > "$at_status_file" + + # In verbose mode, append to the log file *and* show on + # the standard output; in quiet mode only write to the log. + if test -z "$at_verbose"; then + at_tee_pipe='tee -a "$at_group_log"' + else + at_tee_pipe='cat >> "$at_group_log"' + fi +} + +AS_FUNCTION_DESCRIBE([at_fn_group_banner], [[ORDINAL LINE DESC PAD [BANNER]]], +[Declare the test group ORDINAL, located at LINE with group description +DESC, and residing under BANNER. Use PAD to align the status column.]) +at_fn_group_banner () +{ + at_setup_line="$[2]" + test -n "$[5]" && at_fn_banner $[5] + at_desc="$[3]" + case $[1] in + [[0-9]]) at_desc_line=" $[1]: ";; + [[0-9][0-9]]) at_desc_line=" $[1]: " ;; + [*]) at_desc_line="$[1]: " ;; + esac + AS_VAR_APPEND([at_desc_line], ["$[3]$[4]"]) + $at_quiet AS_ECHO_N(["$at_desc_line"]) + echo "# -*- compilation -*-" >> "$at_group_log" +} + +AS_FUNCTION_DESCRIBE([at_fn_group_postprocess], [], +[Perform cleanup after running a test group.]) +at_fn_group_postprocess () +{ + # Be sure to come back to the suite directory, in particular + # since below we might `rm' the group directory we are in currently. + cd "$at_suite_dir" + + if test ! -f "$at_check_line_file"; then + sed "s/^ */$as_me: WARNING: /" <<_ATEOF + A failure happened in a test group before any test could be + run. This means that test suite is improperly designed. Please + report this failure to <AT_PACKAGE_BUGREPORT>. +_ATEOF + AS_ECHO(["$at_setup_line"]) >"$at_check_line_file" + at_status=99 + fi + $at_verbose AS_ECHO_N(["$at_group. $at_setup_line: "]) + AS_ECHO_N(["$at_group. $at_setup_line: "]) >> "$at_group_log" + case $at_xfail:$at_status in + yes:0) + at_msg="UNEXPECTED PASS" + at_res=xpass + at_errexit=$at_errexit_p + at_color=$at_red + ;; + no:0) + at_msg="ok" + at_res=pass + at_errexit=false + at_color=$at_grn + ;; + *:77) + at_msg='skipped ('`cat "$at_check_line_file"`')' + at_res=skip + at_errexit=false + at_color=$at_blu + ;; + no:* | *:99) + at_msg='FAILED ('`cat "$at_check_line_file"`')' + at_res=fail + at_errexit=$at_errexit_p + at_color=$at_red + ;; + yes:*) + at_msg='expected failure ('`cat "$at_check_line_file"`')' + at_res=xfail + at_errexit=false + at_color=$at_lgn + ;; + esac + echo "$at_res" > "$at_job_dir/$at_res" + # In parallel mode, output the summary line only afterwards. + if test $at_jobs -ne 1 && test -n "$at_verbose"; then + AS_ECHO(["$at_desc_line $at_color$at_msg$at_std"]) + else + # Make sure there is a separator even with long titles. + AS_ECHO([" $at_color$at_msg$at_std"]) + fi + at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg" + case $at_status in + 0|77) + # $at_times_file is only available if the group succeeded. + # We're not including the group log, so the success message + # is written in the global log separately. But we also + # write to the group log in case they're using -d. + if test -f "$at_times_file"; then + at_log_msg="$at_log_msg ("`sed 1d "$at_times_file"`')' + rm -f "$at_times_file" + fi + AS_ECHO(["$at_log_msg"]) >> "$at_group_log" + AS_ECHO(["$at_log_msg"]) >&AS_MESSAGE_LOG_FD + + # Cleanup the group directory, unless the user wants the files + # or the success was unexpected. + if $at_debug_p || test $at_res = xpass; then + at_fn_create_debugging_script + if test $at_res = xpass && $at_errexit; then + echo stop > "$at_stop_file" + fi + else + if test -d "$at_group_dir"; then + find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; + rm -fr "$at_group_dir" + fi + rm -f "$at_test_source" + fi + ;; + *) + # Upon failure, include the log into the testsuite's global + # log. The failure message is written in the group log. It + # is later included in the global log. + AS_ECHO(["$at_log_msg"]) >> "$at_group_log" + + # Upon failure, keep the group directory for autopsy, and create + # the debugging script. With -e, do not start any further tests. + at_fn_create_debugging_script + if $at_errexit; then + echo stop > "$at_stop_file" + fi + ;; + esac +} + + +m4_text_box([Driver loop.]) + +dnl Catching signals correctly: +dnl +dnl The first idea was: trap the signal, send it to all spawned jobs, +dnl then reset the handler and reraise the signal for ourselves. +dnl However, before exiting, ksh will then send the signal to all +dnl process group members, potentially killing the outer testsuite +dnl and/or the 'make' process driving us. +dnl So now the strategy is: trap the signal, send it to all spawned jobs, +dnl then exit the script with the right status. +dnl +dnl In order to let the jobs know about the signal, we cannot just send it +dnl to the current process group (kill $SIG 0), for the same reason as above. +dnl Also, it does not reliably stop the suite to send the signal to the +dnl spawned processes, because they might not transport it further +dnl (maybe this can be fixed?). +dnl +dnl So what we do is enable shell job control if available, which causes the +dnl shell to start each parallel task as its own shell job, thus as a new +dnl process group leader. We then send the signal to all new process groups. + +dnl Do we have job control? +if (set -m && set +m && set +b) >/dev/null 2>&1; then + set +b + at_job_control_on='set -m' at_job_control_off='set +m' at_job_group=- +else + at_job_control_on=: at_job_control_off=: at_job_group= +fi + +for at_signal in 1 2 15; do +dnl This signal handler is not suitable for PIPE: it causes writes. +dnl The code that was interrupted may have the errexit, monitor, or xtrace +dnl flags enabled, so sanitize. + trap 'set +x; set +e + $at_job_control_off + at_signal='"$at_signal"' +dnl Safety belt: even with runaway processes, prevent starting new jobs. + echo stop > "$at_stop_file" +dnl Do not enter this area multiple times, do not kill self prematurely. + trap "" $at_signal +dnl Gather process group IDs of currently running jobs. + at_pgids= + for at_pgid in `jobs -p 2>/dev/null`; do + at_pgids="$at_pgids $at_job_group$at_pgid" + done +dnl Ignore `kill' errors, as some jobs may have finished in the meantime. + test -z "$at_pgids" || kill -$at_signal $at_pgids 2>/dev/null +dnl wait until all jobs have exited. + wait +dnl Status output. Do this after waiting for the jobs, for ordered output. +dnl Avoid scribbling onto the end of a possibly incomplete line. + if test "$at_jobs" -eq 1 || test -z "$at_verbose"; then + echo >&2 + fi + at_signame=`kill -l $at_signal 2>&1 || echo $at_signal` + set x $at_signame + test $# -gt 2 && at_signame=$at_signal + AS_WARN([caught signal $at_signame, bailing out]) +dnl Do not reinstall the default handler here and reraise the signal to +dnl let the default handler do its job, see the note about ksh above. +dnl trap - $at_signal +dnl kill -$at_signal $$ +dnl Instead, exit with appropriate status. + AS_VAR_ARITH([exit_status], [128 + $at_signal]) + AS_EXIT([$exit_status])' $at_signal +done + +rm -f "$at_stop_file" +at_first=: + +if test $at_jobs -ne 1 && + rm -f "$at_job_fifo" && + test -n "$at_job_group" && + ( mkfifo "$at_job_fifo" && trap 'exit 1' PIPE STOP TSTP ) 2>/dev/null +then + # FIFO job dispatcher. + +dnl Since we use job control, we need to propagate TSTP. +dnl This handler need not be used for serial execution. +dnl Again, we should stop all processes in the job groups, otherwise +dnl the stopping will not be effective while one test group is running. +dnl Apparently ksh does not honor the TSTP trap. +dnl As a safety measure, not use the same variable names as in the +dnl termination handlers above, one might get called during execution +dnl of the other. + trap 'at_pids= + for at_pid in `jobs -p`; do + at_pids="$at_pids $at_job_group$at_pid" + done +dnl Send it to all spawned jobs, ignoring those finished meanwhile. + if test -n "$at_pids"; then +dnl Unfortunately, ksh93 fork-bombs when we send TSTP, so send STOP +dnl if this might be ksh (STOP prevents possible TSTP handlers inside +dnl AT_CHECKs from running). Then stop ourselves. + at_sig=TSTP + test "${TMOUT+set}" = set && at_sig=STOP + kill -$at_sig $at_pids 2>/dev/null + fi + kill -STOP $$ +dnl We got a CONT, so let's go again. Passing this to all processes +dnl in the groups is necessary (because we stopped them), but it may +dnl cause changed test semantics; e.g., a sleep will be interrupted. + test -z "$at_pids" || kill -CONT $at_pids 2>/dev/null' TSTP + + echo + # Turn jobs into a list of numbers, starting from 1. + at_joblist=`AS_ECHO(["$at_groups"]) | sed -n 1,${at_jobs}p` + + set X $at_joblist + shift + for at_group in $at_groups; do +dnl Enable job control only for spawning the test group: +dnl Let the jobs to run in separate process groups, but +dnl avoid all the status output by the shell. + $at_job_control_on 2>/dev/null + ( + # Start one test group. + $at_job_control_off +dnl First child must open the fifo to avoid blocking parent; all other +dnl children inherit it already opened from the parent. + if $at_first; then + exec AT_JOB_FIFO_OUT_FD>"$at_job_fifo" + else +dnl Children do not need parent's copy of fifo. + exec AT_JOB_FIFO_IN_FD<&- + fi +dnl When a child receives PIPE, be sure to write back the token, +dnl so the master does not hang waiting for it. +dnl errexit and xtrace should not be set in this shell instance, +dnl except as debug measures. However, shells such as dash may +dnl optimize away the _AT_CHECK subshell, so normalize here. + trap 'set +x; set +e +dnl Ignore PIPE signals that stem from writing back the token. + trap "" PIPE + echo stop > "$at_stop_file" + echo >&AT_JOB_FIFO_OUT_FD +dnl Do not reraise the default PIPE handler. +dnl It wreaks havoc with ksh, see above. +dnl trap - 13 +dnl kill -13 $$ + AS_EXIT([141])' PIPE + at_fn_group_prepare + if cd "$at_group_dir" && + at_fn_test $at_group && + . "$at_test_source" + then :; else + AS_WARN([unable to parse test group: $at_group]) + at_failed=: + fi + at_fn_group_postprocess + echo >&AT_JOB_FIFO_OUT_FD + ) & + $at_job_control_off + if $at_first; then + at_first=false + exec AT_JOB_FIFO_IN_FD<"$at_job_fifo" AT_JOB_FIFO_OUT_FD>"$at_job_fifo" + fi + shift # Consume one token. + if test $[@%:@] -gt 0; then :; else + read at_token <&AT_JOB_FIFO_IN_FD || break + set x $[*] + fi + test -f "$at_stop_file" && break + done + exec AT_JOB_FIFO_OUT_FD>&- + # Read back the remaining ($at_jobs - 1) tokens. + set X $at_joblist + shift + if test $[@%:@] -gt 0; then + shift + for at_job + do + read at_token + done <&AT_JOB_FIFO_IN_FD + fi + exec AT_JOB_FIFO_IN_FD<&- + wait +else + # Run serially, avoid forks and other potential surprises. + for at_group in $at_groups; do + at_fn_group_prepare + if cd "$at_group_dir" && + at_fn_test $at_group && + . "$at_test_source"; then :; else + AS_WARN([unable to parse test group: $at_group]) + at_failed=: + fi + at_fn_group_postprocess + test -f "$at_stop_file" && break + at_first=false + done +fi + +# Wrap up the test suite with summary statistics. +cd "$at_helper_dir" + +# Use ?..???? when the list must remain sorted, the faster * otherwise. +at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'` +at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'` +at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'` +at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do + echo $f; done | sed '/?/d; s,/xpass,,'` +at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do + echo $f; done | sed '/?/d; s,/fail,,'` + +set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list +shift; at_group_count=$[@%:@] +set X $at_xpass_list; shift; at_xpass_count=$[@%:@]; at_xpass_list=$[*] +set X $at_xfail_list; shift; at_xfail_count=$[@%:@] +set X $at_fail_list; shift; at_fail_count=$[@%:@]; at_fail_list=$[*] +set X $at_skip_list; shift; at_skip_count=$[@%:@] + +AS_VAR_ARITH([at_run_count], [$at_group_count - $at_skip_count]) +AS_VAR_ARITH([at_unexpected_count], [$at_xpass_count + $at_fail_count]) +AS_VAR_ARITH([at_total_fail_count], [$at_xfail_count + $at_fail_count]) + +# Back to the top directory. +cd "$at_dir" +rm -rf "$at_helper_dir" + +# Compute the duration of the suite. +at_stop_date=`date` +at_stop_time=`date +%s 2>/dev/null` +AS_ECHO(["$as_me: ending at: $at_stop_date"]) >&AS_MESSAGE_LOG_FD +case $at_start_time,$at_stop_time in + [[0-9]*,[0-9]*]) + AS_VAR_ARITH([at_duration_s], [$at_stop_time - $at_start_time]) + AS_VAR_ARITH([at_duration_m], [$at_duration_s / 60]) + AS_VAR_ARITH([at_duration_h], [$at_duration_m / 60]) + AS_VAR_ARITH([at_duration_s], [$at_duration_s % 60]) + AS_VAR_ARITH([at_duration_m], [$at_duration_m % 60]) + at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s" + AS_ECHO(["$as_me: test suite duration: $at_duration"]) >&AS_MESSAGE_LOG_FD + ;; +esac + +echo +AS_BOX([Test results.]) +echo +{ + echo + AS_BOX([Test results.]) + echo +} >&AS_MESSAGE_LOG_FD + +dnl +dnl FIXME: this code is as far from i18n-cleanness as man +dnl could imagine... +dnl +if test $at_run_count = 1; then + at_result="1 test" + at_were=was +else + at_result="$at_run_count tests" + at_were=were +fi +if $at_errexit_p && test $at_unexpected_count != 0; then + if test $at_xpass_count = 1; then + at_result="$at_result $at_were run, one passed" + else + at_result="$at_result $at_were run, one failed" + fi + at_result="$at_result unexpectedly and inhibited subsequent tests." + at_color=$at_red +else + # Don't you just love exponential explosion of the number of cases? + at_color=$at_red + case $at_xpass_count:$at_fail_count:$at_xfail_count in + # So far, so good. + 0:0:0) at_result="$at_result $at_were successful." at_color=$at_grn ;; + 0:0:*) at_result="$at_result behaved as expected." at_color=$at_lgn ;; + + # Some unexpected failures + 0:*:0) at_result="$at_result $at_were run, +$at_fail_count failed unexpectedly." ;; + + # Some failures, both expected and unexpected + 0:*:1) at_result="$at_result $at_were run, +$at_total_fail_count failed ($at_xfail_count expected failure)." ;; + 0:*:*) at_result="$at_result $at_were run, +$at_total_fail_count failed ($at_xfail_count expected failures)." ;; + + # No unexpected failures, but some xpasses + *:0:*) at_result="$at_result $at_were run, +$at_xpass_count passed unexpectedly." ;; + + # No expected failures, but failures and xpasses + *:1:0) at_result="$at_result $at_were run, +$at_unexpected_count did not behave as expected dnl +($at_fail_count unexpected failure)." ;; + *:*:0) at_result="$at_result $at_were run, +$at_unexpected_count did not behave as expected dnl +($at_fail_count unexpected failures)." ;; + + # All of them. + *:*:1) at_result="$at_result $at_were run, +$at_xpass_count passed unexpectedly, +$at_total_fail_count failed ($at_xfail_count expected failure)." ;; + *:*:*) at_result="$at_result $at_were run, +$at_xpass_count passed unexpectedly, +$at_total_fail_count failed ($at_xfail_count expected failures)." ;; + esac + + if test $at_skip_count = 0 && test $at_run_count -gt 1; then + at_result="All $at_result" + fi +fi + +# Now put skips in the mix. +case $at_skip_count in + 0) ;; + 1) at_result="$at_result +1 test was skipped." ;; + *) at_result="$at_result +$at_skip_count tests were skipped." ;; +esac + +if test $at_unexpected_count = 0; then + echo "$at_color$at_result$at_std" + echo "$at_result" >&AS_MESSAGE_LOG_FD +else + echo "${at_color}ERROR: $at_result$at_std" >&2 + echo "ERROR: $at_result" >&AS_MESSAGE_LOG_FD + { + echo + AS_BOX([Summary of the failures.]) + + # Summary of failed and skipped tests. + if test $at_fail_count != 0; then + echo "Failed tests:" + $SHELL "$at_myself" $at_fail_list --list + echo + fi + if test $at_skip_count != 0; then + echo "Skipped tests:" + $SHELL "$at_myself" $at_skip_list --list + echo + fi + if test $at_xpass_count != 0; then + echo "Unexpected passes:" + $SHELL "$at_myself" $at_xpass_list --list + echo + fi + if test $at_fail_count != 0; then + AS_BOX([Detailed failed tests.]) + echo + for at_group in $at_fail_list + do + at_group_normalized=$at_group + _AT_NORMALIZE_TEST_GROUP_NUMBER(at_group_normalized) + cat "$at_suite_dir/$at_group_normalized/$as_me.log" + echo + done + echo + fi + if test -n "$at_top_srcdir"; then + AS_BOX([${at_top_build_prefix}config.log]) + sed 's/^/| /' ${at_top_build_prefix}config.log + echo + fi + } >&AS_MESSAGE_LOG_FD + + AS_BOX([$as_me.log was created.]) + + echo + if $at_debug_p; then + at_msg='per-test log files' + else + at_msg="\`${at_testdir+${at_testdir}/}$as_me.log'" + fi + AS_ECHO(["Please send $at_msg and all information you think might help: + + To: <AT_PACKAGE_BUGREPORT> + Subject: @<:@AT_PACKAGE_STRING@:>@ $as_me: dnl +$at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}dnl +$at_xpass_list${at_xpass_list:+ passed unexpectedly} + +You may investigate any problem if you feel able to do so, in which +case the test suite provides a good starting point. Its output may +be found below \`${at_testdir+${at_testdir}/}$as_me.dir'. +"]) + exit 1 +fi + +exit 0 + +m4_text_box([Actual tests.]) +m4_divert_pop([TESTS])dnl +dnl End of AT_INIT: divert to KILL, only test groups are to be +dnl output, the rest is ignored. Current diversion is BODY, inherited +dnl from M4sh. +m4_divert([KILL]) +])# AT_INIT + + +# _AT_ARG_OPTION(OPTIONS,HELP-TEXT,[ARGS],[ACTION-IF-GIVEN], +# [ACTION-IF-NOT-GIVEN]) +# ---------------------------------------------------------- +# Internal implementation of AT_ARG_OPTION & AT_ARG_OPTION_ARG +m4_defun([_AT_ARG_OPTION], +[m4_divert_once([HELP_OTHER], +[cat <<_ATEOF || at_write_fail=1 + +Other options: +_ATEOF +])dnl m4_divert_once HELP_OTHER +m4_divert_text([HELP_OTHER], +[cat <<_ATEOF || at_write_fail=1 +$2 +_ATEOF])dnl +dnl Turn our options into our desired strings +m4_ifdef([AT_first_option],[m4_undefine([AT_first_option])])dnl +m4_ifdef([AT_case],[m4_undefine([AT_case])])dnl +m4_ifdef([AT_case_no],[m4_undefine([AT_case_no])])dnl +m4_ifdef([AT_case_arg],[m4_undefine([AT_case_arg])])dnl +m4_foreach([AT_option], m4_split(m4_normalize([$1]),[[ \|]+]), +[m4_define_default([AT_first_option],AT_option)dnl +m4_define_default([AT_first_option_tr], + [m4_bpatsubst(m4_defn([AT_first_option]), -, [_])])dnl +m4_append([AT_case],m4_if(m4_len(AT_option),1,[],[-])[-]AT_option, [ | ])dnl +m4_append([AT_case_no],[--no-]AT_option, [ | ])dnl +m4_append([AT_case_arg], + m4_if(m4_len(AT_option),1,[],[-])[-]AT_option[=*], [ | ])dnl +])dnl m4_foreach AT_option +dnl keep track so we or the user may process ACTION-IF-NOT-GIVEN +m4_divert_once([PARSE_ARGS_BEGIN], +[ +## +## Set up package specific options. +## +])dnl +m4_divert_text([PARSE_ARGS_BEGIN], +[dnl Provide a default value for options without arguments. +m4_ifvaln([$3],,[at_arg_[]AT_first_option_tr=false])dnl +at_arg_given_[]AT_first_option_tr=false +])dnl m4_divert_text DEFAULTS +m4_divert_text([PARSE_ARGS], +[dnl Parse the options and args when necessary. +m4_ifvaln([$3], +[ AT_case ) + at_prev=--AT_first_option_tr + ;; + AT_case_arg ) + at_arg_[]AT_first_option_tr=$at_optarg + at_arg_given_[]AT_first_option_tr=: + $4 + ;;], +[ AT_case ) + at_optarg=: + at_arg_[]AT_first_option_tr=: + at_arg_given_[]AT_first_option_tr=: + m4_ifval([$4],[$4])[]dnl + ;; + AT_case_no ) + at_optarg=false + at_arg_[]AT_first_option_tr=false + at_arg_given_[]AT_first_option_tr=: + m4_ifval([$4],[$4])[]dnl + ;;])dnl m4_ifvaln $3 +])dnl m4_divert_text PARSE_ARGS +m4_ifvaln([$5], +[m4_divert_once([PARSE_ARGS_END], +[ +## +## Process package specific options when _not_ supplied. +##])dnl m4_divert_once PARSE_ARGS_END +m4_divert_text([PARSE_ARGS_END], +[ +AS_IF([$at_arg_given_[]AT_first_option_tr],,[$5])dnl +])dnl m4_divert_text PARSE_ARGS_END +])dnl m4_ifvaln $5 +])dnl _AT_ARG_OPTION + + +# AT_ARG_OPTION(OPTIONS,HELP-TEXT,[ACTION-IF-GIVEN],[ACTION-IF-NOT-GIVEN]) +# ------------------------------------------------------------------------ +# Accept a list of space-separated OPTIONS, all aliases of the first one. +# Add HELP-TEXT to the HELP_OTHER diversion. +# +# Leading dashes should not be passed in OPTIONS. Users will be required +# to pass `--' before long options and `-' before single character options. +# +# $at_arg_OPTION will be set to `:' if this option is received, `false' if +# if --no-OPTION is received, and `false' by default. +# +# Run ACTION-IF-GIVEN each time an option in OPTIONS is encountered; here, +# $at_optarg will be set to `:' or `false' as appropriate. $at_optarg is +# actually just a copy of $at_arg_OPTION. +# +# ACTION-IF-NOT-GIVEN will be run once after option parsing is complete and +# if no option from OPTIONS was used. +m4_defun([AT_ARG_OPTION],[_AT_ARG_OPTION([$1],[$2],,[$3],[$4])]) + + +# AT_ARG_OPTION_ARG(OPTIONS,HELP-TEXT,[ACTION-IF-GIVEN],[ACTION-IF-NOT-GIVEN]) +# ---------------------------------------------------------------------------- +# Accept a set of space-separated OPTIONS with arguments, all aliases of the +# first one. Add HELP-TEXT to the HELP_OTHER diversion. +# +# Leading dashes should not be passed in OPTIONS. Users will be required +# to pass `--' before long options and `-' before single character options. +# +# By default, any argument to these options will be assigned to the shell +# variable $at_arg_OPTION, where OPTION is the first option in OPTIONS with +# any `-' characters replaced with `_'. +# +# Run ACTION-IF-GIVEN each time an option in OPTIONS is encountered; here, +# $at_optarg will be set to the option argument. $at_optarg is actually just +# a copy of $at_arg_OPTION. +# +# ACTION-IF-NOT-GIVEN will be run once after option parsing is complete +# and if no option from OPTIONS was used. +m4_defun([AT_ARG_OPTION_ARG],[_AT_ARG_OPTION([$1],[$2],1,[$3],[$4])]) + + +# AT_TESTED(PROGRAMS) +# ------------------- +# Specify the list of programs exercised by the test suite. Their +# versions are logged, and in the case of embedded test suite, they +# must correspond to the version of the package. PATH should be +# already preset so the proper executable will be selected. +m4_define([AT_TESTED], +[m4_append_uniq_w([AT_tested], [$1])]) + + +# AT_COPYRIGHT(TEXT, [FILTER = m4_newline]) +# ----------------------------------------- +# Emit TEXT, a copyright notice, in the top of the test suite and in +# --version output. Macros in TEXT are evaluated once. Process +# the --version output through FILTER (m4_newline, m4_do, and +# m4_copyright_condense are common filters). +m4_define([AT_COPYRIGHT], +[AS_COPYRIGHT([$1])[]]dnl +[m4_divert_text([VERSION_NOTICES], +[m4_default([$2], [m4_newline])([$1])])])# AT_COPYRIGHT + + +# AT_COLOR_TESTS +# -------------- +# Enable colored test results if standard error is connected to a terminal. +m4_define([AT_COLOR_TESTS], +[m4_define([AT_color], [auto])]) + +# AT_SETUP(DESCRIPTION) +# --------------------- +# Start a group of related tests, all to be executed in the same subshell. +# The group is testing what DESCRIPTION says. +_AT_DEFINE_INIT([AT_SETUP], +[m4_ifdef([AT_ingroup], [m4_fatal([$0: nested AT_SETUP detected])], + [m4_define([AT_ingroup], [AS_ECHO(["$at_setup_line"]) >"$at_check_line_file" +])]) +m4_ifdef([AT_keywords], [m4_undefine([AT_keywords])]) +m4_define([AT_capture_files], []) +m4_define([AT_line], AT_LINE) +m4_define([AT_xfail], [at_xfail=no]) +m4_define([AT_description], m4_expand([$1])) +m4_define([AT_ordinal], m4_incr(AT_ordinal)) +m4_divert_push([TEST_GROUPS])dnl +[#AT_START_]AT_ordinal +at_fn_group_banner AT_ordinal 'm4_defn([AT_line])' \ + "AS_ESCAPE(m4_dquote(m4_defn([AT_description])))" m4_format(["%*s"], + m4_max(0, m4_eval(47 - m4_qlen(m4_defn([AT_description])))), [])m4_if( + AT_banner_ordinal, [0], [], [ AT_banner_ordinal]) +m4_divert_push([TEST_SCRIPT])dnl +]) + + +# AT_FAIL_IF(SHELL-EXPRESSION) +# ---------------------------- +# Make the test die with hard failure if SHELL-EXPRESSION evaluates to +# true (exitcode = 0). +_AT_DEFINE_SETUP([AT_FAIL_IF], +[dnl +dnl Try to limit the amount of conditionals that we emit. +m4_case([$1], + [], [], + [false], [], + [:], [_AT_CHECK_EXIT([], [99])], + [true], [_AT_CHECK_EXIT([], [99])], + [_AT_CHECK_EXIT([$1], [99])])]) + + +# AT_SKIP_IF(SHELL-EXPRESSION) +# ---------------------------- +# Skip the rest of the group if SHELL-EXPRESSION evaluates to true +# (exitcode = 0). +_AT_DEFINE_SETUP([AT_SKIP_IF], +[dnl +dnl Try to limit the amount of conditionals that we emit. +m4_case([$1], + [], [], + [false], [], + [:], [_AT_CHECK_EXIT([], [77])], + [true], [_AT_CHECK_EXIT([], [77])], + [_AT_CHECK_EXIT([$1], [77])])]) + + +# AT_XFAIL_IF(SHELL-EXPRESSION) +# ----------------------------- +# Set up the test to be expected to fail if SHELL-EXPRESSION evaluates to +# true (exitcode = 0). +_AT_DEFINE_SETUP([AT_XFAIL_IF], +[dnl +dnl Try to limit the amount of conditionals that we emit. +m4_case([$1], + [], [], + [false], [], + [:], [m4_define([AT_xfail], [at_xfail=yes])], + [true], [m4_define([AT_xfail], [at_xfail=yes])], + [m4_append([AT_xfail], [ + $1 && at_xfail=yes])])]) + + +# AT_KEYWORDS(KEYWORDS) +# --------------------- +# Declare a list of keywords associated to the current test group. +# Since the -k option is case-insensitive, the list is stored in lower case +# to avoid duplicates that differ only by case. +_AT_DEFINE_SETUP([AT_KEYWORDS], +[m4_append_uniq_w([AT_keywords], m4_tolower(_m4_expand([$1 +])))]) + + +# AT_CAPTURE_FILE(FILE) +# --------------------- +# If the current test group does not behave as expected, save the contents of +# FILE in the test suite log. +_AT_DEFINE_SETUP([AT_CAPTURE_FILE], +[m4_append_uniq([AT_capture_files], ["$1"], [ \ +])]) + + +# AT_CLEANUP +# ---------- +# Complete a group of related tests. +_AT_DEFINE_INIT([AT_CLEANUP], +[m4_ifdef([AT_ingroup], [AT_ingroup[]_m4_undefine([AT_ingroup])], + [m4_fatal([$0: missing AT_SETUP detected])])dnl +m4_append([AT_help_all], +m4_defn([AT_ordinal]);m4_defn([AT_line]);m4_defn([AT_description]);dnl +m4_ifdef([AT_keywords], [m4_defn([AT_keywords])]); +)dnl +m4_divert_pop([TEST_SCRIPT])dnl Back to TEST_GROUPS +AT_xfail +( + AS_ECHO(["AT_ordinal. $at_setup_line: testing $at_desc ..."]) + $at_traceon +m4_undivert([TEST_SCRIPT])dnl Insert the code here + set +x + $at_times_p && times >"$at_times_file" +) AS_MESSAGE_LOG_FD>&1 2>&1 AT_JOB_FIFO_OUT_FD>&- | eval $at_tee_pipe +read at_status <"$at_status_file" +[#AT_STOP_]AT_ordinal +m4_divert_pop([TEST_GROUPS])dnl Back to KILL. +])# AT_CLEANUP + + +# AT_BANNER([TEXT]) +# ----------------- +# Start a category of related test groups. If multiple groups are executed, +# output TEXT as a banner without any shell expansion, prior to any test +# from the category. If TEXT is empty, no banner is printed. +_AT_DEFINE_INIT([AT_BANNER], +[m4_ifdef([AT_ingroup], [m4_fatal([$0: nested AT_SETUP detected])])dnl +m4_define([AT_banner_ordinal], m4_incr(AT_banner_ordinal)) +m4_divert_text([BANNERS], +[@%:@ Banner AT_banner_ordinal. AT_LINE +@%:@ Category starts at test group m4_incr(AT_ordinal). +at_banner_text_[]AT_banner_ordinal="AS_ESCAPE([$1])"])dnl +])# AT_BANNER + + +# AT_DATA(FILE, CONTENTS) +# ----------------------- +# Initialize an input data FILE with given CONTENTS, which should be +# empty or end with a newline. +# This macro is not robust to active symbols in CONTENTS *on purpose*. +# If you don't want CONTENTS to be evaluated, quote it twice. +_AT_DEFINE_SETUP([AT_DATA], +[m4_if([$2], [], [: >$1], + [$2], [[]], [: >$1], +[cat >$1 <<'_ATEOF' +$2[]_ATEOF +])]) + + +# AT_CHECK(COMMANDS, [STATUS = 0], STDOUT, STDERR, +# [RUN-IF-FAIL], [RUN-IF-PASS]) +# ------------------------------------------------ +# Execute a test by performing given shell COMMANDS. These commands +# should normally exit with STATUS, while producing expected STDOUT and +# STDERR contents. Shell metacharacters in STDOUT and STDERR are +# _not_ processed by the shell, but are treated as string literals. +# +# STATUS, STDOUT, and STDERR are not checked if equal to `ignore'. +# +# If STDOUT is `expout', then stdout is compared to the content of the file +# `expout'. Likewise for STDERR and `experr'. +# +# If STDOUT is `stdout', then the stdout is left in the file `stdout', +# likewise for STDERR and `stderr'. Don't do this: +# +# AT_CHECK([command >out]) +# # Some checks on `out' +# +# do this instead: +# +# AT_CHECK([command], [], [stdout]) +# # Some checks on `stdout' +# +# You might wonder why you can't just use `ignore', then directly use stdout +# and stderr left by the test suite: +# +# AT_CHECK([command], [], [ignore]) +# AT_CHECK([check stdout]) +# +# If the test suite always captured data in the file `stdout', then the +# second command would be trying to read and write from the same file, with +# undefined behavior. Therefore, the test suite actually captures data in +# an internal file of a different name, and only creates `stdout' when +# explicitly requested. +# +# Any line of stderr starting with leading blanks and a `+' are filtered +# out, since most shells when tracing include subshell traces in stderr. +# This may cause spurious failures when the test suite is run with `-x'. +# +_AT_DEFINE_SETUP([AT_CHECK], +[_AT_CHECK(m4_expand([$1]), [$2], AS_ESCAPE(m4_dquote(m4_expand([$3]))), + AS_ESCAPE(m4_dquote(m4_expand([$4]))), [$5], [$6])]) + +# AT_CHECK_UNQUOTED(COMMANDS, [STATUS = 0], STDOUT, STDERR, +# [RUN-IF-FAIL], [RUN-IF-PASS]) +# --------------------------------------------------------- +# Like AT_CHECK, but do not AS_ESCAPE shell metacharacters in the STDOUT +# and STDERR arguments before running the comparison. +_AT_DEFINE_SETUP([AT_CHECK_UNQUOTED], +[_AT_CHECK(m4_expand([$1]), [$2], AS_ESCAPE(m4_dquote(m4_expand([$3])), [""]), + AS_ESCAPE(m4_dquote(m4_expand([$4])), [""]), [$5], [$6])]) + +# AT_CHECK_NOESCAPE(COMMANDS, [STATUS = 0], STDOUT, STDERR, +# [RUN-IF-FAIL], [RUN-IF-PASS]) +# --------------------------------------------------------- +# Obsolete spelling of AT_CHECK_UNQUOTED. +m4_define([AT_CHECK_NOESCAPE], +[m4_warn([obsolete], [consider using AT_CHECK_UNQUOTED instead of $0])]dnl +[_AT_CHECK(m4_expand([$1]), [$2], m4_expand([$3]), + m4_expand([$4]), [$5], [$6])]) + + +# _AT_DECIDE_TRACEABLE(COMMANDS) +# ------------------------------ +# Worker for _AT_CHECK that expands to shell code. If COMMANDS are safe to +# trace with `set -x', the shell code will evaluate to true. Otherwise, +# the shell code will print a message stating an aspect of COMMANDS that makes +# tracing them unsafe, and evaluate to false. +# +# Tracing COMMANDS is not safe if they contain a command that spans multiple +# lines. When the test suite user passes `-x' or `--trace', the test suite +# precedes every command with a `set -x'. Since most tests expect a specific +# stderr, if only to confirm that it is empty, the test suite filters ^+ from +# the captured stderr before comparing with the expected stderr. If a command +# spans multiple lines, so will its trace, but a `+' only prefixes the first +# line of that trace: +# +# $ echo 'foo +# bar' +# => stdout +# foo +# bar +# => stderr +# + foo +# bar +# +# In a subset of cases, one could filter such extended shell traces from +# stderr. Since test commands spanning several lines are rare, I chose +# instead to simply not trace COMMANDS that could yield multiple trace lines. +# Distinguishing such COMMANDS became the task at hand. +# +# These features may cause a shell command to span multiple lines: +# +# (a) A quoted literal newline. +# Example: +# echo foo' +# 'bar +# M4 is a hostile language for the job of parsing COMMANDS to determine whether +# each literal newline is quoted, so we simply disable tracing for all COMMANDS +# that bear literal newlines. +# +# (b) A command substitution not subject to word splitting. +# Example: +# var=$(printf 'foo\nbar') +# Example: +# echo "`printf 'foo\\nbar`" +# One cannot know in general the number of lines a command substitution will +# yield without executing the substituted command. As such, we disable tracing +# for all COMMANDS containing these constructs. +# +# (c) A parameter expansion not subject to word splitting. +# Example: +# var=foo' +# 'bar +# echo "$var" +# Parameter expansions appear in COMMANDS with much greater frequency than do +# newlines and command substitutions, so disabling tracing for all such +# COMMANDS would much more substantially devalue `testsuite -x'. To determine +# which parameter expansions yield multiple lines, we escape all ``', `"', +# and `\' in a copy of COMMANDS and expand that string within double quotes +# at runtime. If the result of that expansion contains multiple lines, the +# test suite disables tracing for the command in question. +# +# This method leads the test suite to expand some parameters that the shell +# itself will never expand due to single-quotes or backslash escapes. This is +# not a problem for `$foo' expansions, which will simply yield the empty string +# or some unrelated value. A `${...}' expansion could actually form invalid +# shell code, however; consider `${=foo}'. Therefore, we disable tracing for +# all COMMANDS containing `${...}'. This affects few COMMANDS. +# +# This macro falls in a very hot path; the Autoconf test suite expands it 1640 +# times as of this writing. To give a sense of the impact of the heuristics I +# just described, the test suite preemptively disables tracing for 31 of those, +# and 268 contain parameter expansions that require runtime evaluation. The +# balance are always safe to trace. +m4_define([_AT_DECIDE_TRACEABLE], +dnl Utility macro. +dnl +dnl Examine COMMANDS for a reason to never trace COMMANDS. +[m4_pushdef([at_reason], +m4_cond([m4_eval(m4_index([$1], [`]) >= 0)], [1], + [[a `...` command substitution]], + [m4_eval(m4_index([$1], [$(]) >= 0)], [1], + [[a $(...) command substitution]], + [m4_eval(m4_index([$1], [${]) >= 0)], [1], + [[a ${...} parameter expansion]], + [m4_eval(m4_index([$1], m4_newline) >= 0)], [1], + [[an embedded newline]], + [m4_eval(m4_bregexp([$1], [[^|]|[^|]]) >= 0)], [1], + [[a shell pipeline]], + []))]dnl No reason. +[m4_if(m4_index(_m4_defn([at_reason]), [a]), [0],]dnl +dnl We know at build time that tracing COMMANDS is never safe. +[[at_fn_check_prepare_notrace '_m4_defn([at_reason])'], + m4_index([$1], [$]), [-1],]dnl +dnl We know at build time that tracing COMMANDS is always safe. +[[at_fn_check_prepare_trace],]dnl +dnl COMMANDS may contain parameter expansions; expand them at runtime. +[[at_fn_check_prepare_dynamic "AS_ESCAPE([[$1]], [`\"])"])[]]dnl +[_m4_popdef([at_reason])]) + + +# AT_DIFF_STDERR/AT_DIFF_STDOUT +# ----------------------------- +# These are subroutines of AT_CHECK. Using indirect dispatch is a tad +# faster than using m4_case, and these are called very frequently. +m4_define([AT_DIFF_STDERR(stderr)], + [echo stderr:; tee stderr <"$at_stderr"]) +m4_define([AT_DIFF_STDERR(stderr-nolog)], + [echo stderr captured; cp "$at_stderr" stderr]) +m4_define([AT_DIFF_STDERR(ignore)], + [echo stderr:; cat "$at_stderr"]) +m4_define([AT_DIFF_STDERR(ignore-nolog)]) +m4_define([AT_DIFF_STDERR(experr)], + [$at_diff experr "$at_stderr" || at_failed=:]) +m4_define([AT_DIFF_STDERR()], + [at_fn_diff_devnull "$at_stderr" || at_failed=:]) + +m4_define([AT_DIFF_STDOUT(stdout)], + [echo stdout:; tee stdout <"$at_stdout"]) +m4_define([AT_DIFF_STDOUT(stdout-nolog)], + [echo stdout captured; cp "$at_stdout" stdout]) +m4_define([AT_DIFF_STDOUT(ignore)], + [echo stdout:; cat "$at_stdout"]) +m4_define([AT_DIFF_STDOUT(ignore-nolog)]) +m4_define([AT_DIFF_STDOUT(expout)], + [$at_diff expout "$at_stdout" || at_failed=:]) +m4_define([AT_DIFF_STDOUT()], + [at_fn_diff_devnull "$at_stdout" || at_failed=:]) + +# _AT_CHECK(COMMANDS, [STATUS = 0], STDOUT, STDERR, +# [RUN-IF-FAIL], [RUN-IF-PASS]) +# ------------------------------------------------- +# Worker for AT_CHECK and AT_CHECK_UNQUOTED, with COMMANDS, STDOUT, and +# STDERR pre-expanded. +# +# Implementation Details +# ---------------------- +# Ideally, we would like to run +# +# ( $at_traceon; COMMANDS >at-stdout 2> at-stderr ) +# +# but we must group COMMANDS as it is not limited to a single command, and +# then the shells will save the traces in at-stderr. So we have to filter +# them out when checking stderr, and we must send them into the test suite's +# stderr to honor -x properly. Since only the first line of the trace of a +# multiline command starts with a `+', and I know of no straightforward way to +# filter out the unadorned trace lines, we disable shell tracing entirely for +# commands that could span multiple lines. +# +# Limiting COMMANDS to a single command is not good either, since then +# the user herself would use {} or (), and then we face the same problem. +# +# But then, there is no point in running +# +# ( $at_traceon { $1 ; } >at-stdout 2>at-stder1 ) +# +# instead of the simpler +# +# ( $at_traceon; $1 ) >at-stdout 2>at-stder1 +# +# Note that we truncate and append to the output files, to avoid losing +# output from multiple concurrent processes, e.g., an inner testsuite +# with parallel jobs. +m4_define([_AT_CHECK], +[m4_define([AT_ingroup])]dnl +[{ set +x +AS_ECHO(["$at_srcdir/AT_LINE: AS_ESCAPE([[$1]])"]) +_AT_DECIDE_TRACEABLE([$1]) _AT_LINE_ESCAPED +( $at_check_trace; [$1] +) >>"$at_stdout" 2>>"$at_stderr" AS_MESSAGE_LOG_FD>&- +at_status=$? at_failed=false +$at_check_filter +m4_ifdef([AT_DIFF_STDERR($4)], [m4_indir([AT_DIFF_STDERR($4)])], + [echo >>"$at_stderr"; AS_ECHO([["$4"]]) | \ + $at_diff - "$at_stderr" || at_failed=:]) +m4_ifdef([AT_DIFF_STDOUT($3)], [m4_indir([AT_DIFF_STDOUT($3)])], + [echo >>"$at_stdout"; AS_ECHO([["$3"]]) | \ + $at_diff - "$at_stdout" || at_failed=:]) +m4_if([$2], [ignore], [at_fn_check_skip], + [at_fn_check_status m4_default([$2], [0])]) $at_status "$at_srcdir/AT_LINE" +m4_ifvaln([$5$6], [AS_IF($at_failed, [$5], [$6])])]dnl +[$at_failed && at_fn_log_failure AT_capture_files +$at_traceon; } +])# _AT_CHECK + +# _AT_CHECK_EXIT(COMMANDS, [EXIT-STATUS-IF-PASS]) +# ----------------------------------------------- +# Minimal version of _AT_CHECK for AT_SKIP_IF and AT_FAIL_IF. +m4_define([_AT_CHECK_EXIT], +[m4_define([AT_ingroup])]dnl +[AS_ECHO(_AT_LINE_ESCAPED) >"$at_check_line_file" +m4_ifval([$1], [($1) \ + && ])at_fn_check_skip $2 "$at_srcdir/AT_LINE"])# _AT_CHECK_EXIT diff --git a/lib/autotest/specific.m4 b/lib/autotest/specific.m4 new file mode 100644 index 0000000..155a5da --- /dev/null +++ b/lib/autotest/specific.m4 @@ -0,0 +1,74 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# M4 macros used in running tests using third-party testing tools. +m4_define([_AT_COPYRIGHT_YEARS], +[Copyright (C) 2009-2012 Free Software Foundation, Inc.]) + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + + +## ------------------------ ## +## Erlang EUnit unit tests. ## +## ------------------------ ## + +# AT_CHECK_EUNIT(MODULE, SPEC, [ERLFLAGS], [RUN-IF-FAIL], [RUN-IF-PASS]) +# ---------------------------------------------------------------------- +# Check that the EUnit test specification SPEC passes. The ERLFLAGS +# optional flags are passed to the Erlang interpreter command line to +# execute the test. The test is executed from an automatically +# generated Erlang module named MODULE. Each call to this macro should +# have a distinct MODULE name within each test group, to ease +# debugging. +# An Erlang/OTP version which contains the eunit library must be +# installed, in order to execute this macro in a test suite. The ERL, +# ERLC, and ERLCFLAGS variables must be defined in atconfig, +# typically by using the AC_ERLANG_PATH_ERL and AC_ERLANG_PATH_ERLC +# Autoconf macros. +_AT_DEFINE_SETUP([AT_CHECK_EUNIT], +[AT_SKIP_IF([test ! -f "$ERL" || test ! -f "$ERLC"]) +## A wrapper to EUnit, to exit the Erlang VM with the right exit code: +AT_DATA([$1.erl], +[[-module($1). +-export([test/0, test/1]). +test() -> test([]). +test(Options) -> + TestSpec = $2, + ReturnValue = case code:load_file(eunit) of + {module, _} -> case eunit:test(TestSpec, Options) of + ok -> "0\n"; %% test passes + _ -> "1\n" %% test fails + end; + _ -> "77\n" %% EUnit not found, test skipped + end, + file:write_file("$1.result", ReturnValue), + init:stop(). +]]) +AT_CHECK(["$ERLC" $ERLCFLAGS -b beam $1.erl]) +## Make EUnit verbose when testsuite is verbose: +if test -z "$at_verbose"; then + at_eunit_options="verbose" +else + at_eunit_options="" +fi +AT_CHECK(["$ERL" $3 -s $1 test $at_eunit_options -noshell], [0], [ignore], [], + [$4], [$5]) +AT_CAPTURE_FILE([$1.result]) +AT_CHECK([test -f "$1.result" && (exit `cat "$1.result"`)]) +]) diff --git a/lib/emacs/Makefile.am b/lib/emacs/Makefile.am new file mode 100644 index 0000000..aa62207 --- /dev/null +++ b/lib/emacs/Makefile.am @@ -0,0 +1,3 @@ +# Make Autoconf Emacs library. + +dist_lisp_LISP = autoconf-mode.el autotest-mode.el diff --git a/lib/emacs/Makefile.in b/lib/emacs/Makefile.in new file mode 100644 index 0000000..13490a3 --- /dev/null +++ b/lib/emacs/Makefile.in @@ -0,0 +1,420 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autoconf Emacs library. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = lib/emacs +DIST_COMMON = $(dist_lisp_LISP) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(lispdir)" +dist_lispLISP_INSTALL = $(INSTALL_DATA) +LISP = $(dist_lisp_LISP) +am__ELFILES = autoconf-mode.el autotest-mode.el +am__ELCFILES = $(am__ELFILES:.el=.elc) +ELCFILES = $(LISP:.el=.elc) +elisp_comp = $(top_srcdir)/build-aux/elisp-comp +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +dist_lisp_LISP = autoconf-mode.el autotest-mode.el +all: all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/emacs/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/emacs/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +elc-stamp: $(LISP) + @echo 'WARNING: Warnings can be ignored. :-)' + @rm -f elc-temp && touch elc-temp + if test "$(EMACS)" != no; then \ + set x; \ + list='$(LISP)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + set x "$$@" "$$d$$p"; shift; \ + done; \ + shift; \ + EMACS="$(EMACS)" $(SHELL) $(elisp_comp) "$$@" || exit 1; \ + else : ; fi + @mv -f elc-temp $@ +$(am__ELCFILES): elc-stamp + @if test "$(EMACS)" != no && test ! -f $@; then \ + trap 'rm -rf elc-lock elc-stamp' 1 2 13 15; \ + if mkdir elc-lock 2>/dev/null; then \ + rm -f elc-stamp; \ + $(MAKE) $(AM_MAKEFLAGS) elc-stamp; \ + rmdir elc-lock; \ + else \ + while test -d elc-lock; do sleep 1; done; \ + test -f elc-stamp; exit $$?; \ + fi; \ + else : ; fi +install-dist_lispLISP: $(dist_lisp_LISP) $(ELCFILES) + @$(NORMAL_INSTALL) + @if test "$(EMACS)" != no && test -n "$(lispdir)"; then \ + $(MKDIR_P) "$(DESTDIR)$(lispdir)"; \ + list='$(dist_lisp_LISP)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + $(am__strip_dir) \ + echo " $(dist_lispLISP_INSTALL) '$$d$$p' '$(DESTDIR)$(lispdir)/$$f'"; \ + $(dist_lispLISP_INSTALL) "$$d$$p" "$(DESTDIR)$(lispdir)/$$f" || exit $$?; \ + if test -f $${p}c; then \ + echo " $(dist_lispLISP_INSTALL) '$${p}c' '$(DESTDIR)$(lispdir)/$${f}c'"; \ + $(dist_lispLISP_INSTALL) "$${p}c" "$(DESTDIR)$(lispdir)/$${f}c" || exit $$?; \ + else : ; fi; \ + done; \ + else : ; fi + +uninstall-dist_lispLISP: + @$(NORMAL_UNINSTALL) + @test "$(EMACS)" != no && test -n "$(lispdir)" || exit 0; \ + list='$(dist_lisp_LISP)'; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + filesc=`echo "$$files" | sed 's|$$|c|'`; \ + echo " ( cd '$(DESTDIR)$(lispdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(lispdir)" && rm -f $$files || exit $$?; \ + echo " ( cd '$(DESTDIR)$(lispdir)' && rm -f" $$filesc ")"; \ + cd "$(DESTDIR)$(lispdir)" && rm -f $$filesc + +clean-lisp: + -rm -f elc-stamp $(ELCFILES) +tags: TAGS +TAGS: + +ctags: CTAGS +CTAGS: + + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LISP) $(ELCFILES) +installdirs: + for dir in "$(DESTDIR)$(lispdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-lisp mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_lispLISP + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_lispLISP + +.MAKE: install-am install-strip + +.PHONY: all all-am check check-am clean clean-generic clean-lisp \ + distclean distclean-generic distdir dvi dvi-am html html-am \ + info info-am install install-am install-data install-data-am \ + install-dist_lispLISP install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am uninstall uninstall-am uninstall-dist_lispLISP + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/emacs/autoconf-mode.el b/lib/emacs/autoconf-mode.el new file mode 100644 index 0000000..161ea82 --- /dev/null +++ b/lib/emacs/autoconf-mode.el @@ -0,0 +1,100 @@ +;;; autoconf-mode.el --- autoconf code editing commands for Emacs + +;; Author: Martin Buchholz (martin@xemacs.org) +;; Maintainer: Martin Buchholz +;; Keywords: languages, faces, m4, configure + +;; This file is part of Autoconf + +;; Copyright (C) 2001, 2006, 2009-2012 Free Software Foundation, Inc. +;; +;; This program is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. +;; +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see <http://www.gnu.org/licenses/>. + +;; A major mode for editing autoconf input (like configure.in). +;; Derived from m4-mode.el by Andrew Csillag (drew@staff.prodigy.com) + +;;; Your should add the following to your Emacs configuration file: + +;; (autoload 'autoconf-mode "autoconf-mode" +;; "Major mode for editing autoconf files." t) +;; (setq auto-mode-alist +;; (cons '("\\.ac\\'\\|configure\\.in\\'" . autoconf-mode) +;; auto-mode-alist)) + +;;; Code: + +;;thank god for make-regexp.el! +(defvar autoconf-font-lock-keywords + `(("\\bdnl \\(.*\\)" 1 font-lock-comment-face t) + ("\\$[0-9*#@]" . font-lock-variable-name-face) + ("\\b\\(m4_\\)?\\(builtin\\|change\\(com\\|quote\\|word\\)\\|d\\(e\\(bug\\(file\\|mode\\)\\|cr\\|f\\(ine\\|n\\)\\)\\|iv\\(ert\\|num\\)\\|nl\\|umpdef\\)\\|e\\(rrprint\\|syscmd\\|val\\)\\|f\\(ile\\|ormat\\)\\|gnu\\|i\\(f\\(def\\|else\\)\\|n\\(c\\(lude\\|r\\)\\|d\\(ex\\|ir\\)\\)\\)\\|l\\(en\\|ine\\)\\|m\\(4\\(exit\\|wrap\\)\\|aketemp\\|kstemp\\)\\|p\\(atsubst\\|opdef\\|ushdef\\)\\|regexp\\|s\\(hift\\|include\\|ubstr\\|ys\\(cmd\\|val\\)\\)\\|tra\\(ceo\\(ff\\|n\\)\\|nslit\\)\\|un\\(d\\(efine\\|ivert\\)\\|ix\\)\\)\\b" . font-lock-keyword-face) + ("^\\(\\(m4_\\)?define\\(_default\\)?\\|A._DEFUN\\|m4_defun\\(_once\\|_init\\)?\\)(\\[?\\([A-Za-z0-9_]+\\)" 5 font-lock-function-name-face) + "default font-lock-keywords") +) + +(defvar autoconf-mode-syntax-table nil + "syntax table used in autoconf mode") +(setq autoconf-mode-syntax-table (make-syntax-table)) +(modify-syntax-entry ?\" "\"" autoconf-mode-syntax-table) +;;(modify-syntax-entry ?\' "\"" autoconf-mode-syntax-table) +(modify-syntax-entry ?# "<\n" autoconf-mode-syntax-table) +(modify-syntax-entry ?\n ">#" autoconf-mode-syntax-table) +(modify-syntax-entry ?\( "()" autoconf-mode-syntax-table) +(modify-syntax-entry ?\) ")(" autoconf-mode-syntax-table) +(modify-syntax-entry ?\[ "(]" autoconf-mode-syntax-table) +(modify-syntax-entry ?\] ")[" autoconf-mode-syntax-table) +(modify-syntax-entry ?* "." autoconf-mode-syntax-table) +(modify-syntax-entry ?_ "_" autoconf-mode-syntax-table) + +(defvar autoconf-mode-map + (let ((map (make-sparse-keymap))) + (define-key map '[(control c) (\;)] 'comment-region) + map)) + +(defun autoconf-current-defun () + "Autoconf value for `add-log-current-defun-function'. +This tells add-log.el how to find the current macro." + (save-excursion + (if (re-search-backward "^\\(m4_define\\(_default\\)?\\|m4_defun\\(_once\\|_init\\)?\\|A._DEFUN\\)(\\[*\\([A-Za-z0-9_]+\\)" nil t) + (buffer-substring (match-beginning 4) + (match-end 4)) + nil))) + +;;;###autoload +(defun autoconf-mode () + "A major-mode to edit Autoconf files like configure.ac. +\\{autoconf-mode-map} +" + (interactive) + (kill-all-local-variables) + (use-local-map autoconf-mode-map) + + (make-local-variable 'add-log-current-defun-function) + (setq add-log-current-defun-function 'autoconf-current-defun) + + (make-local-variable 'comment-start) + (setq comment-start "# ") + (make-local-variable 'parse-sexp-ignore-comments) + (setq parse-sexp-ignore-comments t) + + (make-local-variable 'font-lock-defaults) + (setq major-mode 'autoconf-mode) + (setq mode-name "Autoconf") + (setq font-lock-defaults `(autoconf-font-lock-keywords nil)) + (set-syntax-table autoconf-mode-syntax-table) + (run-hooks 'autoconf-mode-hook)) + +(provide 'autoconf-mode) + +;;; autoconf-mode.el ends here diff --git a/lib/emacs/autotest-mode.el b/lib/emacs/autotest-mode.el new file mode 100644 index 0000000..6cb304e --- /dev/null +++ b/lib/emacs/autotest-mode.el @@ -0,0 +1,101 @@ +;;; autotest-mode.el --- autotest code editing commands for Emacs + +;; Author: Akim Demaille (akim@freefriends.org) +;; Keywords: languages, faces, m4, Autotest + +;; This file is part of Autoconf + +;; Copyright (C) 2001, 2009-2012 Free Software Foundation, Inc. +;; +;; This program is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. +;; +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; A major mode for editing autotest input (like testsuite.at). +;; Derived from autoconf-mode.el, by Martin Buchholz (martin@xemacs.org). + +;;; Your should add the following to your Emacs configuration file: + +;; (autoload 'autotest-mode "autotest-mode" +;; "Major mode for editing autotest files." t) +;; (setq auto-mode-alist +;; (cons '("\\.at\\'" . autotest-mode) auto-mode-alist)) + +;;; Code: + +(defvar autotest-font-lock-keywords + `(("\\bdnl\\b\\(.*\\)" 1 font-lock-comment-face t) + ("\\$[0-9*#@]" . font-lock-variable-name-face) + ("^\\(m4_define\\|m4_defun\\)(\\[*\\([A-Za-z0-9_]+\\)" 2 font-lock-function-name-face) + ("^AT_SETUP(\\[+\\([^]]+\\)" 1 font-lock-function-name-face) + ("^AT_DATA(\\[+\\([^]]+\\)" 1 font-lock-variable-name-face) + ("\\b\\(_?m4_[_a-z0-9]*\\|_?A[ST]_[_A-Z0-9]+\\)\\b" . font-lock-keyword-face) + "default font-lock-keywords") +) + +(defvar autotest-mode-syntax-table nil + "syntax table used in autotest mode") +(setq autotest-mode-syntax-table (make-syntax-table)) +(modify-syntax-entry ?\" "\"" autotest-mode-syntax-table) +;;(modify-syntax-entry ?\' "\"" autotest-mode-syntax-table) +(modify-syntax-entry ?# "<\n" autotest-mode-syntax-table) +(modify-syntax-entry ?\n ">#" autotest-mode-syntax-table) +(modify-syntax-entry ?\( "()" autotest-mode-syntax-table) +(modify-syntax-entry ?\) ")(" autotest-mode-syntax-table) +(modify-syntax-entry ?\[ "(]" autotest-mode-syntax-table) +(modify-syntax-entry ?\] ")[" autotest-mode-syntax-table) +(modify-syntax-entry ?* "." autotest-mode-syntax-table) +(modify-syntax-entry ?_ "_" autotest-mode-syntax-table) + +(defvar autotest-mode-map + (let ((map (make-sparse-keymap))) + (define-key map '[(control c) (\;)] 'comment-region) + map)) + +(defun autotest-current-defun () + "Autotest value for `add-log-current-defun-function'. +This tells add-log.el how to find the current test group/macro." + (save-excursion + (if (re-search-backward "^\\(m4_define\\|m4_defun\\|AT_SETUP\\)(\\[+\\([^]]+\\)" nil t) + (buffer-substring (match-beginning 2) + (match-end 2)) + nil))) + +;;;###autoload +(defun autotest-mode () + "A major-mode to edit Autotest files like testsuite.at. +\\{autotest-mode-map} +" + (interactive) + (kill-all-local-variables) + (use-local-map autotest-mode-map) + + (make-local-variable 'add-log-current-defun-function) + (setq add-log-current-defun-function 'autotest-current-defun) + + (make-local-variable 'comment-start) + (setq comment-start "# ") + (make-local-variable 'parse-sexp-ignore-comments) + (setq parse-sexp-ignore-comments t) + + (make-local-variable 'font-lock-defaults) + (setq major-mode 'autotest-mode) + (setq mode-name "Autotest") + (setq font-lock-defaults `(autotest-font-lock-keywords nil)) + (set-syntax-table autotest-mode-syntax-table) + (run-hooks 'autotest-mode-hook)) + +(provide 'autotest-mode) + +;;; autotest-mode.el ends here diff --git a/lib/freeze.mk b/lib/freeze.mk new file mode 100644 index 0000000..492342c --- /dev/null +++ b/lib/freeze.mk @@ -0,0 +1,132 @@ +# Freeze M4 files. + +# Copyright (C) 2002, 2004, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + + +## ----------------- ## +## Freeze M4 files. ## +## ----------------- ## + +SUFFIXES = .m4 .m4f + +AUTOM4TE_CFG = $(top_builddir)/lib/autom4te.cfg +$(AUTOM4TE_CFG): $(top_srcdir)/lib/autom4te.in + cd $(top_builddir)/lib && $(MAKE) $(AM_MAKEFLAGS) autom4te.cfg + +# Do not use AUTOM4TE here, since maint.mk (my-distcheck) +# checks if we are independent of Autoconf by defining AUTOM4TE (and +# others) to `false'. Autoconf provides autom4te, so that doesn't +# apply to us. +MY_AUTOM4TE = \ + autom4te_perllibdir='$(top_srcdir)'/lib \ + AUTOM4TE_CFG='$(AUTOM4TE_CFG)' $(top_builddir)/bin/autom4te \ + -B '$(top_builddir)'/lib -B '$(top_srcdir)'/lib # keep ` ' + +# When processing the file with diversion disabled, there must be no +# output but comments and empty lines. +# If freezing produces output, something went wrong: a bad `divert', +# or an improper paren etc. +# It may happen that the output does not end with an end of line, hence +# force an end of line when reporting errors. +.m4.m4f: + $(MY_AUTOM4TE) \ + --language=$* \ + --freeze \ + --output=$@ + +# Factor the dependencies between all the frozen files. +# Some day we should explain to Automake how to use autom4te to compute +# the dependencies... +src_libdir = $(top_srcdir)/lib +build_libdir = $(top_builddir)/lib + +m4f_dependencies = $(top_builddir)/bin/autom4te $(AUTOM4TE_CFG) + +# For parallel builds. +$(build_libdir)/m4sugar/version.m4: + cd $(build_libdir)/m4sugar && $(MAKE) $(AM_MAKEFLAGS) version.m4 + +m4sugar_m4f_dependencies = \ + $(m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sugar.m4 \ + $(build_libdir)/m4sugar/version.m4 + +m4sh_m4f_dependencies = \ + $(m4sugar_m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sh.m4 + +autotest_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autotest/autotest.m4 \ + $(src_libdir)/autotest/general.m4 \ + $(src_libdir)/autotest/specific.m4 + +autoconf_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autoconf/autoscan.m4 \ + $(src_libdir)/autoconf/general.m4 \ + $(src_libdir)/autoconf/autoheader.m4 \ + $(src_libdir)/autoconf/autoupdate.m4 \ + $(src_libdir)/autoconf/autotest.m4 \ + $(src_libdir)/autoconf/status.m4 \ + $(src_libdir)/autoconf/oldnames.m4 \ + $(src_libdir)/autoconf/specific.m4 \ + $(src_libdir)/autoconf/lang.m4 \ + $(src_libdir)/autoconf/c.m4 \ + $(src_libdir)/autoconf/fortran.m4 \ + $(src_libdir)/autoconf/erlang.m4 \ + $(src_libdir)/autoconf/go.m4 \ + $(src_libdir)/autoconf/functions.m4 \ + $(src_libdir)/autoconf/headers.m4 \ + $(src_libdir)/autoconf/types.m4 \ + $(src_libdir)/autoconf/libs.m4 \ + $(src_libdir)/autoconf/programs.m4 \ + $(src_libdir)/autoconf/autoconf.m4 + + +## --------------------------- ## +## Run ETAGS on some M4 code. ## +## --------------------------- ## + +ETAGS_FOR_M4 = \ + --lang=none \ + --regex='/\(m4_define\|define\)(\[\([^]]*\)\]/\2/' + +ETAGS_FOR_M4SUGAR = \ + $(ETAGS_FOR_M4) \ + --regex='/m4_defun(\[\([^]]*\)\]/\1/' + +ETAGS_FOR_AUTOCONF = \ + $(ETAGS_FOR_M4SUGAR) \ + --regex='/\(A[CU]_DEFUN\|AU_ALIAS\)(\[\([^]]*\)\]/\2/' \ + --regex='/AN_\(FUNCTION\|HEADER\|IDENTIFIER\|LIBRARY\|MAKEVAR\|PROGRAM\)(\[\([^]]*\)\]/\2/' + + +## -------------------------------- ## +## Looking for forbidden patterns. ## +## -------------------------------- ## + +check-forbidden-patterns: + @if (cd $(srcdir) && \ + $(GREP) $(forbidden_patterns) $(forbidden_patterns_files)) \ + >forbidden.log; then \ + echo "ERROR: forbidden patterns were found:" >&2; \ + sed "s|^|$*.m4: |" <forbidden.log >&2; \ + echo >&2; \ + exit 1; \ + else \ + rm -f forbidden.log; \ + fi diff --git a/lib/m4sugar/Makefile.am b/lib/m4sugar/Makefile.am new file mode 100644 index 0000000..23824a3 --- /dev/null +++ b/lib/m4sugar/Makefile.am @@ -0,0 +1,75 @@ +# Make Autoconf library for M4sugar. + +# Copyright (C) 2001-2002, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +m4sugarlibdir = $(pkgdatadir)/m4sugar +dist_m4sugarlib_DATA = m4sugar.m4 foreach.m4 m4sh.m4 +nodist_m4sugarlib_DATA = version.m4 m4sugar.m4f m4sh.m4f +CLEANFILES = $(nodist_m4sugarlib_DATA) + +# Get the release year from ../ChangeLog. +RELEASE_YEAR = \ + `sed 's/^\([0-9][0-9][0-9][0-9]\).*/\1/;q' $(top_srcdir)/ChangeLog` + +## ------------ ## +## version.m4. ## +## ------------ ## + +# The `:;' works around a redirected compound command bash exit status bug. +version.m4: Makefile + :;{ \ + echo '# This file is part of -*- Autoconf -*-.' && \ + echo '# Version of Autoconf.' && \ + echo '# Copyright (C) 1999, 2000, 2001, 2002, 2006, 2007, 2009' && \ + echo '# Free Software Foundation, Inc.' && \ + echo &&\ + echo 'm4_define([m4_PACKAGE_NAME], [$(PACKAGE_NAME)])' && \ + echo 'm4_define([m4_PACKAGE_TARNAME], [$(PACKAGE_TARNAME)])' && \ + echo 'm4_define([m4_PACKAGE_VERSION], [$(PACKAGE_VERSION)])' && \ + echo 'm4_define([m4_PACKAGE_STRING], [$(PACKAGE_STRING)])' && \ + echo 'm4_define([m4_PACKAGE_BUGREPORT], [$(PACKAGE_BUGREPORT)])' && \ + echo 'm4_define([m4_PACKAGE_URL], [$(PACKAGE_URL)])' && \ + echo 'm4_define([m4_PACKAGE_YEAR], ['$(RELEASE_YEAR)'])'; \ + } > $@-t + mv $@-t $@ + + +## --------------- ## +## Building TAGS. ## +## --------------- ## + +TAGS_FILES = $(dist_m4sugarlib_DATA) + +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) + + +## -------- ## +## Checks. ## +## -------- ## + +check-local: check-forbidden-patterns +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_m4sugarlib_DATA) + + + +## ------------------ ## +## The frozen files. ## +## ------------------ ## + +m4sugar.m4f: $(m4sugar_m4f_dependencies) +m4sh.m4f: $(m4sh_m4f_dependencies) +include ../freeze.mk diff --git a/lib/m4sugar/Makefile.in b/lib/m4sugar/Makefile.in new file mode 100644 index 0000000..c026628 --- /dev/null +++ b/lib/m4sugar/Makefile.in @@ -0,0 +1,622 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# Make Autoconf library for M4sugar. + +# Copyright (C) 2001-2002, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Freeze M4 files. + +# Copyright (C) 2002, 2004, 2006-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(dist_m4sugarlib_DATA) $(srcdir)/../freeze.mk \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in +subdir = lib/m4sugar +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/make-case.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(m4sugarlibdir)" \ + "$(DESTDIR)$(m4sugarlibdir)" +DATA = $(dist_m4sugarlib_DATA) $(nodist_m4sugarlib_DATA) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMACS = @EMACS@ +EMACSLOADPATH = @EMACSLOADPATH@ +EXPR = @EXPR@ +GREP = @GREP@ +HELP2MAN = @HELP2MAN@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_FLOCK = @PERL_FLOCK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TEST_EMACS = @TEST_EMACS@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_cv_dir_trailing_space = @ac_cv_dir_trailing_space@ +ac_cv_sh_n_works = @ac_cv_sh_n_works@ +ac_cv_unsupported_fs_chars = @ac_cv_unsupported_fs_chars@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +m4sugarlibdir = $(pkgdatadir)/m4sugar +dist_m4sugarlib_DATA = m4sugar.m4 foreach.m4 m4sh.m4 +nodist_m4sugarlib_DATA = version.m4 m4sugar.m4f m4sh.m4f +CLEANFILES = $(nodist_m4sugarlib_DATA) + +# Get the release year from ../ChangeLog. +RELEASE_YEAR = \ + `sed 's/^\([0-9][0-9][0-9][0-9]\).*/\1/;q' $(top_srcdir)/ChangeLog` + +TAGS_FILES = $(dist_m4sugarlib_DATA) +ETAGS_ARGS = $(ETAGS_FOR_AUTOCONF) +forbidden_patterns = -e '^_*EOF' -e ' cmp ' +forbidden_patterns_files = $(dist_m4sugarlib_DATA) +SUFFIXES = .m4 .m4f +AUTOM4TE_CFG = $(top_builddir)/lib/autom4te.cfg + +# Do not use AUTOM4TE here, since maint.mk (my-distcheck) +# checks if we are independent of Autoconf by defining AUTOM4TE (and +# others) to `false'. Autoconf provides autom4te, so that doesn't +# apply to us. +MY_AUTOM4TE = \ + autom4te_perllibdir='$(top_srcdir)'/lib \ + AUTOM4TE_CFG='$(AUTOM4TE_CFG)' $(top_builddir)/bin/autom4te \ + -B '$(top_builddir)'/lib -B '$(top_srcdir)'/lib # keep ` ' + + +# Factor the dependencies between all the frozen files. +# Some day we should explain to Automake how to use autom4te to compute +# the dependencies... +src_libdir = $(top_srcdir)/lib +build_libdir = $(top_builddir)/lib +m4f_dependencies = $(top_builddir)/bin/autom4te $(AUTOM4TE_CFG) +m4sugar_m4f_dependencies = \ + $(m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sugar.m4 \ + $(build_libdir)/m4sugar/version.m4 + +m4sh_m4f_dependencies = \ + $(m4sugar_m4f_dependencies) \ + $(src_libdir)/m4sugar/m4sh.m4 + +autotest_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autotest/autotest.m4 \ + $(src_libdir)/autotest/general.m4 \ + $(src_libdir)/autotest/specific.m4 + +autoconf_m4f_dependencies = \ + $(m4sh_m4f_dependencies) \ + $(src_libdir)/autoconf/autoscan.m4 \ + $(src_libdir)/autoconf/general.m4 \ + $(src_libdir)/autoconf/autoheader.m4 \ + $(src_libdir)/autoconf/autoupdate.m4 \ + $(src_libdir)/autoconf/autotest.m4 \ + $(src_libdir)/autoconf/status.m4 \ + $(src_libdir)/autoconf/oldnames.m4 \ + $(src_libdir)/autoconf/specific.m4 \ + $(src_libdir)/autoconf/lang.m4 \ + $(src_libdir)/autoconf/c.m4 \ + $(src_libdir)/autoconf/fortran.m4 \ + $(src_libdir)/autoconf/erlang.m4 \ + $(src_libdir)/autoconf/go.m4 \ + $(src_libdir)/autoconf/functions.m4 \ + $(src_libdir)/autoconf/headers.m4 \ + $(src_libdir)/autoconf/types.m4 \ + $(src_libdir)/autoconf/libs.m4 \ + $(src_libdir)/autoconf/programs.m4 \ + $(src_libdir)/autoconf/autoconf.m4 + +ETAGS_FOR_M4 = \ + --lang=none \ + --regex='/\(m4_define\|define\)(\[\([^]]*\)\]/\2/' + +ETAGS_FOR_M4SUGAR = \ + $(ETAGS_FOR_M4) \ + --regex='/m4_defun(\[\([^]]*\)\]/\1/' + +ETAGS_FOR_AUTOCONF = \ + $(ETAGS_FOR_M4SUGAR) \ + --regex='/\(A[CU]_DEFUN\|AU_ALIAS\)(\[\([^]]*\)\]/\2/' \ + --regex='/AN_\(FUNCTION\|HEADER\|IDENTIFIER\|LIBRARY\|MAKEVAR\|PROGRAM\)(\[\([^]]*\)\]/\2/' + +all: all-am + +.SUFFIXES: +.SUFFIXES: .m4 .m4f +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(srcdir)/../freeze.mk $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/m4sugar/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu lib/m4sugar/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-dist_m4sugarlibDATA: $(dist_m4sugarlib_DATA) + @$(NORMAL_INSTALL) + test -z "$(m4sugarlibdir)" || $(MKDIR_P) "$(DESTDIR)$(m4sugarlibdir)" + @list='$(dist_m4sugarlib_DATA)'; test -n "$(m4sugarlibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(m4sugarlibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(m4sugarlibdir)" || exit $$?; \ + done + +uninstall-dist_m4sugarlibDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_m4sugarlib_DATA)'; test -n "$(m4sugarlibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(m4sugarlibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(m4sugarlibdir)" && rm -f $$files +install-nodist_m4sugarlibDATA: $(nodist_m4sugarlib_DATA) + @$(NORMAL_INSTALL) + test -z "$(m4sugarlibdir)" || $(MKDIR_P) "$(DESTDIR)$(m4sugarlibdir)" + @list='$(nodist_m4sugarlib_DATA)'; test -n "$(m4sugarlibdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(m4sugarlibdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(m4sugarlibdir)" || exit $$?; \ + done + +uninstall-nodist_m4sugarlibDATA: + @$(NORMAL_UNINSTALL) + @list='$(nodist_m4sugarlib_DATA)'; test -n "$(m4sugarlibdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(m4sugarlibdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(m4sugarlibdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-local +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(m4sugarlibdir)" "$(DESTDIR)$(m4sugarlibdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_m4sugarlibDATA \ + install-nodist_m4sugarlibDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_m4sugarlibDATA \ + uninstall-nodist_m4sugarlibDATA + +.MAKE: check-am install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am check-local clean \ + clean-generic ctags distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am \ + install-dist_m4sugarlibDATA install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man \ + install-nodist_m4sugarlibDATA install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am tags uninstall uninstall-am \ + uninstall-dist_m4sugarlibDATA uninstall-nodist_m4sugarlibDATA + + +# The `:;' works around a redirected compound command bash exit status bug. +version.m4: Makefile + :;{ \ + echo '# This file is part of -*- Autoconf -*-.' && \ + echo '# Version of Autoconf.' && \ + echo '# Copyright (C) 1999, 2000, 2001, 2002, 2006, 2007, 2009' && \ + echo '# Free Software Foundation, Inc.' && \ + echo &&\ + echo 'm4_define([m4_PACKAGE_NAME], [$(PACKAGE_NAME)])' && \ + echo 'm4_define([m4_PACKAGE_TARNAME], [$(PACKAGE_TARNAME)])' && \ + echo 'm4_define([m4_PACKAGE_VERSION], [$(PACKAGE_VERSION)])' && \ + echo 'm4_define([m4_PACKAGE_STRING], [$(PACKAGE_STRING)])' && \ + echo 'm4_define([m4_PACKAGE_BUGREPORT], [$(PACKAGE_BUGREPORT)])' && \ + echo 'm4_define([m4_PACKAGE_URL], [$(PACKAGE_URL)])' && \ + echo 'm4_define([m4_PACKAGE_YEAR], ['$(RELEASE_YEAR)'])'; \ + } > $@-t + mv $@-t $@ + +check-local: check-forbidden-patterns + +m4sugar.m4f: $(m4sugar_m4f_dependencies) +m4sh.m4f: $(m4sh_m4f_dependencies) +$(AUTOM4TE_CFG): $(top_srcdir)/lib/autom4te.in + cd $(top_builddir)/lib && $(MAKE) $(AM_MAKEFLAGS) autom4te.cfg + +# When processing the file with diversion disabled, there must be no +# output but comments and empty lines. +# If freezing produces output, something went wrong: a bad `divert', +# or an improper paren etc. +# It may happen that the output does not end with an end of line, hence +# force an end of line when reporting errors. +.m4.m4f: + $(MY_AUTOM4TE) \ + --language=$* \ + --freeze \ + --output=$@ + +# For parallel builds. +$(build_libdir)/m4sugar/version.m4: + cd $(build_libdir)/m4sugar && $(MAKE) $(AM_MAKEFLAGS) version.m4 + +check-forbidden-patterns: + @if (cd $(srcdir) && \ + $(GREP) $(forbidden_patterns) $(forbidden_patterns_files)) \ + >forbidden.log; then \ + echo "ERROR: forbidden patterns were found:" >&2; \ + sed "s|^|$*.m4: |" <forbidden.log >&2; \ + echo >&2; \ + exit 1; \ + else \ + rm -f forbidden.log; \ + fi + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/lib/m4sugar/foreach.m4 b/lib/m4sugar/foreach.m4 new file mode 100644 index 0000000..3fc1913 --- /dev/null +++ b/lib/m4sugar/foreach.m4 @@ -0,0 +1,362 @@ +# -*- Autoconf -*- +# This file is part of Autoconf. +# foreach-based replacements for recursive functions. +# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes +# GNU M4 1.6 by requiring more memory and macro expansions. +# +# Copyright (C) 2008-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by Eric Blake. + +# In M4 1.4.x, every byte of $@ is rescanned. This means that an +# algorithm on n arguments that recurses with one less argument each +# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In +# M4 1.6, this was fixed so that $@ is only scanned once, then +# back-references are made to information stored about the scan. +# Thus, n iterations need only scan n arguments, for O(n) time. +# Additionally, in M4 1.4.x, recursive algorithms did not clean up +# memory very well, requiring O(n^2) memory rather than O(n) for n +# iterations. +# +# This file is designed to overcome the quadratic nature of $@ +# recursion by writing a variant of m4_foreach that uses m4_for rather +# than $@ recursion to operate on the list. This involves more macro +# expansions, but avoids the need to rescan a quadratic number of +# arguments, making these replacements very attractive for M4 1.4.x. +# On the other hand, in any version of M4, expanding additional macros +# costs additional time; therefore, in M4 1.6, where $@ recursion uses +# fewer macros, these replacements actually pessimize performance. +# Additionally, the use of $10 to mean the tenth argument violates +# POSIX; although all versions of m4 1.4.x support this meaning, a +# future m4 version may switch to take it as the first argument +# concatenated with a literal 0, so the implementations in this file +# are not future-proof. Thus, this file is conditionally included as +# part of m4_init(), only when it is detected that M4 probably has +# quadratic behavior (ie. it lacks the macro __m4_version__). +# +# Please keep this file in sync with m4sugar.m4. + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# This version minimizes the number of times that $@ is evaluated by +# using m4_for to generate a boilerplate into _m4_f then passing $@ to +# that temporary macro. Thus, the recursion is done in m4_for without +# reparsing any user input, and is not quadratic. For an idea of how +# this works, note that m4_foreach(i,[1,2],[i]) calls +# _m4_foreach([m4_define([i],],[)i],[],[1],[2]) +# which defines _m4_f: +# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f]) +# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result: +# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]). +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [m4_pushdef([_m4_f], _m4_for([4], [$#], [1], + [$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])]) + +m4_define([_m4_foreach_], +[[$$1[$$3]$$2[]]]) + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# Find the first VAL that SWITCH matches, and expand the corresponding +# IF-VAL. If there are no matches, expand DEFAULT. +# +# Use m4_for to create a temporary macro in terms of a boilerplate +# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is +# odd, then rounding the last $# up in the temporary macro is +# harmless. For example, both m4_case(1,2,3,4,5) and +# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being +# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) +m4_define([m4_case], +[m4_if(m4_eval([$# <= 2]), [1], [$2], +[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2], + [_$0_(], [)])[_m4_popdef( + [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) + +m4_define([_m4_case_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_case__], +[[[$$1],[$$2],[$$3],]]) + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# We build the temporary macro _m4_b: +# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... +# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) +# then invoke m4_unquote(_m4_b($@)), for concatenation with later text. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_pushdef([_m4_b], [m4_define([_m4_b], + _m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]), + [2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval( + [($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) + +m4_define([_m4_bmatch], +[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) + +m4_define([_m4_bmatch_], +[$0_([1], m4_decr([$1]), [$1])]) + +m4_define([_m4_bmatch__], +[[_m4_b([$$1], [$$2], [$$3])]]) + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. +# We only have to speed up _m4_cond, by building the temporary _m4_c: +# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], +# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], +# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], +# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) +# We invoke m4_unquote(_m4_c($@)), for concatenation with later text. +m4_define([_m4_cond], +[m4_pushdef([_m4_c], [m4_define([_m4_c], + _m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3], + [$0_(], [)])[_m4_c(]m4_dquote(m4_dquote( + [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) + +m4_define([_m4_cond_], +[$0_(m4_decr([$1]), [$1], m4_incr([$1]))]) + +m4_define([_m4_cond__], +[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# m4_bpatsubsts already validated an odd number of arguments; we only +# need to speed up _m4_bpatsubsts. To avoid nesting, we build the +# temporary _m4_p: +# m4_define([_m4_p], [$1])m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( +# _m4_defn([_m4_p])_m4_popdef([_m4_p])) +m4_define([_m4_bpatsubsts], +[m4_pushdef([_m4_p], [m4_define([_m4_p], + ]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(], + [)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) + +m4_define([_m4_bpatsubsts_], +[$0_(m4_decr([$1]), [$1])]) + +m4_define([_m4_bpatsubsts__], +[[m4_define([_m4_p], +m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# m4_shiftn already validated arguments; we only need to speed up +# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as +# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) +# before calling m4_shift(_m4_s($@)). +m4_define([_m4_shiftn], +[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s], + _m4_for(m4_eval([$1 + 2]), [$#], [1], + [[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. +# +# Here, we use the temporary macro _m4_do, defined as +# $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) +m4_define([m4_do], +[m4_if([$#], [0], [], + [m4_pushdef([_$0], _m4_for([1], [$#], [1], + [$], [[[]]])[_m4_popdef([_$0])])_$0($@)])]) + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# _m4_foreach to the rescue. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])]) + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Invoke _m4_r($@) with the temporary _m4_r built as +# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], +[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1], + [[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# Build the temporary macro _m4_map_args_pair, with the $2([$m+1]) +# only output if $# is odd: +# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], +# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair]) +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [m4_pushdef([_$0], _m4_for([3], + m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end( + [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) + +m4_define([_m4_map_args_pair_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_map_args_pair__], +[[$$1([$$2], [$$3])[]]]) + +m4_define([_m4_map_args_pair_end], +[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Use a self-modifying separator, since we don't know how many +# arguments might be skipped before a separator is first printed, but +# be careful if the separator contains $. _m4_foreach to the rescue. +m4_define([m4_join], +[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl +[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])]) + +m4_define([_m4_join], +[m4_if([$2], [], [], [_m4_sep([$1])[$2]])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# A bit easier than m4_join. _m4_foreach to the rescue. +m4_define([m4_joinall], +[[$2]m4_if(m4_eval([$# <= 2]), [1], [], + [_m4_foreach([$1], [], m4_shift($@))])]) + +# m4_list_cmp(A, B) +# ----------------- +# Compare the two lists of integer expressions A and B. +# +# m4_list_cmp takes care of any side effects; we only override +# _m4_list_cmp_raw, where we can safely expand lists multiple times. +# First, insert padding so that both lists are the same length; the +# trailing +0 is necessary to handle a missing list. Next, create a +# temporary macro to perform pairwise comparisons until an inequality +# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as +# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], +# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], +# [0]_m4_popdef([_m4_cmp])) +# then calls _m4_cmp([1+0], [0*2], [1], [2+0]) +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], 0, + [_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), + $2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) + +m4_define([_m4_list_pad], +[m4_if(m4_eval($1 < $2), [1], + [_m4_for(m4_incr([$1]), [$2], [1], [,0*])])]) + +m4_define([_m4_list_cmp], +[m4_pushdef([_m4_cmp], [m4_if(]_m4_for( + [1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[ + [0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)]) + +m4_define([_m4_list_cmp_], +[$0_([$1], m4_eval([$1 + $2]))]) + +m4_define([_m4_list_cmp__], +[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], +]]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here, +# we need a temporary macro to track the best answer so far, so that +# the foreach expression is tractable. +m4_define([_m4_minmax], +[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach( + [m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl +[_m4_best[]_m4_popdef([_m4_best])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# _m4_foreach to the rescue. If no deletions have occurred, then +# avoid the speed penalty of m4_set_add. +m4_define([m4_set_add_all], +[m4_if([$#], [0], [], [$#], [1], [], + [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)], + [[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])]) + +m4_define([_m4_set_add_all], +[m4_ifdef([_m4_set([$1],$2)], [], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], [$2])-])]) diff --git a/lib/m4sugar/m4sh.m4 b/lib/m4sugar/m4sh.m4 new file mode 100644 index 0000000..f05346b --- /dev/null +++ b/lib/m4sugar/m4sh.m4 @@ -0,0 +1,2168 @@ +# This file is part of Autoconf. -*- Autoconf -*- +# M4 sugar for common shell constructs. +# Requires GNU M4 and M4sugar. +# +# Copyright (C) 2000-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by Akim Demaille, Pavel Roskin, Alexandre Oliva, Lars J. Aas +# and many other people. + + +# We heavily use m4's diversions both for the initializations and for +# required macros, because in both cases we have to issue soon in +# output something which is discovered late. +# +# +# KILL is only used to suppress output. +# +# - BINSH +# AC_REQUIRE'd #! /bin/sh line +# - HEADER-REVISION +# RCS keywords etc. +# - HEADER-COMMENT +# Purpose of the script etc. +# - HEADER-COPYRIGHT +# Copyright notice(s) +# - M4SH-SANITIZE +# M4sh's shell setup +# - M4SH-INIT-FN +# M4sh initialization (shell functions) +# - M4SH-INIT +# M4sh initialization (detection code) +# - BODY +# The body of the script. + + +# _m4_divert(DIVERSION-NAME) +# -------------------------- +# Convert a diversion name into its number. Otherwise, return +# DIVERSION-NAME which is supposed to be an actual diversion number. +# Of course it would be nicer to use m4_case here, instead of zillions +# of little macros, but it then takes twice longer to run `autoconf'! +m4_define([_m4_divert(BINSH)], 0) +m4_define([_m4_divert(HEADER-REVISION)], 1) +m4_define([_m4_divert(HEADER-COMMENT)], 2) +m4_define([_m4_divert(HEADER-COPYRIGHT)], 3) +m4_define([_m4_divert(M4SH-SANITIZE)], 4) +m4_define([_m4_divert(M4SH-INIT-FN)], 5) +m4_define([_m4_divert(M4SH-INIT)], 6) +m4_define([_m4_divert(BODY)], 1000) + +# Aaarg. Yet it starts with compatibility issues... Libtool wants to +# use NOTICE to insert its own LIBTOOL-INIT stuff. People should ask +# before diving into our internals :( +m4_copy([_m4_divert(M4SH-INIT)], [_m4_divert(NOTICE)]) + + + +## ------------------------- ## +## 1. Sanitizing the shell. ## +## ------------------------- ## +# Please maintain lexicographic sorting of this section, ignoring leading _. + +# AS_BOURNE_COMPATIBLE +# -------------------- +# Try to be as Bourne and/or POSIX as possible. +# +# This does not set BIN_SH, due to the problems described in +# <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>. +# People who need BIN_SH should set it in their environment before invoking +# configure; apparently this would include UnixWare, as described in +# <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00025.html>. +m4_define([AS_BOURNE_COMPATIBLE], +[# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +_$0 +]) + +# _AS_BOURNE_COMPATIBLE +# --------------------- +# This is the part of AS_BOURNE_COMPATIBLE which has to be repeated inside +# each instance. +m4_define([_AS_BOURNE_COMPATIBLE], +[AS_IF([test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1], + [emulate sh + NULLCMD=: + [#] Pre-4.2 versions of Zsh do word splitting on ${1+"$[@]"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$[@]"}'='"$[@]"' + setopt NO_GLOB_SUBST], + [AS_CASE([`(set -o) 2>/dev/null`], [*posix*], [set -o posix])]) +]) + + +# _AS_CLEANUP +# ----------- +# Expanded as the last thing before m4sugar cleanup begins. Macros +# may append m4sh cleanup hooks to this as appropriate. +m4_define([_AS_CLEANUP], +[m4_divert_text([M4SH-SANITIZE], [_AS_DETECT_BETTER_SHELL])]) + + +# AS_COPYRIGHT(TEXT) +# ------------------ +# Emit TEXT, a copyright notice, as a shell comment near the top of the +# script. TEXT is evaluated once; to accomplish that, we do not prepend +# `# ' but `@%:@ '. +m4_define([AS_COPYRIGHT], +[m4_divert_text([HEADER-COPYRIGHT], +[m4_bpatsubst([ +$1], [^], [@%:@ ])])]) + + +# _AS_DETECT_EXPAND(VAR, SET) +# --------------------------- +# Assign the contents of VAR from the contents of SET, expanded in such +# a manner that VAR can be passed to _AS_RUN. In order to make +# _AS_LINENO_WORKS operate correctly, we must specially handle the +# first instance of $LINENO within any line being expanded (the first +# instance is important to tests using the current shell, leaving +# remaining instances for tests using a candidate shell). Bash loses +# track of line numbers if a double quote contains a newline, hence, +# we must piece-meal the assignment of VAR such that $LINENO expansion +# occurs in a single line. +m4_define([_AS_DETECT_EXPAND], +[$1="m4_bpatsubst(m4_dquote(AS_ESCAPE(_m4_expand(m4_set_contents([$2], [ +])))), [\\\$LINENO\(.*\)$], [";$1=$$1$LINENO;$1=$$1"\1])"]) + + +# _AS_DETECT_REQUIRED(TEST) +# ------------------------- +# Refuse to execute under a shell that does not pass the given TEST. +# Does not do AS_REQUIRE for the better-shell detection code. +# +# M4sh should never require something not required by POSIX, although +# other clients are free to do so. +m4_defun([_AS_DETECT_REQUIRED], +[m4_set_add([_AS_DETECT_REQUIRED_BODY], [$1 || AS_EXIT])]) + + +# _AS_DETECT_SUGGESTED(TEST) +# -------------------------- +# Prefer to execute under a shell that passes the given TEST. +# Does not do AS_REQUIRE for the better-shell detection code. +# +# M4sh should never suggest something not required by POSIX, although +# other clients are free to do so. +m4_defun([_AS_DETECT_SUGGESTED], +[m4_set_add([_AS_DETECT_SUGGESTED_BODY], [$1 || AS_EXIT])]) + + +# _AS_DETECT_SUGGESTED_PRUNE(TEST) +# -------------------------------- +# If TEST is also a required test, remove it from the set of suggested tests. +m4_define([_AS_DETECT_SUGGESTED_PRUNE], +[m4_set_contains([_AS_DETECT_REQUIRED_BODY], [$1], + [m4_set_remove([_AS_DETECT_SUGGESTED_BODY], [$1])])]) + + +# _AS_DETECT_BETTER_SHELL +# ----------------------- +# The real workhorse for detecting a shell with the correct +# features. +# +# In previous versions, we prepended /usr/posix/bin to the path, but that +# caused a regression on OpenServer 6.0.0 +# <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00017.html> +# and on HP-UX 11.11, see the failure of test 120 in +# <http://lists.gnu.org/archive/html/bug-autoconf/2006-10/msg00003.html> +# +# FIXME: The code should test for the OSF bug described in +# <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>. +# +# This code is run outside any trap 0 context, hence we can simplify AS_EXIT. +m4_defun([_AS_DETECT_BETTER_SHELL], +dnl +dnl By default, do not force re-execution of the script just because +dnl the user has pre-set $CONFIG_SHELL; do so only if the m4sh client has +dnl defined the internal variable `_AS_FORCE_REEXEC_WITH_CONFIG_SHELL' to +dnl "yes". +dnl FIXME: This interface is acceptable for the moment, as a private, +dnl FIXME: internal one; but if we want to make the "always re-execute" +dnl FIXME: feature public, we should find a better interface! +[m4_if(_AS_FORCE_REEXEC_WITH_CONFIG_SHELL, [yes], + [# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + _AS_REEXEC_WITH_SHELL([$CONFIG_SHELL]) + fi + # We don't want this to propagate to other subprocesses. + dnl This might be especially important in case an m4sh-generated script + dnl is used to later execute other m4sh-generated scripts. This happens + dnl for example in autoconf's own testsuite (and happens *a lot* there, + dnl in fact). + AS_UNSET([_as_can_reexec]) +])]dnl +dnl Remove any tests from suggested that are also required +[m4_set_map([_AS_DETECT_SUGGESTED_BODY], [_AS_DETECT_SUGGESTED_PRUNE])]dnl +[m4_pushdef([AS_EXIT], [exit m4_default(]m4_dquote([$][1])[, 1)])]dnl +[if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="AS_ESCAPE(_m4_expand([_AS_BOURNE_COMPATIBLE]))" + _AS_DETECT_EXPAND([as_required], [_AS_DETECT_REQUIRED_BODY]) + _AS_DETECT_EXPAND([as_suggested], [_AS_DETECT_SUGGESTED_BODY]) + AS_IF([_AS_RUN(["$as_required"])], + [as_have_required=yes], + [as_have_required=no]) + AS_IF([test x$as_have_required = xyes && _AS_RUN(["$as_suggested"])], + [], + [_AS_PATH_WALK([/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH], + [case $as_dir in @%:@( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + AS_IF([{ test -f "$as_shell" || test -f "$as_shell.exe"; } && + _AS_RUN(["$as_required"], ["$as_shell"])], + [CONFIG_SHELL=$as_shell as_have_required=yes + m4_set_empty([_AS_DETECT_SUGGESTED_BODY], [break 2], + [AS_IF([_AS_RUN(["$as_suggested"], ["$as_shell"])], + [break 2])])]) + done;; + esac], + [AS_IF([{ test -f "$SHELL" || test -f "$SHELL.exe"; } && + _AS_RUN(["$as_required"], ["$SHELL"])], + [CONFIG_SHELL=$SHELL as_have_required=yes])]) + + AS_IF([test "x$CONFIG_SHELL" != x], + [export CONFIG_SHELL + _AS_REEXEC_WITH_SHELL([$CONFIG_SHELL])]) + +dnl Unfortunately, $as_me isn't available here. + AS_IF([test x$as_have_required = xno], + [AS_ECHO(["$[]0: This script requires a shell more modern than all"]) + AS_ECHO(["$[]0: the shells that I found on your system."]) + if test x${ZSH_VERSION+set} = xset ; then + AS_ECHO(["$[]0: In particular, zsh $ZSH_VERSION has bugs and should"]) + AS_ECHO(["$[]0: be upgraded to zsh 4.3.4 or later."]) + else + AS_ECHO("m4_text_wrap([Please tell ]_m4_defn([m4_PACKAGE_BUGREPORT]) +m4_ifset([AC_PACKAGE_BUGREPORT], [m4_if(_m4_defn([m4_PACKAGE_BUGREPORT]), +_m4_defn([AC_PACKAGE_BUGREPORT]), [], [and _m4_defn([AC_PACKAGE_BUGREPORT])])]) +[about your system, including any error possibly output before this message. +Then install a modern shell, or manually run the script under such a +shell if you do have one.], [$[]0: ], [], [62])") + fi + AS_EXIT])]) +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS +_m4_popdef([AS_EXIT])])# _AS_DETECT_BETTER_SHELL + +# _AS_REEXEC_WITH_SHELL(SHELL) +# ---------------------------- +# Re-execute the current script with the given shell, trying to preserve +# portable settings (e.g., the `xtrace' and `verbose' shell flag). +m4_defun([_AS_REEXEC_WITH_SHELL], [dnl +# We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in @%:@ (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $1 $as_opts "$as_myself" ${1+"$[@]"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +AS_ECHO(["$[]0: could not re-execute with $1"]) >&2 +AS_EXIT([255])])# _AS_REEXEC_WITH_SHELL + + +# _AS_PREPARE +# ----------- +# This macro has a very special status. Normal use of M4sh relies +# heavily on AS_REQUIRE, so that needed initializations (such as +# _AS_TEST_PREPARE) are performed on need, not on demand. But +# Autoconf is the first client of M4sh, and for two reasons: configure +# and config.status. Relying on AS_REQUIRE is of course fine for +# configure, but fails for config.status (which is created by +# configure). So we need a means to force the inclusion of the +# various _AS_*_PREPARE on top of config.status. That's basically why +# there are so many _AS_*_PREPARE below, and that's also why it is +# important not to forget some: config.status needs them. +# List any preparations that create shell functions first, then +# topologically sort the others by their dependencies. +# +# Special case: we do not need _AS_LINENO_PREPARE, because the +# parent will have substituted $LINENO for us when processing its +# own invocation of _AS_LINENO_PREPARE. +# +# Special case: the full definition of _AS_ERROR_PREPARE is not output +# unless AS_MESSAGE_LOG_FD is non-empty, although the value of +# AS_MESSAGE_LOG_FD is not relevant. +m4_defun([_AS_PREPARE], +[m4_pushdef([AS_REQUIRE])]dnl +[m4_pushdef([AS_REQUIRE_SHELL_FN], _m4_defn([_AS_REQUIRE_SHELL_FN]) +)]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD], [-1])]dnl +[_AS_ERROR_PREPARE +_m4_popdef([AS_MESSAGE_LOG_FD])]dnl +[_AS_EXIT_PREPARE +_AS_UNSET_PREPARE +_AS_VAR_APPEND_PREPARE +_AS_VAR_ARITH_PREPARE + +_AS_EXPR_PREPARE +_AS_BASENAME_PREPARE +_AS_DIRNAME_PREPARE +_AS_ME_PREPARE +_AS_CR_PREPARE +_AS_ECHO_N_PREPARE +_AS_LN_S_PREPARE +_AS_MKDIR_P_PREPARE +_AS_TEST_PREPARE +_AS_TR_CPP_PREPARE +_AS_TR_SH_PREPARE +_m4_popdef([AS_REQUIRE], [AS_REQUIRE_SHELL_FN])]) + +# AS_PREPARE +# ---------- +# Output all the M4sh possible initialization into the initialization +# diversion. We do not use _AS_PREPARE so that the m4_provide symbols for +# AS_REQUIRE and AS_REQUIRE_SHELL_FN are defined properly, and so that +# shell functions are placed in M4SH-INIT-FN. +m4_defun([AS_PREPARE], +[m4_divert_push([KILL]) +m4_append_uniq([_AS_CLEANUP], + [m4_divert_text([M4SH-INIT-FN], [_AS_ERROR_PREPARE[]])]) +AS_REQUIRE([_AS_EXPR_PREPARE]) +AS_REQUIRE([_AS_BASENAME_PREPARE]) +AS_REQUIRE([_AS_DIRNAME_PREPARE]) +AS_REQUIRE([_AS_ME_PREPARE]) +AS_REQUIRE([_AS_CR_PREPARE]) +AS_REQUIRE([_AS_LINENO_PREPARE]) +AS_REQUIRE([_AS_ECHO_N_PREPARE]) +AS_REQUIRE([_AS_EXIT_PREPARE]) +AS_REQUIRE([_AS_LN_S_PREPARE]) +AS_REQUIRE([_AS_MKDIR_P_PREPARE]) +AS_REQUIRE([_AS_TEST_PREPARE]) +AS_REQUIRE([_AS_TR_CPP_PREPARE]) +AS_REQUIRE([_AS_TR_SH_PREPARE]) +AS_REQUIRE([_AS_UNSET_PREPARE]) +AS_REQUIRE([_AS_VAR_APPEND_PREPARE], [], [M4SH-INIT-FN]) +AS_REQUIRE([_AS_VAR_ARITH_PREPARE], [], [M4SH-INIT-FN]) +m4_divert_pop[]]) + + +# AS_REQUIRE(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# [DIVERSION = M4SH-INIT]) +# ----------------------------------------------------------- +# BODY-TO-EXPAND is some initialization which must be expanded in the +# given diversion when expanded (required or not). The expansion +# goes in the named diversion or an earlier one. +# +# Since $2 can be quite large, this is factored for faster execution, giving +# either m4_require([$1], [$2]) or m4_divert_require(desired, [$1], [$2]). +m4_defun([AS_REQUIRE], +[m4_define([_m4_divert_desired], [m4_default_quoted([$3], [M4SH-INIT])])]dnl +[m4_if(m4_eval(_m4_divert_dump - 0 <= _m4_divert(_m4_divert_desired, [-])), + 1, [m4_require(], + [m4_divert_require(_m4_divert_desired,]) [$1], [$2])]) + +# _AS_REQUIRE_SHELL_FN(NAME-TO-CHECK, COMMENT, BODY-TO-EXPAND) +# ------------------------------------------------------------ +# Core of AS_REQUIRE_SHELL_FN, but without diversion support. +m4_define([_AS_REQUIRE_SHELL_FN], [ +m4_n([$2])$1 () +{ +$3 +} @%:@ $1[]]) + +# AS_REQUIRE_SHELL_FN(NAME-TO-CHECK, COMMENT, BODY-TO-EXPAND, +# [DIVERSION = M4SH-INIT-FN]) +# ----------------------------------------------------------- +# BODY-TO-EXPAND is the body of a shell function to be emitted in the +# given diversion when expanded (required or not). Unlike other +# xx_REQUIRE macros, BODY-TO-EXPAND is mandatory. If COMMENT is +# provided (often via AS_FUNCTION_DESCRIBE), it is listed with a +# newline before the function name. +m4_define([AS_REQUIRE_SHELL_FN], +[m4_provide_if([AS_SHELL_FN_$1], [], +[AS_REQUIRE([AS_SHELL_FN_$1], +[m4_provide([AS_SHELL_FN_$1])_$0($@)], +m4_default_quoted([$4], [M4SH-INIT-FN]))])]) + + +# _AS_RUN(TEST, [SHELL]) +# ---------------------- +# Run TEST under the current shell (if one parameter is used) +# or under the given SHELL, protecting it from syntax errors. +# Set as_run in order to assist _AS_LINENO_WORKS. +m4_define([_AS_RUN], +[m4_ifval([$2], [{ $as_echo "$as_bourne_compatible"$1 | as_run=a $2; }], + [(eval $1)]) 2>/dev/null]) + + +# _AS_SHELL_FN_WORK +# ----------------- +# This is a spy to detect "in the wild" shells that do not support shell +# functions correctly. It is based on the m4sh.at Autotest testcases. +m4_define([_AS_SHELL_FN_WORK], +[as_fn_return () { (exit [$]1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +AS_IF([( set x; as_fn_ret_success y && test x = "[$]1" )], [], + [exitcode=1; echo positional parameters were not saved.]) +test x$exitcode = x0[]])# _AS_SHELL_FN_WORK + + +# _AS_SHELL_SANITIZE +# ------------------ +# This is the prolog that is emitted by AS_INIT and AS_INIT_GENERATED; +# it is executed prior to shell function definitions, hence the +# temporary redefinition of AS_EXIT. +m4_defun([_AS_SHELL_SANITIZE], +[m4_pushdef([AS_EXIT], [exit m4_default(]m4_dquote([$][1])[, 1)])]dnl +[m4_text_box([M4sh Initialization.]) + +AS_BOURNE_COMPATIBLE +_AS_ECHO_PREPARE +_AS_PATH_SEPARATOR_PREPARE + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $[0] in @%:@(( + *[[\\/]]* ) as_myself=$[0] ;; + *) _AS_PATH_WALK([], + [test -r "$as_dir/$[0]" && as_myself=$as_dir/$[0] && break]) + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$[0] +fi +if test ! -f "$as_myself"; then + AS_ECHO(["$as_myself: error: cannot find myself; rerun with an absolute file name"]) >&2 + AS_EXIT +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH +_m4_popdef([AS_EXIT])])# _AS_SHELL_SANITIZE + + +# AS_SHELL_SANITIZE +# ----------------- +# This is only needed for the sake of Libtool, which screws up royally +# in its usage of M4sh internals. +m4_define([AS_SHELL_SANITIZE], +[_AS_SHELL_SANITIZE +m4_provide_if([AS_INIT], [], +[m4_provide([AS_INIT]) +_AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK]) +_AS_DETECT_REQUIRED([_AS_TEST_X_WORKS]) +_AS_DETECT_BETTER_SHELL +_AS_UNSET_PREPARE +])]) + + +## ----------------------------- ## +## 2. Wrappers around builtins. ## +## ----------------------------- ## + +# This section is lexicographically sorted. + + +# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT]) +# ---------------------------------------------------- +# Expand into +# | case WORD in #( +# | PATTERN1) IF-MATCHED1 ;; #( +# | ... +# | *) DEFAULT ;; +# | esac +# The shell comments are intentional, to work around people who don't +# realize the impacts of using insufficient m4 quoting. This macro +# always uses : and provides a default case, to work around Solaris +# /bin/sh bugs regarding the exit status. +m4_define([_AS_CASE], +[ [@%:@(] + $1[)] : + $2 ;;]) +m4_define([_AS_CASE_DEFAULT], +[ [@%:@(] + *[)] : + $1 ;;]) + +m4_defun([AS_CASE], +[case $1 in[]m4_map_args_pair([_$0], [_$0_DEFAULT], + m4_shift($@m4_if(m4_eval([$# & 1]), [1], [,]))) +esac])# AS_CASE + + +# _AS_EXIT_PREPARE +# ---------------- +# Ensure AS_EXIT and AS_SET_STATUS will work. +# +# We cannot simply use "exit N" because some shells (zsh and Solaris sh) +# will not set $? to N while running the code set by "trap 0" +# Some shells fork even for (exit N), so we use a helper function +# to set $? prior to the exit. +# Then there are shells that don't inherit $? correctly into the start of +# a shell function, so we must always be given an argument. +# Other shells don't use `$?' as default for `exit', hence just repeating +# the exit value can only help improving portability. +m4_defun([_AS_EXIT_PREPARE], +[AS_REQUIRE_SHELL_FN([as_fn_set_status], + [AS_FUNCTION_DESCRIBE([as_fn_set_status], [STATUS], + [Set $? to STATUS, without forking.])], [ return $[]1])]dnl +[AS_REQUIRE_SHELL_FN([as_fn_exit], + [AS_FUNCTION_DESCRIBE([as_fn_exit], [STATUS], + [Exit the shell with STATUS, even in a "trap 0" or "set -e" context.])], +[ set +e + as_fn_set_status $[1] + exit $[1]])])#_AS_EXIT_PREPARE + + +# AS_EXIT([EXIT-CODE = $?]) +# ------------------------- +# Exit, with status set to EXIT-CODE in the way that it's seen +# within "trap 0", and without interference from "set -e". If +# EXIT-CODE is omitted, then use $?. +m4_defun([AS_EXIT], +[AS_REQUIRE([_AS_EXIT_PREPARE])[]as_fn_exit m4_ifval([$1], [$1], [$][?])]) + + +# AS_FOR(MACRO, SHELL-VAR, [LIST = "$@"], [BODY = :]) +# --------------------------------------------------- +# Expand to a shell loop that assigns SHELL-VAR to each of the +# whitespace-separated entries in LIST (or "$@" if LIST is empty), +# then executes BODY. BODY may call break to abort the loop, or +# continue to proceed with the next element of LIST. Requires that +# IFS be set to the normal space-tab-newline. As an optimization, +# BODY should access MACRO rather than $SHELL-VAR. Normally, MACRO +# expands to $SHELL-VAR, but if LIST contains only a single element +# that needs no additional shell quoting, then MACRO will expand to +# that element, thus providing a direct value rather than a shell +# variable indirection. +# +# Only use the optimization if LIST can be used without additional +# shell quoting in either a literal or double-quoted context (that is, +# we give up on default IFS chars, parameter expansion, command +# substitution, shell quoting, globs, or quadrigraphs). Inline the +# m4_defn for speed. +m4_defun([AS_FOR], +[m4_pushdef([$1], m4_if([$3], [], [[$$2]], m4_translit([$3], ]dnl +m4_dquote(_m4_defn([m4_cr_symbols2]))[[%+=:,./-]), [], [[$3]], [[$$2]]))]dnl +[for $2[]m4_ifval([$3], [ in $3]) +do : + $4 +done[]_m4_popdef([$1])]) + + +# AS_IF(TEST1, [IF-TRUE1 = :]...[IF-FALSE = :]) +# --------------------------------------------- +# Expand into +# | if TEST1; then +# | IF-TRUE1 +# | elif TEST2; then +# | IF-TRUE2 +# [...] +# | else +# | IF-FALSE +# | fi +# with simplifications when IF-TRUE1 and/or IF-FALSE are empty. +# +m4_define([_AS_IF], +[elif $1; then : + $2 +]) +m4_define([_AS_IF_ELSE], +[m4_ifnblank([$1], +[else + $1 +])]) + +m4_defun([AS_IF], +[if $1; then : + $2 +m4_map_args_pair([_$0], [_$0_ELSE], m4_shift2($@))]dnl +[fi[]])# AS_IF + + +# AS_SET_STATUS(STATUS) +# --------------------- +# Set the shell status ($?) to STATUS, without forking. +m4_defun([AS_SET_STATUS], +[AS_REQUIRE([_AS_EXIT_PREPARE])[]as_fn_set_status $1]) + + +# _AS_UNSET_PREPARE +# ----------------- +# Define $as_unset to execute AS_UNSET, for backwards compatibility +# with older versions of M4sh. +m4_defun([_AS_UNSET_PREPARE], +[AS_FUNCTION_DESCRIBE([as_fn_unset], [VAR], [Portably unset VAR.]) +as_fn_unset () +{ + AS_UNSET([$[1]]) +} +as_unset=as_fn_unset]) + + +# AS_UNSET(VAR) +# ------------- +# Unset the env VAR, working around shells that do not allow unsetting +# a variable that is not already set. You should not unset MAIL and +# MAILCHECK, as that triggers a bug in Bash 2.01. +m4_defun([AS_UNSET], +[{ AS_LITERAL_WORD_IF([$1], [], [eval ])$1=; unset $1;}]) + + + + + + +## ------------------------------------------ ## +## 3. Error and warnings at the shell level. ## +## ------------------------------------------ ## + + +# AS_MESSAGE_FD +# ------------- +# Must expand to the fd where messages will be sent. Defaults to 1, +# although a script may reassign this value and use exec to either +# copy stdout to the new fd, or open the new fd on /dev/null. +m4_define([AS_MESSAGE_FD], [1]) + +# AS_MESSAGE_LOG_FD +# ----------------- +# Must expand to either the empty string (when no logging is +# performed), or to the fd of a log file. Defaults to empty, although +# a script may reassign this value and use exec to open a log. When +# not empty, messages to AS_MESSAGE_FD are duplicated to the log, +# along with a LINENO reference. +m4_define([AS_MESSAGE_LOG_FD]) + + +# AS_ORIGINAL_STDIN_FD +# -------------------- +# Must expand to the fd of the script's original stdin. Defaults to +# 0, although the script may reassign this value and use exec to +# shuffle fd's. +m4_define([AS_ORIGINAL_STDIN_FD], [0]) + + +# AS_ESCAPE(STRING, [CHARS = `\"$]) +# --------------------------------- +# Add backslash escaping to the CHARS in STRING. In an effort to +# optimize use of this macro inside double-quoted shell constructs, +# the behavior is intentionally undefined if CHARS is longer than 4 +# bytes, or contains bytes outside of the set [`\"$]. However, +# repeated bytes within the set are permissible (AS_ESCAPE([$1], [""]) +# being a common way to be nice to syntax highlighting). +# +# Avoid the m4_bpatsubst if there are no interesting characters to escape. +# _AS_ESCAPE bypasses argument defaulting. +m4_define([AS_ESCAPE], +[_$0([$1], m4_if([$2], [], [[`], [\"$]], [m4_substr([$2], [0], [1]), [$2]]))]) + +# _AS_ESCAPE(STRING, KEY, SET) +# ---------------------------- +# Backslash-escape all instances of the single byte KEY or up to four +# bytes in SET occurring in STRING. Although a character can occur +# multiple times, optimum efficiency occurs when KEY and SET are +# distinct, and when SET does not exceed two bytes. These particular +# semantics allow for the fewest number of parses of STRING, as well +# as taking advantage of the optimizations in m4 1.4.13+ when +# m4_translit is passed SET of size 2 or smaller. +m4_define([_AS_ESCAPE], +[m4_if(m4_index(m4_translit([[$1]], [$3], [$2$2$2$2]), [$2]), [-1], + [$0_], [m4_bpatsubst])([$1], [[$2$3]], [\\\&])]) +m4_define([_AS_ESCAPE_], [$1]) + + +# _AS_QUOTE(STRING) +# ----------------- +# If there are quoted (via backslash) backquotes, output STRING +# literally and warn; otherwise, output STRING with ` and " quoted. +# +# Compatibility glue between the old AS_MSG suite which did not +# quote anything, and the modern suite which quotes the quotes. +# If STRING contains `\\' or `\$', it's modern. +# If STRING contains `\"' or `\`', it's old. +# Otherwise it's modern. +# +# Profiling shows that m4_index is 5 to 8x faster than m4_bregexp. The +# slower implementation used: +# m4_bmatch([$1], +# [\\[\\$]], [$2], +# [\\[`"]], [$3], +# [$2]) +# The current implementation caters to the common case of no backslashes, +# to minimize m4_index expansions (hence the nested if). +m4_define([_AS_QUOTE], +[m4_cond([m4_index([$1], [\])], [-1], [_AS_QUOTE_MODERN], + [m4_eval(m4_index(m4_translit([[$1]], [$], [\]), [\\]) >= 0)], +[1], [_AS_QUOTE_MODERN], + [m4_eval(m4_index(m4_translit([[$1]], ["], [`]), [\`]) >= 0)],dnl" +[1], [_AS_QUOTE_OLD], + [_AS_QUOTE_MODERN])([$1])]) + +m4_define([_AS_QUOTE_MODERN], +[_AS_ESCAPE([$1], [`], [""])]) + +m4_define([_AS_QUOTE_OLD], +[m4_warn([obsolete], + [back quotes and double quotes must not be escaped in: $1])$1]) + + +# _AS_ECHO_UNQUOTED(STRING, [FD = AS_MESSAGE_FD]) +# ----------------------------------------------- +# Perform shell expansions on STRING and echo the string to FD. +m4_define([_AS_ECHO_UNQUOTED], +[AS_ECHO(["$1"]) >&m4_default([$2], [AS_MESSAGE_FD])]) + + +# _AS_ECHO(STRING, [FD = AS_MESSAGE_FD]) +# -------------------------------------- +# Protect STRING from backquote expansion, echo the result to FD. +m4_define([_AS_ECHO], +[_AS_ECHO_UNQUOTED([_AS_QUOTE([$1])], [$2])]) + + +# _AS_ECHO_LOG(STRING) +# -------------------- +# Log the string to AS_MESSAGE_LOG_FD. +m4_defun_init([_AS_ECHO_LOG], +[AS_REQUIRE([_AS_LINENO_PREPARE])], +[_AS_ECHO([$as_me:${as_lineno-$LINENO}: $1], AS_MESSAGE_LOG_FD)]) + + +# _AS_ECHO_N_PREPARE +# ------------------ +# Check whether to use -n, \c, or newline-tab to separate +# checking messages from result messages. +# Don't try to cache, since the results of this macro are needed to +# display the checking message. In addition, caching something used once +# has little interest. +# Idea borrowed from dist 3.0. Use `*c*,', not `*c,' because if `\c' +# failed there is also a newline to match. Use `xy' because `\c' echoed +# in a command substitution prints only the first character of the output +# with ksh version M-11/16/88f on AIX 6.1; it needs to be reset by another +# backquoted echo. +m4_defun([_AS_ECHO_N_PREPARE], +[ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in @%:@((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac +])# _AS_ECHO_N_PREPARE + + +# _AS_ECHO_N(STRING, [FD = AS_MESSAGE_FD]) +# ---------------------------------------- +# Same as _AS_ECHO, but echo doesn't return to a new line. +m4_define([_AS_ECHO_N], +[AS_ECHO_N(["_AS_QUOTE([$1])"]) >&m4_default([$2], [AS_MESSAGE_FD])]) + + +# AS_MESSAGE(STRING, [FD = AS_MESSAGE_FD]) +# ---------------------------------------- +# Output "`basename $0`: STRING" to the open file FD, and if logging +# is enabled, copy it to the log with a reference to LINENO. +m4_defun_init([AS_MESSAGE], +[AS_REQUIRE([_AS_ME_PREPARE])], +[m4_ifval(AS_MESSAGE_LOG_FD, + [{ _AS_ECHO_LOG([$1]) +_AS_ECHO([$as_me: $1], [$2]);}], + [_AS_ECHO([$as_me: $1], [$2])])[]]) + + +# AS_WARN(PROBLEM) +# ---------------- +# Output "`basename $0`: WARNING: PROBLEM" to stderr. +m4_define([AS_WARN], +[AS_MESSAGE([WARNING: $1], [2])])# AS_WARN + + +# _AS_ERROR_PREPARE +# ----------------- +# Output the shell function used by AS_ERROR. This is designed to be +# expanded during the m4_wrap cleanup. +# +# If AS_MESSAGE_LOG_FD is non-empty at the end of the script, then +# make this function take optional parameters that use LINENO at the +# points where AS_ERROR was expanded with non-empty AS_MESSAGE_LOG_FD; +# otherwise, assume the entire script does not do logging. +m4_define([_AS_ERROR_PREPARE], +[AS_REQUIRE_SHELL_FN([as_fn_error], + [AS_FUNCTION_DESCRIBE([as_fn_error], [STATUS ERROR]m4_ifval(AS_MESSAGE_LOG_FD, + [[ [[LINENO LOG_FD]]]]), + [Output "`basename @S|@0`: error: ERROR" to stderr.] +m4_ifval(AS_MESSAGE_LOG_FD, + [[If LINENO and LOG_FD are provided, also output the error to LOG_FD, + referencing LINENO.]]) + [Then exit the script with STATUS, using 1 if that was 0.])], +[ as_status=$[1]; test $as_status -eq 0 && as_status=1 +m4_ifval(AS_MESSAGE_LOG_FD, +[m4_pushdef([AS_MESSAGE_LOG_FD], [$[4]])dnl + if test "$[4]"; then + AS_LINENO_PUSH([$[3]]) + _AS_ECHO_LOG([error: $[2]]) + fi +m4_define([AS_MESSAGE_LOG_FD])], [m4_pushdef([AS_MESSAGE_LOG_FD])])dnl + AS_MESSAGE([error: $[2]], [2]) +_m4_popdef([AS_MESSAGE_LOG_FD])dnl + AS_EXIT([$as_status])])]) + +# AS_ERROR(ERROR, [EXIT-STATUS = max($?/1)]) +# ------------------------------------------ +# Output "`basename $0`: error: ERROR" to stderr, then exit the +# script with EXIT-STATUS. +m4_defun_init([AS_ERROR], +[m4_append_uniq([_AS_CLEANUP], + [m4_divert_text([M4SH-INIT-FN], [_AS_ERROR_PREPARE[]])])], +[as_fn_error m4_default([$2], [$?]) "_AS_QUOTE([$1])"m4_ifval(AS_MESSAGE_LOG_FD, + [ "$LINENO" AS_MESSAGE_LOG_FD])]) + + +# AS_LINENO_PUSH([LINENO]) +# ------------------------ +# If this is the outermost call to AS_LINENO_PUSH, make sure that +# AS_MESSAGE will print LINENO as the line number. +m4_defun([AS_LINENO_PUSH], +[as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack]) + + +# AS_LINENO_POP([LINENO]) +# ----------------------- +# If this is call balances the outermost call to AS_LINENO_PUSH, +# AS_MESSAGE will restart printing $LINENO as the line number. +# +# No need to use AS_UNSET, since as_lineno is necessarily set. +m4_defun([AS_LINENO_POP], +[eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno]) + + + +## -------------------------------------- ## +## 4. Portable versions of common tools. ## +## -------------------------------------- ## + +# This section is lexicographically sorted. + + +# AS_BASENAME(FILE-NAME) +# ---------------------- +# Simulate the command 'basename FILE-NAME'. Not all systems have basename. +# Also see the comments for AS_DIRNAME. + +m4_defun([_AS_BASENAME_EXPR], +[$as_expr X/[]$1 : '.*/\([[^/][^/]*]\)/*$' \| \ + X[]$1 : 'X\(//\)$' \| \ + X[]$1 : 'X\(/\)' \| .]) + +m4_defun([_AS_BASENAME_SED], +[AS_ECHO([X/[]$1]) | + sed ['/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q']]) + +m4_defun_init([AS_BASENAME], +[AS_REQUIRE([_$0_PREPARE])], +[$as_basename -- $1 || +_AS_BASENAME_EXPR([$1]) 2>/dev/null || +_AS_BASENAME_SED([$1])]) + + +# _AS_BASENAME_PREPARE +# -------------------- +# Avoid Solaris 9 /usr/ucb/basename, as `basename /' outputs an empty line. +# Also, traditional basename mishandles --. Require here _AS_EXPR_PREPARE, +# to avoid problems when _AS_BASENAME is called from the M4SH-INIT diversion. +m4_defun([_AS_BASENAME_PREPARE], +[AS_REQUIRE([_AS_EXPR_PREPARE])]dnl +[if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi +])# _AS_BASENAME_PREPARE + + +# AS_DIRNAME(FILE-NAME) +# --------------------- +# Simulate the command 'dirname FILE-NAME'. Not all systems have dirname. +# This macro must be usable from inside ` `. +# +# Prefer expr to echo|sed, since expr is usually faster and it handles +# backslashes and newlines correctly. However, older expr +# implementations (e.g. SunOS 4 expr and Solaris 8 /usr/ucb/expr) have +# a silly length limit that causes expr to fail if the matched +# substring is longer than 120 bytes. So fall back on echo|sed if +# expr fails. +m4_defun_init([_AS_DIRNAME_EXPR], +[AS_REQUIRE([_AS_EXPR_PREPARE])], +[$as_expr X[]$1 : 'X\(.*[[^/]]\)//*[[^/][^/]]*/*$' \| \ + X[]$1 : 'X\(//\)[[^/]]' \| \ + X[]$1 : 'X\(//\)$' \| \ + X[]$1 : 'X\(/\)' \| .]) + +m4_defun([_AS_DIRNAME_SED], +[AS_ECHO([X[]$1]) | + sed ['/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q']]) + +m4_defun_init([AS_DIRNAME], +[AS_REQUIRE([_$0_PREPARE])], +[$as_dirname -- $1 || +_AS_DIRNAME_EXPR([$1]) 2>/dev/null || +_AS_DIRNAME_SED([$1])]) + + +# _AS_DIRNAME_PREPARE +# ------------------- +m4_defun([_AS_DIRNAME_PREPARE], +[AS_REQUIRE([_AS_EXPR_PREPARE])]dnl +[if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi +])# _AS_DIRNAME_PREPARE + + +# AS_ECHO(WORD) +# ------------- +# Output WORD followed by a newline. WORD must be a single shell word +# (typically a quoted string). The bytes of WORD are output as-is, even +# if it starts with "-" or contains "\". +m4_defun_init([AS_ECHO], +[AS_REQUIRE([_$0_PREPARE])], +[$as_echo $1]) + + +# AS_ECHO_N(WORD) +# --------------- +# Like AS_ECHO(WORD), except do not output the trailing newline. +m4_defun_init([AS_ECHO_N], +[AS_REQUIRE([_AS_ECHO_PREPARE])], +[$as_echo_n $1]) + + +# _AS_ECHO_PREPARE +# ---------------- +# Arrange for $as_echo 'FOO' to echo FOO without escape-interpretation; +# and similarly for $as_echo_n, which omits the trailing newline. +# 'FOO' is an optional single argument; a missing FOO is treated as empty. +m4_defun([_AS_ECHO_PREPARE], +[[as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$][1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$][1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$][1; + case $arg in @%:@( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi +]])# _AS_ECHO_PREPARE + + +# AS_TEST_X +# --------- +# Check whether a file has executable or search permissions. +# FIXME: This macro is no longer useful; consider deleting it in 2014 +# after we ensure m4sh scripts can always find a shell with test -x. +m4_defun_init([AS_TEST_X], +[AS_REQUIRE([_AS_TEST_PREPARE])], +[test -x $1[]])# AS_TEST_X + + +# AS_EXECUTABLE_P +# --------------- +# Check whether a file is a regular file that has executable permissions. +m4_defun_init([AS_EXECUTABLE_P], +[AS_REQUIRE([_AS_TEST_PREPARE])], +[as_fn_executable_p $1])# AS_EXECUTABLE_P + + +# _AS_EXPR_PREPARE +# ---------------- +# QNX 4.25 expr computes and issue the right result but exits with failure. +# Tru64 expr mishandles leading zeros in numeric strings. +# Detect these flaws. +m4_defun([_AS_EXPR_PREPARE], +[if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi +])# _AS_EXPR_PREPARE + + +# _AS_ME_PREPARE +# -------------- +# Define $as_me to the basename of the executable file's name. +m4_defun([AS_ME_PREPARE], [AS_REQUIRE([_$0])]) +m4_defun([_AS_ME_PREPARE], +[AS_REQUIRE([_AS_BASENAME_PREPARE])]dnl +[as_me=`AS_BASENAME("$[0]")` +]) + +# _AS_LINENO_WORKS +# ---------------- +# Succeed if the currently executing shell supports LINENO. +# This macro does not expand to a single shell command, so be careful +# when using it. Surrounding the body of this macro with {} would +# cause "bash -c '_ASLINENO_WORKS'" to fail (with Bash 2.05, anyway), +# but that bug is irrelevant to our use of LINENO. We can't use +# AS_VAR_ARITH, as this is expanded prior to shell functions. +# +# Testing for LINENO support is hard; we use _AS_LINENO_WORKS inside +# _AS_RUN, which sometimes eval's its argument (pdksh gives false +# negatives if $LINENO is expanded by eval), and sometimes passes the +# argument to another shell (if the current shell supports LINENO, +# then expanding $LINENO prior to the string leads to false +# positives). Hence, we perform two tests, and coordinate with +# _AS_DETECT_EXPAND (which ensures that only the first of two LINENO +# is expanded in advance) and _AS_RUN (which sets $as_run to 'a' when +# handing the test to another shell), so that we know which test to +# trust. +m4_define([_AS_LINENO_WORKS], +[ as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"']) + + +# _AS_LINENO_PREPARE +# ------------------ +# If LINENO is not supported by the shell, produce a version of this +# script where LINENO is hard coded. +# Comparing LINENO against _oline_ is not a good solution, since in +# the case of embedded executables (such as config.status within +# configure) you'd compare LINENO wrt config.status vs. _oline_ wrt +# configure. +# +# AS_ERROR normally uses LINENO if logging, but AS_LINENO_PREPARE uses +# AS_ERROR. Besides, if the logging fd is open, we don't want to use +# $LINENO in the log complaining about broken LINENO. We break the +# circular require by changing AS_ERROR and AS_MESSAGE_LOG_FD. +m4_defun([AS_LINENO_PREPARE], [AS_REQUIRE([_$0])]) +m4_defun([_AS_LINENO_PREPARE], +[AS_REQUIRE([_AS_CR_PREPARE])]dnl +[AS_REQUIRE([_AS_ME_PREPARE])]dnl +[_AS_DETECT_SUGGESTED([_AS_LINENO_WORKS])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[m4_pushdef([AS_ERROR], + [{ AS_MESSAGE(]m4_dquote([error: $][1])[, [2]); AS_EXIT([1]); }])]dnl +dnl Create $as_me.lineno as a copy of $as_myself, but with $LINENO +dnl uniformly replaced by the line number. The first 'sed' inserts a +dnl line-number line after each line using $LINENO; the second 'sed' +dnl does the real work. The second script uses 'N' to pair each +dnl line-number line with the line containing $LINENO, and appends +dnl trailing '-' during substitution so that $LINENO is not a special +dnl case at line end. (Raja R Harinath suggested sed '=', and Paul +dnl Eggert wrote the scripts with optimization help from Paolo Bonzini). +[_AS_LINENO_WORKS || { +[ # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno"] || + AS_ERROR([cannot create $as_me.lineno; rerun with a POSIX shell]) + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} +_m4_popdef([AS_MESSAGE_LOG_FD], [AS_ERROR])])# _AS_LINENO_PREPARE + + +# _AS_LN_S_PREPARE +# ---------------- +# Don't use conftest.sym to avoid file name issues on DJGPP, where this +# would yield conftest.sym.exe for DJGPP < 2.04. And don't use `conftest' +# as base name to avoid prohibiting concurrency (e.g., concurrent +# config.statuses). On read-only media, assume 'cp -pR' and hope we +# are just running --help anyway. +m4_defun([_AS_LN_S_PREPARE], +[rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null +])# _AS_LN_S_PREPARE + + +# AS_LN_S(FILE, LINK) +# ------------------- +# FIXME: Should we add the glue code to handle properly relative symlinks +# simulated with `ln' or `cp'? +m4_defun_init([AS_LN_S], +[AS_REQUIRE([_AS_LN_S_PREPARE])], +[$as_ln_s $1 $2]) + + +# _AS_MKDIR_P +# ----------- +# Emit code that can be used to emulate `mkdir -p` with plain `mkdir'; +# the code assumes that "$as_dir" contains the directory to create. +# $as_dir is normalized, so there is no need to worry about using --. +m4_define([_AS_MKDIR_P], +[case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`AS_ECHO(["$as_dir"]) | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`AS_DIRNAME("$as_dir")` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || AS_ERROR([cannot create directory $as_dir]) +]) + +# AS_MKDIR_P(DIR) +# --------------- +# Emulate `mkdir -p' with plain `mkdir' if needed. +m4_defun_init([AS_MKDIR_P], +[AS_REQUIRE([_$0_PREPARE])], +[as_dir=$1; as_fn_mkdir_p])# AS_MKDIR_P + + +# _AS_MKDIR_P_PREPARE +# ------------------- +m4_defun([_AS_MKDIR_P_PREPARE], +[AS_REQUIRE_SHELL_FN([as_fn_mkdir_p], + [AS_FUNCTION_DESCRIBE([as_fn_mkdir_p], [], + [Create "$as_dir" as a directory, including parents if necessary.])], +[ + _AS_MKDIR_P +])]dnl +[if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi +])# _AS_MKDIR_P_PREPARE + + +# _AS_PATH_SEPARATOR_PREPARE +# -------------------------- +# Compute the path separator. +m4_defun([_AS_PATH_SEPARATOR_PREPARE], +[# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi +])# _AS_PATH_SEPARATOR_PREPARE + + +# _AS_PATH_WALK([PATH = $PATH], BODY, [IF-NOT-FOUND]) +# --------------------------------------------------- +# Walk through PATH running BODY for each `as_dir'. If BODY never does a +# `break', evaluate IF-NOT-FOUND. +# +# Still very private as its interface looks quite bad. +# +# `$as_dummy' forces splitting on constant user-supplied paths. +# POSIX.2 field splitting is done only on the result of word +# expansions, not on literal text. This closes a longstanding sh security +# hole. Optimize it away when not needed, i.e., if there are no literal +# path separators. +m4_defun_init([_AS_PATH_WALK], +[AS_REQUIRE([_AS_PATH_SEPARATOR_PREPARE])], +[as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +m4_ifvaln([$3], [as_found=false])dnl +m4_bmatch([$1], [[:;]], +[as_dummy="$1" +for as_dir in $as_dummy], +[for as_dir in m4_default([$1], [$PATH])]) +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + m4_ifvaln([$3], [as_found=:])dnl + $2 + m4_ifvaln([$3], [as_found=false])dnl +done +m4_ifvaln([$3], [$as_found || { $3; }])dnl +IFS=$as_save_IFS +]) + + +# AS_SET_CATFILE(VAR, DIR-NAME, FILE-NAME) +# ---------------------------------------- +# Set VAR to DIR-NAME/FILE-NAME. +# Optimize the common case where $2 or $3 is '.'. +m4_define([AS_SET_CATFILE], +[case $2 in @%:@(( +.) AS_VAR_SET([$1], [$3]);; +*) + case $3 in @%:@((( + .) AS_VAR_SET([$1], [$2]);; + [[\\/]]* | ?:[[\\/]]* ) AS_VAR_SET([$1], [$3]);; + *) AS_VAR_SET([$1], [$2/$3]);; + esac;; +esac[]])# AS_SET_CATFILE + + +# _AS_TEST_X_WORKS +# ---------------- +# These days, we require that `test -x' works. +m4_define([_AS_TEST_X_WORKS], [test -x /]) + +# _AS_TEST_PREPARE +# ---------------- +# Provide back-compat to people that hooked into our undocumented +# internals (here's looking at you, libtool). +m4_defun([_AS_TEST_PREPARE], +[AS_REQUIRE_SHELL_FN([as_fn_executable_p], + [AS_FUNCTION_DESCRIBE([as_fn_executable_p], [FILE], + [Test if FILE is an executable regular file.])], + [ test -f "$[]1" && test -x "$[]1"])]dnl +[as_test_x='test -x' +as_executable_p=as_fn_executable_p +])# _AS_TEST_PREPARE + + + + +## ------------------ ## +## 5. Common idioms. ## +## ------------------ ## + +# This section is lexicographically sorted. + + +# AS_BOX(MESSAGE, [FRAME-CHARACTER = `-']) +# ---------------------------------------- +# Output MESSAGE, a single line text, framed with FRAME-CHARACTER (which +# must not be `/'). +m4_define([AS_BOX], +[_$0(m4_expand([$1]), [$2])]) + +m4_define([_AS_BOX], +[m4_if(m4_index(m4_translit([[$1]], [`\"], [$$$]), [$]), + [-1], [$0_LITERAL], [$0_INDIR])($@)]) + + +# _AS_BOX_LITERAL(MESSAGE, [FRAME-CHARACTER = `-']) +# ------------------------------------------------- +m4_define([_AS_BOX_LITERAL], +[AS_ECHO(["_AS_ESCAPE(m4_dquote(m4_expand([m4_text_box($@)])), [`], [\"$])"])]) + + +# _AS_BOX_INDIR(MESSAGE, [FRAME-CHARACTER = `-']) +# ----------------------------------------------- +m4_define([_AS_BOX_INDIR], +[sed 'h;s/./m4_default([$2], [-])/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX +@%:@@%:@ $1 @%:@@%:@ +_ASBOX]) + + +# _AS_CLEAN_DIR(DIR) +# ------------------ +# Remove all contents from within DIR, including any unwritable +# subdirectories, but leave DIR itself untouched. +m4_define([_AS_CLEAN_DIR], +[if test -d $1; then + find $1 -type d ! -perm -700 -exec chmod u+rwx {} \; + rm -fr $1/* $1/.[[!.]] $1/.??* +fi]) + + +# AS_FUNCTION_DESCRIBE(NAME, [ARGS], DESCRIPTION, [WRAP-COLUMN = 79]) +# ------------------------------------------------------------------- +# Output a shell comment describing NAME and its arguments ARGS, then +# a separator line, then the DESCRIPTION wrapped at a decimal +# WRAP-COLUMN. The output resembles: +# # NAME ARGS +# # --------- +# # Wrapped DESCRIPTION text +# NAME and ARGS are expanded, while DESCRIPTION is treated as a +# whitespace-separated list of strings that are not expanded. +m4_define([AS_FUNCTION_DESCRIBE], +[@%:@ $1[]m4_ifval([$2], [ $2]) +@%:@ m4_translit(m4_format([%*s], + m4_decr(m4_qlen(_m4_expand([$1[]m4_ifval([$2], [ $2]) +]))), []), [ ], [-]) +m4_text_wrap([$3], [@%:@ ], [], [$4])]) + + +# AS_HELP_STRING(LHS, RHS, [INDENT-COLUMN = 26], [WRAP-COLUMN = 79]) +# ------------------------------------------------------------------ +# +# Format a help string so that it looks pretty when the user executes +# "script --help". This macro takes up to four arguments, a +# "left hand side" (LHS), a "right hand side" (RHS), a decimal +# INDENT-COLUMN which is the column where wrapped lines should begin +# (the default of 26 is recommended), and a decimal WRAP-COLUMN which is +# the column where lines should wrap (the default of 79 is recommended). +# LHS is expanded, RHS is not. +# +# For backwards compatibility not documented in the manual, INDENT-COLUMN +# can also be specified as a string of white spaces, whose width +# determines the indentation column. Using TABs in INDENT-COLUMN is not +# recommended, since screen width of TAB is not computed. +# +# The resulting string is suitable for use in other macros that require +# a help string (e.g. AC_ARG_WITH). +# +# Here is the sample string from the Autoconf manual (Node: External +# Software) which shows the proper spacing for help strings. +# +# --with-readline support fancy command line editing +# ^ ^ ^ +# | | | +# | column 2 column 26 +# | +# column 0 +# +# A help string is made up of a "left hand side" (LHS) and a "right +# hand side" (RHS). In the example above, the LHS is +# "--with-readline", while the RHS is "support fancy command line +# editing". +# +# If the LHS contains more than (INDENT-COLUMN - 3) characters, then the +# LHS is terminated with a newline so that the RHS starts on a line of its +# own beginning at INDENT-COLUMN. In the default case, this corresponds to an +# LHS with more than 23 characters. +# +# Therefore, in the example, if the LHS were instead +# "--with-readline-blah-blah-blah", then the AS_HELP_STRING macro would +# expand into: +# +# +# --with-readline-blah-blah-blah +# ^ ^ support fancy command line editing +# | | ^ +# | column 2 | +# column 0 column 26 +# +# +# m4_text_wrap hacks^Wworks around the fact that m4_format does not +# know quadrigraphs. +# +m4_define([AS_HELP_STRING], +[m4_text_wrap([$2], m4_cond([[$3]], [], [ ], + [m4_eval([$3]+0)], [0], [[$3]], + [m4_format([[%*s]], [$3], [])]), + m4_expand([ $1 ]), [$4])])# AS_HELP_STRING + + +# AS_IDENTIFIER_IF(EXPRESSION, IF-IDENT, IF-NOT-IDENT) +# ---------------------------------------------------- +# If EXPRESSION serves as an identifier (ie, after removal of @&t@, it +# matches the regex `^[a-zA-Z_][a-zA-Z_0-9]*$'), execute IF-IDENT, +# otherwise IF-NOT-IDENT. +# +# This is generally faster than the alternative: +# m4_bmatch(m4_bpatsubst([[$1]], [@&t@]), ^m4_defn([m4_re_word])$, +# [$2], [$3]) +# +# Rather than expand m4_defn every time AS_IDENTIFIER_IF is expanded, we +# inline its expansion up front. Only use a regular expression if we +# detect a potential quadrigraph. +# +# First, check if the entire string matches m4_cr_symbol2. Only then do +# we worry if the first character also matches m4_cr_symbol1 (ie. does not +# match m4_cr_digit). +m4_define([AS_IDENTIFIER_IF], +[m4_if(_$0(m4_if(m4_index([$1], [@]), [-1], + [[$1]], [m4_bpatsubst([[$1]], [@&t@])])), [-], [$2], [$3])]) + +m4_define([_AS_IDENTIFIER_IF], +[m4_cond([[$1]], [], [], + [m4_eval(m4_len(m4_translit([[$1]], ]]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[)) > 0)], [1], [], + [m4_len(m4_translit(m4_format([[%.1s]], [$1]), ]]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_symbols1])))[[))], [0], [-])]) + + +# AS_LITERAL_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL, +# [IF-SIMPLE-REF = IF-NOT-LITERAL]) +# ----------------------------------------------------- +# If EXPRESSION has no shell indirections ($var or `expr`), expand +# IF-LITERAL, else IF-NOT-LITERAL. In some cases, IF-NOT-LITERAL +# must be complex to safely deal with ``, while a simpler +# expression IF-SIMPLE-REF can be used if the indirection +# involves only shell variable expansion (as in ${varname}). +# +# EXPRESSION is treated as a literal if it results in the same +# interpretation whether it is unquoted or contained within double +# quotes, with the exception that whitespace is ignored (on the +# assumption that it will be flattened to _). Therefore, neither `\$' +# nor `a''b' is a literal, since both backslash and single quotes have +# different quoting behavior in the two contexts; and `a*' is not a +# literal, because it has different globbing. Note, however, that +# while `${a+b}' is neither a literal nor a simple ref, `a+b' is a +# literal. This macro is an *approximation*: it is possible that +# there are some EXPRESSIONs which the shell would treat as literals, +# but which this macro does not recognize. +# +# Why do we reject EXPRESSION expanding with `[' or `]' as a literal? +# Because AS_TR_SH is MUCH faster if it can use m4_translit on literals +# instead of m4_bpatsubst; but m4_translit is much tougher to do safely +# if `[' is translated. That, and file globbing matters. +# +# Note that the quadrigraph @S|@ can result in non-literals, but outright +# rejecting all @ would make AC_INIT complain on its bug report address. +# +# We used to use m4_bmatch(m4_quote($1), [[`$]], [$3], [$2]), but +# profiling shows that it is faster to use m4_translit. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# or unbalanced parentheses. Valid shell variable characters and +# unambiguous literal characters are deleted (`a.b'), and remaining +# characters are normalized into `$' if they can form simple refs +# (${a}), `+' if they can potentially form literals (a+b), ``' if they +# can interfere with m4 parsing, or left alone otherwise. If both `$' +# and `+' are left, it is treated as a complex reference (${a+b}), +# even though it could technically be a simple reference (${a}+b). +# _AS_LITERAL_IF_ only has to check for an empty string after removing +# one of the two normalized characters. +# +# Rather than expand m4_defn every time AS_LITERAL_IF is expanded, we +# inline its expansion up front. _AS_LITERAL_IF expands to the name +# of a macro that takes three arguments: IF-SIMPLE-REF, +# IF-NOT-LITERAL, IF-LITERAL. It also takes an optional argument of +# any additional characters to allow as literals (useful for AS_TR_SH +# and AS_TR_CPP to perform inline conversion of whitespace to _). The +# order of the arguments allows reuse of m4_default. +m4_define([AS_LITERAL_IF], +[_$0(m4_expand([$1]), [ ][ +])([$4], [$3], [$2])]) + +m4_define([_AS_LITERAL_IF], +[m4_if(m4_index([$1], [@S|@]), [-1], [$0_(m4_translit([$1], + [-:=%/@{}[]#(),.$2]]]m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[, + [++++++$$`````]))], [$0_NO])]) + +m4_define([_AS_LITERAL_IF_], +[m4_if(m4_translit([$1], [+]), [], [$0YES], + m4_translit([$1], [$]), [], [m4_default], [$0NO])]) + +m4_define([_AS_LITERAL_IF_YES], [$3]) +m4_define([_AS_LITERAL_IF_NO], [$2]) + +# AS_LITERAL_WORD_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL, +# [IF-SIMPLE-REF = IF-NOT-LITERAL]) +# ---------------------------------------------------------- +# Like AS_LITERAL_IF, except that spaces and tabs in EXPRESSION +# are treated as non-literal. +m4_define([AS_LITERAL_WORD_IF], +[_AS_LITERAL_IF(m4_expand([$1]))([$4], [$3], [$2])]) + +# AS_LITERAL_HEREDOC_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL) +# ------------------------------------------------------------- +# Like AS_LITERAL_IF, except that a string is considered literal +# if it results in the same output in both quoted and unquoted +# here-documents. +m4_define([AS_LITERAL_HEREDOC_IF], +[_$0(m4_expand([$1]))([$2], [$3])]) + +m4_define([_AS_LITERAL_HEREDOC_IF], +[m4_if(m4_index([$1], [@S|@]), [-1], + [m4_if(m4_index(m4_translit([[$1]], [\`], [$]), [$]), [-1], + [$0_YES], [$0_NO])], + [$0_NO])]) + +m4_define([_AS_LITERAL_HEREDOC_IF_YES], [$1]) +m4_define([_AS_LITERAL_HEREDOC_IF_NO], [$2]) + + +# AS_TMPDIR(PREFIX, [DIRECTORY = $TMPDIR [= /tmp]]) +# ------------------------------------------------- +# Create as safely as possible a temporary directory in DIRECTORY +# which name is inspired by PREFIX (should be 2-4 chars max). +# +# Even though $tmp does not fit our normal naming scheme of $as_*, +# it is a documented part of the public API and must not be changed. +m4_define([AS_TMPDIR], +[# Create a (secure) tmp directory for tmp files. +m4_if([$2], [], [: "${TMPDIR:=/tmp}"]) +{ + tmp=`(umask 077 && mktemp -d "m4_default([$2], + [$TMPDIR])/$1XXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=m4_default([$2], [$TMPDIR])/$1$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || AS_ERROR([cannot create a temporary directory in m4_default([$2], + [$TMPDIR])])])# AS_TMPDIR + + +# AS_UNAME +# -------- +# Try to describe this machine. Meant for logs. +m4_define([AS_UNAME], +[{ +cat <<_ASUNAME +m4_text_box([Platform.]) + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +_AS_PATH_WALK([$PATH], [AS_ECHO(["PATH: $as_dir"])]) +}]) + + +# _AS_VERSION_COMPARE_PREPARE +# --------------------------- +# Output variables for comparing version numbers. +m4_defun([_AS_VERSION_COMPARE_PREPARE], +[[as_awk_strverscmp=' + # Use only awk features that work with 7th edition Unix awk (1978). + # My, what an old awk you have, Mr. Solaris! + END { + while (length(v1) && length(v2)) { + # Set d1 to be the next thing to compare from v1, and likewise for d2. + # Normally this is a single character, but if v1 and v2 contain digits, + # compare them as integers and fractions as strverscmp does. + if (v1 ~ /^[0-9]/ && v2 ~ /^[0-9]/) { + # Split v1 and v2 into their leading digit string components d1 and d2, + # and advance v1 and v2 past the leading digit strings. + for (len1 = 1; substr(v1, len1 + 1) ~ /^[0-9]/; len1++) continue + for (len2 = 1; substr(v2, len2 + 1) ~ /^[0-9]/; len2++) continue + d1 = substr(v1, 1, len1); v1 = substr(v1, len1 + 1) + d2 = substr(v2, 1, len2); v2 = substr(v2, len2 + 1) + if (d1 ~ /^0/) { + if (d2 ~ /^0/) { + # Compare two fractions. + while (d1 ~ /^0/ && d2 ~ /^0/) { + d1 = substr(d1, 2); len1-- + d2 = substr(d2, 2); len2-- + } + if (len1 != len2 && ! (len1 && len2 && substr(d1, 1, 1) == substr(d2, 1, 1))) { + # The two components differ in length, and the common prefix + # contains only leading zeros. Consider the longer to be less. + d1 = -len1 + d2 = -len2 + } else { + # Otherwise, compare as strings. + d1 = "x" d1 + d2 = "x" d2 + } + } else { + # A fraction is less than an integer. + exit 1 + } + } else { + if (d2 ~ /^0/) { + # An integer is greater than a fraction. + exit 2 + } else { + # Compare two integers. + d1 += 0 + d2 += 0 + } + } + } else { + # The normal case, without worrying about digits. + d1 = substr(v1, 1, 1); v1 = substr(v1, 2) + d2 = substr(v2, 1, 1); v2 = substr(v2, 2) + } + if (d1 < d2) exit 1 + if (d1 > d2) exit 2 + } + # Beware Solaris /usr/xgp4/bin/awk (at least through Solaris 10), + # which mishandles some comparisons of empty strings to integers. + if (length(v2)) exit 1 + if (length(v1)) exit 2 + } +']])# _AS_VERSION_COMPARE_PREPARE + + +# AS_VERSION_COMPARE(VERSION-1, VERSION-2, +# [ACTION-IF-LESS], [ACTION-IF-EQUAL], [ACTION-IF-GREATER]) +# ---------------------------------------------------------------------------- +# Compare two strings possibly containing shell variables as version strings. +# +# This usage is portable even to ancient awk, +# so don't worry about finding a "nice" awk version. +m4_defun_init([AS_VERSION_COMPARE], +[AS_REQUIRE([_$0_PREPARE])], +[as_arg_v1=$1 +as_arg_v2=$2 +awk "$as_awk_strverscmp" v1="$as_arg_v1" v2="$as_arg_v2" /dev/null +AS_CASE([$?], + [1], [$3], + [0], [$4], + [2], [$5])])# AS_VERSION_COMPARE + + + +## --------------------------------------- ## +## 6. Common m4/sh character translation. ## +## --------------------------------------- ## + +# The point of this section is to provide high level macros comparable +# to m4's `translit' primitive, but m4/sh polymorphic. +# Transliteration of literal strings should be handled by m4, while +# shell variables' content will be translated at runtime (tr or sed). + + +# _AS_CR_PREPARE +# -------------- +# Output variables defining common character ranges. +# See m4_cr_letters etc. +m4_defun([_AS_CR_PREPARE], +[# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits +]) + + +# _AS_TR_SH_PREPARE +# ----------------- +m4_defun([_AS_TR_SH_PREPARE], +[AS_REQUIRE([_AS_CR_PREPARE])]dnl +[# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[[^_$as_cr_alnum]]%_%g'" +]) + + +# AS_TR_SH(EXPRESSION) +# -------------------- +# Transform EXPRESSION into a valid shell variable name. +# sh/m4 polymorphic. +# Be sure to update the definition of `$as_tr_sh' if you change this. +# +# AS_LITERAL_IF guarantees that a literal does not have any nested quotes, +# once $1 is expanded. m4_translit silently uses only the first occurrence +# of a character that appears multiple times in argument 2, since we know +# that m4_cr_not_symbols2 also contains [ and ]. m4_translit also silently +# ignores characters in argument 3 that do not match argument 2; we use this +# fact to skip worrying about the length of m4_cr_not_symbols2. +# +# For speed, we inline the literal definitions that can be computed up front. +m4_defun_init([AS_TR_SH], +[AS_REQUIRE([_$0_PREPARE])], +[_$0(m4_expand([$1]))]) + +m4_define([_AS_TR_SH], +[_AS_LITERAL_IF([$1], [*][ ][ +])([], [$0_INDIR], [$0_LITERAL])([$1])]) + +m4_define([_AS_TR_SH_LITERAL], +[m4_translit([[$1]], + [*+[]]]m4_dquote(m4_defn([m4_cr_not_symbols2]))[, + [pp[]]]m4_dquote(m4_for(,1,255,,[[_]]))[)]) + +m4_define([_AS_TR_SH_INDIR], +[`AS_ECHO(["_AS_ESCAPE([[$1]], [`], [\])"]) | $as_tr_sh`]) + + +# _AS_TR_CPP_PREPARE +# ------------------ +m4_defun([_AS_TR_CPP_PREPARE], +[AS_REQUIRE([_AS_CR_PREPARE])]dnl +[# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[[^_$as_cr_alnum]]%_%g'" +]) + + +# AS_TR_CPP(EXPRESSION) +# --------------------- +# Map EXPRESSION to an upper case string which is valid as rhs for a +# `#define'. sh/m4 polymorphic. Be sure to update the definition +# of `$as_tr_cpp' if you change this. +# +# See implementation comments in AS_TR_SH. +m4_defun_init([AS_TR_CPP], +[AS_REQUIRE([_$0_PREPARE])], +[_$0(m4_expand([$1]))]) + +m4_define([_AS_TR_CPP], +[_AS_LITERAL_IF([$1], [*][ ][ +])([], [$0_INDIR], [$0_LITERAL])([$1])]) + +m4_define([_AS_TR_CPP_LITERAL], +[m4_translit([[$1]], + [*[]]]m4_dquote(m4_defn([m4_cr_letters])m4_defn([m4_cr_not_symbols2]))[, + [P[]]]m4_dquote(m4_defn([m4_cr_LETTERS])m4_for(,1,255,,[[_]]))[)]) + +m4_define([_AS_TR_CPP_INDIR], +[`AS_ECHO(["_AS_ESCAPE([[$1]], [`], [\])"]) | $as_tr_cpp`]) + + +# _AS_TR_PREPARE +# -------------- +m4_defun([_AS_TR_PREPARE], +[AS_REQUIRE([_AS_TR_SH_PREPARE])AS_REQUIRE([_AS_TR_CPP_PREPARE])]) + + + + +## ------------------------------------------------------ ## +## 7. Common m4/sh handling of variables (indirections). ## +## ------------------------------------------------------ ## + + +# The purpose of this section is to provide a uniform API for +# reading/setting sh variables with or without indirection. +# Typically, one can write +# AS_VAR_SET(var, val) +# or +# AS_VAR_SET(as_$var, val) +# and expect the right thing to happen. In the descriptions below, +# a literal name matches the regex [a-zA-Z_][a-zA-Z0-9_]*, an +# indirect name is a shell expression that produces a literal name +# when passed through eval, and a polymorphic name is either type. + + +# _AS_VAR_APPEND_PREPARE +# ---------------------- +# Define as_fn_append to the optimum definition for the current +# shell (bash and zsh provide the += assignment operator to avoid +# quadratic append growth over repeated appends). +m4_defun([_AS_VAR_APPEND_PREPARE], +[AS_FUNCTION_DESCRIBE([as_fn_append], [VAR VALUE], +[Append the text in VALUE to the end of the definition contained in +VAR. Take advantage of any shell optimizations that allow amortized +linear growth over repeated appends, instead of the typical quadratic +growth present in naive implementations.]) +AS_IF([_AS_RUN(["AS_ESCAPE(m4_quote(_AS_VAR_APPEND_WORKS))"])], +[eval 'as_fn_append () + { + eval $[]1+=\$[]2 + }'], +[as_fn_append () + { + eval $[]1=\$$[]1\$[]2 + }]) # as_fn_append +]) + +# _AS_VAR_APPEND_WORKS +# -------------------- +# Output a shell test to discover whether += works. +m4_define([_AS_VAR_APPEND_WORKS], +[as_var=1; as_var+=2; test x$as_var = x12]) + +# AS_VAR_APPEND(VAR, VALUE) +# ------------------------- +# Append the shell expansion of VALUE to the end of the existing +# contents of the polymorphic shell variable VAR, taking advantage of +# any shell optimizations that allow repeated appends to result in +# amortized linear scaling rather than quadratic behavior. This macro +# is not worth the overhead unless the expected final size of the +# contents of VAR outweigh the typical VALUE size of repeated appends. +# Note that unlike AS_VAR_SET, VALUE must be properly quoted to avoid +# field splitting and file name expansion. +m4_defun_init([AS_VAR_APPEND], +[AS_REQUIRE([_AS_VAR_APPEND_PREPARE], [], [M4SH-INIT-FN])], +[as_fn_append $1 $2]) + + +# _AS_VAR_ARITH_PREPARE +# --------------------- +# Define as_fn_arith to the optimum definition for the current +# shell (using POSIX $(()) where supported). +m4_defun([_AS_VAR_ARITH_PREPARE], +[AS_FUNCTION_DESCRIBE([as_fn_arith], [ARG...], +[Perform arithmetic evaluation on the ARGs, and store the result in +the global $as_val. Take advantage of shells that can avoid forks. +The arguments must be portable across $(()) and expr.]) +AS_IF([_AS_RUN(["AS_ESCAPE(m4_quote(_AS_VAR_ARITH_WORKS))"])], +[eval 'as_fn_arith () + { + as_val=$(( $[]* )) + }'], +[as_fn_arith () + { + as_val=`expr "$[]@" || test $? -eq 1` + }]) # as_fn_arith +]) + +# _AS_VAR_ARITH_WORKS +# ------------------- +# Output a shell test to discover whether $(()) works. +m4_define([_AS_VAR_ARITH_WORKS], +[test $(( 1 + 1 )) = 2]) + +# AS_VAR_ARITH(VAR, EXPR) +# ----------------------- +# Perform the arithmetic evaluation of the arguments in EXPR, and set +# contents of the polymorphic shell variable VAR to the result, taking +# advantage of any shell optimizations that perform arithmetic without +# forks. Note that numbers occurring within EXPR must be written in +# decimal, and without leading zeroes; variables containing numbers +# must be expanded prior to arithmetic evaluation; the first argument +# must not be a negative number; there is no portable equality +# operator; and operators must be given as separate arguments and +# properly quoted. +m4_defun_init([AS_VAR_ARITH], +[_AS_DETECT_SUGGESTED([_AS_VAR_ARITH_WORKS])]dnl +[AS_REQUIRE([_AS_VAR_ARITH_PREPARE], [], [M4SH-INIT-FN])], +[as_fn_arith $2 && AS_VAR_SET([$1], [$as_val])]) + + +# AS_VAR_COPY(DEST, SOURCE) +# ------------------------- +# Set the polymorphic shell variable DEST to the contents of the polymorphic +# shell variable SOURCE. +m4_define([AS_VAR_COPY], +[AS_LITERAL_WORD_IF([$1[]$2], [$1=$$2], [eval $1=\$$2])]) + + +# AS_VAR_GET(VARIABLE) +# -------------------- +# Get the value of the shell VARIABLE. +# Evaluates to $VARIABLE if there is no indirection in VARIABLE, +# else to the appropriate `eval' sequence. +# This macro is deprecated because it sometimes mishandles trailing newlines; +# use AS_VAR_COPY instead. +m4_define([AS_VAR_GET], +[AS_LITERAL_WORD_IF([$1], + [$$1], + [`eval 'as_val=${'_AS_ESCAPE([[$1]], [`], [\])'};AS_ECHO(["$as_val"])'`])]) + + +# AS_VAR_IF(VARIABLE, VALUE, IF-TRUE, IF-FALSE) +# --------------------------------------------- +# Implement a shell `if test $VARIABLE = VALUE; then-else'. +# Polymorphic, and avoids sh expansion error upon interrupt or term signal. +m4_define([AS_VAR_IF], +[AS_LITERAL_WORD_IF([$1], + [AS_IF(m4_ifval([$2], [[test "x$$1" = x[]$2]], [[${$1:+false} :]])], + [AS_VAR_COPY([as_val], [$1]) + AS_IF(m4_ifval([$2], [[test "x$as_val" = x[]$2]], [[${as_val:+false} :]])], + [AS_IF(m4_ifval([$2], + [[eval test \"x\$"$1"\" = x"_AS_ESCAPE([$2], [`], [\"$])"]], + [[eval \${$1:+false} :]])]), +[$3], [$4])]) + + +# AS_VAR_PUSHDEF and AS_VAR_POPDEF +# -------------------------------- +# + +# Sometimes we may have to handle literals (e.g. `stdlib.h'), while at +# other moments, the same code may have to get the value from a +# variable (e.g., `ac_header'). To have a uniform handling of both +# cases, when a new value is about to be processed, declare a local +# variable, e.g.: +# +# AS_VAR_PUSHDEF([header], [ac_cv_header_$1]) +# +# and then in the body of the macro, use `header' as is. It is of +# first importance to use `AS_VAR_*' to access this variable. +# +# If the value `$1' was a literal (e.g. `stdlib.h'), then `header' is +# in fact the value `ac_cv_header_stdlib_h'. If `$1' was indirect, +# then `header's value in m4 is in fact `$as_header', the shell +# variable that holds all of the magic to get the expansion right. +# +# At the end of the block, free the variable with +# +# AS_VAR_POPDEF([header]) + + +# AS_VAR_POPDEF(VARNAME) +# ---------------------- +# Free the shell variable accessor VARNAME. To be dnl'ed. +m4_define([AS_VAR_POPDEF], +[m4_popdef([$1])]) + + +# AS_VAR_PUSHDEF(VARNAME, VALUE) +# ------------------------------ +# Define the m4 macro VARNAME to an accessor to the shell variable +# named VALUE. VALUE does not need to be a valid shell variable name: +# the transliteration is handled here. To be dnl'ed. +# +# AS_TR_SH attempts to play with diversions if _AS_TR_SH_PREPARE has +# not been expanded. However, users are expected to do subsequent +# calls that trigger AS_LITERAL_IF([VARNAME]), and that macro performs +# expansion inside an argument collection context, where diversions +# don't work. Therefore, we must require the preparation ourselves. +m4_defun_init([AS_VAR_PUSHDEF], +[AS_REQUIRE([_AS_TR_SH_PREPARE])], +[_$0([$1], m4_expand([$2]))]) + +m4_define([_AS_VAR_PUSHDEF], +[_AS_LITERAL_IF([$2], [ ][ +])([], [as_$1=_AS_TR_SH_INDIR([$2]) +m4_pushdef([$1], [$as_[$1]])], +[m4_pushdef([$1], [_AS_TR_SH_LITERAL([$2])])])]) + + +# AS_VAR_SET(VARIABLE, VALUE) +# --------------------------- +# Set the contents of the polymorphic shell VARIABLE to the shell +# expansion of VALUE. VALUE is immune to field splitting and file +# name expansion. +m4_define([AS_VAR_SET], +[AS_LITERAL_WORD_IF([$1], + [$1=$2], + [eval "$1=_AS_ESCAPE([$2], [`], [\"$])"])]) + + +# AS_VAR_SET_IF(VARIABLE, IF-TRUE, IF-FALSE) +# ------------------------------------------ +# Implement a shell `if-then-else' depending whether VARIABLE is set +# or not. Polymorphic. +m4_define([AS_VAR_SET_IF], +[AS_IF([AS_VAR_TEST_SET([$1])], [$2], [$3])]) + + +# AS_VAR_TEST_SET(VARIABLE) +# ------------------------- +# Expands into an expression which is true if VARIABLE +# is set. Polymorphic. +m4_define([AS_VAR_TEST_SET], +[AS_LITERAL_WORD_IF([$1], + [${$1+:} false], + [{ as_var=$1; eval \${$as_var+:} false; }], + [eval \${$1+:} false])]) + + +## -------------------- ## +## 8. Setting M4sh up. ## +## -------------------- ## + + +# AS_INIT_GENERATED(FILE, [COMMENT]) +# ---------------------------------- +# Generate a child script FILE with all initialization necessary to +# reuse the environment learned by the parent script, and make the +# file executable. If COMMENT is supplied, it is inserted after the +# `#!' sequence but before initialization text begins. After this +# macro, additional text can be appended to FILE to form the body of +# the child script. The macro ends with non-zero status if the +# file could not be fully written (such as if the disk is full). +m4_defun([AS_INIT_GENERATED], +[m4_require([AS_PREPARE])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[as_write_fail=0 +cat >$1 <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +$2 +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$1 <<\_ASEOF || as_write_fail=1 +_AS_SHELL_SANITIZE +_AS_PREPARE +m4_if(AS_MESSAGE_FD, [1], [], [exec AS_MESSAGE_FD>&1 +])]dnl +[m4_text_box([Main body of $1 script.]) +_ASEOF +test $as_write_fail = 0 && chmod +x $1[]dnl +_m4_popdef([AS_MESSAGE_LOG_FD])])# AS_INIT_GENERATED + + +# AS_INIT +# ------- +# Initialize m4sh. +m4_define([AS_INIT], +[# Wrap our cleanup prior to m4sugar's cleanup. +m4_wrap([_AS_CLEANUP]) +m4_init +m4_provide([AS_INIT]) + +# Forbidden tokens and exceptions. +m4_pattern_forbid([^_?AS_]) + +# Bangshe and minimal initialization. +m4_divert_text([BINSH], [@%:@! /bin/sh]) +m4_divert_text([HEADER-COMMENT], + [@%:@ Generated from __file__ by m4_PACKAGE_STRING.]) +m4_divert_text([M4SH-SANITIZE], [_AS_SHELL_SANITIZE]) +m4_divert_text([M4SH-INIT-FN], [m4_text_box([M4sh Shell Functions.])]) + +# Let's go! +m4_divert([BODY])dnl +m4_text_box([Main body of script.]) +_AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK])dnl +_AS_DETECT_REQUIRED([_AS_TEST_X_WORKS])dnl +AS_REQUIRE([_AS_UNSET_PREPARE], [], [M4SH-INIT-FN])dnl +]) diff --git a/lib/m4sugar/m4sugar.m4 b/lib/m4sugar/m4sugar.m4 new file mode 100644 index 0000000..278bc05 --- /dev/null +++ b/lib/m4sugar/m4sugar.m4 @@ -0,0 +1,3301 @@ +divert(-1)# -*- Autoconf -*- +# This file is part of Autoconf. +# Base M4 layer. +# Requires GNU M4. +# +# Copyright (C) 1999-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see <http://www.gnu.org/licenses/>. + +# Written by Akim Demaille. + +# Set the quotes, whatever the current quoting system. +changequote() +changequote([, ]) + +# Some old m4's don't support m4exit. But they provide +# equivalent functionality by core dumping because of the +# long macros we define. +ifdef([__gnu__], , +[errprint(M4sugar requires GNU M4. Install it before installing M4sugar or +set the M4 environment variable to its absolute file name.) +m4exit(2)]) + + +## ------------------------------- ## +## 1. Simulate --prefix-builtins. ## +## ------------------------------- ## + +# m4_define +# m4_defn +# m4_undefine +define([m4_define], defn([define])) +define([m4_defn], defn([defn])) +define([m4_undefine], defn([undefine])) + +m4_undefine([define]) +m4_undefine([defn]) +m4_undefine([undefine]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define DST as the definition of SRC. +# What's the difference between: +# 1. m4_copy([from], [to]) +# 2. m4_define([to], [from($@)]) +# Well, obviously 1 is more expensive in space. Maybe 2 is more expensive +# in time, but because of the space cost of 1, it's not that obvious. +# Nevertheless, one huge difference is the handling of `$0'. If `from' +# uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. +# The user would certainly prefer to see `to'. +# +# This definition is in effect during m4sugar initialization, when +# there are no pushdef stacks; later on, we redefine it to something +# more powerful for all other clients to use. +m4_define([m4_copy], +[m4_define([$2], m4_defn([$1]))]) + + +# m4_rename(SRC, DST) +# ------------------- +# Rename the macro SRC to DST. +m4_define([m4_rename], +[m4_copy([$1], [$2])m4_undefine([$1])]) + + +# m4_rename_m4(MACRO-NAME) +# ------------------------ +# Rename MACRO-NAME to m4_MACRO-NAME. +m4_define([m4_rename_m4], +[m4_rename([$1], [m4_$1])]) + + +# m4_copy_unm4(m4_MACRO-NAME) +# --------------------------- +# Copy m4_MACRO-NAME to MACRO-NAME. +m4_define([m4_copy_unm4], +[m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) + + +# Some m4 internals have names colliding with tokens we might use. +# Rename them a` la `m4 --prefix-builtins'. Conditionals first, since +# some subsequent renames are conditional. +m4_rename_m4([ifdef]) +m4_rename([ifelse], [m4_if]) + +m4_rename_m4([builtin]) +m4_rename_m4([changecom]) +m4_rename_m4([changequote]) +m4_ifdef([changeword],dnl conditionally available in 1.4.x +[m4_undefine([changeword])]) +m4_rename_m4([debugfile]) +m4_rename_m4([debugmode]) +m4_rename_m4([decr]) +m4_rename_m4([divnum]) +m4_rename_m4([dumpdef]) +m4_rename_m4([errprint]) +m4_rename_m4([esyscmd]) +m4_rename_m4([eval]) +m4_rename_m4([format]) +m4_undefine([include]) +m4_rename_m4([incr]) +m4_rename_m4([index]) +m4_rename_m4([indir]) +m4_rename_m4([len]) +m4_rename([m4exit], [m4_exit]) +m4_undefine([m4wrap]) +m4_ifdef([mkstemp],dnl added in M4 1.4.8 +[m4_rename_m4([mkstemp]) +m4_copy([m4_mkstemp], [m4_maketemp]) +m4_undefine([maketemp])], +[m4_rename_m4([maketemp]) +m4_copy([m4_maketemp], [m4_mkstemp])]) +m4_rename([patsubst], [m4_bpatsubst]) +m4_rename_m4([popdef]) +m4_rename_m4([pushdef]) +m4_rename([regexp], [m4_bregexp]) +m4_rename_m4([shift]) +m4_undefine([sinclude]) +m4_rename_m4([substr]) +m4_ifdef([symbols],dnl present only in alpha-quality 1.4o +[m4_rename_m4([symbols])]) +m4_rename_m4([syscmd]) +m4_rename_m4([sysval]) +m4_rename_m4([traceoff]) +m4_rename_m4([traceon]) +m4_rename_m4([translit]) + +# _m4_defn(ARG) +# ------------- +# _m4_defn is for internal use only - it bypasses the wrapper, so it +# must only be used on one argument at a time, and only on macros +# known to be defined. Make sure this still works if the user renames +# m4_defn but not _m4_defn. +m4_copy([m4_defn], [_m4_defn]) + +# _m4_divert_raw(NUM) +# ------------------- +# _m4_divert_raw is for internal use only. Use this instead of +# m4_builtin([divert], NUM), so that tracing diversion flow is easier. +m4_rename([divert], [_m4_divert_raw]) + +# _m4_popdef(ARG...) +# ------------------ +# _m4_popdef is for internal use only - it bypasses the wrapper, so it +# must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_popdef but not _m4_popdef. +m4_copy([m4_popdef], [_m4_popdef]) + +# _m4_undefine(ARG...) +# -------------------- +# _m4_undefine is for internal use only - it bypasses the wrapper, so +# it must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_undefine but not _m4_undefine. +m4_copy([m4_undefine], [_m4_undefine]) + +# _m4_undivert(NUM...) +# -------------------- +# _m4_undivert is for internal use only, and should always be given +# arguments. Use this instead of m4_builtin([undivert], NUM...), so +# that tracing diversion flow is easier. +m4_rename([undivert], [_m4_undivert]) + + +## ------------------- ## +## 2. Error messages. ## +## ------------------- ## + + +# m4_location +# ----------- +# Output the current file, colon, and the current line number. +m4_define([m4_location], +[__file__:__line__]) + + +# m4_errprintn(MSG) +# ----------------- +# Same as `errprint', but with the missing end of line. +m4_define([m4_errprintn], +[m4_errprint([$1 +])]) + + +# m4_warning(MSG) +# --------------- +# Warn the user. +m4_define([m4_warning], +[m4_errprintn(m4_location[: warning: $1])]) + + +# m4_fatal(MSG, [EXIT-STATUS]) +# ---------------------------- +# Fatal the user. :) +m4_define([m4_fatal], +[m4_errprintn(m4_location[: error: $1] +m4_expansion_stack)m4_exit(m4_if([$2],, 1, [$2]))]) + + +# m4_assert(EXPRESSION, [EXIT-STATUS = 1]) +# ---------------------------------------- +# This macro ensures that EXPRESSION evaluates to true, and exits if +# EXPRESSION evaluates to false. +m4_define([m4_assert], +[m4_if(m4_eval([$1]), 0, + [m4_fatal([assert failed: $1], [$2])])]) + + + +## ------------- ## +## 3. Warnings. ## +## ------------- ## + + +# _m4_warn(CATEGORY, MESSAGE, [STACK-TRACE]) +# ------------------------------------------ +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +# This is for traces only. +# If present, STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE", +# where the last line (and no other) ends with "the top level". +# +# Within m4, the macro is a no-op. This macro really matters +# when autom4te post-processes the trace output. +m4_define([_m4_warn], []) + + +# m4_warn(CATEGORY, MESSAGE) +# -------------------------- +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +m4_define([m4_warn], +[_m4_warn([$1], [$2], +m4_ifdef([_m4_expansion_stack], [m4_expansion_stack]))]) + + + +## ------------------- ## +## 4. File inclusion. ## +## ------------------- ## + + +# We also want to neutralize include (and sinclude for symmetry), +# but we want to extend them slightly: warn when a file is included +# several times. This is, in general, a dangerous operation, because +# too many people forget to quote the first argument of m4_define. +# +# For instance in the following case: +# m4_define(foo, [bar]) +# then a second reading will turn into +# m4_define(bar, [bar]) +# which is certainly not what was meant. + +# m4_include_unique(FILE) +# ----------------------- +# Declare that the FILE was loading; and warn if it has already +# been included. +m4_define([m4_include_unique], +[m4_ifdef([m4_include($1)], + [m4_warn([syntax], [file `$1' included several times])])dnl +m4_define([m4_include($1)])]) + + +# m4_include(FILE) +# ---------------- +# Like the builtin include, but warns against multiple inclusions. +m4_define([m4_include], +[m4_include_unique([$1])dnl +m4_builtin([include], [$1])]) + + +# m4_sinclude(FILE) +# ----------------- +# Like the builtin sinclude, but warns against multiple inclusions. +m4_define([m4_sinclude], +[m4_include_unique([$1])dnl +m4_builtin([sinclude], [$1])]) + + + +## ------------------------------------ ## +## 5. Additional branching constructs. ## +## ------------------------------------ ## + +# Both `m4_ifval' and `m4_ifset' tests against the empty string. The +# difference is that `m4_ifset' is specialized on macros. +# +# In case of arguments of macros, eg. $1, it makes little difference. +# In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, +# TRUE)', because if `FOO' expands with commas, there is a shifting of +# the arguments. So you want to run `m4_ifval([FOO])', but then you just +# compare the *string* `FOO' against `', which, of course fails. +# +# So you want the variation `m4_ifset' that expects a macro name as $1. +# If this macro is both defined and defined to a non empty value, then +# it runs TRUE, etc. + + +# m4_ifblank(COND, [IF-BLANK], [IF-TEXT]) +# m4_ifnblank(COND, [IF-TEXT], [IF-BLANK]) +# ---------------------------------------- +# If COND is empty, or consists only of blanks (space, tab, newline), +# then expand IF-BLANK, otherwise expand IF-TEXT. This differs from +# m4_ifval only if COND has just whitespace, but it helps optimize in +# spite of users who mistakenly leave trailing space after what they +# thought was an empty argument: +# macro( +# [] +# ) +# +# Writing one macro in terms of the other causes extra overhead, so +# we inline both definitions. +m4_define([m4_ifblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$2], [$3])]) + +m4_define([m4_ifnblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$3], [$2])]) + + +# m4_ifval(COND, [IF-TRUE], [IF-FALSE]) +# ------------------------------------- +# If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. +# Comparable to m4_ifdef. +m4_define([m4_ifval], +[m4_if([$1], [], [$3], [$2])]) + + +# m4_n(TEXT) +# ---------- +# If TEXT is not empty, return TEXT and a new line, otherwise nothing. +m4_define([m4_n], +[m4_if([$1], + [], [], + [$1 +])]) + + +# m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE +# unless that argument is empty. +m4_define([m4_ifvaln], +[m4_if([$1], + [], [m4_n([$3])], + [m4_n([$2])])]) + + +# m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# If MACRO has no definition, or of its definition is the empty string, +# expand IF-FALSE, otherwise IF-TRUE. +m4_define([m4_ifset], +[m4_ifdef([$1], + [m4_ifval(_m4_defn([$1]), [$2], [$3])], + [$3])]) + + +# m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) +# ----------------------------------------------- +m4_define([m4_ifndef], +[m4_ifdef([$1], [$3], [$2])]) + + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# m4 equivalent of +# switch (SWITCH) +# { +# case VAL1: +# IF-VAL1; +# break; +# case VAL2: +# IF-VAL2; +# break; +# ... +# default: +# DEFAULT; +# break; +# }. +# All the values are optional, and the macro is robust to active +# symbols properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_case], +[m4_if([$#], 0, [], + [$#], 1, [], + [$#], 2, [$2], + [$1], [$2], [$3], + [$0([$1], m4_shift3($@))])]) + + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], + [$3])])]) + +# m4_argn(N, ARGS...) +# ------------------- +# Extract argument N (greater than 0) from ARGS. Example: +# m4_define([b], [B]) +# m4_argn([2], [a], [b], [c]) => b +# +# Rather than using m4_car(m4_shiftn([$1], $@)), we exploit the fact that +# GNU m4 can directly reference any argument, through an indirect macro. +m4_define([m4_argn], +[m4_assert([0 < $1])]dnl +[m4_pushdef([_$0], [_m4_popdef([_$0])]m4_dquote([$]m4_incr([$1])))_$0($@)]) + + +# m4_car(ARGS...) +# m4_cdr(ARGS...) +# --------------- +# Manipulate m4 lists. m4_car returns the first argument. m4_cdr +# bundles all but the first argument into a quoted list. These two +# macros are generally used with list arguments, with quoting removed +# to break the list into multiple m4 ARGS. +m4_define([m4_car], [[$1]]) +m4_define([m4_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) + +# _m4_cdr(ARGS...) +# ---------------- +# Like m4_cdr, except include a leading comma unless only one argument +# remains. Why? Because comparing a large list against [] is more +# expensive in expansion time than comparing the number of arguments; so +# _m4_cdr can be used to reduce the number of arguments when it is time +# to end recursion. +m4_define([_m4_cdr], +[m4_if([$#], 1, [], + [, m4_dquote(m4_shift($@))])]) + + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# For an example, consider a previous implementation of _AS_QUOTE_IFELSE: +# +# m4_if(m4_index([$1], [\]), [-1], [$2], +# m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], +# m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], +# [$2]) +# +# Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains +# no backslash. It is more efficient to do: +# +# m4_cond([m4_index([$1], [\])], [-1], [$2], +# [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], +# [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], +# [$2]) +# +# In the common case of $1 with no backslash, only one m4_index expansion +# occurs, and m4_eval is avoided altogether. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_cond], +[m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], + [$#], [1], [$1], + m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], + [_$0($@)])]) + +m4_define([_m4_cond], +[m4_if(($1), [($2)], [$3], + [$#], [3], [], + [$#], [4], [$4], + [$0(m4_shift3($@))])]) + + +## ---------------------------------------- ## +## 6. Enhanced version of some primitives. ## +## ---------------------------------------- ## + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# I would have liked to name this macro `m4_bpatsubst', unfortunately, +# due to quotation problems, I need to double quote $1 below, therefore +# the anchors are broken :( I can't let users be trapped by that. +# +# Recall that m4_shift3 always results in an argument. Hence, we need +# to distinguish between a final deletion vs. ending recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bpatsubsts], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], + [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], + [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) +m4_define([_m4_bpatsubsts], +[m4_if([$#], 2, [$1], + [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), + m4_shift3($@))])]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define the pushdef stack DST as a copy of the pushdef stack SRC; +# give an error if DST is already defined. This is particularly nice +# for copying self-modifying pushdef stacks, where the top definition +# includes one-shot initialization that is later popped to the normal +# definition. This version intentionally does nothing if SRC is +# undefined. +# +# Some macros simply can't be renamed with this method: namely, anything +# involved in the implementation of m4_stack_foreach_sep. +m4_define([m4_copy], +[m4_ifdef([$2], [m4_fatal([$0: won't overwrite defined macro: $2])], + [m4_stack_foreach_sep([$1], [m4_pushdef([$2],], [)])])]dnl +[m4_ifdef([m4_location($1)], [m4_define([m4_location($2)], m4_location)])]) + + +# m4_copy_force(SRC, DST) +# m4_rename_force(SRC, DST) +# ------------------------- +# Like m4_copy/m4_rename, except blindly overwrite any existing DST. +# Note that m4_copy_force tolerates undefined SRC, while m4_rename_force +# does not. +m4_define([m4_copy_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_copy($@)]) + +m4_define([m4_rename_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_rename($@)]) + + +# m4_define_default(MACRO, VALUE) +# ------------------------------- +# If MACRO is undefined, set it to VALUE. +m4_define([m4_define_default], +[m4_ifndef([$1], [m4_define($@)])]) + + +# m4_default(EXP1, EXP2) +# m4_default_nblank(EXP1, EXP2) +# ----------------------------- +# Returns EXP1 if not empty/blank, otherwise EXP2. Expand the result. +# +# m4_default is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default], +[m4_if([$1], [], [$2], [$1])]) + +m4_define([m4_default_nblank], +[m4_ifblank([$1], [$2], [$1])]) + + +# m4_default_quoted(EXP1, EXP2) +# m4_default_nblank_quoted(EXP1, EXP2) +# ------------------------------------ +# Returns EXP1 if non empty/blank, otherwise EXP2. Leave the result quoted. +# +# For comparison: +# m4_define([active], [ACTIVE]) +# m4_default([active], [default]) => ACTIVE +# m4_default([], [active]) => ACTIVE +# -m4_default([ ], [active])- => - - +# -m4_default_nblank([ ], [active])- => -ACTIVE- +# m4_default_quoted([active], [default]) => active +# m4_default_quoted([], [active]) => active +# -m4_default_quoted([ ], [active])- => - - +# -m4_default_nblank_quoted([ ], [active])- => -active- +# +# m4_default macro is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default_quoted], +[m4_if([$1], [], [[$2]], [[$1]])]) + +m4_define([m4_default_nblank_quoted], +[m4_ifblank([$1], [[$2]], [[$1]])]) + + +# m4_defn(NAME) +# ------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). This replacement is not a full-featured +# replacement: if any of the defined macros contain unbalanced quoting, but +# when pasted together result in a well-quoted string, then only native m4 +# support is able to get it correct. But that's where quadrigraphs come in +# handy, if you really need unbalanced quotes inside your macros. +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_defn], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_dumpdef(NAME...) +# ------------------- +# In m4 1.4.x, dumpdef writes to the current debugfile, rather than +# stderr. This in turn royally confuses autom4te; so we follow the +# lead of newer m4 and always dump to stderr. Unlike the original, +# this version requires an argument, since there is no convenient way +# in m4 1.4.x to grab the names of all defined macros. Newer m4 +# always dumps to stderr, regardless of the current debugfile; it also +# provides m4symbols as a way to grab all current macro names. But +# dumpdefs is not frequently called, so we don't need to worry about +# conditionally using these newer features. Also, this version +# doesn't sort multiple arguments. +# +# If we detect m4 1.6 or newer, then provide an alternate definition, +# installed during m4_init, that allows builtins through. +# Unfortunately, there is no nice way in m4 1.4.x to dump builtins. +m4_define([m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_ifdef([$1], [m4_errprintn( + [$1: ]m4_dquote(_m4_defn([$1])))], [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +m4_define([_m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_builtin([dumpdef], [$1])], + [m4_map_args_sep([m4_builtin([dumpdef],], [)], [], $@)])]) + + +# m4_dumpdefs(NAME...) +# -------------------- +# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its +# value stack (most recent displayed first). Also, this version silently +# ignores undefined macros, rather than erroring out. +# +# This macro cheats, because it relies on the current definition of NAME +# while the second argument of m4_stack_foreach_lifo is evaluated (which +# would be undefined according to the API). +m4_define([m4_dumpdefs], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_stack_foreach_lifo([$1], [m4_dumpdef([$1])m4_ignore])], + [m4_map_args([$0], $@)])]) + +# m4_esyscmd_s(COMMAND) +# --------------------- +# Like m4_esyscmd, except strip any trailing newlines, thus behaving +# more like shell command substitution. +m4_define([m4_esyscmd_s], +[m4_chomp_all(m4_esyscmd([$1]))]) + + +# m4_popdef(NAME) +# --------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_popdef], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# Autoconf does not use this macro, because it is inherently slower than +# calling the common cases of m4_shift2 or m4_shift3 directly. But it +# might as well be fast for other clients, such as Libtool. One way to +# do this is to expand $@ only once in _m4_shiftn (otherwise, for long +# lists, the expansion of m4_if takes twice as much memory as what the +# list itself occupies, only to throw away the unused branch). The end +# result is strictly equivalent to +# m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], +# [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) +# but with the final `m4_shift(m4_shift($@)))' shared between the two +# paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_shiftn], +[m4_assert(0 < $1 && $1 < $#)_$0($@)]) + +m4_define([_m4_shiftn], +[m4_if([$1], 1, [m4_shift(], + [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) + +# m4_shift2(...) +# m4_shift3(...) +# -------------- +# Returns ... shifted twice, and three times. Faster than m4_shiftn. +m4_define([m4_shift2], [m4_shift(m4_shift($@))]) +m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) + +# _m4_shift2(...) +# _m4_shift3(...) +# --------------- +# Like m4_shift2 or m4_shift3, except include a leading comma unless shifting +# consumes all arguments. Why? Because in recursion, it is nice to +# distinguish between 1 element left and 0 elements left, based on how many +# arguments this shift expands to. +m4_define([_m4_shift2], +[m4_if([$#], [2], [], + [, m4_shift(m4_shift($@))])]) +m4_define([_m4_shift3], +[m4_if([$#], [3], [], + [, m4_shift(m4_shift(m4_shift($@)))])]) + + +# m4_undefine(NAME) +# ----------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_undefine], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +# _m4_wrap(PRE, POST) +# ------------------- +# Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to +# m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. +m4_define([_m4_wrap], +[m4_ifdef([$0_text], + [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], + [m4_builtin([m4wrap], [m4_unquote( + _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) + +# m4_wrap(TEXT) +# ------------- +# Append TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of the original may be LIFO in the underlying m4, +# this version is always FIFO. +m4_define([m4_wrap], +[_m4_wrap([], [$1[]])]) + +# m4_wrap_lifo(TEXT) +# ------------------ +# Prepend TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of m4_wrap may be FIFO in the underlying m4, this +# version is always LIFO. +m4_define([m4_wrap_lifo], +[_m4_wrap([$1[]])]) + +## ------------------------- ## +## 7. Quoting manipulation. ## +## ------------------------- ## + + +# m4_apply(MACRO, LIST) +# --------------------- +# Invoke MACRO, with arguments provided from the quoted list of +# comma-separated quoted arguments. If LIST is empty, invoke MACRO +# without arguments. The expansion will not be concatenated with +# subsequent text. +m4_define([m4_apply], +[m4_if([$2], [], [$1], [$1($2)])[]]) + +# _m4_apply(MACRO, LIST) +# ---------------------- +# Like m4_apply, except do nothing if LIST is empty. +m4_define([_m4_apply], +[m4_if([$2], [], [], [$1($2)[]])]) + + +# m4_count(ARGS) +# -------------- +# Return a count of how many ARGS are present. +m4_define([m4_count], [$#]) + + +# m4_curry(MACRO, ARG...) +# ----------------------- +# Perform argument currying. The expansion of this macro is another +# macro that takes exactly one argument, appends it to the end of the +# original ARG list, then invokes MACRO. For example: +# m4_curry([m4_curry], [m4_reverse], [1])([2])([3]) => 3, 2, 1 +# Not quite as practical as m4_incr, but you could also do: +# m4_define([add], [m4_eval(([$1]) + ([$2]))]) +# m4_define([add_one], [m4_curry([add], [1])]) +# add_one()([2]) => 3 +m4_define([m4_curry], [$1(m4_shift($@,)_$0]) +m4_define([_m4_curry], [[$1])]) + + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. No concatenation +# occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_do], +[m4_if([$#], 0, [], + [$#], 1, [$1[]], + [$1[]$0(m4_shift($@))])]) + + +# m4_dquote(ARGS) +# --------------- +# Return ARGS as a quoted list of quoted arguments. +m4_define([m4_dquote], [[$@]]) + + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], + [$#], [1], [[[$1]]], + [[[$1]],$0(m4_shift($@))])]) + + +# m4_echo(ARGS) +# ------------- +# Return the ARGS, with the same level of quoting. Whitespace after +# unquoted commas are consumed. +m4_define([m4_echo], [$@]) + + +# m4_expand(ARG) +# _m4_expand(ARG) +# --------------- +# Return the expansion of ARG as a single string. Unlike +# m4_quote($1), this preserves whitespace following single-quoted +# commas that appear within ARG. It also deals with shell case +# statements. +# +# m4_define([active], [ACT, IVE]) +# m4_define([active2], [[ACT, IVE]]) +# m4_quote(active, active2) +# => ACT,IVE,ACT, IVE +# m4_expand([active, active2]) +# => ACT, IVE, ACT, IVE +# +# Unfortunately, due to limitations in m4, ARG must expand to +# something with balanced quotes (use quadrigraphs to get around +# this), and should not contain the unlikely delimiters -=<{( or +# )}>=-. It is possible to have unbalanced quoted `(' or `)', as well +# as unbalanced unquoted `)'. m4_expand can handle unterminated +# comments or dnl on the final line, at the expense of speed; it also +# aids in detecting attempts to incorrectly change the current +# diversion inside ARG. Meanwhile, _m4_expand is faster but must be +# given a terminated expansion, and has no safety checks for +# mis-diverted text. +# +# Exploit that extra unquoted () will group unquoted commas and the +# following whitespace. m4_bpatsubst can't handle newlines inside $1, +# and m4_substr strips quoting. So we (ab)use m4_changequote, using +# temporary quotes to remove the delimiters that conveniently included +# the unquoted () that were added prior to the changequote. +# +# Thanks to shell case statements, too many people are prone to pass +# underquoted `)', so we try to detect that by passing a marker as a +# fourth argument; if the marker is not present, then we assume that +# we encountered an early `)', and re-expand the first argument, but +# this time with one more `(' in the second argument and in the +# open-quote delimiter. We must also ignore the slop from the +# previous try. The final macro is thus half line-noise, half art. +m4_define([m4_expand], +[m4_pushdef([m4_divert], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_pushdef([m4_divert_push], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_chomp(_$0([$1 +]))_m4_popdef([m4_divert], [m4_divert_push])]) + +m4_define([_m4_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])]) + +m4_define([_m4_expand_], +[m4_if([$4], [}>=-], + [m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])], + [$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])m4_ignore$2])]) + + +# m4_ignore(ARGS) +# --------------- +# Expands to nothing. Useful for conditionally ignoring an arbitrary +# number of arguments (see _m4_list_cmp for an example). +m4_define([m4_ignore]) + + +# m4_make_list(ARGS) +# ------------------ +# Similar to m4_dquote, this creates a quoted list of quoted ARGS. This +# version is less efficient than m4_dquote, but separates each argument +# with a comma and newline, rather than just comma, for readability. +# When developing an m4sugar algorithm, you could temporarily use +# m4_pushdef([m4_dquote],m4_defn([m4_make_list])) +# around your code to make debugging easier. +m4_define([m4_make_list], [m4_join([, +], m4_dquote_elt($@))]) + + +# m4_noquote(STRING) +# ------------------ +# Return the result of ignoring all quotes in STRING and invoking the +# macros it contains. Among other things, this is useful for enabling +# macro invocations inside strings with [] blocks (for instance regexps +# and help-strings). On the other hand, since all quotes are disabled, +# any macro expanded during this time that relies on nested [] quoting +# will likely crash and burn. This macro is seldom useful; consider +# m4_unquote or m4_expand instead. +m4_define([m4_noquote], +[m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) + + +# m4_quote(ARGS) +# -------------- +# Return ARGS as a single argument. Any whitespace after unquoted commas +# is stripped. There is always output, even when there were no arguments. +# +# It is important to realize the difference between `m4_quote(exp)' and +# `[exp]': in the first case you obtain the quoted *result* of the +# expansion of EXP, while in the latter you just obtain the string +# `exp'. +m4_define([m4_quote], [[$*]]) + + +# _m4_quote(ARGS) +# --------------- +# Like m4_quote, except that when there are no arguments, there is no +# output. For conditional scenarios (such as passing _m4_quote as the +# macro name in m4_mapall), this feature can be used to distinguish between +# one argument of the empty string vs. no arguments. However, in the +# normal case with arguments present, this is less efficient than m4_quote. +m4_define([_m4_quote], +[m4_if([$#], [0], [], [[$*]])]) + + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], + [$0(m4_shift($@)), [$1]])]) + + +# m4_unquote(ARGS) +# ---------------- +# Remove one layer of quotes from each ARG, performing one level of +# expansion. For one argument, m4_unquote([arg]) is more efficient than +# m4_do([arg]), but for multiple arguments, the difference is that +# m4_unquote separates arguments with commas while m4_do concatenates. +# Follow this macro with [] if concatenation with subsequent text is +# undesired. +m4_define([m4_unquote], [$*]) + + +## -------------------------- ## +## 8. Implementing m4 loops. ## +## -------------------------- ## + + +# m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) +# -------------------------------------------------------- +# Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with +# increments of STEP. Both limits are included, and bounds are +# checked for consistency. The algorithm is robust to indirect +# VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact +# the number of iterations. +# +# Uses _m4_defn for speed, and avoid dnl in the macro body. Factor +# the _m4_for call so that EXPRESSION is only parsed once. +m4_define([m4_for], +[m4_pushdef([$1], m4_eval([$2]))]dnl +[m4_cond([m4_eval(([$3]) > ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + 1)))m4_assert(_m4_step > 0)_$0(_m4_defn([$1]), + m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), _m4_step,], + [m4_eval(([$3]) < ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + -1)))m4_assert(_m4_step < 0)_$0(_m4_defn([$1]), + m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), _m4_step,], + [m4_pushdef([_m4_step])_$0(_m4_defn([$1]), _m4_defn([$1]), 0,])]dnl +[[m4_define([$1],], [)$5])m4_popdef([_m4_step], [$1])]) + +# _m4_for(COUNT, LAST, STEP, PRE, POST) +# ------------------------------------- +# Core of the loop, no consistency checks, all arguments are plain +# numbers. Expand PRE[COUNT]POST, then alter COUNT by STEP and +# iterate if COUNT is not LAST. +m4_define([_m4_for], +[$4[$1]$5[]m4_if([$1], [$2], [], + [$0(m4_eval([$1 + $3]), [$2], [$3], [$4], [$5])])]) + + +# Implementing `foreach' loops in m4 is much more tricky than it may +# seem. For example, the old M4 1.4.4 manual had an incorrect example, +# which looked like this (when translated to m4sugar): +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], +# | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if([$2], [()], , +# | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) +# +# But then if you run +# +# | m4_define(a, 1) +# | m4_define(b, 2) +# | m4_define(c, 3) +# | foreach([f], [([a], [(b], [c)])], [echo f +# | ]) +# +# it gives +# +# => echo 1 +# => echo (2,3) +# +# which is not what is expected. +# +# Of course the problem is that many quotes are missing. So you add +# plenty of quotes at random places, until you reach the expected +# result. Alternatively, if you are a quoting wizard, you directly +# reach the following implementation (but if you really did, then +# apply to the maintenance of m4sugar!). +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [[$1]]) +# | m4_define([_foreach], +# | [m4_if($2, [()], , +# | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) +# +# which this time answers +# +# => echo a +# => echo (b +# => echo c) +# +# Bingo! +# +# Well, not quite. +# +# With a better look, you realize that the parens are more a pain than +# a help: since anyway you need to quote properly the list, you end up +# with always using an outermost pair of parens and an outermost pair +# of quotes. Rejecting the parens both eases the implementation, and +# simplifies the use: +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if($2, [], , +# | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) +# +# +# Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' +# to improve robustness, and you come up with a nice implementation +# that doesn't require extra parentheses in the user's LIST. +# +# But wait - now the algorithm is quadratic, because every recursion of +# the algorithm keeps the entire LIST and merely adds another m4_shift to +# the quoted text. If the user has a lot of elements in LIST, you can +# bring the system to its knees with the memory m4 then requires, or trip +# the m4 --nesting-limit recursion factor. The only way to avoid +# quadratic growth is ensure m4_shift is expanded prior to the recursion. +# Hence the design below. +# +# The M4 manual now includes a chapter devoted to this issue, with +# the lessons learned from m4sugar. And still, this design is only +# optimal for M4 1.6; see foreach.m4 for yet more comments on why +# M4 1.4.x uses yet another implementation. + + +# m4_foreach(VARIABLE, LIST, EXPRESSION) +# -------------------------------------- +# +# Expand EXPRESSION assigning each value of the LIST to VARIABLE. +# LIST should have the form `item_1, item_2, ..., item_n', i.e. the +# whole list must *quoted*. Quote members too if you don't want them +# to be expanded. +# +# This macro is robust to active symbols: +# | m4_define(active, [ACT, IVE]) +# | m4_foreach(Var, [active, active], [-Var-]) +# => -ACT--IVE--ACT--IVE- +# +# | m4_foreach(Var, [[active], [active]], [-Var-]) +# => -ACT, IVE--ACT, IVE- +# +# | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) +# => -active--active- +# +# This macro is called frequently, so avoid extra expansions such as +# m4_ifval and dnl. Also, since $2 might be quite large, try to use it +# as little as possible in _m4_foreach; each extra use requires that much +# more memory for expansion. So, rather than directly compare $2 against +# [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which +# requires swapping the argument order in the helper), insert an ignored +# third argument, and use m4_shift3 to detect when recursion is complete, +# at which point this looks very much like m4_map_args. +m4_define([m4_foreach], +[m4_if([$2], [], [], + [m4_pushdef([$1])_$0([m4_define([$1],], [)$3], [], + $2)m4_popdef([$1])])]) + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [$1[$4]$2[]$0([$1], [$2], m4_shift3($@))])]) + + +# m4_foreach_w(VARIABLE, LIST, EXPRESSION) +# ---------------------------------------- +# Like m4_foreach, but the list is whitespace separated. Depending on +# EXPRESSION, it may be more efficient to use m4_map_args_w. +# +# This macro is robust to active symbols: +# m4_foreach_w([Var], [ active +# b act\ +# ive ], [-Var-])end +# => -active--b--active-end +# +# This used to use a slower implementation based on m4_foreach: +# m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3]) +m4_define([m4_foreach_w], +[m4_pushdef([$1])m4_map_args_w([$2], + [m4_define([$1],], [)$3])m4_popdef([$1])]) + + +# m4_map(MACRO, LIST) +# m4_mapall(MACRO, LIST) +# ---------------------- +# Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of +# LIST. $1, $2... must in turn be lists, appropriate for m4_apply. +# If LIST contains an empty sublist, m4_map skips the expansion of +# MACRO, while m4_mapall expands MACRO with no arguments. +# +# Since LIST may be quite large, we want to minimize how often it +# appears in the expansion. Rather than use m4_car/m4_cdr iteration, +# we unbox the list, and use _m4_foreach for iteration. For m4_map, +# an empty list behaves like an empty sublist and gets ignored; for +# m4_mapall, we must special-case the empty list. +m4_define([m4_map], +[_m4_foreach([_m4_apply([$1],], [)], [], $2)]) + +m4_define([m4_mapall], +[m4_if([$2], [], [], + [_m4_foreach([m4_apply([$1],], [)], [], $2)])]) + + +# m4_map_sep(MACRO, [SEPARATOR], LIST) +# m4_mapall_sep(MACRO, [SEPARATOR], LIST) +# --------------------------------------- +# Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, +# $2... $N are the elements of LIST, and are in turn lists appropriate +# for m4_apply. SEPARATOR is expanded, in order to allow the creation +# of a list of arguments by using a single-quoted comma as the +# separator. For each empty sublist, m4_map_sep skips the expansion +# of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no +# arguments. +# +# For m4_mapall_sep, merely expand the first iteration without the +# separator, then include separator as part of subsequent recursion; +# but avoid extra expansion of LIST's side-effects via a helper macro. +# For m4_map_sep, things are trickier - we don't know if the first +# list element is an empty sublist, so we must define a self-modifying +# helper macro and use that as the separator instead. +m4_define([m4_map_sep], +[m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl +[_m4_foreach([_m4_apply([m4_Sep([$2])[]$1],], [)], [], $3)m4_popdef([m4_Sep])]) + +m4_define([m4_mapall_sep], +[m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) + +m4_define([_m4_mapall_sep], +[m4_apply([$1], [$3])_m4_foreach([m4_apply([$2[]$1],], [)], m4_shift2($@))]) + +# m4_map_args(EXPRESSION, ARG...) +# ------------------------------- +# Expand EXPRESSION([ARG]) for each argument. More efficient than +# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) +# Shorthand for m4_map_args_sep([EXPRESSION(], [)], [], ARG...). +m4_define([m4_map_args], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [$1([$2])[]], + [_m4_foreach([$1(], [)], $@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# For example: +# m4_define([show], [($*)m4_newline])dnl +# m4_map_args_pair([show], [], [a], [b], [c], [d], [e])dnl +# => (a,b) +# => (c,d) +# => (e) +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [$#], [4], [$1([$3], [$4])[]], + [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) + + +# m4_map_args_sep([PRE], [POST], [SEP], ARG...) +# --------------------------------------------- +# Expand PRE[ARG]POST for each argument, with SEP between arguments. +m4_define([m4_map_args_sep], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [], + [$#], [3], [], + [$#], [4], [$1[$4]$2[]], + [$1[$4]$2[]_m4_foreach([$3[]$1], [$2], m4_shift3($@))])]) + + +# m4_map_args_w(STRING, [PRE], [POST], [SEP]) +# ------------------------------------------- +# Perform the expansion of PRE[word]POST[] for each word in STRING +# separated by whitespace. More efficient than: +# m4_foreach_w([var], [STRING], [PRE[]m4_defn([var])POST]) +# Additionally, expand SEP between words. +# +# As long as we have to use m4_bpatsubst to split the string, we might +# as well make it also apply PRE and POST; this avoids iteration +# altogether. But we must be careful of any \ in PRE or POST. +# _m4_strip returns a quoted string, but that's okay, since it also +# supplies an empty leading and trailing argument due to our +# intentional whitespace around STRING. We use m4_substr to strip the +# empty elements and remove the extra layer of quoting. +m4_define([m4_map_args_w], +[_$0(_m4_split([ ]m4_flatten([$1])[ ], [[ ]+], + m4_if(m4_index([$2$3$4], [\]), [-1], [[$3[]$4[]$2]], + [m4_bpatsubst([[$3[]$4[]$2]], [\\], [\\\\])])), + m4_len([[]$3[]$4]), m4_len([$4[]$2[]]))]) + +m4_define([_m4_map_args_w], +[m4_substr([$1], [$2], m4_eval(m4_len([$1]) - [$2] - [$3]))]) + + +# m4_stack_foreach(MACRO, FUNC) +# m4_stack_foreach_lifo(MACRO, FUNC) +# ---------------------------------- +# Pass each stacked definition of MACRO to the one-argument macro FUNC. +# m4_stack_foreach proceeds in FIFO order, while m4_stack_foreach_lifo +# processes the topmost definitions first. In addition, FUNC should +# not push or pop definitions of MACRO, and should not expect anything about +# the active definition of MACRO (it will not be the topmost, and may not +# be the one passed to FUNC either). +# +# Some macros simply can't be examined with this method: namely, +# anything involved in the implementation of _m4_stack_reverse. +m4_define([m4_stack_foreach], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2(_m4_defn([m4_tmp-$1]))])]) + +m4_define([m4_stack_foreach_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2(_m4_defn([m4_tmp-$1]))])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + +# m4_stack_foreach_sep(MACRO, [PRE], [POST], [SEP]) +# m4_stack_foreach_sep_lifo(MACRO, [PRE], [POST], [SEP]) +# ------------------------------------------------------ +# Similar to m4_stack_foreach and m4_stack_foreach_lifo, in that every +# definition of a pushdef stack will be visited. But rather than +# passing the definition as a single argument to a macro, this variant +# expands the concatenation of PRE[]definition[]POST, and expands SEP +# between consecutive expansions. Note that m4_stack_foreach([a], [b]) +# is equivalent to m4_stack_foreach_sep([a], [b(], [)]). +m4_define([m4_stack_foreach_sep], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]) + +m4_define([m4_stack_foreach_sep_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + + +# _m4_stack_reverse(OLD, NEW, [ACTION], [SEP]) +# -------------------------------------------- +# A recursive worker for pushdef stack manipulation. Destructively +# copy the OLD stack into the NEW, and expanding ACTION for each +# iteration. After the first iteration, SEP is promoted to the front +# of ACTION (note that SEP should include a trailing [] if it is to +# avoid interfering with ACTION). The current definition is examined +# after the NEW has been pushed but before OLD has been popped; this +# order is important, as ACTION is permitted to operate on either +# _m4_defn([OLD]) or _m4_defn([NEW]). Since the operation is +# destructive, this macro is generally used twice, with a temporary +# macro name holding the swapped copy. +m4_define([_m4_stack_reverse], +[m4_ifdef([$1], [m4_pushdef([$2], + _m4_defn([$1]))$3[]_m4_popdef([$1])$0([$1], [$2], [$4$3])])]) + + + +## --------------------------- ## +## 9. More diversion support. ## +## --------------------------- ## + + +# m4_cleardivert(DIVERSION-NAME...) +# --------------------------------- +# Discard any text in DIVERSION-NAME. +# +# This works even inside m4_expand. +m4_define([m4_cleardivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [_m4_divert_raw([-1])m4_undivert($@)_m4_divert_raw( + _m4_divert(_m4_defn([_m4_divert_diversion]), [-]))])]) + + +# _m4_divert(DIVERSION-NAME or NUMBER, [NOWARN]) +# ---------------------------------------------- +# If DIVERSION-NAME is the name of a diversion, return its number, +# otherwise if it is a NUMBER return it. Issue a warning about +# the use of a number instead of a name, unless NOWARN is provided. +m4_define([_m4_divert], +[m4_ifdef([_m4_divert($1)], + [m4_indir([_m4_divert($1)])], + [m4_if([$2], [], [m4_warn([syntax], + [prefer named diversions])])$1])]) + +# KILL is only used to suppress output. +m4_define([_m4_divert(KILL)], -1) + +# The empty diversion name is a synonym for 0. +m4_define([_m4_divert()], 0) + + +# m4_divert_stack +# --------------- +# Print the diversion stack, if it's nonempty. The caller is +# responsible for any leading or trailing newline. +m4_define([m4_divert_stack], +[m4_stack_foreach_sep_lifo([_m4_divert_stack], [], [], [ +])]) + + +# m4_divert_stack_push(MACRO-NAME, DIVERSION-NAME) +# ------------------------------------------------ +# Form an entry of the diversion stack from caller MACRO-NAME and +# entering DIVERSION-NAME and push it. +m4_define([m4_divert_stack_push], +[m4_pushdef([_m4_divert_stack], m4_location[: $1: $2])]) + + +# m4_divert(DIVERSION-NAME) +# ------------------------- +# Change the diversion stream to DIVERSION-NAME. +m4_define([m4_divert], +[m4_popdef([_m4_divert_stack])]dnl +[m4_define([_m4_divert_diversion], [$1])]dnl +[m4_divert_stack_push([$0], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1]))]) + + +# m4_divert_push(DIVERSION-NAME, [NOWARN]) +# ---------------------------------------- +# Change the diversion stream to DIVERSION-NAME, while stacking old values. +# For internal use only: if NOWARN is not empty, DIVERSION-NAME can be a +# number instead of a name. +m4_define([m4_divert_push], +[m4_divert_stack_push([$0], [$1])]dnl +[m4_pushdef([_m4_divert_diversion], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1], [$2]))]) + + +# m4_divert_pop([DIVERSION-NAME]) +# ------------------------------- +# Change the diversion stream to its previous value, unstacking it. +# If specified, verify we left DIVERSION-NAME. +# When we pop the last value from the stack, we divert to -1. +m4_define([m4_divert_pop], +[m4_if([$1], [], [], + [$1], _m4_defn([_m4_divert_diversion]), [], + [m4_fatal([$0($1): diversion mismatch: +]m4_divert_stack)])]dnl +[_m4_popdef([_m4_divert_stack], [_m4_divert_diversion])]dnl +[m4_ifdef([_m4_divert_diversion], [], + [m4_fatal([too many m4_divert_pop])])]dnl +[_m4_divert_raw(_m4_divert(_m4_defn([_m4_divert_diversion]), [-]))]) + + +# m4_divert_text(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME (which may be a number actually). +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_text], +[m4_divert_push([$1])$2 +m4_divert_pop([$1])]) + + +# m4_divert_once(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME once, if not already there. +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_once], +[m4_expand_once([m4_divert_text([$1], [$2])])]) + + +# _m4_divert_unsafe(DIVERSION-NAME) +# --------------------------------- +# Issue a warning that the attempt to change the current diversion to +# DIVERSION-NAME is unsafe, because this macro is being expanded +# during argument collection of m4_expand. +m4_define([_m4_divert_unsafe], +[m4_fatal([$0: cannot change diversion to `$1' inside m4_expand])]) + + +# m4_undivert(DIVERSION-NAME...) +# ------------------------------ +# Undivert DIVERSION-NAME. Unlike the M4 version, this requires at +# least one DIVERSION-NAME; also, due to support for named diversions, +# this should not be used to undivert files. +m4_define([m4_undivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [_m4_undivert(_m4_divert([$1]))], + [m4_map_args([$0], $@)])]) + + +## --------------------------------------------- ## +## 10. Defining macros with bells and whistles. ## +## --------------------------------------------- ## + +# `m4_defun' is basically `m4_define' but it equips the macro with the +# needed machinery for `m4_require'. A macro must be m4_defun'd if +# either it is m4_require'd, or it m4_require's. +# +# Two things deserve attention and are detailed below: +# 1. Implementation of m4_require +# 2. Keeping track of the expansion stack +# +# 1. Implementation of m4_require +# =============================== +# +# Of course m4_defun calls m4_provide, so that a macro which has +# been expanded is not expanded again when m4_require'd, but the +# difficult part is the proper expansion of macros when they are +# m4_require'd. +# +# The implementation is based on three ideas, (i) using diversions to +# prepare the expansion of the macro and its dependencies (by Franc,ois +# Pinard), (ii) expand the most recently m4_require'd macros _after_ +# the previous macros (by Axel Thimm), and (iii) track instances of +# provide before require (by Eric Blake). +# +# +# The first idea: why use diversions? +# ----------------------------------- +# +# When a macro requires another, the other macro is expanded in new +# diversion, GROW. When the outer macro is fully expanded, we first +# undivert the most nested diversions (GROW - 1...), and finally +# undivert GROW. To understand why we need several diversions, +# consider the following example: +# +# | m4_defun([TEST1], [Test...m4_require([TEST2])1]) +# | m4_defun([TEST2], [Test...m4_require([TEST3])2]) +# | m4_defun([TEST3], [Test...3]) +# +# Because m4_require is not required to be first in the outer macros, we +# must keep the expansions of the various levels of m4_require separated. +# Right before executing the epilogue of TEST1, we have: +# +# GROW - 2: Test...3 +# GROW - 1: Test...2 +# GROW: Test...1 +# BODY: +# +# Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and +# GROW into the regular flow, BODY. +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: Test...3; Test...2; Test...1 +# +# (The semicolons are here for clarification, but of course are not +# emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) +# implement. +# +# +# The second idea: first required first out +# ----------------------------------------- +# +# The natural implementation of the idea above is buggy and produces +# very surprising results in some situations. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [m4_require([TEST2a])m4_require([TEST2b])]) +# | m4_defun([TEST2a], []) +# | m4_defun([TEST2b], [m4_require([TEST3])]) +# | m4_defun([TEST3], [m4_require([TEST2a])]) +# | +# | AC_INIT +# | TEST1 +# +# The dependencies between the macros are: +# +# 3 --- 2b +# / \ is m4_require'd by +# / \ left -------------------- right +# 2a ------------ 1 +# +# If you strictly apply the rules given in the previous section you get: +# +# GROW - 2: TEST3 +# GROW - 1: TEST2a; TEST2b +# GROW: TEST1 +# BODY: +# +# (TEST2a, although required by TEST3 is not expanded in GROW - 3 +# because is has already been expanded before in GROW - 1, so it has +# been AC_PROVIDE'd, so it is not expanded again) so when you undivert +# the stack of diversions, you get: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST3; TEST2a; TEST2b; TEST1 +# +# i.e., TEST2a is expanded after TEST3 although the latter required the +# former. +# +# Starting from 2.50, we use an implementation provided by Axel Thimm. +# The idea is simple: the order in which macros are emitted must be the +# same as the one in which macros are expanded. (The bug above can +# indeed be described as: a macro has been m4_provide'd before its +# dependent, but it is emitted after: the lack of correlation between +# emission and expansion order is guilty). +# +# How to do that? You keep the stack of diversions to elaborate the +# macros, but each time a macro is fully expanded, emit it immediately. +# +# In the example above, when TEST2a is expanded, but it's epilogue is +# not run yet, you have: +# +# GROW - 2: +# GROW - 1: TEST2a +# GROW: Elaboration of TEST1 +# BODY: +# +# The epilogue of TEST2a emits it immediately: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# TEST2b then requires TEST3, so right before the epilogue of TEST3, you +# have: +# +# GROW - 2: TEST3 +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# The epilogue of TEST3 emits it: +# +# GROW - 2: +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3 +# +# TEST2b is now completely expanded, and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3; TEST2b +# +# and finally, TEST1 is finished and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST2a; TEST3; TEST2b: TEST1 +# +# The idea is simple, but the implementation is a bit involved. If +# you are like me, you will want to see the actual functioning of this +# implementation to be convinced. The next section gives the full +# details. +# +# +# The Axel Thimm implementation at work +# ------------------------------------- +# +# We consider the macros above, and this configure.ac: +# +# AC_INIT +# TEST1 +# +# You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and +# m4_require at hand to follow the steps. +# +# This implementation tries not to assume that the current diversion is +# BODY, so as soon as a macro (m4_defun'd) is expanded, we first +# record the current diversion under the name _m4_divert_dump (denoted +# DUMP below for short). This introduces an important difference with +# the previous versions of Autoconf: you cannot use m4_require if you +# are not inside an m4_defun'd macro, and especially, you cannot +# m4_require directly from the top level. +# +# We have not tried to simulate the old behavior (better yet, we +# diagnose it), because it is too dangerous: a macro m4_require'd from +# the top level is expanded before the body of `configure', i.e., before +# any other test was run. I let you imagine the result of requiring +# AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... +# +# After AC_INIT was run, the current diversion is BODY. +# * AC_INIT was run +# DUMP: undefined +# diversion stack: BODY |- +# +# * TEST1 is expanded +# The prologue of TEST1 sets _m4_divert_dump, which is the diversion +# where the current elaboration will be dumped, to the current +# diversion. It also m4_divert_push to GROW, where the full +# expansion of TEST1 and its dependencies will be elaborated. +# DUMP: BODY +# BODY: empty +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2a +# _m4_require_call m4_divert_pushes another temporary diversion, +# GROW - 1, and expands TEST2a in there. +# DUMP: BODY +# BODY: empty +# GROW - 1: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# Then the content of the temporary diversion is moved to DUMP and the +# temporary diversion is popped. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2b +# Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST2b requires TEST3 +# _m4_require_call pushes GROW - 2 and expands TEST3 here. +# (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so +# nothing happens.) +# DUMP: BODY +# BODY: TEST2a +# GROW - 2: TEST3 +# diversions: GROW - 2, GROW - 1, GROW, BODY |- +# Then the diversion is appended to DUMP, and popped. +# DUMP: BODY +# BODY: TEST2a; TEST3 +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST1 requires TEST2b (contd.) +# The content of TEST2b is expanded... +# DUMP: BODY +# BODY: TEST2a; TEST3 +# GROW - 1: TEST2b, +# diversions: GROW - 1, GROW, BODY |- +# ... and moved to DUMP. +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# diversions: GROW, BODY |- +# +# * TEST1 is expanded: epilogue +# TEST1's own content is in GROW... +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# GROW: TEST1 +# diversions: BODY |- +# ... and it's epilogue moves it to DUMP and then undefines DUMP. +# DUMP: undefined +# BODY: TEST2a; TEST3; TEST2b; TEST1 +# diversions: BODY |- +# +# +# The third idea: track macros provided before they were required +# --------------------------------------------------------------- +# +# Using just the first two ideas, Autoconf 2.50 through 2.63 still had +# a subtle bug for more than seven years. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [1]) +# | m4_defun([TEST2], [2[]m4_require([TEST1])]) +# | m4_defun([TEST3], [3 TEST1 m4_require([TEST2])]) +# | TEST3 +# +# After the prologue of TEST3, we are collecting text in GROW with the +# intent of dumping it in BODY during the epilogue. Next, we +# encounter the direct invocation of TEST1, which provides the macro +# in place in GROW. From there, we encounter a requirement for TEST2, +# which must be collected in a new diversion. While expanding TEST2, +# we encounter a requirement for TEST1, but since it has already been +# expanded, the Axel Thimm algorithm states that we can treat it as a +# no-op. But that would lead to an end result of `2 3 1', meaning +# that we have once again output a macro (TEST2) prior to its +# requirements (TEST1). +# +# The problem can only occur if a single defun'd macro first provides, +# then later indirectly requires, the same macro. Note that directly +# expanding then requiring a macro is okay: because the dependency was +# met, the require phase can be a no-op. For that matter, the outer +# macro can even require two helpers, where the first helper expands +# the macro, and the second helper indirectly requires the macro. +# Out-of-order expansion is only present if the inner macro is +# required by something that will be hoisted in front of where the +# direct expansion occurred. In other words, we must be careful not +# to warn on: +# +# | m4_defun([TEST4], [4]) +# | m4_defun([TEST5], [5 TEST4 m4_require([TEST4])]) +# | TEST5 => 5 4 +# +# or even the more complex: +# +# | m4_defun([TEST6], [6]) +# | m4_defun([TEST7], [7 TEST6]) +# | m4_defun([TEST8], [8 m4_require([TEST6])]) +# | m4_defun([TEST9], [9 m4_require([TEST8])]) +# | m4_defun([TEST10], [10 m4_require([TEST7]) m4_require([TEST9])]) +# | TEST10 => 7 6 8 9 10 +# +# So, to detect whether a require was direct or indirect, m4_defun and +# m4_require track the name of the macro that caused a diversion to be +# created (using the stack _m4_diverting, coupled with an O(1) lookup +# _m4_diverting([NAME])), and m4_provide stores the name associated +# with the diversion at which a macro was provided. A require call is +# direct if it occurs within the same diversion where the macro was +# provided, or if the diversion associated with the providing context +# has been collected. +# +# The implementation of the warning involves tracking the set of +# macros which have been provided since the start of the outermost +# defun'd macro (the set is named _m4_provide). When starting an +# outermost macro, the set is emptied; when a macro is provided, it is +# added to the set; when require expands the body of a macro, it is +# removed from the set; and when a macro is indirectly required, the +# set is checked. If a macro is in the set, then it has been provided +# before it was required, and we satisfy dependencies by expanding the +# macro as if it had never been provided; in the example given above, +# this means we now output `1 2 3 1'. Meanwhile, a warning is issued +# to inform the user that her macros trigger the bug in older autoconf +# versions, and that her output file now contains redundant contents +# (and possibly new problems, if the repeated macro was not +# idempotent). Meanwhile, macros defined by m4_defun_once instead of +# m4_defun are idempotent, avoiding any warning or duplicate output. +# +# +# 2. Keeping track of the expansion stack +# ======================================= +# +# When M4 expansion goes wrong it is often extremely hard to find the +# path amongst macros that drove to the failure. What is needed is +# the stack of macro `calls'. One could imagine that GNU M4 would +# maintain a stack of macro expansions, unfortunately it doesn't, so +# we do it by hand. This is of course extremely costly, but the help +# this stack provides is worth it. Nevertheless to limit the +# performance penalty this is implemented only for m4_defun'd macros, +# not for define'd macros. +# +# Each time we enter an m4_defun'd macros, we add a definition in +# _m4_expansion_stack, and when we exit the macro, we remove it (thanks +# to pushdef/popdef). m4_stack_foreach is used to print the expansion +# stack in the rare cases when it's needed. +# +# In addition, we want to detect circular m4_require dependencies. +# Each time we expand a macro FOO we define _m4_expanding(FOO); and +# m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. + + +# m4_expansion_stack +# ------------------ +# Expands to the entire contents of the expansion stack. The caller +# must supply a trailing newline. This macro always prints a +# location; check whether _m4_expansion_stack is defined to filter out +# the case when no defun'd macro is in force. +m4_define([m4_expansion_stack], +[m4_stack_foreach_sep_lifo([_$0], [_$0_entry(], [) +])m4_location[: the top level]]) + +# _m4_expansion_stack_entry(MACRO) +# -------------------------------- +# Format an entry for MACRO found on the expansion stack. +m4_define([_m4_expansion_stack_entry], +[_m4_defn([m4_location($1)])[: $1 is expanded from...]]) + +# m4_expansion_stack_push(MACRO) +# ------------------------------ +# Form an entry of the expansion stack on entry to MACRO and push it. +m4_define([m4_expansion_stack_push], +[m4_pushdef([_m4_expansion_stack], [$1])]) + + +# _m4_divert(GROW) +# ---------------- +# This diversion is used by the m4_defun/m4_require machinery. It is +# important to keep room before GROW because for each nested +# AC_REQUIRE we use an additional diversion (i.e., two m4_require's +# will use GROW - 2. More than 3 levels has never seemed to be +# needed.) +# +# ... +# - GROW - 2 +# m4_require'd code, 2 level deep +# - GROW - 1 +# m4_require'd code, 1 level deep +# - GROW +# m4_defun'd macros are elaborated here. + +m4_define([_m4_divert(GROW)], 10000) + + +# _m4_defun_pro(MACRO-NAME) +# ------------------------- +# The prologue for Autoconf macros. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_defn overhead. +m4_define([_m4_defun_pro], +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_pro_outer([$1])])]dnl +[m4_expansion_stack_push([$1])m4_pushdef([_m4_expanding($1)])]) + +m4_define([_m4_defun_pro_outer], +[m4_set_delete([_m4_provide])]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_pushdef([_m4_divert_dump], m4_divnum)m4_divert_push([GROW])]) + +# _m4_defun_epi(MACRO-NAME) +# ------------------------- +# The Epilogue for Autoconf macros. MACRO-NAME only helps tracing +# the PRO/EPI pairs. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_popdef overhead. +m4_define([_m4_defun_epi], +[_m4_popdef([_m4_expanding($1)], [_m4_expansion_stack])]dnl +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_epi_outer([$1])])]dnl +[m4_provide([$1])]) + +m4_define([_m4_defun_epi_outer], +[_m4_popdef([_m4_divert_dump], [_m4_diverting([$1])], [_m4_diverting])]dnl +[m4_divert_pop([GROW])m4_undivert([GROW])]) + + +# _m4_divert_dump +# --------------- +# If blank, we are outside of any defun'd macro. Otherwise, expands +# to the diversion number (not name) where require'd macros should be +# moved once completed. +m4_define([_m4_divert_dump]) + + +# m4_divert_require(DIVERSION, NAME-TO-CHECK, [BODY-TO-EXPAND]) +# ------------------------------------------------------------- +# Same as m4_require, but BODY-TO-EXPAND goes into the named DIVERSION; +# requirements still go in the current diversion though. +# +m4_define([m4_divert_require], +[m4_ifdef([_m4_expanding($2)], + [m4_fatal([$0: circular dependency of $2])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($2): cannot be used outside of an m4_defun'd macro])])]dnl +[m4_provide_if([$2], [], + [_m4_require_call([$2], [$3], _m4_divert([$1], [-]))])]) + + +# m4_defun(NAME, EXPANSION, [MACRO = m4_define]) +# ---------------------------------------------- +# Define a macro NAME which automatically provides itself. Add +# machinery so the macro automatically switches expansion to the +# diversion stack if it is not already using it, prior to EXPANSION. +# In this case, once finished, it will bring back all the code +# accumulated in the diversion stack. This, combined with m4_require, +# achieves the topological ordering of macros. We don't use this +# macro to define some frequently called macros that are not involved +# in ordering constraints, to save m4 processing. +# +# MACRO is an undocumented argument; when set to m4_pushdef, and NAME +# is already defined, the new definition is added to the pushdef +# stack, rather than overwriting the current definition. It can thus +# be used to write self-modifying macros, which pop themselves to a +# previously m4_define'd definition so that subsequent use of the +# macro is faster. +m4_define([m4_defun], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_default([$3], [m4_define])([$1], + [_m4_defun_pro(]m4_dquote($[0])[)$2[]_m4_defun_epi(]m4_dquote($[0])[)])]) + + +# m4_defun_init(NAME, INIT, COMMON) +# --------------------------------- +# Like m4_defun, but split EXPANSION into two portions: INIT which is +# done only the first time NAME is invoked, and COMMON which is +# expanded every time. +# +# For now, the COMMON definition is always m4_define'd, giving an even +# lighter-weight definition. m4_defun allows self-providing, but once +# a macro is provided, m4_require no longer cares if it is m4_define'd +# or m4_defun'd. m4_defun also provides location tracking to identify +# dependency bugs, but once the INIT has been expanded, we know there +# are no dependency bugs. However, if a future use needs COMMON to be +# m4_defun'd, we can add a parameter, similar to the third parameter +# to m4_defun. +m4_define([m4_defun_init], +[m4_define([$1], [$3[]])m4_defun([$1], + [$2[]_m4_popdef(]m4_dquote($[0])[)m4_indir(]m4_dquote($[0])dnl +[m4_if(]m4_dquote($[#])[, [0], [], ]m4_dquote([,$]@)[))], [m4_pushdef])]) + + +# m4_defun_once(NAME, EXPANSION) +# ------------------------------ +# Like m4_defun, but guarantee that EXPANSION only happens once +# (thereafter, using NAME is a no-op). +# +# If _m4_divert_dump is empty, we are called at the top level; +# otherwise, we must ensure that we are required in front of the +# current defun'd macro. Use a helper macro so that EXPANSION need +# only occur once in the definition of NAME, since it might be large. +m4_define([m4_defun_once], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_define([$1], [_m4_defun_once([$1], [$2], m4_if(_m4_divert_dump, [], + [[_m4_defun_pro([$1])m4_unquote(], [)_m4_defun_epi([$1])]], +m4_ifdef([_m4_diverting([$1])], [-]), [-], [[m4_unquote(], [)]], + [[_m4_require_call([$1],], [, _m4_divert_dump)]]))])]) + +m4_define([_m4_defun_once], +[m4_pushdef([$1])$3[$2[]m4_provide([$1])]$4]) + + +# m4_pattern_forbid(ERE, [WHY]) +# ----------------------------- +# Declare that no token matching the forbidden extended regular +# expression ERE should be seen in the output unless... +m4_define([m4_pattern_forbid], []) + + +# m4_pattern_allow(ERE) +# --------------------- +# ... that token also matches the allowed extended regular expression ERE. +# Both used via traces. +m4_define([m4_pattern_allow], []) + + +## --------------------------------- ## +## 11. Dependencies between macros. ## +## --------------------------------- ## + + +# m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# --------------------------------------------- +# Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. +m4_define([m4_before], +[m4_provide_if([$2], + [m4_warn([syntax], [$2 was called before $1])])]) + + +# m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) +# ----------------------------------------------------------- +# If NAME-TO-CHECK has never been expanded (actually, if it is not +# m4_provide'd), expand BODY-TO-EXPAND *before* the current macro +# expansion; follow the expansion with a newline. Once expanded, emit +# it in _m4_divert_dump. Keep track of the m4_require chain in +# _m4_expansion_stack. +# +# The normal cases are: +# +# - NAME-TO-CHECK == BODY-TO-EXPAND +# Which you can use for regular macros with or without arguments, e.g., +# m4_require([AC_PROG_CC], [AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(limits.h)], [AC_CHECK_HEADERS(limits.h)]) +# which is just the same as +# m4_require([AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(limits.h)]) +# +# - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) +# In the case of macros with irregular names. For instance: +# m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) +# which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are +# part of the name, it is not an argument) has not been run, then +# call it.' +# Had you used +# m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) +# then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., +# call the macro `AC_LANG_COMPILER' with `C' as argument. +# +# You could argue that `AC_LANG_COMPILER', when it receives an argument +# such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this +# `extension' prevents `AC_LANG_COMPILER' from having actual arguments that +# it passes to `AC_LANG_COMPILER(C)'. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([m4_require], +[m4_ifdef([_m4_expanding($1)], + [m4_fatal([$0: circular dependency of $1])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($1): cannot be used outside of an ]dnl +m4_if([$0], [m4_require], [[m4_defun]], [[AC_DEFUN]])['d macro])])]dnl +[m4_provide_if([$1], [m4_set_contains([_m4_provide], [$1], + [_m4_require_check([$1], _m4_defn([m4_provide($1)]), [$0])], [m4_ignore])], + [_m4_require_call])([$1], [$2], _m4_divert_dump)]) + + +# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# DIVERSION-NUMBER) +# ----------------------------------------------------------------- +# If m4_require decides to expand the body, it calls this macro. The +# expansion is placed in DIVERSION-NUMBER. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([_m4_require_call], +[m4_pushdef([_m4_divert_grow], m4_decr(_m4_divert_grow))]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_divert_push(_m4_divert_grow, [-])]dnl +[m4_if([$2], [], [$1], [$2]) +m4_provide_if([$1], [m4_set_remove([_m4_provide], [$1])], + [m4_warn([syntax], [$1 is m4_require'd but not m4_defun'd])])]dnl +[_m4_divert_raw($3)_m4_undivert(_m4_divert_grow)]dnl +[m4_divert_pop(_m4_divert_grow)_m4_popdef([_m4_divert_grow], +[_m4_diverting([$1])], [_m4_diverting])]) + + +# _m4_require_check(NAME-TO-CHECK, OWNER, CALLER) +# ----------------------------------------------- +# NAME-TO-CHECK has been identified as previously expanded in the +# diversion owned by OWNER. If this is a problem, warn on behalf of +# CALLER and return _m4_require_call; otherwise return m4_ignore. +m4_define([_m4_require_check], +[m4_if(_m4_defn([_m4_diverting]), [$2], [m4_ignore], + m4_ifdef([_m4_diverting([$2])], [-]), [-], [m4_warn([syntax], + [$3: `$1' was expanded before it was required +http://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required])_m4_require_call], + [m4_ignore])]) + + +# _m4_divert_grow +# --------------- +# The counter for _m4_require_call. +m4_define([_m4_divert_grow], _m4_divert([GROW])) + + +# m4_expand_once(TEXT, [WITNESS = TEXT]) +# -------------------------------------- +# If TEXT has never been expanded, expand it *here*. Use WITNESS as +# as a memory that TEXT has already been expanded. +m4_define([m4_expand_once], +[m4_provide_if(m4_default_quoted([$2], [$1]), + [], + [m4_provide(m4_default_quoted([$2], [$1]))[]$1])]) + + +# m4_provide(MACRO-NAME) +# ---------------------- +m4_define([m4_provide], +[m4_ifdef([m4_provide($1)], [], +[m4_set_add([_m4_provide], [$1], [m4_define([m4_provide($1)], + m4_ifdef([_m4_diverting], [_m4_defn([_m4_diverting])]))])])]) + + +# m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ------------------------------------------------------- +# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. +# The purpose of this macro is to provide the user with a means to +# check macros which are provided without letting her know how the +# information is coded. +m4_define([m4_provide_if], +[m4_ifdef([m4_provide($1)], + [$2], [$3])]) + + +## --------------------- ## +## 12. Text processing. ## +## --------------------- ## + + +# m4_cr_letters +# m4_cr_LETTERS +# m4_cr_Letters +# ------------- +m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) +m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) +m4_define([m4_cr_Letters], +m4_defn([m4_cr_letters])dnl +m4_defn([m4_cr_LETTERS])dnl +) + + +# m4_cr_digits +# ------------ +m4_define([m4_cr_digits], [0123456789]) + + +# m4_cr_alnum +# ----------- +m4_define([m4_cr_alnum], +m4_defn([m4_cr_Letters])dnl +m4_defn([m4_cr_digits])dnl +) + + +# m4_cr_symbols1 +# m4_cr_symbols2 +# -------------- +m4_define([m4_cr_symbols1], +m4_defn([m4_cr_Letters])dnl +_) + +m4_define([m4_cr_symbols2], +m4_defn([m4_cr_symbols1])dnl +m4_defn([m4_cr_digits])dnl +) + +# m4_cr_all +# --------- +# The character range representing everything, with `-' as the last +# character, since it is special to m4_translit. Use with care, because +# it contains characters special to M4 (fortunately, both ASCII and EBCDIC +# have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It +# also contains characters special to terminals, so it should never be +# displayed in an error message. Also, attempts to map [ and ] to other +# characters via m4_translit must deal with the fact that m4_translit does +# not add quotes to the output. +# +# In EBCDIC, $ is immediately followed by *, which leads to problems +# if m4_cr_all is inlined into a macro definition; so swap them. +# +# It is mainly useful in generating inverted character range maps, for use +# in places where m4_translit is faster than an equivalent m4_bpatsubst; +# the regex `[^a-z]' is equivalent to: +# m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) +m4_define([m4_cr_all], +m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( + ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [$*-], [*$])-) + + +# _m4_define_cr_not(CATEGORY) +# --------------------------- +# Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. +m4_define([_m4_define_cr_not], +[m4_define([m4_cr_not_$1], + m4_translit(m4_dquote(m4_defn([m4_cr_all])), + m4_defn([m4_cr_$1])))]) + + +# m4_cr_not_letters +# m4_cr_not_LETTERS +# m4_cr_not_Letters +# m4_cr_not_digits +# m4_cr_not_alnum +# m4_cr_not_symbols1 +# m4_cr_not_symbols2 +# ------------------ +# Inverse character sets +_m4_define_cr_not([letters]) +_m4_define_cr_not([LETTERS]) +_m4_define_cr_not([Letters]) +_m4_define_cr_not([digits]) +_m4_define_cr_not([alnum]) +_m4_define_cr_not([symbols1]) +_m4_define_cr_not([symbols2]) + + +# m4_newline([STRING]) +# -------------------- +# Expands to a newline, possibly followed by STRING. Exists mostly for +# formatting reasons. +m4_define([m4_newline], [ +$1]) + + +# m4_re_escape(STRING) +# -------------------- +# Escape RE active characters in STRING. +m4_define([m4_re_escape], +[m4_bpatsubst([$1], + [[][*+.?\^$]], [\\\&])]) + + +# m4_re_string +# ------------ +# Regexp for `[a-zA-Z_0-9]*' +# m4_dquote provides literal [] for the character class. +m4_define([m4_re_string], +m4_dquote(m4_defn([m4_cr_symbols2]))dnl +[*]dnl +) + + +# m4_re_word +# ---------- +# Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' +m4_define([m4_re_word], +m4_dquote(m4_defn([m4_cr_symbols1]))dnl +m4_defn([m4_re_string])dnl +) + + +# m4_tolower(STRING) +# m4_toupper(STRING) +# ------------------ +# These macros convert STRING to lowercase or uppercase. +# +# Rather than expand the m4_defn each time, we inline them up front. +m4_define([m4_tolower], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, + ]m4_dquote(m4_defn([m4_cr_letters]))[)]) +m4_define([m4_toupper], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_letters]))[, + ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) + + +# m4_split(STRING, [REGEXP]) +# -------------------------- +# Split STRING into an m4 list of quoted elements. The elements are +# quoted with [ and ]. Beginning spaces and end spaces *are kept*. +# Use m4_strip to remove them. +# +# REGEXP specifies where to split. Default is [\t ]+. +# +# If STRING is empty, the result is an empty list. +# +# Pay attention to the m4_changequotes. When m4 reads the definition of +# m4_split, it still has quotes set to [ and ]. Luckily, these are matched +# in the macro body, so the definition is stored correctly. Use the same +# alternate quotes as m4_noquote; it must be unlikely to appear in $1. +# +# Also, notice that $1 is quoted twice, since we want the result to +# be quoted. Then you should understand that the argument of +# patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). +# +# This macro is safe on active symbols, i.e.: +# m4_define(active, ACTIVE) +# m4_split([active active ])end +# => [active], [active], []end +# +# Optimize on regex of ` ' (space), since m4_foreach_w already guarantees +# that the list contains single space separators, and a common case is +# splitting a single-element list. This macro is called frequently, +# so avoid unnecessary dnl inside the definition. +m4_define([m4_split], +[m4_if([$1], [], [], + [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], + [_$0([$1], [$2], [, ])])], + [$2], [], [_$0([$1], [[ ]+], [, ])], + [_$0([$1], [$2], [, ])])]) + +m4_define([_m4_split], +[m4_changequote([-=<{(],[)}>=-])]dnl +[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, + -=<{(]$3[)}>=-)]m4_changequote([, ])]) + + +# m4_chomp(STRING) +# m4_chomp_all(STRING) +# -------------------- +# Return STRING quoted, but without a trailing newline. m4_chomp +# removes at most one newline, while m4_chomp_all removes all +# consecutive trailing newlines. Embedded newlines are not touched, +# and a trailing backslash-newline leaves just a trailing backslash. +# +# m4_bregexp is slower than m4_index, and we don't always want to +# remove all newlines; hence the two variants. We massage characters +# to give a nicer pattern to match, particularly since m4_bregexp is +# line-oriented. Both versions must guarantee a match, to avoid bugs +# with precision -1 in m4_format in older m4. +m4_define([m4_chomp], +[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [ +/.], [/ ])[./.], [/.]), [$1])]) + +m4_define([m4_chomp_all], +[m4_format([[%.*s]], m4_bregexp(m4_translit([[$1]], [ +/], [/ ]), [/*$]), [$1])]) + + +# m4_flatten(STRING) +# ------------------ +# If STRING contains end of lines, replace them with spaces. If there +# are backslashed end of lines, remove them. This macro is safe with +# active symbols. +# m4_define(active, ACTIVE) +# m4_flatten([active +# act\ +# ive])end +# => active activeend +# +# In m4, m4_bpatsubst is expensive, so first check for a newline. +m4_define([m4_flatten], +[m4_if(m4_index([$1], [ +]), [-1], [[$1]], + [m4_translit(m4_bpatsubst([[[$1]]], [\\ +]), [ +], [ ])])]) + + +# m4_strip(STRING) +# ---------------- +# Expands into STRING with tabs and spaces singled out into a single +# space, and removing leading and trailing spaces. +# +# This macro is robust to active symbols. +# m4_define(active, ACTIVE) +# m4_strip([ active <tab> <tab>active ])end +# => active activeend +# +# First, notice that we guarantee trailing space. Why? Because regular +# expressions are greedy, and `.* ?' would always group the space into the +# .* portion. The algorithm is simpler by avoiding `?' at the end. The +# algorithm correctly strips everything if STRING is just ` '. +# +# Then notice the second pattern: it is in charge of removing the +# leading/trailing spaces. Why not just `[^ ]'? Because they are +# applied to over-quoted strings, i.e. more or less [STRING], due +# to the limitations of m4_bpatsubsts. So the leading space in STRING +# is the *second* character; equally for the trailing space. +m4_define([m4_strip], +[m4_bpatsubsts([$1 ], + [[ ]+], [ ], + [^. ?\(.*\) .$], [[[\1]]])]) + + +# m4_normalize(STRING) +# -------------------- +# Apply m4_flatten and m4_strip to STRING. +# +# The argument is quoted, so that the macro is robust to active symbols: +# +# m4_define(active, ACTIVE) +# m4_normalize([ act\ +# ive +# active ])end +# => active activeend + +m4_define([m4_normalize], +[m4_strip(m4_flatten([$1]))]) + + + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Since the number of arguments to join can be arbitrarily long, we +# want to avoid having more than one $@ in the macro definition; +# otherwise, the expansion would require twice the memory of the already +# long list. Hence, m4_join merely looks for the first non-empty element, +# and outputs just that element; while _m4_join looks for all non-empty +# elements, and outputs them following a separator. The final trick to +# note is that we decide between recursing with $0 or _$0 based on the +# nested m4_if ending with `_'. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) +m4_define([_m4_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) +m4_define([_m4_joinall], +[m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) + +# m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) +# -------------------------------------------------------- +# Produce the pairwise combination of every element in the quoted, +# comma-separated PREFIX-LIST with every element from the SUFFIX arguments. +# Each pair is joined with INFIX, and pairs are separated by SEPARATOR. +# No expansion occurs on SEPARATOR, INFIX, or elements of either list. +# +# For example: +# m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) +# => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 +# +# This definition is a bit hairy; the thing to realize is that we want +# to construct m4_map_args_sep([[prefix$3]], [], [[$1]], m4_shift3($@)) +# as the inner loop, using each prefix generated by the outer loop, +# and without recalculating m4_shift3 every outer iteration. +m4_define([m4_combine], +[m4_if([$2], [], [], m4_eval([$# > 3]), [1], +[m4_map_args_sep([m4_map_args_sep(m4_dquote(], [)[[$3]], [], [[$1]],]]]dnl +[m4_dquote(m4_dquote(m4_shift3($@)))[[)], [[$1]], $2)])]) + + +# m4_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' +# at the end. It is valid to use this macro with MACRO-NAME undefined, +# in which case no SEPARATOR is added. Be aware that the criterion is +# `not being defined', and not `not being empty'. +# +# Note that neither STRING nor SEPARATOR are expanded here; rather, when +# you expand MACRO-NAME, they will be expanded at that point in time. +# +# This macro is robust to active symbols. It can be used to grow +# strings. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([sentence], [This is an])dnl +# | m4_append([sentence], [ active ])dnl +# | m4_append([sentence], [symbol.])dnl +# | sentence +# | m4_undefine([active])dnl +# | sentence +# => This is an ACTIVE symbol. +# => This is an active symbol. +# +# It can be used to define hooks. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([hooks], [m4_define([act1], [act2])])dnl +# | m4_append([hooks], [m4_define([act2], [active])])dnl +# | m4_undefine([active])dnl +# | act1 +# | hooks +# | act1 +# => act1 +# => +# => active +# +# It can also be used to create lists, although this particular usage was +# broken prior to autoconf 2.62. +# | m4_append([list], [one], [, ])dnl +# | m4_append([list], [two], [, ])dnl +# | m4_append([list], [three], [, ])dnl +# | list +# | m4_dquote(list) +# => one, two, three +# => [one],[two],[three] +# +# Note that m4_append can benefit from amortized O(n) m4 behavior, if +# the underlying m4 implementation is smart enough to avoid copying existing +# contents when enlarging a macro's definition into any pre-allocated storage +# (m4 1.4.x unfortunately does not implement this optimization). We do +# not implement m4_prepend, since it is inherently O(n^2) (pre-allocated +# storage only occurs at the end of a macro, so the existing contents must +# always be moved). +# +# Use _m4_defn for speed. +m4_define([m4_append], +[m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) + + +# m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) +# -------------------------------------------------------------------- +# Like `m4_append', but append only if not yet present. Additionally, +# expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already +# present. Also, warn if SEPARATOR is not empty and occurs within STRING, +# as the algorithm no longer guarantees uniqueness. +# +# Note that while m4_append can be O(n) (depending on the quality of the +# underlying M4 implementation), m4_append_uniq is inherently O(n^2) +# because each append operation searches the entire string. +m4_define([m4_append_uniq], +[m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], + [m4_warn([syntax], + [$0: `$2' contains `$3'])])])_$0($@)]) +m4_define([_m4_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], + [m4_append([$1], [$2], [$3])$4], [$5])], + [m4_define([$1], [$2])$4])]) + +# m4_append_uniq_w(MACRO-NAME, STRINGS) +# ------------------------------------- +# For each of the words in the whitespace separated list STRINGS, append +# only the unique strings to the definition of MACRO-NAME. +# +# Use _m4_defn for speed. +m4_define([m4_append_uniq_w], +[m4_map_args_w([$2], [_m4_append_uniq([$1],], [, [ ])])]) + + +# m4_escape(STRING) +# ----------------- +# Output quoted STRING, but with embedded #, $, [ and ] turned into +# quadrigraphs. +# +# It is faster to check if STRING is already good using m4_translit +# than to blindly perform four m4_bpatsubst. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# and parentheses. All the problem characters are unified so that a +# single m4_index can scan the result. +# +# Rather than expand m4_defn every time m4_escape is expanded, we +# inline its expansion up front. +m4_define([m4_escape], +[m4_if(m4_index(m4_translit([$1], + [[]#,()]]m4_dquote(m4_defn([m4_cr_symbols2]))[, [$$$]), [$]), + [-1], [m4_echo], [_$0])([$1])]) + +m4_define([_m4_escape], +[m4_changequote([-=<{(],[)}>=-])]dnl +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst( + -=<{(-=<{(-=<{(-=<{(-=<{($1)}>=-)}>=-)}>=-)}>=-)}>=-, + -=<{(#)}>=-, -=<{(@%:@)}>=-), + -=<{(\[)}>=-, -=<{(@<:@)}>=-), + -=<{(\])}>=-, -=<{(@:>@)}>=-), + -=<{(\$)}>=-, -=<{(@S|@)}>=-)m4_changequote([,])]) + + +# m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) +# ------------------------------------------------------- +# Expands into STRING wrapped to hold in WIDTH columns (default = 79). +# If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is +# specified, then the first line is prefixed with it. As a special case, +# if the length of FIRST-PREFIX is greater than that of PREFIX, then +# FIRST-PREFIX will be left alone on the first line. +# +# No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, +# although quadrigraphs are correctly recognized. More precisely, +# you may redefine m4_qlen to recognize whatever escape sequences that +# you will post-process. +# +# Typical outputs are: +# +# m4_text_wrap([Short string */], [ ], [/* ], 20) +# => /* Short string */ +# +# m4_text_wrap([Much longer string */], [ ], [/* ], 20) +# => /* Much longer +# => string */ +# +# m4_text_wrap([Short doc.], [ ], [ --short ], 30) +# => --short Short doc. +# +# m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Short doc. +# +# m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Super long +# => documentation. +# +# FIXME: there is no checking of a longer PREFIX than WIDTH, but do +# we really want to bother with people trying each single corner +# of a software? +# +# This macro does not leave a trailing space behind the last word of a line, +# which complicates it a bit. The algorithm is otherwise stupid and simple: +# all the words are preceded by m4_Separator which is defined to empty for +# the first word, and then ` ' (single space) for all the others. +# +# The algorithm uses a helper that uses $2 through $4 directly, rather than +# using local variables, to avoid m4_defn overhead, or expansion swallowing +# any $. It also bypasses m4_popdef overhead with _m4_popdef since no user +# macro expansion occurs in the meantime. Also, the definition is written +# with m4_do, to avoid time wasted on dnl during expansion (since this is +# already a time-consuming macro). +m4_define([m4_text_wrap], +[_$0(m4_escape([$1]), [$2], m4_default_quoted([$3], [$2]), + m4_default_quoted([$4], [79]))]) + +m4_define([_m4_text_wrap], +m4_do(dnl set up local variables, to avoid repeated calculations +[[m4_pushdef([m4_Indent], m4_qlen([$2]))]], +[[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], +[[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], +dnl expand the first prefix, then check its length vs. regular prefix +dnl same length: nothing special +dnl prefix1 longer: output on line by itself, and reset cursor +dnl prefix1 shorter: pad to length of prefix, and reset cursor +[[[$3]m4_cond([m4_Cursor], m4_Indent, [], + [m4_eval(m4_Cursor > m4_Indent)], [1], [ +[$2]m4_define([m4_Cursor], m4_Indent)], + [m4_format([%*s], m4_max([0], + m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], +dnl now, for each word, compute the cursor after the word is output, then +dnl check if the cursor would exceed the wrap column +dnl if so, reset cursor, and insert newline and prefix +dnl if not, insert the separator (usually a space) +dnl either way, insert the word +[[m4_map_args_w([$1], [$0_word(], [, [$2], [$4])])]], +dnl finally, clean up the local variables +[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) + +m4_define([_m4_text_wrap_word], +[m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_qlen([$1]) + 1))]dnl +[m4_if(m4_eval(m4_Cursor > ([$3])), + [1], [m4_define([m4_Cursor], m4_eval(m4_Indent + m4_qlen([$1]) + 1)) +[$2]], + [m4_Separator[]])[$1]]) + +# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) +# --------------------------------------------- +# Turn MESSAGE into: +# ## ------- ## +# ## MESSAGE ## +# ## ------- ## +# using FRAME-CHARACTER in the border. +# +# Quadrigraphs are correctly recognized. More precisely, you may +# redefine m4_qlen to recognize whatever escape sequences that you +# will post-process. +m4_define([m4_text_box], +[m4_pushdef([m4_Border], + m4_translit(m4_format([[[%*s]]], m4_decr(m4_qlen(_m4_expand([$1 +]))), []), [ ], m4_default_quoted([$2], [-])))]dnl +[[##] _m4_defn([m4_Border]) [##] +[##] $1 [##] +[##] _m4_defn([m4_Border]) [##]_m4_popdef([m4_Border])]) + + +# m4_qlen(STRING) +# --------------- +# Expands to the length of STRING after autom4te converts all quadrigraphs. +# +# If you use some other means of post-processing m4 output rather than +# autom4te, then you may redefine this macro to recognize whatever +# escape sequences your post-processor will handle. For that matter, +# m4_define([m4_qlen], m4_defn([m4_len])) is sufficient if you don't +# do any post-processing. +# +# Avoid bpatsubsts for the common case of no quadrigraphs. Cache +# results, as configure scripts tend to ask about lengths of common +# strings like `/*' and `*/' rather frequently. Minimize the number +# of times that $1 occurs in m4_qlen, so there is less text to parse +# on a cache hit. +m4_define([m4_qlen], +[m4_ifdef([$0-$1], [_m4_defn([$0-]], [_$0(])[$1])]) +m4_define([_m4_qlen], +[m4_define([m4_qlen-$1], +m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], + [m4_len(m4_bpatsubst([[$1]], + [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], + [\3]))]))_m4_defn([m4_qlen-$1])]) + +# m4_copyright_condense(TEXT) +# --------------------------- +# Condense the copyright notice in TEXT to only display the final +# year, wrapping the results to fit in 80 columns. +m4_define([m4_copyright_condense], +[m4_text_wrap(m4_bpatsubst(m4_flatten([[$1]]), +[(C)[- ,0-9]*\([1-9][0-9][0-9][0-9]\)], [(C) \1]))]) + +## ----------------------- ## +## 13. Number processing. ## +## ----------------------- ## + +# m4_cmp(A, B) +# ------------ +# Compare two integer expressions. +# A < B -> -1 +# A = B -> 0 +# A > B -> 1 +m4_define([m4_cmp], +[m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) + + +# m4_list_cmp(A, B) +# ----------------- +# +# Compare the two lists of integer expressions A and B. For instance: +# m4_list_cmp([1, 0], [1]) -> 0 +# m4_list_cmp([1, 0], [1, 0]) -> 0 +# m4_list_cmp([1, 2], [1, 0]) -> 1 +# m4_list_cmp([1, 2, 3], [1, 2]) -> 1 +# m4_list_cmp([1, 2, -3], [1, 2]) -> -1 +# m4_list_cmp([1, 0], [1, 2]) -> -1 +# m4_list_cmp([1], [1, 2]) -> -1 +# m4_define([xa], [oops])dnl +# m4_list_cmp([[0xa]], [5+5]) -> 0 +# +# Rather than face the overhead of m4_case, we use a helper function whose +# expansion includes the name of the macro to invoke on the tail, either +# m4_ignore or m4_unquote. This is particularly useful when comparing +# long lists, since less text is being expanded for deciding when to end +# recursion. The recursion is between a pair of macros that alternate +# which list is trimmed by one element; this is more efficient than +# calling m4_cdr on both lists from a single macro. Guarantee exactly +# one expansion of both lists' side effects. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_list_cmp], +[_$0_raw(m4_dquote($1), m4_dquote($2))]) + +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) + +m4_define([_m4_list_cmp], +[m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) + +m4_define([_m4_list_cmp_1], +[_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) + +m4_define([_m4_list_cmp_2], +[_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( + [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval +# if both arguments are identical, but be aware of m4_max(0xa, 10) (hence +# the use of <=, not just <, in the second multiply). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_max], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_max], +[m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) + +m4_define([m4_min], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_min], +[m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) + +# _m4_minmax(METHOD, ARG1, ARG2...) +# --------------------------------- +# Common recursion code for m4_max and m4_min. METHOD must be _m4_max +# or _m4_min, and there must be at least two arguments to combine. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_minmax], +[m4_if([$#], [3], [$1([$2], [$3])], + [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) + + +# m4_sign(A) +# ---------- +# The sign of the integer expression A. +m4_define([m4_sign], +[m4_eval((([$1]) > 0) - (([$1]) < 0))]) + + + +## ------------------------ ## +## 14. Version processing. ## +## ------------------------ ## + + +# m4_version_unletter(VERSION) +# ---------------------------- +# Normalize beta version numbers with letters to numeric expressions, which +# can then be handed to m4_eval for the purpose of comparison. +# +# Nl -> (N+1).-1.(l#) +# +# for example: +# [2.14a] -> [0,2,14+1,-1,[0r36:a]] -> 2.15.-1.10 +# [2.14b] -> [0,2,15+1,-1,[0r36:b]] -> 2.15.-1.11 +# [2.61aa.b] -> [0,2.61,1,-1,[0r36:aa],+1,-1,[0r36:b]] -> 2.62.-1.370.1.-1.11 +# [08] -> [0,[0r10:0]8] -> 8 +# +# This macro expects reasonable version numbers, but can handle double +# letters and does not expand any macros. Original version strings can +# use both `.' and `-' separators. +# +# Inline constant expansions, to avoid m4_defn overhead. +# _m4_version_unletter is the real workhorse used by m4_version_compare, +# but since [0r36:a] and commas are less readable than 10 and dots, we +# provide a wrapper for human use. +m4_define([m4_version_unletter], +[m4_substr(m4_map_args([.m4_eval], m4_unquote(_$0([$1]))), [3])]) +m4_define([_m4_version_unletter], +[m4_bpatsubst(m4_bpatsubst(m4_translit([[[[0,$1]]]], [.-], [,,]),]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], + [+1,-1,[0r36:\&]]), [,0], [,[0r10:0]])]) + + +# m4_version_compare(VERSION-1, VERSION-2) +# ---------------------------------------- +# Compare the two version numbers and expand into +# -1 if VERSION-1 < VERSION-2 +# 0 if = +# 1 if > +# +# Since _m4_version_unletter does not output side effects, we can +# safely bypass the overhead of m4_version_cmp. +m4_define([m4_version_compare], +[_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) + + +# m4_PACKAGE_NAME +# m4_PACKAGE_TARNAME +# m4_PACKAGE_VERSION +# m4_PACKAGE_STRING +# m4_PACKAGE_BUGREPORT +# -------------------- +# If m4sugar/version.m4 is present, then define version strings. This +# file is optional, provided by Autoconf but absent in Bison. +m4_sinclude([m4sugar/version.m4]) + + +# m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) +# ---------------------------------------------------- +# Check this Autoconf version against VERSION. +m4_define([m4_version_prereq], +m4_ifdef([m4_PACKAGE_VERSION], +[[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), + [-1], + [m4_default([$3], + [m4_fatal([Autoconf version $1 or higher is required], + [63])])], + [$2])]], +[[m4_fatal([m4sugar/version.m4 not found])]])) + + +## ------------------ ## +## 15. Set handling. ## +## ------------------ ## + +# Autoconf likes to create arbitrarily large sets; for example, as of +# this writing, the configure.ac for coreutils tracks a set of more +# than 400 AC_SUBST. How do we track all of these set members, +# without introducing duplicates? We could use m4_append_uniq, with +# the set NAME residing in the contents of the macro NAME. +# Unfortunately, m4_append_uniq is quadratic for set creation, because +# it costs O(n) to search the string for each of O(n) insertions; not +# to mention that with m4 1.4.x, even using m4_append is slow, costing +# O(n) rather than O(1) per insertion. Other set operations, not used +# by Autoconf but still possible by manipulation of the definition +# tracked in macro NAME, include O(n) deletion of one element and O(n) +# computation of set size. Because the set is exposed to the user via +# the definition of a single macro, we cannot cache any data about the +# set without risking the cache being invalidated by the user +# redefining NAME. +# +# Can we do better? Yes, because m4 gives us an O(1) search function +# for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) +# insert operation for free: pushdef. But to use these, we must +# represent the set via a group of macros; to keep the set consistent, +# we must hide the set so that the user can only manipulate it through +# accessor macros. The contents of the set are maintained through two +# access points; _m4_set([name]) is a pushdef stack of values in the +# set, useful for O(n) traversal of the set contents; while the +# existence of _m4_set([name],value) with no particular value is +# useful for O(1) querying of set membership. And since the user +# cannot externally manipulate the set, we are free to add additional +# caching macros for other performance improvements. Deletion can be +# O(1) per element rather than O(n), by reworking the definition of +# _m4_set([name],value) to be 0 or 1 based on current membership, and +# adding _m4_set_cleanup(name) to defer the O(n) cleanup of +# _m4_set([name]) until we have another reason to do an O(n) +# traversal. The existence of _m4_set_cleanup(name) can then be used +# elsewhere to determine if we must dereference _m4_set([name],value), +# or assume that definition implies set membership. Finally, size can +# be tracked in an O(1) fashion with _m4_set_size(name). +# +# The quoting in _m4_set([name],value) is chosen so that there is no +# ambiguity with a set whose name contains a comma, and so that we can +# supply the value via _m4_defn([_m4_set([name])]) without needing any +# quote manipulation. + +# m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) +# ------------------------------------------- +# Add VALUE as an element of SET. Expand IF-UNIQ on the first +# addition, and IF-DUP if it is already in the set. Addition of one +# element is O(1), such that overall set creation is O(n). +# +# We do not want to add a duplicate for a previously deleted but +# unpruned element, but it is just as easy to check existence directly +# as it is to query _m4_set_cleanup($1). +m4_define([m4_set_add], +[m4_ifdef([_m4_set([$1],$2)], + [m4_if(m4_indir([_m4_set([$1],$2)]), [0], + [m4_define([_m4_set([$1],$2)], + [1])_m4_set_size([$1], [m4_incr])$3], [$4])], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], + [$2])_m4_set_size([$1], [m4_incr])$3])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# Implement two recursion helpers; the check variant is slower but +# handles the case where an element has previously been removed but +# not pruned. The recursion helpers ignore their second argument, so +# that we can use the faster m4_shift2 and 2 arguments, rather than +# _m4_shift2 and one argument, as the signal to end recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_set_add_all], +[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) + +m4_define([_m4_set_add_all], +[m4_if([$#], [2], [], + [m4_ifdef([_m4_set([$1],$3)], [], + [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], + [$3])-])$0([$1], m4_shift2($@))])]) + +m4_define([_m4_set_add_all_check], +[m4_if([$#], [2], [], + [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) + +# m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ------------------------------------------------------ +# Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. +# This is always O(1). +m4_define([m4_set_contains], +[m4_ifdef([_m4_set_cleanup($1)], + [m4_if(m4_ifdef([_m4_set([$1],$2)], + [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], + [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) + +# m4_set_contents(SET, [SEP]) +# --------------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, without modifying SET. No provision is made for +# disambiguating set elements that contain non-empty SEP as a +# sub-string, or for recognizing a set that contains only the empty +# string. Order of the output is not guaranteed. If any elements +# have been previously removed from the set, this action will prune +# the unused memory. This is O(n) in the size of the set before +# pruning. +# +# Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) +# determines which version of _1 helper we use. +m4_define([m4_set_contents], +[m4_set_map_sep([$1], [], [], [[$2]])]) + +# _m4_set_contents_1(SET) +# _m4_set_contents_1c(SET) +# _m4_set_contents_2(SET, [PRE], [POST], [SEP]) +# --------------------------------------------- +# Expand to a list of quoted elements currently in the set, each +# surrounded by PRE and POST, and moving SEP in front of PRE on +# recursion. To avoid nesting limit restrictions, the algorithm must +# be broken into two parts; _1 destructively copies the stack in +# reverse into _m4_set_($1), producing no output; then _2 +# destructively copies _m4_set_($1) back into the stack in reverse. +# If no elements were deleted, then this visits the set in the order +# that elements were inserted. Behavior is undefined if PRE/POST/SEP +# tries to recursively list or modify SET in any way other than +# calling m4_set_remove on the current element. Use _1 if all entries +# in the stack are guaranteed to be in the set, and _1c to prune +# removed entries. Uses _m4_defn and _m4_popdef for speed. +m4_define([_m4_set_contents_1], +[_m4_stack_reverse([_m4_set([$1])], [_m4_set_($1)])]) + +m4_define([_m4_set_contents_1c], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], + [_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +m4_define([_m4_set_contents_2], +[_m4_stack_reverse([_m4_set_($1)], [_m4_set([$1])], + [$2[]_m4_defn([_m4_set_($1)])$3], [$4[]])]) + +# m4_set_delete(SET) +# ------------------ +# Delete all elements in SET, and reclaim any memory occupied by the +# set. This is O(n) in the set size. +# +# Use _m4_defn and _m4_popdef for speed. +m4_define([m4_set_delete], +[m4_ifdef([_m4_set([$1])], + [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1])], + [m4_ifdef([_m4_set_cleanup($1)], + [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( + [_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])])]) + +# m4_set_difference(SET1, SET2) +# ----------------------------- +# Produce a LIST of quoted elements that occur in SET1 but not SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Short-circuit the idempotence relation. +m4_define([m4_set_difference], +[m4_if([$1], [$2], [], [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_difference], +[m4_set_contains([$1], [$2], [], [,[$2]])]) + +# m4_set_dump(SET, [SEP]) +# ----------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, then delete SET. In general, if you only need to +# list the contents once, this is faster than m4_set_contents. No +# provision is made for disambiguating set elements that contain +# non-empty SEP as a sub-string. Order of the output is not +# guaranteed. This is O(n) in the size of the set before pruning. +# +# Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to +# decide if more expensive recursion is needed. +m4_define([m4_set_dump], +[m4_ifdef([_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], + [_$0_check], [_$0])([$1], [], [$2])]) + +# _m4_set_dump(SET, [SEP], [PREP]) +# _m4_set_dump_check(SET, [SEP], [PREP]) +# -------------------------------------- +# Print SEP and the current element, then delete the element and +# recurse with empty SEP changed to PREP. The check variant checks +# whether the element has been previously removed. Use _m4_defn and +# _m4_popdef for speed. +m4_define([_m4_set_dump], +[m4_ifdef([_m4_set([$1])], + [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) + +m4_define([_m4_set_dump_check], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( + [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1], [$2$3])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +# m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) +# -------------------------------------------- +# Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. +m4_define([m4_set_empty], +[m4_ifdef([_m4_set_size($1)], + [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) + +# m4_set_foreach(SET, VAR, ACTION) +# -------------------------------- +# For each element of SET, define VAR to the element and expand +# ACTION. ACTION should not recursively list SET's contents, add +# elements to SET, nor delete any element from SET except the one +# currently in VAR. The order that the elements are visited in is not +# guaranteed. This is faster than the corresponding m4_foreach([VAR], +# m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) +m4_define([m4_set_foreach], +[m4_pushdef([$2])m4_set_map_sep([$1], [m4_define([$2],], [)$3])]) + +# m4_set_intersection(SET1, SET2) +# ------------------------------- +# Produce a LIST of quoted elements that occur in both SET1 or SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Iterate over the smaller set, and short-circuit the idempotence +# relation. +m4_define([m4_set_intersection], +[m4_if([$1], [$2], [m4_set_listc([$1])], + m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], + [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_intersection], +[m4_set_contains([$1], [$2], [,[$2]])]) + +# m4_set_list(SET) +# m4_set_listc(SET) +# ----------------- +# Produce a LIST of quoted elements of SET. This can be directly used +# as a series of arguments, such as for m4_join or m4_set_add_all, or +# wrapped inside quotes for use in m4_foreach or m4_map. With +# m4_set_list, there is no way to distinguish an empty set from a set +# containing only the empty string; with m4_set_listc, a leading comma +# is output if there are any elements. +m4_define([m4_set_list], +[m4_set_map_sep([$1], [], [], [,])]) + +m4_define([m4_set_listc], +[m4_set_map_sep([$1], [,])]) + +# m4_set_map(SET, ACTION) +# ----------------------- +# For each element of SET, expand ACTION with a single argument of the +# current element. ACTION should not recursively list SET's contents, +# add elements to SET, nor delete any element from SET except the one +# passed as an argument. The order that the elements are visited in +# is not guaranteed. This is faster than either of the corresponding +# m4_map_args([ACTION]m4_set_listc([SET])) +# m4_set_foreach([SET], [VAR], [ACTION(m4_defn([VAR]))]) +m4_define([m4_set_map], +[m4_set_map_sep([$1], [$2(], [)])]) + +# m4_set_map_sep(SET, [PRE], [POST], [SEP]) +# ----------------------------------------- +# For each element of SET, expand PRE[value]POST[], and expand SEP +# between elements. +m4_define([m4_set_map_sep], +[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], + [_m4_set_contents_1])([$1])_m4_set_contents_2($@)]) + +# m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ---------------------------------------------------- +# If VALUE is an element of SET, delete it and expand IF-PRESENT. +# Otherwise expand IF-ABSENT. Deleting a single value is O(1), +# although it leaves memory occupied until the next O(n) traversal of +# the set which will compact the set. +# +# Optimize if the element being removed is the most recently added, +# since defining _m4_set_cleanup($1) slows down so many other macros. +# In particular, this plays well with m4_set_foreach and m4_set_map. +m4_define([m4_set_remove], +[m4_set_contains([$1], [$2], [_m4_set_size([$1], + [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], + [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], + [m4_define([_m4_set_cleanup($1)])m4_define( + [_m4_set([$1],$2)], [0])])$3], [$4])]) + +# m4_set_size(SET) +# ---------------- +# Expand to the number of elements currently in SET. This operation +# is O(1), and thus more efficient than m4_count(m4_set_list([SET])). +m4_define([m4_set_size], +[m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) + +# _m4_set_size(SET, ACTION) +# ------------------------- +# ACTION must be either m4_incr or m4_decr, and the size of SET is +# changed accordingly. If the set is empty, ACTION must not be +# m4_decr. +m4_define([_m4_set_size], +[m4_define([_m4_set_size($1)], + m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], + [1]))]) + +# m4_set_union(SET1, SET2) +# ------------------------ +# Produce a LIST of double quoted elements that occur in either SET1 +# or SET2, without duplicates. Output a comma prior to any elements, +# to distinguish the empty string from no elements. This can be +# directly used as a series of arguments, such as for m4_join, or +# wrapped inside quotes for use in m4_foreach. Order of the output is +# not guaranteed. +# +# We can rely on the fact that m4_set_listc prunes SET1, so we don't +# need to check _m4_set([$1],element) for 0. Short-circuit the +# idempotence relation. +m4_define([m4_set_union], +[m4_set_listc([$1])m4_if([$1], [$2], [], + [m4_set_map_sep([$2], [_$0([$1],], [)])])]) + +m4_define([_m4_set_union], +[m4_ifdef([_m4_set([$1],$2)], [], [,[$2]])]) + + +## ------------------- ## +## 16. File handling. ## +## ------------------- ## + + +# It is a real pity that M4 comes with no macros to bind a diversion +# to a file. So we have to deal without, which makes us a lot more +# fragile than we should. + + +# m4_file_append(FILE-NAME, CONTENT) +# ---------------------------------- +m4_define([m4_file_append], +[m4_syscmd([cat >>$1 <<_m4eof +$2 +_m4eof +]) +m4_if(m4_sysval, [0], [], + [m4_fatal([$0: cannot write: $1])])]) + + + +## ------------------------ ## +## 17. Setting M4sugar up. ## +## ------------------------ ## + +# _m4_divert_diversion should be defined. +m4_divert_push([KILL]) + +# m4_init +# ------- +# Initialize the m4sugar language. +m4_define([m4_init], +[# All the M4sugar macros start with `m4_', except `dnl' kept as is +# for sake of simplicity. +m4_pattern_forbid([^_?m4_]) +m4_pattern_forbid([^dnl$]) + +# If __m4_version__ is defined, we assume that we are being run by M4 +# 1.6 or newer, thus $@ recursion is linear, and debugmode(+do) +# is available for faster checks of dereferencing undefined macros +# and forcing dumpdef to print to stderr regardless of debugfile. +# But if it is missing, we assume we are being run by M4 1.4.x, that +# $@ recursion is quadratic, and that we need foreach-based +# replacement macros. Also, m4 prior to 1.4.8 loses track of location +# during m4wrap text; __line__ should never be 0. +# +# Use the raw builtin to avoid tripping up include tracing. +# Meanwhile, avoid m4_copy, since it temporarily undefines m4_defn. +m4_ifdef([__m4_version__], +[m4_debugmode([+do]) +m4_define([m4_defn], _m4_defn([_m4_defn])) +m4_define([m4_dumpdef], _m4_defn([_m4_dumpdef])) +m4_define([m4_popdef], _m4_defn([_m4_popdef])) +m4_define([m4_undefine], _m4_defn([_m4_undefine]))], +[m4_builtin([include], [m4sugar/foreach.m4]) +m4_wrap_lifo([m4_if(__line__, [0], [m4_pushdef([m4_location], +]]m4_dquote(m4_dquote(m4_dquote(__file__:__line__)))[[)])])]) + +# Rewrite the first entry of the diversion stack. +m4_divert([KILL]) + +# Check the divert push/pop perfect balance. +# Some users are prone to also use m4_wrap to register last-minute +# m4_divert_text; so after our diversion cleanups, we restore +# KILL as the bottom of the diversion stack. +m4_wrap([m4_popdef([_m4_divert_diversion])m4_ifdef( + [_m4_divert_diversion], [m4_fatal([$0: unbalanced m4_divert_push: +]m4_divert_stack)])_m4_popdef([_m4_divert_stack])m4_divert_push([KILL])]) +]) |