project('graphene', 'c',

version: '1.11.1',

license: 'MIT',

meson_version: '>= 1.0',

default_options: [

'buildtype=debugoptimized',

'c_std=c99',

'warning_level=1'

],

)

cc = meson.get_compiler('c')

host_system = host_machine.system()

host_cpu_family = host_machine.cpu_family()

add_project_arguments([ '-D_GNU_SOURCE' ], language: 'c')

# Version

graphene_version = meson.project_version()

version_array = graphene_version.split('.')

graphene_major_version = version_array[0].to_int()

graphene_minor_version = version_array[1].to_int()

graphene_micro_version = version_array[2].to_int()

graphene_api_version = '@0@.0'.format(graphene_major_version)

# The interface age is reset every time we add new API; this

# should only happen during development cycles, otherwise the

# interface age is the same as the micro version

if graphene_minor_version.is_odd()

graphene_interface_age = 0

else

graphene_interface_age = graphene_micro_version

endif

graphene_binary_age = 100 * graphene_minor_version + graphene_micro_version

# Maintain compatibility with the previous libtool versioning

soversion = 0

current = graphene_binary_age - graphene_interface_age

revision = graphene_interface_age

libversion = '@0@.@1@.@2@'.format(soversion, current, revision)

darwin_versions = [current + 1, '@0@.@1@'.format(current + 1, revision)]

# Paths

graphene_prefix = get_option('prefix')

graphene_libdir = graphene_prefix / get_option('libdir')

graphene_includedir = graphene_prefix / get_option('includedir')

graphene_datadir = graphene_prefix / get_option('datadir')

graphene_api_path = '@0@-@1@'.format(meson.project_name(), graphene_api_version)

conf = configuration_data()

# Compiler and linker flags

common_cflags = []

common_ldflags = []

if cc.get_id() == 'msvc'

# Make MSVC more pedantic, this is a recommended pragma list

# from _Win32_Programming_ by Rector and Newcomer. Taken from

# glib's msvc_recommended_pragmas.h--please see that file for

# the meaning of the warning codes used here

test_cflags = [

'-we4002',

'-we4003',

'-w14010',

'-we4013',

'-w14016',

'-we4020',

'-we4021',

'-we4027',

'-we4029',

'-we4033',

'-we4035',

'-we4045',

'-we4047',

'-we4049',

'-we4053',

'-we4071',

'-we4244',

'-we4150',

'-utf-8'

]

else

test_cflags = [

'-ffast-math',

'-fstrict-aliasing',

'-Wpointer-arith',

'-Wstrict-prototypes',

'-Wnested-externs',

'-Wold-style-definition',

'-Wunused',

'-Wmissing-noreturn',

'-Wmissing-format-attribute',

'-Wlogical-op',

'-Wcast-align',

'-Wno-unused-local-typedefs',

'-Werror=float-conversion',

'-Werror=float-equal',

'-Werror=redundant-decls',

'-Werror=missing-prototypes',

'-Werror=missing-declarations',

'-Werror=format=2',

'-Werror=uninitialized',

'-Werror=shadow',

'-Werror=implicit',

'-Werror=init-self',

'-Werror=main',

'-Werror=missing-braces',

'-Werror=return-type',

'-Werror=array-bounds',

'-Werror=write-strings',

'-Werror=undef',

]

endif

common_cflags = cc.get_supported_arguments(test_cflags)

# MSVC: Let C4819 error out if we do not have the -utf-8 compiler flag

if cc.get_id() == 'msvc'

if not common_cflags.contains('-utf-8')

common_cflags += cc.get_supported_arguments('-we4819')

endif

endif

common_ldflags = []

if host_system == 'linux'

ldflags = [ '-Wl,-Bsymbolic-functions', '-Wl,-z,relro', '-Wl,-z,now', ]

common_ldflags += cc.get_supported_link_arguments(ldflags)

endif

# Required dependencies

mathlib = cc.find_library('m', required: false)

threadlib = dependency('threads')

# Headers

test_headers = [

'stdlib.h',

'stdint.h',

'stdbool.h',

'memory.h',

]

foreach h: test_headers

conf.set('HAVE_' + h.underscorify().to_upper(),

cc.has_header(h),

description: 'Define if @0@ is available'.format(h),

)

endforeach

conf.set('HAVE_PTHREAD_H',

cc.has_header('pthread.h', dependencies: threadlib),

description: 'Define if pthread.h is available',

)

# Functions

if cc.has_function('memalign', prefix: '#include <stdlib.h>\n#include <malloc.h>')

conf.set10('HAVE_MEMALIGN', true, description: 'Define if memalign() is available')

elif cc.has_function('_aligned_malloc', prefix: '#include <malloc.h>')

conf.set10('HAVE__ALIGNED_MALLOC', true, description: 'Define if _aligned_malloc() is available')

# Don't probe the ones below on Windows because when building with

# MinGW-w64 on MSYS2, Meson<0.37.0 incorrectly detects those below as

# being available even though they're not.

elif cc.has_function('aligned_alloc', prefix: '#include <stdlib.h>') and not (host_system == 'windows')

conf.set10('HAVE_ALIGNED_ALLOC', true, description: 'Define if aligned_malloc() is available')

elif cc.has_function('posix_memalign', prefix: '#include <stdlib.h>') and not (host_system == 'windows')

conf.set10('HAVE_POSIX_MEMALIGN', true, description: 'Define if posix_memalign() is available')

else

error('No aligned malloc function could be found.')

endif

math_exts = [

'sincosf',

'isinff',

'isnanf',

]

foreach mfunc: math_exts

conf.set('HAVE_' + mfunc.underscorify().to_upper(),

cc.has_function(mfunc,

prefix: '#include <math.h>',

args: [ '-D_GNU_SOURCE' ],

dependencies: mathlib,

),

description: 'Define if @0@ is available'.format(mfunc),

)

endforeach

# Debugging

debug_flags = []

if get_option('debug')

debug_flags += [ '-DGRAPHENE_ENABLE_DEBUG' ]

message('Enabling various debug infrastructure')

elif get_option('optimization') in ['2', '3', 's']

debug_flags += [ '-DG_DISABLE_ASSERT' ]

message('Disabling assertions')

endif

extra_args = []

# Export DLL symbols on Windows when building a shared library

if get_option('default_library') != 'static' and host_system == 'windows'

conf.set('DLL_EXPORT', true)

endif

# Optional dependency on GObject

build_gobject = false

gobject_req_version = '>= 2.30.0'

if get_option('gobject_types')

graphene_gobject_api_path = '@0@-gobject-@1@'.format(meson.project_name(), graphene_api_version)

# Automatic fallback to a subproject of glib is possible if you install

# glib.wrap: meson wrap install glib

gobject = dependency('gobject-2.0',

version: gobject_req_version,

required: false,

)

build_gobject = gobject.found()

if build_gobject

if cc.get_id() == 'msvc'

extra_args += ['/FImsvc_recommended_pragmas.h']

endif

endif

endif

# Optional dependency on GObject-Introspection; if GObject is disabled

# then we don't build introspection data either.

#

# We only build introspection if we can run binaries on the host.

gir = find_program('g-ir-scanner', required: get_option('introspection'))

build_gir = get_option('introspection').allowed() and build_gobject and gir.found() and meson.can_run_host_binaries()

# Check for InitOnce on Windows

if host_system == 'windows'

init_once_prog = '''

#define _WIN32_WINNT 0x0600

#include <windows.h>

INIT_ONCE g_InitOnce = INIT_ONCE_STATIC_INIT;

BOOL CALLBACK InitHandleFunc (PINIT_ONCE i, PVOID arg, PVOID *ctx) { return TRUE; }

int main (void) {

BOOL bInitStatus = InitOnceExecuteOnce (&g_InitOnce, InitHandleFunc, NULL, NULL);

return 0;

}

'''

conf.set('HAVE_INIT_ONCE',

cc.compiles(init_once_prog, name: 'InitOnceExecuteOnce'),

description: 'Define if InitOnceExecuteOnce is available',

)

endif

# Check for IEEE 754 floating-point division compilance

float_division_prog = '''

#include <math.h>

int main() {

if (isinf(1.f / 0.f) != 1)

return 1;

if (isinf(1.f / -0.f) != -1)

return 2;

return 0;

}

'''

if not meson.can_run_host_binaries()

ieee754_float_div = meson.get_external_property('ieee754_float_div', cc.get_id() in ['gcc', 'clang'])

message('Cross-building, assuming IEEE 754 division:', ieee754_float_div)

else

ieee754_float_div = cc.run(float_division_prog, name: 'IEEE 754 floating-point division').returncode() == 0

endif

conf.set('HAVE_IEEE_754_FLOAT_DIVISION',

ieee754_float_div,

description: 'Define if floating-point division is compliant with IEEE 754',

)

# Configuration for our installed config header

graphene_conf = configuration_data()

# Enabled SIMD implementations

graphene_simd = []

# SSE intrinsics

sse2_cflags = []

if get_option('sse2')

sse_prog = '''

#if defined(__GNUC__)

# if !defined(__amd64__) && !defined(__x86_64__)

# error "SSE2 intrinsics are only available on x86_64"

# endif

#elif defined (_MSC_VER) && !defined (_M_X64) && !defined (_M_AMD64)

# error "SSE2 intrinsics not supported on x86 MSVC builds"

#endif

#if defined(__SSE__) || (_M_X64 > 0)

# include <mmintrin.h>

# include <xmmintrin.h>

# include <emmintrin.h>

#else

# error "No SSE intrinsics available"

#endif

int main () {

__m128i a = _mm_set1_epi32 (0), b = _mm_set1_epi32 (0), c;

c = _mm_xor_si128 (a, b);

return 0;

}'''

if cc.get_id() != 'msvc'

test_sse2_cflags = ['-mfpmath=sse', '-msse', '-msse2']

else

test_sse2_cflags = []

endif

if cc.compiles(sse_prog, args: test_sse2_cflags, name: 'SSE intrinsics')

graphene_conf.set('GRAPHENE_HAS_SSE', 1)

sse2_cflags = test_sse2_cflags

common_cflags += test_sse2_cflags

graphene_simd += [ 'sse2' ]

endif

endif

# GCC/Clang vector intrinsics

if get_option('gcc_vector')

vector_intrin_prog = '''

#if defined(__GNUC__) // Clang advertises __GNUC__ too

# if __GNUC__ < 4 || ((__GNUC__ == 4 && __GNUC_MINOR__ < 9) && !defined(__clang__))

# error "GCC/Clang vector intrinsics are disabled on GCC prior to 4.9"

# elif defined(__arm__)

# error "GCC/Clang vector intrinsics are disabled on ARM"

# elif (__SIZEOF_POINTER__ < 8)

# error "GCC/Clang vector intrinsics are disabled on 32bit"

# endif

#else

# error "Need GCC or Clang for vector intrinsics"

#endif

typedef float simd4f __attribute__((vector_size(16)));

typedef int simd4i __attribute__((vector_size(16)));

int main () {

simd4f s = { 1.f, 2.f, 3.f, 4.f };

#ifdef __clang__

simd4f r = __builtin_shufflevector (s, s, 0, 1, 1, 3);

#else

simd4i m = { 0, 1, 1, 3 };

simd4f r = __builtin_shuffle (s, m);

#endif

return 0;

}'''

if cc.compiles(vector_intrin_prog, name: 'Vector intrinsics')

if cc.get_id() == 'gcc'

graphene_conf.set('GRAPHENE_HAS_GCC', 1)

endif

graphene_conf.set('GRAPHENE_HAS_INTRINSICS', 1)

graphene_simd += [ 'intrinsics' ]

endif

endif

# ARM NEON intrinsics

neon_cflags = []

if get_option('arm_neon')

neon_prog = '''

#if !defined (_MSC_VER) || defined (__clang__)

# if !defined (_M_ARM64) && !defined (__aarch64__)

# ifndef __ARM_EABI__

# error "EABI is required (to be sure that calling conventions are compatible)"

# endif

# ifndef __ARM_NEON__

# error "No ARM NEON instructions available"

# endif

# endif

#endif

#if defined (_MSC_VER) && (_MSC_VER < 1920) && defined (_M_ARM64)

# include <arm64_neon.h>

#else

# include <arm_neon.h>

#endif

int main () {

const float32_t __v[4] = { 1, 2, 3, 4 }; \

const unsigned int __umask[4] = { \

0x80000000, \

0x80000000, \

0x80000000, \

0x80000000 \

}; \

const uint32x4_t __mask = vld1q_u32 (__umask); \

float32x4_t s = vld1q_f32 (__v); \

float32x4_t c = vreinterpretq_f32_u32 (veorq_u32 (vreinterpretq_u32_f32 (s), __mask)); \

return 0;

}'''

test_neon_cflags = []

if cc.get_id() != 'msvc' and host_cpu_family != 'aarch64'

test_neon_cflags += ['-mfpu=neon']

endif

if host_system == 'android'

test_neon_cflags += ['-mfloat-abi=softfp']

endif

if cc.compiles(neon_prog, args: test_neon_cflags, name: 'ARM NEON intrinsics')

graphene_conf.set('GRAPHENE_HAS_ARM_NEON', 1)

neon_cflags = test_neon_cflags

common_cflags += test_neon_cflags

graphene_simd += [ 'neon' ]

endif

endif

# Scalar is always available as a fallback

graphene_simd += [ 'scalar' ]

graphene_build_shared = false

graphene_build_static = false

if get_option('default_library') == 'both'

graphene_build_static = true

graphene_build_shared = true

elif get_option('default_library') == 'static'

graphene_build_static = true

elif get_option('default_library') == 'shared'

graphene_build_shared = true

endif

graphene_build_both = graphene_build_static and graphene_build_shared

graphene_build_static_only = graphene_build_static and not graphene_build_shared

graphene_build_shared_only = graphene_build_shared and not graphene_build_static

if graphene_build_shared and graphene_build_static and (

host_system == 'windows' or host_system == 'cygwin')

error('On Windows default_library must be "shared" or "static" but not "both"')

endif

if graphene_build_static_only

graphene_conf.set('GRAPHENE_STATIC_COMPILATION', '1')

endif

python = import('python')

gnome = import('gnome')

subdir('include')

src_inc = include_directories('src')

subdir('src')

if get_option('tests')

if cc.get_id() == 'msvc' and cc.version().version_compare('<19')

warning('Tests, specifically the mutest library, cannot be built for pre-2015 Visual Studio builds.')

warning('Use \'meson configure -Dtests=false\' if you are sure you want to proceed.')

endif

subdir('tests')

endif

if get_option('gtk_doc')

subdir('doc')

endif

summary({

'prefix': get_option('prefix'),

'libdir': get_option('libdir'),

'includedir': get_option('includedir'),

},

section: 'Directories',

)

summary({

'SSE': graphene_simd.contains('sse2'),

'GCC/Clang vector': graphene_simd.contains('intrinsics'),

'ARM NEON': graphene_simd.contains('neon'),

},

section: 'SIMD',

bool_yn: true,

)

summary({

'GObject types': build_gobject,

'Introspection': build_gir,

},

section: 'Features',

bool_yn: true,

)

summary({

'Documentation': get_option('gtk_doc'),

'Tests': get_option('tests'),

'Installed tests': get_option('installed_tests'),

},

section: 'Build',

bool_yn: true,

)