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.
1352 lines
62 KiB
1352 lines
62 KiB
# Copyright 2015-2016 The Meson development team |
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
|
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
|
|
'''This module provides helper functions for Gnome/GLib related |
|
functionality such as gobject-introspection, gresources and gtk-doc''' |
|
|
|
from .. import build |
|
import os |
|
import copy |
|
import subprocess |
|
from . import ModuleReturnValue |
|
from ..mesonlib import MesonException, OrderedSet, Popen_safe, extract_as_list |
|
from ..dependencies import Dependency, PkgConfigDependency, InternalDependency |
|
from .. import mlog |
|
from .. import mesonlib |
|
from .. import compilers |
|
from .. import interpreter |
|
from . import GResourceTarget, GResourceHeaderTarget, GirTarget, TypelibTarget, VapiTarget |
|
from . import find_program, get_include_args |
|
from . import ExtensionModule |
|
from ..interpreterbase import noKwargs, permittedKwargs |
|
|
|
# gresource compilation is broken due to the way |
|
# the resource compiler and Ninja clash about it |
|
# |
|
# https://github.com/ninja-build/ninja/issues/1184 |
|
# https://bugzilla.gnome.org/show_bug.cgi?id=774368 |
|
gresource_dep_needed_version = '>= 2.51.1' |
|
|
|
native_glib_version = None |
|
girwarning_printed = False |
|
gdbuswarning_printed = False |
|
gresource_warning_printed = False |
|
_gir_has_extra_lib_arg = None |
|
|
|
def gir_has_extra_lib_arg(): |
|
global _gir_has_extra_lib_arg |
|
if _gir_has_extra_lib_arg is not None: |
|
return _gir_has_extra_lib_arg |
|
|
|
_gir_has_extra_lib_arg = False |
|
try: |
|
g_ir_scanner = find_program('g-ir-scanner', '').get_command() |
|
opts = Popen_safe(g_ir_scanner + ['--help'], stderr=subprocess.STDOUT)[1] |
|
_gir_has_extra_lib_arg = '--extra-library' in opts |
|
except (MesonException, FileNotFoundError, subprocess.CalledProcessError): |
|
pass |
|
return _gir_has_extra_lib_arg |
|
|
|
class GnomeModule(ExtensionModule): |
|
gir_dep = None |
|
|
|
@staticmethod |
|
def _get_native_glib_version(state): |
|
global native_glib_version |
|
if native_glib_version is None: |
|
glib_dep = PkgConfigDependency('glib-2.0', state.environment, |
|
{'native': True}) |
|
native_glib_version = glib_dep.get_version() |
|
return native_glib_version |
|
|
|
def __print_gresources_warning(self, state): |
|
global gresource_warning_printed |
|
if not gresource_warning_printed: |
|
if not mesonlib.version_compare(self._get_native_glib_version(state), gresource_dep_needed_version): |
|
mlog.warning('GLib compiled dependencies do not work reliably with \n' |
|
'the current version of GLib. See the following upstream issue:', |
|
mlog.bold('https://bugzilla.gnome.org/show_bug.cgi?id=774368')) |
|
gresource_warning_printed = True |
|
return [] |
|
|
|
@staticmethod |
|
def _print_gdbus_warning(): |
|
global gdbuswarning_printed |
|
if not gdbuswarning_printed: |
|
mlog.warning('Code generated with gdbus_codegen() requires the root directory be added to\n' |
|
' include_directories of targets with GLib < 2.51.3:', |
|
mlog.bold('https://github.com/mesonbuild/meson/issues/1387')) |
|
gdbuswarning_printed = True |
|
|
|
@permittedKwargs({'source_dir', 'c_name', 'dependencies', 'export', 'gresource_bundle', 'install_header', |
|
'install', 'install_dir', 'extra_args', 'build_by_default'}) |
|
def compile_resources(self, state, args, kwargs): |
|
self.__print_gresources_warning(state) |
|
glib_version = self._get_native_glib_version(state) |
|
|
|
cmd = ['glib-compile-resources', '@INPUT@'] |
|
|
|
source_dirs, dependencies = mesonlib.extract_as_list(kwargs, 'source_dir', 'dependencies', pop=True) |
|
|
|
if len(args) < 2: |
|
raise MesonException('Not enough arguments; the name of the resource ' |
|
'and the path to the XML file are required') |
|
|
|
# Validate dependencies |
|
for (ii, dep) in enumerate(dependencies): |
|
if hasattr(dep, 'held_object'): |
|
dependencies[ii] = dep = dep.held_object |
|
if not isinstance(dep, (mesonlib.File, build.CustomTarget, build.CustomTargetIndex)): |
|
m = 'Unexpected dependency type {!r} for gnome.compile_resources() ' \ |
|
'"dependencies" argument.\nPlease pass the return value of ' \ |
|
'custom_target() or configure_file()' |
|
raise MesonException(m.format(dep)) |
|
if isinstance(dep, (build.CustomTarget, build.CustomTargetIndex)): |
|
if not mesonlib.version_compare(glib_version, gresource_dep_needed_version): |
|
m = 'The "dependencies" argument of gnome.compile_resources() can not\n' \ |
|
'be used with the current version of glib-compile-resources due to\n' \ |
|
'<https://bugzilla.gnome.org/show_bug.cgi?id=774368>' |
|
raise MesonException(m) |
|
|
|
ifile = args[1] |
|
if isinstance(ifile, mesonlib.File): |
|
# glib-compile-resources will be run inside the source dir, |
|
# so we need either 'src_to_build' or the absolute path. |
|
# Absolute path is the easiest choice. |
|
if ifile.is_built: |
|
ifile = os.path.join(state.environment.get_build_dir(), ifile.subdir, ifile.fname) |
|
else: |
|
ifile = os.path.join(ifile.subdir, ifile.fname) |
|
elif isinstance(ifile, str): |
|
ifile = os.path.join(state.subdir, ifile) |
|
elif isinstance(ifile, (interpreter.CustomTargetHolder, |
|
interpreter.CustomTargetIndexHolder, |
|
interpreter.GeneratedObjectsHolder)): |
|
m = 'Resource xml files generated at build-time cannot be used ' \ |
|
'with gnome.compile_resources() because we need to scan ' \ |
|
'the xml for dependencies. Use configure_file() instead ' \ |
|
'to generate it at configure-time.' |
|
raise MesonException(m) |
|
else: |
|
raise MesonException('Invalid file argument: {!r}'.format(ifile)) |
|
|
|
depend_files, depends, subdirs = self._get_gresource_dependencies( |
|
state, ifile, source_dirs, dependencies) |
|
|
|
# Make source dirs relative to build dir now |
|
source_dirs = [os.path.join(state.build_to_src, state.subdir, d) for d in source_dirs] |
|
# Always include current directory, but after paths set by user |
|
source_dirs.append(os.path.join(state.build_to_src, state.subdir)) |
|
# Ensure build directories of generated deps are included |
|
source_dirs += subdirs |
|
|
|
for source_dir in OrderedSet(source_dirs): |
|
cmd += ['--sourcedir', source_dir] |
|
|
|
if 'c_name' in kwargs: |
|
cmd += ['--c-name', kwargs.pop('c_name')] |
|
export = kwargs.pop('export', False) |
|
if not export: |
|
cmd += ['--internal'] |
|
|
|
cmd += ['--generate', '--target', '@OUTPUT@'] |
|
|
|
cmd += mesonlib.stringlistify(kwargs.pop('extra_args', [])) |
|
|
|
gresource = kwargs.pop('gresource_bundle', False) |
|
if gresource: |
|
output = args[0] + '.gresource' |
|
name = args[0] + '_gresource' |
|
else: |
|
output = args[0] + '.c' |
|
name = args[0] + '_c' |
|
|
|
if kwargs.get('install', False) and not gresource: |
|
raise MesonException('The install kwarg only applies to gresource bundles, see install_header') |
|
|
|
install_header = kwargs.pop('install_header', False) |
|
if install_header and gresource: |
|
raise MesonException('The install_header kwarg does not apply to gresource bundles') |
|
if install_header and not export: |
|
raise MesonException('GResource header is installed yet export is not enabled') |
|
|
|
kwargs['input'] = args[1] |
|
kwargs['output'] = output |
|
kwargs['depends'] = depends |
|
if not mesonlib.version_compare(glib_version, gresource_dep_needed_version): |
|
# This will eventually go out of sync if dependencies are added |
|
kwargs['depend_files'] = depend_files |
|
kwargs['command'] = cmd |
|
else: |
|
depfile = kwargs['output'] + '.d' |
|
kwargs['depfile'] = depfile |
|
kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@'] |
|
target_c = GResourceTarget(name, state.subdir, state.subproject, kwargs) |
|
|
|
if gresource: # Only one target for .gresource files |
|
return ModuleReturnValue(target_c, [target_c]) |
|
|
|
h_kwargs = { |
|
'command': cmd, |
|
'input': args[1], |
|
'output': args[0] + '.h', |
|
# The header doesn't actually care about the files yet it errors if missing |
|
'depends': depends |
|
} |
|
if 'build_by_default' in kwargs: |
|
h_kwargs['build_by_default'] = kwargs['build_by_default'] |
|
if install_header: |
|
h_kwargs['install'] = install_header |
|
h_kwargs['install_dir'] = kwargs.get('install_dir', |
|
state.environment.coredata.get_builtin_option('includedir')) |
|
target_h = GResourceHeaderTarget(args[0] + '_h', state.subdir, state.subproject, h_kwargs) |
|
rv = [target_c, target_h] |
|
return ModuleReturnValue(rv, rv) |
|
|
|
def _get_gresource_dependencies(self, state, input_file, source_dirs, dependencies): |
|
|
|
cmd = ['glib-compile-resources', |
|
input_file, |
|
'--generate-dependencies'] |
|
|
|
# Prefer generated files over source files |
|
cmd += ['--sourcedir', state.subdir] # Current build dir |
|
for source_dir in source_dirs: |
|
cmd += ['--sourcedir', os.path.join(state.subdir, source_dir)] |
|
|
|
pc, stdout, stderr = Popen_safe(cmd, cwd=state.environment.get_source_dir()) |
|
if pc.returncode != 0: |
|
m = 'glib-compile-resources failed to get dependencies for {}:\n{}' |
|
mlog.warning(m.format(cmd[1], stderr)) |
|
raise subprocess.CalledProcessError(pc.returncode, cmd) |
|
|
|
dep_files = stdout.split('\n')[:-1] |
|
|
|
# In generate-dependencies mode, glib-compile-resources doesn't raise |
|
# an error for missing resources but instead prints whatever filename |
|
# was listed in the input file. That's good because it means we can |
|
# handle resource files that get generated as part of the build, as |
|
# follows. |
|
# |
|
# If there are multiple generated resource files with the same basename |
|
# then this code will get confused. |
|
def exists_in_srcdir(f): |
|
return os.path.exists(os.path.join(state.environment.get_source_dir(), f)) |
|
|
|
depends = [] |
|
subdirs = [] |
|
for resfile in dep_files[:]: |
|
resbasename = os.path.basename(resfile) |
|
for dep in dependencies: |
|
if hasattr(dep, 'held_object'): |
|
dep = dep.held_object |
|
if isinstance(dep, mesonlib.File): |
|
if dep.fname != resbasename: |
|
continue |
|
dep_files.remove(resfile) |
|
dep_files.append(dep) |
|
subdirs.append(dep.subdir) |
|
break |
|
elif isinstance(dep, (build.CustomTarget, build.CustomTargetIndex)): |
|
fname = None |
|
outputs = {(o, os.path.basename(o)) for o in dep.get_outputs()} |
|
for o, baseo in outputs: |
|
if baseo == resbasename: |
|
fname = o |
|
break |
|
if fname is not None: |
|
dep_files.remove(resfile) |
|
dep_files.append( |
|
mesonlib.File( |
|
is_built=True, |
|
subdir=dep.get_subdir(), |
|
fname=fname)) |
|
depends.append(dep) |
|
subdirs.append(dep.get_subdir()) |
|
break |
|
else: |
|
if not exists_in_srcdir(resfile): |
|
raise MesonException( |
|
'Resource "%s" listed in "%s" was not found. If this is a ' |
|
'generated file, pass the target that generates it to ' |
|
'gnome.compile_resources() using the "dependencies" ' |
|
'keyword argument.' % (resfile, input_file)) |
|
return dep_files, depends, subdirs |
|
|
|
def _get_link_args(self, state, lib, depends=None, include_rpath=False, |
|
use_gir_args=False): |
|
link_command = [] |
|
# Construct link args |
|
if isinstance(lib, build.SharedLibrary): |
|
libdir = os.path.join(state.environment.get_build_dir(), state.backend.get_target_dir(lib)) |
|
link_command.append('-L' + libdir) |
|
# Needed for the following binutils bug: |
|
# https://github.com/mesonbuild/meson/issues/1911 |
|
# However, g-ir-scanner does not understand -Wl,-rpath |
|
# so we need to use -L instead |
|
for d in state.backend.determine_rpath_dirs(lib): |
|
d = os.path.join(state.environment.get_build_dir(), d) |
|
link_command.append('-L' + d) |
|
if include_rpath: |
|
link_command.append('-Wl,-rpath,' + d) |
|
if include_rpath: |
|
link_command.append('-Wl,-rpath,' + libdir) |
|
if depends: |
|
depends.append(lib) |
|
if gir_has_extra_lib_arg() and use_gir_args: |
|
link_command.append('--extra-library=' + lib.name) |
|
else: |
|
link_command.append('-l' + lib.name) |
|
return link_command |
|
|
|
def _get_dependencies_flags(self, deps, state, depends=None, include_rpath=False, |
|
use_gir_args=False): |
|
cflags = OrderedSet() |
|
ldflags = OrderedSet() |
|
gi_includes = OrderedSet() |
|
deps = mesonlib.listify(deps, unholder=True) |
|
|
|
for dep in deps: |
|
if isinstance(dep, InternalDependency): |
|
cflags.update(get_include_args(dep.include_directories)) |
|
for lib in dep.libraries: |
|
if hasattr(lib, 'held_object'): |
|
lib = lib.held_object |
|
ldflags.update(self._get_link_args(state, lib, depends, include_rpath)) |
|
libdepflags = self._get_dependencies_flags(lib.get_external_deps(), state, depends, include_rpath, |
|
use_gir_args) |
|
cflags.update(libdepflags[0]) |
|
ldflags.update(libdepflags[1]) |
|
gi_includes.update(libdepflags[2]) |
|
extdepflags = self._get_dependencies_flags(dep.ext_deps, state, depends, include_rpath, |
|
use_gir_args) |
|
cflags.update(extdepflags[0]) |
|
ldflags.update(extdepflags[1]) |
|
gi_includes.update(extdepflags[2]) |
|
for source in dep.sources: |
|
if hasattr(source, 'held_object'): |
|
source = source.held_object |
|
if isinstance(source, GirTarget): |
|
gi_includes.update([os.path.join(state.environment.get_build_dir(), |
|
source.get_subdir())]) |
|
# This should be any dependency other than an internal one. |
|
elif isinstance(dep, Dependency): |
|
cflags.update(dep.get_compile_args()) |
|
for lib in dep.get_link_args(): |
|
if (os.path.isabs(lib) and |
|
# For PkgConfigDependency only: |
|
getattr(dep, 'is_libtool', False)): |
|
lib_dir = os.path.dirname(lib) |
|
ldflags.update(["-L%s" % lib_dir]) |
|
if include_rpath: |
|
ldflags.update(['-Wl,-rpath {}'.format(lib_dir)]) |
|
libname = os.path.basename(lib) |
|
if libname.startswith("lib"): |
|
libname = libname[3:] |
|
libname = libname.split(".so")[0] |
|
lib = "-l%s" % libname |
|
# Hack to avoid passing some compiler options in |
|
if lib.startswith("-W"): |
|
continue |
|
ldflags.update([lib]) |
|
|
|
if isinstance(dep, PkgConfigDependency): |
|
girdir = dep.get_pkgconfig_variable("girdir", {}) |
|
if girdir: |
|
gi_includes.update([girdir]) |
|
elif isinstance(dep, (build.StaticLibrary, build.SharedLibrary)): |
|
cflags.update(get_include_args(dep.get_include_dirs())) |
|
else: |
|
mlog.log('dependency {!r} not handled to build gir files'.format(dep)) |
|
continue |
|
|
|
if gir_has_extra_lib_arg() and use_gir_args: |
|
fixed_ldflags = set() |
|
for ldflag in ldflags: |
|
if ldflag.startswith("-l"): |
|
fixed_ldflags.add(ldflag.replace('-l', '--extra-library=', 1)) |
|
else: |
|
fixed_ldflags.add(ldflag) |
|
ldflags = fixed_ldflags |
|
return cflags, ldflags, gi_includes |
|
|
|
@permittedKwargs({'sources', 'nsversion', 'namespace', 'symbol_prefix', 'identifier_prefix', |
|
'export_packages', 'includes', 'dependencies', 'link_with', 'include_directories', |
|
'install', 'install_dir_gir', 'install_dir_typelib', 'extra_args', |
|
'packages', 'header', 'build_by_default'}) |
|
def generate_gir(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException('Gir takes one argument') |
|
if kwargs.get('install_dir'): |
|
raise MesonException('install_dir is not supported with generate_gir(), see "install_dir_gir" and "install_dir_typelib"') |
|
giscanner = find_program('g-ir-scanner', 'Gir') |
|
gicompiler = find_program('g-ir-compiler', 'Gir') |
|
girtarget = args[0] |
|
while hasattr(girtarget, 'held_object'): |
|
girtarget = girtarget.held_object |
|
if not isinstance(girtarget, (build.Executable, build.SharedLibrary)): |
|
raise MesonException('Gir target must be an executable or shared library') |
|
try: |
|
if not self.gir_dep: |
|
self.gir_dep = PkgConfigDependency('gobject-introspection-1.0', |
|
state.environment, |
|
{'native': True}) |
|
pkgargs = self.gir_dep.get_compile_args() |
|
except Exception: |
|
raise MesonException('gobject-introspection dependency was not found, gir cannot be generated.') |
|
ns = kwargs.pop('namespace') |
|
nsversion = kwargs.pop('nsversion') |
|
libsources = mesonlib.extract_as_list(kwargs, 'sources', pop=True) |
|
girfile = '%s-%s.gir' % (ns, nsversion) |
|
srcdir = os.path.join(state.environment.get_source_dir(), state.subdir) |
|
builddir = os.path.join(state.environment.get_build_dir(), state.subdir) |
|
depends = [girtarget] |
|
gir_inc_dirs = [] |
|
|
|
scan_command = [giscanner] |
|
scan_command += pkgargs |
|
scan_command += ['--no-libtool', '--namespace=' + ns, '--nsversion=' + nsversion, '--warn-all', |
|
'--output', '@OUTPUT@'] |
|
|
|
header = kwargs.pop('header', None) |
|
if header: |
|
if not isinstance(header, str): |
|
raise MesonException('header must be a string') |
|
scan_command += ['--c-include=' + header] |
|
|
|
extra_args = mesonlib.stringlistify(kwargs.pop('extra_args', [])) |
|
scan_command += extra_args |
|
scan_command += ['-I' + srcdir, |
|
'-I' + builddir] |
|
scan_command += get_include_args(girtarget.get_include_dirs()) |
|
|
|
gir_filelist_dir = state.backend.get_target_private_dir_abs(girtarget) |
|
if not os.path.isdir(gir_filelist_dir): |
|
os.mkdir(gir_filelist_dir) |
|
gir_filelist_filename = os.path.join(gir_filelist_dir, '%s_%s_gir_filelist' % (ns, nsversion)) |
|
|
|
with open(gir_filelist_filename, 'w', encoding='utf-8') as gir_filelist: |
|
for s in libsources: |
|
if hasattr(s, 'held_object'): |
|
s = s.held_object |
|
if isinstance(s, (build.CustomTarget, build.CustomTargetIndex)): |
|
gir_filelist.write(os.path.join(state.environment.get_build_dir(), |
|
state.backend.get_target_dir(s), |
|
s.get_outputs()[0]) + '\n') |
|
elif isinstance(s, mesonlib.File): |
|
gir_filelist.write(s.rel_to_builddir(state.build_to_src) + '\n') |
|
elif isinstance(s, build.GeneratedList): |
|
for gen_src in s.get_outputs(): |
|
gir_filelist.write(os.path.join(srcdir, gen_src) + '\n') |
|
else: |
|
gir_filelist.write(os.path.join(srcdir, s) + '\n') |
|
scan_command += ['--filelist=' + gir_filelist_filename] |
|
|
|
if 'link_with' in kwargs: |
|
link_with = mesonlib.extract_as_list(kwargs, 'link_with', pop = True) |
|
|
|
for link in link_with: |
|
scan_command += self._get_link_args(state, link.held_object, depends, |
|
use_gir_args=True) |
|
|
|
if 'includes' in kwargs: |
|
includes = mesonlib.extract_as_list(kwargs, 'includes', pop = True) |
|
for inc in includes: |
|
if hasattr(inc, 'held_object'): |
|
inc = inc.held_object |
|
if isinstance(inc, str): |
|
scan_command += ['--include=%s' % (inc, )] |
|
elif isinstance(inc, GirTarget): |
|
gir_inc_dirs += [ |
|
os.path.join(state.environment.get_build_dir(), |
|
inc.get_subdir()), |
|
] |
|
scan_command += [ |
|
"--include-uninstalled=%s" % (os.path.join(inc.get_subdir(), inc.get_basename()), ) |
|
] |
|
depends += [inc] |
|
else: |
|
raise MesonException( |
|
'Gir includes must be str, GirTarget, or list of them') |
|
|
|
cflags = [] |
|
ldflags = [] |
|
for lang, compiler in girtarget.compilers.items(): |
|
# XXX: Can you use g-i with any other language? |
|
if lang in ('c', 'cpp', 'objc', 'objcpp', 'd'): |
|
break |
|
else: |
|
lang = None |
|
compiler = None |
|
if lang and compiler: |
|
if state.global_args.get(lang): |
|
cflags += state.global_args[lang] |
|
if state.project_args.get(lang): |
|
cflags += state.project_args[lang] |
|
if 'b_sanitize' in compiler.base_options: |
|
sanitize = state.environment.coredata.base_options['b_sanitize'].value |
|
cflags += compilers.sanitizer_compile_args(sanitize) |
|
if 'address' in sanitize.split(','): |
|
ldflags += ['-lasan'] |
|
# FIXME: Linking directly to libasan is not recommended but g-ir-scanner |
|
# does not understand -f LDFLAGS. https://bugzilla.gnome.org/show_bug.cgi?id=783892 |
|
# ldflags += compilers.sanitizer_link_args(sanitize) |
|
if 'symbol_prefix' in kwargs: |
|
sym_prefixes = mesonlib.stringlistify(kwargs.pop('symbol_prefix', [])) |
|
scan_command += ['--symbol-prefix=%s' % sym_prefix for sym_prefix in sym_prefixes] |
|
if 'identifier_prefix' in kwargs: |
|
identifier_prefix = kwargs.pop('identifier_prefix') |
|
if not isinstance(identifier_prefix, str): |
|
raise MesonException('Gir identifier prefix must be str') |
|
scan_command += ['--identifier-prefix=%s' % identifier_prefix] |
|
if 'export_packages' in kwargs: |
|
pkgs = kwargs.pop('export_packages') |
|
if isinstance(pkgs, str): |
|
scan_command += ['--pkg-export=%s' % pkgs] |
|
elif isinstance(pkgs, list): |
|
scan_command += ['--pkg-export=%s' % pkg for pkg in pkgs] |
|
else: |
|
raise MesonException('Gir export packages must be str or list') |
|
|
|
deps = (girtarget.get_all_link_deps() + girtarget.get_external_deps() + |
|
extract_as_list(kwargs, 'dependencies', pop=True, unholder=True)) |
|
# Need to recursively add deps on GirTarget sources from our |
|
# dependencies and also find the include directories needed for the |
|
# typelib generation custom target below. |
|
typelib_includes = [] |
|
for dep in deps: |
|
if hasattr(dep, 'held_object'): |
|
dep = dep.held_object |
|
# Add a dependency on each GirTarget listed in dependencies and add |
|
# the directory where it will be generated to the typelib includes |
|
if isinstance(dep, InternalDependency): |
|
for source in dep.sources: |
|
if hasattr(source, 'held_object'): |
|
source = source.held_object |
|
if isinstance(source, GirTarget) and source not in depends: |
|
depends.append(source) |
|
subdir = os.path.join(state.environment.get_build_dir(), |
|
source.get_subdir()) |
|
if subdir not in typelib_includes: |
|
typelib_includes.append(subdir) |
|
# Do the same, but for dependencies of dependencies. These are |
|
# stored in the list of generated sources for each link dep (from |
|
# girtarget.get_all_link_deps() above). |
|
# FIXME: Store this in the original form from declare_dependency() |
|
# so it can be used here directly. |
|
elif isinstance(dep, build.SharedLibrary): |
|
for source in dep.generated: |
|
if isinstance(source, GirTarget): |
|
subdir = os.path.join(state.environment.get_build_dir(), |
|
source.get_subdir()) |
|
if subdir not in typelib_includes: |
|
typelib_includes.append(subdir) |
|
elif isinstance(dep, PkgConfigDependency): |
|
girdir = dep.get_pkgconfig_variable("girdir", {}) |
|
if girdir and girdir not in typelib_includes: |
|
typelib_includes.append(girdir) |
|
# ldflags will be misinterpreted by gir scanner (showing |
|
# spurious dependencies) but building GStreamer fails if they |
|
# are not used here. |
|
dep_cflags, dep_ldflags, gi_includes = self._get_dependencies_flags(deps, state, depends, |
|
use_gir_args=True) |
|
cflags += list(dep_cflags) |
|
ldflags += list(dep_ldflags) |
|
scan_command += ['--cflags-begin'] |
|
scan_command += cflags |
|
scan_command += ['--cflags-end'] |
|
# need to put our output directory first as we need to use the |
|
# generated libraries instead of any possibly installed system/prefix |
|
# ones. |
|
if isinstance(girtarget, build.SharedLibrary): |
|
scan_command += ["-L@PRIVATE_OUTDIR_ABS_%s@" % girtarget.get_id()] |
|
scan_command += list(ldflags) |
|
for i in gi_includes: |
|
scan_command += ['--add-include-path=%s' % i] |
|
|
|
inc_dirs = mesonlib.extract_as_list(kwargs, 'include_directories', pop = True) |
|
for incd in inc_dirs: |
|
if not isinstance(incd.held_object, (str, build.IncludeDirs)): |
|
raise MesonException( |
|
'Gir include dirs should be include_directories().') |
|
scan_command += get_include_args(inc_dirs) |
|
scan_command += get_include_args(gir_inc_dirs + inc_dirs, prefix='--add-include-path=') |
|
|
|
if isinstance(girtarget, build.Executable): |
|
scan_command += ['--program', girtarget] |
|
elif isinstance(girtarget, build.SharedLibrary): |
|
libname = girtarget.get_basename() |
|
# Needed for the following binutils bug: |
|
# https://github.com/mesonbuild/meson/issues/1911 |
|
# However, g-ir-scanner does not understand -Wl,-rpath |
|
# so we need to use -L instead |
|
for d in state.backend.determine_rpath_dirs(girtarget): |
|
d = os.path.join(state.environment.get_build_dir(), d) |
|
scan_command.append('-L' + d) |
|
scan_command += ['--library', libname] |
|
scankwargs = {'output': girfile, |
|
'command': scan_command, |
|
'depends': depends} |
|
if 'install' in kwargs: |
|
scankwargs['install'] = kwargs['install'] |
|
scankwargs['install_dir'] = kwargs.get('install_dir_gir', |
|
os.path.join(state.environment.get_datadir(), 'gir-1.0')) |
|
if 'build_by_default' in kwargs: |
|
scankwargs['build_by_default'] = kwargs['build_by_default'] |
|
scan_target = GirTarget(girfile, state.subdir, state.subproject, scankwargs) |
|
|
|
typelib_output = '%s-%s.typelib' % (ns, nsversion) |
|
typelib_cmd = [gicompiler, scan_target, '--output', '@OUTPUT@'] |
|
typelib_cmd += get_include_args(gir_inc_dirs, prefix='--includedir=') |
|
for incdir in typelib_includes: |
|
typelib_cmd += ["--includedir=" + incdir] |
|
|
|
typelib_kwargs = { |
|
'output': typelib_output, |
|
'command': typelib_cmd, |
|
} |
|
if 'install' in kwargs: |
|
typelib_kwargs['install'] = kwargs['install'] |
|
typelib_kwargs['install_dir'] = kwargs.get('install_dir_typelib', |
|
os.path.join(state.environment.get_libdir(), 'girepository-1.0')) |
|
if 'build_by_default' in kwargs: |
|
typelib_kwargs['build_by_default'] = kwargs['build_by_default'] |
|
typelib_target = TypelibTarget(typelib_output, state.subdir, state.subproject, typelib_kwargs) |
|
rv = [scan_target, typelib_target] |
|
return ModuleReturnValue(rv, rv) |
|
|
|
@permittedKwargs({'build_by_default', 'depend_files'}) |
|
def compile_schemas(self, state, args, kwargs): |
|
if args: |
|
raise MesonException('Compile_schemas does not take positional arguments.') |
|
srcdir = os.path.join(state.build_to_src, state.subdir) |
|
outdir = state.subdir |
|
|
|
cmd = [find_program('glib-compile-schemas', 'gsettings-compile')] |
|
cmd += ['--targetdir', outdir, srcdir] |
|
kwargs['command'] = cmd |
|
kwargs['input'] = [] |
|
kwargs['output'] = 'gschemas.compiled' |
|
if state.subdir == '': |
|
targetname = 'gsettings-compile' |
|
else: |
|
targetname = 'gsettings-compile-' + state.subdir.replace('/', '_') |
|
target_g = build.CustomTarget(targetname, state.subdir, state.subproject, kwargs) |
|
return ModuleReturnValue(target_g, [target_g]) |
|
|
|
@permittedKwargs({'sources', 'media', 'symlink_media', 'languages'}) |
|
def yelp(self, state, args, kwargs): |
|
if len(args) < 1: |
|
raise MesonException('Yelp requires a project id') |
|
|
|
project_id = args[0] |
|
sources = mesonlib.stringlistify(kwargs.pop('sources', [])) |
|
if not sources: |
|
if len(args) > 1: |
|
sources = mesonlib.stringlistify(args[1:]) |
|
if not sources: |
|
raise MesonException('Yelp requires a list of sources') |
|
source_str = '@@'.join(sources) |
|
|
|
langs = mesonlib.stringlistify(kwargs.pop('languages', [])) |
|
if langs: |
|
mlog.log(mlog.red('DEPRECATION:'), '''The "languages" argument of gnome.yelp() is deprecated. |
|
Use a LINGUAS file in the sources directory instead. |
|
This will become a hard error in the future.''') |
|
|
|
media = mesonlib.stringlistify(kwargs.pop('media', [])) |
|
symlinks = kwargs.pop('symlink_media', True) |
|
|
|
if not isinstance(symlinks, bool): |
|
raise MesonException('symlink_media must be a boolean') |
|
|
|
if kwargs: |
|
raise MesonException('Unknown arguments passed: {}'.format(', '.join(kwargs.keys()))) |
|
|
|
script = state.environment.get_build_command() |
|
args = ['--internal', |
|
'yelphelper', |
|
'install', |
|
'--subdir=' + state.subdir, |
|
'--id=' + project_id, |
|
'--installdir=' + os.path.join(state.environment.get_datadir(), 'help'), |
|
'--sources=' + source_str] |
|
if symlinks: |
|
args.append('--symlinks=true') |
|
if media: |
|
args.append('--media=' + '@@'.join(media)) |
|
if langs: |
|
args.append('--langs=' + '@@'.join(langs)) |
|
inscript = build.RunScript(script, args) |
|
|
|
potargs = state.environment.get_build_command() + [ |
|
'--internal', 'yelphelper', 'pot', |
|
'--subdir=' + state.subdir, |
|
'--id=' + project_id, |
|
'--sources=' + source_str, |
|
] |
|
pottarget = build.RunTarget('help-' + project_id + '-pot', potargs[0], |
|
potargs[1:], [], state.subdir, state.subproject) |
|
|
|
poargs = state.environment.get_build_command() + [ |
|
'--internal', 'yelphelper', 'update-po', |
|
'--subdir=' + state.subdir, |
|
'--id=' + project_id, |
|
'--sources=' + source_str, |
|
'--langs=' + '@@'.join(langs), |
|
] |
|
potarget = build.RunTarget('help-' + project_id + '-update-po', poargs[0], |
|
poargs[1:], [], state.subdir, state.subproject) |
|
|
|
rv = [inscript, pottarget, potarget] |
|
return ModuleReturnValue(None, rv) |
|
|
|
@permittedKwargs({'main_xml', 'main_sgml', 'src_dir', 'dependencies', 'install', |
|
'install_dir', 'scan_args', 'scanobjs_args', 'gobject_typesfile', |
|
'fixxref_args', 'html_args', 'html_assets', 'content_files', |
|
'mkdb_args', 'ignore_headers', 'include_directories', |
|
'namespace', 'mode', 'expand_content_files'}) |
|
def gtkdoc(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException('Gtkdoc must have one positional argument.') |
|
modulename = args[0] |
|
if not isinstance(modulename, str): |
|
raise MesonException('Gtkdoc arg must be string.') |
|
if 'src_dir' not in kwargs: |
|
raise MesonException('Keyword argument src_dir missing.') |
|
main_file = kwargs.get('main_sgml', '') |
|
if not isinstance(main_file, str): |
|
raise MesonException('Main sgml keyword argument must be a string.') |
|
main_xml = kwargs.get('main_xml', '') |
|
if not isinstance(main_xml, str): |
|
raise MesonException('Main xml keyword argument must be a string.') |
|
if main_xml != '': |
|
if main_file != '': |
|
raise MesonException('You can only specify main_xml or main_sgml, not both.') |
|
main_file = main_xml |
|
targetname = modulename + '-doc' |
|
command = state.environment.get_build_command() |
|
|
|
namespace = kwargs.get('namespace', '') |
|
mode = kwargs.get('mode', 'auto') |
|
VALID_MODES = ('xml', 'sgml', 'none', 'auto') |
|
if mode not in VALID_MODES: |
|
raise MesonException('gtkdoc: Mode {} is not a valid mode: {}'.format(mode, VALID_MODES)) |
|
|
|
src_dirs = mesonlib.extract_as_list(kwargs, 'src_dir') |
|
header_dirs = [] |
|
for src_dir in src_dirs: |
|
if hasattr(src_dir, 'held_object'): |
|
src_dir = src_dir.held_object |
|
if not isinstance(src_dir, build.IncludeDirs): |
|
raise MesonException('Invalid keyword argument for src_dir.') |
|
for inc_dir in src_dir.get_incdirs(): |
|
header_dirs.append(os.path.join(state.environment.get_source_dir(), |
|
src_dir.get_curdir(), inc_dir)) |
|
header_dirs.append(os.path.join(state.environment.get_build_dir(), |
|
src_dir.get_curdir(), inc_dir)) |
|
else: |
|
header_dirs.append(src_dir) |
|
|
|
args = ['--internal', 'gtkdoc', |
|
'--sourcedir=' + state.environment.get_source_dir(), |
|
'--builddir=' + state.environment.get_build_dir(), |
|
'--subdir=' + state.subdir, |
|
'--headerdirs=' + '@@'.join(header_dirs), |
|
'--mainfile=' + main_file, |
|
'--modulename=' + modulename, |
|
'--mode=' + mode] |
|
if namespace: |
|
args.append('--namespace=' + namespace) |
|
args += self._unpack_args('--htmlargs=', 'html_args', kwargs) |
|
args += self._unpack_args('--scanargs=', 'scan_args', kwargs) |
|
args += self._unpack_args('--scanobjsargs=', 'scanobjs_args', kwargs) |
|
args += self._unpack_args('--gobjects-types-file=', 'gobject_typesfile', kwargs, state) |
|
args += self._unpack_args('--fixxrefargs=', 'fixxref_args', kwargs) |
|
args += self._unpack_args('--mkdbargs=', 'mkdb_args', kwargs) |
|
args += self._unpack_args('--html-assets=', 'html_assets', kwargs, state) |
|
|
|
depends = [] |
|
content_files = [] |
|
for s in mesonlib.extract_as_list(kwargs, 'content_files'): |
|
if hasattr(s, 'held_object'): |
|
s = s.held_object |
|
if isinstance(s, (build.CustomTarget, build.CustomTargetIndex)): |
|
depends.append(s) |
|
content_files.append(os.path.join(state.environment.get_build_dir(), |
|
state.backend.get_target_dir(s), |
|
s.get_outputs()[0])) |
|
elif isinstance(s, mesonlib.File): |
|
content_files.append(s.rel_to_builddir(state.build_to_src)) |
|
elif isinstance(s, build.GeneratedList): |
|
depends.append(s) |
|
for gen_src in s.get_outputs(): |
|
content_files.append(os.path.join(state.environment.get_source_dir(), |
|
state.subdir, |
|
gen_src)) |
|
elif isinstance(s, str): |
|
content_files.append(os.path.join(state.environment.get_source_dir(), |
|
state.subdir, |
|
s)) |
|
else: |
|
raise MesonException( |
|
'Invalid object type: {!r}'.format(s.__class__.__name__)) |
|
args += ['--content-files=' + '@@'.join(content_files)] |
|
|
|
args += self._unpack_args('--expand-content-files=', 'expand_content_files', kwargs, state) |
|
args += self._unpack_args('--ignore-headers=', 'ignore_headers', kwargs) |
|
args += self._unpack_args('--installdir=', 'install_dir', kwargs, state) |
|
args += self._get_build_args(kwargs, state) |
|
res = [build.RunTarget(targetname, command[0], command[1:] + args, depends, state.subdir, state.subproject)] |
|
if kwargs.get('install', True): |
|
res.append(build.RunScript(command, args)) |
|
return ModuleReturnValue(None, res) |
|
|
|
def _get_build_args(self, kwargs, state): |
|
args = [] |
|
deps = extract_as_list(kwargs, 'dependencies', unholder=True) |
|
cflags, ldflags, gi_includes = self._get_dependencies_flags(deps, state, include_rpath=True) |
|
inc_dirs = mesonlib.extract_as_list(kwargs, 'include_directories') |
|
for incd in inc_dirs: |
|
if not isinstance(incd.held_object, (str, build.IncludeDirs)): |
|
raise MesonException( |
|
'Gir include dirs should be include_directories().') |
|
cflags.update(get_include_args(inc_dirs)) |
|
if cflags: |
|
args += ['--cflags=%s' % ' '.join(cflags)] |
|
if ldflags: |
|
args += ['--ldflags=%s' % ' '.join(ldflags)] |
|
compiler = state.environment.coredata.compilers.get('c') |
|
if compiler: |
|
args += ['--cc=%s' % ' '.join(compiler.get_exelist())] |
|
args += ['--ld=%s' % ' '.join(compiler.get_linker_exelist())] |
|
|
|
return args |
|
|
|
@noKwargs |
|
def gtkdoc_html_dir(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException('Must have exactly one argument.') |
|
modulename = args[0] |
|
if not isinstance(modulename, str): |
|
raise MesonException('Argument must be a string') |
|
return ModuleReturnValue(os.path.join('share/gtk-doc/html', modulename), []) |
|
|
|
@staticmethod |
|
def _unpack_args(arg, kwarg_name, kwargs, expend_file_state=None): |
|
if kwarg_name not in kwargs: |
|
return [] |
|
|
|
new_args = mesonlib.extract_as_list(kwargs, kwarg_name) |
|
args = [] |
|
for i in new_args: |
|
if expend_file_state and isinstance(i, mesonlib.File): |
|
i = i.absolute_path(expend_file_state.environment.get_source_dir(), expend_file_state.environment.get_build_dir()) |
|
elif not isinstance(i, str): |
|
raise MesonException(kwarg_name + ' values must be strings.') |
|
args.append(i) |
|
|
|
if args: |
|
return [arg + '@@'.join(args)] |
|
|
|
return [] |
|
|
|
@permittedKwargs({'interface_prefix', 'namespace', 'object_manager', 'build_by_default', |
|
'annotations', 'docbook'}) |
|
def gdbus_codegen(self, state, args, kwargs): |
|
if len(args) != 2: |
|
raise MesonException('Gdbus_codegen takes two arguments, name and xml file.') |
|
namebase = args[0] |
|
xml_file = args[1] |
|
target_name = namebase + '-gdbus' |
|
cmd = [find_program('gdbus-codegen', target_name)] |
|
if 'interface_prefix' in kwargs: |
|
cmd += ['--interface-prefix', kwargs.pop('interface_prefix')] |
|
if 'namespace' in kwargs: |
|
cmd += ['--c-namespace', kwargs.pop('namespace')] |
|
if kwargs.get('object_manager', False): |
|
cmd += ['--c-generate-object-manager'] |
|
if 'docbook' in kwargs: |
|
cmd += ['--generate-docbook', kwargs.pop('docbook')] |
|
|
|
# Annotations are a bit ugly in that they are a list of lists of strings... |
|
annotations = kwargs.pop('annotations', []) |
|
if not isinstance(annotations, list): |
|
raise MesonException('annotations takes a list') |
|
if annotations and isinstance(annotations, list) and not isinstance(annotations[0], list): |
|
annotations = [annotations] |
|
|
|
for annotation in annotations: |
|
if len(annotation) != 3 or not all(isinstance(i, str) for i in annotation): |
|
raise MesonException('Annotations must be made up of 3 strings for ELEMENT, KEY, and VALUE') |
|
cmd += ['--annotate'] + annotation |
|
|
|
# https://git.gnome.org/browse/glib/commit/?id=ee09bb704fe9ccb24d92dd86696a0e6bb8f0dc1a |
|
if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.51.3'): |
|
cmd += ['--output-directory', '@OUTDIR@', '--generate-c-code', namebase, '@INPUT@'] |
|
else: |
|
self._print_gdbus_warning() |
|
cmd += ['--generate-c-code', '@OUTDIR@/' + namebase, '@INPUT@'] |
|
outputs = [namebase + '.c', namebase + '.h'] |
|
custom_kwargs = {'input': xml_file, |
|
'output': outputs, |
|
'command': cmd |
|
} |
|
if 'build_by_default' in kwargs: |
|
custom_kwargs['build_by_default'] = kwargs['build_by_default'] |
|
ct = build.CustomTarget(target_name, state.subdir, state.subproject, custom_kwargs) |
|
return ModuleReturnValue(ct, [ct]) |
|
|
|
@permittedKwargs({'sources', 'c_template', 'h_template', 'install_header', 'install_dir', |
|
'comments', 'identifier_prefix', 'symbol_prefix', 'eprod', 'vprod', |
|
'fhead', 'fprod', 'ftail', 'vhead', 'vtail', 'depends'}) |
|
def mkenums(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException('Mkenums requires one positional argument.') |
|
basename = args[0] |
|
|
|
if 'sources' not in kwargs: |
|
raise MesonException('Missing keyword argument "sources".') |
|
sources = kwargs.pop('sources') |
|
if isinstance(sources, str): |
|
sources = [sources] |
|
elif not isinstance(sources, list): |
|
raise MesonException( |
|
'Sources keyword argument must be a string or array.') |
|
|
|
cmd = [] |
|
known_kwargs = ['comments', 'eprod', 'fhead', 'fprod', 'ftail', |
|
'identifier_prefix', 'symbol_prefix', 'template', |
|
'vhead', 'vprod', 'vtail'] |
|
known_custom_target_kwargs = ['install_dir', 'build_always', |
|
'depends', 'depend_files'] |
|
c_template = h_template = None |
|
install_header = False |
|
for arg, value in kwargs.items(): |
|
if arg == 'sources': |
|
raise AssertionError("sources should've already been handled") |
|
elif arg == 'c_template': |
|
c_template = value |
|
if 'template' in kwargs: |
|
raise MesonException('Mkenums does not accept both ' |
|
'c_template and template keyword ' |
|
'arguments at the same time.') |
|
elif arg == 'h_template': |
|
h_template = value |
|
if 'template' in kwargs: |
|
raise MesonException('Mkenums does not accept both ' |
|
'h_template and template keyword ' |
|
'arguments at the same time.') |
|
elif arg == 'install_header': |
|
install_header = value |
|
elif arg in known_kwargs: |
|
cmd += ['--' + arg.replace('_', '-'), value] |
|
elif arg not in known_custom_target_kwargs: |
|
raise MesonException( |
|
'Mkenums does not take a %s keyword argument.' % (arg, )) |
|
cmd = [find_program('glib-mkenums', 'mkenums')] + cmd |
|
custom_kwargs = {} |
|
for arg in known_custom_target_kwargs: |
|
if arg in kwargs: |
|
custom_kwargs[arg] = kwargs[arg] |
|
|
|
targets = [] |
|
|
|
if h_template is not None: |
|
h_output = os.path.splitext(h_template)[0] |
|
# We always set template as the first element in the source array |
|
# so --template consumes it. |
|
h_cmd = cmd + ['--template', '@INPUT@'] |
|
h_sources = [h_template] + sources |
|
custom_kwargs['install'] = install_header |
|
if 'install_dir' not in custom_kwargs: |
|
custom_kwargs['install_dir'] = \ |
|
state.environment.coredata.get_builtin_option('includedir') |
|
h_target = self._make_mkenum_custom_target(state, h_sources, |
|
h_output, h_cmd, |
|
custom_kwargs) |
|
targets.append(h_target) |
|
|
|
if c_template is not None: |
|
c_output = os.path.splitext(c_template)[0] |
|
# We always set template as the first element in the source array |
|
# so --template consumes it. |
|
c_cmd = cmd + ['--template', '@INPUT@'] |
|
c_sources = [c_template] + sources |
|
# Never install the C file. Complain on bug tracker if you need it. |
|
custom_kwargs['install'] = False |
|
if h_template is not None: |
|
if 'depends' in custom_kwargs: |
|
custom_kwargs['depends'] += [h_target] |
|
else: |
|
custom_kwargs['depends'] = h_target |
|
c_target = self._make_mkenum_custom_target(state, c_sources, |
|
c_output, c_cmd, |
|
custom_kwargs) |
|
targets.insert(0, c_target) |
|
|
|
if c_template is None and h_template is None: |
|
generic_cmd = cmd + ['@INPUT@'] |
|
custom_kwargs['install'] = install_header |
|
if 'install_dir' not in custom_kwargs: |
|
custom_kwargs['install_dir'] = \ |
|
state.environment.coredata.get_builtin_option('includedir') |
|
target = self._make_mkenum_custom_target(state, sources, basename, |
|
generic_cmd, custom_kwargs) |
|
return ModuleReturnValue(target, [target]) |
|
elif len(targets) == 1: |
|
return ModuleReturnValue(targets[0], [targets[0]]) |
|
else: |
|
return ModuleReturnValue(targets, targets) |
|
|
|
def mkenums_simple(self, state, args, kwargs): |
|
hdr_filename = args[0] + '.h' |
|
body_filename = args[0] + '.c' |
|
|
|
# not really needed, just for sanity checking |
|
forbidden_kwargs = ['c_template', 'h_template', 'eprod', 'fhead', |
|
'fprod', 'ftail', 'vhead', 'vtail', 'comments'] |
|
for arg in forbidden_kwargs: |
|
if arg in kwargs: |
|
raise MesonException('mkenums_simple() does not take a %s keyword argument' % (arg, )) |
|
|
|
# kwargs to pass as-is from mkenums_simple() to mkenums() |
|
shared_kwargs = ['sources', 'install_header', 'install_dir', |
|
'identifier_prefix', 'symbol_prefix'] |
|
mkenums_kwargs = {} |
|
for arg in shared_kwargs: |
|
if arg in kwargs: |
|
mkenums_kwargs[arg] = kwargs[arg] |
|
|
|
# .c file generation |
|
c_file_kwargs = copy.deepcopy(mkenums_kwargs) |
|
if 'sources' not in kwargs: |
|
raise MesonException('Missing keyword argument "sources".') |
|
sources = kwargs['sources'] |
|
if isinstance(sources, str): |
|
sources = [sources] |
|
elif not isinstance(sources, list): |
|
raise MesonException( |
|
'Sources keyword argument must be a string or array.') |
|
|
|
header_prefix = kwargs.get('header_prefix', '') |
|
decl_decorator = kwargs.get('decorator', '') |
|
func_prefix = kwargs.get('function_prefix', '') |
|
body_prefix = kwargs.get('body_prefix', '') |
|
|
|
# Maybe we should write our own template files into the build dir |
|
# instead, but that seems like much more work, nice as it would be. |
|
fhead = '' |
|
if body_prefix != '': |
|
fhead += '%s\n' % body_prefix |
|
fhead += '#include "%s"\n' % hdr_filename |
|
for hdr in sources: |
|
fhead += '#include "%s"\n' % hdr |
|
fhead += ''' |
|
#define C_ENUM(v) ((gint) v) |
|
#define C_FLAGS(v) ((guint) v) |
|
''' |
|
c_file_kwargs['fhead'] = fhead |
|
|
|
c_file_kwargs['fprod'] = ''' |
|
/* enumerations from "@basename@" */ |
|
''' |
|
|
|
c_file_kwargs['vhead'] = ''' |
|
GType |
|
%s@enum_name@_get_type (void) |
|
{ |
|
static volatile gsize gtype_id = 0; |
|
static const G@Type@Value values[] = {''' % func_prefix |
|
|
|
c_file_kwargs['vprod'] = ' { C_@TYPE@(@VALUENAME@), "@VALUENAME@", "@valuenick@" },' |
|
|
|
c_file_kwargs['vtail'] = ''' { 0, NULL, NULL } |
|
}; |
|
if (g_once_init_enter (>ype_id)) { |
|
GType new_type = g_@type@_register_static ("@EnumName@", values); |
|
g_once_init_leave (>ype_id, new_type); |
|
} |
|
return (GType) gtype_id; |
|
}''' |
|
|
|
rv = self.mkenums(state, [body_filename], c_file_kwargs) |
|
c_file = rv.return_value |
|
|
|
# .h file generation |
|
h_file_kwargs = copy.deepcopy(mkenums_kwargs) |
|
|
|
h_file_kwargs['fhead'] = '''#pragma once |
|
|
|
#include <glib-object.h> |
|
{} |
|
|
|
G_BEGIN_DECLS |
|
'''.format(header_prefix) |
|
|
|
h_file_kwargs['fprod'] = ''' |
|
/* enumerations from "@basename@" */ |
|
''' |
|
|
|
h_file_kwargs['vhead'] = ''' |
|
{} |
|
GType {}@enum_name@_get_type (void); |
|
#define @ENUMPREFIX@_TYPE_@ENUMSHORT@ ({}@enum_name@_get_type())'''.format(decl_decorator, func_prefix, func_prefix) |
|
|
|
h_file_kwargs['ftail'] = ''' |
|
G_END_DECLS''' |
|
|
|
rv = self.mkenums(state, [hdr_filename], h_file_kwargs) |
|
h_file = rv.return_value |
|
|
|
return ModuleReturnValue([c_file, h_file], [c_file, h_file]) |
|
|
|
@staticmethod |
|
def _make_mkenum_custom_target(state, sources, output, cmd, kwargs): |
|
custom_kwargs = { |
|
'input': sources, |
|
'output': output, |
|
'capture': True, |
|
'command': cmd |
|
} |
|
custom_kwargs.update(kwargs) |
|
return build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs, |
|
# https://github.com/mesonbuild/meson/issues/973 |
|
absolute_paths=True) |
|
|
|
@permittedKwargs({'sources', 'prefix', 'install_header', 'install_dir', 'stdinc', |
|
'nostdinc', 'internal', 'skip_source', 'valist_marshallers', |
|
'extra_args'}) |
|
def genmarshal(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException( |
|
'Genmarshal requires one positional argument.') |
|
output = args[0] |
|
|
|
if 'sources' not in kwargs: |
|
raise MesonException('Missing keyword argument "sources".') |
|
sources = kwargs.pop('sources') |
|
if isinstance(sources, str): |
|
sources = [sources] |
|
elif not isinstance(sources, list): |
|
raise MesonException( |
|
'Sources keyword argument must be a string or array.') |
|
|
|
new_genmarshal = mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.53.3') |
|
|
|
cmd = [find_program('glib-genmarshal', output + '_genmarshal')] |
|
known_kwargs = ['internal', 'nostdinc', 'skip_source', 'stdinc', |
|
'valist_marshallers', 'extra_args'] |
|
known_custom_target_kwargs = ['build_always', 'depends', |
|
'depend_files', 'install_dir', |
|
'install_header'] |
|
for arg, value in kwargs.items(): |
|
if arg == 'prefix': |
|
cmd += ['--prefix', value] |
|
elif arg == 'extra_args': |
|
if new_genmarshal: |
|
cmd += mesonlib.stringlistify(value) |
|
else: |
|
mlog.warning('The current version of GLib does not support extra arguments \n' |
|
'for glib-genmarshal. You need at least GLib 2.53.3. See ', |
|
mlog.bold('https://github.com/mesonbuild/meson/pull/2049')) |
|
elif arg in known_kwargs and value: |
|
cmd += ['--' + arg.replace('_', '-')] |
|
elif arg not in known_custom_target_kwargs: |
|
raise MesonException( |
|
'Genmarshal does not take a %s keyword argument.' % ( |
|
arg, )) |
|
|
|
install_header = kwargs.pop('install_header', False) |
|
install_dir = kwargs.pop('install_dir', None) |
|
|
|
custom_kwargs = { |
|
'input': sources, |
|
} |
|
|
|
# https://github.com/GNOME/glib/commit/0fbc98097fac4d3e647684f344e508abae109fdf |
|
if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.51.0'): |
|
cmd += ['--output', '@OUTPUT@'] |
|
else: |
|
custom_kwargs['capture'] = True |
|
|
|
for arg in known_custom_target_kwargs: |
|
if arg in kwargs: |
|
custom_kwargs[arg] = kwargs[arg] |
|
|
|
header_file = output + '.h' |
|
custom_kwargs['command'] = cmd + ['--body', '@INPUT@'] |
|
if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.53.4'): |
|
# Silence any warnings about missing prototypes |
|
custom_kwargs['command'] += ['--include-header', header_file] |
|
custom_kwargs['output'] = output + '.c' |
|
body = build.CustomTarget(output + '_c', state.subdir, state.subproject, custom_kwargs) |
|
|
|
custom_kwargs['install'] = install_header |
|
if install_dir is not None: |
|
custom_kwargs['install_dir'] = install_dir |
|
if new_genmarshal: |
|
cmd += ['--pragma-once'] |
|
custom_kwargs['command'] = cmd + ['--header', '@INPUT@'] |
|
custom_kwargs['output'] = header_file |
|
header = build.CustomTarget(output + '_h', state.subdir, state.subproject, custom_kwargs) |
|
|
|
rv = [body, header] |
|
return ModuleReturnValue(rv, rv) |
|
|
|
@staticmethod |
|
def _vapi_args_to_command(prefix, variable, kwargs, accept_vapi=False): |
|
arg_list = mesonlib.extract_as_list(kwargs, variable) |
|
ret = [] |
|
for arg in arg_list: |
|
if not isinstance(arg, str): |
|
types = 'strings' + ' or InternalDependencys' if accept_vapi else '' |
|
raise MesonException('All {} must be {}'.format(variable, types)) |
|
ret.append(prefix + arg) |
|
return ret |
|
|
|
def _extract_vapi_packages(self, state, kwargs): |
|
''' |
|
Packages are special because we need to: |
|
- Get a list of packages for the .deps file |
|
- Get a list of depends for any VapiTargets |
|
- Get package name from VapiTargets |
|
- Add include dirs for any VapiTargets |
|
''' |
|
arg_list = kwargs.get('packages') |
|
if not arg_list: |
|
return [], [], [], [] |
|
arg_list = mesonlib.listify(arg_list) |
|
vapi_depends = [] |
|
vapi_packages = [] |
|
vapi_includes = [] |
|
ret = [] |
|
remaining_args = [] |
|
for arg in arg_list: |
|
if hasattr(arg, 'held_object'): |
|
arg = arg.held_object |
|
if isinstance(arg, InternalDependency): |
|
targets = [t for t in arg.sources if isinstance(t, VapiTarget)] |
|
for target in targets: |
|
srcdir = os.path.join(state.environment.get_source_dir(), |
|
target.get_subdir()) |
|
outdir = os.path.join(state.environment.get_build_dir(), |
|
target.get_subdir()) |
|
outfile = target.get_outputs()[0][:-5] # Strip .vapi |
|
ret.append('--vapidir=' + outdir) |
|
ret.append('--girdir=' + outdir) |
|
ret.append('--pkg=' + outfile) |
|
vapi_depends.append(target) |
|
vapi_packages.append(outfile) |
|
vapi_includes.append(srcdir) |
|
else: |
|
vapi_packages.append(arg) |
|
remaining_args.append(arg) |
|
|
|
kwargs['packages'] = remaining_args |
|
vapi_args = ret + self._vapi_args_to_command('--pkg=', 'packages', kwargs, accept_vapi=True) |
|
return vapi_args, vapi_depends, vapi_packages, vapi_includes |
|
|
|
def _generate_deps(self, state, library, packages, install_dir): |
|
outdir = state.environment.scratch_dir |
|
fname = os.path.join(outdir, library + '.deps') |
|
with open(fname, 'w') as ofile: |
|
for package in packages: |
|
ofile.write(package + '\n') |
|
return build.Data(mesonlib.File(True, outdir, fname), install_dir) |
|
|
|
def _get_vapi_link_with(self, target): |
|
link_with = [] |
|
for dep in target.get_target_dependencies(): |
|
if isinstance(dep, build.SharedLibrary): |
|
link_with.append(dep) |
|
elif isinstance(dep, GirTarget): |
|
link_with += self._get_vapi_link_with(dep) |
|
return link_with |
|
|
|
@permittedKwargs({'sources', 'packages', 'metadata_dirs', 'gir_dirs', |
|
'vapi_dirs', 'install', 'install_dir'}) |
|
def generate_vapi(self, state, args, kwargs): |
|
if len(args) != 1: |
|
raise MesonException('The library name is required') |
|
|
|
if not isinstance(args[0], str): |
|
raise MesonException('The first argument must be the name of the library') |
|
created_values = [] |
|
|
|
library = args[0] |
|
build_dir = os.path.join(state.environment.get_build_dir(), state.subdir) |
|
source_dir = os.path.join(state.environment.get_source_dir(), state.subdir) |
|
pkg_cmd, vapi_depends, vapi_packages, vapi_includes = self._extract_vapi_packages(state, kwargs) |
|
target_name = 'generate_vapi({})'.format(library) |
|
if 'VAPIGEN' in os.environ: |
|
cmd = [find_program(os.environ['VAPIGEN'], target_name)] |
|
else: |
|
cmd = [find_program('vapigen', target_name)] |
|
cmd += ['--quiet', '--library=' + library, '--directory=' + build_dir] |
|
cmd += self._vapi_args_to_command('--vapidir=', 'vapi_dirs', kwargs) |
|
cmd += self._vapi_args_to_command('--metadatadir=', 'metadata_dirs', kwargs) |
|
cmd += self._vapi_args_to_command('--girdir=', 'gir_dirs', kwargs) |
|
cmd += pkg_cmd |
|
cmd += ['--metadatadir=' + source_dir] |
|
|
|
if 'sources' not in kwargs: |
|
raise MesonException('sources are required to generate the vapi file') |
|
|
|
inputs = mesonlib.extract_as_list(kwargs, 'sources') |
|
|
|
link_with = [] |
|
for i in inputs: |
|
if isinstance(i, str): |
|
cmd.append(os.path.join(source_dir, i)) |
|
elif hasattr(i, 'held_object') and isinstance(i.held_object, GirTarget): |
|
link_with += self._get_vapi_link_with(i.held_object) |
|
subdir = os.path.join(state.environment.get_build_dir(), |
|
i.held_object.get_subdir()) |
|
gir_file = os.path.join(subdir, i.held_object.get_outputs()[0]) |
|
cmd.append(gir_file) |
|
else: |
|
raise MesonException('Input must be a str or GirTarget') |
|
|
|
vapi_output = library + '.vapi' |
|
custom_kwargs = { |
|
'command': cmd, |
|
'input': inputs, |
|
'output': vapi_output, |
|
'depends': vapi_depends, |
|
} |
|
install_dir = kwargs.get('install_dir', |
|
os.path.join(state.environment.coredata.get_builtin_option('datadir'), |
|
'vala', 'vapi')) |
|
if kwargs.get('install'): |
|
custom_kwargs['install'] = kwargs['install'] |
|
custom_kwargs['install_dir'] = install_dir |
|
|
|
# We shouldn't need this locally but we install it |
|
deps_target = self._generate_deps(state, library, vapi_packages, install_dir) |
|
created_values.append(deps_target) |
|
vapi_target = VapiTarget(vapi_output, state.subdir, state.subproject, custom_kwargs) |
|
|
|
# So to try our best to get this to just work we need: |
|
# - link with with the correct library |
|
# - include the vapi and dependent vapi files in sources |
|
# - add relevant directories to include dirs |
|
incs = [build.IncludeDirs(state.subdir, ['.'] + vapi_includes, False)] |
|
sources = [vapi_target] + vapi_depends |
|
rv = InternalDependency(None, incs, [], [], link_with, sources, []) |
|
created_values.append(rv) |
|
return ModuleReturnValue(rv, created_values) |
|
|
|
def initialize(): |
|
return GnomeModule()
|
|
|