project('postgresql',

['c'],

version: '20devel',

license: 'PostgreSQL',

# We want < 0.62 for python 3.6 compatibility on old platforms.

# RHEL 8 has 0.58. < 0.57 would require various additional

# backward-compatibility conditionals.

# Meson 0.57.0 and 0.57.1 are buggy, therefore >=0.57.2.

meson_version: '>=0.57.2',

default_options: [

'warning_level=1', #-Wall equivalent

'b_pch=false',

'buildtype=debugoptimized', # -O2 + debug

'default_library=both',

# For compatibility with the autoconf build, set a default prefix. This

# works even on windows, where it's a drive-relative path (i.e. when on

# d:/somepath it'll install to d:/usr/local/pgsql)

'prefix=/usr/local/pgsql',

]

)

fs = import('fs')

pkgconfig = import('pkgconfig')

host_system = host_machine.system()

build_system = build_machine.system()

host_cpu = host_machine.cpu_family()

cc = meson.get_compiler('c')

have_cxx = add_languages('cpp', required: false, native: false)

if have_cxx

cxx = meson.get_compiler('cpp')

not_found_dep = dependency('', required: false)

thread_dep = dependency('threads')

auto_features = get_option('auto_features')

default_library_opt = get_option('default_library')

build_shared_lib = true

build_static_lib = true

install_internal_static_lib = true

if default_library_opt == 'shared'

build_static_lib = false

install_internal_static_lib = false

elif default_library_opt == 'static'

build_shared_lib = false

error('-Ddefault_library=static is not yet supported')

errmsg_nonclean_base = '''

if fs.exists(meson.current_source_dir() / 'src' / 'include' / 'pg_config.h')

errmsg_cleanup = 'To clean up, run make distclean in the source tree.'

error(errmsg_nonclean_base.format(errmsg_cleanup))

postgres_inc_d = ['src/include']

postgres_inc_d += get_option('extra_include_dirs')

postgres_lib_d = get_option('extra_lib_dirs')

cppflags = []

cflags = []

cxxflags = []

cflags_warn = []

cxxflags_warn = []

cflags_mod = []

cxxflags_mod = []

ldflags = []

ldflags_be = []

ldflags_sl = []

ldflags_mod = []

test_c_args = []

os_deps = []

backend_both_deps = []

backend_deps = []

libpq_deps = []

libpq_oauth_deps = []

pg_sysroot = ''

cdata = configuration_data()

pg_version = meson.project_version()

if pg_version.endswith('devel')

pg_version_arr = [pg_version.split('devel')[0], '0']

elif pg_version.contains('beta')

pg_version_arr = [pg_version.split('beta')[0], '0']

elif pg_version.contains('rc')

pg_version_arr = [pg_version.split('rc')[0], '0']

pg_version_arr = pg_version.split('.')

pg_version_major = pg_version_arr[0].to_int()

pg_version_minor = pg_version_arr[1].to_int()

pg_version_num = (pg_version_major * 10000) + pg_version_minor

pg_url = 'https://www.postgresql.org/'

cdata.set_quoted('PACKAGE_NAME', 'PostgreSQL')

cdata.set_quoted('PACKAGE_BUGREPORT', 'pgsql-bugs@lists.postgresql.org')

cdata.set_quoted('PACKAGE_URL', pg_url)

cdata.set_quoted('PACKAGE_VERSION', pg_version)

cdata.set_quoted('PACKAGE_STRING', 'PostgreSQL @0@'.format(pg_version))

cdata.set_quoted('PACKAGE_TARNAME', 'postgresql')

pg_version += get_option('extra_version')

cdata.set_quoted('PG_VERSION', pg_version)

cdata.set_quoted('PG_MAJORVERSION', pg_version_major.to_string())

cdata.set('PG_MAJORVERSION_NUM', pg_version_major)

cdata.set('PG_MINORVERSION_NUM', pg_version_minor)

cdata.set('PG_VERSION_NUM', pg_version_num)

cdata.set_quoted('CONFIGURE_ARGS', '')

exesuffix = '' # overridden below where necessary

dlsuffix = '.so' # overridden below where necessary

library_path_var = 'LD_LIBRARY_PATH'

export_file_format = 'gnu'

export_file_suffix = 'list'

export_fmt = '-Wl,--version-script=@0@'

mod_link_args_fmt = []

memset_loop_limit = 1024

shmem_kind = 'sysv'

sema_kind = 'sysv'

if host_system == 'dragonfly'

# apparently the most similar

host_system = 'netbsd'

elif host_system == 'android'

# while android isn't quite a normal linux, it seems close enough

# for our purposes so far

host_system = 'linux'

portname = host_system

if host_system == 'aix'

sema_kind = 'unnamed_posix'

library_path_var = 'LIBPATH'

export_file_format = 'aix'

export_fmt = '-Wl,-bE:@0@'

mod_link_args_fmt = ['-Wl,-bI:@0@']

mod_link_with_dir = 'libdir'

mod_link_with_name = '@0@.imp'

# We force 64-bit builds, because AIX doesn't play very nice with dynamic

# library loading in 32-bit mode: there's not enough address space.

cppflags += '-maix64'

ldflags += '-maix64'

# Note: it's also necessary to tell programs like 'ar' to work in 64-bit

# mode. Since meson, in its infinite wisdom, doesn't allow us either

# to pass '-X64' to ar or to set the OBJECT_MODE environment variable

# from here, we have to tell the user to set OBJECT_MODE.

# M:SRE sets a flag indicating that an object is a shared library.

ldflags_sl += '-Wl,-bM:SRE'

# -brtllib indicates binaries should use runtime-loaded shared libraries.

ldflags_be += '-Wl,-brtllib'

# On AIX, shared libraries are wrapped in static libraries and can have

# the same extension '.a'. Therefore we must refrain from trying to build

# static libraries alongside shared ones, or meson will complain about

# duplicate targets. Note however that we leave dlsuffix with its default

# value of '.so'; this results in using '.so' for loadable modules, which

# is fine.

build_static_lib = false

elif host_system == 'cygwin'

sema_kind = 'unnamed_posix'

cppflags += '-D_GNU_SOURCE'

dlsuffix = '.dll'

mod_link_args_fmt = ['@0@']

mod_link_with_name = 'lib@0@.a'

mod_link_with_dir = 'libdir'

elif host_system == 'darwin'

dlsuffix = '.dylib'

library_path_var = 'DYLD_LIBRARY_PATH'

export_file_format = 'darwin'

export_fmt = '-Wl,-exported_symbols_list,@0@'

mod_link_args_fmt = ['-bundle_loader', '@0@']

mod_link_with_dir = 'bindir'

mod_link_with_name = '@0@'

sysroot_args = [files('src/tools/darwin_sysroot'), get_option('darwin_sysroot')]

pg_sysroot = run_command(sysroot_args, check:true).stdout().strip()

message('darwin sysroot: @0@'.format(pg_sysroot))

if pg_sysroot != ''

cflags += ['-isysroot', pg_sysroot]

ldflags += ['-isysroot', pg_sysroot]

endif

# meson defaults to -Wl,-undefined,dynamic_lookup for modules, which we

# don't want because a) it's different from what we do for autoconf, b) it

# causes warnings in macOS Ventura. But using -Wl,-undefined,error causes a

# warning starting in Sonoma. So only add -Wl,-undefined,error if it does

# not cause a warning.

if cc.has_multi_link_arguments('-Wl,-undefined,error', '-Werror')

ldflags_mod += '-Wl,-undefined,error'

endif

# Starting in Sonoma, the linker warns about the same library being

# linked twice. Which can easily happen when multiple dependencies

# depend on the same library. Quiesce the ill considered warning.

ldflags += cc.get_supported_link_arguments('-Wl,-no_warn_duplicate_libraries')

elif host_system == 'freebsd'

sema_kind = 'unnamed_posix'

elif host_system == 'linux'

sema_kind = 'unnamed_posix'

cppflags += '-D_GNU_SOURCE'

elif host_system == 'netbsd'

# We must resolve all dynamic linking in the core server at program start.

# Otherwise the postmaster can self-deadlock due to signals interrupting

# resolution of calls, since NetBSD's linker takes a lock while doing that

# and some postmaster signal handlers do things that will also acquire that

# lock. As long as we need "-z now", might as well specify "-z relro" too.

# While there's not a hard reason to adopt these settings for our other

# executables, there's also little reason not to, so just add them to

# LDFLAGS.

ldflags += ['-Wl,-z,now', '-Wl,-z,relro']

elif host_system == 'openbsd'

# you're ok

elif host_system == 'sunos'

portname = 'solaris'

sema_kind = 'unnamed_posix'

export_fmt = '-Wl,-M@0@'

# We need these #defines to get POSIX-conforming versions

# of many interfaces (sigwait, getpwuid_r, shmdt, ...).

cppflags += [

'-D_POSIX_C_SOURCE=200112L',

'-D__EXTENSIONS__',

'-D_POSIX_PTHREAD_SEMANTICS',

]

elif host_system == 'windows'

portname = 'win32'

exesuffix = '.exe'

dlsuffix = '.dll'

library_path_var = ''

if cc.get_id() != 'msvc'

# define before including <time.h> for getting localtime_r() etc. on MinGW

cppflags += '-D_POSIX_C_SOURCE'

endif

export_file_format = 'win'

export_file_suffix = 'def'

if cc.get_id() == 'msvc'

export_fmt = '/DEF:@0@'

mod_link_with_name = '@0@.lib'

else

export_fmt = '@0@'

mod_link_with_name = 'lib@0@.a'

endif

mod_link_args_fmt = ['@0@']

mod_link_with_dir = 'libdir'

shmem_kind = 'win32'

sema_kind = 'win32'

cdata.set('WIN32_STACK_RLIMIT', 4194304)

if cc.get_id() == 'msvc'

ldflags += '/INCREMENTAL:NO'

ldflags += '/STACK:@0@'.format(cdata.get('WIN32_STACK_RLIMIT'))

# ldflags += '/nxcompat' # generated by msbuild, should have it for ninja?

else

ldflags += '-Wl,--stack,@0@'.format(cdata.get('WIN32_STACK_RLIMIT'))

# Need to allow multiple definitions, we e.g. want to override getopt.

ldflags += '-Wl,--allow-multiple-definition'

# Ensure we get MSVC-like linking behavior.

ldflags += '-Wl,--disable-auto-import'

endif

os_deps += cc.find_library('ws2_32', required: true)

secur32_dep = cc.find_library('secur32', required: true)

backend_deps += secur32_dep

libpq_deps += secur32_dep

postgres_inc_d += 'src/include/port/win32'

if cc.get_id() == 'msvc'

postgres_inc_d += 'src/include/port/win32_msvc'

endif

windows = import('windows')

# XXX: Should we add an option to override the host_system as an escape

# hatch?

error('unknown host system: @0@'.format(host_system))

perl = find_program(get_option('PERL'), required: true, native: true)

python = find_program(get_option('PYTHON'), required: true, native: true)

flex = find_program(get_option('FLEX'), native: true)

bison = find_program(get_option('BISON'), native: true, version: '>= 2.3')

sed = find_program(get_option('SED'), 'sed', native: true, required: false)

prove = find_program(get_option('PROVE'), native: true, required: false)

tar = find_program(get_option('TAR'), native: true, required: false)

gzip = find_program(get_option('GZIP'), native: true, required: false)

program_lz4 = find_program(get_option('LZ4'), native: true, required: false)

openssl = find_program(get_option('OPENSSL'), native: true, required: false)

program_zstd = find_program(get_option('ZSTD'), native: true, required: false)

dtrace = find_program(get_option('DTRACE'), native: true, required: get_option('dtrace'))

missing = find_program('config/missing', native: true)

cp = find_program('cp', required: false, native: true)

xmllint_bin = find_program(get_option('XMLLINT'), native: true, required: false)

xsltproc_bin = find_program(get_option('XSLTPROC'), native: true, required: false)

nm = find_program('nm', required: false, native: true)

ditaa = find_program('ditaa', native: true, required: false)

dot = find_program('dot', native: true, required: false)

bison_flags = []

if bison.found()

bison_version_c = run_command(bison, '--version', check: true)

# bison version string helpfully is something like

# >>bison (GNU bison) 3.8.1<<

bison_version = bison_version_c.stdout().split(' ')[3].split('\n')[0]

if bison_version.version_compare('>=3.0')

bison_flags += ['-Wno-deprecated']

endif

bison_cmd = [bison, bison_flags, '-o', '@OUTPUT0@', '-d', '@INPUT@']

bison_kw = {

'output': ['@BASENAME@.c', '@BASENAME@.h'],

'command': bison_cmd,

}

flex_flags = []

if flex.found()

flex_version_c = run_command(flex, '--version', check: true)

flex_version = flex_version_c.stdout().split(' ')[1].split('\n')[0]

flex_wrapper = files('src/tools/pgflex')

flex_cmd = [python, flex_wrapper,

'--builddir', '@BUILD_ROOT@',

'--srcdir', '@SOURCE_ROOT@',

'--privatedir', '@PRIVATE_DIR@',

'--flex', flex, '--perl', perl,

'-i', '@INPUT@', '-o', '@OUTPUT0@',

]

wget = find_program('wget', required: false, native: true)

wget_flags = ['-O', '@OUTPUT0@', '--no-use-server-timestamps']

install_files = files('src/tools/install_files')

meson_binpath_r = run_command(python, 'src/tools/find_meson', check: true)

if meson_binpath_r.stdout() == ''

error('huh, could not run find_meson.\nerrcode: @0@\nstdout: @1@\nstderr: @2@'.format(

meson_binpath_r.returncode(),

meson_binpath_r.stdout(),

meson_binpath_r.stderr()))

meson_binpath_s = meson_binpath_r.stdout().split('\n')

meson_binpath_len = meson_binpath_s.length()

if meson_binpath_len < 1

error('unexpected introspect line @0@'.format(meson_binpath_r.stdout()))

i = 0

meson_impl = ''

meson_binpath = ''

meson_args = []

foreach e : meson_binpath_s

if i == 0

meson_impl = e

elif i == 1

meson_binpath = e

else

meson_args += e

endif

i += 1

if meson_impl not in ['muon', 'meson']

error('unknown meson implementation "@0@"'.format(meson_impl))

meson_bin = find_program(meson_binpath, native: true)

cdata.set('USE_ASSERT_CHECKING', get_option('cassert') ? 1 : false)

cdata.set('USE_INJECTION_POINTS', get_option('injection_points') ? 1 : false)

blocksize = get_option('blocksize').to_int() * 1024

if get_option('segsize_blocks') != 0

if get_option('segsize') != 1

warning('both segsize and segsize_blocks specified, segsize_blocks wins')

endif

segsize = get_option('segsize_blocks')

segsize = (get_option('segsize') * 1024 * 1024 * 1024) / blocksize

if cc.sizeof('off_t', args: test_c_args) < 8

segsize_bytes = segsize * blocksize

if segsize_bytes >= (2 * 1024 * 1024 * 1024)

error('Large file support is not enabled. Segment size cannot be larger than 1GB.')

endif

cdata.set('BLCKSZ', blocksize, description:

Changing BLCKSZ requires an initdb.''')

cdata.set('XLOG_BLCKSZ', get_option('wal_blocksize').to_int() * 1024)

cdata.set('RELSEG_SIZE', segsize)

cdata.set('DEF_PGPORT', get_option('pgport'))

cdata.set_quoted('DEF_PGPORT_STR', get_option('pgport').to_string())

cdata.set_quoted('PG_KRB_SRVNAM', get_option('krb_srvnam'))

if get_option('system_tzdata') != ''

cdata.set_quoted('SYSTEMTZDIR', get_option('system_tzdata'))

pkg = 'postgresql'

dir_prefix = get_option('prefix')

dir_prefix_contains_pg = (dir_prefix.contains('pgsql') or dir_prefix.contains('postgres'))

dir_bin = get_option('bindir')

dir_data = get_option('datadir')

if not (dir_prefix_contains_pg or dir_data.contains('pgsql') or dir_data.contains('postgres'))

dir_data = dir_data / pkg

dir_sysconf = get_option('sysconfdir')

if not (dir_prefix_contains_pg or dir_sysconf.contains('pgsql') or dir_sysconf.contains('postgres'))

dir_sysconf = dir_sysconf / pkg

dir_lib = get_option('libdir')

dir_lib_pkg = dir_lib

if not (dir_prefix_contains_pg or dir_lib_pkg.contains('pgsql') or dir_lib_pkg.contains('postgres'))

dir_lib_pkg = dir_lib_pkg / pkg

dir_pgxs = dir_lib_pkg / 'pgxs'

dir_include = get_option('includedir')

dir_include_pkg = dir_include

dir_include_pkg_rel = ''

if not (dir_prefix_contains_pg or dir_include_pkg.contains('pgsql') or dir_include_pkg.contains('postgres'))

dir_include_pkg = dir_include_pkg / pkg

dir_include_pkg_rel = pkg

dir_man = get_option('mandir')

dir_doc = get_option('datadir') / 'doc'

if not (dir_prefix_contains_pg or dir_doc.contains('pgsql') or dir_doc.contains('postgres'))

dir_doc = dir_doc / pkg

dir_doc_html = dir_doc / 'html'

dir_locale = get_option('localedir')

dir_bitcode = dir_lib_pkg / 'bitcode'

dir_include_internal = dir_include_pkg / 'internal'

dir_include_server = dir_include_pkg / 'server'

dir_include_extension = dir_include_server / 'extension'

dir_data_extension = dir_data / 'extension'

dir_doc_extension = dir_doc / 'extension'

c11_test = '''

if not cc.compiles(c11_test, name: 'C11')

c11_ok = false

if cc.get_id() == 'msvc'

c11_test_args = ['/std:c11']

else

c11_test_args = ['-std=gnu11', '-std=c11']

endif

foreach arg : c11_test_args

if cc.compiles(c11_test, name: 'C11 with @0@'.format(arg), args: [arg])

c11_ok = true

cflags += arg

break

endif

endforeach

if not c11_ok

error('C compiler does not support C11')

endif

cxx11_test = '''

if have_cxx and not cxx.compiles(cxx11_test, name: 'C++11')

cxx11_ok = false

if cxx.get_id() == 'msvc'

cxx11_test_args = ['/std:c++14'] # oldest version supported

else

cxx11_test_args = ['-std=gnu++11', '-std=c++11']

endif

foreach arg : cxx11_test_args

if cxx.compiles(cxx11_test, name: 'C++11 with @0@'.format(arg), args: [arg])

cxx11_ok = true

cxxflags += arg

break

endif

endforeach

if not cxx11_ok

error('C++ compiler does not support C++11')

endif

postgres_inc = [include_directories(postgres_inc_d)]

test_lib_d = postgres_lib_d

test_c_args = cppflags + cflags

bsd_authopt = get_option('bsd_auth')

bsd_auth = not_found_dep

if cc.check_header('bsd_auth.h', required: bsd_authopt,

args: test_c_args, prefix: '#include <sys/types.h>',

include_directories: postgres_inc)

cdata.set('USE_BSD_AUTH', 1)

bsd_auth = declare_dependency()

bonjouropt = get_option('bonjour')

bonjour = not_found_dep

if cc.check_header('dns_sd.h', required: bonjouropt,

args: test_c_args, include_directories: postgres_inc) and \

cc.has_function('DNSServiceRegister',

args: test_c_args, include_directories: postgres_inc)

cdata.set('USE_BONJOUR', 1)

bonjour = declare_dependency()

docs_opt = get_option('docs')

docs_dep = not_found_dep

if not docs_opt.disabled()

if xmllint_bin.found() and xsltproc_bin.found()

docs_dep = declare_dependency()

elif docs_opt.enabled()

error('missing required tools (xmllint and xsltproc needed) for docs in HTML / man page format')

endif

docs_pdf_opt = get_option('docs_pdf')

docs_pdf_dep = not_found_dep

if not docs_pdf_opt.disabled()

fop = find_program(get_option('FOP'), native: true, required: docs_pdf_opt)

if xmllint_bin.found() and xsltproc_bin.found() and fop.found()

docs_pdf_dep = declare_dependency()

elif docs_pdf_opt.enabled()

error('missing required tools for docs in PDF format')

endif

gssapiopt = get_option('gssapi')

krb_srvtab = ''

have_gssapi = false

if not gssapiopt.disabled()

gssapi = dependency('krb5-gssapi', required: false)

have_gssapi = gssapi.found()

if not have_gssapi

# Hardcoded lookup for gssapi. This is necessary as gssapi on windows does

# not install neither pkg-config nor cmake dependency information.

if host_system == 'windows'

is_64 = cc.sizeof('void *', args: test_c_args) == 8

if is_64

gssapi_search_libs = ['gssapi64', 'krb5_64', 'comerr64']

else

gssapi_search_libs = ['gssapi32', 'krb5_32', 'comerr32']

endif

else

gssapi_search_libs = ['gssapi_krb5']

endif

gssapi_deps = []

foreach libname : gssapi_search_libs

lib = cc.find_library(libname, dirs: test_lib_d, required: false)

if lib.found()

have_gssapi = true

gssapi_deps += lib

endif

endforeach

if have_gssapi

gssapi = declare_dependency(dependencies: gssapi_deps)

endif

endif

if not have_gssapi

elif cc.check_header('gssapi/gssapi.h', dependencies: [gssapi], required: false,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_GSSAPI_GSSAPI_H', 1)

elif cc.check_header('gssapi.h', dependencies: [gssapi], required: gssapiopt,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_GSSAPI_H', 1)

else

have_gssapi = false

endif

if not have_gssapi

elif cc.check_header('gssapi/gssapi_ext.h', dependencies: [gssapi], required: false,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_GSSAPI_GSSAPI_EXT_H', 1)

elif cc.check_header('gssapi_ext.h', dependencies: [gssapi], required: gssapiopt,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_GSSAPI_EXT_H', 1)

else

have_gssapi = false

endif

if not have_gssapi

elif cc.has_function('gss_store_cred_into', dependencies: [gssapi],

args: test_c_args, include_directories: postgres_inc)

cdata.set('ENABLE_GSS', 1)

krb_srvtab = 'FILE:/@0@/krb5.keytab)'.format(get_option('sysconfdir'))

cdata.set_quoted('PG_KRB_SRVTAB', krb_srvtab)

elif gssapiopt.enabled()

error('''could not find function 'gss_store_cred_into' required for GSSAPI''')

else

have_gssapi = false

endif

if not have_gssapi and gssapiopt.enabled()

error('dependency lookup for gssapi failed')

endif

if not have_gssapi

gssapi = not_found_dep

ldapopt = get_option('ldap')

if ldapopt.disabled()

ldap = not_found_dep

ldap_r = not_found_dep

elif host_system == 'windows'

ldap = cc.find_library('wldap32', required: ldapopt)

ldap_r = ldap

# macos framework dependency is buggy for ldap (one can argue whether it's

# Apple's or meson's fault), leading to an endless recursion with ldap.h

# including itself. See https://github.com/mesonbuild/meson/issues/10002

# Luckily we only need pkg-config support, so the workaround isn't

# complicated.

ldap = dependency('ldap', method: 'pkg-config', required: false)

ldap_r = ldap

# Before 2.5 openldap didn't have a pkg-config file, and it might not be

# installed

if not ldap.found()

ldap = cc.find_library('ldap', required: ldapopt, dirs: test_lib_d,

has_headers: 'ldap.h', header_include_directories: postgres_inc)

# The separate ldap_r library only exists in OpenLDAP < 2.5, and if we

# have 2.5 or later, we shouldn't even probe for ldap_r (we might find a

# library from a separate OpenLDAP installation). The most reliable

# way to check that is to check for a function introduced in 2.5.

if not ldap.found()

# don't have ldap, we shouldn't check for ldap_r

elif cc.has_function('ldap_verify_credentials',

dependencies: ldap, args: test_c_args)

ldap_r = ldap # ldap >= 2.5, no need for ldap_r

else

# Use ldap_r for FE if available, else assume ldap is thread-safe.

ldap_r = cc.find_library('ldap_r', required: false, dirs: test_lib_d,

has_headers: 'ldap.h', header_include_directories: postgres_inc)

if not ldap_r.found()

ldap_r = ldap

else

# On some platforms ldap_r fails to link without PTHREAD_LIBS.

ldap_r = declare_dependency(dependencies: [ldap_r, thread_dep])

endif

# PostgreSQL sometimes loads libldap_r and plain libldap into the same

# process. Check for OpenLDAP versions known not to tolerate doing so;

# assume non-OpenLDAP implementations are safe. The dblink test suite

# exercises the hazardous interaction directly.

compat_test_code = '''

if not cc.compiles(compat_test_code,

name: 'LDAP implementation compatible',

dependencies: ldap, args: test_c_args)

warning('''

*** also uses LDAP will crash on exit.''')

endif

endif

endif

if ldap.found() and cc.has_function('ldap_initialize',

dependencies: ldap, args: test_c_args)

cdata.set('HAVE_LDAP_INITIALIZE', 1)

endif

if ldap.found()

assert(ldap_r.found())

cdata.set('USE_LDAP', 1)

assert(not ldap_r.found())

llvmopt = get_option('llvm')

llvm = not_found_dep

if have_cxx

llvm = dependency('llvm', version: '>=14', method: 'config-tool', required: llvmopt)

if llvm.found()

cdata.set('USE_LLVM', 1)

llvm_binpath = llvm.get_variable(configtool: 'bindir')

ccache = find_program('ccache', native: true, required: false)

# Some distros put LLVM and clang in different paths, so fallback to

# find via PATH, too.

clang = find_program(llvm_binpath / 'clang', 'clang', required: true)

endif

msg = 'llvm requires a C++ compiler'

if llvmopt.auto()

message(msg)

elif llvmopt.enabled()

error(msg)

endif

icuopt = get_option('icu')

if not icuopt.disabled()

icu = dependency('icu-uc', required: false, version: '>= 55')

if icu.found()

icu_i18n = dependency('icu-i18n', required: true)

endif

# Unfortunately the dependency is named differently with cmake

if not icu.found() # combine with above once meson 0.60.0 is required

icu = dependency('ICU', required: icuopt, version: '>= 55',

components: ['uc'], modules: ['ICU::uc'], method: 'cmake')

if icu.found()

icu_i18n = dependency('ICU', required: true,

components: ['i18n'], modules: ['ICU::i18n'])

endif

endif

if icu.found()

cdata.set('USE_ICU', 1)

else

icu_i18n = not_found_dep

endif

icu = not_found_dep

icu_i18n = not_found_dep

libcurlopt = get_option('libcurl')

oauth_flow_supported = false

if not libcurlopt.disabled()

# Check for libcurl 7.61.0 or higher (corresponding to RHEL8 and the ability

# to explicitly set TLS 1.3 ciphersuites).

libcurl = dependency('libcurl', version: '>= 7.61.0', required: libcurlopt)

if libcurl.found()

# Check to see whether the current platform supports thread-safe Curl

# initialization.

libcurl_threadsafe_init = false