path: root/acsite.m4

dnl ============================================================
dnl We define the macro GLIBC_PROVIDES to do an AC_PROVIDE for
dnl each macro which appears in configure.ac before the sysdep
dnl configure scripts are run. Each sysdep configure.ac does
dnl LIBMPU_PROVIDES first, to avoid any AC_REQUIREs or
dnl AC_BEFOREs duplicating their code.
dnl ============================================================
define([LIBMPU_PROVIDES], [dnl
AC_PROVIDE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
AC_PROVIDE([AC_CONFIG_SUBDIRS])dnl
AC_PROVIDE([_AS_ECHO_N_PREPARE])dnl
AC_PROVIDE([_AS_ECHO_PREPARE])dnl
AC_PROVIDE([_AS_CR_PREPARE])dnl
AC_PROVIDE([_AS_TR_SH_PREPARE])dnl
AC_PROVIDE([_AS_VAR_ARITH_PREPARE])dnl
AC_PROVIDE([AC_PROG_INSTALL])dnl
AC_PROVIDE([AC_PROG_CC])dnl
AC_PROVIDE([AC_PROG_CPP])dnl
AC_PROVIDE([_AS_PATH_SEPARATOR_PREPARE])dnl
AC_PROVIDE([_AS_TEST_PREPARE])dnl
AC_PROVIDE([_AS_BASENAME_PREPARE])dnl
AC_PROVIDE([_AS_ME_PREPARE])dnl
AC_PROVIDE([_AS_LINENO_PREPARE])dnl
AC_PROVIDE([AS_SHELL_FN_as_fn_set_status])dnl
AC_PROVIDE([AS_SHELL_FN_as_fn_exit])dnl
AC_PROVIDE([AS_SHELL_FN_as_fn_arith])dnl
AC_PROVIDE([AS_SHELL_FN_ac_fn_c_try_compile])dnl
define([AS_MESSAGE_LOG_FD],5)dnl
define([AS_MESSAGE_FD],6)dnl
dnl Ripped out of AS_INIT, which does more cruft we do not want.
m4_wrap([m4_divert_pop([BODY])[]])
m4_divert_push([BODY])[]dnl
dnl End of ripped out of AS_INIT.
# This file is generated from configure.ac by Autoconf.  DO NOT EDIT!
define([_AC_LANG], [C])dnl
])dnl

dnl ============================================================
dnl Support for Configuration Headers
dnl
dnl    configure.ac:
dnl       AC_LIBMPU_HEADLINE(<short-name>, <long-name>,
dnl                          <vers-var>, <vers-file>,
dnl                          <copyright>)
dnl
dnl NOTE:
dnl ====
dnl   See the paragraph 8.3.3 of Autoconf Documentation at:
dnl
dnl     https://www.gnu.org/software/autoconf/manual/autoconf.html#Diversion-support
dnl
dnl ============================================================
m4_define([AC_LIBMPU_HEADLINE], [dnl
m4_divert_push([M4SH-SANITIZE])dnl
{
  if test ".`echo dummy [$]@ | grep help`" = .; then
    ####### bootstrapping version-tool
    ac_prog=[$]0
changequote(, )dnl
    ac_srcdir=`echo $ac_prog | sed -e 's%/[^/][^/]*$%%' -e 's%\([^/]\)/*$%\1%'`
changequote([, ])dnl
    test ".$ac_srcdir" = ".$ac_prog" && ac_srcdir=.
    ac_version_tool="${CONFIG_SHELL-/bin/sh} $ac_srcdir/version-tool"

    ####### нахождение escape последовательностей для
    ####### обозначения начала и конца выделяемого текста
    ####### Use a `Quadrigaph'. '@<:@' gives you [ and '@:>@' gives you ] :
    TB=`echo -n -e '\033@<:@1m'`
    TN=`echo -n -e '\033@<:@0m'`

    ####### чтение короткого номера версии продукта (например, "1.0.0")
    $3="`$ac_version_tool $ac_srcdir/$4`"
    AC_SUBST($3)

    ####### печать заголовка
    echo "Configuring:"
    echo ""
    echo "${TB}$1${TN} ($2), Version ${TB}${$3}${TN}"
    echo "$5"
    echo ""

    ####### чтение шестнадцатеричного номера версии продукта (например, 0x100200)
#    $3_HEX="`$ac_version_tool version -lc -dhex $ac_srcdir/$4`"
#    AC_SUBST($3_HEX)
  fi
}
m4_divert_pop([M4SH-SANITIZE])dnl
])dnl


dnl ============================================================
dnl Display Configuration Headers
dnl
dnl    configure.ac:
dnl       AC_MSG_CFG_PART(<text>)
dnl ============================================================
AC_DEFUN([AC_MSG_CFG_PART],[dnl
   AC_MSG_RESULT()
   AC_MSG_RESULT([${TB}$1:${TN}])
])dnl


dnl ============================================================
dnl  Check for weak symbols too:
dnl ============================================================
AC_DEFUN([LIBMPU_ALIAS_ATTRIBUTE],
[AC_CACHE_CHECK(for broken __attribute__((alias())),
  libmpu_cv_broken_alias_attribute,
  [cat > conftest.c <<EOF
   extern int foo (int x) __asm ("xyzzy");
   int bar (int x) { return x; }
   extern __typeof (bar) foo __attribute ((weak, alias ("bar")));
   extern int dfoo;
   extern __typeof (dfoo) dfoo __asm ("abccb");
   int dfoo = 1;
EOF
  libmpu_cv_broken_alias_attribute=yes
  if AC_TRY_COMMAND(${CC-cc} -Werror -S conftest.c -o conftest.s 1>&AS_MESSAGE_LOG_FD); then
    if grep 'xyzzy' conftest.s >/dev/null &&
       grep 'abccb' conftest.s >/dev/null; then
       libmpu_cv_broken_alias_attribute=no
    fi
  fi
  rm -f conftest.c conftest.s
  ])
if test $libmpu_cv_broken_alias_attribute = yes; then
  AC_MSG_ERROR([
********   ${TB}Working alias attribute support required.${TN}])
else
  AC_DEFINE(HAVE_WEAK_SYMBOLS, 1, [Defined if supports weak symbols.])
fi
])


dnl ============================================================
dnl  Check for hidden visibility attribute:
dnl ============================================================
AC_DEFUN([LIBMPU_HIDDEN_VISIBILITY_ATTRIBUTE],
[AC_CACHE_CHECK(for __attribute__((visibility("hidden"))),
  libmpu_cv_hidden_visibility_attribute,
  [cat > conftest.c <<EOF
   int __attribute__ ((visibility ("hidden"))) foo (void) { return 1; }
EOF
  libmpu_cv_hidden_visibility_attribute=no
  if AC_TRY_COMMAND(${CC-cc} -Werror -S conftest.c -o conftest.s 1>&AS_MESSAGE_LOG_FD); then
    if grep '\.hidden.*foo' conftest.s >/dev/null; then
       libmpu_cv_hidden_visibility_attribute=yes
    fi
  fi
  rm -f conftest.c conftest.s
  ])
if test $libmpu_cv_hidden_visibility_attribute = yes; then
  AC_DEFINE([HAVE_HIDDEN_VISIBILITY_ATTRIBUTE], [1],
    [Defined if __attribute__((visibility("hidden"))) supported.])
fi
])


dnl ============================================================
dnl Check GNU Binutils
dnl
dnl    configure.ac:
dnl       LIBMPU_PROG_BINUTILS
dnl ============================================================
AC_DEFUN([LIBMPU_PROG_FOO_GNU],
[# Most GNU programs take a -v and spit out some text including
# the word 'GNU'.  Some try to read stdin, so give them /dev/null.
if $1 -o conftest -v </dev/null 2>&1 | grep GNU > /dev/null 2>&1; then
  $2
else
  $3
fi
rm -fr contest*])

AC_DEFUN([LIBMPU_PROG_BINUTILS],
[dnl
AS=`$CC -print-prog-name=as`
LD=`$CC -print-prog-name=ld`
AR=`$CC -print-prog-name=ar`
AC_SUBST(AR)
AC_SUBST(AS)
OBJDUMP=`$CC -print-prog-name=objdump`
AC_SUBST(OBJDUMP)
OBJCOPY=`$CC -print-prog-name=objcopy`
AC_SUBST(OBJCOPY)

# ranlib has to be treated a bit differently since it might not exist at all.
RANLIB=`$CC -print-prog-name=ranlib`
if test $RANLIB = ranlib; then
# This extra check has to happen since gcc simply echos the parameter in
# case it cannot find the value in its own directories.
AC_CHECK_TOOL(RANLIB, ranlib, :)
fi
AC_SUBST(RANLIB)

# readelf has to be treated a bit differently since it might not exist at all.
READELF=`$CC -print-prog-name=readelf`
if test $READELF = readelf; then
# This extra check has to happen since gcc simply echos the parameter in
# case it cannot find the value in its own directories.
AC_CHECK_TOOL(READELF, readelf, :)
fi
AC_SUBST(READELF)

# nm has to be treated a bit differently since it might not exist at all.
NM=`$CC -print-prog-name=nm`
if test $NM = nm; then
# This extra check has to happen since gcc simply echos the parameter in
# case it cannot find the value in its own directories.
AC_CHECK_TOOL(NM, nm, :)
fi
AC_SUBST(NM)

# strip has to be treated a bit differently since it might not exist at all.
STRIP=`$CC -print-prog-name=strip`
if test $STRIP = strip; then
# This extra check has to happen since gcc simply echos the parameter in
# case it cannot find the value in its own directories.
AC_CHECK_TOOL(STRIP, strip, :)
fi
AC_SUBST(STRIP)

# Determine whether we are using GNU binutils.
AC_CACHE_CHECK(whether $AS is GNU as, libmpu_cv_prog_as_gnu,
[LIBMPU_PROG_FOO_GNU($AS, libmpu_cv_prog_as_gnu=yes, libmpu_cv_prog_as_gnu=no)])
rm -f a.out
gnu_as=$libmpu_cv_prog_as_gnu

AC_CACHE_CHECK(whether $LD is GNU ld, libmpu_cv_prog_ld_gnu,
[LIBMPU_PROG_FOO_GNU($LD, libmpu_cv_prog_ld_gnu=yes, libmpu_cv_prog_ld_gnu=no)])
gnu_ld=$libmpu_cv_prog_ld_gnu
])


dnl ============================================================
dnl  Test for build_cc:
dnl  =================
dnl
dnl    configure.ac:
dnl       if test $host != $build; then
dnl         AC_PROG_BUILD_CC
dnl       fi
dnl
dnl ============================================================
AC_DEFUN([AC_PROG_BUILD_CC],
[ac_test_BUILD_CFLAGS=${BUILD_CFLAGS+set}
ac_save_BUILD_CFLAGS=$BUILD_CFLAGS
AC_CHECK_PROGS(BUILD_CC, gcc cc)
AC_MSG_CHECKING(whether $BUILD_CC works on build machine)
AC_CACHE_VAL(ac_cv_prog_build_cc,
[rm -f conftest
cat > conftest.c <<EOF

int main()
{
   char *s = "strip";

   return( 0 );
}

EOF
$BUILD_CC -o conftest conftest.c
if test -f conftest
then
   rm -f conftest conftest.c
   ac_cv_prog_build_cc="$BUILD_CC"
else
   rm -f conftest conftest.c
   ac_cv_prog_build_cc=
fi])dnl

if test "$ac_test_BUILD_CFLAGS" = set; then
  BUILD_CFLAGS=$ac_save_BUILD_CFLAGS
fi

BUILD_CC="$ac_cv_prog_build_cc"
if test "$ac_cv_prog_build_cc" = "$BUILD_CC"; then
   AC_MSG_RESULT(yes)
else
   AC_MSG_RESULT(no)
fi
AC_SUBST(BUILD_CC)dnl
])


dnl ============================================================
dnl  Test for build_host `strip -s':
dnl  ==============================
dnl
dnl    configure.ac:
dnl       if test $host != $build; then
dnl         AC_PATH_PROG_BUILD_STRIP_S
dnl       fi
dnl
dnl ============================================================
AC_DEFUN([AC_PATH_PROG_BUILD_STRIP_S],
[AC_REQUIRE([AC_PROG_BUILD_CC])dnl
AC_PATH_PROG(BUILD_STRIP, strip, no, /usr/local/bin:/usr/bin:/bin:$PATH)
AC_MSG_CHECKING(whether strip -s works on build machine)
AC_CACHE_VAL(ac_cv_path_prog_STRIP_S,
[rm -f conftest
cat > conftest.c <<EOF

int main()
{
   char *s = "strip";

   return( 0 );
}

EOF
$BUILD_CC -o conftest conftest.c
if $BUILD_STRIP -s conftest 2>/dev/null
then
   rm -f conftest conftest.c
   ac_cv_path_prog_STRIP_S="$BUILD_STRIP -s"
else
   rm -f conftest conftest.c
   ac_cv_path_prog_STRIP_S="$BUILD_STRIP"
fi])dnl
BUILD_STRIP_S="$ac_cv_path_prog_STRIP_S"
if test "$ac_cv_path_prog_STRIP_S" = "$BUILD_STRIP -s"; then
   AC_MSG_RESULT(yes)
else
   AC_MSG_RESULT(no)
fi
AC_SUBST(BUILD_STRIP)dnl
AC_SUBST(BUILD_STRIP_S)dnl
])


dnl ============================================================
dnl  Test for WIDTH of MACHINE REGISTER using GCC predefines:
dnl  ==================
dnl
dnl    configure.ac:
dnl       AC_GCC_REGISTER_WIDTH
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_REGISTER_WIDTH],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __INT_FAST32_WIDTH__ )
AC_CACHE_VAL(ac_cv_int_fast32_width,
[ac_cv_int_fast32_width=`$CC -dM -E - < /dev/null | grep __INT_FAST32_WIDTH__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int_fast32_width" != ""; then
  AC_MSG_RESULT($ac_cv_int_fast32_width)
else
  AC_MSG_RESULT(not defined)
fi

AC_MSG_CHECKING(for CPP predefined macro __INT_FAST64_WIDTH__ )
AC_CACHE_VAL(ac_cv_int_fast64_width,
[ac_cv_int_fast64_width=`$CC -dM -E - < /dev/null | grep __INT_FAST64_WIDTH__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int_fast64_width" != ""; then
  AC_MSG_RESULT($ac_cv_int_fast64_width)
else
  AC_MSG_RESULT(not defined)
fi

AC_MSG_CHECKING(for MACHINE REGISTER WIDTH )
AC_CACHE_VAL(ac_cv_machine_register_width,
[dnl
if test "$ac_cv_int_fast64_width" != "" -a "$ac_cv_int_fast32_width" != "" ; then
  if test "$ac_cv_int_fast64_width" -gt "$ac_cv_int_fast32_width" ; then
    ac_cv_machine_register_width=$ac_cv_int_fast32_width
  else
    ac_cv_machine_register_width=$ac_cv_int_fast64_width
  fi
elif test "$ac_cv_int_fast64_width" != "" ; then
  ac_cv_machine_register_width=$ac_cv_int_fast64_width
elif test "$ac_cv_int_fast32_width" != "" ; then
  ac_cv_machine_register_width=$ac_cv_int_fast32_width
else
  ac_cv_machine_register_width=32
fi
])dnl
if test "$ac_cv_machine_register_width" != ""; then
  MACHINE_REGISTER_WIDTH=$ac_cv_machine_register_width
  AC_MSG_RESULT($ac_cv_machine_register_width)
else
  MACHINE_REGISTER_WIDTH=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(MACHINE_REGISTER_WIDTH)dnl
AC_DEFINE_UNQUOTED([MACHINE_REGISTER_WIDTH], [$ac_cv_machine_register_width], [The size of Machine Register in bits.])dnl
])


dnl ============================================================
dnl  Test for GCC Types:
dnl  ==================
dnl
dnl    configure.ac:
dnl       AC_GCC_TYPES
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_TYPES],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __CHAR16_TYPE__ )
AC_CACHE_VAL(ac_cv_char16_type,
[ac_cv_char16_type=`$CC -dM -E - < /dev/null | grep __CHAR16_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_char16_type" != ""; then
  GCC_CHAR16_TYPE=$ac_cv_char16_type
  AC_MSG_RESULT($ac_cv_char16_type)
else
  GCC_CHAR16_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_CHAR16_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __CHAR32_TYPE__ )
AC_CACHE_VAL(ac_cv_char32_type,
[ac_cv_char32_type=`$CC -dM -E - < /dev/null | grep __CHAR32_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_char32_type" != ""; then
  GCC_CHAR32_TYPE=$ac_cv_char32_type
  AC_MSG_RESULT($ac_cv_char32_type)
else
  GCC_CHAR32_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_CHAR32_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __WCHAR_TYPE__ )
AC_CACHE_VAL(ac_cv_wchar_type,
[ac_cv_wchar_type=`$CC -dM -E - < /dev/null | grep __WCHAR_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_wchar_type" != ""; then
  GCC_WCHAR_TYPE=$ac_cv_wchar_type
  AC_MSG_RESULT($ac_cv_wchar_type)
else
  GCC_WCHAR_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_WCHAR_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INT8_TYPE__ )
AC_CACHE_VAL(ac_cv_int8_type,
[ac_cv_int8_type=`$CC -dM -E - < /dev/null | grep __INT8_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int8_type" != ""; then
  GCC_INT8_TYPE=$ac_cv_int8_type
  AC_MSG_RESULT($ac_cv_int8_type)
else
  GCC_INT8_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INT8_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINT8_TYPE__ )
AC_CACHE_VAL(ac_cv_uint8_type,
[ac_cv_uint8_type=`$CC -dM -E - < /dev/null | grep __UINT8_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uint8_type" != ""; then
  GCC_UINT8_TYPE=$ac_cv_uint8_type
  AC_MSG_RESULT($ac_cv_uint8_type)
else
  GCC_UINT8_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINT8_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INT16_TYPE__ )
AC_CACHE_VAL(ac_cv_int16_type,
[ac_cv_int16_type=`$CC -dM -E - < /dev/null | grep __INT16_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int16_type" != ""; then
  GCC_INT16_TYPE=$ac_cv_int16_type
  AC_MSG_RESULT($ac_cv_int16_type)
else
  GCC_INT16_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INT16_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINT16_TYPE__ )
AC_CACHE_VAL(ac_cv_uint16_type,
[ac_cv_uint16_type=`$CC -dM -E - < /dev/null | grep __UINT16_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uint16_type" != ""; then
  GCC_UINT16_TYPE=$ac_cv_uint16_type
  AC_MSG_RESULT($ac_cv_uint16_type)
else
  GCC_UINT16_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINT16_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INT32_TYPE__ )
AC_CACHE_VAL(ac_cv_int32_type,
[ac_cv_int32_type=`$CC -dM -E - < /dev/null | grep __INT32_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int32_type" != ""; then
  GCC_INT32_TYPE=$ac_cv_int32_type
  AC_MSG_RESULT($ac_cv_int32_type)
else
  GCC_INT32_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INT32_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINT32_TYPE__ )
AC_CACHE_VAL(ac_cv_uint32_type,
[ac_cv_uint32_type=`$CC -dM -E - < /dev/null | grep __UINT32_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_uint32_const_suffix,
[ac_cv_uint32_const_suffix=`$CC -dM -E - < /dev/null | grep __UINT32_C | cut -f5- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uint32_type" != ""; then
  GCC_UINT32_TYPE=$ac_cv_uint32_type
  AC_MSG_RESULT($ac_cv_uint32_type)
else
  GCC_UINT32_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINT32_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INT64_TYPE__ )
AC_CACHE_VAL(ac_cv_int64_type,
[ac_cv_int64_type=`$CC -dM -E - < /dev/null | grep __INT64_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_int64_type" != ""; then
  GCC_INT64_TYPE=$ac_cv_int64_type
  AC_MSG_RESULT($ac_cv_int64_type)
else
  GCC_INT64_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INT64_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINT64_TYPE__ )
AC_CACHE_VAL(ac_cv_uint64_type,
[ac_cv_uint64_type=`$CC -dM -E - < /dev/null | grep __UINT64_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_uint64_const_suffix,
[ac_cv_uint64_const_suffix=`$CC -dM -E - < /dev/null | grep __UINT64_C | cut -f5- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uint64_type" != ""; then
  GCC_UINT64_TYPE=$ac_cv_uint64_type
  AC_MSG_RESULT($ac_cv_uint64_type)
else
  GCC_UINT64_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINT64_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __WINT_TYPE__ )
AC_CACHE_VAL(ac_cv_wint_type,
[ac_cv_wint_type=`$CC -dM -E - < /dev/null | grep __WINT_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_wint_type" != ""; then
  GCC_WINT_TYPE=$ac_cv_wint_type
  AC_MSG_RESULT($ac_cv_wint_type)
else
  GCC_WINT_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_WINT_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INTMAX_TYPE__ )
AC_CACHE_VAL(ac_cv_intmax_type,
[ac_cv_intmax_type=`$CC -dM -E - < /dev/null | grep __INTMAX_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_intmax_type" != ""; then
  GCC_INTMAX_TYPE=$ac_cv_intmax_type
  AC_MSG_RESULT($ac_cv_intmax_type)
else
  GCC_INTMAX_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INTMAX_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINTMAX_TYPE__ )
AC_CACHE_VAL(ac_cv_uintmax_type,
[ac_cv_uintmax_type=`$CC -dM -E - < /dev/null | grep __UINTMAX_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uintmax_type" != ""; then
  GCC_UINTMAX_TYPE=$ac_cv_uintmax_type
  AC_MSG_RESULT($ac_cv_uintmax_type)
else
  GCC_UINTMAX_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINTMAX_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZE_TYPE__ )
AC_CACHE_VAL(ac_cv_size_type,
[ac_cv_size_type=`$CC -dM -E - < /dev/null | grep __SIZE_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_size_type" != ""; then
  GCC_SIZE_TYPE=$ac_cv_size_type
  AC_MSG_RESULT($ac_cv_size_type)
else
  GCC_SIZE_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZE_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __INTPTR_TYPE__ )
AC_CACHE_VAL(ac_cv_intptr_type,
[ac_cv_intptr_type=`$CC -dM -E - < /dev/null | grep __INTPTR_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_intptr_type" != ""; then
  GCC_INTPTR_TYPE=$ac_cv_intptr_type
  AC_MSG_RESULT($ac_cv_intptr_type)
else
  GCC_INTPTR_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_INTPTR_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __UINTPTR_TYPE__ )
AC_CACHE_VAL(ac_cv_uintptr_type,
[ac_cv_uintptr_type=`$CC -dM -E - < /dev/null | grep __UINTPTR_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_uintptr_type" != ""; then
  GCC_UINTPTR_TYPE=$ac_cv_uintptr_type
  AC_MSG_RESULT($ac_cv_uintptr_type)
else
  GCC_UINTPTR_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_UINTPTR_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __PTRDIFF_TYPE__ )
AC_CACHE_VAL(ac_cv_ptrdiff_type,
[ac_cv_ptrdiff_type=`$CC -dM -E - < /dev/null | grep __PTRDIFF_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_ptrdiff_type" != ""; then
  GCC_PTRDIFF_TYPE=$ac_cv_ptrdiff_type
  AC_MSG_RESULT($ac_cv_ptrdiff_type)
else
  GCC_PTRDIFF_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_PTRDIFF_TYPE)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIG_ATOMIC_TYPE__ )
AC_CACHE_VAL(ac_cv_sig_atomic_type,
[ac_cv_sig_atomic_type=`$CC -dM -E - < /dev/null | grep __SIG_ATOMIC_TYPE__ | cut -f3- -d' ' | tr '\n' ' ' | tr -s ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sig_atomic_type" != ""; then
  GCC_SIG_ATOMIC_TYPE=$ac_cv_sig_atomic_type
  AC_MSG_RESULT($ac_cv_sig_atomic_type)
else
  GCC_SIG_ATOMIC_TYPE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIG_ATOMIC_TYPE)dnl
])


dnl ============================================================
dnl  Test for GCC Sizeof Types:
dnl  =========================
dnl
dnl    configure.ac:
dnl       AC_GCC_SIZEOF_TYPES
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_SIZEOF_TYPES],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_WCHAR_T__ )
AC_CACHE_VAL(ac_cv_sizeof_wchar_t,
[ac_cv_sizeof_wchar_t=`$CC -dM -E - < /dev/null | grep __SIZEOF_WCHAR_T__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_wchar_t" != ""; then
  GCC_SIZEOF_WCHAR_T=$ac_cv_sizeof_wchar_t
  AC_MSG_RESULT($ac_cv_sizeof_wchar_t)
else
  GCC_SIZEOF_WCHAR_T=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_WCHAR_T)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_SHORT__ )
AC_CACHE_VAL(ac_cv_sizeof_short,
[ac_cv_sizeof_short=`$CC -dM -E - < /dev/null | grep __SIZEOF_SHORT__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_short" != ""; then
  GCC_SIZEOF_SHORT=$ac_cv_sizeof_short
  AC_MSG_RESULT($ac_cv_sizeof_short)
else
  GCC_SIZEOF_SHORT=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_SHORT)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_INT__ )
AC_CACHE_VAL(ac_cv_sizeof_int,
[ac_cv_sizeof_int=`$CC -dM -E - < /dev/null | grep __SIZEOF_INT__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_int" != ""; then
  GCC_SIZEOF_INT=$ac_cv_sizeof_int
  AC_MSG_RESULT($ac_cv_sizeof_int)
else
  GCC_SIZEOF_INT=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_INT)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_WINT_T__ )
AC_CACHE_VAL(ac_cv_sizeof_wint_t,
[ac_cv_sizeof_wint_t=`$CC -dM -E - < /dev/null | grep __SIZEOF_WINT_T__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_wint_t" != ""; then
  GCC_SIZEOF_WINT_T=$ac_cv_sizeof_wint_t
  AC_MSG_RESULT($ac_cv_sizeof_wint_t)
else
  GCC_SIZEOF_WINT_T=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_WINT_T)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_LONG__ )
AC_CACHE_VAL(ac_cv_sizeof_long,
[ac_cv_sizeof_long=`$CC -dM -E - < /dev/null | grep __SIZEOF_LONG__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_long" != ""; then
  GCC_SIZEOF_LONG=$ac_cv_sizeof_long
  AC_MSG_RESULT($ac_cv_sizeof_long)
else
  GCC_SIZEOF_LONG=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_LONG)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_LONG_LONG__ )
AC_CACHE_VAL(ac_cv_sizeof_long_long,
[ac_cv_sizeof_long_long=`$CC -dM -E - < /dev/null | grep __SIZEOF_LONG_LONG__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_long_long" != ""; then
  GCC_SIZEOF_LONG_LONG=$ac_cv_sizeof_long_long
  AC_MSG_RESULT($ac_cv_sizeof_long_long)
else
  GCC_SIZEOF_LONG_LONG=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_LONG_LONG)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_FLOAT__ )
AC_CACHE_VAL(ac_cv_sizeof_float,
[ac_cv_sizeof_float=`$CC -dM -E - < /dev/null | grep __SIZEOF_FLOAT__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_float" != ""; then
  GCC_SIZEOF_FLOAT=$ac_cv_sizeof_float
  AC_MSG_RESULT($ac_cv_sizeof_float)
else
  GCC_SIZEOF_FLOAT=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_FLOAT)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_DOUBLE__ )
AC_CACHE_VAL(ac_cv_sizeof_double,
[ac_cv_sizeof_double=`$CC -dM -E - < /dev/null | grep __SIZEOF_DOUBLE__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_double" != ""; then
  GCC_SIZEOF_DOUBLE=$ac_cv_sizeof_double
  AC_MSG_RESULT($ac_cv_sizeof_double)
else
  GCC_SIZEOF_DOUBLE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_DOUBLE)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_LONG_DOUBLE__ )
AC_CACHE_VAL(ac_cv_sizeof_long_double,
[ac_cv_sizeof_long_double=`$CC -dM -E - < /dev/null | grep __SIZEOF_LONG_DOUBLE__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_long_double" != ""; then
  GCC_SIZEOF_LONG_DOUBLE=$ac_cv_sizeof_long_double
  AC_MSG_RESULT($ac_cv_sizeof_long_double)
else
  GCC_SIZEOF_LONG_DOUBLE=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_LONG_DOUBLE)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_SIZE_T__ )
AC_CACHE_VAL(ac_cv_sizeof_size_t,
[ac_cv_sizeof_size_t=`$CC -dM -E - < /dev/null | grep __SIZEOF_SIZE_T__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_size_t" != ""; then
  GCC_SIZEOF_SIZE_T=$ac_cv_sizeof_size_t
  AC_MSG_RESULT($ac_cv_sizeof_size_t)
else
  GCC_SIZEOF_SIZE_T=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_SIZE_T)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_POINTER__ )
AC_CACHE_VAL(ac_cv_sizeof_pointer,
[ac_cv_sizeof_pointer=`$CC -dM -E - < /dev/null | grep __SIZEOF_POINTER__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_pointer" != ""; then
  GCC_SIZEOF_POINTER=$ac_cv_sizeof_pointer
  AC_MSG_RESULT($ac_cv_sizeof_pointer)
else
  GCC_SIZEOF_POINTER=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_POINTER)dnl

AC_MSG_CHECKING(for CPP predefined macro __SIZEOF_PTRDIFF_T__ )
AC_CACHE_VAL(ac_cv_sizeof_ptrdiff_t,
[ac_cv_sizeof_ptrdiff_t=`$CC -dM -E - < /dev/null | grep __SIZEOF_PTRDIFF_T__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_sizeof_ptrdiff_t" != ""; then
  GCC_SIZEOF_PTRDIFF_T=$ac_cv_sizeof_ptrdiff_t
  AC_MSG_RESULT($ac_cv_sizeof_ptrdiff_t)
else
  GCC_SIZEOF_PTRDIFF_T=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_SIZEOF_PTRDIFF_T)dnl
])


dnl ============================================================
dnl  Test for GCC Width of Types:
dnl  ===========================
dnl
dnl    configure.ac:
dnl       AC_GCC_WIDTH_OF_TYPES
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_WIDTH_OF_TYPES],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __CHAR_BIT__ )
AC_CACHE_VAL(ac_cv_char_width,
[ac_cv_char_width=`$CC -dM -E - < /dev/null | grep __CHAR_BIT__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_char_width" != ""; then
  GCC_CHAR_WIDTH=$ac_cv_char_width
  AC_MSG_RESULT($ac_cv_char_width)
else
  GCC_CHAR_WIDTH=
  AC_MSG_RESULT(not defined)
fi
AC_SUBST(GCC_CHAR_WIDTH)dnl
])


dnl ============================================================
dnl  Test for GCC Byte Order:
dnl  =======================
dnl
dnl    configure.ac:
dnl       AC_GCC_BYTE_ORDER
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_BYTE_ORDER],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __BYTE_ORDER__ )
AC_CACHE_VAL(ac_cv_order_little_endian,
[ac_cv_order_little_endian=`$CC -dM -E - < /dev/null | grep __ORDER_LITTLE_ENDIAN__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_order_big_endian,
[ac_cv_order_big_endian=`$CC -dM -E - < /dev/null | grep __ORDER_BIG_ENDIAN__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_byte_order,
[ac_cv_byte_order=`$CC -dM -E - < /dev/null | grep __BYTE_ORDER__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_byte_order" = "__ORDER_LITTLE_ENDIAN__"; then
  GCC_BYTE_ORDER=1234
  GCC_BYTE_ORDER_LITTLE_ENDIAN=1
  GCC_BYTE_ORDER_BIG_ENDIAN=0
  AC_MSG_RESULT(Little-endian)
else
  GCC_BYTE_ORDER=4321
  GCC_BYTE_ORDER_LITTLE_ENDIAN=0
  GCC_BYTE_ORDER_BIG_ENDIAN=1
  AC_MSG_RESULT(Big-endian)
fi
AC_SUBST(GCC_BYTE_ORDER)dnl
AC_SUBST(GCC_BYTE_ORDER_LITTLE_ENDIAN)dnl
AC_SUBST(GCC_BYTE_ORDER_BIG_ENDIAN)dnl
])


dnl ============================================================
dnl  Test for GCC Float Word Order:
dnl  =============================
dnl
dnl    configure.ac:
dnl       AC_GCC_FLOAT_WORD_ORDER
dnl
dnl ============================================================
AC_DEFUN([AC_GCC_FLOAT_WORD_ORDER],
[dnl
AC_MSG_CHECKING(for CPP predefined macro __FLOAT_WORD_ORDER__ )
AC_CACHE_VAL(ac_cv_order_little_endian,
[ac_cv_order_little_endian=`$CC -dM -E - < /dev/null | grep __ORDER_LITTLE_ENDIAN__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_order_big_endian,
[ac_cv_order_big_endian=`$CC -dM -E - < /dev/null | grep __ORDER_BIG_ENDIAN__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
AC_CACHE_VAL(ac_cv_float_word_order,
[ac_cv_float_word_order=`$CC -dM -E - < /dev/null | grep __FLOAT_WORD_ORDER__ | cut -f3 -d' ' | tr '\n' ' ' | sed 's,^[ \t]*,,;s,[ \t]*$,,'`])dnl
if test "$ac_cv_float_word_order" = "__ORDER_LITTLE_ENDIAN__"; then
  GCC_FLOAT_WORD_ORDER=1234
  GCC_FLOAT_WORD_ORDER_LITTLE_ENDIAN=1
  GCC_FLOAT_WORD_ORDER_BIG_ENDIAN=0
  AC_MSG_RESULT(Little-endian)
else
  GCC_FLOAT_WORD_ORDER=4321
  GCC_FLOAT_WORD_ORDER_LITTLE_ENDIAN=0
  GCC_FLOAT_WORD_ORDER_BIG_ENDIAN=1
  AC_MSG_RESULT(Big-endian)
fi
AC_SUBST(GCC_FLOAT_WORD_ORDER)dnl
AC_SUBST(GCC_FLOAT_WORD_ORDER_LITTLE_ENDIAN)dnl
AC_SUBST(GCC_FLOAT_WORD_ORDER_BIG_ENDIAN)dnl
])


dnl =======================================================================
dnl  AC_GCC_PROGRAMMING_MODEL
dnl
dnl  Determine programming model corresponding to following list:
dnl
dnl    PROGRAMMING MODELS:
dnl    ------------------
dnl
dnl           PM: |     1 |     2 |        3  |     4 |        5  |      6
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl               |  LP32 | ILP32 |     LP64  | ILP64 |    LLP64  | SILP64
dnl     Data type |       |       | (I32LP64) |       | (IL32P64) |
dnl    ===========|=======|=======|===========|=======|===========|========
dnl          char |     8 |     8 |         8 |     8 |         8 |      8
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl         short |    16 |    16 |        16 |    16 |        16 |     64
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl           int |    16 |    32 |        32 |    64 |        32 |     64
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl          long |    32 |    32 |        64 |    64 |        32 |     64
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl     long long |                     64
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl       pointer |    32 |    32 |        64 |    64 |        64 |     64
dnl    -----------+-------+-------+-----------+-------+-----------+--------
dnl     ptrdiff_t |    32 |    32 |        64 |    64 |        64 |     64
dnl    ===========+=======+=======+===========+=======+===========+========
dnl          CPU: |       |  i686 |    x86_64 |       |           |
dnl
dnl    Many 64-bit platforms today use an LP64 model (including Solaris,
dnl    AIX, HP-UX, Linux, macOS, BSD, and IBM z/OS).  Microsoft Windows
dnl    uses an LLP64 model.  The disadvantage of the LP64 model is that
dnl    storing a long into an int may overflow.  On the other hand,
dnl    converting a pointer to a long will “work” in LP64. In the LLP64
dnl    model, the reverse is true.  These are not problems which affect
dnl    fully standard-compliant code, but code is often written with
dnl    implicit assumptions about the widths of data types. C code
dnl    should prefer (u)intptr_t instead of long when casting pointers
dnl    into integer objects.
dnl
dnl =======================================================================
AC_DEFUN([AC_GCC_PROGRAMMING_MODEL],
[AC_REQUIRE([AC_GCC_TYPES])dnl
AC_REQUIRE([AC_GCC_SIZEOF_TYPES])dnl
AC_CACHE_CHECK(for Target Machine Programming Model, ac_cv_gcc_programming_model,
ac_cv_gcc_programming_model=unknown  dnl Initialize to unknown
[
silp=${ac_cv_sizeof_short}${ac_cv_sizeof_int}${ac_cv_sizeof_long}${ac_cv_sizeof_pointer}
changequote(,)dnl
case "$silp" in
   2244)
      ac_cv_gcc_programming_model=LP32
      ac_cv_gcc_programming_model_silp=2244
      ac_cv_gcc_programming_model_id=1
      ;;
   2444)
      ac_cv_gcc_programming_model=ILP32
      ac_cv_gcc_programming_model_silp=2444
      ac_cv_gcc_programming_model_id=2
      ;;
   2488)
      ac_cv_gcc_programming_model=LP64
      ac_cv_gcc_programming_model_silp=2488
      ac_cv_gcc_programming_model_id=3
      ;;
   2888)
      ac_cv_gcc_programming_model=ILP64
      ac_cv_gcc_programming_model_silp=2888
      ac_cv_gcc_programming_model_id=4
      ;;
   2448)
      ac_cv_gcc_programming_model=LLP64
      ac_cv_gcc_programming_model_silp=2448
      ac_cv_gcc_programming_model_id=5
      ;;
   8888)
      ac_cv_gcc_programming_model=SILP64
      ac_cv_gcc_programming_model_silp=8888
      ac_cv_gcc_programming_model_id=6
      ;;
   *)
changequote([,])dnl
      ac_cv_c_programming_model=unknown
      ;;
esac
]
if test $ac_cv_gcc_programming_model = unknown ; then
  AC_MSG_ERROR([
********   ${TB}Not able to determine programming model.${TN}])
elif test $ac_cv_gcc_programming_model = LP32 ; then
  AC_MSG_ERROR([
********   ${TB}MPU Library does not support LP32 programming model.${TN}])
elif test $ac_cv_gcc_programming_model = IPL64 ; then
  AC_MSG_ERROR([
********   ${TB}MPU Library does not support IPL64 programming model.${TN}])
elif test $ac_cv_gcc_programming_model = SIPL64 ; then
  AC_MSG_ERROR([
********   ${TB}MPU Library does not support SIPL64 programming model.${TN}])
fi
)

dnl =======================================================================
dnl Programming model IDs:
dnl =======================================================================
AC_SUBST(PM_LP32, 1)
AC_SUBST(PM_ILP32, 2)
AC_SUBST(PM_LP64, 3)
AC_SUBST(PM_ILP64, 4)
AC_SUBST(PM_LLP64, 5)
AC_SUBST(PM_SILP64, 6)

AC_DEFINE([__PM_LP32], [1], [The ID of LP32 programming model.])dnl
AC_DEFINE([__PM_ILP32], [2], [The ID of ILP32 programming model.])dnl
AC_DEFINE([__PM_LP64], [3], [The ID of LP64 programming model.])dnl
AC_DEFINE([__PM_ILP64], [4], [The ID of ILP64 programming model.])dnl
AC_DEFINE([__PM_LLP64], [5], [The ID of LLP64 programming model.])dnl
AC_DEFINE([__PM_SILP64], [6], [The ID of SILP64 programming model.])dnl

dnl =======================================================================
dnl EMUSHORT, EMULONG Types:
dnl =======================================================================
AC_SUBST(LIBMPU_EMUSHORT_TYPE, $ac_cv_int32_type)
AC_SUBST(LIBMPU_UINT32_CONST_SUFFIX, $ac_cv_uint32_const_suffix)
AC_SUBST(LIBMPU_SIZEOF_EMUSHORT, 4)
AC_SUBST(LIBMPU_EMUSHORT_WIDTH, 32)

AC_DEFINE_UNQUOTED([EMUSHORT], [$ac_cv_uint32_type], [The type of unsigned 32-bit integer variables.])dnl
AC_DEFINE_UNQUOTED([EMUSHORT_C(c)], [c ## $ac_cv_uint32_const_suffix], [The macro for expand the EMUSHORT value to constant expression.])dnl
AC_DEFINE([SIZE_OF_EMUSHORT], [4], [The size of EMUSHORT type in bytes.])dnl
AC_DEFINE([BITS_PER_EMUSHORT], [32], [The size of EMUSHORT type in bits.])dnl

AC_SUBST(LIBMPU_EMUPART_TYPE, $ac_cv_int32_type)
AC_SUBST(LIBMPU_SIZEOF_EMUPART, 4)
AC_SUBST(LIBMPU_EMUPART_WIDTH, 32)

AC_DEFINE_UNQUOTED([EMUPART], [$ac_cv_uint32_type], [The type of unsigned 32-bit integer variables.])dnl
AC_DEFINE_UNQUOTED([EMUPART_C(c)], [c ## $ac_cv_uint32_const_suffix], [The macro for expand the EMUPART value to constant expression.])dnl
AC_DEFINE([SIZE_OF_EMUPART], [4], [The size of EMUPART type in bytes.])dnl
AC_DEFINE([BITS_PER_EMUPART], [32], [The size of EMUPART type in bits.])dnl

AC_SUBST(LIBMPU_EMULONG_TYPE, $ac_cv_int64_type)
AC_SUBST(LIBMPU_UINT64_CONST_SUFFIX, $ac_cv_uint64_const_suffix)
AC_SUBST(LIBMPU_SIZEOF_EMULONG, 8)
AC_SUBST(LIBMPU_EMULONG_WIDTH, 64)

AC_DEFINE_UNQUOTED([EMULONG], [$ac_cv_uint64_type], [The type of unsigned 64-bit integer variables.])dnl
AC_DEFINE_UNQUOTED([EMULONG_C(c)], [c ## $ac_cv_uint64_const_suffix], [The macro for expand the EMULONG value to constant expression.])dnl
AC_DEFINE([SIZE_OF_EMULONG], [8], [The size of EMULONG type in bytes.])dnl
AC_DEFINE([BITS_PER_EMULONG], [64], [The size of EMULONG type in bits.])dnl

AC_DEFINE_UNQUOTED([BITS_PER_BYTE], [$ac_cv_char_width], [The size of BYTE or UNIT type in bits.])dnl

AC_SUBST(GCC_PROGRAMMING_MODEL, $ac_cv_gcc_programming_model)
AC_SUBST(GCC_PROGRAMMING_MODEL_SILP, $ac_cv_gcc_programming_model_silp)
AC_SUBST(GCC_PROGRAMMING_MODEL_ID, $ac_cv_gcc_programming_model_id)

AC_DEFINE_UNQUOTED([__PROGRAMMING_MODEL], [$ac_cv_gcc_programming_model], [The programming model name.])dnl
AC_DEFINE_UNQUOTED([__PROGRAMMING_MODEL_SILP], [$ac_cv_gcc_programming_model_silp], [The programming model sizes of short, int, long, pointer types.])dnl
AC_DEFINE_UNQUOTED([__PROGRAMMING_MODEL_ID], [$ac_cv_gcc_programming_model_id], [The programming model identificator.])dnl
])


AC_DEFUN([AC_LIBMPU_LT_VERSION_INFO],
[AC_MSG_CHECKING(for MPU Library Version Information)
#
# Made LT_VERSION_INFO so that library version matches PACKAGE_VERSION:
#
major=`echo ${PACKAGE_VERSION} | cut -f1 -d'.'`
minor=`echo ${PACKAGE_VERSION} | cut -f2 -d'.'`
patch=`echo ${PACKAGE_VERSION} | cut -f3 -d'.'`

current=$( expr ${major} + ${patch} )
revision=${minor}
age=${patch}

ac_cv_libmpu_lt_release="${major}.${minor}"
ac_cv_libmpu_lt_current="${current}"
ac_cv_libmpu_lt_revision="${revision}"
ac_cv_libmpu_lt_age="${age}"

ac_cv_libmpu_lt_version_info="${major}:${age}:${revision}"

AC_SUBST(LIBMPU_LT_RELEASE, $ac_cv_libmpu_lt_release)
AC_SUBST(LIBMPU_LT_VERSION_INFO, $ac_cv_libmpu_lt_version_info)
AC_SUBST(LIBMPU_LT_CURRENT, $ac_cv_libmpu_lt_current)
AC_SUBST(LIBMPU_LT_REVISION, $ac_cv_libmpu_lt_revision)
AC_SUBST(LIBMPU_LT_AGE, $ac_cv_libmpu_lt_age)

AC_MSG_RESULT($ac_cv_libmpu_lt_version_info)
if test "$ac_cv_libmpu_lt_version_info" = ""; then
AC_MSG_ERROR([
********   ${TB}The MPU Library Version Information does not declared.${TN}])
fi
])


dnl ============================================================
dnl  Test if LD_LIBRARY_PATH contains the notation for the
dnl  current directory since this would lead to problems
dnl  installing/building kxlibc .
dnl
dnl  LD_LIBRARY_PATH contains the current directory if one
dnl  of the following is true:
dnl     - one of the terminals (":" and ";") is the first or
dnl       last sign;
dnl     - two terminals occur directly after each other;
dnl     - the path contains an element with a dot in it .
dnl ============================================================
AC_DEFUN([AC_LD_LIBRARY_PATH],
[AC_MSG_CHECKING(for LD_LIBRARY_PATH does not contain current directory)
changequote(,)dnl
case ${LD_LIBRARY_PATH} in
   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
      ld_library_path_setting="contains current directory"
      ;;
   *)
      ld_library_path_setting="ok"
      ;;
esac
changequote([,])dnl
AC_MSG_RESULT($ld_library_path_setting)
if test "$ld_library_path_setting" != "ok"; then
AC_MSG_ERROR([
********   ${TB}LD_LIBRARY_PATH shouldn't contain the current directory when${TN}
********   ${TB}building MPU Library. Please change the environment variable${TN}
********   ${TB}and run configure again.${TN}])
fi
])