build: add meson build system

Meson is easier to maintain, much faster, encourages better practices,
and is not built on a pile of shell scripts.

The autotools build system is kept intact for now, in order to ease the
migration. The intention is to remove it sooner rather than later, if
all goes well.

Run `meson build && mesonconf build` to see the configuration options
for the new system. Conversion should be straightforward. Environment
variables like CFLAGS work the same.

If meson is used, xorg-util-macros is not required.

In terms of functionality the two systems have about the same
capabilities. Here are some differences I noticed:

- Meson uses `-g` by default, autotools uses `-g -O2`.

- In autotools the default behavior is to install both static and shared
  versions of the libraries. In meson the user must choose exactly one
  (using -Ddefault_library=static/shared).

  It is possible to workaround if needed (install twice...), but
  hopefully meson will add the option in the future.

- Autotools has builtin ctags/cscope targets, meson doesn't.

  Easy to run the tools directly.

- Meson has builtin benchmarks target. Handy.

- Meson has builtin support for sanitizers/clang-analyzer/lto/pgo/
  coverage etc. Also handy.

Signed-off-by: Ran Benita <ran234@gmail.com>
master
Ran Benita 2017-07-25 21:57:42 +03:00
parent 75ec764cee
commit 86434d8498
6 changed files with 564 additions and 21 deletions

1
.gitignore vendored
View File

@ -84,3 +84,4 @@ test-driver
build-aux/
/xdg-shell-unstable-v6-client-protocol.h
/xdg-shell-unstable-v6-protocol.c
build/

View File

@ -4,11 +4,14 @@ language: c
before_install:
- sudo apt-get update -qq
- sudo apt-get -y install xutils-dev doxygen libxcb-xkb-dev
- sudo apt-get -y install xutils-dev doxygen libxcb-xkb-dev python3-pip
- wget https://github.com/ninja-build/ninja/releases/download/v1.7.2/ninja-linux.zip && unzip ninja-linux.zip && sudo install ninja /usr/bin/
- sudo pip3 install meson
compiler:
- gcc
- clang
script:
- mkdir autotools-build && cd autotools-build && ../autogen.sh && make && make check
- mkdir autotools-build && pushd autotools-build && ../autogen.sh && make && make check && popd
- meson meson-build -Denable-wayland=false && pushd meson-build && ninja && ninja test && popd

View File

@ -5,22 +5,18 @@ The files for libxkbcommon-x11 are:
libxkbcommon-x11.a libxkbcommon-x11.so* xkbcommon/xkbcommon-x11.h
xkbcommon-x11.map xkbcommon-x11.pc
libxkbcommon-x11 can be disabled with --disable-x11 (see
`./configure --help` for other options/variables).
libxkbcommon-x11 can be disabled with -Denable-x11=false (see
`mesonconf build` for other options/variables).
Dependencies for libxkbcommon:
- C compiler, autoconf, automake, pkg-config, libc, etc.
- C compiler, meson, pkg-config, libc, bash, grep, sed.
- (build optional) xorg-util-macros.
Output included in tarball.
- (build optional) bison (preferred) or byacc>=20141006.
Output included in tarball.
- (build) bison (preferred) or byacc>=20141006.
byacc must be configured with --enable-btyacc.
- (build optional, runtime) xkeyboard-config.
During build, for automatically detecting the value of
--with-xkb-config-root instead of guessing (/usr/share/X11/xkb).
-Dxkb-config-root instead of guessing (/usr/share/X11/xkb).
During runtime, not strictly needed, but most users of the library
would need it.
@ -30,6 +26,7 @@ Dependencies for libxkbcommon:
- (build optional) doxygen.
For generating the HTML documentation.
To disable, use -Denable-docs=false.
- (build optional) gperf.
Output included in git and tarball. To regenerate, use
@ -45,9 +42,8 @@ Dependencies for libxkbcommon-x11 tests:
If they are not available, the relevant tests are skipped.
Dependencies for Wayland tests:
- wayland-client>=1.2.0, wayland-scanner, wayland-protocols>=1.0
If they are not available, the relevant example/utility program is
skipped.
- wayland-client>=1.2.0, wayland-scanner, wayland-protocols>=1.0.
To disable, use -Denable-wayland=false.
Unless libxcb is always available as part of the system, it is preferred
that libxkbcommon and libxkbcommon-x11 be split into separate packages,

View File

@ -11,18 +11,19 @@ See [Quick Guide](doc/quick-guide.md).
## Building
libxkbcommon is built the typical autoconf way:
libxkbcommon is built with [Meson](http://mesonbuild.com/):
./autogen.sh
make
meson build
ninja -C build
To build for use with Wayland, you can disable X11 support while still
using the X11 keyboard configuration resource files thusly:
./autogen.sh --disable-x11 \
--with-xkb-config-root=/usr/share/X11/xkb \
--with-x-locale-root=/usr/share/X11/locale
make
meson build \
-Denable-x11=false \
-Dxkb-config-root=/usr/share/X11/xkb \
-Dx-locale-root=/usr/share/X11/locale
ninja -C build
## API

484
meson.build Normal file
View File

@ -0,0 +1,484 @@
project(
'libxkbcommon',
'c',
version: '0.7.1',
default_options: [
'c_std=c99',
'warning_level=2',
'b_lundef=true',
],
)
pkgconfig = import('pkgconfig')
cc = meson.get_compiler('c')
# Compiler flags.
foreach cflag: [
'-fvisibility=hidden',
'-Wextra',
'-Wno-unused-parameter',
'-Wno-missing-field-initializers',
'-Wpointer-arith',
'-Wmissing-declarations',
'-Wformat=2',
'-Wstrict-prototypes',
'-Wmissing-prototypes',
'-Wnested-externs',
'-Wbad-function-cast',
'-Wshadow',
'-Wlogical-op',
'-Wdate-time',
'-Wwrite-strings',
]
if cc.has_argument(cflag)
add_project_arguments(cflag, language: 'c')
endif
endforeach
# The XKB config root.
XKBCONFIGROOT = get_option('xkb-config-root')
if XKBCONFIGROOT == ''
xkeyboard_config_dep = dependency('xkeyboard-config', required: false)
if xkeyboard_config_dep.found()
XKBCONFIGROOT = xkeyboard_config_dep.get_pkgconfig_variable('xkb_base')
else
XKBCONFIGROOT = join_paths(get_option('prefix'), get_option('datadir'), 'X11', 'xkb')
endif
endif
# The X locale directory for compose.
XLOCALEDIR = get_option('x-locale-root')
if XLOCALEDIR == ''
XLOCALEDIR = join_paths(get_option('prefix'), get_option('datadir'), 'X11', 'locale')
endif
# config.h.
configh_data = configuration_data()
configh_data.set('_GNU_SOURCE', 1)
configh_data.set_quoted('DFLT_XKB_CONFIG_ROOT', XKBCONFIGROOT)
configh_data.set_quoted('XLOCALEDIR', XLOCALEDIR)
configh_data.set_quoted('DEFAULT_XKB_RULES', get_option('default-rules'))
configh_data.set_quoted('DEFAULT_XKB_MODEL', get_option('default-model'))
configh_data.set_quoted('DEFAULT_XKB_LAYOUT', get_option('default-layout'))
if get_option('default-variant') != ''
configh_data.set_quoted('DEFAULT_XKB_VARIANT', get_option('default-variant'))
endif
if get_option('default-options') != ''
configh_data.set_quoted('DEFAULT_XKB_OPTIONS', get_option('default-options'))
endif
if cc.links('int main(){if(__builtin_expect(1<0,0)){}}', name: '__builtin_expect')
configh_data.set('HAVE___BUILTIN_EXPECT', 1)
endif
if cc.links('int main(){__builtin_popcount(1);}', name: '__builtin_popcount')
configh_data.set('HAVE___BUILTIN_POPCOUNT', 1)
endif
if cc.has_header_symbol('unistd.h', 'eaccess', prefix: '#define _GNU_SOURCE')
configh_data.set('HAVE_EACCESS', 1)
endif
if cc.has_header_symbol('unistd.h', 'euidaccess', prefix: '#define _GNU_SOURCE')
configh_data.set('HAVE_EUIDACCESS', 1)
endif
if cc.has_header_symbol('sys/mman.h', 'mmap')
configh_data.set('HAVE_MMAP', 1)
endif
if cc.has_header_symbol('stdlib.h', 'secure_getenv', prefix: '#define _GNU_SOURCE')
configh_data.set('HAVE_SECURE_GETENV', 1)
elif cc.has_header_symbol('stdlib.h', '__secure_getenv', prefix: '#define _GNU_SOURCE')
configh_data.set('HAVE___SECURE_GETENV', 1)
else
message('C library does not support secure_getenv, using getenv instead')
endif
configure_file(output: 'config.h', configuration: configh_data)
add_project_arguments('-include', 'config.h', language: 'c')
# Supports -Wl,--version-script?
have_version_script = cc.links(
'int main(){}',
link_args: '-Wl,--version-script=' + join_paths(meson.source_root(), 'xkbcommon.map'),
name: '-Wl,--version-script',
)
# libxkbcommon.
# Note: we use some yacc extensions, which work with either GNU bison
# (preferred) or byacc. Other yacc's may or may not work.
yacc = find_program('bison', 'byacc')
yacc_gen = generator(
yacc,
output: ['@BASENAME@.c', '@BASENAME@.h'],
arguments: ['@INPUT@', '--defines=@OUTPUT1@', '--output=@OUTPUT0@', '-p _xkbcommon_'],
)
libxkbcommon_internal = static_library(
'xkbcommon-internal',
'src/compose/parser.c',
'src/compose/parser.h',
'src/compose/paths.c',
'src/compose/paths.h',
'src/compose/state.c',
'src/compose/table.c',
'src/compose/table.h',
'src/xkbcomp/action.c',
'src/xkbcomp/action.h',
'src/xkbcomp/ast.h',
'src/xkbcomp/ast-build.c',
'src/xkbcomp/ast-build.h',
'src/xkbcomp/compat.c',
'src/xkbcomp/expr.c',
'src/xkbcomp/expr.h',
'src/xkbcomp/include.c',
'src/xkbcomp/include.h',
'src/xkbcomp/keycodes.c',
'src/xkbcomp/keymap.c',
'src/xkbcomp/keymap-dump.c',
'src/xkbcomp/keywords.c',
yacc_gen.process('src/xkbcomp/parser.y'),
'src/xkbcomp/parser-priv.h',
'src/xkbcomp/rules.c',
'src/xkbcomp/rules.h',
'src/xkbcomp/scanner.c',
'src/xkbcomp/symbols.c',
'src/xkbcomp/types.c',
'src/xkbcomp/vmod.c',
'src/xkbcomp/vmod.h',
'src/xkbcomp/xkbcomp.c',
'src/xkbcomp/xkbcomp-priv.h',
'src/atom.c',
'src/atom.h',
'src/context.c',
'src/context.h',
'src/context-priv.c',
'src/darray.h',
'src/keysym.c',
'src/keysym.h',
'src/keysym-utf.c',
'src/ks_tables.h',
'src/keymap.c',
'src/keymap.h',
'src/keymap-priv.c',
'src/scanner-utils.h',
'src/state.c',
'src/text.c',
'src/text.h',
'src/utf8.c',
'src/utf8.h',
'src/utils.c',
'src/utils.h',
include_directories: include_directories('src'),
)
libxkbcommon_link_args = []
if have_version_script
libxkbcommon_link_args += '-Wl,--version-script=' + join_paths(meson.source_root(), 'xkbcommon.map')
endif
libxkbcommon = library(
'xkbcommon',
'xkbcommon/xkbcommon.h',
link_whole: libxkbcommon_internal,
link_args: libxkbcommon_link_args,
link_depends: 'xkbcommon.map',
version: '0.0.0',
install: true,
)
install_headers(
'xkbcommon/xkbcommon.h',
'xkbcommon/xkbcommon-compat.h',
'xkbcommon/xkbcommon-compose.h',
'xkbcommon/xkbcommon-keysyms.h',
'xkbcommon/xkbcommon-names.h',
subdir: 'xkbcommon',
)
pkgconfig.generate(
name: 'xkbcommon',
filebase: 'xkbcommon',
libraries: libxkbcommon,
version: meson.project_version(),
description: 'XKB API common to servers and clients',
)
# libxkbcommon-x11.
if get_option('enable-x11')
xcb_dep = dependency('xcb', version: '>=1.10', required: false)
xcb_xkb_dep = dependency('xcb-xkb', version: '>=1.10', required: false)
if not xcb_dep.found() or not xcb_xkb_dep.found()
error('''X11 support requires xcb-xkb >= 1.10 which was not found.
You can disable X11 support with -Denable-x11=false.''')
endif
libxkbcommon_x11_internal = static_library(
'xkbcommon-x11-internal',
'src/x11/keymap.c',
'src/x11/state.c',
'src/x11/util.c',
'src/x11/x11-priv.h',
'src/context.h',
'src/context-priv.c',
'src/keymap.h',
'src/keymap-priv.c',
'src/atom.h',
'src/atom.c',
include_directories: include_directories('src'),
link_with: libxkbcommon,
dependencies: [
xcb_dep,
xcb_xkb_dep,
],
)
libxkbcommon_x11_link_args = []
if have_version_script
libxkbcommon_x11_link_args += '-Wl,--version-script=' + join_paths(meson.source_root(), 'xkbcommon-x11.map')
endif
libxkbcommon_x11 = library(
'xkbcommon-x11',
'xkbcommon/xkbcommon-x11.h',
link_whole: libxkbcommon_x11_internal,
link_args: libxkbcommon_x11_link_args,
link_depends: 'xkbcommon-x11.map',
version: '0.0.0',
install: true,
)
install_headers(
'xkbcommon/xkbcommon-x11.h',
subdir: 'xkbcommon',
)
pkgconfig.generate(
name: 'xkbcommon-x11',
filebase: 'xkbcommon-x11',
libraries: libxkbcommon_x11,
version: meson.project_version(),
description: 'XKB API common to servers and clients - X11 support',
)
endif
# Tests
test_env = environment()
test_env.set('XKB_LOG_LEVEL', 'debug')
test_env.set('XKB_LOG_VERBOSITY', '10')
test_env.set('top_srcdir', meson.source_root())
test_env.set('MALLOC_PERTURB_', '15')
test_env.set('MallocPreScribble', '1')
test_env.set('MallocScribble', '1')
# Some tests need to use unexported symbols, so we link them against
# the internal copy of libxkbcommon with all symbols exposed.
libxkbcommon_test_internal = static_library(
'xkbcommon-test-internal',
'test/common.c',
'test/test.h',
'test/evdev-scancodes.h',
include_directories: include_directories('src'),
link_with: libxkbcommon_internal,
)
test_dep = declare_dependency(
include_directories: include_directories('src'),
link_with: libxkbcommon_test_internal,
)
test(
'keysym',
executable('test-keysym', 'test/keysym.c', dependencies: test_dep),
env: test_env,
)
test(
'keymap',
executable('test-keymap', 'test/keymap.c', dependencies: test_dep),
env: test_env,
)
test(
'filecomp',
executable('test-filecomp', 'test/filecomp.c', dependencies: test_dep),
env: test_env,
)
test(
'context',
executable('test-context', 'test/context.c', dependencies: test_dep),
env: test_env,
)
test(
'rules-file',
executable('test-rules-file', 'test/rules-file.c', dependencies: test_dep),
env: test_env,
)
test(
'stringcomp',
executable('test-stringcomp', 'test/stringcomp.c', dependencies: test_dep),
env: test_env,
)
test(
'buffercomp',
executable('test-buffercomp', 'test/buffercomp.c', dependencies: test_dep),
env: test_env,
)
test(
'log',
executable('test-log', 'test/log.c', dependencies: test_dep),
env: test_env,
)
test(
'atom',
executable('test-atom', 'test/atom.c', dependencies: test_dep),
env: test_env,
)
test(
'utf8',
executable('test-utf8', 'test/utf8.c', dependencies: test_dep),
env: test_env,
)
test(
'state',
executable('test-state', 'test/state.c', dependencies: test_dep),
env: test_env,
)
test(
'keyseq',
executable('test-keyseq', 'test/keyseq.c', dependencies: test_dep),
env: test_env,
)
test(
'rulescomp',
executable('test-rulescomp', 'test/rulescomp.c', dependencies: test_dep),
env: test_env,
)
test(
'compose',
executable('test-compose', 'test/compose.c', dependencies: test_dep),
env: test_env,
)
test(
'symbols-leak-test',
find_program('test/symbols-leak-test.bash'),
env: test_env,
)
if get_option('enable-x11')
test(
'x11',
executable('test-x11', 'test/x11.c', dependencies: test_dep, link_with: libxkbcommon_x11_internal),
env: test_env,
)
# test/x11comp is meant to be run, but it is (temporarily?) disabled.
# See: https://github.com/xkbcommon/libxkbcommon/issues/30
executable('test-x11comp', 'test/x11comp.c', dependencies: test_dep, link_with: libxkbcommon_x11_internal)
endif
# Demo programs.
executable('rmlvo-to-kccgst', 'test/rmlvo-to-kccgst.c', dependencies: test_dep)
executable('print-compiled-keymap', 'test/print-compiled-keymap.c', dependencies: test_dep)
if cc.has_header('linux/input.h')
executable('interactive-evdev', 'test/interactive-evdev.c', dependencies: test_dep)
endif
if get_option('enable-x11')
executable('interactive-x11', 'test/interactive-x11.c', dependencies: test_dep, link_with: libxkbcommon_x11_internal)
endif
if get_option('enable-wayland')
wayland_client_dep = dependency('wayland-client', version: '>=1.2.0', required: false)
wayland_protocols_dep = dependency('wayland-protocols', version: '>=1.7', required: false)
wayland_scanner_dep = dependency('wayland-scanner', required: false)
if not wayland_client_dep.found() or not wayland_protocols_dep.found() or not wayland_scanner_dep.found()
error('''The Wayland demo programs require wayland-client >= 1.2.0, wayland-protocols >= 1.7 which were not found.
You can disable the Wayland demo programs with -Denable-wayland=false.''')
endif
wayland_scanner = find_program(wayland_scanner_dep.get_pkgconfig_variable('wayland_scanner'))
wayland_scanner_code_gen = generator(
wayland_scanner,
output: '@BASENAME@-protocol.c',
arguments: ['code', '@INPUT@', '@OUTPUT@'],
)
wayland_scanner_client_header_gen = generator(
wayland_scanner,
output: '@BASENAME@-client-protocol.h',
arguments: ['client-header', '@INPUT@', '@OUTPUT@'],
)
wayland_protocols_datadir = wayland_protocols_dep.get_pkgconfig_variable('pkgdatadir')
xdg_shell_xml = join_paths(wayland_protocols_datadir, 'unstable/xdg-shell/xdg-shell-unstable-v6.xml')
xdg_shell_sources = [
wayland_scanner_code_gen.process(xdg_shell_xml),
wayland_scanner_client_header_gen.process(xdg_shell_xml),
]
executable('interactive-wayland', 'test/interactive-wayland.c', xdg_shell_sources, dependencies: [test_dep, wayland_client_dep])
endif
# Benchmarks.
# For clock_gettime, on some systems.
rt_dep = cc.find_library('rt', required: false)
libxkbcommon_bench_internal = static_library(
'xkbcommon-bench-internal',
'bench/bench.c',
'bench/bench.h',
dependencies: rt_dep,
link_with: libxkbcommon_test_internal,
)
bench_dep = declare_dependency(
include_directories: include_directories('src'),
link_with: libxkbcommon_bench_internal,
)
bench_env = environment()
bench_env.set('top_srcdir', meson.source_root())
benchmark(
'key-proc',
executable('bench-key-proc', 'bench/key-proc.c', dependencies: bench_dep),
env: bench_env,
)
benchmark(
'rules',
executable('bench-rules', 'bench/rules.c', dependencies: bench_dep),
env: bench_env,
)
benchmark(
'rulescomp',
executable('bench-rulescomp', 'bench/rulescomp.c', dependencies: bench_dep),
env: bench_env,
)
benchmark(
'compose',
executable('bench-compose', 'bench/compose.c', dependencies: bench_dep),
env: bench_env,
)
# Documentation.
if get_option('enable-docs')
doxygen = find_program('doxygen', required: false)
if not doxygen.found()
error('''Documentation requires doxygen which was not found.
You can disable the documentation with -Denable-docs=false.''')
endif
doxygen_input = [
join_paths(meson.source_root(), 'README.md'),
join_paths(meson.source_root(), 'doc/doxygen-extra.css'),
join_paths(meson.source_root(), 'doc/quick-guide.md'),
join_paths(meson.source_root(), 'doc/compat.md'),
join_paths(meson.source_root(), 'xkbcommon/xkbcommon.h'),
join_paths(meson.source_root(), 'xkbcommon/xkbcommon-names.h'),
join_paths(meson.source_root(), 'xkbcommon/xkbcommon-x11.h'),
join_paths(meson.source_root(), 'xkbcommon/xkbcommon-compose.h'),
]
doxygen_data = configuration_data()
doxygen_data.set('PACKAGE_NAME', meson.project_name())
doxygen_data.set('PACKAGE_VERSION', meson.project_version())
doxygen_data.set('INPUT', ' '.join(doxygen_input))
doxygen_data.set('abs_top_srcdir', meson.source_root())
doxyfile = configure_file(
input: 'doc/Doxyfile.in',
output: 'Doxyfile',
configuration: doxygen_data,
install: false,
)
# TODO: Meson should provide this.
docdir = join_paths(get_option('datadir'), 'doc', meson.project_name())
# TODO: Relative links in README.md fail.
custom_target(
'doc',
input: [doxyfile] + doxygen_input,
output: 'html',
command: [doxygen, doxyfile],
install: true,
install_dir: docdir,
build_by_default: true,
)
endif

58
meson_options.txt Normal file
View File

@ -0,0 +1,58 @@
option(
'xkb-config-root',
type: 'string',
description: 'The XKB config root [default=xkeyboard-config install path]',
)
option(
'x-locale-root',
type: 'string',
description: 'The X locale root [default=$datadir/X11/locale]',
)
option(
'default-rules',
type: 'string',
value: 'evdev',
description: 'Default XKB ruleset',
)
option(
'default-model',
type: 'string',
value: 'pc105',
description: 'Default XKB model',
)
option(
'default-layout',
type: 'string',
value: 'us',
description: 'Default XKB layout',
)
option(
'default-variant',
type: 'string',
value: '',
description: 'Default XKB variant',
)
option(
'default-options',
type: 'string',
value: '',
description: 'Default XKB options',
)
option(
'enable-x11',
type: 'boolean',
value: true,
description: 'Enable building the xkbcommon-x11 library',
)
option(
'enable-docs',
type: 'boolean',
value: true,
description: 'Enable building the documentation',
)
option(
'enable-wayland',
type: 'boolean',
value: true,
description: 'Enable support for Wayland utility programs',
)