Abhängigkeiten

Nur wenige Anwendungen sind vollständig eigenständig, sondern nutzen externe Bibliotheken und Frameworks für ihre Arbeit. Meson macht es sehr einfach, externe Abhängigkeiten zu finden und zu nutzen. Hier ist, wie man die zlib-Kompressionsbibliothek verwenden würde.

zdep = dependency('zlib', version : '>=1.2.8')
exe = executable('zlibprog', 'prog.c', dependencies : zdep)

Zuerst wird Meson angewiesen, die externe Bibliothek zlib zu finden und einen Fehler auszugeben, wenn sie nicht gefunden wird. Das Schlüsselwort version ist optional und gibt eine Versionsanforderung für die Abhängigkeit an. Dann wird eine ausführbare Datei unter Verwendung der angegebenen Abhängigkeit erstellt. Beachten Sie, wie der Benutzer keine Compiler- oder Linker-Flags manuell behandeln oder sich mit anderen Kleinigkeiten befassen muss.

Wenn Sie mehrere Abhängigkeiten haben, übergeben Sie diese als Array

executable('manydeps', 'file.c', dependencies : [dep1, dep2, dep3, dep4])

Wenn die Abhängigkeit optional ist, können Sie Meson anweisen, keinen Fehler auszugeben, wenn die Abhängigkeit nicht gefunden wird, und dann weitere Konfigurationen vorzunehmen.

opt_dep = dependency('somedep', required : false)
if opt_dep.found()
  # Do something.
else
  # Do something else.
endif

Sie können die Variable opt_dep an Zielfunktionen übergeben, unabhängig davon, ob die tatsächliche Abhängigkeit gefunden wurde oder nicht. Meson ignoriert nicht gefundene Abhängigkeiten.

Meson erlaubt es auch, Variablen abzurufen, die in einer pkg-config-Datei definiert sind. Dies kann durch die Verwendung der Funktion dep.get_pkgconfig_variable() erfolgen.

zdep_prefix = zdep.get_pkgconfig_variable('prefix')

Diese Variablen können auch durch Übergabe des Parameters define_variable neu definiert werden, was in bestimmten Situationen nützlich sein kann.

zdep_prefix = zdep.get_pkgconfig_variable('libdir', define_variable: ['prefix', '/tmp'])

Der Abhängigkeitsdetektor funktioniert mit allen Bibliotheken, die eine pkg-config-Datei bereitstellen. Leider stellen viele Pakete keine pkg-config-Dateien bereit. Meson hat Unterstützung für die automatische Erkennung für einige davon, und diese werden weiter unten auf dieser Seite beschrieben.

Beliebige Variablen von Abhängigkeiten, die auf verschiedene Weise gefunden werden können

Hinweis neu in 0.51.0 neu in 0.54.0, das Schlüsselwort internal

Wenn Sie eine beliebige Variable von einer Abhängigkeit abrufen müssen, die auf verschiedene Weise gefunden werden kann und Sie den Typ nicht einschränken möchten, können Sie die generische Methode get_variable verwenden. Dies unterstützt derzeit Variablen, die auf cmake, pkg-config und config-tool basieren.

foo_dep = dependency('foo')
var = foo_dep.get_variable(cmake : 'CMAKE_VAR', pkgconfig : 'pkg-config-var', configtool : 'get-var', default_value : 'default')

Sie akzeptiert die Schlüsselwörter 'cmake', 'pkgconfig', 'pkgconfig_define', 'configtool', 'internal', 'system' und 'default_value'. 'pkgconfig_define' funktioniert genauso wie das Argument 'define_variable' von get_pkgconfig_variable. Wenn diese Methode aufgerufen wird, wird das Schlüsselwort, das dem zugrunde liegenden Typ der Abhängigkeit entspricht, zum Suchen einer Variablen verwendet. Wenn diese Variable nicht gefunden werden kann oder wenn der Aufrufer kein Argument für den Abhängigkeitstyp bereitstellt, tritt eines der folgenden Ereignisse ein: Wenn 'default_value' bereitgestellt wurde, wird dieser Wert zurückgegeben, wenn 'default_value' nicht bereitgestellt wurde, wird ein Fehler ausgelöst.

Abhängigkeiten, die Ressourcendateien bereitstellen

Manchmal stellt eine Abhängigkeit installierbare Dateien bereit, die andere Projekte dann verwenden müssen. Zum Beispiel Wayland-Protokolle XML-Dateien.

foo_dep = dependency('foo')
foo_datadir = foo_dep.get_variable('pkgdatadir')
custom_target(
    'foo-generated.c',
    input: foo_datadir / 'prototype.xml',
    output: 'foo-generated.c',
    command: [generator, '@INPUT@', '@OUTPUT@']
)

Seit 0.63.0 funktionieren diese tatsächlich wie erwartet, auch wenn sie von einer (wohlgeformten) internen Abhängigkeit stammen. Dies funktioniert nur, wenn die zu beziehenden Dateien mit einer Systemabhängigkeit austauschbar behandelt werden – d.h. es dürfen nur öffentliche Dateien verwendet werden, und das Verlassen des Verzeichnisses, auf das von der Abhängigkeit verwiesen wird, ist nicht gestattet.

Eigene deklarieren

Sie können eigene Abhängigkeitsobjekte deklarieren, die austauschbar mit Abhängigkeitsobjekten verwendet werden können, die vom System bezogen wurden. Die Syntax ist unkompliziert

my_inc = include_directories(...)
my_lib = static_library(...)
my_dep = declare_dependency(link_with : my_lib,
  include_directories : my_inc)

Dies deklariert eine Abhängigkeit, die die angegebenen Include-Verzeichnisse und die statische Bibliothek zu jedem Ziel hinzufügt, in dem Sie sie verwenden.

Abhängigkeiten als Subprojekte bauen

Viele Plattformen bieten keinen System-Paketmanager. Auf diesen Systemen müssen Abhängigkeiten aus dem Quellcode kompiliert werden. Mesons Subprojekte vereinfachen die Verwendung von Systemabhängigkeiten, wenn diese verfügbar sind, und das manuelle Bauen von Abhängigkeiten, wenn sie nicht verfügbar sind.

Damit dies funktioniert, muss die Abhängigkeit Meson-Build-Definitionen haben und ihre eigene Abhängigkeit wie folgt deklarieren:

    foo_dep = declare_dependency(...)

Dann kann jedes Projekt, das sie verwenden möchte, die folgende Deklaration in seiner Hauptdatei meson.build schreiben.

    foo_dep = dependency('foo', fallback : ['foo', 'foo_dep'])

Diese Deklaration bedeutet, dass Meson zuerst versucht, die Abhängigkeit vom System zu suchen (z. B. mithilfe von pkg-config). Wenn sie nicht verfügbar ist, baut es das Subprojekt namens foo und extrahiert daraus eine Variable foo_dep. Das bedeutet, dass der Rückgabewert dieser Funktion entweder ein externes oder ein internes Abhängigkeitsobjekt ist. Da sie austauschbar verwendet werden können, müssen sich die restlichen Build-Definitionen nicht darum kümmern, welche es ist. Meson kümmert sich hinter den Kulissen um die gesamte Arbeit, damit dies funktioniert.

Abhängigkeitserkennungsmethode

Sie können das Schlüsselwort method verwenden, um Meson mitzuteilen, welche Methode bei der Suche nach der Abhängigkeit verwendet werden soll. Der Standardwert ist auto. Zusätzliche Methoden sind pkg-config, config-tool, cmake, builtin, system, sysconfig, qmake, extraframework und dub.

cups_dep = dependency('cups', method : 'pkg-config')

Für Abhängigkeiten ohne spezifische Erkennungslogik ist die Reihenfolge der Abhängigkeitsmethoden für auto:

  1. pkg-config
  2. cmake
  3. extraframework (nur OSX)

System

Einige Abhängigkeiten bieten keine gültigen Methoden zur Erkennung oder tun dies nur in einigen Fällen. Beispiele hierfür sind Zlib, das sowohl pkg-config als auch cmake bietet, außer wenn es Teil des Basis-Betriebssystem-Images ist (wie unter FreeBSD und macOS); OpenGL, das auf Unices von glvnd oder mesa pkg-config hat, aber kein pkg-config auf macOS und Windows hat.

In diesen Fällen bietet Meson praktische Wrapper in Form von system-Abhängigkeiten. Intern tun diese Abhängigkeiten genau das, was ein Benutzer im Build-System-DSL oder mit einem Skript tun würde, wahrscheinlich durch Aufrufen von compiler.find_library(), Setzen von link_with und include_directories. Indem diese in Meson Upstream aufgenommen werden, wird die Hürde für deren Verwendung gesenkt, da Projekte, die Meson verwenden, die Logik nicht neu implementieren müssen.

Builtin

Einige Abhängigkeiten bieten auf einigen Systemen keine gültigen Erkennungsmethoden, da sie intern von der Sprache bereitgestellt werden. Ein Beispiel hierfür ist intl, das in GNU- oder musl-libc integriert ist, aber ansonsten als system-Abhängigkeit geliefert wird.

In diesen Fällen bietet Meson praktische Wrapper für die system-Abhängigkeit, prüft aber zuerst, ob die Funktionalität standardmäßig nutzbar ist.

CMake

Meson kann die CMake-Funktion find_package() verwenden, um Abhängigkeiten mit den integrierten Modulen Find<NAME>.cmake und exportierten Projektkonfigurationen (normalerweise in /usr/lib/cmake) zu erkennen. Meson kann sowohl die alten Variablen <NAME>_LIBRARIES als auch importierte Ziele verwenden.

Es ist möglich, manuell eine Liste von CMake-Zielen anzugeben, die mit der Eigenschaft modules verwendet werden sollen. Dieser Schritt ist jedoch optional, da Meson versucht, das richtige Ziel automatisch anhand des Namens der Abhängigkeit zu erraten.

Je nach Abhängigkeit kann es notwendig sein, ein CMake-Ziel explizit mit der Eigenschaft modules anzugeben, wenn Meson es nicht automatisch erraten kann.

    cmake_dep = dependency('ZLIB', method : 'cmake', modules : ['ZLIB::ZLIB'])

Die Unterstützung für das Hinzufügen zusätzlicher COMPONENTS für die CMake find_package-Suche wird mit dem Argument components bereitgestellt (eingeführt in 0.54.0). Alle angegebenen Komponenten werden direkt an find_package(COMPONENTS) übergeben.

Die Unterstützung für Pakete, die eine bestimmte Version für den Erfolg von CMake find_package erfordern, wird mit dem Argument cmake_package_version bereitgestellt (eingeführt in 0.57.0). Die angegebene cmake_package_version wird direkt als zweiter Parameter an find_package übergeben.

Es ist auch möglich, vorhandene Find<name>.cmake-Dateien mit der Eigenschaft cmake_module_path wiederzuverwenden (seit 0.50.0). Die Verwendung dieser Eigenschaft entspricht dem Setzen der Variable CMAKE_MODULE_PATH in CMake. Die an cmake_module_path übergebenen Pfade sollten sich alle relativ zum Quellverzeichnis des Projekts befinden. Absolute Pfade sollten nur verwendet werden, wenn sich die CMake-Dateien nicht im Projekt selbst befinden.

Zusätzliche CMake-Parameter können mit der Eigenschaft cmake_args angegeben werden (seit 0.50.0).

Dub

Bitte beachten Sie, dass Meson nur Abhängigkeiten finden kann, die im lokalen Dub-Repository vorhanden sind. Sie müssen die Zielabhängigkeiten manuell abrufen und bauen.

Für urld.

dub fetch urld
dub build urld

Eine weitere Sache, die Sie beachten müssen, ist, dass sowohl Meson als auch Dub denselben Compiler verwenden müssen. Dies kann durch das Argument -compiler von Dub und/oder durch manuelles Setzen der Umgebungsvariable DC beim Ausführen von Meson erreicht werden.

dub build urld --compiler=dmd
DC="dmd" meson setup builddir

Config-Tool

CUPS, LLVM, ObjFW, pcap, WxWidgets, libwmf, GCrypt, GPGME und GnuStep stellen entweder keine pkg-config-Module bereit oder können zusätzlich über ein Konfigurationstool (cups-config, llvm-config, libgcrypt-config usw.) erkannt werden. Meson hat native Unterstützung für diese Tools, und sie können wie andere Abhängigkeiten gefunden werden.

pcap_dep = dependency('pcap', version : '>=1.0')
cups_dep = dependency('cups', version : '>=1.4')
llvm_dep = dependency('llvm', version : '>=4.0')
libgcrypt_dep = dependency('libgcrypt', version: '>= 1.8')
gpgme_dep = dependency('gpgme', version: '>= 1.0')
objfw_dep = dependency('objfw', version: '>= 1.0')

Seit 0.55.0 durchsucht Meson bei Cross-Kompilierung nicht mehr $PATH nach einer Config-Tool-Binärdatei, wenn das Config-Tool keinen Eintrag in der Cross-Datei hat.

Abhängigkeiten mit benutzerdefinierter Suchfunktionalität

Einige Abhängigkeiten haben spezifische Erkennungslogiken.

Generische Abhängigkeitsnamen sind Groß-/Kleinschreibung-sensitiv1, aber diese Abhängigkeitsnamen werden Groß-/Kleinschreibung-unabhängig abgeglichen. Der empfohlene Stil ist, sie komplett in Kleinbuchstaben zu schreiben.

In einigen Fällen existieren mehr als eine Erkennungsmethode, und das Schlüsselwort method kann verwendet werden, um eine zu verwendende Erkennungsmethode auszuwählen. Die Methode auto verwendet alle Prüfmechanismen in der Reihenfolge, die Meson für am besten hält.

z.B. libwmf und CUPS bieten sowohl pkg-config- als auch config-tool-Unterstützung. Sie können eine oder die andere über das Schlüsselwort method erzwingen.

cups_dep = dependency('cups', method : 'pkg-config')
wmf_dep = dependency('libwmf', method : 'config-tool')

AppleFrameworks

Verwenden Sie das Schlüsselwort modules, um erforderliche Frameworks aufzulisten, z. B.

dep = dependency('appleframeworks', modules : 'foundation')

Diese Abhängigkeiten können niemals für Nicht-OSX-Hosts gefunden werden.

Blocks

Aktiviert die Unterstützung für Clangs Blocks-Erweiterung.

dep = dependency('blocks')

(hinzugefügt 0.52.0)

Boost

Boost ist keine einzelne Abhängigkeit, sondern eher eine Gruppe verschiedener Bibliotheken. Um Header-only-Bibliotheken von Boost zu verwenden, fügen Sie einfach Boost als Abhängigkeit hinzu.

boost_dep = dependency('boost')
exe = executable('myprog', 'file.cc', dependencies : boost_dep)

Um gegen Boost mit Meson zu linken, listen Sie einfach die Bibliotheken auf, die Sie verwenden möchten.

boost_dep = dependency('boost', modules : ['thread', 'utility'])
exe = executable('myprog', 'file.cc', dependencies : boost_dep)

Sie können dependency() mehrmals mit verschiedenen Modulen aufrufen und diese zum Verlinken gegen Ihre Ziele verwenden.

Wenn sich Ihre Boost-Header oder -Bibliotheken an nicht standardmäßigen Orten befinden, können Sie die Umgebungsvariablen BOOST_ROOT oder BOOST_INCLUDEDIR und BOOST_LIBRARYDIR festlegen. (hinzugefügt in 0.56.0) Sie können diese Parameter auch als boost_root, boost_includedir und boost_librarydir in Ihrer nativen oder Cross-Maschinen-Datei festlegen. Beachten Sie, dass Maschinen-Datei-Variablen Vorrang vor Umgebungsvariablen haben und dass die Angabe einer dieser Variablen die systemweite Suche nach Boost deaktiviert.

Sie können das Argument threading auf single setzen, um stattdessen Boost-Bibliotheken zu verwenden, die für Single-Threaded-Nutzung kompiliert wurden.

CUDA

(hinzugefügt 0.53.0)

Aktiviert das Kompilieren und Linken gegen das CUDA Toolkit. Die Schlüsselwörter version und modules können übergeben werden, um die Verwendung einer bestimmten CUDA Toolkit-Version und/oder zusätzlicher CUDA-Bibliotheken anzufordern.

dep = dependency('cuda', version : '>=10', modules : ['cublas'])

Beachten Sie, dass das explizite Hinzufügen dieser Abhängigkeit nur notwendig ist, wenn Sie CUDA Toolkit aus einer C/C++-Datei oder einem Projekt verwenden oder wenn Sie zusätzliche Toolkit-Bibliotheken nutzen, die explizit verlinkt werden müssen. Wenn das CUDA Toolkit nicht in den Standardpfaden auf Ihrem System gefunden werden kann, können Sie den Pfad explizit mit CUDA_PATH festlegen.

CUPS

method kann auto, config-tool, pkg-config, cmake oder extraframework sein.

Curses

(Seit 0.54.0)

Curses (und ncurses) sind auf verschiedenen Plattformen eine Zumutung. Meson fasst diese Abhängigkeiten in der curses-Abhängigkeit zusammen. Dies deckt sowohl ncurses (bevorzugt) als auch andere Curses-Implementierungen ab.

method kann auto, pkg-config, config-tool oder system sein.

Neu in 0.56.0 Die Methoden config-tool und system.

Um einige der Präprozessor-Symbole zu definieren, die in der Autoconf-Dokumentation für Curses erwähnt werden.

conf = configuration_data()
check_headers = [
  ['ncursesw/menu.h', 'HAVE_NCURSESW_MENU_H'],
  ['ncurses/menu.h', 'HAVE_NCURSES_MENU_H'],
  ['menu.h', 'HAVE_MENU_H'],
  ['ncursesw/curses.h', 'HAVE_NCURSESW_CURSES_H'],
  ['ncursesw.h', 'HAVE_NCURSESW_H'],
  ['ncurses/curses.h', 'HAVE_NCURSES_CURSES_H'],
  ['ncurses.h', 'HAVE_NCURSES_H'],
  ['curses.h', 'HAVE_CURSES_H'],
]

foreach h : check_headers
  if compiler.has_header(h.get(0))
    conf.set(h.get(1), 1)
  endif
endforeach

dl (libdl)

(hinzugefügt 0.62.0)

Bietet Zugriff auf die dynamische Link-Schnittstelle (Funktionen: dlopen, dlclose, dlsym und andere). Auf Systemen, auf denen dies nicht in libc integriert ist (hauptsächlich glibc < 2.34), wird stattdessen versucht, eine externe Bibliothek zu finden, die diese bereitstellt.

method kann auto, builtin oder system sein.

Fortran Coarrays

(hinzugefügt 0.50.0)

Coarrays sind ein intrinsisches Merkmal der Fortran-Sprache, das durch dependency('coarray') aktiviert wird.

GCC verwendet OpenCoarrays, falls vorhanden, zur Implementierung von Coarrays, während Intel und NAG die interne Coarray-Unterstützung nutzen.

GPGME

(hinzugefügt 0.51.0)

method kann auto, config-tool oder pkg-config sein.

GL

Dies findet die OpenGL-Bibliothek auf eine plattformspezifische Weise.

method kann auto, pkg-config oder system sein.

GTest und GMock

GTest und GMock werden als Quellen geliefert, die im Rahmen Ihres Projekts kompiliert werden müssen. Mit Meson müssen Sie sich nicht um die Details kümmern, übergeben Sie einfach gtest oder gmock an dependency und es wird alles für Sie erledigen. Wenn Sie GMock verwenden möchten, wird empfohlen, auch GTest zu verwenden, da es schwierig ist, es eigenständig zum Laufen zu bringen.

Sie können das Schlüsselwort main auf true setzen, um die von GTest bereitgestellte main()-Funktion zu verwenden.

gtest_dep = dependency('gtest', main : true, required : false)
e = executable('testprog', 'test.cc', dependencies : gtest_dep)
test('gtest test', e)

HDF5

(hinzugefügt 0.50.0)

HDF5 wird für C, C++ und Fortran unterstützt. Da Abhängigkeiten sprachspezifisch sind, müssen Sie die angeforderte Sprache mit dem Schlüsselwort-Argument language angeben, d.h.

  • dependency('hdf5', language: 'c') für die C HDF5-Header und -Bibliotheken
  • dependency('hdf5', language: 'cpp') für die C++ HDF5-Header und -Bibliotheken
  • dependency('hdf5', language: 'fortran') für die Fortran HDF5-Header und -Bibliotheken

Die standardmäßigen Low-Level-HDF5-Funktionen und die HL High-Level-HDF5-Funktionen werden für jede Sprache verknüpft.

method kann auto, config-tool oder pkg-config sein.

Neu in 0.56.0 die Methode config-tool. Neu in 0.56.0 die Abhängigkeiten geben jetzt korrekte Abhängigkeitstypen zurück und get_variable und ähnliche Methoden sollten wie erwartet funktionieren.

iconv

(hinzugefügt 0.60.0)

Bietet Zugriff auf die iconv-Familie von C-Funktionen. Auf Systemen, auf denen dies nicht in libc integriert ist, wird stattdessen versucht, eine externe Bibliothek zu finden, die diese bereitstellt.

method kann auto, builtin oder system sein.

intl

(hinzugefügt 0.59.0)

Bietet Zugriff auf die *gettext-Familie von C-Funktionen. Auf Systemen, auf denen dies nicht in libc integriert ist, wird stattdessen versucht, eine externe Bibliothek zu finden, die diese bereitstellt.

method kann auto, builtin oder system sein.

JDK

(hinzugefügt 0.58.0) (veraltet 0.62.0)

Veralteter Name für JNI. dependency('jdk') anstelle von dependency('jni').

JNI

(hinzugefügt 0.62.0)

modules ist eine optionale Liste von Zeichenketten, die jvm und awt enthalten kann.

Bietet Zugriff auf das Kompilieren mit der Java Native Interface (JNI). Die Suche prüft zuerst, ob JAVA_HOME in der Umgebung gesetzt ist, und verwendet andernfalls den aufgelösten Pfad von javac. Systeme verknüpfen normalerweise Ihre bevorzugte JDK mit bekannten Pfaden wie /usr/bin/javac unter Linux zum Beispiel. Unter Verwendung des Pfads aus JAVA_HOME oder des aufgelösten javac platziert diese Abhängigkeit das include-Verzeichnis der JDK-Installation und dessen plattformabhängiges Unterverzeichnis im Include-Pfad des Compilers. Wenn modules nicht leer ist, werden auch die entsprechenden Linker-Argumente hinzugefügt.

dep = dependency('jni', version: '>= 1.8.0', modules: ['jvm'])

Hinweis: Aufgrund der Verwendung eines aufgelösten Pfads kann das Aktualisieren der JDK dazu führen, dass die verschiedenen Pfade nicht gefunden werden. In diesem Fall konfigurieren Sie bitte das Build-Verzeichnis neu. Eine Problemumgehung besteht darin, JAVA_HOME explizit zu setzen, anstatt sich auf das Fallback-Verhalten des aufgelösten javac-Pfads zu verlassen.

Hinweis: Die Verwendung von Include-Pfaden kann auf anderen Plattformen als linux, windows, darwin und sunos fehlerhaft sein. Bitte reichen Sie in diesem Fall einen PR oder eröffnen Sie ein Issue.

Hinweis: Die Verwendung des Arguments modules bei einer JDK <= 1.8 kann fehlerhaft sein, wenn Ihr System etwas anderes als x86_64 ist. Bitte reichen Sie in diesem Fall einen PR oder eröffnen Sie ein Issue.

libgcrypt

(hinzugefügt 0.49.0)

method kann auto, config-tool oder pkg-config sein.

libwmf

(hinzugefügt 0.44.0)

method kann auto, config-tool oder pkg-config sein.

LLVM

Meson hat native Unterstützung für LLVM bis zur Version 3.5. Es unterstützt einige zusätzliche Funktionen im Vergleich zu anderen Abhängigkeiten, die auf Konfigurationstools basieren.

Ab 0.44.0 unterstützt Meson das Schlüsselwort-Argument static für LLVM. Davor hat LLVM >= 3.9 immer dynamisch gelinkt, während ältere Versionen aufgrund einer Eigenart von llvm-config statisch gelinkt haben.

method kann auto, config-tool oder cmake sein.

Module, auch Komponenten genannt

Meson wickelt das Konzept von LLVM-Komponenten in sein eigenes Modulkonzept ein. Wenn Sie bestimmte Komponenten benötigen, fügen Sie sie als Module hinzu, und Meson wird das Richtige tun.

llvm_dep = dependency('llvm', version : '>= 4.0', modules : ['amdgpu'])

Ab 0.44.0 kann es auch optionale Module entgegennehmen (diese beeinflussen die generierten Argumente für einen statischen Link).

llvm_dep = dependency(
  'llvm', version : '>= 4.0', modules : ['amdgpu'], optional_modules : ['inteljitevents'],
)

Verwendung von LLVM-Tools

Bei der Verwendung von LLVM als Bibliothek, aber auch beim Bedarf an seinen Werkzeugen, ist es oft vorteilhaft, dieselbe Version zu verwenden. Dies kann teilweise mit dem Argument version von find_program() erreicht werden. Distributionen neigen jedoch dazu, verschiedene LLVM-Versionen auf recht unterschiedliche Weise zu paketieren. Daher ist es oft besser, die LLVM-Abhängigkeit direkt zu verwenden, um die Werkzeuge abzurufen.

llvm_dep = dependency('llvm', version : ['>= 8', '< 9'])
llvm_link = find_program(llvm_dep.get_variable(configtool: 'bindir') / 'llvm-link')

MPI

(hinzugefügt 0.42.0)

MPI wird für C, C++ und Fortran unterstützt. Da Abhängigkeiten sprachspezifisch sind, müssen Sie die angeforderte Sprache mit dem Schlüsselwort-Argument language angeben, d.h.

  • dependency('mpi', language: 'c') für die C MPI-Header und -Bibliotheken
  • dependency('mpi', language: 'cpp') für die C++ MPI-Header und -Bibliotheken
  • dependency('mpi', language: 'fortran') für die Fortran MPI-Header und -Bibliotheken

Meson bevorzugt pkg-config für MPI, aber wenn Ihre MPI-Implementierung diese nicht bereitstellt, sucht es nach den Standard-Wrapper-Executables mpic, mpicxx, mpic++, mpifort, mpif90, mpif77. Wenn diese nicht in Ihrem Pfad sind, können sie durch Setzen der Standard-Umgebungsvariablen MPICC, MPICXX, MPIFC, MPIF90 oder MPIF77 während der Konfiguration angegeben werden. Es wird auch versuchen, die Microsoft-Implementierung unter Windows über die Methode system zu verwenden.

method kann auto, config-tool, pkg-config oder system sein.

Neu in 0.54.0 die Methoden config-tool und system. Frühere Versionen würden immer zuerst pkg-config, dann config-tool und dann system versuchen.

NetCDF

(hinzugefügt 0.50.0)

NetCDF wird für C, C++ und Fortran unterstützt. Da NetCDF-Abhängigkeiten sprachspezifisch sind, müssen Sie die angeforderte Sprache mit dem Schlüsselwort-Argument language angeben, d.h.

  • dependency('netcdf', language: 'c') für die C NetCDF-Header und -Bibliotheken
  • dependency('netcdf', language: 'cpp') für die C++ NetCDF-Header und -Bibliotheken
  • dependency('netcdf', language: 'fortran') für die Fortran NetCDF-Header und -Bibliotheken

Meson verwendet pkg-config, um NetCDF zu finden.

ObjFW

(hinzugefügt 1.5.0)

Meson hat native Unterstützung für ObjFW, einschließlich Unterstützung für ObjFW-Pakete.

Um ObjFW zu verwenden, erstellen Sie einfach die Abhängigkeit

objfw_dep = dependency('objfw')

Um auch ObjFW-Pakete zu verwenden, geben Sie diese einfach als Module an.

objfw_dep = dependency('objfw', modules: ['SomePackage'])

Wenn Sie eine Abhängigkeit mit und ohne Pakete benötigen, z.B. weil Ihre Tests ObjFWTest verwenden möchten, Sie Ihre Anwendung aber nicht gegen die Tests linken möchten, holen Sie sich einfach zwei Abhängigkeiten und verwenden Sie diese entsprechend.

objfw_dep = dependency('objfw', modules: ['SomePackage'])
objfwtest_dep = dependency('objfw', modules: ['ObjFWTest'])

Verwenden Sie dann objfw_dep für Ihre Bibliothek und nur objfwtest_dep (nicht beide) für Ihre Tests.

OpenMP

(hinzugefügt 0.46.0)

Diese Abhängigkeit wählt die geeigneten Compiler-Flags und/oder Bibliotheken für die OpenMP-Unterstützung aus.

Das Schlüsselwort language kann verwendet werden.

OpenSSL

(hinzugefügt 0.62.0)

method kann auto, pkg-config, system oder cmake sein.

NumPy

(hinzugefügt 1.4.0)

method kann auto, pkg-config oder config-tool sein. dependency('numpy') unterstützt die reguläre Verwendung der NumPy C-API. Die Verwendung von numpy.f2py zur Bindung von Fortran-Code wird noch nicht unterstützt.

pcap

(hinzugefügt 0.42.0)

method kann auto, config-tool oder pkg-config sein.

Pybind11

(hinzugefügt 1.1.0)

method kann auto, pkg-config, config-tool oder cmake sein.

Python3

Python3 wird von Meson speziell behandelt.

  1. Meson versucht, pkg-config zu verwenden.
  2. Wenn pkg-config fehlschlägt, verwendet Meson einen Fallback.
    • Unter Windows ist der Fallback der aktuelle python3-Interpreter.
    • Unter OSX ist der Fallback eine Framework-Abhängigkeit von /Library/Frameworks.

Beachten Sie, dass das von dieser Abhängigkeit gefundene python3 vomjenigen abweichen kann, das im Modul python3 verwendet wird, da Module den aktuellen Interpreter verwenden, die Abhängigkeit aber zuerst pkg-config versucht.

method kann auto, extraframework, pkg-config oder sysconfig sein.

Qt

Meson hat native Qt-Unterstützung. Ihre Verwendung wird am besten anhand eines Beispiels demonstriert.

qt5_mod = import('qt5')
qt5widgets = dependency('qt5', modules : 'Widgets')

processed = qt5_mod.preprocess(
  moc_headers : 'mainWindow.h',   # Only headers that need moc should be put here
  moc_sources : 'helperFile.cpp', # must have #include"moc_helperFile.cpp"
  ui_files    : 'mainWindow.ui',
  qresources  : 'resources.qrc',
)

q5exe = executable('qt5test',
  sources     : ['main.cpp',
                 'mainWindow.cpp',
                 processed],
  dependencies: qt5widgets)

Hier haben wir eine UI-Datei, die mit Qt Designer erstellt wurde, und jeweils eine Quell- und Header-Datei, die eine Vorverarbeitung mit dem moc-Tool erfordern. Wir definieren auch eine Ressourcendatei, die mit rcc kompiliert werden soll. Wir müssen Meson nur mitteilen, welche Dateien welche sind, und es wird sich um das Aufrufen aller notwendigen Werkzeuge in der richtigen Reihenfolge kümmern, was mit der Methode preprocess des Moduls qt5 geschieht. Dessen Ausgabe wird einfach in die Liste der Quellen für das Ziel aufgenommen. Das Schlüsselwort modules von dependency funktioniert genauso wie bei Boost. Es gibt an, welche Unterteile von Qt das Programm verwendet.

Sie können das Schlüsselwort main auf true setzen, um die von der statischen Bibliothek qtmain bereitgestellte WinMain()-Funktion zu verwenden (dieses Argument bewirkt nichts auf anderen Plattformen als Windows).

Das Setzen des optionalen Schlüsselworts private_headers auf true fügt den privaten Header-Include-Pfad der angegebenen Module zu den Compiler-Flags hinzu. (seit v0.47.0)

Hinweis: Die Verwendung privater Header in Ihrem Projekt ist eine schlechte Idee, tun Sie dies auf eigene Gefahr.

method kann auto, pkg-config oder qmake sein.

SDL2

SDL2 kann über pkg-config, das sdl2-config-Konfigurationstool, als OSX-Framework oder cmake gefunden werden.

method kann auto, config-tool, extraframework, pkg-config oder cmake sein.

Shaderc

(hinzugefügt 0.51.0)

Meson versucht zunächst, Shaderc über pkg-config zu finden. Upstream liefert derzeit drei verschiedene pkg-config-Dateien und prüft standardmäßig in dieser Reihenfolge: shaderc, shaderc_combined und shaderc_static. Wenn das Schlüsselwort static true ist, prüft Meson stattdessen in dieser Reihenfolge: shaderc_combined, shaderc_static und shaderc.

Wenn keine pkg-config-Datei gefunden wird, versucht Meson die Bibliothek manuell zu erkennen. In diesem Fall versucht es, gegen -lshaderc_shared oder -lshaderc_combined zu linken, wobei letzteres bevorzugt wird, wenn das statische Schlüsselwort true ist. Beachten Sie, dass es mit dieser Methode nicht möglich ist, die Shaderc-Version zu ermitteln.

method kann auto, pkg-config oder system sein.

Threads

Diese Abhängigkeit wählt die geeigneten Compiler-Flags und/oder Bibliotheken für die Thread-Unterstützung aus.

Siehe threads.

Valgrind

Meson findet Valgrind über pkg-config, verwendet aber nur die Kompilierungsflags und versucht nicht, mit seinen nicht-PIC-Statikbibliotheken zu linken.

Vulkan

(hinzugefügt 0.42.0)

Vulkan kann über pkg-config oder die Umgebungsvariable VULKAN_SDK gefunden werden.

method kann auto, pkg-config oder system sein.

WxWidgets

Ähnlich wie bei Boost ist WxWidgets keine einzelne Bibliothek, sondern eher eine Sammlung von Modulen. WxWidgets wird über wx-config unterstützt. Meson substituiert modules für die wx-config-Aufrufe und generiert

  • compile_args mit wx-config --cxxflags $modules...
  • link_args mit wx-config --libs $modules...

Beispiel

wx_dep = dependency(
  'wxwidgets', version : '>=3.0.0', modules : ['std', 'stc'],
)

# compile_args:
$ wx-config --cxxflags std stc

# link_args:
$ wx-config --libs std stc

Zlib

Zlib wird mit pkg-config und cmake-Unterstützung geliefert, aber auf einigen Betriebssystemen (Windows, macOS, FreeBSD, DragonflyBSD, Android) wird es als Teil des Basisbetriebssystems ohne pkg-config-Unterstützung bereitgestellt. Der neue System-Finder kann auf diesen Betriebssystemen verwendet werden, um mit der gebündelten Version zu linken.

method kann auto, pkg-config, cmake oder system sein.

Neu in 0.54.0 die Methode system.

DIA SDK

(hinzugefügt 1.6.0)

Das Debug Interface Access SDK (DIA SDK) von Microsoft ist nur unter Windows verfügbar, wenn der msvc-, clang-cl- oder clang-Compiler von Microsoft Visual Studio verwendet wird.

Die DIA SDK-Laufzeit wird nicht statisch mit dem Ziel verknüpft. Die Standardverwendungsmethode erfordert, dass die Laufzeit-DLL (msdiaXXX.dll) manuell im Betriebssystem mit dem Befehl regsrv32.exe registriert wird, damit sie mit der Windows-Funktion CoCreateInstance geladen werden kann.

Alternativ können Sie Meson verwenden, um die DIA-Laufzeit-DLL in Ihr Build-Verzeichnis zu kopieren und sie dynamisch mit der Funktion NoRegCoCreate des DIA SDK zu laden. Um dies zu erleichtern, können Sie den Pfad der DLL aus der Variable 'dll' der Abhängigkeit lesen und das fs-Modul zum Kopieren verwenden. Beispiel

dia = dependency('diasdk', required: true)
fs = import('fs')
fs.copyfile(dia.get_variable('dll'))

conf = configuration_data()
conf.set('msdia_dll_name', fs.name(dia_dll_name))

Nur die Hauptversion ist verfügbar (z. B. ist die Version 14 für msdia140.dll).

1: Sie scheinen Groß-/Kleinschreibung-unabhängig zu sein, wenn das zugrunde liegende Dateisystem zufällig Groß-/Kleinschreibung-unabhängig ist.

Die Ergebnisse der Suche sind