configure

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_char" >&5
$as_echo "$ac_cv_sizeof_char" >&6; }



cat >>confdefs.h <<_ACEOF
#define SIZEOF_CHAR $ac_cv_sizeof_char
_ACEOF


# The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
$as_echo_n "checking size of int... " >&6; }
if ${ac_cv_sizeof_int+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :

else
  if test "$ac_cv_type_int" = yes; then
     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "cannot compute sizeof (int)
See \`config.log' for more details" "$LINENO" 5; }
   else
     ac_cv_sizeof_int=0
   fi
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
$as_echo "$ac_cv_sizeof_int" >&6; }



cat >>confdefs.h <<_ACEOF
#define SIZEOF_INT $ac_cv_sizeof_int
_ACEOF


# The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
$as_echo_n "checking size of long... " >&6; }
if ${ac_cv_sizeof_long+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :

else
  if test "$ac_cv_type_long" = yes; then
     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "cannot compute sizeof (long)
See \`config.log' for more details" "$LINENO" 5; }
   else
     ac_cv_sizeof_long=0
   fi
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
$as_echo "$ac_cv_sizeof_long" >&6; }



cat >>confdefs.h <<_ACEOF
#define SIZEOF_LONG $ac_cv_sizeof_long
_ACEOF


# The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
$as_echo_n "checking size of short... " >&6; }
if ${ac_cv_sizeof_short+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :

else
  if test "$ac_cv_type_short" = yes; then
     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "cannot compute sizeof (short)
See \`config.log' for more details" "$LINENO" 5; }
   else
     ac_cv_sizeof_short=0
   fi
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
$as_echo "$ac_cv_sizeof_short" >&6; }



cat >>confdefs.h <<_ACEOF
#define SIZEOF_SHORT $ac_cv_sizeof_short
_ACEOF


# The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5
$as_echo_n "checking size of long long... " >&6; }
if ${ac_cv_sizeof_long_long+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long long))" "ac_cv_sizeof_long_long"        "$ac_includes_default"; then :

else
  if test "$ac_cv_type_long_long" = yes; then
     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "cannot compute sizeof (long long)
See \`config.log' for more details" "$LINENO" 5; }
   else
     ac_cv_sizeof_long_long=0
   fi
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long" >&5
$as_echo "$ac_cv_sizeof_long_long" >&6; }



cat >>confdefs.h <<_ACEOF
#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
_ACEOF



if test "$ac_cv_sizeof_short" = "2"; then
    short_value=short
fi
if test "$ac_cv_sizeof_int" = "4"; then
    int_value=int
fi
# Now we need to find what apr_int64_t (sizeof == 8) will be.
# The first match is our preference.
if test "$ac_cv_sizeof_int" = "8"; then
    int64_literal='#define APR_INT64_C(val) (val)'
    uint64_literal='#define APR_UINT64_C(val) (val##U)'
    int64_t_fmt='#define APR_INT64_T_FMT "d"'
    uint64_t_fmt='#define APR_UINT64_T_FMT "u"'
    uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "x"'
    int64_value="int"
    long_value=int
    int64_strfn="strtoi"
elif test "$ac_cv_sizeof_long" = "8"; then
    int64_literal='#define APR_INT64_C(val) (val##L)'
    uint64_literal='#define APR_UINT64_C(val) (val##UL)'
    int64_t_fmt='#define APR_INT64_T_FMT "ld"'
    uint64_t_fmt='#define APR_UINT64_T_FMT "lu"'
    uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "lx"'
    int64_value="long"
    long_value=long
    int64_strfn="strtol"
elif test "$ac_cv_sizeof_long_long" = "8"; then
    int64_literal='#define APR_INT64_C(val) (val##LL)'
    uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
    # Linux, Solaris, FreeBSD all support ll with printf.
    # BSD 4.4 originated 'q'.  Solaris is more popular and
    # doesn't support 'q'.  Solaris wins.  Exceptions can
    # go to the OS-dependent section.
    int64_t_fmt='#define APR_INT64_T_FMT "lld"'
    uint64_t_fmt='#define APR_UINT64_T_FMT "llu"'
    uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "llx"'
    int64_value="long long"
    long_value="long long"
    int64_strfn="strtoll"
elif test "$ac_cv_sizeof_longlong" = "8"; then
    int64_literal='#define APR_INT64_C(val) (val##LL)'
    uint64_literal='#define APR_UINT64_C(val) (val##ULL)'
    int64_t_fmt='#define APR_INT64_T_FMT "qd"'
    uint64_t_fmt='#define APR_UINT64_T_FMT "qu"'
    uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "qx"'
    int64_value="__int64"
    long_value="__int64"
    int64_strfn="strtoll"
else
    # int64_literal may be overriden if your compiler thinks you have
    # a 64-bit value but APR does not agree.
    as_fn_error $? "could not detect a 64-bit integer type" "$LINENO" 5
fi

# If present, allow the C99 macro INT64_C to override our conversion.
#
# HP-UX's ANSI C compiler provides this without any includes, so we
# will first look for INT64_C without adding stdint.h
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for INT64_C" >&5
$as_echo_n "checking for INT64_C... " >&6; }
if ${apr_cv_define_INT64_C+:} false; then :
  $as_echo_n "(cached) " >&6
else

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef INT64_C
YES_IS_DEFINED
#endif
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "YES_IS_DEFINED" >/dev/null 2>&1; then :
  apr_cv_define_INT64_C=yes
else

    # Now check for INT64_C in stdint.h
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdint.h>
#ifdef INT64_C
YES_IS_DEFINED
#endif
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "YES_IS_DEFINED" >/dev/null 2>&1; then :
  apr_cv_define_INT64_C=yes
else
  apr_cv_define_INT64_C=no
fi
rm -f conftest*

fi
rm -f conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $apr_cv_define_INT64_C" >&5
$as_echo "$apr_cv_define_INT64_C" >&6; }

if test "$apr_cv_define_INT64_C" = "yes"; then
    int64_literal='#define APR_INT64_C(val) INT64_C(val)'
    uint64_literal='#define APR_UINT64_C(val) UINT64_C(val)'
    stdint=1
else
    stdint=0
fi

if test "$ac_cv_type_size_t" = "yes"; then
    size_t_value="size_t"
else
    size_t_value="apr_int32_t"
fi
if test "$ac_cv_type_ssize_t" = "yes"; then
    ssize_t_value="ssize_t"
else
    ssize_t_value="apr_int32_t"
fi
if test "$ac_cv_socklen_t" = "yes"; then
    socklen_t_value="socklen_t"
    case $host in
        *-hp-hpux*)
            if test "$ac_cv_sizeof_long" = "8"; then
                # 64-bit HP-UX requires 32-bit socklens in
                # kernel, but user-space declarations say
                # 64-bit (socklen_t == size_t == long).
                # This will result in many compile warnings,
                # but we're functionally busted otherwise.
                socklen_t_value="int"
            fi
            ;;
    esac
else
    socklen_t_value="int"
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of pid_t" >&5
$as_echo_n "checking size of pid_t... " >&6; }
if ${ac_cv_sizeof_pid_t+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_sizeof_pid_t=8
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
#include <sys/types.h>
#ifdef WIN32
#define binmode "b"
#else
#define binmode
#endif
main()
{
  FILE *f=fopen("conftestval", "w" binmode);
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(pid_t));
  exit(0);
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_sizeof_pid_t=`cat conftestval`
else
  ac_cv_sizeof_pid_t=0
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_pid_t" >&5
$as_echo "$ac_cv_sizeof_pid_t" >&6; }

cat >>confdefs.h <<_ACEOF
#define SIZEOF_PID_T $ac_cv_sizeof_pid_t
_ACEOF



if test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_short"; then
    pid_t_fmt='#define APR_PID_T_FMT "hd"'
elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_int"; then
    pid_t_fmt='#define APR_PID_T_FMT "d"'
elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long"; then
    pid_t_fmt='#define APR_PID_T_FMT "ld"'
elif test "$ac_cv_sizeof_pid_t" = "$ac_cv_sizeof_long_long"; then
    pid_t_fmt='#define APR_PID_T_FMT APR_INT64_T_FMT'
else
    pid_t_fmt='#error Can not determine the proper size for pid_t'
fi

# Basically, we have tried to figure out the correct format strings
# for APR types which vary between platforms, but we don't always get
# it right.
case $host in
   s390*linux*)
       # uniquely, the 31-bit Linux/s390 uses "unsigned long int"
       # for size_t rather than "unsigned int":
       size_t_fmt="lu"
       ssize_t_fmt="ld"
       ;;
   *-os2*)
       size_t_fmt="lu"
       ;;
   *-solaris*)
       if test "$ac_cv_sizeof_long" = "8"; then
         pid_t_fmt='#define APR_PID_T_FMT "d"'
       else
         pid_t_fmt='#define APR_PID_T_FMT "ld"'
       fi
       ;;
   *aix4*|*aix5*)
       ssize_t_fmt="ld"
       size_t_fmt="lu"
       ;;
    *beos*)
        ssize_t_fmt="ld"
        size_t_fmt="ld"
        ;;
    *apple-darwin*)
        osver=`uname -r`
        case $osver in
           [0-7].*)
              ssize_t_fmt="d"
              ;;
           *)
              ssize_t_fmt="ld"
              ;;
        esac
        size_t_fmt="lu"
        ;;
    *-mingw*)
        int64_t_fmt='#define APR_INT64_T_FMT "I64d"'
        uint64_t_fmt='#define APR_UINT64_T_FMT "I64u"'
        uint64_t_hex_fmt='#define APR_UINT64_T_HEX_FMT "I64x"'
        int64_value="__int64"
        long_value="__int64"
        int64_strfn="_strtoi64"
        ;;
esac



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ssize_t and int are the same" >&5
$as_echo_n "checking whether ssize_t and int are the same... " >&6; }
if ${apr_cv_typematch_ssize_t_int+:} false; then :
  $as_echo_n "(cached) " >&6
else

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

    int foo[0 - !__builtin_types_compatible_p(ssize_t, int)];

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  apr_cv_typematch_ssize_t_int=yes
ssize_t_fmt="d"
else
  apr_cv_typematch_ssize_t_int=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $apr_cv_typematch_ssize_t_int" >&5
$as_echo "$apr_cv_typematch_ssize_t_int" >&6; }



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ssize_t and long are the same" >&5
$as_echo_n "checking whether ssize_t and long are the same... " >&6; }
if ${apr_cv_typematch_ssize_t_long+:} false; then :
  $as_echo_n "(cached) " >&6
else

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

    int foo[0 - !__builtin_types_compatible_p(ssize_t, long)];

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  apr_cv_typematch_ssize_t_long=yes
ssize_t_fmt="ld"
else
  apr_cv_typematch_ssize_t_long=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $apr_cv_typematch_ssize_t_long" >&5
$as_echo "$apr_cv_typematch_ssize_t_long" >&6; }



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether size_t and unsigned int are the same" >&5
$as_echo_n "checking whether size_t and unsigned int are the same... " >&6; }
if ${apr_cv_typematch_size_t_unsigned_int+:} false; then :
  $as_echo_n "(cached) " >&6
else

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

    int foo[0 - !__builtin_types_compatible_p(size_t, unsigned int)];

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  apr_cv_typematch_size_t_unsigned_int=yes
size_t_fmt="u"
else
  apr_cv_typematch_size_t_unsigned_int=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $apr_cv_typematch_size_t_unsigned_int" >&5
$as_echo "$apr_cv_typematch_size_t_unsigned_int" >&6; }



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether size_t and unsigned long are the same" >&5
$as_echo_n "checking whether size_t and unsigned long are the same... " >&6; }
if ${apr_cv_typematch_size_t_unsigned_long+:} false; then :
  $as_echo_n "(cached) " >&6
else

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{

    int foo[0 - !__builtin_types_compatible_p(size_t, unsigned long)];

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  apr_cv_typematch_size_t_unsigned_long=yes
size_t_fmt="lu"
else
  apr_cv_typematch_size_t_unsigned_long=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $apr_cv_typematch_size_t_unsigned_long" >&5
$as_echo "$apr_cv_typematch_size_t_unsigned_long" >&6; }


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of ssize_t" >&5
$as_echo_n "checking size of ssize_t... " >&6; }
if ${ac_cv_sizeof_ssize_t+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_sizeof_ssize_t=8
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
#include <sys/types.h>
#ifdef WIN32
#define binmode "b"
#else
#define binmode
#endif
main()
{
  FILE *f=fopen("conftestval", "w" binmode);
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(ssize_t));
  exit(0);
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_sizeof_ssize_t=`cat conftestval`
else
  ac_cv_sizeof_ssize_t=0
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_ssize_t" >&5
$as_echo "$ac_cv_sizeof_ssize_t" >&6; }

cat >>confdefs.h <<_ACEOF
#define SIZEOF_SSIZE_T $ac_cv_sizeof_ssize_t
_ACEOF



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which format to use for apr_ssize_t" >&5
$as_echo_n "checking which format to use for apr_ssize_t... " >&6; }
if test -n "$ssize_t_fmt"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %$ssize_t_fmt" >&5
$as_echo "%$ssize_t_fmt" >&6; }
elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_int"; then
    ssize_t_fmt="d"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %d" >&5
$as_echo "%d" >&6; }
elif test "$ac_cv_sizeof_ssize_t" = "$ac_cv_sizeof_long"; then
    ssize_t_fmt="ld"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %ld" >&5
$as_echo "%ld" >&6; }
else
    as_fn_error $? "could not determine the proper format for apr_ssize_t" "$LINENO" 5
fi

ssize_t_fmt="#define APR_SSIZE_T_FMT \"$ssize_t_fmt\""

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of size_t" >&5
$as_echo_n "checking size of size_t... " >&6; }
if ${ac_cv_sizeof_size_t+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_sizeof_size_t=8
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
#include <stddef.h>
#ifdef WIN32
#define binmode "b"
#else
#define binmode
#endif
main()
{
  FILE *f=fopen("conftestval", "w" binmode);
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(size_t));
  exit(0);
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_sizeof_size_t=`cat conftestval`
else
  ac_cv_sizeof_size_t=0
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_size_t" >&5
$as_echo "$ac_cv_sizeof_size_t" >&6; }

cat >>confdefs.h <<_ACEOF
#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t
_ACEOF



{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which format to use for apr_size_t" >&5
$as_echo_n "checking which format to use for apr_size_t... " >&6; }
if test -n "$size_t_fmt"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %$size_t_fmt" >&5
$as_echo "%$size_t_fmt" >&6; }
elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_int"; then
    size_t_fmt="d"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %d" >&5
$as_echo "%d" >&6; }
elif test "$ac_cv_sizeof_size_t" = "$ac_cv_sizeof_long"; then
    size_t_fmt="ld"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: %ld" >&5
$as_echo "%ld" >&6; }
else
    as_fn_error $? "could not determine the proper format for apr_size_t" "$LINENO" 5
fi

size_t_fmt="#define APR_SIZE_T_FMT \"$size_t_fmt\""

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of off_t" >&5
$as_echo_n "checking size of off_t... " >&6; }
if ${ac_cv_sizeof_off_t+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_sizeof_off_t=8
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
#include <sys/types.h>
#ifdef WIN32
#define binmode "b"
#else
#define binmode
#endif
main()
{
  FILE *f=fopen("conftestval", "w" binmode);
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(off_t));
  exit(0);
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_sizeof_off_t=`cat conftestval`
else
  ac_cv_sizeof_off_t=0
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_off_t" >&5
$as_echo "$ac_cv_sizeof_off_t" >&6; }

cat >>confdefs.h <<_ACEOF
#define SIZEOF_OFF_T $ac_cv_sizeof_off_t
_ACEOF



if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then
    # Enable LFS
    aprlfs=1
    for ac_func in mmap64 sendfile64 sendfilev64 readdir64_r
do :
  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
_ACEOF

fi
done

    case $host in
        *-hp-hpux*)
                        ;;
        *)
            for ac_func in mkstemp64
do :
  ac_fn_c_check_func "$LINENO" "mkstemp64" "ac_cv_func_mkstemp64"
if test "x$ac_cv_func_mkstemp64" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_MKSTEMP64 1
_ACEOF

fi
done

            ;;
    esac
elif test "${ac_cv_sizeof_off_t}" != "${ac_cv_sizeof_size_t}"; then
    # unsure of using -gt above is as portable, can can't forsee where
    # off_t can legitimately be smaller than size_t
    aprlfs=1
else
    aprlfs=0
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which type to use for apr_off_t" >&5
$as_echo_n "checking which type to use for apr_off_t... " >&6; }
if test "${ac_cv_sizeof_off_t}${apr_cv_use_lfs64}" = "4yes"; then
    # LFS is go!
    off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT'
    off_t_value='off64_t'
    off_t_strfn='apr_strtoi64'
elif test "${ac_cv_sizeof_off_t}x${ac_cv_sizeof_long}" = "4x4"; then
    # Special case: off_t may change size with _FILE_OFFSET_BITS
    # on 32-bit systems with LFS support.  To avoid compatibility
    # issues when other packages do define _FILE_OFFSET_BITS,
    # hard-code apr_off_t to long.
    off_t_value=long
    off_t_fmt='#define APR_OFF_T_FMT "ld"'
    off_t_strfn='strtol'
elif test "$ac_cv_type_off_t" = "yes"; then
    off_t_value=off_t
    # off_t is more commonly a long than an int; prefer that case
    # where int and long are the same size.
    if test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long"; then
        off_t_fmt='#define APR_OFF_T_FMT "ld"'
        off_t_strfn='strtol'
    elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_int"; then
        off_t_fmt='#define APR_OFF_T_FMT "d"'
        off_t_strfn='strtoi'
    elif test "$ac_cv_sizeof_off_t" = "$ac_cv_sizeof_long_long"; then
        off_t_fmt='#define APR_OFF_T_FMT APR_INT64_T_FMT'
        off_t_strfn='apr_strtoi64'
    else
        as_fn_error $? "could not determine the size of off_t" "$LINENO" 5
    fi
    # Per OS tuning...
    case $host in
    *-mingw*)
        off_t_value=apr_int64_t
        off_t_fmt='#define APR_OFF_T_FMT "I64d"'
        off_t_strfn='_strtoi64'
        ;;
    esac
else
   # Fallback on int
   off_t_value=apr_int32_t
   off_t_fmt=d
   off_t_strfn='strtoi'
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $off_t_value" >&5
$as_echo "$off_t_value" >&6; }

# Regardless of whether _LARGEFILE64_SOURCE is used, on some
# platforms _FILE_OFFSET_BITS will affect the size of ino_t and hence
# the build-time ABI may be different from the apparent ABI when using
# APR with another package which *does* define _FILE_OFFSET_BITS.
# (Exactly as per the case above with off_t where LFS is *not* used)
#
# To be safe, hard-code apr_ino_t as 'unsigned long' or 'unsigned int'
# iff that is exactly the size of ino_t here; otherwise use ino_t as existing
# releases did.  To be correct, apr_ino_t should have been made an
# ino64_t as apr_off_t is off64_t, but this can't be done now without
# breaking ABI.

# Per OS tuning...
case $host in
*mingw*)
    ino_t_value=apr_int64_t
    ;;
*)
    ino_t_value=ino_t
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of ino_t" >&5
$as_echo_n "checking size of ino_t... " >&6; }
if ${ac_cv_sizeof_ino_t+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "$cross_compiling" = yes; then :
  ac_cv_sizeof_ino_t=$ac_cv_sizeof_long
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
$ac_includes_default
#ifdef WIN32
#define binmode "b"
#else
#define binmode
#endif
main()
{
  FILE *f=fopen("conftestval", "w" binmode);
  if (!f) exit(1);
  fprintf(f, "%d\n", sizeof(ino_t));
  exit(0);
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
  ac_cv_sizeof_ino_t=`cat conftestval`
else
  ac_cv_sizeof_ino_t=0
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_ino_t" >&5
$as_echo "$ac_cv_sizeof_ino_t" >&6; }

cat >>confdefs.h <<_ACEOF
#define SIZEOF_INO_T $ac_cv_sizeof_ino_t
_ACEOF


    if test $ac_cv_sizeof_ino_t = 4; then
        if test $ac_cv_sizeof_long = 4; then
            ino_t_value="unsigned long"
        else
            ino_t_value="unsigned int"
        fi
    fi
    ;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: using $ino_t_value for ino_t" >&5
$as_echo "$as_me: using $ino_t_value for ino_t" >&6;}

# Checks for endianness
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
if ${ac_cv_c_bigendian+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_c_bigendian=unknown
    # See if we're dealing with a universal compiler.
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifndef __APPLE_CC__
	       not a universal capable compiler
	     #endif
	     typedef int dummy;

_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

	# Check for potential -arch flags.  It is not universal unless
	# there are at least two -arch flags with different values.
	ac_arch=
	ac_prev=
	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
	 if test -n "$ac_prev"; then
	   case $ac_word in
	     i?86 | x86_64 | ppc | ppc64)
	       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
		 ac_arch=$ac_word
	       else
		 ac_cv_c_bigendian=universal
		 break
	       fi
	       ;;
	   esac
	   ac_prev=
	 elif test "x$ac_word" = "x-arch"; then
	   ac_prev=arch
	 fi
       done
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    if test $ac_cv_c_bigendian = unknown; then
      # See if sys/param.h defines the BYTE_ORDER macro.
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <sys/types.h>
	     #include <sys/param.h>

int
main ()
{
#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
		     && LITTLE_ENDIAN)
	      bogus endian macros
	     #endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  # It does; now see whether it defined to BIG_ENDIAN or not.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <sys/types.h>
		#include <sys/param.h>

int
main ()
{
#if BYTE_ORDER != BIG_ENDIAN
		 not big endian
		#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_c_bigendian=yes
else
  ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    fi
    if test $ac_cv_c_bigendian = unknown; then
      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <limits.h>

int
main ()
{
#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
	      bogus endian macros
	     #endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  # It does; now see whether it defined to _BIG_ENDIAN or not.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <limits.h>

int
main ()
{
#ifndef _BIG_ENDIAN
		 not big endian
		#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_c_bigendian=yes
else
  ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    fi
    if test $ac_cv_c_bigendian = unknown; then
      # Compile a test program.
      if test "$cross_compiling" = yes; then :
  # Try to guess by grepping values from an object file.
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
short int ascii_mm[] =
		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
		short int ascii_ii[] =
		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
		int use_ascii (int i) {
		  return ascii_mm[i] + ascii_ii[i];
		}
		short int ebcdic_ii[] =
		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
		short int ebcdic_mm[] =
		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
		int use_ebcdic (int i) {
		  return ebcdic_mm[i] + ebcdic_ii[i];
		}
		extern int foo;

int
main ()
{