project('glib', 'c', 'cpp',
- version : '2.64.5',
+ version : '2.67.1',
# NOTE: We keep this pinned at 0.49 because that's what Debian 10 ships
meson_version : '>= 0.49.2',
default_options : [
host_system = host_machine.system()
+if host_system == 'darwin'
+ ios_test_code = '''#include <TargetConditionals.h>
+ #if ! TARGET_OS_IPHONE
+ #error "Not iOS/tvOS/watchOS/iPhoneSimulator"
+ #endif'''
+ if cc.compiles(ios_test_code, name : 'building for iOS')
+ host_system = 'ios'
+ endif
+endif
+
glib_version = meson.project_version()
glib_api_version = '2.0'
version_arr = glib_version.split('.')
endif
glibconfig_conf.set('glib_os', glib_os)
-# We need to know the build type to determine what .lib files we need on Visual Studio
-# for dependencies that don't normally come with pkg-config files for Visual Studio builds
-buildtype = get_option('buildtype')
+# We need to know the CRT being used to determine what .lib files we need on
+# Visual Studio for dependencies that don't normally come with pkg-config files
+vs_crt = 'release'
+vs_crt_opt = get_option('b_vscrt')
+if vs_crt_opt in ['mdd', 'mtd']
+ vs_crt = 'debug'
+elif vs_crt_opt == 'from_buildtype'
+ if get_option('buildtype') == 'debug'
+ vs_crt = 'debug'
+ endif
+endif
+# Use debug/optimization flags to determine whether to enable debug or disable
+# cast checks
glib_debug_cflags = []
-if buildtype.startswith('debug')
+if get_option('debug')
glib_debug_cflags += ['-DG_ENABLE_DEBUG']
-elif buildtype == 'release'
+ message('Enabling various debug infrastructure')
+elif get_option('optimization') in ['2', '3', 's']
glib_debug_cflags += ['-DG_DISABLE_CAST_CHECKS']
+ message('Disabling cast checks')
+endif
+
+if not get_option('glib_assert')
+ glib_debug_cflags += ['-DG_DISABLE_ASSERT']
+ message('Disabling GLib asserts')
+endif
+
+if not get_option('glib_checks')
+ glib_debug_cflags += ['-DG_DISABLE_CHECKS']
+ message('Disabling GLib checks')
endif
add_project_arguments(glib_debug_cflags, language: 'c')
glib_conf.set('HAVE_NETLINK', 1)
endif
+# Is statx() supported? Android systems don’t reliably support it as of August 2020.
+statx_code = '''
+ #ifndef _GNU_SOURCE
+ #define _GNU_SOURCE
+ #endif
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ int main (void)
+ {
+ struct statx stat_buf;
+ return statx (AT_FDCWD, "/", AT_SYMLINK_NOFOLLOW, STATX_BASIC_STATS | STATX_BTIME, &stat_buf);
+ }
+ '''
+if host_system != 'android' and cc.compiles(statx_code, name : 'statx() test')
+ glib_conf.set('HAVE_STATX', 1)
+endif
+
if glib_conf.has('HAVE_LOCALE_H')
if cc.has_header_symbol('locale.h', 'LC_MESSAGES')
glib_conf.set('HAVE_LC_MESSAGES', 1)
endif
functions = [
+ 'close_range',
'endmntent',
'endservent',
'fallocate',
'wcslen',
'wcsnlen',
'sysctlbyname',
- '_NSGetEnviron',
]
+# _NSGetEnviron is available on iOS too, but its usage gets apps rejected from
+# the app store since it's considered 'private API'
+if host_system == 'darwin'
+ functions += ['_NSGetEnviron']
+endif
+
if glib_conf.has('HAVE_SYS_STATVFS_H')
functions += ['statvfs']
else
glib_conf.set('HAVE_STPCPY', 1)
endif
+# When building for Android-20 and earlier, require Meson 0.54.2 or newer.
+# This is needed, because Meson build versions prior to 0.54.2 return false
+# positive for stpcpy has_function check when building for legacy Android.
+if host_system.startswith('android-')
+ android_is_older = cc.compiles('''#if __ANDROID_API__ >= 21
+ #error Android is 21 or newer
+ #endif''')
+ if android_is_older and meson.version().version_compare('< 0.54.2')
+ error('Compiling for <Android-21 requires Meson 0.54.2 or newer')
+ endif
+endif
+
+
# Check that posix_memalign() is usable; must use header
if host_system != 'windows' and cc.has_function('posix_memalign', prefix : '#include <stdlib.h>')
glib_conf.set('HAVE_POSIX_MEMALIGN', 1)
glib_conf.set('HAVE_EVENTFD', 1)
endif
+# Check for __uint128_t (gcc) by checking for 128-bit division
+uint128_t_src = '''int main() {
+static __uint128_t v1 = 100;
+static __uint128_t v2 = 10;
+static __uint128_t u;
+u = v1 / v2;
+}'''
+if cc.compiles(uint128_t_src, name : '__uint128_t available')
+ glib_conf.set('HAVE_UINT128_T', 1)
+endif
+
clock_gettime_test_code = '''
#include <time.h>
struct timespec t;
glib_conf.set('HAVE_OPEN_O_DIRECTORY', 1)
endif
+# fcntl takes F_FULLFSYNC as an option
+# See https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fsync.2.html
+if cc.compiles('''#include <fcntl.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ void some_func (void) {
+ fcntl(0, F_FULLFSYNC, 0);
+ }''', name : 'fcntl() option F_FULLFSYNC')
+ glib_conf.set('HAVE_FCNTL_F_FULLFSYNC', 1)
+endif
+
# Check whether there is a vsnprintf() function with C99 semantics installed.
# (similar tests to AC_FUNC_VSNPRINTF_C99)
# Check whether there is a snprintf() function with C99 semantics installed.
glibconfig_conf.set(d[1], val)
endforeach
-# We need a more robust approach here...
-host_cpu_family = host_machine.cpu_family()
-if host_cpu_family == 'x86' or host_cpu_family == 'x86_64' or host_cpu_family == 's390' or host_cpu_family == 's390x' or host_cpu_family.startswith('arm') or host_cpu_family == 'aarch64' or host_cpu_family.startswith('crisv32') or host_cpu_family.startswith('etrax')
- glib_memory_barrier_needed = false
-elif host_cpu_family.startswith('sparc') or host_cpu_family.startswith('alpha') or host_cpu_family.startswith('powerpc') or host_cpu_family == 'ia64'
- glib_memory_barrier_needed = true
-else
- warning('Unknown host cpu: ' + host_cpu_family)
- glib_memory_barrier_needed = true
-endif
-glibconfig_conf.set('G_ATOMIC_OP_MEMORY_BARRIER_NEEDED', glib_memory_barrier_needed)
-
# We need to decide at configure time if GLib will use real atomic
# operations ("lock free") or emulated ones with a mutex. This is
# because we must put this information in glibconfig.h so we know if
# that then to silently fall back on emulated atomic ops just because
# the user had the wrong build environment.
atomictest = '''int main() {
- volatile int atomic = 2;
+ int atomic = 2;
__sync_bool_compare_and_swap (&atomic, 2, 3);
return 0;
}
# FIXME: we should make it print the result and always return 0, so that
# the output in meson shows up as green
+# volatile is needed here to avoid optimisations in the test
stack_grows_check_prog = '''
volatile int *a = 0, *b = 0;
void f (int i) {
# MSVC: Search for the PCRE library by the configuration, which corresponds
# to the output of CMake builds of PCRE. Note that debugoptimized
# is really a Release build with .PDB files.
- if buildtype == 'debug'
+ if vs_crt == 'debug'
pcre = cc.find_library('pcred', required : false)
else
pcre = cc.find_library('pcre', required : false)
# proxy-libintl subproject.
# FIXME: glib-gettext.m4 has much more checks to detect broken/uncompatible
# implementations. This could be extended if issues are found in some platforms.
+libintl_deps = []
if cc.has_function('ngettext')
- libintl = []
have_bind_textdomain_codeset = cc.has_function('bind_textdomain_codeset')
else
+ # First just find the bare library.
libintl = cc.find_library('intl', required : false)
+ # The bare library probably won't link without help if it's static.
+ if libintl.found() and not cc.has_function('ngettext', dependencies : libintl)
+ libintl_iconv = cc.find_library('iconv', required : false)
+ # libintl supports different threading APIs, which may not
+ # require additional flags, but it defaults to using pthreads if
+ # found. Meson's "threads" dependency does not allow you to
+ # prefer pthreads. We may not be using pthreads for glib itself
+ # either so just link the library to satisfy libintl rather than
+ # also defining the macros with the -pthread flag.
+ libintl_pthread = cc.find_library('pthread', required : false)
+ # Try linking with just libiconv.
+ if libintl_iconv.found() and cc.has_function('ngettext', dependencies : [libintl, libintl_iconv])
+ libintl_deps += [libintl_iconv]
+ # Then also try linking with pthreads.
+ elif libintl_iconv.found() and libintl_pthread.found() and cc.has_function('ngettext', dependencies : [libintl, libintl_iconv, libintl_pthread])
+ libintl_deps += [libintl_iconv, libintl_pthread]
+ else
+ libintl = disabler()
+ endif
+ endif
if not libintl.found()
libintl = subproject('proxy-libintl').get_variable('intl_dep')
+ libintl_deps = [libintl] + libintl_deps
have_bind_textdomain_codeset = true # proxy-libintl supports it
else
+ libintl_deps = [libintl] + libintl_deps
have_bind_textdomain_codeset = cc.has_function('bind_textdomain_codeset',
- dependencies : libintl)
+ dependencies : libintl_deps)
endif
endif
selinux_dep = []
if host_system == 'linux'
- selinux_dep = dependency('libselinux', required: get_option('selinux'))
+ selinux_dep = dependency('libselinux', version: '>=2.2', required: get_option('selinux'))
glib_conf.set('HAVE_SELINUX', selinux_dep.found())
endif
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
-#undef NDEBUG
-#include <assert.h>
static int
__getcmdline (void)
struct stat stat_buf;
int fd = open ("/proc/self/cmdline", O_RDONLY|O_BINARY);
- assert (fd >= 0);
- assert (fstat (fd, &stat_buf) == 0);
+ if (fd < 0)
+ exit (1);
+ if (fstat (fd, &stat_buf))
+ exit (1);
if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode))
- assert (read (fd, result, BUFSIZE) > 0);
+ {
+ if (read (fd, result, BUFSIZE) <= 0)
+ exit (1);
+ }
else
{
FILE *f = fdopen (fd, "r");
- assert (f != NULL);
- assert (fread (result, 1, BUFSIZE, f) > 0);
+ if (f == NULL)
+ exit (1);
+
+ if (fread (result, 1, BUFSIZE, f) <= 0)
+ exit (1);
}
return 0;
export_dynamic_ldflags = []
elif host_system == 'cygwin'
export_dynamic_ldflags = ['-Wl,--export-all-symbols']
-elif host_system == 'darwin'
+elif host_system in ['darwin', 'ios']
export_dynamic_ldflags = []
elif host_system == 'sunos'
export_dynamic_ldflags = []
projects / platform / upstream / glib.git / blobdiff