summaryrefslogtreecommitdiff
path: root/acsite.m4
diff options
context:
space:
mode:
Diffstat (limited to 'acsite.m4')
-rw-r--r--acsite.m4797
1 files changed, 797 insertions, 0 deletions
diff --git a/acsite.m4 b/acsite.m4
new file mode 100644
index 0000000..8b4c011
--- /dev/null
+++ b/acsite.m4
@@ -0,0 +1,797 @@
+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.])
+])
generated by cgit v1.2.3 (git 2.39.0) at 2026-10-04 08:30:03 +0300