CMakeLists.txt

message(STATUS "cmake version: ${CMAKE_VERSION}")
cmake_minimum_required(VERSION 3.10)

cmake_policy(SET CMP0048 NEW) # project() sets the VERSION variables
project(libiio LANGUAGES C VERSION 1.0)

# Set the default install path to /usr
if (NOT WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
	set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "default install path" FORCE)
endif()

if (MINGW)
	set(WIN32 ON)
endif()

set(LIBIIO_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
set(LIBIIO_VERSION_MINOR ${PROJECT_VERSION_MINOR})
set(VERSION "${PROJECT_VERSION}")
if (WIN32)
	string(TIMESTAMP BUILD_YEAR "%Y")
	string(REPLACE "." "," LIBIIO_FILEVERSION ${VERSION})
endif()

if (NOT CMAKE_BUILD_TYPE)
	set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
		"Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel."
		FORCE)
	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS None Debug Release RelWithDebInfo MinSizeRel)
endif()

option(BUILD_SHARED_LIBS "Build shared libraries" ON)

add_library(iio
	attr.c
	backend.c
	block.c
	buffer.c
	channel.c
	context.c
	device.c
	events.c
	library.c
	mask.c
	scan.c
	sort.c
	stream.c
	task.c
	utilities.c
	${CMAKE_CURRENT_BINARY_DIR}/iio-config.h
)

if (CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
	# Specify that the symbols referenced by Libiio should be searched from
	# within Libiio itself first. This makes sure that the library won't
	# call the symbols from the compat layer if the compat layer is used.

	# TODO: Use cmake_link_options() in CMake 3.13+
	SET(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -Wl,-Bsymbolic")
	SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-Bsymbolic")
endif()

if (CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|MSVC")
	option(LIBIIO_COMPAT "Add compatibility layer for libiio 0.x" ON)
	if (LIBIIO_COMPAT)
		add_library(iio-compat compat.c)
		if (WIN32)
			target_sources(iio-compat PRIVATE dynamic-windows.c)
			target_compile_definitions(iio-compat PRIVATE
				LIBIIO1_NAME="iio${PROJECT_VERSION_MAJOR}.dll"
			)
		else()
			target_sources(iio-compat PRIVATE dynamic-unix.c)
			target_link_libraries(iio-compat PRIVATE dl)
			target_compile_definitions(iio-compat PRIVATE
				LIBIIO1_NAME="libiio.so.${PROJECT_VERSION_MAJOR}"
			)
		endif()

		target_include_directories(iio-compat PUBLIC ${CMAKE_BINARY_DIR} include)
		target_compile_definitions(iio-compat PRIVATE LIBIIO_COMPAT_EXPORTS)
		set(IIO_COMPAT_LIB iio-compat)

		set_target_properties(iio-compat PROPERTIES
			OUTPUT_NAME iio
			NO_SONAME ON
			VERSION 0.99
			SOVERSION 0
		)
		if (NOT WIN32)
			set_target_properties(iio-compat PROPERTIES SUFFIX .so.0)
		endif()
	endif()
endif()

if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
	option(OSX_FRAMEWORK "Create a OSX_FRAMEWORK" ON)
else()
	set(OSX_FRAMEWORK OFF)
endif()

set(IIO_PUBLIC_HEADERS include/iio/iio.h;include/iio/iio-debug.h;include/iio/iio-lock.h;include/iio/iiod-client.h)

if (CPP_BINDINGS)
	list(APPEND IIO_PUBLIC_HEADERS bindings/cpp/iiopp.h)
endif()

set_target_properties(iio PROPERTIES
	VERSION ${PROJECT_VERSION}
	SOVERSION ${PROJECT_VERSION_MAJOR}
	PUBLIC_HEADER "${IIO_PUBLIC_HEADERS}"
)
set_target_properties(iio ${IIO_COMPAT_LIB} PROPERTIES
	FRAMEWORK ${OSX_FRAMEWORK}
	C_STANDARD 99
	C_STANDARD_REQUIRED ON
	C_EXTENSIONS OFF
)
if (WIN32)
	if (MSVC)
		target_link_options(iio PUBLIC /DEBUG)
		set(LIBIIO_WIN32_PREFIX lib)
	endif()

	# On Windows, DLLs aren't suffixed with the library's version;
	# therefore the libiio 1.x DLL needs to have a different name
	# than the compatibility library.
	set_target_properties(iio PROPERTIES
		OUTPUT_NAME ${LIBIIO_WIN32_PREFIX}iio${PROJECT_VERSION_MAJOR}
	)
endif()

target_include_directories(iio PUBLIC include ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})

target_compile_definitions(iio PRIVATE LIBIIO_EXPORTS)

target_compile_definitions(iio PUBLIC
	# Request Posix 2008.09
	_POSIX_C_SOURCE=200809L __XSI_VISIBLE=500

	# Per http://www.mingw.org/wiki/Use_more_recent_defined_functions
	$<$<PLATFORM_ID:MinGW>:_WIN32_WINNT=0x600 WINVER=0x600>

	# full Single Unix Standard v3 (SUSv3) conformance (the Unix API)
	$<$<PLATFORM_ID:Darwin>:_DARWIN_C_SOURCE>

	# Set -DLIBIIO_STATIC if building statically
	$<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:LIBIIO_STATIC>
)

if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|DragonFly|OpenBSD|NetBsd")
	target_compile_definitions(iio PUBLIC __BSD_VISIBLE)
	set(CMAKE_REQUIRED_DEFINITIONS -D__BSD_VISIBLE=1)
endif()

include(GNUInstallDirs)

if (BUILD_SHARED_LIBS)
	option(WITH_MODULES "Enable support for dynamically-loaded modules" OFF)
	if (WITH_MODULES)
		target_sources(iio PRIVATE dynamic.c)
		if (WIN32)
			target_sources(iio PRIVATE dynamic-windows.c)
		else()
			target_sources(iio PRIVATE dynamic-unix.c)
			target_link_libraries(iio PRIVATE dl)
		endif()

		file(TO_NATIVE_PATH "${CMAKE_INSTALL_FULL_LIBDIR}/libiio/" IIO_MODULES_DIR)
		string(REPLACE "\\" "\\\\" IIO_MODULES_DIR ${IIO_MODULES_DIR})
	endif()
endif()

option(WITH_EXAMPLES "Build examples" OFF)
option(WITH_UTILS "Build the Libiio utility programs" ON)

if (NOT LOG_LEVEL)
	set(LOG_LEVEL Info CACHE STRING "Default log level" FORCE)
	set_property(CACHE LOG_LEVEL PROPERTY STRINGS NoLog Error Warning Info Debug)
endif()

if (NOT MAX_LOG_LEVEL)
	set(MAX_LOG_LEVEL Debug CACHE STRING "Maximum log level supported" FORCE)
	set_property(CACHE MAX_LOG_LEVEL PROPERTY STRINGS NoLog Error Warning Info Debug)
endif()

set(LEVEL_NoLog 1)
set(LEVEL_Error 2)
set(LEVEL_Warning 3)
set(LEVEL_Info 4)
set(LEVEL_Debug 5)
set(DEFAULT_LOG_LEVEL ${LEVEL_${LOG_LEVEL}})
set(MAX_LOG_LEVEL_VALUE ${LEVEL_${MAX_LOG_LEVEL}})

if (DEFAULT_LOG_LEVEL GREATER MAX_LOG_LEVEL_VALUE)
	message(SEND_ERROR "Default log level cannot be more than the maximum log level.")
endif()

if (MSVC)
	target_compile_options(iio PRIVATE /Zi /W4 /wd4200 /wd4127 /wd4100)
	# Zi produces a separate PDB file that contains all the symbolic debugging information
	# W4 displays level 1, 2, 3, and 4 (informational) warnings that aren't off by default
	# C4200: nonstandard extension used : zero-sized array in struct (usb.h)
	# C4127: conditional expression is constant (IIO_ERROR and IIO_DEBUG macros)
	# C4100: unreferenced parameter; same as -Wno-unused-parameter

	set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
	set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll.a" ".a" ".lib")

elseif (CMAKE_COMPILER_IS_GNUCC)
	if (NOT WIN32)
		target_compile_options(iio PUBLIC -fvisibility=hidden)
	endif()

	include(CheckCCompilerFlag)
	check_c_compiler_flag(-Wpedantic HAS_WPEDANTIC)
	check_c_compiler_flag(-Wshadow HAS_WSHADOW)

	target_compile_options(iio PRIVATE -Wall -Wextra -Wno-unused-parameter
		$<$<BOOL:HAS_WPEDANTIC>:-Wpedantic>
		$<$<BOOL:HAS_WSHADOW>:-Wshadow>
	)

elseif (CMAKE_C_COMPILER_ID STREQUAL "Clang")
	target_compile_options(iio PRIVATE -Wall -Wextra -pedantic -Wno-unused-parameter)
else()
	message(STATUS "Unknown compiler, please report upstream")
	message(STATUS "CMAKE_C_COMPILER_ID : " ${CMAKE_C_COMPILER_ID})
	message(STATUS "CFLAGS set to " ${CMAKE_C_FLAGS})
endif()

include(CheckSymbolExists)
check_symbol_exists(strdup "string.h" HAS_STRDUP)
check_symbol_exists(strndup "string.h" HAS_STRNDUP)
check_symbol_exists(strerror_r "string.h" HAS_STRERROR_R)
check_symbol_exists(strtok_r "string.h" HAS_STRTOK_R)
check_symbol_exists(newlocale "locale.h" HAS_NEWLOCALE)

option(ENABLE_IPV6 "Define if you want to enable IPv6 support" ON)
if (ENABLE_IPV6)
	if (WIN32)
		set(HAVE_IPV6 ON)
	else()
		check_symbol_exists(in6addr_any "netinet/in.h" HAVE_IPV6)
	endif()
	if (NOT HAVE_IPV6)
		message(SEND_ERROR "IPv6 is not available in your system.")
	endif()
endif()

option(WITH_EXTERNAL_BACKEND "Support external backend provided by the application" OFF)

option(WITH_USB_BACKEND "Enable the libusb backend" ON)
if (WITH_USB_BACKEND)
	find_package(PkgConfig)
	if (PkgConfig_FOUND)
		pkg_check_modules(LIBUSB libusb-1.0)
	endif()
	if (LIBUSB_LINK_LIBRARIES AND LIBUSB_INCLUDE_DIRS)
		set(LIBUSB_LIBRARIES ${LIBUSB_LINK_LIBRARIES})
		set(LIBUSB_INCLUDE_DIR ${LIBUSB_INCLUDE_DIRS})
	else()
		#Handle FreeBSD libusb and Linux libusb-1.0 libraries
		find_library(LIBUSB_LIBRARIES NAMES usb-1.0 usb)
		find_path(LIBUSB_INCLUDE_DIR libusb.h PATH_SUFFIXES libusb-1.0)
	endif()
	if (NOT LIBUSB_LIBRARIES OR NOT LIBUSB_INCLUDE_DIR)
		message(SEND_ERROR "Unable to find libusb-1.0 dependency.\n"
			"If you want to disable the USB backend, set WITH_USB_BACKEND=OFF.")
	else()
		list(APPEND LIBIIO_SCAN_BACKENDS usb)
		set(IIOD_CLIENT 1)
		set(NEED_LIBXML2 1)

		if (WITH_MODULES)
			option(WITH_USB_BACKEND_DYNAMIC "Build USB backend as a module instead of built-in" ON)
		else()
			set(WITH_USB_BACKEND_DYNAMIC OFF)
		endif()
		if (WITH_USB_BACKEND_DYNAMIC)
			add_library(iio-usb SHARED usb.c)
			target_link_libraries(iio-usb PRIVATE iio ${LIBUSB_LIBRARIES})
			target_include_directories(iio-usb PRIVATE ${LIBUSB_INCLUDE_DIR})
			set_target_properties(iio-usb PROPERTIES PREFIX lib)
		else()
			target_include_directories(iio PRIVATE ${LIBUSB_INCLUDE_DIR})
			target_sources(iio PRIVATE usb.c)
			target_link_libraries(iio PRIVATE ${LIBUSB_LIBRARIES})
		endif()

		set(TEMP ${CMAKE_REQUIRED_LIBRARIES})
		set(TEMP1 ${CMAKE_REQUIRED_INCLUDES})
		list(APPEND CMAKE_REQUIRED_LIBRARIES ${LIBUSB_LIBRARIES})
		list(APPEND CMAKE_REQUIRED_INCLUDES ${LIBUSB_INCLUDE_DIR})
		check_symbol_exists(libusb_get_version libusb.h HAS_LIBUSB_GETVERSION)
		set(CMAKE_REQUIRED_LIBRARIES ${TEMP})
		set(CMAKE_REQUIRED_INCLUDES ${TEMP1})

		if (NOT HAS_LIBUSB_GETVERSION)
			message(SEND_ERROR "Libusb >= 1.0.10 is required.")
		endif()
	endif()
endif()

# make sure all check_symbol_exists are before this point, otherwise they fail
# on some versions of compilers
option(COMPILE_WARNING_AS_ERROR "Make all warnings into errors" OFF)
if (MSVC)
	# why can't different CIs use the same flags?
	# Travis CI      : CI=True & TRAVIS=True
	# Appveyor       : CI=True & APPVEYOR=True
	# Azure Pipelines: TF_BUILD=True
	if(COMPILE_WARNING_AS_ERROR)
		message(STATUS "Setting -Werror")
		target_compile_options(iio PUBLIC /WX)
	endif()
elseif (CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
	option(WITH_GCOV "Build with gcov profiling flags" OFF)
	if (WITH_GCOV)
		target_compile_options(iio PRIVATE -fprofile-arcs -ftest-coverage)

		# TODO: Use cmake_link_options() in CMake 3.13+
		SET(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
		SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}  -fprofile-arcs -ftest-coverage")
	endif()
	if(COMPILE_WARNING_AS_ERROR)
		message(STATUS "Setting -Werror")
		target_compile_options(iio PUBLIC -Werror)
	endif()
else()
	message(STATUS "Unknown compiler ${CMAKE_C_COMPILER_ID}")
	message(STATUS "GCC ${CMAKE_COMPILER_IS_GNUCC}")
endif()

option(WITH_LIBTINYIIOD "Build libtinyiiod" OFF)

IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
	option(WITH_IIOD "Build the IIO Daemon" ON)
	option(WITH_LOCAL_BACKEND "Enable the local backend" ON)
endif()

set(DOXYGEN_INPUT "${CMAKE_SOURCE_DIR}")
set(DOXYGEN_STRIP_FROM_PATH "${CMAKE_SOURCE_DIR}")

if (CPP_BINDINGS)
    set(DOXYGEN_ENABLED_SECTIONS CPP_BINDINGS)
    set(DOXYGEN_INPUT "${DOXYGEN_INPUT} ${CMAKE_SOURCE_DIR}/bindings/cpp/")
    set(DOXYGEN_STRIP_FROM_PATH "${CMAKE_SOURCE_DIR}/bindings/cpp/")
    set(DOXYGEN_CPP_EXAMPLE_PATH "${CMAKE_SOURCE_DIR}/bindings/cpp/examples")
endif()

# Get the GIT hash of the latest commit
include(FindGit OPTIONAL)
if (GIT_FOUND)
	execute_process(
		COMMAND ${GIT_EXECUTABLE} rev-parse --show-toplevel
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
		OUTPUT_VARIABLE LIBIIO_GIT_REPO
		OUTPUT_STRIP_TRAILING_WHITESPACE
		ERROR_QUIET
	)

	if ("${LIBIIO_GIT_REPO}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
		execute_process(
			COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
			OUTPUT_VARIABLE LIBIIO_VERSION_GIT
			OUTPUT_STRIP_TRAILING_WHITESPACE
		)
	endif()
endif()

if (NOT LIBIIO_VERSION_GIT)
	set(LIBIIO_VERSION_GIT v${VERSION})
endif()

set(LIBIIO_VERSION ${VERSION}.g${LIBIIO_VERSION_GIT})
file(WRITE ${CMAKE_BINARY_DIR}/.version ${LIBIIO_VERSION})

if(WITH_LOCAL_BACKEND)
	if (NO_THREADS)
		message(SEND_ERROR "Local backend require threads.")
	endif()

	target_sources(iio PRIVATE local.c)

	# Link with librt if present
	find_library(LIBRT_LIBRARIES rt)
	if (LIBRT_LIBRARIES)
		target_link_libraries(iio PRIVATE ${LIBRT_LIBRARIES})
	endif()

	option(WITH_LOCAL_CONFIG "Read local context attributes from /etc/libiio.ini" ON)
	if (WITH_LOCAL_CONFIG)
		target_sources(iio PRIVATE deps/libini/libini.c)
	endif()

	option(WITH_HWMON "Add compatibility with the hardware monitoring (hwmon) subsystem" ON)

	option(WITH_LOCAL_DMABUF_API "Add support for the DMABUF API" ON)
	if (WITH_LOCAL_DMABUF_API)
		target_sources(iio PRIVATE local-dmabuf.c)
	endif()

	option(WITH_LOCAL_MMAP_API "Use the mmap API provided in Analog Devices' kernel (not upstream)" ON)
	if (WITH_LOCAL_MMAP_API)
		target_sources(iio PRIVATE local-mmap.c)

		find_library(LIBATOMIC_LIBRARIES atomic)
		if (NOT LIBATOMIC_LIBRARIES)
			# Workaround for some distributions, where the libatomic.so is
			# hidden inside /usr/lib/gcc/, where CMake won't search.
			# Point CMake to the .so.1 instead.

			set(OLD_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
			set(CMAKE_FIND_LIBRARY_SUFFIXES ".so.1")
			find_library(LIBATOMIC_LIBRARIES atomic)
			set(CMAKE_FIND_LIBRARY_SUFFIXES ${OLD_LIBRARY_SUFFIXES})
		endif()

		if (LIBATOMIC_LIBRARIES)
			target_link_libraries(iio PRIVATE ${LIBATOMIC_LIBRARIES})
		else()
			target_compile_options(iio PRIVATE -pthread)
		endif()
	endif()

	list(APPEND LIBIIO_SCAN_BACKENDS local)
endif()

option(WITH_SERIAL_BACKEND "Enable the serial backend" OFF)
if (WITH_SERIAL_BACKEND)
	find_library(LIBSERIALPORT_LIBRARIES serialport)
	find_path(LIBSERIALPORT_INCLUDE_DIR libserialport.h)
	if (NOT LIBSERIALPORT_LIBRARIES OR NOT LIBSERIALPORT_INCLUDE_DIR)
		message(SEND_ERROR "Unable to find libserialport dependency.\n")
	else()
		file(STRINGS ${LIBSERIALPORT_INCLUDE_DIR}/libserialport.h LIBSERIALPORT_VERSION_STR REGEX "SP_PACKAGE_VERSION_STRING")
		string(REGEX REPLACE "#define SP_PACKAGE_VERSION_STRING \"(.*)\"" "\\1" LIBSERIALPORT_VERSION ${LIBSERIALPORT_VERSION_STR})
		if ("${LIBSERIALPORT_VERSION}" VERSION_LESS 0.1.1)
			message(SEND_ERROR "The installed version of libserialport is too old. The minimum version supported is 0.1.1.")
		endif()
	endif()

	set(IIOD_CLIENT 1)
	set(NEED_LIBXML2 1)

	if (WITH_MODULES)
		option(WITH_SERIAL_BACKEND_DYNAMIC "Build serial backend as a module instead of built-in" ON)
	else()
		set(WITH_SERIAL_BACKEND_DYNAMIC OFF)
	endif()
	if (WITH_SERIAL_BACKEND_DYNAMIC)
		add_library(iio-serial SHARED serial.c)
		target_link_libraries(iio-serial PRIVATE iio ${LIBSERIALPORT_LIBRARIES})
		target_include_directories(iio-serial PRIVATE ${LIBSERIALPORT_INCLUDE_DIR})
		set_target_properties(iio-serial PROPERTIES PREFIX lib)
	else()
		target_sources(iio PRIVATE serial.c)
		target_link_libraries(iio PRIVATE ${LIBSERIALPORT_LIBRARIES})
		target_include_directories(iio PRIVATE ${LIBSERIALPORT_INCLUDE_DIR})
	endif()
endif()

option(WITH_ZSTD "Support for ZSTD compressed metadata" ON)
if (WITH_ZSTD)
	find_library(LIBZSTD_LIBRARIES zstd)
	find_path(LIBZSTD_INCLUDE_DIR zstd.h)

	if (NOT LIBZSTD_LIBRARIES OR NOT LIBZSTD_INCLUDE_DIR)
		message(SEND_ERROR "Unable to find libzstd dependency.\n"
			"If you want to disable ZSTD compression support, set WITH_ZSTD=OFF.")
	endif()

	target_link_libraries(iio PRIVATE ${LIBZSTD_LIBRARIES})
	target_include_directories(iio PRIVATE ${LIBZSTD_INCLUDE_DIR})
endif (WITH_ZSTD)

option(WITH_NETWORK_BACKEND "Enable the network backend" ON)
if(WITH_NETWORK_BACKEND)
	if (WIN32)
		target_link_libraries(iio PRIVATE wsock32 iphlpapi ws2_32)
	endif()

	if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
		include(CheckCSourceCompiles)

		check_c_source_compiles("#include <sys/eventfd.h>\nint main(void) { return eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); }"
			WITH_NETWORK_EVENTFD)
		if (NOT WITH_NETWORK_EVENTFD)
			check_c_source_compiles("#define _GNU_SOURCE=1\n#include <unistd.h>\n#include <fcntl.h>\nint main(void) { int fd[2]; return pipe2(fd, O_CLOEXEC | O_NONBLOCK); }"
				HAS_PIPE2)
		endif()

		if (HAS_PIPE2)
			add_definitions(-D_GNU_SOURCE=1)
		endif()
	endif()

	if (WITH_MODULES)
		option(WITH_NETWORK_BACKEND_DYNAMIC "Build network backend as a module instead of built-in" ON)
	else()
		set(WITH_NETWORK_BACKEND_DYNAMIC OFF)
	endif()

	if (WITH_NETWORK_BACKEND_DYNAMIC)
		add_library(iio-ip SHARED network.c)
		target_link_libraries(iio-ip PRIVATE iio)
		set_target_properties(iio-ip PROPERTIES PREFIX lib)
		set(IIO_NETWORK_LIB iio-ip)
	else()
		target_sources(iio PRIVATE network.c)
		set(IIO_NETWORK_LIB iio)
	endif()
	if (WIN32)
		target_sources(${IIO_NETWORK_LIB} PRIVATE network-windows.c)
	else()
		target_sources(${IIO_NETWORK_LIB} PRIVATE network-unix.c)
	endif()

	option(HAVE_DNS_SD "Enable DNS-SD (ZeroConf) support" ON)
	if (NOT HAVE_DNS_SD)
	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
		find_library(CORE_SERVICES CoreServices)

		target_sources(${IIO_NETWORK_LIB} PRIVATE dns_sd.c dns_sd_bonjour.c)
		target_link_libraries(${IIO_NETWORK_LIB} PRIVATE ${CORE_SERVICES})
		set(HAVE_BONJOUR ON)
	elseif(WIN32)
		if (CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
			set_source_files_properties(dns_sd_windows.c PROPERTIES COMPILE_FLAGS "-Wno-unused-function")
		endif()

		target_sources(${IIO_NETWORK_LIB} PRIVATE dns_sd.c dns_sd_windows.c)

	else()
		find_library(AVAHI_CLIENT_LIBRARIES avahi-client)
		find_library(AVAHI_COMMON_LIBRARIES avahi-common)
		if (NOT AVAHI_CLIENT_LIBRARIES OR NOT AVAHI_COMMON_LIBRARIES)
			message(SEND_ERROR "Unable to find libavahi-common / libavahi-client dependencies.\n"
				"If you want to disable DNS-SD (ZeroConf) support, set HAVE_DNS_SD=OFF.")
		endif()

		target_sources(${IIO_NETWORK_LIB} PRIVATE dns_sd.c dns_sd_avahi.c)
		target_link_libraries(${IIO_NETWORK_LIB} PRIVATE ${AVAHI_COMMON_LIBRARIES} ${AVAHI_CLIENT_LIBRARIES})
		set(HAVE_AVAHI ON)
	endif()

	if (HAVE_DNS_SD)
		list(APPEND LIBIIO_SCAN_BACKENDS ip)
	endif()

	set(IIOD_CLIENT 1)
	set(NEED_LIBXML2 1)
else()
	set(HAVE_DNS_SD OFF)
endif()


option(WITH_XML_BACKEND "Enable the XML backend" ON)
if (WITH_XML_BACKEND)
	# Since libxml2-2.9.2, libxml2 provides its own LibXml2-config.cmake, with all
	# variables correctly set.
	# So, try first to find the CMake module provided by libxml2 package, then fallback
	# on the CMake's FindLibXml2.cmake module (which can lack some definition, especially
	# in static build case).
	find_package(LibXml2 QUIET NO_MODULE NO_SYSTEM_ENVIRONMENT_PATH)
	if(DEFINED LIBXML2_VERSION_STRING)
		set(LIBXML2_FOUND ON)
		set(LIBXML2_INCLUDE_DIR ${LIBXML2_INCLUDE_DIRS})
	else()
		include(FindLibXml2)
	endif()

	if (NOT LIBXML2_FOUND)
		message(SEND_ERROR "Unable to find libxml2 dependency.\n"
			"If you want to disable the XML backend, set WITH_XML_BACKEND=OFF.")
	endif()

	target_sources(iio PRIVATE xml.c)

	target_include_directories(iio PRIVATE ${LIBXML2_INCLUDE_DIR})
	target_link_libraries(iio PRIVATE ${LIBXML2_LIBRARIES})
elseif(NEED_LIBXML2)
	message(SEND_ERROR "Enabled backends require the XML backend to be enabled as well.\n"
		"If you want to enable the XML backend, set WITH_XML_BACKEND=ON.")
endif()

option(NO_THREADS "Build a thread-less Libiio library" OFF)
if (NO_THREADS)
	target_sources(iio PRIVATE lock-dummy.c)
elseif (WIN32)
	target_sources(iio PRIVATE lock-windows.c)
else ()
	if (NOT ANDROID)
		find_library(PTHREAD_LIBRARIES pthread)

		if (NOT PTHREAD_LIBRARIES)
			message(SEND_ERROR "Unable to find pthread dependency.")
		endif()

		target_link_libraries(iio PRIVATE ${PTHREAD_LIBRARIES})

		include(cmake/Utilities.cmake)

		CHECK_PTHREAD_SET_NAME(HAS_PTHREAD_SETNAME_NP)
		if (HAS_PTHREAD_SETNAME_NP AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux")
			set_source_files_properties(lock.c PROPERTIES COMPILE_FLAGS -D_GNU_SOURCE)
		endif()
	endif()

	target_sources(iio PRIVATE lock.c)
endif()

if (IIOD_CLIENT OR WITH_IIOD OR WITH_LIBTINYIIOD)
	add_library(iiod-responder STATIC iiod-responder.c)
	target_include_directories(iiod-responder PRIVATE include ${CMAKE_BINARY_DIR})
	set_target_properties(iiod-responder PROPERTIES POSITION_INDEPENDENT_CODE ON)

	# Link against exported symbols of Libiio and not the
	# DLL-exported symbols
	target_compile_definitions(iiod-responder PRIVATE LIBIIO_STATIC)

	# Use the same compile options as Libiio
	target_compile_options(iiod-responder PUBLIC $<TARGET_PROPERTY:iio,INTERFACE_COMPILE_OPTIONS>)
endif()

if (IIOD_CLIENT)
	if (NO_THREADS)
		message(SEND_ERROR "Backends using iiod-client require threads.")
	endif()

	target_sources(iio PRIVATE iiod-client.c)
	target_link_libraries(iio PRIVATE iiod-responder)
endif()

macro(toggle_iio_feature opt str)
	if (${opt})
		list(APPEND IIO_FEATURES_ON ${str})
	else()
		list(APPEND IIO_FEATURES_OFF ${str})
	endif()
endmacro()

if(WITH_UTILS)
	add_subdirectory(utils)
endif()
if(WITH_EXAMPLES)
	add_subdirectory(examples)
endif()
if (WITH_IIOD)
	if (NO_THREADS)
		message(SEND_ERROR "IIOD require threads.")
	endif()

	if (NOT PTHREAD_LIBRARIES)
		message(SEND_ERROR "IIOD requires pthread support.\n"
			"If you want to disable IIOD, set WITH_IIOD=OFF.")
	endif()

	add_subdirectory(iiod)
endif()

if (WITH_LIBTINYIIOD)
	add_subdirectory(tinyiiod)
endif()

if ((WITH_IIOD OR IIOD_CLIENT) AND NOT WITH_ZSTD)
	message(WARNING "IIOD async. API requires ZSTD support, consider enabling it.\n"
		"If you want to enable libzstd support, set WITH_ZSTD=ON.")
endif()

if (WIN32)
	set(LIBIIO_ORIGINAL_FILENAME libiio.dll)
	set(LIBIIO_RC ${CMAKE_CURRENT_BINARY_DIR}/properties.rc)
	configure_file(properties.rc.cmakein ${LIBIIO_RC} @ONLY)
endif()

set(CMAKE_HTML_DEST_DIR "${CMAKE_CURRENT_BINARY_DIR}/html/v${VERSION}")

option(CPP_BINDINGS "Install C++ bindings" OFF)
option(CSHARP_BINDINGS "Install C# bindings" OFF)
option(PYTHON_BINDINGS "Install Python bindings" OFF)
add_subdirectory(bindings)

option(WITH_MAN "Generate on-line reference manuals (man pages)" OFF)
add_subdirectory(man)

include(cmake/Install.cmake)

# Add uninstall target
if(NOT TARGET uninstall)
	configure_file(
		"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
		"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
		IMMEDIATE @ONLY
	)

	add_custom_target(uninstall
		COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
endif()

string(REPLACE ";" "," LIBIIO_SCAN_BACKENDS "${LIBIIO_SCAN_BACKENDS}")

configure_file(iio-config.h.cmakein ${CMAKE_CURRENT_BINARY_DIR}/iio-config.h @ONLY)

toggle_iio_feature("${NO_THREADS}" threadless)
toggle_iio_feature("${LIBIIO_COMPAT}" compat)
toggle_iio_feature("${WITH_XML_BACKEND}" xml)
toggle_iio_feature("${WITH_ZSTD}" zstd)
toggle_iio_feature("${WITH_NETWORK_BACKEND}" network)
toggle_iio_feature("${WITH_EXTERNAL_BACKEND}" external)
toggle_iio_feature("${HAVE_DNS_SD}" dns-sd)
toggle_iio_feature("${HAVE_AVAHI}" avahi)
toggle_iio_feature("${HAVE_BONJOUR}" bonjour)
toggle_iio_feature("${ENABLE_IPV6}" ipv6)
toggle_iio_feature("${WITH_SERIAL_BACKEND}" serial)
toggle_iio_feature("${WITH_LOCAL_BACKEND}" local)
toggle_iio_feature("${WITH_LOCAL_DMABUF_API}" local-dmabuf)
toggle_iio_feature("${WITH_LOCAL_MMAP_API}" local-mmap)
toggle_iio_feature("${WITH_HWMON}" hwmon)
toggle_iio_feature("${WITH_USB_BACKEND}" usb)
toggle_iio_feature("${WITH_UTILS}" utils)
toggle_iio_feature("${WITH_EXAMPLES}" examples)
toggle_iio_feature("${WITH_LIBTINYIIOD}" libtinyiiod)
toggle_iio_feature("${WITH_IIOD}" iiod)
toggle_iio_feature("${WITH_MODULES}" modules)
toggle_iio_feature("${WITH_USB_BACKEND_DYNAMIC}" usb-dynamic)
toggle_iio_feature("${WITH_NETWORK_BACKEND_DYNAMIC}" network-dynamic)
toggle_iio_feature("${WITH_SERIAL_BACKEND_DYNAMIC}" serial-dynamic)
toggle_iio_feature("${INSTALL_UDEV_RULE}" udev-rule)
#add iiod settings
list(APPEND IIO_FEATURES_ON ${IIOD_FEATURES_ON})
list(APPEND IIO_FEATURES_OFF ${IIOD_FEATURES_OFF})
toggle_iio_feature("${WITH_DOC}" doc)
#add man page settings
list(APPEND IIO_FEATURES_ON ${IIOM_FEATURES_ON})
list(APPEND IIO_FEATURES_OFF ${IIOM_FEATURES_OFF})
#add binding settings
list(APPEND IIO_FEATURES_ON ${IIOB_FEATURES_ON})
list(APPEND IIO_FEATURES_OFF ${IIOB_FEATURES_OFF})

string(REPLACE ";" " " IIO_FEATURES_ON "${IIO_FEATURES_ON}")
string(REPLACE ";" " " IIO_FEATURES_OFF "${IIO_FEATURES_OFF}")

message(STATUS "Features enabled : ${IIO_FEATURES_ON}")
message(STATUS "Features disabled: ${IIO_FEATURES_OFF}")
message(STATUS "LOG_LEVEL set to \"${LOG_LEVEL}\"")