# Process this file with `autoreconf -i` to create a 'configure' file.

# Licensed to the Apache Software Foundation (ASF) under one

# or more contributor license agreements. See the NOTICE file

# distributed with this work for additional information

# regarding copyright ownership. The ASF licenses this file

# to you under the Apache License, Version 2.0 (the

# "License"); you may not use this file except in compliance

# with the License. You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# Table of Contents

# 1. INITIALIZATION

# 2. SITE CONFIGURATION

# 3. CHECK FOR PROGRAMS

# 4. CHECK FOR LIBRARIES

# 5. CHECK FOR HEADERS

# 6. OUTPUT FILES

# 7. autoheader TEMPLATES

# -----------------------------------------------------------------------------

# 1. INITIALIZATION

# These first two version numbers are updated automatically on each release.

# Version number is calculated as MAJOR * 1000000 + MINOR * 1000 + MICRO

# Version string is in the form of MAJOR.MINOR.MICRO[sufix]

#

m4_define([TS_VERSION_S],[9.0.0])

m4_define([TS_VERSION_N],[9000000])

AC_INIT([Apache Traffic Server], TS_VERSION_S(), [dev@trafficserver.apache.org], [trafficserver],[http://trafficserver.apache.org])

AC_PREREQ([2.59])

AC_CONFIG_AUX_DIR([build/_aux])

AC_CONFIG_SRCDIR([src/traffic_server/traffic_server.cc])

AC_CONFIG_MACRO_DIR([build])

# NOTE: we turn off portability warnings because the clang-tidy targets use

# GNU make extensions to filter the sources list.

AM_INIT_AUTOMAKE([-Wall -Werror -Wno-portability tar-ustar foreign no-installinfo no-installman subdir-objects 1.9.2])

# See discussion at https://autotools.io/automake/maintainer.html.

AM_MAINTAINER_MODE([enable])

# Enable a recursive "tidy" rule for clang-tidy.

m4_ifdef([AM_EXTRA_RECURSIVE_TARGETS], [AM_EXTRA_RECURSIVE_TARGETS([clang-tidy])])

AC_CONFIG_HEADERS([include/ink_autoconf.h])

# Configure with --disable-silent-rules to get verbose output. For more info, see

# http://www.gnu.org/software/automake/manual/html_node/Automake-silent_002drules-Option.html

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

# Libtool versioning uses different conventions on different

# platforms. At least on FreeBSD, libtool uses an overly complex

# convention that attempts to solve problems that most people just

# don't have and which just causes confusion for most end users.

#

TS_VERSION_MAJOR=$((TS_VERSION_N() / 1000000 ))

TS_VERSION_MINOR=$(((TS_VERSION_N() / 1000) % 1000 ))

TS_VERSION_MICRO=$((TS_VERSION_N() % 1000 ))

TS_LIBTOOL_MAJOR=`echo $((${TS_VERSION_MAJOR} + ${TS_VERSION_MINOR}))`

TS_LIBTOOL_VERSION=$TS_LIBTOOL_MAJOR:$TS_VERSION_MICRO:$TS_VERSION_MINOR

TS_VERSION_STRING=TS_VERSION_S()

TS_VERSION_NUMBER=TS_VERSION_N()

#

# Substitute the above version numbers into the various files below.

#

AC_SUBST(TS_LIBTOOL_VERSION)

AC_SUBST(TS_VERSION_STRING)

AC_SUBST(TS_VERSION_NUMBER)

AC_SUBST(TS_VERSION_MAJOR)

AC_SUBST(TS_VERSION_MINOR)

AC_SUBST(TS_VERSION_MICRO)

dnl Hard-coded top of ink_autoconf.h:

AH_TOP([

#pragma once

])

#

# Generate ./config.nice for reproducing runs of configure

#

TS_CONFIG_NICE([config.nice])

# XXX we can't just use AC_PREFIX_DEFAULT because that isn't subbed in

# by configure until it is too late. Is that how it should be or not?

# Something seems broken here.

AC_PREFIX_DEFAULT([/usr/local/trafficserver])

# Get the layout here, so we can pass the required variables to Trafficserver

TS_ENABLE_LAYOUT(TrafficServer, [cachedir docdir])

# Reparse the configure arguments so we can override the layout.

TS_PARSE_ARGUMENTS

#

# Host detection

#

AC_CANONICAL_HOST

HOST_GUESS="$host"

AC_SUBST(HOST_GUESS)

AC_ARG_WITH([user],

[AS_HELP_STRING([--with-user],[specify the system user [default=nobody]])],

[

with_user="$withval"

],[

with_user="nobody"

]

)

default_group="`id -ng $with_user`"

AC_ARG_WITH([group],

[AS_HELP_STRING([--with-group],[specify the system group [default=nobody]])],

[

with_group="$withval"

],[

with_group=${default_group:-nobody}

]

)

AC_SUBST([pkgsysuser],[$with_user])

AC_SUBST([pkgsysgroup],[$with_group])

AC_ARG_WITH([build-number],

[AS_HELP_STRING([--with-build-number],[specify a version string for this build])],

[ build_number="$withval" ]

)

#

# Build environment

#

build_person="`id -nu | sed -e 's/\\\\/\\\\\\\\/g'`"

build_group="`id -ng | sed -e 's/\\\\/\\\\\\\\/g'`"

build_machine="`uname -n | sed -e 's/\\\\/\\\\\\\\/g'`"

AC_SUBST([build_machine])

AC_SUBST([build_person])

AC_SUBST([build_group])

AC_SUBST([build_number])

# -----------------------------------------------------------------------------

# 2. SITE CONFIGURATION

#

# Debug

#

AC_MSG_CHECKING([whether to enable debugging])

AC_ARG_ENABLE([debug],

[AS_HELP_STRING([--enable-debug],[turn on debugging])],

[],

[enable_debug=no]

)

AC_MSG_RESULT([$enable_debug])

AC_MSG_CHECKING([whether to enable mime sanity check])

AC_ARG_ENABLE([mime-sanity-check],

[AS_HELP_STRING([--enable-mime-sanity-check],[turn on mime sanity check])],

[],

[enable_mime_sanity_check=no]

)

AC_MSG_RESULT([$enable_mime_sanity_check])

# Enable code coverage instrumentation only if requested by the user.

AC_MSG_CHECKING([whether to code coverage])

AC_ARG_ENABLE([coverage],

[AS_HELP_STRING([--enable-coverage],[generate code coverage instrumentation])],

[],

[enable_coverage=no]

)

AC_MSG_RESULT([$enable_coverage])

#

# Enable -Werror. We want this enabled by default for developers, but disabled by default

# for end users (because we don't want released versions to suffer from compiler warning hell).

#

AC_MSG_CHECKING([whether to enable -Werror])

AC_ARG_ENABLE([werror],

[AS_HELP_STRING([--enable-werror],[turn compiler warnings into errors])],

[],

[enable_werror=no]

)

AC_MSG_RESULT([$enable_werror])

# Enable ASAN for the builds

AC_MSG_CHECKING([whether to enable asan])

AC_ARG_ENABLE([asan],

[AS_HELP_STRING([--enable-asan],[enable Address Sanitizer])],

[],

[enable_asan=no]

)

AC_MSG_RESULT([$enable_asan])

# Enable LSAN in stand-alone mode for the builds

AC_MSG_CHECKING([whether to enable lsan])

AC_ARG_ENABLE([lsan],

[AS_HELP_STRING([--enable-lsan],[enable stand-alone Leak Sanitizer])],

[],

[enable_lsan=no]

)

AC_MSG_RESULT([$enable_lsan])

# Enable TSAN for the builds

AC_MSG_CHECKING([whether to enable tsan])

AC_ARG_ENABLE([tsan],

[AS_HELP_STRING([--enable-tsan],[turn on Thread Sanitizer])],

[],

[enable_tsan=no]

)

AC_MSG_RESULT([$enable_tsan])

#

# Fast SDK APIs, this disables the parameter checks (assert)

# on all APIs.

#

AC_MSG_CHECKING([whether to enable fast SDK APIs])

AC_ARG_ENABLE([fast-sdk],

[AS_HELP_STRING([--enable-fast-sdk],[enable fast SDK APIs (no input parameter sanity checks)])],

[],

[enable_fast_sdk=no]

)

AC_MSG_RESULT([$enable_fast_sdk])

TS_ARG_ENABLE_VAR([use], [fast-sdk])

# Curl support for traffic_top

AC_MSG_CHECKING([whether to enable CURL])

AC_ARG_ENABLE([curl],

[AS_HELP_STRING([--disable-curl],[turn off CURL support for traffic_top])],

[],

[enable_curl=yes]

)

AC_MSG_RESULT([$enable_curl])

if test "x${enable_curl}" = "xyes"; then

AX_LIB_CURL([7.19], [AC_DEFINE([HAS_CURL], [1], [Define if libcurl >= 7.19.])])

fi

#

# Diags

#

AC_MSG_CHECKING([whether to enable diags])

AC_ARG_ENABLE([diags],

[AS_HELP_STRING([--disable-diags],[turn off diags])],

[],

[enable_diags=yes]

)

AC_MSG_RESULT([$enable_diags])

TS_ARG_ENABLE_VAR([use], [diags])

#

# FIPS

#

AC_MSG_CHECKING([whether to enable fips])

AC_ARG_ENABLE([fips],

[AS_HELP_STRING([--enable-fips],[turn on FIPS compliance])],

[],

[enable_fips=no]

)

AC_MSG_RESULT([$enable_fips])

TS_ARG_ENABLE_VAR([enable], [fips])

#

# Build regression tests?

#

AC_MSG_CHECKING([whether to enable regression tests])

AC_ARG_ENABLE([tests],

[AS_HELP_STRING([--disable-tests],[turn off regression tests])],

[],

[enable_tests=yes]

)

AC_MSG_RESULT([$enable_tests])

TS_ARG_ENABLE_VAR([has], [tests])

AM_CONDITIONAL([BUILD_TESTS], [test 0 -ne $has_tests])

#

# Build documentation?

#

# Java needed only for documentation building, but making it conditional

# makes the diagnostic output ugly and hard to follow.

AC_ARG_VAR(JAVA, [path to java executor])

AC_CHECK_PROG(JAVA, java, java)

AC_MSG_RESULT([Checking whether to build documentation:])

AC_ARG_ENABLE([docs],

[AS_HELP_STRING([--enable-docs],[enable documentation building])],

[

enable_doc_build=yes

AM_PATH_PYTHON([3.4], [

TS_MAN1_MANPAGES=`cd $srcdir/doc && $PYTHON manpages.py --section=1 | $AWK '{print "$(BUILDDIR)/man/" $0 }' | tr '\n' ' '`

TS_MAN3_MANPAGES=`cd $srcdir/doc && $PYTHON manpages.py --section=3 | $AWK '{print "$(BUILDDIR)/man/" $0 }' | tr '\n' ' '`

TS_MAN5_MANPAGES=`cd $srcdir/doc && $PYTHON manpages.py --section=5 | $AWK '{print "$(BUILDDIR)/man/" $0 }' | tr '\n' ' '`

TS_MAN8_MANPAGES=`cd $srcdir/doc && $PYTHON manpages.py --section=8 | $AWK '{print "$(BUILDDIR)/man/" $0 }' | tr '\n' ' '`

], [

enable_doc_build=no

AC_ERROR([Doc building disabled, python 3.4 or better required])

])

AS_IF([test -z "$JAVA"],

[

enable_doc_build=no

AC_ERROR([Doc building disabled, java required but not found])

])

AC_ARG_VAR(SPHINXBUILD, [the sphinx-build documentation generator])

AC_ARG_VAR(SPHINXOPTS, [additional sphinx-build options])

AC_PATH_PROG([SPHINXBUILD], [$SPHINXBUILD], [$PYTHON -m sphinx])

AS_IF(["$PYTHON" "$srcdir/doc/checkvers.py" --check-version],

[

sphinx_version_check=yes

],[

sphinx_version_check=no

enable_doc_build=no

AC_ERROR([Doc building disabled, check sphinx installation])

])

AC_SUBST(TS_MAN1_MANPAGES)

AC_SUBST(TS_MAN3_MANPAGES)

AC_SUBST(TS_MAN5_MANPAGES)

AC_SUBST(TS_MAN8_MANPAGES)

AC_MSG_CHECKING([whether to build man pages])

AS_IF([test "x$sphinx_version_check" = "xyes" -a "x$SPHINXBUILD" != "xfalse"], [

build_manpages=true

AC_MSG_RESULT([yes])

], [

build_manpages=false

AC_MSG_RESULT([no])

])

],

[enable_doc_build=no]

)

AC_MSG_RESULT([Will build documentation: $enable_doc_build])

AM_CONDITIONAL([BUILD_DOCS], [test "xyes" = "x$enable_doc_build"])

AM_CONDITIONAL([BUILD_MANPAGES], [test "xtrue" = "x$build_manpages"])

#

# Remote Coverity Prevent commit

#

AC_MSG_CHECKING([whether to commit cov defects to remote host])

AC_ARG_ENABLE([remote-cov-commit],

[AS_HELP_STRING([--enable-remote-cov-commit[=HOST]], [commit cov defects to remote host [HOST=localhost]])],

[],

[enable_remote_cov_commit=localhost]

)

AC_MSG_RESULT([$enable_remote_cov_commit])

AC_SUBST([enable_remote_cov_commit])

#

# WCCP

#

AC_MSG_CHECKING([whether to enable WCCP v2 support])

AC_ARG_ENABLE([wccp],

[AS_HELP_STRING([--enable-wccp],[enable WCCP v2])],

[],

[enable_wccp=no]

)

AC_MSG_RESULT([$enable_wccp])

TS_ARG_ENABLE_VAR([has],[wccp])

AM_CONDITIONAL([BUILD_WCCP], [test 0 -ne $has_wccp])

# Google profiler

AC_MSG_CHECKING([whether to enable profiler])

AC_ARG_WITH([profiler],

[AS_HELP_STRING([--with-profiler],[enable support for profiler [default=no]])],

[with_profiler=$withval],

[with_profiler=no]

)

AC_MSG_RESULT([$with_profiler])

# Disable all static library builds

AC_DISABLE_STATIC

#

# use eventfd() or pipes

# Found that ec2 is using an older kernel causing eventfd errors.

# Disable eventfd when using ATS on EC2 Fedora.

#

AC_MSG_CHECKING([whether to enable eventfd()])

AC_ARG_ENABLE([eventfd],

[AS_HELP_STRING([--disable-eventfd],[turn off eventfd and use pipes])],

[],

[enable_eventfd="yes"]

)

AC_MSG_RESULT([$enable_eventfd])

#

# use POSIX capabilities instead of user ID switching.

#

AC_MSG_CHECKING([whether to use POSIX capabilities])

AC_ARG_ENABLE([posix-cap],

[AS_HELP_STRING([--disable-posix-cap],[Use user id switching instead of POSIX capabilities])],

[],

[enable_posix_cap="auto"]

)

AC_MSG_RESULT([$enable_posix_cap])

#

# use hwloc library when possible (can be disabled)

#

AC_MSG_CHECKING([whether to use hwloc library])

AC_ARG_ENABLE([hwloc],

[AS_HELP_STRING([--disable-hwloc],[Don't use the hwloc library])],

[],

[enable_hwloc="yes"]

)

AC_MSG_RESULT([$enable_hwloc])

#

# Enble ccache explicitly (it's disabled by default, because of build problems in some cases)

#

AC_MSG_CHECKING([whether to enable ccache])

AC_ARG_ENABLE([ccache],

[AS_HELP_STRING([--enable-ccache],[Enable ccache (for developers)])],

[],

[enable_ccache="no"]

)

AC_MSG_RESULT([$enable_ccache])

#

# Enble hardening of the executables

#

AC_MSG_CHECKING([whether to enable hardening of the executables])

AC_ARG_ENABLE([hardening],

[AS_HELP_STRING([--enable-hardening],[Enable hardening of executables])],

[],

[enable_hardening="no"]

)

AC_MSG_RESULT([$enable_hardening])

#

# Enable SSLv3 to origin

#

AC_MSG_CHECKING([whether to enable SSLv3 config for origin connections])

AC_ARG_ENABLE([sslv3-client],

[AS_HELP_STRING([--enable-sslv3-client],[Enable SSLv3 config for origin connections (Only do this if you understand the risks)])],

[],

[enable_sslv3_client="no"]

)

AC_MSG_RESULT([$enable_sslv3_client])

TS_ARG_ENABLE_VAR([use], [sslv3-client])

#

# Use TPROXY for connection transparency.

#

AC_MSG_CHECKING([whether to enable TPROXY based transparency])

AC_ARG_ENABLE([tproxy],

[AS_HELP_STRING([--enable-tproxy[[=ARG]]],

[Use TPROXY to enable connection transparency.

'auto' or omitted for local system default,

'no' to disable,

'force' to use built in default,

number to use as IP_TRANSPARENT sockopt.

[default=auto]

])

],

[],

[enable_tproxy="auto"]

)

AC_MSG_RESULT([$enable_tproxy])

#

# Configure how many stats to allocate for plugins. Default is 512.

#

AC_ARG_WITH([max-api-stats],

[AS_HELP_STRING([--with-max-api-stats],[max number of plugin stats [default=512]])],

[max_api_stats=$withval],

[max_api_stats=512]

)

AC_SUBST(max_api_stats)

#

# Max host name length that we deal with in URLs.

#

AC_ARG_WITH([max-host-name-len],

[AS_HELP_STRING([--with-max-host-name-len],[max host name length [default=256]])],

[max_host_name_len=$withval],

[max_host_name_len=256]

)

AC_SUBST(max_host_name_len)

#

# EventProcessor thread configurations

#

AC_ARG_WITH([max-event-threads],

[AS_HELP_STRING([--with-max-event-threads],[max number of event threads [default=4096]])],

[max_event_threads=$withval],

[max_event_threads=4096]

)

AC_SUBST(max_event_threads)

AC_ARG_WITH([max-threads-per-type],

[AS_HELP_STRING([--with-max-threads-per-type],[max number of threads per event type [default=3072]])],

[max_threads_per_type=$withval],

[max_threads_per_type=3072]

)

AC_SUBST(max_threads_per_type)

#

# Experimental plugins

#

AC_MSG_CHECKING([whether to enable experimental plugins])

AC_ARG_ENABLE([experimental-plugins],

[AS_HELP_STRING([--enable-experimental-plugins],[build experimental plugins])],

[],

[enable_experimental_plugins=no]

)

AC_MSG_RESULT([$enable_experimental_plugins])

AM_CONDITIONAL([BUILD_EXPERIMENTAL_PLUGINS], [ test "x${enable_experimental_plugins}" = "xyes" ])

#

# Enable experimental/memcached_remap plugin

#

PKG_CHECK_MODULES([LIBMEMCACHED], [libmemcached >= 1.0], [have_libmemcached=yes], [have_libmemcached=no])

AM_CONDITIONAL([BUILD_MEMCACHED_REMAP_PLUGIN], [test "x${have_libmemcached}" = "xyes"])

#

# Check Magick++ is available. Enable experimental/webp_transform plugin

#

PKG_CHECK_MODULES([LIBMAGICKCPP],[Magick++ >= 7], [

TS_ADDTO(LIBMAGICKCPP_CFLAGS, [-DMAGICK_VERSION=7])

have_libmagickcpp=yes

AS_IF([test "x$enable_experimental_plugins" = "xyes"], [

enable_image_magick_plugins=yes

])

],

[

PKG_CHECK_MODULES([LIBMAGICKCPP],[Magick++ < 7], [

TS_ADDTO(LIBMAGICKCPP_CFLAGS, [-DMAGICK_VERSION=6])

have_libmagickcpp=yes

AS_IF([test "x$enable_experimental_plugins" = "xyes"], [

enable_image_magick_plugins=yes

])

],

[

have_libmagickcpp=no

])])

AM_CONDITIONAL([BUILD_IMAGE_MAGICK_PLUGINS], [test "x${enable_image_magick_plugins}" = "xyes"])

#

# Example plugins. The example plugins are only built and installed if this is enabled. Installing

# them is useful for QA, but not useful for most users, so we default this to disabled.

#

AC_MSG_CHECKING([whether to install example plugins])

AC_ARG_ENABLE([example-plugins],

[AS_HELP_STRING([--enable-example-plugins],[build and install example plugins])],

[],

[enable_example_plugins=no]

)

AC_MSG_RESULT([$enable_example_plugins])

AM_CONDITIONAL([BUILD_EXAMPLE_PLUGINS], [ test "x${enable_example_plugins}" = "xyes" ])

#

# Test tools. The test tools are always built, but not always installed. Installing

# them is useful for QA, but not useful for most users, so we default this to disabled.

#

AC_MSG_CHECKING([whether to install testing tools])

AC_ARG_ENABLE([test-tools],

[AS_HELP_STRING([--enable-test-tools],[install testing tools])],

[],

[enable_test_tools=no]

)

AC_MSG_RESULT([$enable_test_tools])

AM_CONDITIONAL([BUILD_TEST_TOOLS], [ test "x${enable_test_tools}" = "xyes" ])

#

# Check if we should allow builds on 32-bit platforms

#

AC_MSG_CHECKING([whether to allow 32-bit builds])

AC_ARG_ENABLE([32bit-build],

[AS_HELP_STRING([--enable-32bit-build],[allow 32bit builds])],

[],

[enable_32bit=no]

)

AC_MSG_RESULT([$enable_32bit])

#

# Installation directories

# For each var the following is evaluated

# foo Standard variable eg. ${prefix}/foo

# rel_foo Relative to prefix eg. foo

#

TS_SUBST_LAYOUT_PATH([prefix])

TS_SUBST_LAYOUT_PATH([exec_prefix])

TS_SUBST_LAYOUT_PATH([bindir])

TS_SUBST_LAYOUT_PATH([sbindir])

TS_SUBST_LAYOUT_PATH([libdir])

TS_SUBST_LAYOUT_PATH([libexecdir])

TS_SUBST_LAYOUT_PATH([infodir])

TS_SUBST_LAYOUT_PATH([mandir])

TS_SUBST_LAYOUT_PATH([sysconfdir])

TS_SUBST_LAYOUT_PATH([datadir])

TS_SUBST_LAYOUT_PATH([installbuilddir])

TS_SUBST_LAYOUT_PATH([includedir])

TS_SUBST_LAYOUT_PATH([localstatedir])

TS_SUBST_LAYOUT_PATH([runtimedir])

TS_SUBST_LAYOUT_PATH([logdir])

TS_SUBST_LAYOUT_PATH([cachedir])

TS_SUBST_LAYOUT_PATH([docdir])

TS_SUBST([pkgbindir])

TS_SUBST([pkgsbindir])

TS_SUBST([pkglibdir])

TS_SUBST([pkglibexecdir])

TS_SUBST([pkgsysconfdir])

TS_SUBST([pkgdatadir])

TS_SUBST([pkglocalstatedir])

TS_SUBST([pkgruntimedir])

TS_SUBST([pkglogdir])

TS_SUBST([pkgcachedir])

TS_SUBST([pkgdocdir])

# -----------------------------------------------------------------------------

# 3. CHECK FOR PROGRAMS

# Compiler selection:

#

# Implementation note (toc)

# 1) Get default compiler settings (case statement.)

# 2) Check for over-rides of default compiler.

# 3) (in first kludge mode block...) obtain any further CFLAG-type additions.

# 4) Test compilers with all flags set.

# AC_PROG can sometimes mangle CFLAGS etc.

# in particular, on Linux they insert -g -O2, here we preserve any user CFLAGS

_ts_saved_CFLAGS="${CFLAGS}"

_ts_saved_CXXFLAGS="${CXXFLAGS}"

# We force the compiler search list because the default GCC on Darwin cannot build

# Traffic Server. On most (all?) platforms, cc and c++ should be the preferred default

# compiler.

AC_PROG_CC([cc gcc clang icc])

AC_PROG_CXX([c++ g++ clang++ icpc])

AM_PROG_CC_C_O

AC_PROG_CPP

AC_PROG_CXXCPP

AM_PROG_AS

AX_COMPILER_VENDOR

CFLAGS="${_ts_saved_CFLAGS}"

CXXFLAGS="${_ts_saved_CXXFLAGS}"

# All compilers we support have 'gnu99' as an available C standard

TS_ADDTO(AM_CFLAGS, [-std=gnu99])

ac_save_CXX="$CXX"

CXX="$CXX -std=c++17"

AC_LANG_PUSH(C++)

AC_MSG_CHECKING([checking whether $CXX supports -std=c++17])

AC_COMPILE_IFELSE([

AC_LANG_PROGRAM([

#if __cplusplus < 201703L

#error "This is not C++17"

#endif

], []

)], [

AC_MSG_RESULT(yes)

], [

AC_MSG_RESULT(no)

AC_MSG_ERROR([*** A compiler with support for -std=c++17 is required.])

])

AC_LANG_POP

CXX="$ac_save_CXX"

TS_ADDTO(AM_CXXFLAGS, [-std=c++17])

dnl AC_PROG_SED is only available from version 2.6 (released in 2003). CentosOS

dnl 5.9 still has an ancient version, but we have macros that require

dnl AC_PROG_SED. The actual AC_PROG_SED macro does functional checks, but here

dnl we define a trivial local version for times when we are running on

dnl obsoldete autoconf.

ifdef([AC_PROG_SED], [], [

AC_DEFUN([AC_PROG_SED], [

AC_CHECK_PROG(SED, sed, sed)

])

])

# Various OS specific setup. Note that on Solaris, 32-bit is always the

# default, even on a box that with 64-bit architecture.

# This also sets up a "normalized" variable and define $host_os_def.

case $host_os in

linux*)

host_os_def="linux"

AM_LDFLAGS="-rdynamic"

;;

darwin*)

host_os_def="darwin"

;;

freebsd*)

host_os_def="freebsd"

AM_LDFLAGS="-rdynamic"

TS_ADDTO(TS_INCLUDES, [-I/usr/local/include])

TS_ADDTO(AM_CPPFLAGS, [-D_GLIBCXX_USE_C99])

TS_ADDTO(AM_CPPFLAGS, [-D_GLIBCXX_USE_C99_MATH])

TS_ADDTO(AM_CPPFLAGS, [-D_GLIBCXX_USE_C99_MATH_TR1])

;;

kfreebsd*)

host_os_def="freebsd"

AM_LDFLAGS="-rdynamic"

TS_ADDTO(TS_INCLUDES, [-I/usr/local/include])

TS_ADDTO(AM_CPPFLAGS, [-Dkfreebsd])

;;

openbsd*)

host_os_def="openbsd"

;;

solaris*)

host_os_def="solaris"

case "`isalist`" in

*amd64*)

TS_ADDTO(AM_CFLAGS, [-m64])

TS_ADDTO(AM_CXXFLAGS, [-m64])

TS_ADDTO(LUAJIT_LDFLAGS, [-m64])

;;

esac

;;

*)

AM_LDFLAGS="-rdynamic"

host_os_def=unknown

;;

esac

TS_ADDTO(AM_CPPFLAGS, [-D$host_os_def])

dnl AM_PROG_AR is not always available, but it doesn't seem to be needed in older versions.

ifdef([AM_PROG_AR],

[AM_PROG_AR])

AC_PROG_AWK

AC_PROG_SED

AC_PROG_LN_S

AC_PROG_INSTALL

AC_PROG_LIBTOOL

AC_CHECK_PROG(RM, rm, rm)

AC_CHECK_PROG(ASCPP, cpp, cpp)

AC_CHECK_TOOL(AR, ar, ar)

AC_ISC_POSIX

AC_ARG_VAR(RPATH, [path to be added to rpath])

AC_ARG_VAR([CLANG_TIDY], [clang-tidy command])

# Default CLANG_TIDY to "clang-tidy", or "false" if it is not present.

AC_PATH_PROG([CLANG_TIDY], [clang-tidy],[false])

# Do bison check by hand because we must do a version check.

# Use YACC because it makes autotools shut up.

BISON_MAJOR=2

BISON_MINOR=4

BISON_POINT=1

AC_CHECK_PROG([YACC],[bison],[bison])

AS_IF([test -n "$YACC"],

[ bison_version_check=`$YACC --version 2>&1 | \

$SED -n '/bison/s/^[[^0-9]]*\([[0-9]][[0-9.]]*\).*$/\1/p' | \

$AWK "{ if (\\$1 > $BISON_MAJOR || (\\$1 == $BISON_MAJOR && (\\$2 > $BISON_MINOR || (\\$2 == $BISON_MINOR && (NR == 2 || \\$3 >= $BISON_POINT))))) print \"yes\"; else printf(\"version %d.%d.%d\",\\$1,\\$2,\\$3); }" FS=. \

`

AS_IF([test "x$bison_version_check" != "xyes"],

[ YACC=''

AS_IF([test -z "$bison_version_check"],

[bison_version_check='no version data']

)

]

)

],

[ YACC=''

bison_version_check="nothing"

]

)

# Check lex/flex by hand because we need flex of a sufficient version.

FLEX_MAJOR=2

FLEX_MINOR=5

FLEX_POINT=33

dnl ylwrap requires the lexer executable to be an absolute path or in the srcdir.

dnl but we need various other LEX values.

AC_PROG_LEX

AS_IF([test -n "$LEX"],

[ flex_version_check=`$LEX --version 2>&1 | \

$SED -n '/flex/s/^[[^0-9]]*\([[0-9]][[0-9.]]*\)[[^0-9]]*.*$/\1/p' | \

$AWK "{ if (\\$1 > $FLEX_MAJOR || (\\$1 == $FLEX_MAJOR && (\\$2 > $FLEX_MINOR || (\\$2 == $FLEX_MINOR && (NR == 2 || \\$3 >= $FLEX_POINT))))) print \"yes\"; else printf(\"version %d.%d.%d\",\\$1,\\$2,\\$3); }" FS=. \

`

AS_IF([test "x$flex_version_check" != "xyes"],

[ LEX=''

AS_IF([test -z "$flex_version_check"],

[flex_version_check='no version data']

)

]

)

],

[ LEX=''

flex_version_check="nothing"

]

)

# Generated files checked in, only build them if the local OS has the necessary support.

# Otherwise just use the checked in version.

AM_CONDITIONAL([BUILD_TSCONFIG_GRAMMAR], [ test -n "$LEX" && test -n "$YACC" ])

# Check for Perl and Doxygen

AC_PATH_PROG([DOXYGEN], [doxygen]) # needed for Doxygen

AC_PATH_PROG([PERL], [perl],[not found])

AS_IF([test "x$PERL" = "xnot found"],

[AC_MSG_ERROR([check for perl failed. Have you installed perl?])]

)

AC_ARG_VAR([DOXYGEN], [full path of Doxygen executable])

AC_ARG_VAR([PERL], [full path of Perl executable])

# Check if MakeMaker is available

AX_PROG_PERL_MODULES([ExtUtils::MakeMaker], AM_CONDITIONAL([BUILD_PERL_LIB], [true]),

AM_CONDITIONAL([BUILD_PERL_LIB], [false])

)

# Check for GNU-style -On optimization flags

AC_MSG_CHECKING([checking whether to auto-set compiler optimization flags])

has_optimizer_flags=`echo "$CFLAGS $CXXFLAGS" | ${AWK} '$0 !~ /-O.?/{print "no"}'`

AS_IF([test "x${has_optimizer_flags}" = "xno"],

[

optimizing_flags='-O3'

AC_MSG_RESULT([yes ${optimizing_flags}])

],

[

has_optimizer_flags='yes'

optimizing_flags=''

AC_MSG_RESULT([no])

]

)

case $host_os_def in

linux)

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xintel"], [

# -Wall is overzealous for us, so need to turn this off for now:

#

# #873 is "has no corresponding operator delete"

# #279 is "controlling expression is constant" (which is e.g. TSReleaseAssert(!"Unexpected Event");

common_opt="-pipe -Wall -wd873 -wd279"

debug_opt="-g $common_opt"

release_opt="-g $common_opt $optimization_flags -axsse4.2 -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

])

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xclang"], [

common_opt="-pipe -Wall -Wno-deprecated-declarations -Qunused-arguments -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-ggdb3 $common_opt -Qunused-arguments"

release_opt="-g $common_opt $optimizing_flags -fno-strict-aliasing -Qunused-arguments"

cxx_opt="-Wno-invalid-offsetof"

])

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xgnu"], [

# This is useful for finding odd conversions

# common_opt="-pipe -Wall -Wconversion -Wno-sign-conversion -Wno-format-truncation"

common_opt="-pipe -Wall -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter -Wno-format-truncation -Wno-cast-function-type -Wno-stringop-overflow"

debug_opt="-ggdb3 $common_opt"

release_opt="-g $common_opt $optimizing_flags -feliminate-unused-debug-symbols -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof -Wno-noexcept-type"

# Special options for flex generated .c files

flex_cflags="-Wno-unused-parameter"

])

TS_ADDTO([AM_LDFLAGS], [-Wl,--as-needed])

;; # linux)

darwin)

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xclang"], [

common_opt="-pipe -Wall -Wno-deprecated-declarations -Qunused-arguments -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-g $common_opt"

release_opt="-g $common_opt $optimizing_flags -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

], [

AC_MSG_WARN([clang is the only supported compiler on Darwin])

])

# NOTE: This seems semi-kludgy, but useful for MacPorts I think.

AS_IF([test -d /opt/local/include], [

TS_ADDTO(TS_INCLUDES, [-I/opt/local/include])

])

AS_IF([test -d /opt/local/lib], [

TS_ADDTO(AM_LDFLAGS, [-L/opt/local/lib])

])

;; # darwin)

freebsd|kfreebsd)

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xclang"], [

common_opt="-pipe -Wall -Wno-deprecated-declarations -Qunused-arguments -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-ggdb3 $common_opt"

release_opt="-g $common_opt $optimizing_flags -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

])

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xgnu"], [

common_opt="-pipe -Wall -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-ggdb3 $common_opt"

release_opt="-g $common_opt $optimizing_flags -feliminate-unused-debug-symbols -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

])

AS_IF([test -d /usr/local/lib], [

TS_ADDTO(AM_LDFLAGS, [-L/usr/local/lib])

])

;; # freebsd|kfreebsd)

solaris)

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xgnu"], [

common_opt="-pipe -Wall -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-ggdb3 $common_opt"

release_opt="-g $common_opt $optimizing_flags -feliminate-unused-debug-symbols -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

])

;; # solaris)

*)

# Not sure what platform this is, but take a stab at some general GCC options ...

AS_IF([test "x$ax_cv_c_compiler_vendor" = "xgnu"], [

common_opt="-pipe -Wall -Wextra -Wno-ignored-qualifiers -Wno-unused-parameter"

debug_opt="-ggdb3 $common_opt"

release_opt="-g $common_opt $optimizing_flags -feliminate-unused-debug-symbols -fno-strict-aliasing"

cxx_opt="-Wno-invalid-offsetof"

])

esac

AS_IF([test x"$enable_coverage" = "xyes"], [

# Map per-compiler code coverage instrumentation flags. Note that

# we don't test whether the compiler actually support these options

# (we don't do that in general). The user is expected to use a modern,

# supported compiler to test coverage.

AS_CASE("$ax_cv_c_compiler_vendor",

[clang], [

TS_ADDTO(AM_CXXFLAGS, "-fprofile-instr-generate")

TS_ADDTO(AM_CXXFLAGS, "-fcoverage-mapping")

TS_ADDTO(AM_CFLAGS, "-fprofile-instr-generate")

TS_ADDTO(AM_CFLAGS, "-fcoverage-mapping")

], [gnu], [

TS_ADDTO(AM_CXXFLAGS, "--coverage")

TS_ADDTO(AM_CFLAGS, "--coverage")

TS_ADDTO(LIBS, "-lgcov")

])

])

# Only add -Werror if the user has requested it. We enable this by default for

# development, disable it by default for release.

AS_IF([test x"$enable_werror" = "xyes"], [

TS_ADDTO(release_opt, -Werror)

TS_ADDTO(debug_opt, -Werror)

])

cc_oflag_opt=$release_opt

cc_oflag_dbg=$debug_opt

cxx_oflag_opt="$release_opt $cxx_opt $cxx_rel"

cxx_oflag_dbg="$debug_opt $cxx_opt $cxx_dbg"

# Special compiler flag hacks for various pieces of the code

AC_SUBST([FLEX_CFLAGS], $flex_cflags)

#

# _Here_ is where we go ahead and add the _optimizations_ to already

# existing CFLAGS/CXXFLAGS if some special values had been set.

#

if test "x${enable_debug}" = "xyes"; then

TS_ADDTO(AM_CFLAGS, [${cc_oflag_dbg}])

TS_ADDTO(AM_CXXFLAGS, [${cxx_oflag_dbg}])

TS_ADDTO(AM_CPPFLAGS, [-DDEBUG -D_DEBUG])

if test "x${enable_mime_sanity_check}" = "xyes"; then

TS_ADDTO(AM_CPPFLAGS, [-DENABLE_MIME_SANITY_CHECK])

fi

else

TS_ADDTO(AM_CFLAGS, [${cc_oflag_opt}])

TS_ADDTO(AM_CXXFLAGS, [${cxx_oflag_opt}])

fi

# Flags for ASAN

if test "x${enable_asan}" = "xyes"; then

if test "x${enable_tsan}" = "xyes"; then

AC_ERROR([Cannot have ASAN and TSAN options at the same time, pick one])

fi

TS_ADDTO(AM_CFLAGS, [-fno-omit-frame-pointer -fsanitize=address])

TS_ADDTO(AM_CXXFLAGS, [-fno-omit-frame-pointer -fsanitize=address])

fi