dnl ============================================================
dnl Force configure to run under /bin/bash
dnl ============================================================
m4_define([AC_MCPU_CPP_REQUIRE_BASH], [dnl
m4_divert_push([M4SH-SANITIZE])dnl

if test ! -x /bin/bash; then
  echo "configure: error: /bin/bash is required" >&2
  exit 1
fi

CONFIG_SHELL=/bin/bash
export CONFIG_SHELL

m4_divert_pop([M4SH-SANITIZE])dnl
])dnl


dnl ============================================================
dnl Support for Configuration Headers
dnl
dnl    configure.ac:
dnl       AC_MCPU_CPP_HEADLINE(<short-name>, <long-name>,
dnl                             <vers-var>, <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 ============================================================
m4_define([AC_MCPU_CPP_HEADLINE], [dnl
m4_divert_push([M4SH-INIT])dnl
{
  if test ".`echo dummy [$]@ | grep help`" = .; then

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

    ####### получение короткого номера версии продукта
    ####### из AC_INIT()
    $3="AC_PACKAGE_VERSION"
    AC_SUBST($3)

    ####### печать заголовка
    echo "Configuring:"
    echo ""
    echo "${TB}$1${TN} ($2), Version ${TB}${$3}${TN}"
    echo "$4"
    echo ""
  fi
}
m4_divert_pop([M4SH-INIT])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  GCC is a required part of the mcpu-cpp build environment.
dnl ============================================================
AC_DEFUN([MCPU_CPP_REQUIRE_GCC], [dnl
  AC_MSG_CHECKING([whether $CC is GNU GCC])
  AC_COMPILE_IFELSE([
    AC_LANG_SOURCE([[
#if !defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
#error mcpu-cpp requires GNU GCC
#endif
int main( void ) { return 0; }
    ]])
  ], [
    AC_MSG_RESULT([yes])
  ], [
    AC_MSG_RESULT([no])
    AC_MSG_ERROR([mcpu-cpp requires GNU GCC])
  ])
])
dnl ============================================================
dnl  Test for WIDTH of MACHINE REGISTER using GCC predefines:
dnl  ==================
dnl
dnl    configure.ac:
dnl       MCPU_CPP_GCC_REGISTER_WIDTH
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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       MCPU_CPP_GCC_TYPES
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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       MCPU_CPP_GCC_SIZEOF_TYPES
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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       MCPU_CPP_GCC_WIDTH_OF_TYPES
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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       MCPU_CPP_GCC_BYTE_ORDER
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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       MCPU_CPP_GCC_FLOAT_WORD_ORDER
dnl
dnl ============================================================
AC_DEFUN([MCPU_CPP_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 ============================================================
dnl  Read the ABI constants exported by the configured LibMPU.
dnl  mpuio-config supplies the include path and LibMPUIO includes
dnl  <libmpu.h>, so the values below are the exact constants used
dnl  by the installed LibMPU rather than independent guesses.
dnl ============================================================
AC_DEFUN([MCPU_CPP_CHECK_LIBMPU_ABI], [dnl
  AC_REQUIRE([MCPU_CPP_GCC_REGISTER_WIDTH])dnl
  AC_REQUIRE([MCPU_CPP_GCC_TYPES])dnl
  AC_REQUIRE([MCPU_CPP_GCC_SIZEOF_TYPES])dnl
  AC_REQUIRE([MCPU_CPP_GCC_WIDTH_OF_TYPES])dnl
  AC_REQUIRE([MCPU_CPP_GCC_BYTE_ORDER])dnl

  mcpu_cpp_save_CPPFLAGS="$CPPFLAGS"
  mcpu_cpp_save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS $MPUIO_CFLAGS"

  AC_MSG_CHECKING([LibMPU real I/O limit])
  AC_COMPUTE_INT([MCPU_CPP_MPU_REAL_IO_LIMIT], [MPU_REAL_IO_LIMIT],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine MPU_REAL_IO_LIMIT])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_REAL_IO_LIMIT])

  AC_MSG_CHECKING([LibMPU math-function limit])
  AC_COMPUTE_INT([MCPU_CPP_MPU_MATH_FN_LIMIT], [MPU_MATH_FN_LIMIT],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine MPU_MATH_FN_LIMIT])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_MATH_FN_LIMIT])

  AC_MSG_CHECKING([LibMPU integer maximum width])
  AC_COMPUTE_INT([MCPU_CPP_MPU_INT_MAX_WIDTH], [NB_I_MAX * BITS_PER_UNIT_T],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine NB_I_MAX * BITS_PER_UNIT_T])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_INT_MAX_WIDTH])

  AC_MSG_CHECKING([LibMPU byte order])
  AC_COMPUTE_INT([MCPU_CPP_MPU_BYTE_ORDER], [MPU_BYTE_ORDER],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine MPU_BYTE_ORDER])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_BYTE_ORDER])

  AC_MSG_CHECKING([LibMPU word order])
  AC_COMPUTE_INT([MCPU_CPP_MPU_WORD_ORDER], [MPU_WORD_ORDER],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine MPU_WORD_ORDER])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_WORD_ORDER])

  AC_MSG_CHECKING([LibMPU machine-register width])
  AC_COMPUTE_INT([MCPU_CPP_MPU_REGISTER_WIDTH], [BITS_PER_MACHINE_REGISTER],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine BITS_PER_MACHINE_REGISTER])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_REGISTER_WIDTH])

  AC_MSG_CHECKING([LibMPU addressable-unit width])
  AC_COMPUTE_INT([MCPU_CPP_MPU_UNIT_WIDTH], [BITS_PER_UNIT_T],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine BITS_PER_UNIT_T])])
  AC_MSG_RESULT([$MCPU_CPP_MPU_UNIT_WIDTH])

  AC_MSG_CHECKING([sizeof(__mpu_size_t)])
  AC_COMPUTE_INT([MCPU_CPP_SIZEOF_SIZE_T], [sizeof(__mpu_size_t)],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine sizeof(__mpu_size_t)])])
  AC_MSG_RESULT([$MCPU_CPP_SIZEOF_SIZE_T])

  AC_MSG_CHECKING([sizeof(__mpu_ssize_t)])
  AC_COMPUTE_INT([MCPU_CPP_SIZEOF_SSIZE_T], [sizeof(__mpu_ssize_t)],
                 [[#include <libmpuio.h>]],
                 [AC_MSG_ERROR([cannot determine sizeof(__mpu_ssize_t)])])
  AC_MSG_RESULT([$MCPU_CPP_SIZEOF_SSIZE_T])

  CPPFLAGS="$mcpu_cpp_save_CPPFLAGS"
  CFLAGS="$mcpu_cpp_save_CFLAGS"

  MCPU_CPP_SIZE_WIDTH=`expr "$MCPU_CPP_SIZEOF_SIZE_T" \* "$MCPU_CPP_MPU_UNIT_WIDTH"`
  MCPU_CPP_SSIZE_WIDTH=`expr "$MCPU_CPP_SIZEOF_SSIZE_T" \* "$MCPU_CPP_MPU_UNIT_WIDTH"`

  case "$MCPU_CPP_SIZE_WIDTH" in
    8|16|32|64|128|256|512|1024|2048|4096|8192|16384|32768|65536) ;;
    *) AC_MSG_ERROR([unsupported __mpu_size_t width: $MCPU_CPP_SIZE_WIDTH]) ;;
  esac
  case "$MCPU_CPP_SSIZE_WIDTH" in
    8|16|32|64|128|256|512|1024|2048|4096|8192|16384|32768|65536) ;;
    *) AC_MSG_ERROR([unsupported __mpu_ssize_t width: $MCPU_CPP_SSIZE_WIDTH]) ;;
  esac

  if test "x$MCPU_CPP_MPU_BYTE_ORDER" != "x$GCC_BYTE_ORDER"; then
    AC_MSG_ERROR([LibMPU byte order disagrees with GCC target byte order])
  fi
  if test "x$MCPU_CPP_MPU_REGISTER_WIDTH" != "x$MACHINE_REGISTER_WIDTH"; then
    AC_MSG_ERROR([LibMPU machine-register width disagrees with GCC target])
  fi

  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_REAL_IO_LIMIT], [$MCPU_CPP_MPU_REAL_IO_LIMIT],
                     [LibMPU real I/O limit used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_MATH_FN_LIMIT], [$MCPU_CPP_MPU_MATH_FN_LIMIT],
                     [LibMPU math-function limit used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_INT_MAX_WIDTH], [$MCPU_CPP_MPU_INT_MAX_WIDTH],
                     [Maximum LibMPU integer width in bits used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_BYTE_ORDER], [$MCPU_CPP_MPU_BYTE_ORDER],
                     [LibMPU byte order used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_WORD_ORDER], [$MCPU_CPP_MPU_WORD_ORDER],
                     [LibMPU word order used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_REGISTER_WIDTH], [$MCPU_CPP_MPU_REGISTER_WIDTH],
                     [LibMPU machine-register width used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_MPU_UNIT_WIDTH], [$MCPU_CPP_MPU_UNIT_WIDTH],
                     [LibMPU addressable-unit width used by mcpu-cpp.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_SIZEOF_SIZE_T], [$MCPU_CPP_SIZEOF_SIZE_T],
                     [Size of __mpu_size_t in bytes.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_SIZE_WIDTH], [$MCPU_CPP_SIZE_WIDTH],
                     [Width of __mpu_size_t in bits.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_SIZEOF_SSIZE_T], [$MCPU_CPP_SIZEOF_SSIZE_T],
                     [Size of __mpu_ssize_t in bytes.])
  AC_DEFINE_UNQUOTED([MCPU_CPP_SSIZE_WIDTH], [$MCPU_CPP_SSIZE_WIDTH],
                     [Width of __mpu_ssize_t in bits.])
])