[BACK]Return to configure.ac CVS log [TXT] [DIR] Up to [Isaki's NoNo m68k/m88k emulator] / nono
File:  [Isaki's NoNo m68k/m88k emulator] / nono / configure.ac
Revision 1.1.1.20 (vendor branch): download - view: text, annotated - select for diffs
Wed Apr 29 17:05:56 2026 UTC (2 months, 3 weeks ago) by root
Branches: MAIN, Isaki
CVS tags: v027, HEAD
nono 1.7.0

#
# nono
# Copyright (C) 2020 nono project
# Licensed under nono-license.txt
#

AC_PREREQ([2.71])
AC_INIT([nono],[0.0],[])
AC_CONFIG_SRCDIR(wx/wxapp.cpp)
AC_CONFIG_AUX_DIR([scripts])

# Checks for programs.
AC_PROG_CXX
AC_PROG_CC
AC_PROG_INSTALL

# OS
AC_CANONICAL_HOST
AC_SUBST([host_cpu])

# コンパイラをチェック。今のところ clang/gcc のみ。
# (autoconf がやってる gcc かどうかのチェックは clang を検出できず使えない)
AC_MSG_CHECKING(for compiler)
if test -n "`${CC} -v 2>&1 | grep clang`" ; then
	AC_MSG_RESULT([clang])
	COMPILER=CLANG
elif test -n "`${CC} -v 2>&1 | grep GCC`"; then
	AC_MSG_RESULT([gcc])
	COMPILER=GCC
else
	AC_MSG_RESULT([unknown])
	COMPILER=
fi
AC_SUBST([COMPILER])

# C++ のバージョンをチェック
CXX_STD=-std=c++14
AC_LANG_PUSH([C++])
AC_MSG_CHECKING(for ${CXX_STD})
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXX_STD} ${CXXFLAGS}"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])],
	AC_MSG_RESULT([yes]),
	AC_MSG_ERROR("*** C++ compiler '${CXX}' doesn't support ${CXX_STD}."))
CXXFLAGS="${old_CXXFLAGS}"
CXX="${CXX} ${CXX_STD}"
AC_LANG_POP([C++])

# C コンパイラのワーニングオプション
AC_LANG_PUSH([C])
AC_DEFUN([ADD_CC_WARN_IF],[
	AC_MSG_CHECKING([whether cc accepts $1])
	old_CFLAGS="${CFLAGS}"
	CFLAGS="${CFLAGS} -Werror $1"
	AC_COMPILE_IFELSE([
		AC_LANG_PROGRAM([], [])
	], [
		AC_MSG_RESULT([yes])
		eval `echo cc_has$1=yes | sed -e 's/-/_/g'`
		WARNFLAGS_C="${WARNFLAGS_C} $1"
	], [
		AC_MSG_RESULT([no])
	])
	CFLAGS="${old_CFLAGS}"
])
ADD_CC_WARN_IF(-Wcast-qual)
ADD_CC_WARN_IF(-Wextra-semi)
ADD_CC_WARN_IF(-Wlogical-op)
ADD_CC_WARN_IF(-Wmissing-prototypes)
ADD_CC_WARN_IF(-Wmissing-variable-declarations)
# -Wshadow-local があればそっちを使う(gcc>=7)、なければ -Wshadow (clang)
ADD_CC_WARN_IF(-Wshadow-local)
if test x"${cc_has_Wshadow_local}" != xyes; then
	ADD_CC_WARN_IF(-Wshadow)
fi
ADD_CC_WARN_IF(-Wstring-conversion)
ADD_CC_WARN_IF(-Wtype-limits)
AC_LANG_POP([C])
AC_SUBST([WARNFLAGS_C])

# C++ コンパイラのワーニングオプション
# (AC_LANG は C++ のまま継続する)
AC_LANG([C++])
AC_DEFUN([ADD_CXX_WARN_IF],[
	AC_MSG_CHECKING([whether c++ accepts $1])
	old_CXXFLAGS="${CXXFLAGS}"
	CXXFLAGS="${CXXFLAGS} -Werror $1"
	AC_COMPILE_IFELSE([
		AC_LANG_PROGRAM([], [])
	], [
		AC_MSG_RESULT([yes])
		eval `echo cxx_has$1=yes | sed -e 's/-/_/g'`
		WARNFLAGS_CXX="${WARNFLAGS_CXX} $1"
	], [
		AC_MSG_RESULT([no])
	])
	CXXFLAGS="${old_CXXFLAGS}"
])
ADD_CXX_WARN_IF(-Wcast-qual)
ADD_CXX_WARN_IF(-Wextra-semi)
ADD_CXX_WARN_IF(-Wimplicit-fallthrough)
ADD_CXX_WARN_IF(-Winconsistent-missing-destructor-override)
ADD_CXX_WARN_IF(-Winconsistent-missing-override)
ADD_CXX_WARN_IF(-Wlogical-op)
ADD_CXX_WARN_IF(-Wmissing-prototypes)
ADD_CXX_WARN_IF(-Wmissing-variable-declarations)
# -Wshadow-local があればそっちを使う(gcc>=7)、なければ -Wshadow (clang)
ADD_CXX_WARN_IF(-Wshadow-local)
if test x"${cxx_has_Wshadow_local}" != xyes; then
	ADD_CXX_WARN_IF(-Wshadow)
fi
ADD_CXX_WARN_IF(-Wstring-conversion)
ADD_CXX_WARN_IF(-Wsuggest-destructor-override)
ADD_CXX_WARN_IF(-Wsuggest-override)
# gcc14 が C++14 に対しても C++20 のエラーを出そうとする。は??
ADD_CXX_WARN_IF(-Wno-template-id-cdtor)
ADD_CXX_WARN_IF(-Wtype-limits)
ADD_CXX_WARN_IF(-Wvla-extension)
AC_SUBST([WARNFLAGS_CXX])

# コンパイラが AVX2 をサポートしているか。
AC_ARG_ENABLE([avx2],
	[AS_HELP_STRING([--disable-avx2], [disable avx2 support])],
	[],
	[enable_avx2=yes])

AS_IF([test x"${enable_avx2}" != x"no"], [
	AC_MSG_CHECKING(whether the compiler supports AVX2)
	if test x"${host_cpu}" = x"x86_64"; then
		if test x"${host_cpu}" = x"${build_cpu}"; then
			old_CXXFLAGS="${CXXFLAGS}"
			CXXFLAGS="${CXXFLAGS} -mavx2"
			AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
					#include <x86intrin.h>
				], [
					#if !defined(__AVX2__)
					#error __AVX2__ is not defined by the compiler.
					#endif
					__m256i v;
				])], [
					have_avx2=yes
				])
			CXXFLAGS="${old_CXXFLAGS}"
		fi
	fi
	if test x"${have_avx2}" = x"yes"; then
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_AVX2])
		AC_SUBST(HOST_HAS_AVX2, yes)
	else
		AC_MSG_RESULT([no])
	fi
], [
])

# コンパイラが NEON をサポートしているか。
AC_ARG_ENABLE([neon],
	[AS_HELP_STRING([--disable-neon], [disable NEON support])],
	[],
	[enable_neon=yes])

AS_IF([test x"${enable_neon}" != x"no"], [
	AC_MSG_CHECKING(whether the compiler supports NEON)
	if test x"${host_cpu}" = x"aarch64"; then
		if test x"${host_cpu}" = x"${build_cpu}"; then
			old_CXXFLAGS="${CXXFLAGS}"
			AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
				#include <arm_neon.h>
			], [
				uint8x16_t v;
			])], [
				have_neon=yes
			])
			CXXFLAGS="${old_CXXFLAGS}"
		fi
	fi
	if test x"${have_neon}" = x"yes"; then
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_NEON])
		AC_SUBST(HOST_HAS_NEON, yes)
	else
		AC_MSG_RESULT([no])
	fi
], [
])

# Checks for libraries.

# Checks for header files.
AC_CHECK_HEADERS([alsa/asoundlib.h])
AC_CHECK_HEADERS([bsd/bsd.h])
AC_CHECK_HEADERS([bsd/stdio.h])
AC_CHECK_HEADERS([byteswap.h])
AC_CHECK_HEADERS([endian.h])
AC_CHECK_HEADERS([kqueue/sys/event.h])
AC_CHECK_HEADERS([pthread_np.h])
AC_CHECK_HEADERS([sched.h])
AC_CHECK_HEADERS([sndio.h])
AC_CHECK_HEADERS([sys/audioio.h])
AC_CHECK_HEADERS([sys/cpuset.h])
AC_CHECK_HEADERS([sys/endian.h])
AC_CHECK_HEADERS([sys/event.h])
AC_CHECK_HEADERS([net/bpf.h])
AC_CHECK_HEADERS([net/if_tap.h])
AC_CHECK_HEADERS([linux/if_tun.h])
AC_CHECK_HEADERS([libkern/OSByteOrder.h])
AC_CHECK_HEADERS([machine/endian.h])

# Linux で <kqueue/sys/event.h> がなければここで停止したほうがいい
case "${host_os}" in
 linux*)
	if test "$ac_cv_header_kqueue_sys_event_h" != "yes"; then
		AC_MSG_ERROR([*** kqueue is not found.
*** If you use Ubuntu, sudo apt install libkqueue-dev])
	fi
	;;
esac

# Checks for typedefs, structures, and compiler characteristics.
AC_CHECK_HEADER_STDBOOL
#AC_C_INLINE
#AC_TYPE_INT16_T
#AC_TYPE_INT32_T
#AC_TYPE_INT64_T
#AC_TYPE_INT8_T
#AC_TYPE_SIZE_T
#AC_TYPE_UINT16_T
#AC_TYPE_UINT32_T
#AC_TYPE_UINT64_T
#AC_TYPE_UINT8_T

AC_MSG_CHECKING(for cpuset_t)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	]], [[
		cpuset_t set;
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CPUSET_T)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for cpuset_t *)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	]], [[
		cpuset_t *set;
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CPUSET_T_P)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for cpu_set_t)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <sched.h>
	]], [[
		cpu_set_t set;
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CPU_SET_T)
	], [
		AC_MSG_RESULT(no)
	])


# __builtin

AC_MSG_CHECKING(for __builtin_assume)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		__builtin_assume(1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_ASSUME)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bitreverse8)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bitreverse8(1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BITREVERSE8)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bitreverse16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bitreverse16(1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BITREVERSE16)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bitreverse32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bitreverse32(1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BITREVERSE32)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bswap16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bswap16(0);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BSWAP16)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bswap32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bswap32(0);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BSWAP32)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_bswap64)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_bswap64(0);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_BSWAP64)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_expect)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
		if (__builtin_expect(1, 1)) return 0;
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_EXPECT)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_rotateleft32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_rotateleft32(1, 1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_ROTATELEFT32)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_rotateright32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],
	[[
		return __builtin_rotateright32(1, 1);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_ROTATERIGHT32)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __builtin_unreachable)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
		__builtin_unreachable();
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___BUILTIN_UNREACHABLE)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for __attribute__((__fallthrough__)))
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXXFLAGS} -Wall -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
	[
		extern int x;
		switch (x) {
		 case 0:
			__attribute__((__fallthrough__));
		 case 1:
			break;
		}
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE___ATTRIBUTE_FALLTHROUGH])
	], [
		AC_MSG_RESULT([no])
	])
CXXFLAGS="${old_CXXFLAGS}"

dnl とりあえず __format__ までしか調べてないので、
dnl その中の __printf__ とかまで調べる必要ができたら直すこと。
AC_MSG_CHECKING(for __attribute__((__format__)))
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXXFLAGS} -Wall -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
	[
		extern int f(const char *f, ...)
			__attribute__((__format__(__printf__, 1, 2)));
	], [])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE___ATTRIBUTE_FORMAT])
	], [
		AC_MSG_RESULT([no])
	])
CXXFLAGS="${old_CXXFLAGS}"

AC_MSG_CHECKING(for __attribute__((no_sanitize)))
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXXFLAGS} -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
	[
		__attribute__((no_sanitize("undefined")))
		int func() { return 0; }
	], [])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE___ATTRIBUTE_NO_SANITIZE])
	], [
		AC_MSG_RESULT([no])
	])
CXXFLAGS="${old_CXXFLAGS}"


AC_MSG_CHECKING(for __attribute__((__packed__)))
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXXFLAGS} -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
	[
		struct x { char a; int b; } __attribute__((__packed__));
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE___ATTRIBUTE_PACKED])
	], [
		AC_MSG_RESULT([no])
	])
CXXFLAGS="${old_CXXFLAGS}"

AC_MSG_CHECKING(for __attribute__((__unused__)))
old_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${CXXFLAGS} -Wunused-variable -Werror"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
	[
		int a __attribute__((__unused__));
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE___ATTRIBUTE_UNUSED])
	], [
		AC_MSG_RESULT([no])
	])
CXXFLAGS="${old_CXXFLAGS}"

# Checks for library functions.
#AC_FUNC_MALLOC
#AC_FUNC_MMAP

AC_MSG_CHECKING(for bswap16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		bswap16(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP16])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for bswap32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		bswap32(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP32])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for bswap64)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		bswap64(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP64])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for bswap_16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_BYTESWAP_H)
		#include <byteswap.h>
		#endif
	], [
		bswap_16(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP_16])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for bswap_32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_BYTESWAP_H)
		#include <byteswap.h>
		#endif
	], [
		bswap_32(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP_32])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for bswap_64)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_BYTESWAP_H)
		#include <byteswap.h>
		#endif
	], [
		bswap_64(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_BSWAP_64])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for swap16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		swap16(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_SWAP16])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for swap32)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		swap32(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_SWAP32])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for swap64)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
	], [
		swap64(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_SWAP64])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for htobe16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_ENDIAN_H)
		#include <endian.h>
		#endif
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
		#if defined(HAVE_MACHINE_ENDIAN_H)
		#include <machine/endian.h>
		#endif
	], [
		htobe16(0);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_HTOBE16])
	], [
		AC_MSG_RESULT([no])
	])

dnl HTOBE16(x) は x = htobe16(x) するもので、htobe16() とは別物。
dnl ところが autoconf は小文字を大文字にした変数名を作る文化なので
dnl こっちは INPLACE_HTOBE16 とかにしておく。
AC_MSG_CHECKING(for HTOBE16)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_ENDIAN_H)
		#include <endian.h>
		#endif
		#if defined(HAVE_SYS_ENDIAN_H)
		#include <sys/endian.h>
		#endif
		#if defined(HAVE_MACHINE_ENDIAN_H)
		#include <machine/endian.h>
		#endif
	], [
		uint16_t x = 0;
		HTOBE16(x);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_INPLACE_HTOBE16])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for CPU_COUNT)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	], [
		#if defined(HAVE_CPUSET_T)
		cpuset_t set;
		#elif defined(HAVE_CPU_SET_T)
		cpu_set_t set;
		#endif
		CPU_COUNT(&set);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPU_COUNT])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for CPU_ISSET)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	], [
		#if defined(HAVE_CPUSET_T)
		cpuset_t set;
		#elif defined(HAVE_CPU_SET_T)
		cpu_set_t set;
		#endif
		CPU_ISSET(0, &set);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPU_ISSET])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for CPU_SET)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	], [
		#if defined(HAVE_CPUSET_T)
		cpuset_t set;
		#elif defined(HAVE_CPU_SET_T)
		cpu_set_t set;
		#endif
		CPU_SET(0, &set);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPU_SET])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for CPU_ZERO)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#if defined(HAVE_SCHED_H)
		#include <sched.h>
		#endif
		#if defined(HAVE_SYS_CPUSET_H)
		#include <sys/cpuset.h>
		#endif
	], [
		#if defined(HAVE_CPUSET_T)
		cpuset_t set;
		#elif defined(HAVE_CPU_SET_T)
		cpu_set_t set;
		#endif
		CPU_ZERO(&set);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPU_ZERO])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for cpuset_create)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sched.h>
	], [
		cpuset_create();
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPUSET_CREATE])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for cpuset_isset)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sched.h>
	], [
		cpuset_isset(0, NULL);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPUSET_ISSET])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for cpuset_set)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sched.h>
	], [
		cpuset_set(0, NULL);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPUSET_SET])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for cpuset_size)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sched.h>
	], [
		cpuset_size(NULL);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_CPUSET_SIZE])
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for statfs)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sys/statfs.h>
	], [
		struct statfs buf;
		statfs("", &buf);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_STATFS])
		have_statxxfs=statfs
	], [
		AC_MSG_RESULT([no])
	])

AC_MSG_CHECKING(for statvfs)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sys/statvfs.h>
	], [
		struct statvfs buf;
		statvfs("", &buf);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_STATVFS])
		have_statxxfs=statvfs
	], [
		AC_MSG_RESULT([no])
	])

if test -z "${have_statxxfs}"; then
	AC_MSG_FAILURE([*** No statfs() nor statvfs() found])
fi

AC_CHECK_MEMBER([struct stat.st_mtimespec], [
		AC_DEFINE([HAVE_STAT_ST_TIMESPEC])
	], [], [
		#include <sys/stat.h>
	])

AC_MSG_CHECKING(for timegm)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <time.h>
	], [
		timegm(NULL);
	])], [
		AC_MSG_RESULT([yes])
	], [
		AC_MSG_RESULT([no])
		AC_MSG_FAILURE([*** No timegm() found])
	])

AC_MSG_CHECKING(for pthread_getname_np)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		char name[32];
		pthread_getname_np(pthread_self(), name, sizeof(name));
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_GETNAME_NP)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_get_name_np)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		char name[32];
		pthread_get_name_np(pthread_self(), name, sizeof(name));
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_GET_NAME_NP)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_setname_np(name))
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		pthread_setname_np("");
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_name)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_setname_np(thread, name))
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		pthread_setname_np(pthread_self(), "");
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_th_name)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_setname_np(thread, name, arg))
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		pthread_setname_np(pthread_self(), "", (void*)0);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_th_name_arg)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_set_name_np(thread, name))
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		pthread_set_name_np(pthread_self(), "");
	]])],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_SET_NAME_NP_th_name)
	], [
		AC_MSG_RESULT(no)
	])

AC_MSG_CHECKING(for pthread_setaffinity_np)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <pthread.h>
		#if defined(HAVE_PTHREAD_NP_H)
		#include <pthread_np.h>
		#endif
	]], [[
		pthread_setaffinity_np(pthread_self(), 0, NULL);
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PTHREAD_SETAFFINITY_NP)
	], [
		AC_MSG_RESULT(no)
	])


#
# Network
#
AC_MSG_CHECKING(for AF_PACKET)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
		#include <sys/socket.h>
	]], [[
		AF_PACKET;
	]])], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_HOSTNET_AFPACKET)
		AC_SUBST(HOSTNET_AFPACKET, yes)
		netdriver_afpacket=yes
	], [
		AC_MSG_RESULT(no)
		netdriver_afpacket=no
	])

AC_MSG_CHECKING(for tap(4))
case "${host_os}" in
 linux*)
	if test x"$ac_cv_header_linux_if_tun_h" = xyes; then
		netdriver_tap=yes
	fi
	;;
 openbsd*)
	# OpenBSD has no <net/if_tap.h> but supports tap(4).
	netdriver_tap=yes
	;;
 *)
	if test x"$ac_cv_header_net_if_tap_h" = xyes; then
		netdriver_tap=yes
	fi
	;;
esac
if test x"$netdriver_tap" = xyes; then
	AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_HOSTNET_TAP])
	AC_SUBST([HOSTNET_TAP], [yes])
else
	AC_MSG_RESULT([no])
fi

AC_MSG_CHECKING(for bpf(4))
if test x"$ac_cv_header_net_bpf_h" = xyes; then
	AC_MSG_RESULT([yes])
	AC_DEFINE([HAVE_HOSTNET_BPF])
	AC_SUBST([HOSTNET_BPF], [yes])
	netdriver_bpf=yes
else
	AC_MSG_RESULT([no])
	netdriver_bpf=no
fi

#
# Other libraries
#

dnl # MY_CHECK_LIB($1=name, $2=libs, $3=include, $4=src)
dnl #  name は変数名に付けるライブラリ名 ("libslirp" とか "libiconv" とか)
dnl #  libs はライブラリ引数 ("-lslirp" とか)
dnl #  include, src は検出用のヘッダとソース片。
dnl #  ただし src は実行可能で害のないものを指定すること。
dnl # PATHS からライブラリを探してそのパスとかをセットする。
dnl #  has_${name}=<yes|no>
dnl #  $CPPFLAGS_${name}=...
dnl #  $LIBS_${name}=...
AC_DEFUN([MY_CHECK_LIB], [
	AC_MSG_CHECKING([for $1])
	old_CPPFLAGS=${CPPFLAGS}
	old_LIBS=${LIBS}
	for path in ${PATHS}; do
		case ${path} in
		 none)
			LIBS="$2"
			;;
		 *)
			CPPFLAGS="-I${path}/include"
			LIBS="-L${path}/lib $2"
			;;
		esac
		AC_LINK_IFELSE([AC_LANG_PROGRAM([$3], [$4])], [
			has_$1=yes

			dnl リンクできれば -Wl,-R が必要か調べる。
			AC_RUN_IFELSE([AC_LANG_SOURCE([[
				$3
				int main() {
					$4;
					return 0;
				}
			]])], [
				dnl 実行できれば追加しなくていい。
			], [
				LIBS="-L${path}/lib -Wl,-R,${path}/lib $2"
			])

			break
		], [
			has_$1=no
		])
	done
	if test x"${has_$1}" = x"yes"; then
		AC_MSG_RESULT([yes])
		CPPFLAGS_$1=${CPPFLAGS}
		LIBS_$1=${LIBS}
	else
		AC_MSG_RESULT([no])
	fi
	CPPFLAGS=${old_CPPFLAGS}
	LIBS=${old_LIBS}
])

PATHS="none /usr/pkg /usr/local"

# libbsd on Linux
AC_CHECK_LIB(c, getprogname, ,)
AC_CHECK_LIB(bsd, getprogname,
	LIBS="${LIBS} -lbsd"
)
# なければ停止する
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
	[
		#include <stdlib.h>
		#include "confdefs.h"
		#if defined(HAVE_BSD_BSD_H)
		#include <bsd/bsd.h>
		#endif
	], [
		getprogname()
	])], [
	# nothing to do on success
	], [
		AC_MSG_ERROR([*** getprogname is not found.
*** If you use Ubuntu, sudo apt install libbsd-dev])
	]
)

# libkqueue on Linux
AC_CHECK_LIB(kqueue, kqueue,
	LIBS="${LIBS} -lkqueue"
)

AC_CHECK_LIB(z, gzclose,
	LIBS="${LIBS} -lz",
	[AC_MSG_ERROR([*** zlib is not found.
*** If use use Ubuntu, sudo apt install zlib1g-dev])]
)

# libslirp
AC_ARG_WITH([libslirp],
	[AS_HELP_STRING([--without-libslirp],
		[disable usermode network (using SLIRP)])],
	[],
	[with_libslirp=yes])

AS_IF([test "x$with_libslirp" != "xno"], [
	MY_CHECK_LIB([libslirp], [-lslirp], [
		#include <slirp/libslirp.h>
	], [
		slirp_version_string();
	])
	if test x"${has_libslirp}" = x"yes"; then
		AC_DEFINE([HAVE_HOSTNET_SLIRP])
		AC_SUBST([HOSTNET_SLIRP], [yes])
		AC_SUBST([CPPFLAGS_SLIRP], [${CPPFLAGS_libslirp}])
		AC_SUBST([LIBS_SLIRP], [${LIBS_libslirp}])
	else
		AC_MSG_ERROR([*** libslirp is not found.
*** If use use pkgsrc, install net/libslirp.
*** If you use Ubuntu, sudo apt install libslirp-dev.
*** Or specify --without-libslirp (it disables hostnet-driver=usermode).])
	fi
], [
	AC_SUBST([HOSTNET_SLIRP], [no])
])

# ALSA
case "${host_os}" in
 linux*)
	default_alsa=yes
	;;
 *)
	default_alsa=no
	;;
esac
AC_ARG_WITH([alsa],
	[AS_HELP_STRING([--with-alsa],
		[enable ALSA support (default:yes on Linux, otherwise no)])],
	[with_alsa=${withval}],
	[with_alsa=${default_alsa}])
sounddriver_alsa=no
if test x"${with_alsa}" = xyes; then
	AC_CHECK_LIB(asound, snd_pcm_open,
		[has_asound=yes],
		[has_asound=no])
	if test x"${ac_cv_header_alsa_asoundlib_h}" = xyes -a \
	        x"${ac_cv_lib_asound_snd_pcm_open}" = xyes; then
		AC_DEFINE([HAVE_HOSTSOUND_ALSA])
		AC_SUBST([HOSTSOUND_ALSA], [yes])
		LIBS_SOUND="${LIBS_SOUND} -lasound"
		sounddriver_alsa=yes
	else
		AC_MSG_ERROR([*** <alsa/asoundlib.h> or libasound not found.
*** If you use Ubuntu, sudo apt install libasound2-dev.
*** Or specify --without-alsa (it disables hostsound-driver=alsa).])
	fi
fi

# NetBSD audio
if test x"${ac_cv_header_sys_audioio_h}" = xyes; then
	AC_MSG_CHECKING(for AUDIO_GETINFO)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
		#include <sys/ioctl.h>
		#include <sys/audioio.h>
		#include <unistd.h>
	], [
		struct audio_info info;
		AUDIO_INITINFO(&info);
		ioctl(0, AUDIO_GETINFO, &info);
	])], [
		AC_MSG_RESULT([yes])
		AC_DEFINE([HAVE_HOSTSOUND_NETBSD])
		AC_SUBST([HOSTSOUND_NETBSD], [yes])
		sounddriver_netbsd=yes
	], [
		AC_MSG_RESULT([no])
		sounddriver_netbsd=no
	])
fi

# OpenBSD sndio
if test x"${ac_cv_header_sndio_h}" = xyes; then
	AC_DEFINE([HAVE_HOSTSOUND_SNDIO])
	AC_SUBST([HOSTSOUND_SNDIO], [yes])
	LIBS_SOUND="${LIBS_SOUND} -lsndio"
	sounddriver_sndio=yes
else
	sounddriver_sndio=no
fi

AC_SUBST([LIBS_SOUND], [${LIBS_SOUND}])

# wxWidgets
AC_ARG_WITH([gui],
	[AS_HELP_STRING([--without-gui], [disable GUI support])],
	[],
	[with_gui=yes])

AS_IF([test "x$with_gui" != xno], [
	AC_MSG_CHECKING(for wx-config)
	wxconfig_paths="${WX_CONFIG} wx-config-3.2 wx-config-3.0 wx-config"
	wxconfig=""
	for c in ${wxconfig_paths}; do
		ver=`$c --version 2>&1 | cut -f 1 -d .`
		if test "$ver" = "3"; then
			wxconfig=$c
			break
		fi
	done
	if test -z "$wxconfig"; then
		AC_MSG_ERROR([*** wxWidgets-3.2 nor -3.0 not found in ${wxconfig_paths}
*** If you use pkgsrc, install x11/wxGTK32.
*** If you use Ubuntu, sudo apt install libwxgtk3.0-gtk3-dev])
	else
		AC_MSG_RESULT([$wxconfig])

		AC_MSG_CHECKING(for wxWidgets version)
		wxversion=`$wxconfig --version`
		AC_MSG_RESULT([$wxversion])
		wxmajorminor=`echo $wxversion | awk -F . '{print $1 $2}'`
		AC_SUBST([WX_MAJORMINOR], [${wxmajorminor}])

		wxcppflags=`$wxconfig --cppflags`
		wxlibs=`$wxconfig --libs`

		case "${host_os}" in
		 darwin*)
			# XXX -framework AudioToolbox が指定されているとリンカがこけるorz
			wxlibs=[`echo $wxlibs | sed -e 's/-framework AudioToolbox//'`]
			;;
		esac

		dnl -Wl,-R が必要か調べる。
		AC_MSG_CHECKING([whether wx-config requires -Wl,-R])
		old_CPPFLAGS="${CPPFLAGS}"
		old_LIBS="${LIBS}"
		CPPFLAGS="${CPPFLAGS} ${wxcppflags}"
		LIBS="${LIBS} ${wxlibs}"
		AC_RUN_IFELSE([AC_LANG_SOURCE([[
			#include <wx/wx.h>
			int main() {
				wxInitializer init;
				return !init;
			}
		]])], [
			dnl 実行できれば追加しなくていい。
			AC_MSG_RESULT([no])
		], [
			AC_MSG_RESULT([yes])
			wxlibs=[`echo $wxlibs | sed -e 's/-L\([^ ]*\) /-L\1 -Wl,-R,\1 /'`]
		])
		CPPFLAGS="${old_CPPFLAGS}"
		LIBS="${old_LIBS}"

		AC_SUBST([WITH_GUI], [yes])
		AC_SUBST([CPPFLAGS_WXWIDGETS], [$wxcppflags])
		AC_SUBST([LIBS_WXWIDGETS], [$wxlibs])
	fi

	# gettext
	AC_CHECK_TOOL([MSGFMT], [msgfmt], [:])
	if test $MSGFMT = [:]; then
		AC_MSG_ERROR([*** msgfmt not found.
*** If you use pkgsrc, install devel/gettext-tools.
*** If you use Ubuntu, sudo apt install gettext])
	fi
], [
	AC_SUBST([WITH_GUI], [no])
])

# iconv は util/ でのみ必要。
MY_CHECK_LIB([libiconv], [-liconv], [
	#include <iconv.h>
], [
	iconv_open("", "");
])
AC_SUBST([CPPFLAGS_ICONV], [${CPPFLAGS_libiconv}])
AC_SUBST([LIBS_ICONV], [${LIBS_libiconv}])

if test x"${has_libiconv}" = x"yes"; then
	AC_MSG_CHECKING(whether iconv needs const)
	old_CPPFLAGS="${CPPFLAGS}"
	CPPFLAGS="${CPPFLAGS} ${CPPFLAGS_libiconv} -Werror"
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
			#include <iconv.h>
		]], [[
			const char **a;
			iconv(0, a, 0, 0, 0);
		]])], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_ICONV_CONST)
		], [
			AC_MSG_RESULT(no)
		])
	CPPFLAGS="${old_CPPFLAGS}"
fi

AC_CONFIG_FILES([Makefile.cfg])
AC_CONFIG_HEADERS([config-nono.h])
AC_OUTPUT

# サマリを表示
echo ""
echo "Configuration summary:"
echo -n "HostNet supports:			"
if test x"$netdriver_afpacket" = xyes; then
	echo -n " afpacket"
fi
if test x"$netdriver_bpf" = xyes; then
	echo -n " bpf"
fi
if test x"$has_libslirp" = xyes; then
	echo -n " slirp"
fi
if test x"$netdriver_tap" = xyes; then
	echo -n " tap"
fi
echo ""
echo -n "HostSound supports:			"
if test x"$sounddriver_alsa" = xyes; then
	echo -n " alsa"
fi
if test x"$sounddriver_netbsd" = xyes; then
	echo -n " netbsd"
fi
if test x"$sounddriver_sndio" = xyes; then
	echo -n " sndio"
fi
echo ""
unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.