Pakkanen J. .The Meson Manual

Jussi Pakkanen, 2020. — 321 p.The Meson Manual is a full user manual for the Meson build system written by Jussi Pakkanen, the original creator and current project lead of Meson. Written in an informative and concise no-nonsense style, the text makes the material easily approachable even for people with little previous knowledge of build systems in general or Meson in particular. Plenty of practical examples are used to ensure that the information is readily usable on real-world projects.The book starts with the basics such as how compilers and linkers work, what is the difference between static and dynamic linking (both at compile time and runtime), and some differences between different toolchains and operating systems. This is followed by a thorough description of Meson's syntax, behavior, and functionality. A few bigger projects are examined to see how all of this can be applied to real-world projects. The second half of the book is a thorough reference manual of all Meson functionality, including sample code for almost every function, module, and method.Conventions are used in this book.
The user manual.
Getting started.
Obtaining Meson.
Creating the sample project.
Building from the command line.
Building with the Visual Studio IDE.
How compilation works.
Basic term definitions.
Building the Hello World application manually.
Basic symbol resolution.
Static linking.
Shared linking.
Linking multiple libraries.
Which is better, shared or static linking?
Dynamic linker and symbol resolution.
Meson syntax.
Original design principles.
Concrete design decisions.
Elementary types.
Build system phases.
Program flow.
Object types.
Disablers.
Building blocks of a software project.
The elementary operations.
Advanced build cases.
Generating data.
Defining the graph in Meson.
Splitting the project into multiple directories.
Target properties.
External dependencies.
What is dependency?
Finding and using dependencies.
Dependency provider backends.
Executable dependencies.
Dependencies that don't provide any dependency files.
Subprojects and internal dependencies.
Subproject basics and layout.
Using subprojects.
Internal dependencies.
Combining subprojects and internal dependencies.
Overriding executable lookup.
Configuring the project.
Simple approaches to configuration.
Configuration files.
Advanced configuration options.
Introspecting the system.
Printing status messages.
Testing.
Defining a test.
Test properties.
Advanced testing using the test tool.
Defining custom test setups.
Benchmarks.
Installing.
Directory layout.
Installing build targets.
Installing other files.
Running the install.
Custom install tasks.
Other things that happen during install.
Accessing data files before and after install.
Project options.
Builtin options.
Declaring and using project options.
Defining options.
Exploring and setting option values.
Sharing options between projects.
Custom build steps.
Generating data files.
Dependency files.
Special strings in command arguments.
Generating source code.
Generating source and headers.
Using generators.
Cross-compilation.
A word about nomenclature.
A practical example.
Other naming setups.
Cross-compilation with Meson.
Cross file lookup.
Multiple cross files.
Constants in cross files.
Native files.
Running tests when cross-compiling.
Cross compilation and code generators.
Firmware upload targets.
The Wrap dependency download mechanism.
The basic design.
Downloading revision control checkouts.
Downloading a release archive.
Using the WrapDB.
Converting an existing project to Meson.
Why change build systems? Is it even worth it?
Making sense of an existing build system.
Build tasks ordered by difficulty.
Conversions involving an entire team.
A library sample project.
Design requirements.
The external API.
Precompiled headers.
The C/C++ bridge.
Tests.
Project layout.
Creating releases.
Exercises for the reader.
Practical tips for real-world projects.
Use options rather than hardcoding compiler flags.
Shipping pre-generated files.
Do not treat files as strings.
Running Python scripts that use extension modules.
Move everything you can out of build files.
The reference documentation.
Elementary object reference.
array.
boolean.
dictionary.
disabler.
integer.
string.
Domain-specific object reference.
build_machine.
build_target.
compiler.
configuration data.
custom_target.
dependency.
environment.
external_library.
external_program.
generator.
host_machine.
meson.
python_installation.
run_result.
source_configuration.
source_set.
target_machine.
subproject.
Function reference.
add_global_arguments.
add_global_link_arguments.
add_languages.
add_project_arguments.
add_project_link_arguments.
add_test_setup.
alias_target.
assert.
benchmark.
both_libraries.
build_target.
configuration_data.
configure_file.
custom_target.
declare_dependency.
dependency.
disabler.
environment.
executable.
error.
find_program.
files.
generator.
get_option.
get_variable.
import.
include_directories.
install_data.
install_headers.
install_man.
install_subdir.
is_disabler.
is_variable.
jar.
join_paths.
library.
message.
run_command.
run_target.
set_variable.
shared_library.
shared_module.
static_library.
subdir.
subdir_done.
subproject.test.
vcs_tag.
Module reference.
cmake.
dlang.
fs (filesystem).
gnome.
hotdoc.
i18n.
pkgconfig.
python.
qt5.
qt4.
rpm.
sourceset.
windows.
III The appendixes.
Contributing to Meson.
Checking out the code.
Creating the merge request.
Review and continuous integration.
Fixing merge conflicts.
Documentation updates.