libcruft-util/meson.build

project('cruft', 'cpp')

pymod = import('python')
python = pymod.find_installation('python3')

ragel = generator(
    find_program('ragel'),
    output: '@BASENAME@.cpp',
    arguments: [ '@INPUT@', '-o@OUTPUT@', '-G2' ]
)

if host_machine.endian() == 'big'
    add_project_arguments('-DWORDS_BIGENDIAN')
endif

add_project_arguments('-std=c++2a', language: 'cpp')
add_project_link_arguments('-lstdc++fs', language: 'cpp')

add_project_arguments('-Drestrict=__restrict', language: 'cpp')

sources = [
    ragel.process('uri.cpp.rl'),
    ragel.process('version.cpp.rl'),
    ragel.process('format.cpp.rl'),
    ragel.process('time/parse8601.cpp.rl'),
]

dependencies = [
    dependency('threads')
]


### Preemptively define an identity panic macro so that TCL doens't fuck us over
### by renaming a commonly used symbol.
add_project_arguments('-Dpanic=panic', language: 'cpp')


#################################################################################
cpp = meson.get_compiler('cpp')
execinfo = cpp.find_library('execinfo', required: false) # sym:backtrace
dbghelp = cpp.find_library('dbghelp', required: false) # sym:SymFromAddr
capture_stack_backtrace = cpp.has_function('RtlCaptureStackBackTrace')

if execinfo.found()
    sources += 'backtrace_execinfo.cpp'
elif dbghelp.found()
    sources += 'backtrace_stackwalk.cpp'
    dependencies += dbghelp
else 
    sources += 'backtrace_null.cpp'
endif


sources += custom_target(
    'preprocessor.hpp',
    output: 'preprocessor.hpp',
    input: 'preprocessor.py',
    command: [python, '@INPUT@', '@OUTPUT@', '480'],
)


#################################################################################
### Platform wrappers
systems = {
    'linux': 'linux',
    'freebsd': 'freebsd',
    'windows': 'win32'
}

# TODO: handle missing system
sources += 'exe_@0@.cpp'.format(systems[host_machine.system()])


sources += [
    'posix/dir.cpp',
    'posix/dir.hpp',
    'posix/except.cpp',
    'posix/except.hpp',
    'posix/fd.cpp',
    'posix/fd.hpp',
]


if host_machine.system() == 'linux'
    sources += [
        'thread/event_futex.cpp',
        'thread/flag_futex.cpp',
    ]
endif


if host_machine.system() != 'windows'
    sources += [
        'buffer/circular.cpp',
        'buffer/circular.hpp',
        'buffer/paged.cpp',
        'buffer/paged.hpp',
        'memory/system.cpp',
        'memory/system.hpp',
        'debug_posix.cpp',
        'io_posix.cpp',
        'io_posix.hpp',
        'library_posix.hpp',
        'library_posix.cpp',
        'posix/fwd.hpp',
        'posix/map.cpp',
        'posix/map.hpp',
        'posix/socket.cpp',
        'posix/socket.hpp',
        'time_posix.cpp',
    ]
endif


####-----------------------------------------------------------------------------
if host_machine.system() == 'windows'
    sources += [
        'debug_win32.cpp',
        'exe_win32.cpp',
        'io_win32.cpp',
        'io_win32.hpp',
        'thread/event_win32.cpp',
        'library_win32.cpp',
        'library_win32.hpp',
        'time_win32.cpp',
        'win32/windows.hpp',
        'win32/except.cpp',
        'win32/except.hpp',
        'win32/file.cpp',
        'win32/file.hpp',
        'win32/handle.cpp',
        'win32/handle.hpp',
        'win32/registry.cpp',
        'win32/registry.hpp',
    ]

    dependencies += cpp.find_library('ws2_32')
endif


sources += [
    'thread/event.hpp',
    'thread/semaphore.hpp',
    'thread/flag.hpp',
]


if host_machine.system() == 'linux'
    sources += [
        'thread/event_futex.cpp',
        'thread/event_futex.hpp',
        'thread/semaphore_linux.hpp',
        'thread/semaphore_linux.cpp',
        'thread/flag_futex.cpp',
        'thread/flag_futex.hpp',
    ]
elif host_name.system() == 'windows'
    sources += [
        'thread/event_std.cpp',
        'thread/event_std.hpp',
        'thread/semaphore_win32.hpp',
        'thread/semaphore_win32.cpp',
        'thread/flag_std.cpp',
        'thread/flag_std.hpp',
    ]
else
    error('Unknown platform for threading')
endif


if host_machine.cpu_family() == 'x86_64'
    sources += [
        'cpuid/x86.cpp',
        'cpuid/x86.cpp',
    ]
else
    warning('Unknown architecture @0@. Defaulting to null cpuid'.format(host_machine.cpu_family()))
    sources += [
        'cpuid/none.cpp',
        'cpuid/none.hpp',
    ]
endif



if host_machine.system() == 'linux'
    sources += [
        'rand/system_linux.cpp',
        'rand/system_linux.hpp',
    ]
elif host_machine.system() == 'windows'
    sources += [
        'rand/system_win32.cpp',
        'rand/system_win32.hpp',
    ]
else
    error('Unsupported system for rand')
endif


if host_machine.system() == 'linux'
    sources += [ 'sysinfo_posix.cpp' ]
elif host_machine.system() == 'windows'
    sources += [ 'sysinfo_win32.cpp' ]
else
    error('Unsupported system for sysinfo')
endif


#################################################################################
### Common files
sources += [
    'adapter.hpp',
    'adapter.cpp',
    'algo/search.hpp',
    'algo/sort.cpp',
    'algo/sort.hpp',
    'alloc/fwd.hpp',
    'alloc/affix.cpp',
    'alloc/affix.hpp',
    'alloc/aligned/direct.hpp',
    'alloc/aligned/foreign.hpp',
    'alloc/allocator.cpp',
    'alloc/allocator.hpp',
    'alloc/easy.hpp',
    'alloc/fallback.cpp',
    'alloc/fallback.hpp',
    'alloc/linear.cpp',
    'alloc/linear.hpp',
    'alloc/malloc.cpp',
    'alloc/malloc.hpp',
    'alloc/null.cpp',
    'alloc/null.hpp',
    'alloc/stack.cpp',
    'alloc/stack.hpp',
    'alloc/std.hpp',
    'alloc/traits.hpp',
    'alloc/traits.hpp',
    'annotation.hpp',
    'array/darray.hpp',
    'array/sarray.cpp',
    'array/sarray.hpp',
    'array/parray.cpp',
    'array/parray.hpp',
    'array/varray.hpp',
    'ascii.hpp',
    'backtrace.hpp',
    'bezier.cpp',
    'bezier1.cpp',
    'bezier2.cpp',
    'bezier3.cpp',
    'bezier.hpp',
    'bitwise.cpp',
    'bitwise.hpp',
    'buffer/simple.cpp',
    'buffer/simple.hpp',
    'buffer/traits.hpp',
    'cast.hpp',
    'cmdopt.cpp',
    'cmdopt.hpp',
    'colour.cpp',
    'colour.hpp',
    'coord.hpp',
    'coord/fwd.hpp',
    'coord/base.hpp',
    'coord/comparator.hpp',
    'coord/init.hpp',
    'coord/iostream.hpp',
    'coord/ops.hpp',
    'coord/store.hpp',
    'coord/traits.hpp',
    'cpp.cpp',
    'cpp.hpp',
    'cpuid.cpp',
    'cpuid.hpp',
    'debug/assert.cpp',
    'debug/assert.hpp',
    'debug/compiler.cpp',
    'debug/compiler.hpp',
    'debug/debugger.cpp',
    'debug/debugger.hpp',
    'debug/panic.cpp',
    'debug/panic.hpp',
    'debug/system.cpp',
    'debug/system.hpp',
    'debug/validate.cpp',
    'debug/validate.hpp',
    'encode/number.hpp',
    'encode/base.cpp',
    'encode/base.hpp',
    'endian.cpp',
    'endian.hpp',
    'except.cpp',
    'except.hpp',
    'exe.hpp',
    'expected.hpp',
    'extent.cpp',
    'extent.hpp',
    'fixed.cpp',
    'fixed.hpp',
    'float.cpp',
    'float.hpp',
    'format.hpp',
    'fourcc.cpp',
    'fourcc.hpp',
    'functor.hpp',
    'geom/fwd.hpp',
    'geom/aabb.cpp',
    'geom/aabb.hpp',
    'geom/cylinder.cpp',
    'geom/cylinder.hpp',
    'geom/ellipse.cpp',
    'geom/ellipse.hpp',
    'geom/frustum.cpp',
    'geom/frustum.hpp',
    'geom/iostream.cpp',
    'geom/iostream.hpp',
    'geom/line.hpp',
    'geom/line.cpp',
    'geom/ops.cpp',
    'geom/ops.hpp',
    'geom/plane.cpp',
    'geom/plane.hpp',
    'geom/ray.cpp',
    'geom/ray.hpp',
    'geom/rect.cpp',
    'geom/rect.hpp',
    'geom/sample/fwd.hpp',
    'geom/sample/surface.hpp',
    'geom/sample/volume.hpp',
    'geom/segment.cpp',
    'geom/segment.hpp',
    'geom/sphere.cpp',
    'geom/sphere.hpp',
    'geom/tri.cpp',
    'geom/tri.hpp',
    'hash.hpp',
    'hash/fwd.hpp',
    'hash/adler.cpp',
    'hash/adler.hpp',
    'hash/buzhash.hpp',
    'hash/bsdsum.cpp',
    'hash/bsdsum.hpp',
    'hash/crc.cpp',
    'hash/crc.hpp',
    'hash/fasthash.cpp',
    'hash/fasthash.hpp',
    'hash/fletcher.cpp',
    'hash/fletcher.hpp',
    'hash/fnv1a.cpp',
    'hash/fnv1a.hpp',
    'hash/murmur/common.cpp',
    'hash/murmur/common.hpp',
    'hash/murmur.hpp',
    'hash/murmur/murmur1.cpp',
    'hash/murmur/murmur1.hpp',
    'hash/murmur/murmur2.cpp',
    'hash/murmur/murmur2.hpp',
    'hash/murmur/murmur3.cpp',
    'hash/murmur/murmur3.hpp',
    'hash/siphash.cpp',
    'hash/siphash.hpp',
    'hash/table.cpp',
    'hash/table.hpp',
    'hash/wang.hpp',
    'hash/xxhash.cpp',
    'hash/xxhash.hpp',
    'introspection.cpp',
    'introspection.hpp',
    'io.cpp',
    'io.hpp',
    'iterator/constant.hpp',
    'iterator/counting.hpp',
    'iterator/dereference.hpp',
    'iterator/discard.hpp',
    'iterator/indices.hpp',
    'iterator/infix.hpp',
    'iterator/iota.hpp',
    'iterator/numeric.hpp',
    'iterator/referencing.hpp',
    'iterator/transform.hpp',
    'iterator/unequal.hpp',
    'iterator/zip.hpp',
    'job/fwd.hpp',
    'job/dispatch.hpp',
    'job/queue.cpp',
    'job/queue.hpp',
    'kmeans.hpp',
    'library.hpp',
    'log.cpp',
    'log.hpp',
    'map/fixed.cpp',
    'map/fixed.hpp',
    'maths.cpp',
    'maths.hpp',
    'maths/fast.hpp',
    'matrix.cpp',
    'matrix2.cpp',
    'matrix3.cpp',
    'matrix4.cpp',
    'matrix.hpp',
    'memory/deleter.cpp',
    'memory/deleter.hpp',
    'parallel/queue.cpp',
    'parallel/queue.hpp',
    'parallel/stack.cpp',
    'parallel/stack.hpp',
    'parse/fwd.hpp',
    'parse/enum.cpp',
    'parse/enum.hpp',
    'parse/time.cpp',
    'parse/time.hpp',
    'parse/value.cpp',
    'parse/value.hpp',
    'parse/si.cpp',
    'parse/si.hpp',
    'platform.hpp',
    'point.cpp',
    'point.hpp',
    'pointer.hpp',
    'polynomial.cpp',
    'polynomial.hpp',
    'pool.cpp',
    'pool.hpp',
    'quaternion.cpp',
    'quaternion.hpp',
    'rand/lcg.cpp',
    'rand/lcg.hpp',
    'rand/xorshift.cpp',
    'rand/xorshift.hpp',
    'rand/mwc64x.cpp',
    'rand/mwc64x.hpp',
    'rand/pcg.cpp',
    'rand/pcg.hpp',
    'rand/rdrand.cpp',
    'rand/rdrand.hpp',
    'rand/system.hpp',
    'random.cpp',
    'random.hpp',
    'range.cpp',
    'range.hpp',
    'rational.cpp',
    'rational.hpp',
    'region.cpp',
    'region.hpp',
    'registrar.cpp',
    'registrar.hpp',
    'roots/bisection.hpp',
    'scoped.hpp',
    'signal.cpp',
    'signal.hpp',
    'singleton.hpp',
    'stats.cpp',
    'stats.hpp',
    'std.hpp',
    'stream.cpp',
    'stream.hpp',
    'string.cpp',
    'string.hpp',
    'stringid.cpp',
    'stringid.hpp',
    'strongdef.cpp',
    'strongdef.hpp',
    'sysinfo.hpp',
    'tap.cpp',
    'tap.hpp',
    'term.cpp',
    'term.hpp',
    'thread/event.hpp',
    'thread/flag.hpp',
    'thread/monitor.cpp',
    'thread/monitor.hpp',
    'thread/ticketlock.cpp',
    'thread/ticketlock.hpp',
    'thread/spinlock.cpp',
    'thread/spinlock.hpp',
    'time.cpp',
    'time.hpp',
    'time/parse.hpp',
    'tuple/index.hpp',
    'tuple/type.hpp',
    'tuple/value.hpp',
    'typeidx.cpp',
    'typeidx.hpp',
    'types.hpp',
    'types/bits.hpp',
    'types/comparator.hpp',
    'types/description.cpp',
    'types/description.hpp',
    'types/dispatch.hpp',
    'types/string.cpp',
    'types/string.hpp',
    'types/tagged.hpp',
    'types/traits.hpp',
    'uri.hpp',
    'utf8.cpp',
    'utf8.hpp',
    'variadic.cpp',
    'variadic.hpp',
    'vector.cpp',
    'vector.hpp',
    'version.hpp',
    'view.cpp',
    'view.hpp',
]


if get_option('simd')
    sources += [
        'coord/simd.cpp',
        'coord/simd.hpp',
        'coord/simd_sse.hpp',
        'coord/simd_neon.hpp',
    ]
endif


#################################################################################
rt = cpp.find_library('rt', required: false)
if not cpp.has_function('shm_open', dependencies: [rt])
    error('Cannot find shm library')
endif
dependencies += rt

dl = cpp.find_library('dl', required: false)
if not cpp.has_function('dlopen', dependencies: dl)
    error ('Cannot find dl library')
endif
dependencies += dl

if not cpp.has_function('clock_gettime', dependencies: rt)
    error('Cannot find clock_gettime library')
endif

m = cpp.find_library('m', required: false)
if not cpp.has_function('cos', dependencies: m)
    error('Cannot find maths library')
endif
dependencies += m


libcruft = library('cruft', sources, dependencies: dependencies)
libcruft_dep = declare_dependency(
    include_directories: include_directories('.'),
    link_with: libcruft
)


#################################################################################
foreach tool: ['cpuid', 'poisson', 'macro', 'scratch']
    executable(tool, 'tools/@0@.cpp'.format(tool), link_with: libcruft)
endforeach


#################################################################################
tests = [
    'ascii',
    'algo/search',
    'algo/sort',
    'alloc/aligned/foreign',
    'alloc/aligned/direct',
    'alloc/easy',
    'alloc/linear',
    'alloc/stack',
    'affine',
    'array/darray',
    'array/sarray',
    'array/parray',
    'backtrace',
    'bezier',
    'bitwise',
    'buffer/simple',
    'cmdopt',
    'colour',
    'comparator',
    'coord',
    'encode/number',
    'encode/base',
    'endian',
    'exe',
    'expected',
    'extent',
    'fixed',
    'float',
    'format',
    'geom/aabb',
    'geom/ellipse',
    'geom/frustum',
    'geom/line',
    'geom/plane',
    'geom/ray',
    'geom/segment',
    'geom/sphere',
    'hash/buzhash',
    'hash/checksum',
    'hash/crc',
    'hash/fasthash',
    'hash/fnv1a',
    'hash/murmur',
    'hash/siphash',
    'hash/table',
    'hash/xxhash',
    'hton',
    'io',
    'introspection',
    'iterator',
    'job/dispatch',
    'job/queue',
    'kmeans',
    'map/fixed',
    'maths',
    'maths/fast',
    'matrix',
    'memory/deleter',
    'parallel/queue',
    'parallel/stack',
    'parse/enum',
    'parse/value',
    'parse/time',
    'parse/si',
    'point',
    'polynomial',
    'pool',
    'preprocessor',
    'quaternion',
    'rand/buckets',
    'random',
    'range',
    'rational',
    'region',
    'registrar',
    'roots/bisection',
    'scoped',
    'signal',
    'singleton',
    'stream',
    'string',
    'stringid',
    'strongdef',
    'thread/event',
    'thread/flag',
    'thread/monitor',
    'thread/semaphore',
    'thread/spinlock',
    'thread/ticketlock',
    'time/8601',
    'traits',
    'tuple/index',
    'tuple/value',
    'tuple/type',
    'typeidx',
    'types/description',
    'types/tagged',
    'uri',
    'utf8',
    'vector',
    'version',
    'view',
]


if host_machine.system() != 'windows'
    tests += [
        'buffer/circular',
        'buffer/paged',
    ]
endif


if get_option('simd')
    tests += [
        'coord/simd'
    ]
endif


foreach t: tests
    test(
        t.underscorify(),
        executable(
            'test_@0@'.format(t.underscorify()),
            'test/@0@.cpp'.format(t),
            link_with: libcruft,
            dependencies: dependencies
        ),
        protocol: 'tap'
    )
endforeach


##
##    configure_file (test/cpp.py.in util_test_cpp.py @ONLY)
##    add_test (NAME util_test_cpp COMMAND ${PYTHON_EXECUTABLE} util_test_cpp.py)
##    set_property (TEST util_test_cpp APPEND PROPERTY DEPENDS util_macro)
##    set_tests_properties(util_test_cpp PROPERTIES FAIL_REGULAR_EXPRESSION "not ok -")
##endif ()
##
##
#################################################################################
cmake_config = configuration_data()

pkg = import('pkgconfig')

pkg.generate(
    libraries: dependencies,
    version: meson.project_version(),
    name: meson.project_name(),
    filebase: 'cruft',
    description: 'A simple utility library for C++'
)


configure_file(
    input: 'Doxyfile.in',
    output: 'Doxyfile',
    configuration: {
        'CMAKE_PROJECT_NAME': meson.project_name(),
        'CMAKE_PROJECT_VERSION': meson.project_version(),
        'CMAKE_CURRENT_SOURCE_DIR': meson.current_source_dir(),
        'CMAKE_CURRENT_BINARY_DIR': meson.current_build_dir(),
    }
)