project('postgresql',

['c'],

version: '17beta2',

license: 'PostgreSQL',

# We want < 0.56 for python 3.5 compatibility on old platforms. EPEL for

# RHEL 7 has 0.55. < 0.54 would require replacing some uses of the fs

# module, < 0.53 all uses of fs. So far there's no need to go to >=0.56.

meson_version: '>=0.54',

default_options: [

'warning_level=1', #-Wall equivalent

'b_pch=false',

'buildtype=debugoptimized', # -O2 + debug

# 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')

not_found_dep = dependency('', required: false)

thread_dep = dependency('threads')

auto_features = get_option('auto_features')

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 = []

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', '[email protected]')

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 == 'cygwin'

sema_kind = 'unnamed_posix'

cppflags += '-D_GNU_SOURCE'

dlsuffix = '.dll'

mod_link_args_fmt = ['@0@']

mod_link_with_name = 'lib@[email protected]'

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'

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

cppflags += '-D_POSIX_PTHREAD_SEMANTICS'

elif host_system == 'windows'

portname = 'win32'

exesuffix = '.exe'

dlsuffix = '.dll'

library_path_var = ''

export_file_format = 'win'

export_file_suffix = 'def'

if cc.get_id() == 'msvc'

export_fmt = '/DEF:@0@'

mod_link_with_name = '@[email protected]'

else

export_fmt = '@0@'

mod_link_with_name = 'lib@[email protected]'

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, version: '>= 2.5.35')

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)

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

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': ['@[email protected]', '@[email protected]'],

'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

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'))

cdata.set('DEF_ORAPORT', get_option('oraport'))

cdata.set_quoted('DEF_ORAPORT_STR', get_option('oraport').to_string())

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'

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, 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: gssapiopt)

have_gssapi = gssapi.found()

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', args: test_c_args, dependencies: gssapi, required: gssapiopt)

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', args: test_c_args, dependencies: gssapi, required: gssapiopt)

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

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 add_languages('cpp', required: llvmopt, native: false)

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

if llvm.found()

cdata.set('USE_LLVM', 1)

cpp = meson.get_compiler('cpp')

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

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

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

endif

elif llvmopt.auto()

message('llvm requires a C++ compiler')

icuopt = get_option('icu')

if not icuopt.disabled()

icu = dependency('icu-uc', required: icuopt)

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

if icu.found()

cdata.set('USE_ICU', 1)

endif

icu = not_found_dep

icu_i18n = not_found_dep

libxmlopt = get_option('libxml')

if not libxmlopt.disabled()

libxml = dependency('libxml-2.0', required: libxmlopt, version: '>= 2.6.23')

if libxml.found()

cdata.set('USE_LIBXML', 1)

endif

libxml = not_found_dep

libxsltopt = get_option('libxslt')

if not libxsltopt.disabled()

libxslt = dependency('libxslt', required: libxsltopt)

if libxslt.found()

cdata.set('USE_LIBXSLT', 1)

endif

libxslt = not_found_dep

lz4opt = get_option('lz4')

if not lz4opt.disabled()

lz4 = dependency('liblz4', required: lz4opt)

if lz4.found()

cdata.set('USE_LZ4', 1)

cdata.set('HAVE_LIBLZ4', 1)

endif

lz4 = not_found_dep

tclopt = get_option('pltcl')

tcl_version = get_option('tcl_version')

tcl_dep = not_found_dep

if not tclopt.disabled()

# via pkg-config

tcl_dep = dependency(tcl_version, required: false)

if not tcl_dep.found()

tcl_dep = cc.find_library(tcl_version,

required: tclopt,

dirs: test_lib_d)

endif

if not cc.has_header('tcl.h', dependencies: tcl_dep, required: tclopt)

tcl_dep = not_found_dep

endif

pamopt = get_option('pam')

if not pamopt.disabled()

pam = dependency('pam', required: false)

if not pam.found()

pam = cc.find_library('pam', required: pamopt, dirs: test_lib_d)

endif

if pam.found()

pam_header_found = false

# header file <security/pam_appl.h> or <pam/pam_appl.h> is required for PAM.

if cc.check_header('security/pam_appl.h', dependencies: pam, required: false,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_SECURITY_PAM_APPL_H', 1)

pam_header_found = true

elif cc.check_header('pam/pam_appl.h', dependencies: pam, required: pamopt,

args: test_c_args, include_directories: postgres_inc)

cdata.set('HAVE_PAM_PAM_APPL_H', 1)

pam_header_found = true

endif

if pam_header_found

cdata.set('USE_PAM', 1)

else

pam = not_found_dep

endif

endif

pam = not_found_dep

perlopt = get_option('plperl')

perl_dep = not_found_dep

if not perlopt.disabled()

perl_may_work = true

# First verify that perl has the necessary dependencies installed

perl_mods = run_command(

[perl,

'-MConfig', '-MOpcode', '-MExtUtils::Embed', '-MExtUtils::ParseXS',

'-e', ''],

check: false)

if perl_mods.returncode() != 0

perl_may_work = false

perl_msg = 'perl installation does not have the required modules'

endif

# Then inquire perl about its configuration

if perl_may_work

perl_conf_cmd = [perl, '-MConfig', '-e', 'print $Config{$ARGV[0]}']

perlversion = run_command(perl_conf_cmd, 'api_versionstring', check: true).stdout()

archlibexp = run_command(perl_conf_cmd, 'archlibexp', check: true).stdout()

privlibexp = run_command(perl_conf_cmd, 'privlibexp', check: true).stdout()

useshrplib = run_command(perl_conf_cmd, 'useshrplib', check: true).stdout()

perl_inc_dir = '@0@/CORE'.format(archlibexp)

if perlversion.version_compare('< 5.14')

perl_may_work = false

perl_msg = 'Perl version 5.14 or later is required, but this is @0@'.format(perlversion)

elif useshrplib != 'true'

perl_may_work = false

perl_msg = 'need a shared perl'

endif

endif

if perl_may_work

# On most platforms, archlibexp is also where the Perl include files live ...

perl_ccflags = ['-I@0@'.format(perl_inc_dir)]

# ... but on newer macOS versions, we must use -iwithsysroot to look

# under sysroot

if not fs.is_file('@0@/perl.h'.format(perl_inc_dir)) and \

fs.is_file('@0@@1@/perl.h'.format(pg_sysroot, perl_inc_dir))

perl_ccflags = ['-iwithsysroot', perl_inc_dir]

endif

# check compiler finds header

if not cc.has_header('perl.h', required: false,

args: test_c_args + perl_ccflags, include_directories: postgres_inc)

perl_may_work = false

perl_msg = 'missing perl.h'

endif

endif

if perl_may_work

perl_ccflags_r = run_command(perl_conf_cmd, 'ccflags', check: true).stdout()

# See comments for PGAC_CHECK_PERL_EMBED_CCFLAGS in perl.m4

foreach flag : perl_ccflags_r.split(' ')

if flag.startswith('-D') and \

(not flag.startswith('-D_') or flag == '_USE_32BIT_TIME_T')

perl_ccflags += flag

endif

endforeach

if host_system == 'windows'

perl_ccflags += ['-DPLPERL_HAVE_UID_GID']

if cc.get_id() == 'msvc'

# prevent binary mismatch between MSVC built plperl and Strawberry or

# msys ucrt perl libraries

perl_ccflags += ['-DNO_THREAD_SAFE_LOCALE']

endif

endif

message('CCFLAGS recommended by perl: @0@'.format(perl_ccflags_r))

message('CCFLAGS for embedding perl: @0@'.format(' '.join(perl_ccflags)))

# We are after Embed's ldopts, but without the subset mentioned in

# Config's ccdlflags and ldflags. (Those are the choices of those who

# built the Perl installation, which are not necessarily appropriate

# for building PostgreSQL.)

ldopts = run_command(perl, '-MExtUtils::Embed', '-e', 'ldopts', check: true).stdout().strip()

undesired = run_command(perl_conf_cmd, 'ccdlflags', check: true).stdout().split()