File Coverage

blib/lib/Config/AutoConf.pm

Criterion	Covered	Total	%
statement	859	1144	75.0
branch	327	716	45.6
condition	201	576	34.9
subroutine	142	206	68.9
pod	75	75	100.0
total	1604	2717	59.0

package Config::AutoConf;

use warnings;
use strict;

use base 'Exporter';

our @EXPORT = ('$LIBEXT', '$EXEEXT');

use constant QUOTE => do { $^O eq "MSWin32" ? q["] : q['] };

use Config;
use Carp qw/croak/;

use File::Temp qw/tempfile/;
use File::Basename;
use File::Spec;
use Text::ParseWords qw//;

use Capture::Tiny qw/capture/;

# in core since 5.7.3
eval "use Scalar::Util qw/looks_like_number/;";
__PACKAGE__->can("looks_like_number") or eval <<'EOP';
=begin private

=head2 looks_like_number

=end private

=cut

# from PP part of Params::Util
sub looks_like_number {
    local $_ = shift;

    # checks from perlfaq4
    return 0 if !defined($_);
    if (ref($_)) {
        return overload::Overloaded($_) ? defined(0 + $_) : 0;
    }
    return 1 if (/^[+-]?[0-9]+$/); # is a +/- integer
    return 1 if (/^([+-]?)(?=[0-9]|\.[0-9])[0-9]*(\.[0-9]*)?([Ee]([+-]?[0-9]+))?$/); # a C float
    return 1 if ($] >= 5.008 and /^(Inf(inity)?|NaN)$/i) or ($] >= 5.006001 and /^Inf$/i);

    0;
}
EOP

eval "use File::Slurper qw/read_binary/;";
__PACKAGE__->can("read_binary") or eval <<'EOP';
=begin private

=head2 read_file

=end private

=cut

sub read_binary {
  my $fn = shift;
  local $@ = "";
  open( my $fh, "<", $fn ) or croak "Error opening $fn: $!";
  my $fc = <$fh>;
  close($fh) or croak "I/O error closing $fn: $!";
  return $fc;
}
EOP

# PA-RISC1.1-thread-multi
my %special_dlext = (
    darwin  => ".dylib",
    MSWin32 => ".dll",
    ($Config{archname} =~ m/PA-RISC/i ? ("hpux" => ".sl") : ()),
);

our ($LIBEXT, $EXEEXT);

defined $LIBEXT
  or $LIBEXT =
    defined $Config{so}         ? "." . $Config{so}
  : defined $special_dlext{$^O} ? $special_dlext{$^O}
  :                               ".so";
defined $EXEEXT
  or $EXEEXT = ($^O eq "MSWin32") ? ".exe" : "";

=encoding UTF-8

=head1 NAME

Config::AutoConf - A module to implement some of AutoConf macros in pure perl.

=cut

our $VERSION = '0.319';
$VERSION = eval $VERSION;

=head1 ABSTRACT

With this module I pretend to simulate some of the tasks AutoConf
macros do. To detect a command, to detect a library, etc.

=head1 SYNOPSIS

    use Config::AutoConf;

    Config::AutoConf->check_prog("agrep");
    my $grep = Config::AutoConf->check_progs("agrep", "egrep", "grep");

    Config::AutoConf->check_header("ncurses.h");
    my $curses = Config::AutoConf->check_headers("ncurses.h","curses.h");

    Config::AutoConf->check_prog_awk;
    Config::AutoConf->check_prog_egrep;

    Config::AutoConf->check_cc();

    Config::AutoConf->check_lib("ncurses", "tgoto");

    Config::AutoConf->check_file("/etc/passwd"); # -f && -r

=head1 DESCRIPTION

Config::AutoConf is intended to provide the same opportunities to Perl
developers as L
does for Shell developers.

As Perl is the second most deployed language (mind: every Unix comes
with Perl, several mini-computers have Perl and even lot's of Windows
machines run Perl software - which requires deployed Perl there, too),
this gives wider support than Shell based probes.

The API is leaned against GNU Autoconf, but we try to make the API
(especially optional arguments) more Perl'ish than m4 abilities allow
to the original.

=head1 CONSTRUCTOR

=cut

my $glob_instance;

=head2 new

This function instantiates a new instance of Config::AutoConf, e.g. to
configure child components. The constructor adds also values set via
environment variable C.

=cut

sub new
{
    my $class = shift;
    ref $class and $class = ref $class;
    my %args = @_;

    my %flags = map {
        my ($k, $v) = split("=", $_, 2);
        defined $v or $v = 1;
        ($k, $v)
    } split(":", $ENV{PERL5_AC_OPTS}) if ($ENV{PERL5_AC_OPTS});

    my %instance = (
        msg_prefix     => 'configure: ',
        lang           => "C",
        lang_stack     => [],
        lang_supported => {
            "C" => $class->can("check_prog_cc"),
        },
        cache                  => {},
        defines                => {},
        extra_libs             => [],
        extra_lib_dirs         => [],
        extra_include_dirs     => [],
        extra_preprocess_flags => [],
        extra_compile_flags    => {
            "C" => [],
        },
        extra_link_flags => [],
        logfile          => "config.log",
        c_ac_flags       => {%flags},
        %args
    );
    bless(\%instance, $class);
}

=head1 METHODS

=head2 check_file

This function checks if a file exists in the system and is readable by
the user. Returns a boolean. You can use '-f $file && -r $file' so you
don't need to use a function call.

=cut

sub check_file
{
    my $self = shift->_get_instance();
    my $file = shift;

    my $cache_name = $self->_cache_name("file", $file);
    $self->check_cached(
        $cache_name,
        "for $file",
        sub {
            -f $file && -r $file;
        }
    );
}

=head2 check_files

This function checks if a set of files exist in the system and are
readable by the user. Returns a boolean.

=cut

sub check_files
{
    my $self = shift->_get_instance();

    for (@_)
    {
        return 0 unless $self->check_file($_);
    }

    1;
}

sub _quote_shell_arg { scalar Text::ParseWords::shellwords($_[0]) > 1 ? QUOTE . $_[0] . QUOTE : $_[0] }

sub _sanitize_prog { shift; _quote_shell_arg shift }

sub _append_prog_args
{
    shift;
    join " ", map { _quote_shell_arg $_ } @_;
}

my @exe_exts = ($^O eq "MSWin32" ? qw(.exe .com .bat .cmd) : (""));

=head2 check_prog( $prog, \@dirlist?, \%options? )

This function checks for a program with the supplied name. In success
returns the full path for the executable;

An optional array reference containing a list of directories to be searched
instead of $PATH is gracefully honored.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.

=cut

sub check_prog
{
    my $self = shift->_get_instance();
    # sanitize ac_prog
    my $ac_prog = _sanitize(shift @_);

    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;

    my @dirlist;
    @_ and scalar @_ > 1 and @dirlist = @_;
    @_ and scalar @_ == 1 and ref $_[0] eq "ARRAY" and @dirlist = @{$_[0]};
    @dirlist or @dirlist = split(/$Config{path_sep}/, $ENV{PATH});

    for my $p (@dirlist)
    {
        for my $e (@exe_exts)
        {
            my $cmd           = $self->_sanitize_prog(File::Spec->catfile($p, $ac_prog . $e));
            my $is_executable = -x $cmd and -f $cmd;
                  $is_executable
              and $options->{action_on_true}
              and ref $options->{action_on_true} eq "CODE"
              and $options->{action_on_true}->();
            $is_executable and return $cmd;
        }
    }

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and $options->{action_on_false}->();

    return;
}

=head2 check_progs(progs, [dirlist])

This function takes a list of program names. Returns the full path for
the first found on the system. Returns undef if none was found.

An optional array reference containing a list of directories to be searched
instead of $PATH is gracefully honored.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively. The
name of the I<$prog> to check and the found full path are passed as first
and second argument to the I callback.

=cut

sub check_progs
{
    my $self = shift->_get_instance();

    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;

    my @dirlist;
    scalar @_ > 1 and ref $_[-1] eq "ARRAY" and @dirlist = @{pop @_};
    @dirlist or @dirlist = split(/$Config{path_sep}/, $ENV{PATH});

    my @progs = @_;
    foreach my $prog (@progs)
    {
        defined $prog or next;

        my $ans = $self->check_prog($prog, \@dirlist);
              $ans
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_if_true}->($prog, $ans);

        $ans and return $ans;
    }

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and $options->{action_on_false}->();

    return;
}

=head2 check_prog_yacc

From the L documentation,

  If `bison' is found, set [...] `bison -y'.
  Otherwise, if `byacc' is found, set [...] `byacc'.
  Otherwise set [...] `yacc'.  The result of this test can be influenced
  by setting the variable YACC or the cache variable ac_cv_prog_YACC.

Returns the full path, if found.

=cut

sub check_prog_yacc
{
    my $self = shift->_get_instance();

    # my ($self, $cache_name, $message, $check_sub) = @_;

    my $cache_name = $self->_cache_name("prog", "YACC");
    $self->check_cached(
        $cache_name,
        "for yacc",
        sub {
            defined $ENV{YACC} and return $ENV{YACC};
            my $binary = $self->check_progs(qw/bison byacc yacc/);
            defined $binary
              and $binary =~ /bison(?:\.(?:exe|com|bat|cmd))?$/
              and $binary = $self->_append_prog_args($binary, "-y");
            return $binary;
        }
    );
}

=head2 check_prog_awk

From the L documentation,

  Check for `gawk', `mawk', `nawk', and `awk', in that order, and
  set output [...] to the first one that is found.  It tries
  `gawk' first because that is reported to be the best implementation.
  The result can be overridden by setting the variable AWK or the
  cache variable ac_cv_prog_AWK.

Note that it returns the full path, if found.

=cut

sub check_prog_awk
{
    my $self       = shift->_get_instance();
    my $cache_name = $self->_cache_name("prog", "AWK");
    $self->check_cached($cache_name, "for awk", sub { $ENV{AWK} || $self->check_progs(qw/gawk mawk nawk awk/) });
}

=head2 check_prog_egrep

From the L documentation,

  Check for `grep -E' and `egrep', in that order, and [...] output
  [...] the first one that is found.  The result can be overridden by
  setting the EGREP variable and is cached in the ac_cv_path_EGREP
  variable.

Note that it returns the full path, if found.

=cut

sub check_prog_egrep
{
    my $self = shift->_get_instance();

    my $cache_name = $self->_cache_name("prog", "EGREP");
    $self->check_cached(
        $cache_name,
        "for egrep",
        sub {
            defined $ENV{EGREP} and return $ENV{EGREP};
            my $grep;
            $grep = $self->check_progs("egrep") and return $grep;

            if ($grep = $self->check_prog("grep"))
            {
                # check_run - Capture::Tiny, Open3 ... ftw!
                my $ans = `echo a | ($grep -E '(a|b)') 2>/dev/null`;
                chomp $ans;
                $ans eq "a" and return $self->_append_prog_args($grep, "-E");
            }
        }
    );
}

=head2 check_prog_lex

From the L documentation,

  If flex is found, set output [...] to ‘flex’ and [...] to -lfl, if that
  library is in a standard place. Otherwise set output [...] to ‘lex’ and
  [...] to -ll, if found. If [...] packages [...] ship the generated
  file.yy.c alongside the source file.l, this [...] allows users without a
  lexer generator to still build the package even if the timestamp for
  file.l is inadvertently changed.

Note that it returns the full path, if found.

The structure $self->{lex} is set with attributes

  prog => $LEX
  lib => $LEXLIB
  root => $lex_root

=cut

sub check_prog_lex
{
    my $self       = shift->_get_instance;
    my $cache_name = $self->_cache_name("prog", "LEX");
    my $lex        = $self->check_cached($cache_name, "for lex", sub { $ENV{LEX} || $self->check_progs(qw/flex lex/) });
    if ($lex)
    {
        defined $self->{lex}->{prog} or $self->{lex}->{prog} = $lex;
        my $lex_root_var = $self->check_cached(
            "ac_cv_prog_lex_root",
            "for lex output file root",
            sub {
                my ($fh, $filename) = tempfile(
                    "testXXXXXX",
                    SUFFIX => '.l',
                    UNLINK => 0
                );
                my $src = <<'EOLEX';
%%
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 ();
}
EOLEX

                print {$fh} $src;
                close $fh;

                my ($stdout, $stderr, $exit) =
                  capture { system($lex, $filename); };
                chomp $stdout;
                unlink $filename;
                -f "lex.yy.c" and return "lex.yy";
                -f "lexyy.c"  and return "lexyy";
                $self->msg_error("cannot find output from $lex; giving up");
            }
        );
        defined $self->{lex}->{root} or $self->{lex}->{root} = $lex_root_var;

        my $conftest = read_binary($lex_root_var . ".c");
        unlink $lex_root_var . ".c";

        $cache_name = $self->_cache_name("lib", "lex");
        my $check_sub = sub {
            my @save_libs = @{$self->{extra_libs}};
            my $have_lib  = 0;
            foreach my $libstest (undef, qw(-lfl -ll))
            {
                # XXX would local work on array refs? can we omit @save_libs?
                $self->{extra_libs} = [@save_libs];
                defined($libstest) and unshift(@{$self->{extra_libs}}, $libstest);
                $self->link_if_else($conftest)
                  and ($have_lib = defined($libstest) ? $libstest : "none required")
                  and last;
            }
            $self->{extra_libs} = [@save_libs];

            if ($have_lib)
            {
                $self->define_var(_have_lib_define_name("lex"), $have_lib, "defined when lex library is available");
            }
            else
            {
                $self->define_var(_have_lib_define_name("lex"), undef, "defined when lex library is available");
            }
            return $have_lib;
        };

        my $lex_lib = $self->check_cached($cache_name, "lex library", $check_sub);
        defined $self->{lex}->{lib} or $self->{lex}->{lib} = $lex_lib;
    }

    $lex;
}

=head2 check_prog_sed

From the L documentation,

  Set output variable [...] to a Sed implementation that conforms to Posix
  and does not have arbitrary length limits. Report an error if no
  acceptable Sed is found. See Limitations of Usual Tools, for more
  information about portability problems with Sed.

  The result of this test can be overridden by setting the SED variable and
  is cached in the ac_cv_path_SED variable.

Note that it returns the full path, if found.

=cut

sub check_prog_sed
{
    my $self       = shift->_get_instance();
    my $cache_name = $self->_cache_name("prog", "SED");
    $self->check_cached($cache_name, "for sed", sub { $ENV{SED} || $self->check_progs(qw/gsed sed/) });
}

=head2 check_prog_pkg_config

Checks for C program. No additional tests are made for it ...

=cut

sub check_prog_pkg_config
{
    my $self       = shift->_get_instance();
    my $cache_name = $self->_cache_name("prog", "PKG_CONFIG");
    $self->check_cached($cache_name, "for pkg-config", sub { $self->check_prog("pkg-config") });
}

=head2 check_prog_cc

Determine a C compiler to use. Currently the probe is delegated to L.

=cut

sub check_prog_cc
{
    my $self       = shift->_get_instance();
    my $cache_name = $self->_cache_name("prog", "CC");

    $self->check_cached(
        $cache_name,
        "for cc",
        sub {
            $self->{lang_supported}->{C} = undef;
            eval "use ExtUtils::CBuilder;";
            $@ and return;
            my $cb = ExtUtils::CBuilder->new(quiet => 1);
            $cb->have_compiler or return;
            $self->{lang_supported}->{C} = "ExtUtils::CBuilder";
            $cb->{config}->{cc};
        }
    );
}

=head2 check_cc

(Deprecated) Old name of L.

=cut

sub check_cc { shift->check_prog_cc(@_) }

=head2 check_valid_compiler

This function checks for a valid compiler for the currently active language.
At the very moment only C is understood (corresponding to your compiler
default options, e.g. -std=gnu89).

=cut

sub check_valid_compiler
{
    my $self = shift->_get_instance;
    my $lang = $self->{lang};
    $lang eq "C" or $self->msg_error("Language $lang is not supported");
    $self->check_prog_cc;
}

=head2 check_valid_compilers(;\@)

Checks for valid compilers for each given language. When unspecified
defaults to C<[ "C" ]>.

=cut

sub check_valid_compilers
{
    my $self = shift;
    for my $lang (@{$_[0]})
    {
        $self->push_lang($lang);
        my $supp = $self->check_valid_compiler;
        $self->pop_lang($lang);
        $supp or return 0;
    }

    1;
}

=head2 msg_checking

Prints "Checking @_ ..."

=cut

sub msg_checking
{
    my $self = shift->_get_instance();
    $self->{quiet}
      or print "Checking " . join(" ", @_) . "... ";
    $self->_add_log_entry("Checking " . join(" ", @_, "..."));
    return;
}

=head2 msg_result

Prints result \n

=cut

my @_num_to_msg = qw/no yes/;

sub _neat
{
    defined $_[0] or return "";
    looks_like_number($_[0]) and defined $_num_to_msg[$_[0]] and return $_num_to_msg[$_[0]];
    $_[0];
}

sub msg_result
{
    my $self = shift->_get_instance();
    $self->{quiet}
      or print join(" ", map { _neat $_ } @_), "\n";
    $self->_add_log_entry(join(" ", map { _neat $_ } @_), "\n");
    return;
}

=head2 msg_notice

Prints "configure: " @_ to stdout

=cut

sub msg_notice
{
    my $self = shift->_get_instance();
    $self->{quiet}
      or print $self->{msg_prefix} . join(" ", @_) . "\n";
    $self->_add_log_entry($self->{msg_prefix} . join(" ", @_) . "\n");
    return;
}

=head2 msg_warn

Prints "configure: " @_ to stderr

=cut

sub msg_warn
{
    my $self = shift->_get_instance();
    print STDERR $self->{msg_prefix} . join(" ", @_) . "\n";
    $self->_add_log_entry("WARNING: " . $self->{msg_prefix} . join(" ", @_) . "\n");
    return;
}

=head2 msg_error

Prints "configure: " @_ to stderr and exits with exit code 0 (tells
toolchain to stop here and report unsupported environment)

=cut

sub msg_error
{
    my $self = shift->_get_instance();
    print STDERR $self->{msg_prefix} . join(" ", @_) . "\n";
    $self->_add_log_entry("ERROR: " . $self->{msg_prefix} . join(" ", @_) . "\n");
    exit(0);    # #toolchain agreement: prevents configure stage to finish
}

=head2 msg_failure

Prints "configure: " @_ to stderr and exits with exit code 0 (tells
toolchain to stop here and report unsupported environment). Additional
details are provides in config.log (probably more information in a
later stage).

=cut

sub msg_failure
{
    my $self = shift->_get_instance();
    print STDERR $self->{msg_prefix} . join(" ", @_) . "\n";
    $self->_add_log_entry("FAILURE: " . $self->{msg_prefix} . join(" ", @_) . "\n");
    exit(0);    # #toolchain agreement: prevents configure stage to finish
}

=head2 define_var( $name, $value [, $comment ] )

Defines a check variable for later use in further checks or code to compile.
Returns the value assigned value

=cut

sub define_var
{
    my $self = shift->_get_instance();
    my ($name, $value, $comment) = @_;

    defined($name) or croak("Need a name to add a define");
    $self->{defines}->{$name} = [$value, $comment];
    $value;
}

=head2 write_config_h( [$target] )

Writes the defined constants into given target:

  Config::AutoConf->write_config_h( "config.h" );

=cut

sub write_config_h
{
    my $self = shift->_get_instance();
    my $tgt;

    defined($_[0])
      ? (
        ref($_[0])
        ? $tgt = $_[0]
        : open($tgt, ">", $_[0])
      )
      : open($tgt, ">", "config.h");

    my $conf_h = <<'EOC';
/**
 * Generated from Config::AutoConf
 *
 * Do not edit this file, all modifications will be lost,
 * modify Makefile.PL or Build.PL instead.
 *
 * Inspired by GNU AutoConf.
 *
 * (c) 2011 Alberto Simoes & Jens Rehsack
 */
#ifndef __CONFIG_H__

EOC

    while (my ($defname, $defcnt) = each(%{$self->{defines}}))
    {
        if ($defcnt->[0])
        {
            defined $defcnt->[1] and $conf_h .= "/* " . $defcnt->[1] . " */\n";
            $conf_h .= join(" ", "#define", $defname, $defcnt->[0]) . "\n";
        }
        else
        {
            defined $defcnt->[1] and $conf_h .= "/* " . $defcnt->[1] . " */\n";
            $conf_h .= "/* " . join(" ", "#undef", $defname) . " */\n\n";
        }
    }
    $conf_h .= "#endif /* ?__CONFIG_H__ */\n";

    print {$tgt} $conf_h;

    return;
}

=head2 push_lang(lang [, implementor ])

Puts the current used language on the stack and uses specified language
for subsequent operations until ending pop_lang call.

=cut

sub push_lang
{
    my $self = shift->_get_instance();

    push @{$self->{lang_stack}}, [$self->{lang}];

    $self->_set_language(@_);
}

=head2 pop_lang([ lang ])

Pops the currently used language from the stack and restores previously used
language. If I specified, it's asserted that the current used language
equals to specified language (helps finding control flow bugs).

=cut

sub pop_lang
{
    my $self = shift->_get_instance();

    scalar(@{$self->{lang_stack}}) > 0 or croak("Language stack empty");
    defined($_[0])
      and $self->{lang} ne $_[0]
      and croak("pop_lang( $_[0] ) doesn't match language in use (" . $self->{lang} . ")");

    $self->_set_language(@{pop @{$self->{lang_stack}}});
}

=head2 lang_build_program( prologue, body )

Builds program for current chosen language. If no prologue is given
(I), the default headers are used. If body is missing, default
body is used.

Typical call of

  Config::AutoConf->lang_build_program( "const char hw[] = \"Hello, World\\n\";",
                                        "fputs (hw, stdout);" )

will create

  const char hw[] = "Hello, World\n";

  /* Override any gcc2 internal prototype to avoid an error.  */
  #ifdef __cplusplus
  extern "C" {
  #endif

  int
  main (int argc, char **argv)
  {
    (void)argc;
    (void)argv;
    fputs (hw, stdout);;
    return 0;
  }

  #ifdef __cplusplus
  }
  #endif

=cut

sub lang_build_program
{
    my ($self, $prologue, $body) = @_;
    ref $self or $self = $self->_get_instance();

    defined($prologue) or $prologue = $self->_default_includes();
    defined($body)     or $body     = "";
    $body = $self->_build_main($body);

    $self->_fill_defines() . "\n$prologue\n\n$body\n";
}

sub _lang_prologue_func
{
    my ($self, $prologue, $function) = @_;
    ref $self or $self = $self->_get_instance();

    defined($prologue) or $prologue = $self->_default_includes();
    $prologue .= <<"_ACEOF";
/* 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 $function ();
#ifdef __cplusplus
}
#endif
_ACEOF

    return $prologue;
}

sub _lang_body_func
{
    my ($self, $function) = @_;
    ref $self or $self = $self->_get_instance();

    my $func_call = "return $function ();";
    return $func_call;
}

=head2 lang_call( [prologue], function )

Builds program which simply calls given function.
When given, prologue is prepended otherwise, the default
includes are used.

=cut

sub lang_call
{
    my ($self, $prologue, $function) = @_;
    ref $self or $self = $self->_get_instance();

    return $self->lang_build_program($self->_lang_prologue_func($prologue, $function), $self->_lang_body_func($function),);
}

sub _lang_prologue_builtin
{
    my ($self, $prologue, $builtin) = @_;
    ref $self or $self = $self->_get_instance();

    defined($prologue) or $prologue = $self->_default_includes();
    $prologue .= <<"_ACEOF";
#if !defined(__has_builtin)
#undef $builtin
/* Declare this builtin with the same prototype as __builtin_$builtin.
  This removes a warning about conflicting types for built-in builtin $builtin */
__typeof__(__builtin_$builtin) $builtin;
__typeof__(__builtin_$builtin) *f = $builtin;
#endif
_ACEOF
}

sub _lang_body_builtin
{
    my ($self, $builtin) = @_;
    ref $self or $self = $self->_get_instance();

    my $body = <<"_ACEOF";
#if !defined(__has_builtin)
return f != $builtin;
#else
return __has_builtin($builtin);
#endif
_ACEOF
    return $body;
}

=head2 lang_builtin( [prologue], builtin )

Builds program which simply proves whether a builtin is known to
language compiler.

=cut

sub lang_builtin
{
    my ($self, $prologue, $builtin) = @_;
    ref $self or $self = $self->_get_instance();

    return $self->lang_build_program($self->_lang_prologue_func($prologue, $builtin), $self->_lang_body_builtin($builtin),);
}

=head2 lang_build_bool_test (prologue, test, [@decls])

Builds a static test which will fail to compile when test
evaluates to false. If C<@decls> is given, it's prepended
before the test code at the variable definition place.

=cut

sub lang_build_bool_test
{
    my ($self, $prologue, $test, @decls) = @_;
    ref $self or $self = $self->_get_instance();

    defined($test) or $test = "1";
    my $test_code = <
  static int test_array [($test) ? 1 : -1 ];
  test_array [0] = 0
ACEOF
    if (@decls)
    {
        $test_code = join("\n", @decls, $test_code);
    }
    $self->lang_build_program($prologue, $test_code);
}

=head2 push_includes

Adds given list of directories to preprocessor/compiler
invocation. This is not proved to allow adding directories
which might be created during the build.

=cut

sub push_includes
{
    my ($self, @includes) = @_;
    ref $self or $self = $self->_get_instance();

    push(@{$self->{extra_include_dirs}}, @includes);

    return;
}

=head2 push_preprocess_flags

Adds given flags to the parameter list for preprocessor invocation.

=cut

sub push_preprocess_flags
{
    my ($self, @cpp_flags) = @_;
    ref $self or $self = $self->_get_instance();

    push(@{$self->{extra_preprocess_flags}}, @cpp_flags);

    return;
}

=head2 push_compiler_flags

Adds given flags to the parameter list for compiler invocation.

=cut

sub push_compiler_flags
{
    my ($self, @compiler_flags) = @_;
    ref $self or $self = $self->_get_instance();
    my $lang = $self->{lang};

    if (scalar(@compiler_flags) && (ref($compiler_flags[-1]) eq "HASH"))
    {
        my $lang_opt = pop(@compiler_flags);
        defined($lang_opt->{lang}) or croak("Missing lang attribute in language options");
        $lang = $lang_opt->{lang};
        defined($self->{lang_supported}->{$lang}) or croak("Unsupported language '$lang'");
    }

    push(@{$self->{extra_compile_flags}->{$lang}}, @compiler_flags);

    return;
}

=head2 push_libraries

Adds given list of libraries to the parameter list for linker invocation.

=cut

sub push_libraries
{
    my ($self, @libs) = @_;
    ref $self or $self = $self->_get_instance();

    push(@{$self->{extra_libs}}, @libs);

    return;
}

=head2 push_library_paths

Adds given list of library paths to the parameter list for linker invocation.

=cut

sub push_library_paths
{
    my ($self, @libdirs) = @_;
    ref $self or $self = $self->_get_instance();

    push(@{$self->{extra_lib_dirs}}, @libdirs);

    return;
}

=head2 push_link_flags

Adds given flags to the parameter list for linker invocation.

=cut

sub push_link_flags
{
    my ($self, @link_flags) = @_;
    ref $self or $self = $self->_get_instance();

    push(@{$self->{extra_link_flags}}, @link_flags);

    return;
}

=head2 compile_if_else( $src, \%options? )

This function tries to compile specified code and returns a boolean value
containing check success state.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.

=cut

sub compile_if_else
{
    my ($self, $src) = @_;
    ref $self or $self = $self->_get_instance();

    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    my $builder = $self->_get_builder();

    my ($fh, $filename) = tempfile(
        "testXXXXXX",
        SUFFIX => '.c',
        UNLINK => 0
    );

    print {$fh} $src;
    close $fh;

    my ($obj_file, $outbuf, $errbuf, $exception);
    ($outbuf, $errbuf) = capture
    {
        eval {
            $obj_file = $builder->compile(
                source               => $filename,
                include_dirs         => $self->{extra_include_dirs},
                extra_compiler_flags => $self->_get_extra_compiler_flags()
            );
        };

        $exception = $@;
    };

    unlink $filename;
    $obj_file and !-f $obj_file and undef $obj_file;
    unlink $obj_file if $obj_file;

    if ($exception || !$obj_file)
    {
        $self->_add_log_lines("compile stage failed" . ($exception ? " - " . $exception : ""));
        $errbuf
          and $self->_add_log_lines($errbuf);
        $self->_add_log_lines("failing program is:\n" . $src);
        $outbuf
          and $self->_add_log_lines("stdout was :\n" . $outbuf);

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and $options->{action_on_false}->();

        return 0;
    }

    $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    1;
}

=head2 link_if_else( $src, \%options? )

This function tries to compile and link specified code and returns a boolean
value containing check success state.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.

=cut

sub link_if_else
{
    my ($self, $src) = @_;
    ref $self or $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    my $builder = $self->_get_builder();

    my ($fh, $filename) = tempfile(
        "testXXXXXX",
        SUFFIX => '.c',
        UNLINK => 0
    );

    print {$fh} $src;
    close $fh;

    my ($obj_file, $outbuf, $errbuf, $exception);
    ($outbuf, $errbuf) = capture
    {
        eval {
            $obj_file = $builder->compile(
                source               => $filename,
                include_dirs         => $self->{extra_include_dirs},
                extra_compiler_flags => $self->_get_extra_compiler_flags()
            );
        };

        $exception = $@;
    };

    $obj_file and !-f $obj_file and undef $obj_file;

    if ($exception || !$obj_file)
    {
        $self->_add_log_lines("compile stage failed" . ($exception ? " - " . $exception : ""));
        $errbuf
          and $self->_add_log_lines($errbuf);
        $self->_add_log_lines("failing program is:\n" . $src);
        $outbuf
          and $self->_add_log_lines("stdout was :\n" . $outbuf);

        unlink $filename;
        unlink $obj_file if $obj_file;

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and $options->{action_on_false}->();

        return 0;
    }

    my $exe_file;
    ($outbuf, $errbuf) = capture
    {
        eval {
            $exe_file = $builder->link_executable(
                objects            => $obj_file,
                extra_linker_flags => $self->_get_extra_linker_flags()
            );
        };

        $exception = $@;
    };

    $exe_file and !-f $exe_file and undef $exe_file;

    unlink $filename;
    unlink $obj_file if $obj_file;
    unlink $exe_file if $exe_file;

    if ($exception || !$exe_file)
    {
        $self->_add_log_lines("link stage failed" . ($exception ? " - " . $exception : ""));
        $errbuf
          and $self->_add_log_lines($errbuf);
        $self->_add_log_lines("failing program is:\n" . $src);
        $outbuf
          and $self->_add_log_lines("stdout was :\n" . $outbuf);

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and $options->{action_on_false}->();

        return 0;
    }

    $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    1;
}

=head2 check_cached( $cache-key, $check-title, \&check-call, \%options? )

Retrieves the result of a previous L invocation from
C, or (when called for the first time) populates the cache
by invoking C<\&check_call>.

If the very last parameter contains a hash reference, C references
to I or I are executed on B call
to check_cached (not just the first cache-populating invocation), respectively.

=cut

sub check_cached
{
    my ($self, $cache_name, $message, $check_sub) = @_;
    ref $self or $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 4 and ref $_[-1] eq "HASH" and $options = pop @_;

    $self->msg_checking($message);

    defined $ENV{$cache_name}
      and not defined $self->{cache}->{$cache_name}
      and $self->{cache}->{$cache_name} = $ENV{$cache_name};

    my @cached_result;
    defined($self->{cache}->{$cache_name}) and push @cached_result, "(cached)";
    defined($self->{cache}->{$cache_name}) or $self->{cache}->{$cache_name} = $check_sub->();

    $self->msg_result(@cached_result, $self->{cache}->{$cache_name});

    $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $self->{cache}->{$cache_name}
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$self->{cache}->{$cache_name}
      and $options->{action_on_false}->();

    $self->{cache}->{$cache_name};
}

=head2 cache_val

This function returns the value of a previously check_cached call.

=cut

sub cache_val
{
    my ($self, $cache_name) = @_;
    ref $self or $self = $self->_get_instance();
    defined $self->{cache}->{$cache_name} or return;
    $self->{cache}->{$cache_name};
}

=head2 check_decl( $symbol, \%options? )

This method actually tests whether symbol is defined as a macro or can be
used as an r-value, not whether it is really declared, because it is much
safer to avoid introducing extra declarations when they are not needed.
In order to facilitate use of C++ and overloaded function declarations, it
is possible to specify function argument types in parentheses for types
which can be zero-initialized:

  Config::AutoConf->check_decl("basename(char *)")

This method caches its result in the Cset langE>_symbol
variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub check_decl
{
    my ($self, $symbol) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    defined($symbol)   or return croak("No symbol to check for");
    ref($symbol) eq "" or return croak("No symbol to check for");
    (my $sym_plain = $symbol) =~ s/ *\(.*//;
    my $sym_call = $symbol;
    $sym_call =~ s/\(/((/;
    $sym_call =~ s/\)/) 0)/;
    $sym_call =~ s/,/) 0, (/g;

    my $cache_name = $self->_cache_name("decl", $self->{lang}, $symbol);
    my $check_sub  = sub {

        my $body = <
#ifndef $sym_plain
  (void) $sym_call;
#endif
ACEOF
        my $conftest = $self->lang_build_program($options->{prologue}, $body);

        my $have_decl = $self->compile_if_else(
            $conftest,
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );

        $have_decl;
    };

    $self->check_cached(
        $cache_name,
        "whether $symbol is declared",
        $check_sub,
        {
            ($options->{action_on_cache_true}  ? (action_on_true  => $options->{action_on_cache_true})  : ()),
            ($options->{action_on_cache_false} ? (action_on_false => $options->{action_on_cache_false}) : ())
        }
    );
}

=head2 check_decls( symbols, \%options? )

For each of the symbols (with optional function argument types for C++
overloads), run L.

Contrary to B, this method does not declare C
macros for the resulting C, because it differs as C
between compiling languages.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.
Given callbacks for I or I are
called for each symbol checked using L receiving the symbol as
first argument.

=cut

sub check_decls
{
    my ($self, $symbols) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $have_syms = 1;
    foreach my $symbol (@$symbols)
    {
        $have_syms &= $self->check_decl(
            $symbol,
            {
                %pass_options,
                (
                    $options->{action_on_symbol_true} && "CODE" eq ref $options->{action_on_symbol_true}
                    ? (action_on_true => sub { $options->{action_on_symbol_true}->($symbol) })
                    : ()
                ),
                (
                    $options->{action_on_symbol_false} && "CODE" eq ref $options->{action_on_symbol_false}
                    ? (action_on_false => sub { $options->{action_on_symbol_false}->($symbol) })
                    : ()
                ),
            }
        );
    }

          $have_syms
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_syms
      and $options->{action_on_false}->();

    $have_syms;
}

sub _have_func_define_name
{
    my $func      = $_[0];
    my $have_name = "HAVE_" . uc($func);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

=head2 check_func( $function, \%options? )

This method actually tests whether I<$funcion> can be linked into a program
trying to call I<$function>.  This method caches its result in the
ac_cv_func_FUNCTION variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to C, respectively.

Returns: True if the function was found, false otherwise

=cut

sub check_func
{
    my ($self, $function) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    # Build the name of the cache variable.
    my $cache_name = $self->_cache_name('func', $function);
    # Wrap the actual check in a closure so that we can use check_cached.
    my $check_sub = sub {
        my $have_func = $self->link_if_else(
            $self->lang_call(q{}, $function),
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );
        $have_func;
    };

    # Run the check and cache the results.
    return $self->check_cached(
        $cache_name,
        "for $function",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _have_func_define_name($function),
                    $self->cache_val($cache_name),
                    "Defined when $function is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_func_define_name($function), undef, "Defined when $function is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_funcs( \@functions-list, $action-if-true?, $action-if-false? )

The same as check_func, but takes a list of functions in I<\@functions-list>
to look for and checks for each in turn. Define HAVE_FUNCTION for each
function that was found.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to C, respectively.  Given callbacks
for I or I are called for
each symbol checked using L receiving the symbol as first
argument.

=cut

sub check_funcs
{
    my ($self, $functions_ref) = @_;
    $self = $self->_get_instance();

    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    my %pass_options;
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    # Go through the list of functions and call check_func for each one. We
    # generate new closures for the found and not-found functions that pass in
    # the relevant function name.
    my $have_funcs = 1;
    for my $function (@{$functions_ref})
    {
        # Build the code reference to run when a function was found. This defines
        # a HAVE_FUNCTION symbol, plus runs the current $action-if-true if there is
        # one.
        $pass_options{action_on_true} = sub {
            # Run the user-provided hook, if there is one.
            defined $options->{action_on_function_true}
              and ref $options->{action_on_function_true} eq "CODE"
              and $options->{action_on_function_true}->($function);
        };

        defined $options->{action_on_function_false}
          and ref $options->{action_on_function_false} eq "CODE"
          and $pass_options{action_on_false} = sub { $options->{action_on_function_false}->($function); };

        $have_funcs &= check_func($self, $function, \%pass_options);
    }

          $have_funcs
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_funcs
      and $options->{action_on_false}->();

    return $have_funcs;
}

=head2 check_builtin( $builtin, \%options? )

This method actually tests whether I<$builtin> is a supported built-in
known by the compiler. Either, by giving us the type of the built-in or
by taking the value from C<__has_builtin>.  This method caches its result
in the ac_cv_builtin_FUNCTION variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to C, respectively.

Returns: True if the function was found, false otherwise

=cut

sub _have_builtin_define_name
{
    my $builtin   = $_[0];
    my $have_name = "HAVE_BUILTIN_" . uc($builtin);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

sub check_builtin
{
    my ($self, $builtin) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    # Build the name of the cache variable.
    my $cache_name = $self->_cache_name('builtin', $builtin);
    # Wrap the actual check in a closure so that we can use check_cached.
    my $check_sub = sub {
        my $have_builtin = $self->link_if_else(
            $self->lang_builtin(q{}, $builtin),
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );
        $have_builtin;
    };

    # Run the check and cache the results.
    return $self->check_cached(
        $cache_name,
        "for builtin $builtin",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _have_builtin_define_name($builtin),
                    $self->cache_val($cache_name),
                    "Defined when builtin $builtin is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_builtin_define_name($builtin), undef, "Defined when builtin $builtin is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

sub _have_type_define_name
{
    my $type      = $_[0];
    my $have_name = "HAVE_" . uc($type);
    $have_name =~ tr/*/P/;
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

=head2 check_type( $symbol, \%options? )

Check whether type is defined. It may be a compiler builtin type or defined
by the includes.  In C, type must be a type-name, so that the expression
C is valid (but C is not).

If I type is defined, preprocessor macro HAVE_I (in all
capitals, with "*" replaced by "P" and spaces and dots replaced by
underscores) is defined.

This method caches its result in the Ctype variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub check_type
{
    my ($self, $type) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    defined($type)   or return croak("No type to check for");
    ref($type) eq "" or return croak("No type to check for");

    my $cache_name = $self->_cache_type_name("type", $type);
    my $check_sub  = sub {

        my $body = <
  if( sizeof ($type) )
    return 0;
ACEOF
        my $conftest = $self->lang_build_program($options->{prologue}, $body);

        my $have_type = $self->compile_if_else(
            $conftest,
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );
        $have_type;
    };

    $self->check_cached(
        $cache_name,
        "for $type",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(_have_type_define_name($type), $self->cache_val($cache_name),
                    "defined when $type is available");
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_type_define_name($type), undef, "defined when $type is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_types( \@type-list, \%options? )

For each type in I<@type-list>, call L is called to check
for type and return the accumulated result (accumulation op is binary and).

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.
Given callbacks for I or I are
called for each symbol checked using L receiving the symbol as
first argument.

=cut

sub check_types
{
    my ($self, $types) = @_;
    $self = $self->_get_instance();
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $have_types = 1;
    foreach my $type (@$types)
    {
        $have_types &= $self->check_type(
            $type,
            {
                %pass_options,
                (
                    $options->{action_on_type_true} && "CODE" eq ref $options->{action_on_type_true}
                    ? (action_on_true => sub { $options->{action_on_type_true}->($type) })
                    : ()
                ),
                (
                    $options->{action_on_type_false} && "CODE" eq ref $options->{action_on_type_false}
                    ? (action_on_false => sub { $options->{action_on_type_false}->($type) })
                    : ()
                ),
            }
        );
    }

          $have_types
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_types
      and $options->{action_on_false}->();

    $have_types;
}

sub _compute_int_compile
{
    my ($self, $expr, $prologue, @decls) = @_;
    $self = $self->_get_instance();

    my ($body, $conftest, $compile_result);

    my ($low, $mid, $high) = (0, 0, 0);
    if ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) >= 0", @decls)))
    {
        $low = $mid = 0;
        while (1)
        {
            if ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) <= $mid", @decls)))
            {
                $high = $mid;
                last;
            }
            $low = $mid + 1;
            # avoid overflow
            if ($low <= $mid)
            {
                $low = 0;
                last;
            }
            $mid = $low * 2;
        }
    }
    elsif ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) < 0", @decls)))
    {
        $high = $mid = -1;
        while (1)
        {
            if ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) >= $mid", @decls)))
            {
                $low = $mid;
                last;
            }
            $high = $mid - 1;
            # avoid overflow
            if ($mid < $high)
            {
                $high = 0;
                last;
            }
            $mid = $high * 2;
        }
    }

    # perform binary search between $low and $high
    while ($low <= $high)
    {
        $mid = int(($high - $low) / 2 + $low);
        if ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) < $mid", @decls)))
        {
            $high = $mid - 1;
        }
        elsif ($self->compile_if_else($self->lang_build_bool_test($prologue, "((long int)($expr)) > $mid", @decls)))
        {
            $low = $mid + 1;
        }
        else
        {
            return $mid;
        }
    }

    return;
}

=head2 compute_int( $expression, @decls?, \%options )

Returns the value of the integer I. The value should fit in an
initializer in a C variable of type signed long.  It should be possible
to evaluate the expression at compile-time. If no includes are specified,
the default includes are used.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub _expr_value_define_name
{
    my $expr      = $_[0];
    my $have_name = "EXPR_" . uc($expr);
    $have_name =~ tr/*/P/;
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

sub compute_int
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $expr, @decls) = @_;
    $self = $self->_get_instance();

    my $cache_name = $self->_cache_type_name("compute_int", $self->{lang}, $expr);
    my $check_sub  = sub {
        my $val = $self->_compute_int_compile($expr, $options->{prologue}, @decls);

        defined $val
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and !defined $val
          and $options->{action_on_false}->();

        $val;
    };

    $self->check_cached(
        $cache_name,
        "for compute result of ($expr)",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _expr_value_define_name($expr),
                    $self->cache_val($cache_name),
                    "defined when ($expr) could computed"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_expr_value_define_name($expr), undef, "defined when ($expr) could computed");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_sizeof_type( $type, \%options? )

Checks for the size of the specified type by compiling and define
C using the determined size.

In opposition to GNU AutoConf, this method can determine size of structure
members, e.g.

  $ac->check_sizeof_type( "SV.sv_refcnt", { prologue => $include_perl } );
  # or
  $ac->check_sizeof_type( "struct utmpx.ut_id", { prologue => "#include " } );

This method caches its result in the Cset langE>_type variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub _sizeof_type_define_name
{
    my $type      = $_[0];
    my $have_name = "SIZEOF_" . uc($type);
    $have_name =~ tr/*/P/;
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

sub check_sizeof_type
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $type) = @_;
    $self = $self->_get_instance();
    defined($type)   or return croak("No type to check for");
    ref($type) eq "" or return croak("No type to check for");

    my $cache_name = $self->_cache_type_name("sizeof", $self->{lang}, $type);
    my $check_sub  = sub {
        my @decls;
        if ($type =~ m/^([^.]+)\.([^.]+)$/)
        {
            my $struct = $1;
            $type = "_ac_test_aggr.$2";
            my $decl = "static $struct _ac_test_aggr;";
            push(@decls, $decl);
        }

        my $typesize = $self->_compute_int_compile("sizeof($type)", $options->{prologue}, @decls);

              $typesize
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and !$typesize
          and $options->{action_on_false}->();

        $typesize;
    };

    $self->check_cached(
        $cache_name,
        "for size of $type",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _sizeof_type_define_name($type),
                    $self->cache_val($cache_name),
                    "defined when sizeof($type) is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_sizeof_type_define_name($type), undef, "defined when sizeof($type) is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_sizeof_types( type, \%options? )

For each type L is called to check for size of type.

If I is given, it is additionally executed when all of the
sizes of the types could determined. If I is given, it
is executed when one size of the types could not determined.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.
Given callbacks for I or I are
called for each symbol checked using L receiving the
symbol as first argument.

=cut

sub check_sizeof_types
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $types) = @_;
    $self = $self->_get_instance();

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $have_sizes = 1;
    foreach my $type (@$types)
    {
        $have_sizes &= !!(
            $self->check_sizeof_type(
                $type,
                {
                    %pass_options,
                    (
                        $options->{action_on_size_true} && "CODE" eq ref $options->{action_on_size_true}
                        ? (action_on_true => sub { $options->{action_on_size_true}->($type) })
                        : ()
                    ),
                    (
                        $options->{action_on_size_false} && "CODE" eq ref $options->{action_on_size_false}
                        ? (action_on_false => sub { $options->{action_on_size_false}->($type) })
                        : ()
                    ),
                }
            )
        );
    }

          $have_sizes
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_sizes
      and $options->{action_on_false}->();

    $have_sizes;
}

sub _alignof_type_define_name
{
    my $type      = $_[0];
    my $have_name = "ALIGNOF_" . uc($type);
    $have_name =~ tr/*/P/;
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

=head2 check_alignof_type( type, \%options? )

Define ALIGNOF_type to be the alignment in bytes of type. I must
be valid as a structure member declaration or I must be a structure
member itself.

This method caches its result in the Cset langE>_type
variable, with I<*> mapped to C and other characters not suitable for a
variable name mapped to underscores.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub check_alignof_type
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $type) = @_;
    $self = $self->_get_instance();
    defined($type)   or return croak("No type to check for");
    ref($type) eq "" or return croak("No type to check for");

    my $cache_name = $self->_cache_type_name("alignof", $self->{lang}, $type);
    my $check_sub  = sub {
        my @decls = (
            "#ifndef offsetof",
            "# ifdef __ICC",
            "#  define offsetof(type,memb) ((size_t)(((char *)(&((type*)0)->memb)) - ((char *)0)))",
            "# else",  "#  define offsetof(type,memb) ((size_t)&((type*)0)->memb)",
            "# endif", "#endif"
        );

        my ($struct, $memb);
        if ($type =~ m/^([^.]+)\.([^.]+)$/)
        {
            $struct = $1;
            $memb   = $2;
        }
        else
        {
            push(@decls, "typedef struct { char x; $type y; } ac__type_alignof_;");
            $struct = "ac__type_alignof_";
            $memb   = "y";
        }

        my $typealign = $self->_compute_int_compile("offsetof($struct, $memb)", $options->{prologue}, @decls);

              $typealign
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and !$typealign
          and $options->{action_on_false}->();

        $typealign;
    };

    $self->check_cached(
        $cache_name,
        "for align of $type",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _alignof_type_define_name($type),
                    $self->cache_val($cache_name),
                    "defined when alignof($type) is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_alignof_type_define_name($type), undef, "defined when alignof($type) is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_alignof_types (type, [action-if-found], [action-if-not-found], [prologue = default includes])

For each type L is called to check for align of type.

If I is given, it is additionally executed when all of the
aligns of the types could determined. If I is given, it
is executed when one align of the types could not determined.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.
Given callbacks for I or I are
called for each symbol checked using L receiving the
symbol as first argument.

=cut

sub check_alignof_types
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $types) = @_;
    $self = $self->_get_instance();

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $have_aligns = 1;
    foreach my $type (@$types)
    {
        $have_aligns &= !!(
            $self->check_alignof_type(
                $type,
                {
                    %pass_options,
                    (
                        $options->{action_on_align_true} && "CODE" eq ref $options->{action_on_align_true}
                        ? (action_on_true => sub { $options->{action_on_align_true}->($type) })
                        : ()
                    ),
                    (
                        $options->{action_on_align_false} && "CODE" eq ref $options->{action_on_align_false}
                        ? (action_on_false => sub { $options->{action_on_align_false}->($type) })
                        : ()
                    ),
                }
            )
        );
    }

          $have_aligns
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_aligns
      and $options->{action_on_false}->();

    $have_aligns;
}

sub _have_member_define_name
{
    my $member    = $_[0];
    my $have_name = "HAVE_" . uc($member);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    $have_name;
}

=head2 check_member( member, \%options? )

Check whether I is in form of I.I and
I is a member of the I aggregate.

which are used prior to the aggregate under test.

  Config::AutoConf->check_member(
    "struct STRUCT_SV.sv_refcnt",
    {
      action_on_false => sub { Config::AutoConf->msg_failure( "sv_refcnt member required for struct STRUCT_SV" ); },
      prologue => "#include \n#include "
    }
  );

This function will return a true value (1) if the member is found.

If I aggregate has I member, preprocessor
macro HAVE_I_I (in all capitals, with spaces
and dots replaced by underscores) is defined.

This macro caches its result in the Caggr_member variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.

=cut

sub check_member
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $member) = @_;
    $self = $self->_get_instance();
    defined($member)   or return croak("No type to check for");
    ref($member) eq "" or return croak("No type to check for");

    $member =~ m/^([^.]+)\.([^.]+)$/ or return croak("check_member(\"struct foo.member\", \%options)");
    my $type = $1;
    $member = $2;

    my $cache_name = $self->_cache_type_name("$type.$member");
    my $check_sub  = sub {

        my $body = <
  static $type check_aggr;
  if( check_aggr.$member )
    return 0;
ACEOF
        my $conftest    = $self->lang_build_program($options->{prologue}, $body);
        my $have_member = $self->compile_if_else($conftest);

        unless ($have_member)
        {
            $body = <
  static $type check_aggr;
  if( sizeof check_aggr.$member )
    return 0;
ACEOF
            $conftest    = $self->lang_build_program($options->{prologue}, $body);
            $have_member = $self->compile_if_else($conftest);
        }

              $have_member
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and $options->{action_on_false}->()
          unless $have_member;

        $have_member;
    };

    $self->check_cached(
        $cache_name,
        "for $type.$member",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _have_member_define_name("$type.$member"),
                    $self->cache_val($cache_name),
                    "defined when $type.$member is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_member_define_name("$type.$member"), undef, "defined when $type.$member is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_members( members, \%options? )

For each member L is called to check for member of aggregate.

This function will return a true value (1) if at least one member is found.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be favored
over C (represented by L). If any of
I, I is defined, both callbacks
are passed to L as I or I to
C, respectively.
Given callbacks for I or I are
called for each symbol checked using L receiving the symbol as
first argument.

=cut

sub check_members
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $members) = @_;
    $self = $self->_get_instance();

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $have_members = 0;
    foreach my $member (@$members)
    {
        $have_members |= (
            $self->check_member(
                $member,
                {
                    %pass_options,
                    (
                        $options->{action_on_member_true} && "CODE" eq ref $options->{action_on_member_true}
                        ? (action_on_true => sub { $options->{action_on_member_true}->($member) })
                        : ()
                    ),
                    (
                        $options->{action_on_member_false} && "CODE" eq ref $options->{action_on_member_false}
                        ? (action_on_false => sub { $options->{action_on_member_false}->($member) })
                        : ()
                    ),
                }
            )
        );
    }

          $have_members
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_members
      and $options->{action_on_false}->();

    $have_members;
}

sub _have_header_define_name
{
    my $header    = $_[0];
    my $have_name = "HAVE_" . uc($header);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    return $have_name;
}

sub _check_header
{
    my $options = {};
    scalar @_ > 4 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $header, $prologue, $body) = @_;

    $prologue .= <<"_ACEOF";
    #include <$header>
_ACEOF
    my $conftest = $self->lang_build_program($prologue, $body);

    $self->compile_if_else($conftest, $options);
}

=head2 check_header( $header, \%options? )

This function is used to check if a specific header file is present in
the system: if we detect it and if we can compile anything with that
header included. Note that normally you want to check for a header
first, and then check for the corresponding library (not all at once).

The standard usage for this module is:

  Config::AutoConf->check_header("ncurses.h");

This function will return a true value (1) on success, and a false value
if the header is not present or not available for common usage.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
When a I exists in the optional hash at end, it will be prepended
to the tested header. If any of I,
I is defined, both callbacks are passed to
L as I or I to
C, respectively.

=cut

sub check_header
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $header) = @_;
    $self = $self->_get_instance();
    defined($header)   or return croak("No type to check for");
    ref($header) eq "" or return croak("No type to check for");

    return 0 unless $header;
    my $cache_name = $self->_cache_name($header);
    my $check_sub  = sub {
        my $prologue = defined $options->{prologue} ? $options->{prologue} : "";

        my $have_header = $self->_check_header(
            $header,
            $prologue,
            "",
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );

        $have_header;
    };

    $self->check_cached(
        $cache_name,
        "for $header",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _have_header_define_name($header),
                    $self->cache_val($cache_name),
                    "defined when $header is available"
                );
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_header_define_name($header), undef, "defined when $header is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 check_headers

This function uses check_header to check if a set of include files exist
in the system and can be included and compiled by the available compiler.
Returns the name of the first header file found.

Passes an optional \%options hash to each L call.

=cut

sub check_headers
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();
    $self->check_header($_, $options) and return $_ for (@_);
    return;
}

=head2 check_all_headers

This function checks each given header for usability and returns true
when each header can be used -- otherwise false.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
Each of existing key/value pairs using I, I
or I as key are passed-through to each call of
L.
Given callbacks for I or I are
called for each symbol checked using L receiving the symbol as
first argument.

=cut

sub check_all_headers
{
    my $options = {};
    scalar @_ > 2 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();
    @_ or return;

    my %pass_options;
    defined $options->{prologue}              and $pass_options{prologue}              = $options->{prologue};
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};

    my $all_headers = 1;
    foreach my $header (@_)
    {
        $all_headers &= $self->check_header(
            $header,
            {
                %pass_options,
                (
                    $options->{action_on_header_true} && "CODE" eq ref $options->{action_on_header_true}
                    ? (action_on_true => sub { $options->{action_on_header_true}->($header) })
                    : ()
                ),
                (
                    $options->{action_on_header_false} && "CODE" eq ref $options->{action_on_header_false}
                    ? (action_on_false => sub { $options->{action_on_header_false}->($header) })
                    : ()
                ),
            }
        );
    }

          $all_headers
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$all_headers
      and $options->{action_on_false}->();

    $all_headers;
}

=head2 check_stdc_headers

Checks for standard C89 headers, namely stdlib.h, stdarg.h, string.h and float.h.
If those are found, additional all remaining C89 headers are checked: assert.h,
ctype.h, errno.h, limits.h, locale.h, math.h, setjmp.h, signal.h, stddef.h,
stdio.h and time.h.

Returns a false value if it fails.

Passes an optional \%options hash to each L call.

=cut

my @ansi_c_headers = qw(stdlib stdarg string float assert ctype errno limits locale math setjmp signal stddef stdio time);

sub check_stdc_headers
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();

    # XXX for C++ the map should look like "c${_}" ...
    my @c_ansi_c_headers = map { "${_}.h" } @ansi_c_headers;
    my $rc               = $self->check_all_headers(@c_ansi_c_headers, $options);
    $rc and $self->define_var("STDC_HEADERS", 1, "Define to 1 if you have the ANSI C header files.");
    $rc;
}

=head2 check_default_headers

This function checks for some default headers, the std c89 headers and
sys/types.h, sys/stat.h, memory.h, strings.h, inttypes.h, stdint.h and unistd.h

Passes an optional \%options hash to each L call.

=cut

sub check_default_headers
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();
    $self->check_stdc_headers($options)
      and $self->check_all_headers(qw(sys/types.h sys/stat.h memory.h strings.h inttypes.h stdint.h unistd.h), $options);
}

=head2 check_dirent_header

Check for the following header files. For the first one that is found and
defines 'DIR', define the listed C preprocessor macro:

  dirent.h      HAVE_DIRENT_H
  sys/ndir.h    HAVE_SYS_NDIR_H
  sys/dir.h     HAVE_SYS_DIR_H
  ndir.h        HAVE_NDIR_H

The directory-library declarations in your source code should look
something like the following:

  #include
  #ifdef HAVE_DIRENT_H
  # include
  # define NAMLEN(dirent) strlen ((dirent)->d_name)
  #else
  # define dirent direct
  # define NAMLEN(dirent) ((dirent)->d_namlen)
  # ifdef HAVE_SYS_NDIR_H
  #  include
  # endif
  # ifdef HAVE_SYS_DIR_H
  #  include
  # endif
  # ifdef HAVE_NDIR_H
  #  include
  # endif
  #endif

Using the above declarations, the program would declare variables to be of
type C, not C, and would access the length
of a directory entry name by passing a pointer to a C to
the C macro.

For the found header, the macro HAVE_DIRENT_IN_${header} is defined.

This method might be obsolescent, as all current systems with directory
libraries have C<< Edirent.hE >>. Programs supporting only newer OS
might not need to use this method.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
Each of existing key/value pairs using I, I
(as I having the name of the tested header as first argument)
or I (as I having the name of the
tested header as first argument) as key are passed-through to each call of
L.
Given callbacks for I or I are
passed to the call of L.

=cut

sub _have_dirent_header_define_name
{
    my $header    = $_[0];
    my $have_name = "HAVE_DIRENT_IN_" . uc($header);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    return $have_name;
}

sub check_dirent_header
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();

    my %pass_options;
    defined $options->{prologue} and $pass_options{prologue} = $options->{prologue};

    my $have_dirent;
    foreach my $header (qw(dirent.h sys/ndir.h sys/dir.h ndir.h))
    {
        if ($self->check_header($header))
        {
            my $cache_name = $self->_cache_name("dirent", $header);
            my $check_sub  = sub {
                my $have_dirent;
                $have_dirent = $self->_check_header(
                    $header,
                    "#include \n",
                    "if ((DIR *) 0) { return 0; }",
                    {
                        %pass_options,
                        (
                            $options->{action_on_header_true} && "CODE" eq ref $options->{action_on_header_true}
                            ? (action_on_true => sub { $options->{action_on_header_true}->($header) })
                            : ()
                        ),
                        (
                            $options->{action_on_header_false} && "CODE" eq ref $options->{action_on_header_false}
                            ? (action_on_false => sub { $options->{action_on_header_false}->($header) })
                            : ()
                        ),
                    }
                );
            };

            $have_dirent = $self->check_cached(
                $cache_name,
                "for header defining DIR *",
                $check_sub,
                {
                    action_on_true => sub {
                        $self->define_var(
                            _have_dirent_header_define_name($header),
                            $self->cache_val($cache_name),
                            "defined when $header is available"
                        );
                        $options->{action_on_cache_true}
                          and ref $options->{action_on_cache_true} eq "CODE"
                          and $options->{action_on_cache_true}->();
                    },
                    action_on_false => sub {
                        $self->define_var(_have_dirent_header_define_name($header), undef, "defined when $header is available");
                        $options->{action_on_cache_false}
                          and ref $options->{action_on_cache_false} eq "CODE"
                          and $options->{action_on_cache_false}->();
                    },
                }
            );

            $have_dirent and $have_dirent = $header and last;
        }
    }

          $have_dirent
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and !$have_dirent
      and $options->{action_on_false}->();

    $have_dirent;
}

=head2 _check_perlapi_program

This method provides the program source which is suitable to do basic
compile/link tests to prove perl development environment.

=cut

sub _check_perlapi_program
{
    my $self = shift;

    my $includes        = $self->_default_includes_with_perl();
    my $perl_check_body = <<'EOB';
  I32 rc;
  SV *foo = newSVpv("Perl rocks", 11);
  rc = SvCUR(foo);
EOB
    $self->lang_build_program($includes, $perl_check_body);
}

=head2 _check_compile_perlapi

This method can be used from other checks to prove whether we have a perl
development environment or not (perl.h, reasonable basic checks - types, etc.)

=cut

sub _check_compile_perlapi
{
    my $self = shift;

    my $conftest = $self->_check_perlapi_program();
    $self->compile_if_else($conftest);
}

=head2 check_compile_perlapi

This method can be used from other checks to prove whether we have a perl
development environment or not (perl.h, reasonable basic checks - types, etc.)

=cut

sub check_compile_perlapi
{
    my $self       = shift->_get_instance;
    my $cache_name = $self->_cache_name(qw(compile perlapi));

    $self->check_cached($cache_name, "whether perlapi is accessible", sub { $self->_check_compile_perlapi });
}

=head2 check_compile_perlapi_or_die

Dies when not being able to compile using the Perl API

=cut

sub check_compile_perlapi_or_die
{
    my $self = shift;
    $self->check_compile_perlapi(@_) or $self->msg_error("Cannot use Perl API - giving up");
}

=head2 check_linkable_xs_so

Checks whether a dynamic loadable object containing an XS module can be
linked or not. Due the nature of the beast, this test currently always
succeed.

=cut

sub check_linkable_xs_so { 1 }

=head2 check_linkable_xs_so_or_die

Dies when L fails.

=cut

sub check_linkable_xs_so_or_die
{
    my $self = shift;
    $self->check_linkable_xs_so(@_) or $self->msg_error("Cannot link XS dynamic loadable - giving up");
}

=head2 check_loadable_xs_so

Checks whether a dynamic loadable object containing an XS module can be
loaded or not. Due the nature of the beast, this test currently always
succeed.

=cut

sub check_loadable_xs_so { 1 }

=head2 check_loadable_xs_so_or_die

Dies when L fails.

=cut

sub check_loadable_xs_so_or_die
{
    my $self = shift;
    $self->check_loadable_xs_so(@_) or $self->msg_error("Cannot load XS dynamic loadable - giving up");
}

=head2 _check_link_perlapi

This method can be used from other checks to prove whether we have a perl
development environment including a suitable libperl or not (perl.h,
reasonable basic checks - types, etc.)

Caller must ensure that the linker flags are set appropriate (C<-lperl>
or similar).

=cut

sub _check_link_perlapi
{
    my $self = shift;

    my $conftest              = $self->_check_perlapi_program();
    my @save_libs             = @{$self->{extra_libs}};
    my @save_extra_link_flags = @{$self->{extra_link_flags}};

    my $libperl = $Config{libperl};
    $libperl =~ s/^lib//;
    $libperl =~ s/\.[^\.]*$//;

    push @{$self->{extra_link_flags}}, "-L" . File::Spec->catdir($Config{installarchlib}, "CORE");
    push @{$self->{extra_libs}},       "$libperl";
    if ($Config{perllibs})
    {
        foreach my $perllib (split(" ", $Config{perllibs}))
        {
            $perllib =~ m/^\-l(\w+)$/ and push @{$self->{extra_libs}}, "$1" and next;
            push @{$self->{extra_link_flags}}, $perllib;
        }
    }

    my $have_libperl = $self->link_if_else($conftest);

    $have_libperl or $self->{extra_libs}       = [@save_libs];
    $have_libperl or $self->{extra_link_flags} = [@save_extra_link_flags];

    $have_libperl;
}

=head2 check_link_perlapi

This method can be used from other checks to prove whether we have a perl
development environment or not (perl.h, libperl.la, reasonable basic
checks - types, etc.)

=cut

sub check_link_perlapi
{
    my $self       = shift->_get_instance;
    my $cache_name = $self->_cache_name(qw(link perlapi));

    $self->check_cached($cache_name, "whether perlapi is linkable", sub { $self->_check_link_perlapi });
}

sub _have_lib_define_name
{
    my $lib       = $_[0];
    my $have_name = "HAVE_LIB" . uc($lib);
    $have_name =~ tr/_A-Za-z0-9/_/c;
    return $have_name;
}

=head2 check_lib( lib, func, @other-libs?, \%options? )

This function is used to check if a specific library includes some
function. Call it with the library name (without the lib portion), and
the name of the function you want to test:

  Config::AutoConf->check_lib("z", "gzopen");

It returns 1 if the function exist, 0 otherwise.

In case of function found, the HAVE_LIBlibrary (all in capitals)
preprocessor macro is defined with 1 and $lib together with @other_libs
are added to the list of libraries to link with.

If linking with library results in unresolved symbols that would be
resolved by linking with additional libraries, give those libraries
as the I argument: e.g., C<[qw(Xt X11)]>.
Otherwise, this routine may fail to detect that library is present,
because linking the test program can fail with unresolved symbols.
The other-libraries argument should be limited to cases where it is
desirable to test for one library in the presence of another that
is not already in LIBS.

This method caches its result in the Clib_func variable.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to C, respectively.

It's recommended to use L instead of check_lib these days.

=cut

sub check_lib
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();
    my ($lib, $func, @other_libs) = @_;

    return 0 unless $lib and $func;

    scalar(@other_libs) == 1
      and ref($other_libs[0]) eq "ARRAY"
      and @other_libs = @{$other_libs[0]};

    my $cache_name = $self->_cache_name("lib", $lib, $func);
    my $check_sub  = sub {
        my $conftest = $self->lang_call("", $func);

        my @save_libs = @{$self->{extra_libs}};
        push(@{$self->{extra_libs}}, $lib, @other_libs);
        my $have_lib = $self->link_if_else(
            $conftest,
            {
                ($options->{action_on_true}  ? (action_on_true  => $options->{action_on_true})  : ()),
                ($options->{action_on_false} ? (action_on_false => $options->{action_on_false}) : ())
            }
        );
        $self->{extra_libs} = [@save_libs];

        $have_lib;
    };

    $self->check_cached(
        $cache_name,
        "for $func in -l$lib",
        $check_sub,
        {
            action_on_true => sub {
                $self->define_var(
                    _have_lib_define_name($lib),
                    $self->cache_val($cache_name),
                    "defined when library $lib is available"
                );
                push(@{$self->{extra_libs}}, $lib, @other_libs);
                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            action_on_false => sub {
                $self->define_var(_have_lib_define_name($lib), undef, "defined when library $lib is available");
                $options->{action_on_cache_false}
                  and ref $options->{action_on_cache_false} eq "CODE"
                  and $options->{action_on_cache_false}->();
            },
        }
    );
}

=head2 search_libs( function, search-libs, @other-libs?, @extra_link_flags?, \%options? )

    Config::AutoConf->search_libs("gethostent", "nsl", [qw(socket net)], {
        action_on_true => sub { ... }
    });
    Config::AutoConf->search_libs("log4cplus_initialize", ["log4cplus"],
        [[qw(stdc++)], [qw(stdc++ unwind)]],
        [qw(-pthread -thread)]
    );

Search for a library defining function if it's not already available.
This equates to calling

    Config::AutoConf->link_if_else(
        Config::AutoConf->lang_call( "", "$function" ) );

first with no libraries, then for each library listed in search-libs.
I must be specified as an array reference to avoid
confusion in argument order.

Prepend -llibrary to LIBS for the first library found to contain function.

If linking with library results in unresolved symbols that would be
resolved by linking with additional libraries, give those libraries as
the I argument: e.g., C<[qw(Xt X11)]> or C<[qw(intl),
qw(intl iconv)]>. Otherwise, this method fails to detect that function
is present, because linking the test program always fails with unresolved
symbols.

The result of this test is cached in the ac_cv_search_function variable
as "none required" if function is already available, as C<0> if no
library containing function was found, otherwise as the -llibrary option
that needs to be prepended to LIBS.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to C, respectively.  Given callbacks
for I or I are called for
each library checked using L receiving the library as
first argument and all C<@other_libs> subsequently.

=cut

sub search_libs
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();
    my ($func, $libs, @other_libs, @other_link_flags) = @_;

    (defined($libs) and "ARRAY" eq ref($libs) and scalar(@{$libs}) > 0)
      or return 0;    # XXX would prefer croak
    return 0 unless $func;

    scalar(@other_libs) == 1
      and ref($other_libs[0]) eq "ARRAY"
      and @other_libs = @{$other_libs[0]};

    scalar(@other_link_flags) == 1
      and ref($other_link_flags[0]) eq "ARRAY"
      and @other_link_flags = @{$other_link_flags[0]};

    my $cache_name = $self->_cache_name("search", $func);
    my $check_sub  = sub {
        my $conftest = $self->lang_call("", $func);

        my @save_libs  = @{$self->{extra_libs}};
        my @save_extra = @{$self->{extra_link_flags}};
        my $have_lib   = 0;

        my $if_else_sub = sub {
            my ($libstest, @other) = @_;
            defined($libstest) and unshift(@{$self->{extra_libs}}, $libstest, @other);
            $self->link_if_else(
                $conftest,
                {
                    (
                        $options->{action_on_lib_true} && "CODE" eq ref $options->{action_on_lib_true}
                        ? (action_on_true => sub { $options->{action_on_lib_true}->($libstest, @other, @_) })
                        : ()
                    ),
                    (
                        $options->{action_on_lib_false} && "CODE" eq ref $options->{action_on_lib_false}
                        ? (action_on_false => sub { $options->{action_on_lib_false}->($libstest, @other, @_) })
                        : ()
                    ),
                }
            ) and ($have_lib = defined($libstest) ? $libstest : "none required");
        };

      LIBTEST:
        foreach my $libstest (undef, @$libs)
        {
            foreach my $linkextra (undef, @other_link_flags)
            {
                # XXX would local work on array refs? can we omit @save_libs?
                $self->{extra_libs}       = [@save_libs];
                $self->{extra_link_flags} = [@save_extra];
                if (defined $libstest and scalar(@other_libs) > 1 and ref($other_libs[0]) eq "ARRAY")
                {
                    foreach my $ol (@other_libs)
                    {
                        $if_else_sub->($libstest, @{$ol}) and last LIBTEST;
                    }
                }
                else
                {
                    $if_else_sub->($libstest, @other_libs) and last LIBTEST;
                }
            }
        }

        $self->{extra_libs} = [@save_libs];

              $have_lib
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and !$have_lib
          and $options->{action_on_false}->();

        $have_lib;
    };

    return $self->check_cached(
        $cache_name,
        "for library containing $func",
        $check_sub,
        {
            action_on_true => sub {
                $self->cache_val($cache_name) eq "none required"
                  or unshift(@{$self->{extra_libs}}, $self->cache_val($cache_name));

                $options->{action_on_cache_true}
                  and ref $options->{action_on_cache_true} eq "CODE"
                  and $options->{action_on_cache_true}->();
            },
            ($options->{action_on_cache_false} ? (action_on_false => $options->{action_on_cache_false}) : ())
        }
    );
}

sub _check_lm_funcs { qw(log2 pow log10 log exp sqrt) }

=head2 check_lm( \%options? )

This method is used to check if some common C functions are
available, and if C<-lm> is needed. Returns the empty string if no
library is needed, or the "-lm" string if libm is needed.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
Each of existing key/value pairs using I (as
I having the name of the tested functions as first argument),
I (as I having the name of the tested
functions as first argument), I (as
I having the name of the tested functions as first
argument), I (as I having
the name of the tested functions as first argument) as key are passed-
through to each call of L.
Given callbacks for I, I,
I or I are passed to the
call of L.

B that I and I or
I and I cannot be used
at the same time, respectively.

=cut

sub check_lm
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance();

    defined $options->{action_on_lib_true}
      and defined $options->{action_on_func_lib_true}
      and croak("action_on_lib_true and action_on_func_lib_true cannot be used together");
    defined $options->{action_on_lib_false}
      and defined $options->{action_on_func_lib_false}
      and croak("action_on_lib_false and action_on_func_lib_false cannot be used together");

    my %pass_options;
    defined $options->{action_on_cache_true}  and $pass_options{action_on_cache_true}  = $options->{action_on_cache_true};
    defined $options->{action_on_cache_false} and $pass_options{action_on_cache_false} = $options->{action_on_cache_false};
    defined $options->{action_on_lib_true}    and $pass_options{action_on_lib_true}    = $options->{action_on_lib_true};
    defined $options->{action_on_lib_false}   and $pass_options{action_on_lib_false}   = $options->{action_on_lib_false};

    my $fail       = 0;
    my $required   = "";
    my @math_funcs = $self->_check_lm_funcs;
    for my $func (@math_funcs)
    {
        my $ans = $self->search_libs(
            $func,
            ['m'],
            {
                %pass_options,
                (
                    $options->{action_on_func_true} && "CODE" eq ref $options->{action_on_func_true}
                    ? (action_on_true => sub { $options->{action_on_func_true}->($func, @_) })
                    : ()
                ),
                (
                    $options->{action_on_func_false} && "CODE" eq ref $options->{action_on_func_false}
                    ? (action_on_false => sub { $options->{action_on_func_false}->($func, @_) })
                    : ()
                ),
                (
                    $options->{action_on_func_lib_true} && "CODE" eq ref $options->{action_on_func_lib_true}
                    ? (action_on_lib_true => sub { $options->{action_on_func_lib_true}->($func, @_) })
                    : ()
                ),
                (
                    $options->{action_on_func_lib_false} && "CODE" eq ref $options->{action_on_func_lib_false}
                    ? (action_on_lib_false => sub { $options->{action_on_func_lib_false}->($func, @_) })
                    : ()
                ),
            },
        );

        $ans or $fail = 1;
        $ans ne "none required" and $required = $ans;
    }

         !$fail
      and $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

          $fail
      and $options->{action_on_false}
      and ref $options->{action_on_false} eq "CODE"
      and $options->{action_on_false}->();

    $required;
}

=head2 pkg_config_package_flags($package, \%options?)

  use Config::AutoConf

  my $c = Config::AutoConf->new;
  $c->pkg_config_package_flags('log4cplus');
  WriteMakefile(
    ...
    INC  => $c->_get_extra_compiler_flags,
    LIBS => $c->_get_extra_linker_flags,
  );

Search for C flags for package as specified. The flags which are
extracted are C<--cflags> and C<--libs>. The extracted flags are appended
to the global C, C or C,
respectively. Distinguishing between C and C
is essential to avoid conflicts with L
and family.  In case, no I matching given criteria
could be found, return a C value (C<0>).

The C flags are taken from I
C<< ${package}_CFLAGS >> or C<< ${package}_LIBS >> when defined, respectively.
It will be a nice touch to document the particular environment variables
for your build procedure - as for above example it should be

  $ env log4cplus_CFLAGS="-I/opt/coolapp/include" \
        log4cplus_LIBS="-L/opt/coolapp/lib -Wl,-R/opt/coolapp/lib -llog4cplus" \
    perl Makefile.PL

Call C with the package you're looking for and
optional callback whether found or not.

To support stage compiling properly (C vs. library file location),
the internal representation is a moving target. Do not use the result
directly - the getters L<_get_extra_compiler_flags|/_get_extra_compiler_flags>
and L<_get_extra_linker_flags|/_get_extra_linker_flags> are strongly
encouraged. In case this is not possible, please open a ticket to get
informed on invasive changes.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.
If any of I, I is defined,
both callbacks are passed to L as I or
I to L, respectively.

=cut

my $_pkg_config_prog;

sub _pkg_config_flag
{
    defined $_pkg_config_prog or croak("pkg_config_prog required");
    my @pkg_config_args = @_;
    my ($stdout, $stderr, $exit) =
      capture { system($_pkg_config_prog, @pkg_config_args); };
    chomp $stdout;
    0 == $exit and return $stdout;
    return $exit;
}

sub pkg_config_package_flags
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my ($self, $package) = @_;
    $self = $self->_get_instance();

    (my $pkgpfx = $package) =~ s/^(\w+).*?$/$1/;
    my $cache_name = $self->_cache_name("pkg", $pkgpfx);

    defined $_pkg_config_prog or $_pkg_config_prog = $self->{cache}->{$self->_cache_name("prog", "PKG_CONFIG")};
    defined $_pkg_config_prog or $_pkg_config_prog = $self->check_prog_pkg_config;
    my $check_sub = sub {
        my (@pkg_cflags, @pkg_libs);

        (my $ENV_CFLAGS = $package) =~ s/^(\w+).*?$/$1_CFLAGS/;
        (my $ENV_LIBS   = $package) =~ s/^(\w+).*?$/$1_LIBS/;

        my $pkg_exists = 0 + (
                 defined $ENV{$ENV_CFLAGS}
              or defined $ENV{$ENV_LIBS}
              or _pkg_config_flag($package, "--exists") eq ""
        );
        looks_like_number($pkg_exists) and $pkg_exists == 0 and return 0;

        my $CFLAGS =
          defined $ENV{$ENV_CFLAGS}
          ? $ENV{$ENV_CFLAGS}
          : _pkg_config_flag($package, "--cflags");
        $CFLAGS and not looks_like_number($CFLAGS) and @pkg_cflags = (
            map { $_ =~ s/^\s+//; $_ =~ s/\s+$//; Text::ParseWords::shellwords $_; }
              split(m/\n/, $CFLAGS)
        ) and push @{$self->{extra_preprocess_flags}}, @pkg_cflags;

        # do not separate between libs and extra (for now) - they come with -l prepended
        my $LIBS =
          defined $ENV{$ENV_LIBS}
          ? $ENV{$ENV_LIBS}
          : _pkg_config_flag($package, "--libs");
        $LIBS and not looks_like_number($LIBS) and @pkg_libs = (
            map { $_ =~ s/^\s+//; $_ =~ s/\s+$//; Text::ParseWords::shellwords $_; }
              split(m/\n/, $LIBS)
        );
        @pkg_libs and push @{$self->{extra_link_flags}}, grep { $_ !~ m/^-l/ } @pkg_libs;
        @pkg_libs and push @{$self->{extra_libs}}, map { (my $l = $_) =~ s/^-l//; $l } grep { $_ =~ m/^-l/ } @pkg_libs;

        my $pkg_config_flags = join(" ", @pkg_cflags, @pkg_libs);

              $pkg_config_flags
          and $options->{action_on_true}
          and ref $options->{action_on_true} eq "CODE"
          and $options->{action_on_true}->();

        $options->{action_on_false}
          and ref $options->{action_on_false} eq "CODE"
          and !$pkg_config_flags
          and $options->{action_on_false}->();

        $pkg_config_flags;
    };

    $self->check_cached(
        $cache_name,
        "for pkg-config package of $package",
        $check_sub,
        {
            ($options->{action_on_cache_true}  ? (action_on_true  => $options->{action_on_cache_true})  : ()),
            ($options->{action_on_cache_false} ? (action_on_false => $options->{action_on_cache_false}) : ())
        }
    );
}

=head2 _check_mm_pureperl_build_wanted

This method proves the C<_argv> attribute and (when set) the C
whether they contain I or not. The attribute C<_force_xs>
is set as appropriate, which allows a compile test to bail out when C
is called with I.

=cut

sub _check_mm_pureperl_build_wanted
{
    my $self = shift->_get_instance;

    defined $ENV{PERL_MM_OPT} and my @env_args = split " ", $ENV{PERL_MM_OPT};

    foreach my $arg (@{$self->{_argv}}, @env_args)
    {
        $arg =~ m/^PUREPERL_ONLY=(.*)$/ and return int($1);
    }

    0;
}

=head2 _check_mb_pureperl_build_wanted

This method proves the C<_argv> attribute and (when set) the C
whether they contain I<--pureperl-only> or not.

=cut

sub _check_mb_pureperl_build_wanted
{
    my $self = shift->_get_instance;

    defined $ENV{PERL_MB_OPT} and my @env_args = split " ", $ENV{PERL_MB_OPT};

    foreach my $arg (@{$self->{_argv}}, @env_args)
    {
        $arg eq "--pureperl-only" and return 1;
    }

    0;
}

=head2 _check_pureperl_required

This method calls C<_check_mm_pureperl_build_wanted> when running under
L (C) or C<_check_mb_pureperl_build_wanted>
when running under a C (L compatible) environment.

When neither is found (C<$0> contains neither C nor C),
simply 0 is returned.

=cut

sub _check_pureperl_required
{
    my $self = shift;
    $0 =~ m/Makefile\.PL$/i and return $self->_check_mm_pureperl_build_wanted(@_);
    $0 =~ m/Build\.PL$/i    and return $self->_check_mb_pureperl_build_wanted(@_);

    0;
}

=head2 check_pureperl_required

This check method proves whether a pure perl build is wanted or not by
cached-checking C<< $self->_check_pureperl_required >>.

=cut

sub check_pureperl_required
{
    my $self       = shift->_get_instance;
    my $cache_name = $self->_cache_name(qw(pureperl required));
    $self->check_cached($cache_name, "whether pureperl is required", sub { $self->_check_pureperl_required });
}

=head2 check_produce_xs_build

This routine checks whether XS can be produced. Therefore it does
following checks in given order:

=over 4

=item *

check pure perl environment variables (L) or
command line arguments and return false when pure perl is requested

=item *

check whether a compiler is available (L) and
return false if none found

=item *

check whether a test program accessing Perl API can be compiled and
die with error if not

=back

When all checks passed successfully, return a true value.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.

=cut

sub check_produce_xs_build
{
    my $options = {};
    scalar @_ > 1 and ref $_[-1] eq "HASH" and $options = pop @_;
    my $self = shift->_get_instance;
    $self->check_pureperl_required() and return _on_return_callback_helper(0, $options, "action_on_false");
    eval { $self->check_valid_compilers($_[0] || [qw(C)]) }
      or return _on_return_callback_helper(0, $options, "action_on_false");
    # XXX necessary check for $Config{useshrlib}? (need to dicuss with e.g. TuX, 99% likely return 0)
    $self->check_compile_perlapi_or_die();

    $options->{action_on_true}
      and ref $options->{action_on_true} eq "CODE"
      and $options->{action_on_true}->();

    return 1;
}

=head2 check_produce_loadable_xs_build

This routine proves whether XS should be built and it's possible to create
a dynamic linked object which can be loaded using Perl's Dynaloader.

The extension over L can be avoided by adding the
C to C<$ENV{PERL5_AC_OPTS}>.

If the very last parameter contains a hash reference, C references
to I or I are executed, respectively.

=cut

sub check_produce_loadable_xs_build
{
    my $self = shift->_get_instance;
    $self->check_produce_xs_build(@_)
      and !$self->{c_ac_flags}->{notest_loadable_xs}
      and $self->check_linkable_xs_so_or_die
      and $self->check_loadable_xs_so_or_die;
}

#
#
# Auxiliary funcs
#

=head2 _set_argv

Intended to act as a helper for evaluating given command line arguments.
Stores given arguments in instances C<_argv> attribute.

Call once at very begin of C or C:

  Your::Pkg::Config::AutoConf->_set_args(@ARGV);

=cut

sub _set_argv
{
    my ($self, @argv) = @_;
    $self = $self->_get_instance;
    $self->{_argv} = \@argv;
    return;
}

sub _sanitize
{
    # This is hard coded, and maybe a little stupid...
    my $x = shift;
    $x =~ s/ //g;
    $x =~ s/\///g;
    $x =~ s/\\//g;
    $x;
}

sub _get_instance
{
    ref $_[0] and return $_[0];
    defined $glob_instance or $glob_instance = $_[0]->new();
    $glob_instance;
}

sub _get_builder
{
    my $self = $_[0]->_get_instance();

    ref $self->{lang_supported}->{$self->{lang}} eq "CODE" and $self->{lang_supported}->{$self->{lang}}->($self);
    defined($self->{lang_supported}->{$self->{lang}}) or croak("Unsupported compile language \"" . $self->{lang} . "\"");

    $self->{lang_supported}->{$self->{lang}}->new();
}

sub _set_language
{
    my $self = shift->_get_instance();
    my ($lang, $impl) = @_;

    defined($lang) or croak("Missing language");

          defined($impl)
      and defined($self->{lang_supported}->{$lang})
      and $impl ne $self->{lang_supported}->{$lang}
      and croak("Language implementor ($impl) doesn't match exisiting one (" . $self->{lang_supported}->{$lang} . ")");

    defined($impl)
      and !defined($self->{lang_supported}->{$lang})
      and $self->{lang_supported}->{$lang} = $impl;

    ref $self->{lang_supported}->{$lang} eq "CODE" and $self->{lang_supported}->{$lang}->($self);
    defined($self->{lang_supported}->{$lang}) or croak("Unsupported language \"$lang\"");

    defined($self->{extra_compile_flags}->{$lang}) or $self->{extra_compile_flags}->{$lang} = [];

    $self->{lang} = $lang;

    return;
}

sub _on_return_callback_helper
{
    my $callback = pop @_;
    my $options  = pop @_;
    $options->{$callback}
      and ref $options->{$callback} eq "CODE"
      and $options->{$callback}->();
    @_ and wantarray and return @_;
    1 == scalar @_ and return $_[0];
    return;
}

sub _fill_defines
{
    my ($self, $src, $action_if_true, $action_if_false) = @_;
    ref $self or $self = $self->_get_instance();

    my $conftest = "";
    while (my ($defname, $defcnt) = each(%{$self->{defines}}))
    {
        $defcnt->[0] or next;
        defined $defcnt->[1] and $conftest .= "/* " . $defcnt->[1] . " */\n";
        $conftest .= join(" ", "#define", $defname, $defcnt->[0]) . "\n";
    }
    $conftest .= "/* end of conftest.h */\n";

    $conftest;
}

#
# default includes taken from autoconf/headers.m4
#

=head2 _default_includes

returns a string containing default includes for program prologue taken
from C:

  #include
  #ifdef HAVE_SYS_TYPES_H
  # include
  #endif
  #ifdef HAVE_SYS_STAT_H
  # include
  #endif
  #ifdef STDC_HEADERS
  # include
  # include
  #else
  # ifdef HAVE_STDLIB_H
  #  include
  # endif
  #endif
  #ifdef HAVE_STRING_H
  # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
  #  include
  # endif
  # include
  #endif
  #ifdef HAVE_STRINGS_H
  # include
  #endif
  #ifdef HAVE_INTTYPES_H
  # include
  #endif
  #ifdef HAVE_STDINT_H
  # include
  #endif
  #ifdef HAVE_UNISTD_H
  # include
  #endif

=cut

my $_default_includes = <<"_ACEOF";
#include
#ifdef HAVE_SYS_TYPES_H
# include
#endif
#ifdef HAVE_SYS_STAT_H
# include
#endif
#ifdef STDC_HEADERS
# include
# include
#else
# ifdef HAVE_STDLIB_H
#  include
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
#  include
# endif
# include
#endif
#ifdef HAVE_STRINGS_H
# include
#endif
#ifdef HAVE_INTTYPES_H
# include
#endif
#ifdef HAVE_STDINT_H
# include
#endif
#ifdef HAVE_UNISTD_H
# include
#endif
_ACEOF

sub _default_includes { $_default_includes }

sub _default_main { $_[0]->_build_main("") }

my $_main_tpl = <<"_ACEOF";
  int
  main ()
  {
    %s;
    return 0;
  }
_ACEOF

sub _build_main
{
    my $self = shift->_get_instance();
    my $body = shift || "";
    sprintf($_main_tpl, $body);
}

=head2 _default_includes_with_perl

returns a string containing default includes for program prologue containing
I<_default_includes> plus

  #include
  #include

=cut

my $_include_perl = <<"_ACEOF";
#include
#include
#include  /* for perl context in threaded perls */
_ACEOF

sub _default_includes_with_perl
{
    join("\n", $_[0]->_default_includes, $_include_perl);
}

sub _cache_prefix { "ac" }

sub _cache_name
{
    my ($self, @names) = @_;
    my $cache_name = join("_", $self->_cache_prefix(), "cv", @names);
    $cache_name =~ tr/_A-Za-z0-9/_/c;
    $cache_name;
}

sub _get_log_fh
{
    my $self = $_[0]->_get_instance();
    unless (defined($self->{logfh}))
    {
        my $open_mode = defined $self->{logfile_mode} ? $self->{logfile_mode} : ">";
        open(my $fh, $open_mode, $self->{logfile}) or croak "Could not open file $self->{logfile}: $!";
        $self->{logfh} = [$fh];
    }

    $self->{logfh};
}

sub _add_log_entry
{
    my ($self, @logentries) = @_;
    ref($self) or $self = $self->_get_instance();
    $self->_get_log_fh();
    foreach my $logentry (@logentries)
    {
        foreach my $fh (@{$self->{logfh}})
        {
            print {$fh} "$logentry";
        }
    }

    return;
}

sub _add_log_lines
{
    my ($self, @logentries) = @_;
    ref($self) or $self = $self->_get_instance();
    $self->_get_log_fh();
    my $logmsg = join("\n", @logentries) . "\n";
    foreach my $fh (@{$self->{logfh}})
    {
        print {$fh} $logmsg;
    }

    return;
}

=head2 add_log_fh

Push new file handles at end of log-handles to allow tee'ing log-output

=cut

sub add_log_fh
{
    my ($self, @newh) = @_;
    $self->_get_log_fh();
  SKIP_DUP:
    foreach my $fh (@newh)
    {
        foreach my $eh (@{$self->{logfh}})
        {
            $fh == $eh and next SKIP_DUP;
        }
        push @{$self->{logfh}}, $fh;
    }
    return;
}

=head2 delete_log_fh

Removes specified log file handles. This method allows you to shoot
yourself in the foot - it doesn't prove whether the primary nor the last handle
is removed. Use with caution.

=cut

sub delete_log_fh
{
    my ($self, @xh) = @_;
    $self->_get_log_fh();
  SKIP_DUP:
    foreach my $fh (@xh)
    {
        foreach my $ih (0 .. $#{$self->{logfh}})
        {
            $fh == $self->{logfh}->[$ih] or next;
            splice @{$self->{logfh}}, $ih, 1;
            last;
        }
    }
    return;
}

sub _cache_type_name
{
    my ($self, @names) = @_;
    $self->_cache_name(map { $_ =~ tr/*/p/; $_ } @names);
}

=head2 _get_extra_compiler_flags

Returns the determined flags required to run the compile stage as string

=cut

sub _get_extra_compiler_flags
{
    my $self    = shift->_get_instance();
    my @ppflags = @{$self->{extra_preprocess_flags}};
    my @cflags  = @{$self->{extra_compile_flags}->{$self->{lang}}};
    join(" ", map { _quote_shell_arg $_ } (@ppflags, @cflags));
}

=head2 _get_extra_linker_flags

Returns the determined flags required to run the link stage as string

=cut

sub _get_extra_linker_flags
{
    my $self     = shift->_get_instance();
    my @libs     = @{$self->{extra_libs}};
    my @lib_dirs = @{$self->{extra_lib_dirs}};
    my @ldflags  = @{$self->{extra_link_flags}};
    join(" ", map { _quote_shell_arg $_ } (@ldflags, map("-L" . $self->_sanitize_prog($_), @lib_dirs), map("-l$_", @libs)));
}

=head1 AUTHOR

Alberto Simões, C<<  >>

Jens Rehsack, C<<  >>

=head1 NEXT STEPS

Although a lot of work needs to be done, these are the next steps I
intend to take.

  - detect flex/lex
  - detect yacc/bison/byacc
  - detect ranlib (not sure about its importance)

These are the ones I think not too much important, and will be
addressed later, or by request.

  - detect an 'install' command
  - detect a 'ln -s' command -- there should be a module doing
    this kind of task.

=head1 BUGS

A lot. Portability is a pain. B<>.

Please report any bugs or feature requests to
C, or through the web interface at
L.  We will
be notified, and then you'll automatically be notified of progress
on your bug as we make changes.

=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Config::AutoConf

You can also look for information at:

=over 4

=item * AnnoCPAN: Annotated CPAN documentation

L

=item * CPAN Ratings

L

=item * MetaCPAN

L

=item * Git Repository

L

=back

=head1 ACKNOWLEDGEMENTS

Michael Schwern for kind MacOS X help.

Ken Williams for ExtUtils::CBuilder

Peter Rabbitson for help on refactoring and making the API more Perl'ish

=head1 COPYRIGHT & LICENSE

Copyright 2004-2020 by the Authors

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=head1 SEE ALSO

ExtUtils::CBuilder(3)

=cut

1;    # End of Config::AutoConf