The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
88 lines
3.0 KiB
88 lines
3.0 KiB
--- |
|
short-description: Definition of build targets |
|
... |
|
|
|
# Build targets |
|
|
|
Meson provides three kinds of build targets: executables, static |
|
libraries and shared libraries. They are created with the commands |
|
`executable`, `static_library` and `shared_library`, respectively. All |
|
objects created in this way are **immutable**. That is, you can not |
|
change any aspect of them after they have been constructed. This |
|
ensures that all information pertaining to a given build target is |
|
specified in one well defined place. |
|
|
|
As an example, here is how you would build a shared library. |
|
|
|
```meson |
|
project('shared lib', 'c') |
|
shared_library('mylib', 'source.c') |
|
``` |
|
|
|
In Unix-like operating systems, shared libraries can be |
|
versioned. Meson supports this with keyword arguments. |
|
|
|
```meson |
|
project('shared lib', 'c') |
|
shared_library('mylib', 'source.c', version : '1.2.3', soversion : '0') |
|
``` |
|
|
|
It is common to build a library and then an executable that links |
|
against it. This is supported as well. |
|
|
|
```meson |
|
project('shared lib', 'c') |
|
lib = shared_library('mylib', 'source.c') |
|
executable('program', 'prog.c', link_with : lib) |
|
``` |
|
|
|
Meson sets things up so that the resulting executable can be run |
|
directly from the build directory. There is no need to write shell |
|
scripts or set environment variables. |
|
|
|
One target can have multiple language source files. |
|
|
|
```meson |
|
project('multilang', 'c', 'cpp') |
|
executable('multiexe', 'file.c', 'file2.cc') |
|
``` |
|
|
|
Object files |
|
-- |
|
|
|
Sometimes you can't build files from sources but need to utilize an |
|
existing object file. A typical case is using an object file provided |
|
by a third party. Object files can be specified just like sources. |
|
|
|
```meson |
|
exe = executable('myexe', 'source.cpp', objects : 'third_party_object.o') |
|
``` |
|
|
|
A different case is when you want to use object files built in one |
|
target directly in another. A typical case is when you build a shared |
|
library and it has an internal class that is not exported in the |
|
ABI. This means you can't access it even if you link against the |
|
library. Typical workarounds for this include building both a shared |
|
and static version of the library or putting the source file in the |
|
test executable's source list. Both of these approaches cause the |
|
source to be built twice, which is slow. |
|
|
|
In Meson you can extract object files from targets and use them as-is |
|
on other targets. This is the syntax for it. |
|
|
|
```meson |
|
lib = shared_library('somelib', 'internalclass.cc', 'file.cc', ...) |
|
eo = lib.extract_objects('internalclass.cc') |
|
executable('classtest', 'classtest.cpp', objects : eo) |
|
``` |
|
|
|
Here we take the internal class object and use it directly in the |
|
test. The source file is only compiled once. |
|
|
|
Note that careless use of this feature may cause strange bugs. As an |
|
example trying to use objects of an executable or static library in a |
|
shared library will not work because shared library objects require |
|
special compiler flags. Getting this right is the user's |
|
responsibility. For this reason it is strongly recommended that you |
|
only use this feature for generating unit test executables in the |
|
manner described above.
|
|
|