mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-23 12:51:06 +00:00
3859 lines
114 KiB
Python
3859 lines
114 KiB
Python
# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
|
|
# vim: set filetype=python:
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
# App-specific project settings
|
|
|
|
|
|
project_flag(
|
|
env="MOZ_APP_ID",
|
|
nargs=1,
|
|
help='used for application.ini\'s "ID" field, and crash reporter server url',
|
|
)
|
|
|
|
|
|
@depends("MOZ_APP_ID", build_project)
|
|
def check_moz_app_id(moz_app_id, build_project):
|
|
if not moz_app_id:
|
|
die(f"No value for MOZ_APP_ID in project '{build_project}'")
|
|
|
|
|
|
project_flag(
|
|
env="MOZ_APP_VENDOR",
|
|
nargs=1,
|
|
help='used for application.ini\'s "Vendor" field, which also impacts profile location and user-visible fields',
|
|
)
|
|
|
|
project_flag(
|
|
env="MOZ_APP_UA_NAME",
|
|
default="",
|
|
nargs=1,
|
|
help="application name in the User Agent string",
|
|
)
|
|
|
|
project_flag(
|
|
env="MOZ_DEVTOOLS",
|
|
default="server",
|
|
choices=("all", "server"),
|
|
nargs=1,
|
|
help="which devtools version should be built",
|
|
)
|
|
|
|
|
|
option(
|
|
env="MOZ_STUB_INSTALLER",
|
|
help="produce a stub installer",
|
|
)
|
|
set_config("MOZ_STUB_INSTALLER", True, when="MOZ_STUB_INSTALLER")
|
|
|
|
|
|
project_flag(
|
|
env="MOZ_PROFILE_MIGRATOR",
|
|
help="enable profile migrator",
|
|
)
|
|
|
|
project_flag(
|
|
env="BROWSER_CHROME_URL",
|
|
default="",
|
|
nargs=1,
|
|
set_as_define=True,
|
|
help="markup for a single browser window",
|
|
)
|
|
set_define(
|
|
"BROWSER_CHROME_URL_QUOTED",
|
|
depends("BROWSER_CHROME_URL")(lambda v: f'"{v[0]}"' if v else ""),
|
|
)
|
|
|
|
# External builds (specifically Ubuntu) may drop the hg repo information, so we allow to
|
|
# explicitly set the repository and changeset information in.
|
|
option(env="MOZ_SOURCE_REPO", nargs=1, help="project source repository")
|
|
set_config("MOZ_SOURCE_REPO", depends_if("MOZ_SOURCE_REPO")(lambda src: src[0]))
|
|
option(env="MOZ_SOURCE_CHANGESET", nargs=1, help="source changeset")
|
|
set_config("MOZ_SOURCE_CHANGESET", depends_if("MOZ_SOURCE_CHANGESET")(lambda v: v[0]))
|
|
|
|
option(
|
|
env="MOZ_INCLUDE_SOURCE_INFO",
|
|
# Build revisions should always be present in official builds
|
|
default=mozilla_official,
|
|
help="include build repository informations",
|
|
)
|
|
set_config("MOZ_INCLUDE_SOURCE_INFO", True, when="MOZ_INCLUDE_SOURCE_INFO")
|
|
|
|
option(
|
|
"--with-distribution-id",
|
|
nargs=1,
|
|
default="org.mozilla",
|
|
help="Set distribution-specific id",
|
|
)
|
|
set_config("MOZ_DISTRIBUTION_ID", depends("--with-distribution-id")(lambda v: v[0]))
|
|
add_old_configure_assignment(
|
|
"MOZ_DISTRIBUTION_ID", depends("--with-distribution-id")(lambda v: v[0])
|
|
)
|
|
|
|
|
|
@depends("MOZ_APP_VENDOR", build_project)
|
|
def check_moz_app_vendor(moz_app_vendor, build_project):
|
|
if not moz_app_vendor:
|
|
die(f"No value for MOZ_APP_VENDOR in project '{build_project}'")
|
|
|
|
|
|
# Set the MOZ_CONFIGURE_OPTIONS variable with all the options that
|
|
# were passed somehow (environment, command line, mozconfig)
|
|
@dependable
|
|
@imports(_from="mozbuild.shellutil", _import="quote")
|
|
@imports(_from="mozbuild.util", _import="ensure_unicode")
|
|
@imports(_from="mozbuild.util", _import="system_encoding")
|
|
@imports("__sandbox__")
|
|
def all_configure_options():
|
|
result = []
|
|
previous = None
|
|
for option in __sandbox__._options.values():
|
|
# __sandbox__._options contains items for both option.name and
|
|
# option.env. But it's also an OrderedDict, meaning both are
|
|
# consecutive.
|
|
# Also ignore OLD_CONFIGURE and MOZCONFIG because they're not
|
|
# interesting.
|
|
if option == previous or option.env in ("OLD_CONFIGURE", "MOZCONFIG"):
|
|
continue
|
|
previous = option
|
|
value = __sandbox__._value_for(option)
|
|
# We only want options that were explicitly given on the command
|
|
# line, the environment, or mozconfig, and that differ from the
|
|
# defaults.
|
|
if (
|
|
value is not None
|
|
and value.origin not in ("default", "implied")
|
|
and value != option.default
|
|
):
|
|
result.append(
|
|
ensure_unicode(__sandbox__._raw_options[option], system_encoding)
|
|
)
|
|
# We however always include options that are sent to old configure
|
|
# because we don't know their actual defaults. (Keep the conditions
|
|
# separate for ease of understanding and ease of removal)
|
|
elif (
|
|
option.help == "Help missing for old configure options"
|
|
and option in __sandbox__._raw_options
|
|
):
|
|
result.append(
|
|
ensure_unicode(__sandbox__._raw_options[option], system_encoding)
|
|
)
|
|
|
|
# We shouldn't need this, but currently, quote will return a byte string
|
|
# if result is empty, and that's not wanted here.
|
|
if not result:
|
|
return ""
|
|
|
|
return quote(*result)
|
|
|
|
|
|
set_config("MOZ_CONFIGURE_OPTIONS", all_configure_options)
|
|
|
|
|
|
@depends(target)
|
|
def fold_libs(target):
|
|
return target.os in ("WINNT", "OSX", "iOS", "Android")
|
|
|
|
|
|
set_config("MOZ_FOLD_LIBS", fold_libs)
|
|
|
|
# Profiling
|
|
# ==============================================================
|
|
# Some of the options here imply an option from js/moz.configure,
|
|
# so, need to be declared before the include.
|
|
|
|
option("--disable-gecko-profiler", help="Disable the Gecko profiler")
|
|
|
|
|
|
@depends("--disable-gecko-profiler", target)
|
|
def gecko_profiler(enable_gecko_profiler, target):
|
|
if not enable_gecko_profiler:
|
|
return False
|
|
|
|
if target.os == "Android":
|
|
return target.cpu in ("aarch64", "arm", "x86", "x86_64")
|
|
elif target.kernel == "Linux":
|
|
return target.cpu in ("aarch64", "arm", "x86", "x86_64", "mips64")
|
|
elif target.kernel == "FreeBSD":
|
|
return target.cpu in ("aarch64", "x86_64")
|
|
return target.kernel in ("Darwin", "WINNT")
|
|
|
|
|
|
@depends(gecko_profiler)
|
|
def gecko_profiler_define(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_GECKO_PROFILER", gecko_profiler_define)
|
|
set_define("MOZ_GECKO_PROFILER", gecko_profiler_define)
|
|
|
|
|
|
# Enable perfetto on Android if gecko profiling is enabled and only for
|
|
# nightly builds. Linux support requires at least linux-headers-3.18 for <linux/vm_sockets.h>
|
|
set_config(
|
|
"MOZ_PERFETTO", gecko_profiler_define, when=target_is_android & milestone.is_nightly
|
|
)
|
|
set_define(
|
|
"MOZ_PERFETTO", gecko_profiler_define, when=target_is_android & milestone.is_nightly
|
|
)
|
|
|
|
|
|
# Whether code to parse ELF binaries should be compiled for the Gecko profiler
|
|
# (for symbol table dumping).
|
|
@depends(gecko_profiler, target)
|
|
def gecko_profiler_parse_elf(value, target):
|
|
# Currently we only want to build this code on Linux (including Android) and BSD.
|
|
# For Android, this is in order to dump symbols from Android system, where
|
|
# on other platforms there exist alternatives that don't require bloating
|
|
# up our binary size. For Linux more generally, we use this in profile
|
|
# pre-symbolication support, since MozDescribeCodeAddress doesn't do
|
|
# anything useful on that platform. (Ideally, we would update
|
|
# MozDescribeCodeAddress to call into some Rust crates that parse ELF and
|
|
# DWARF data, but build system issues currently prevent Rust from being
|
|
# used in mozglue.)
|
|
if value and (target.kernel == "Linux" or target.kernel == "FreeBSD"):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_GECKO_PROFILER_PARSE_ELF", gecko_profiler_parse_elf)
|
|
set_define("MOZ_GECKO_PROFILER_PARSE_ELF", gecko_profiler_parse_elf)
|
|
|
|
# enable this by default if the profiler is enabled
|
|
# Note: also requires jemalloc
|
|
set_config("MOZ_PROFILER_MEMORY", gecko_profiler_define)
|
|
set_define("MOZ_PROFILER_MEMORY", gecko_profiler_define)
|
|
|
|
|
|
@depends(
|
|
"--enable-debug",
|
|
milestone,
|
|
build_project,
|
|
# Artifact builds are included because the downloaded artifacts can
|
|
# have DMD enabled.
|
|
when=artifact_builds | depends(when="--enable-replace-malloc")(lambda: True),
|
|
)
|
|
def dmd_default(debug, milestone, build_project):
|
|
return bool(build_project == "browser" and (debug or milestone.is_nightly))
|
|
|
|
|
|
option(
|
|
"--enable-dmd",
|
|
env="MOZ_DMD",
|
|
default=dmd_default,
|
|
help="{Enable|Disable} Dark Matter Detector (heap profiler). "
|
|
"Also enables jemalloc, replace-malloc and profiling",
|
|
)
|
|
|
|
|
|
@depends("--enable-dmd")
|
|
def dmd(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_DMD", dmd)
|
|
set_define("MOZ_DMD", dmd)
|
|
imply_option("--enable-profiling", dmd)
|
|
imply_option("--enable-jemalloc", dmd, when=compile_environment)
|
|
imply_option("--enable-replace-malloc", dmd, when=compile_environment)
|
|
|
|
|
|
# midir-based Web MIDI support
|
|
# ==============================================================
|
|
@depends(target)
|
|
def midir_linux_support(target):
|
|
return (
|
|
target.kernel == "Linux" and target.os != "Android" and target.cpu != "riscv64"
|
|
)
|
|
|
|
|
|
@depends(target, midir_linux_support)
|
|
def midir_support(target, midir_linux_support):
|
|
if target.os in ("WINNT", "OSX") or midir_linux_support:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_WEBMIDI_MIDIR_IMPL", midir_support)
|
|
|
|
|
|
# Enable various cubeb backends
|
|
# ==============================================================
|
|
@depends(target)
|
|
def audio_backends_default(target):
|
|
if target.os == "Android":
|
|
return (
|
|
"aaudio",
|
|
"opensl",
|
|
)
|
|
elif target.os in ("DragonFly", "FreeBSD", "SunOS"):
|
|
return ("oss",)
|
|
elif target.os == "OpenBSD":
|
|
return ("sndio",)
|
|
elif target.kernel == "Darwin":
|
|
return ("audiounit",)
|
|
elif target.os == "NetBSD":
|
|
return ("sunaudio",)
|
|
elif target.os == "SunOS":
|
|
return ("sunaudio",)
|
|
elif target.os == "WINNT":
|
|
return ("wasapi",)
|
|
else:
|
|
return ("pulseaudio",)
|
|
|
|
|
|
option(
|
|
"--enable-audio-backends",
|
|
nargs="+",
|
|
choices=(
|
|
"aaudio",
|
|
"alsa",
|
|
"audiounit",
|
|
"jack",
|
|
"opensl",
|
|
"oss",
|
|
"pulseaudio",
|
|
"sndio",
|
|
"sunaudio",
|
|
"wasapi",
|
|
),
|
|
default=audio_backends_default,
|
|
help="{Enable|Disable} various cubeb backends",
|
|
)
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_aaudio(values, target):
|
|
if any("aaudio" in value for value in values) and target.os != "Android":
|
|
die("Cannot enable AAudio on %s", target.os)
|
|
return any("aaudio" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_alsa(values, target):
|
|
if (
|
|
any("alsa" in value for value in values)
|
|
and target.kernel != "Linux"
|
|
and target.os != "FreeBSD"
|
|
):
|
|
die("Cannot enable ALSA on %s", target.os)
|
|
return any("alsa" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_audiounit(values, target):
|
|
if any("audiounit" in value for value in values) and target.kernel != "Darwin":
|
|
die("Cannot enable AudioUnit on %s", target.os)
|
|
return any("audiounit" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends")
|
|
def imply_jack(values):
|
|
return any("jack" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_opensl(values, target):
|
|
if any("opensl" in value for value in values) and target.os != "Android":
|
|
die("Cannot enable OpenSL on %s", target.os)
|
|
return any("opensl" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_oss(values, target):
|
|
if any("oss" in value for value in values) and (
|
|
target.os in ("Android", "OSX", "iOS", "WINNT")
|
|
):
|
|
die("Cannot enable OSS on %s", target.os)
|
|
return any("oss" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_pulseaudio(values, target):
|
|
if any("pulseaudio" in value for value in values) and (
|
|
target.os in ("Android", "OSX", "iOS", "WINNT")
|
|
):
|
|
die("Cannot enable PulseAudio on %s", target.os)
|
|
return any("pulseaudio" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_sndio(values, target):
|
|
if any("sndio" in value for value in values) and (
|
|
target.os in ("Android", "OSX", "iOS", "WINNT")
|
|
):
|
|
die("Cannot enable sndio on %s", target.os)
|
|
return any("sndio" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_sunaudio(values, target):
|
|
if any("sunaudio" in value for value in values) and (
|
|
target.os != "NetBSD" and target.os != "SunOS"
|
|
):
|
|
die("Cannot enable sunaudio on %s", target.os)
|
|
return any("sunaudio" in value for value in values) or None
|
|
|
|
|
|
@depends("--enable-audio-backends", target)
|
|
def imply_wasapi(values, target):
|
|
if any("wasapi" in value for value in values) and target.os != "WINNT":
|
|
die("Cannot enable WASAPI on %s", target.os)
|
|
return any("wasapi" in value for value in values) or None
|
|
|
|
|
|
set_config("MOZ_AAUDIO", imply_aaudio, when="--enable-audio-backends")
|
|
|
|
imply_option(
|
|
"--enable-alsa", imply_alsa, reason="--enable-audio-backends", when=use_pkg_config
|
|
)
|
|
|
|
set_config("MOZ_AUDIOUNIT_RUST", imply_audiounit, when="--enable-audio-backends")
|
|
|
|
imply_option(
|
|
"--enable-jack", imply_jack, reason="--enable-audio-backends", when=use_pkg_config
|
|
)
|
|
|
|
set_config("MOZ_OPENSL", imply_opensl, when="--enable-audio-backends")
|
|
|
|
set_config("MOZ_OSS", imply_oss, when="--enable-audio-backends")
|
|
|
|
imply_option(
|
|
"--enable-pulseaudio",
|
|
imply_pulseaudio,
|
|
reason="--enable-audio-backends",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
imply_option(
|
|
"--enable-sndio", imply_sndio, reason="--enable-audio-backends", when=use_pkg_config
|
|
)
|
|
|
|
set_config("MOZ_SUNAUDIO", imply_sunaudio, when="--enable-audio-backends")
|
|
|
|
set_config("MOZ_WASAPI", imply_wasapi, when="--enable-audio-backends")
|
|
|
|
# ALSA cubeb backend
|
|
# ==============================================================
|
|
option(
|
|
"--enable-alsa",
|
|
env="MOZ_ALSA",
|
|
help="Enable ALSA audio backend.",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
|
|
@depends("--enable-alsa", when=use_pkg_config)
|
|
def enable_alsa_option(enable_alsa):
|
|
return enable_alsa
|
|
|
|
|
|
@depends(enable_alsa_option, midir_linux_support)
|
|
def enable_alsa_or_midir_linux_support(alsa_enabled, midir_linux_support):
|
|
return alsa_enabled or midir_linux_support
|
|
|
|
|
|
pkg_check_modules("MOZ_ALSA", "alsa", when=enable_alsa_or_midir_linux_support)
|
|
|
|
set_config("MOZ_ALSA", True, when="--enable-alsa")
|
|
set_define("MOZ_ALSA", True, when="--enable-alsa")
|
|
|
|
# JACK cubeb backend
|
|
# ==============================================================
|
|
system_lib_option(
|
|
"--enable-jack",
|
|
env="MOZ_JACK",
|
|
help="Enable JACK audio backend.",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
jack = pkg_check_modules("MOZ_JACK", "jack", when="--enable-jack")
|
|
|
|
set_config("MOZ_JACK", depends_if(jack)(lambda _: True))
|
|
|
|
# PulseAudio cubeb backend
|
|
# ==============================================================
|
|
option(
|
|
"--enable-pulseaudio",
|
|
env="MOZ_PULSEAUDIO",
|
|
help="{Enable|Disable} PulseAudio audio backend.",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
pulseaudio = pkg_check_modules("MOZ_PULSEAUDIO", "libpulse", when="--enable-pulseaudio")
|
|
|
|
set_config("MOZ_PULSEAUDIO", depends_if(pulseaudio)(lambda _: True))
|
|
set_define("MOZ_PULSEAUDIO", depends_if(pulseaudio)(lambda _: True))
|
|
|
|
# sndio cubeb backend
|
|
# ==============================================================
|
|
system_lib_option(
|
|
"--enable-sndio",
|
|
env="MOZ_SNDIO",
|
|
help="Enable sndio audio backend.",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
sndio = pkg_check_modules("MOZ_SNDIO", "sndio", when="--enable-sndio")
|
|
|
|
set_config("MOZ_SNDIO", depends_if(sndio)(lambda _: True))
|
|
|
|
# Javascript engine
|
|
# ==============================================================
|
|
include("../js/moz.configure")
|
|
|
|
|
|
# NodeJS
|
|
# ==============================================================
|
|
include("../build/moz.configure/node.configure")
|
|
|
|
# JsonCpp
|
|
# ==============================================================
|
|
set_define("JSON_USE_EXCEPTION", 0)
|
|
|
|
# L10N
|
|
# ==============================================================
|
|
option("--with-l10n-base", nargs=1, env="L10NBASEDIR", help="Path to l10n repositories")
|
|
|
|
|
|
@depends("--with-l10n-base", "MOZ_AUTOMATION", build_environment)
|
|
@imports(_from="os.path", _import="isdir")
|
|
@imports(_from="os.path", _import="expanduser")
|
|
@imports(_from="os", _import="environ")
|
|
def l10n_base(value, automation, build_env):
|
|
if value:
|
|
path = value[0]
|
|
if not isdir(path):
|
|
die("Invalid value --with-l10n-base, %s doesn't exist", path)
|
|
elif automation:
|
|
path = os.path.join(build_env.topsrcdir, "../l10n-central")
|
|
else:
|
|
path = os.path.join(
|
|
environ.get(
|
|
"MOZBUILD_STATE_PATH", expanduser(os.path.join("~", ".mozbuild"))
|
|
),
|
|
"l10n-central",
|
|
)
|
|
return os.path.realpath(os.path.abspath(path))
|
|
|
|
|
|
set_config("L10NBASEDIR", l10n_base)
|
|
|
|
|
|
# Default toolkit
|
|
# ==============================================================
|
|
@depends(target)
|
|
def toolkit_choices(target):
|
|
if target.os == "WINNT":
|
|
return ("cairo-windows",)
|
|
elif target.os == "OSX":
|
|
return ("cairo-cocoa",)
|
|
elif target.os == "iOS":
|
|
return ("cairo-uikit",)
|
|
elif target.os == "Android":
|
|
return ("cairo-android",)
|
|
else:
|
|
# cairo-gtk3 - X11 backend with optional Wayland backend (auto detected)
|
|
# cairo-gtk3-wayland - Wayland backend with optional X11 backend (auto detected)
|
|
# cairo-gtk3-x11-wayland - builds explicitly with X11 & Wayland backends
|
|
return (
|
|
"cairo-gtk3",
|
|
"cairo-gtk3-wayland",
|
|
"cairo-gtk3-x11-wayland",
|
|
"cairo-gtk3-wayland-only",
|
|
"cairo-gtk3-x11-only",
|
|
)
|
|
|
|
|
|
@depends(toolkit_choices)
|
|
def toolkit_default(choices):
|
|
return choices[0]
|
|
|
|
|
|
option(
|
|
"--enable-default-toolkit",
|
|
nargs=1,
|
|
choices=toolkit_choices,
|
|
default=toolkit_default,
|
|
help="Select default toolkit",
|
|
)
|
|
|
|
|
|
@depends("--enable-default-toolkit")
|
|
def full_toolkit(value):
|
|
if value:
|
|
return value[0]
|
|
|
|
|
|
@depends(full_toolkit)
|
|
def toolkit(toolkit):
|
|
if toolkit.startswith("cairo-gtk3"):
|
|
widget_toolkit = "gtk"
|
|
else:
|
|
widget_toolkit = toolkit.replace("cairo-", "")
|
|
return widget_toolkit
|
|
|
|
|
|
set_config("MOZ_WIDGET_TOOLKIT", toolkit)
|
|
|
|
|
|
@depends(toolkit)
|
|
def toolkit_define(toolkit):
|
|
if toolkit != "windows":
|
|
return "MOZ_WIDGET_%s" % toolkit.upper()
|
|
|
|
|
|
set_define(toolkit_define, True)
|
|
|
|
|
|
@depends(toolkit)
|
|
def toolkit_gtk(toolkit):
|
|
return toolkit == "gtk"
|
|
|
|
|
|
@depends(toolkit_gtk, full_toolkit)
|
|
def toolkit_gtk_x11(toolkit_gtk, full_toolkit):
|
|
return toolkit_gtk and full_toolkit != "cairo-gtk3-wayland-only"
|
|
|
|
|
|
@depends(full_toolkit)
|
|
def toolkit_gtk_x11_optional(full_toolkit):
|
|
return full_toolkit == "cairo-gtk3-wayland"
|
|
|
|
|
|
@depends(toolkit_gtk, full_toolkit)
|
|
def toolkit_gtk_wayland(toolkit_gtk, full_toolkit):
|
|
return toolkit_gtk and full_toolkit != "cairo-gtk3-x11-only"
|
|
|
|
|
|
@depends(full_toolkit)
|
|
def toolkit_gtk_wayland_optional(full_toolkit):
|
|
return full_toolkit == "cairo-gtk3"
|
|
|
|
|
|
# Wayland support
|
|
# ==============================================================
|
|
wayland_headers = pkg_check_modules(
|
|
"MOZ_WAYLAND",
|
|
"gtk+-wayland-3.0 >= 3.14 xkbcommon >= 0.4.1",
|
|
allow_missing=toolkit_gtk_wayland_optional,
|
|
when=toolkit_gtk_wayland,
|
|
)
|
|
|
|
|
|
@depends(wayland_headers, toolkit_gtk, artifact_builds, toolkit_gtk_wayland)
|
|
def wayland_headers(wayland, toolkit_gtk, artifacts, toolkit_gtk_wayland):
|
|
if not toolkit_gtk_wayland:
|
|
return False
|
|
if toolkit_gtk and artifacts:
|
|
return True
|
|
return wayland
|
|
|
|
|
|
set_config("MOZ_WAYLAND", depends_if(wayland_headers)(lambda _: True))
|
|
set_define("MOZ_WAYLAND", depends_if(wayland_headers)(lambda _: True))
|
|
|
|
|
|
# Hardware-accelerated video decode with VAAPI and V4L2 on Linux
|
|
# ==============================================================
|
|
set_config("MOZ_ENABLE_VAAPI", True, when=toolkit_gtk)
|
|
set_define("MOZ_ENABLE_VAAPI", True, when=toolkit_gtk)
|
|
|
|
|
|
@depends(target, toolkit_gtk)
|
|
def v4l2(target, toolkit_gtk):
|
|
# V4L2 decode is only used in GTK/Linux and generally only appears on
|
|
# embedded SOCs.
|
|
if target.cpu in ("arm", "aarch64", "riscv64") and toolkit_gtk:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_ENABLE_V4L2", True, when=v4l2)
|
|
set_define("MOZ_ENABLE_V4L2", True, when=v4l2)
|
|
|
|
# GL Provider
|
|
# ==============================================================
|
|
option("--with-gl-provider", nargs=1, help="Set GL provider backend type")
|
|
|
|
|
|
@depends("--with-gl-provider")
|
|
def gl_provider(value):
|
|
if value:
|
|
return value[0]
|
|
|
|
|
|
@depends(gl_provider)
|
|
def gl_provider_define(provider):
|
|
if provider:
|
|
return "GLContextProvider%s" % provider
|
|
|
|
|
|
set_define("MOZ_GL_PROVIDER", gl_provider_define)
|
|
|
|
|
|
@depends(gl_provider, toolkit_gtk)
|
|
def gl_default_provider(value, toolkit_gtk):
|
|
if value:
|
|
return value
|
|
elif toolkit_gtk:
|
|
return "EGL"
|
|
|
|
|
|
set_config("MOZ_GL_PROVIDER", gl_provider)
|
|
set_config("MOZ_GL_DEFAULT_PROVIDER", gl_default_provider)
|
|
|
|
|
|
@depends(gl_default_provider)
|
|
def gl_provider_define(provider):
|
|
if provider:
|
|
return "GL_PROVIDER_%s" % provider
|
|
|
|
|
|
set_define(gl_provider_define, True)
|
|
|
|
|
|
# PDF printing
|
|
# ==============================================================
|
|
@depends(toolkit)
|
|
def pdf_printing(toolkit):
|
|
if toolkit in ("windows", "gtk", "android"):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_PDF_PRINTING", pdf_printing)
|
|
set_define("MOZ_PDF_PRINTING", pdf_printing)
|
|
|
|
# Fontconfig Freetype
|
|
# ==============================================================
|
|
option(env="USE_FC_FREETYPE", help="Force-enable the use of fontconfig freetype")
|
|
|
|
|
|
@depends("USE_FC_FREETYPE", toolkit)
|
|
def fc_freetype(value, toolkit):
|
|
if value or (toolkit == "gtk" and value.origin == "default"):
|
|
return True
|
|
|
|
|
|
set_define("USE_FC_FREETYPE", fc_freetype)
|
|
|
|
# Pango
|
|
# ==============================================================
|
|
pkg_check_modules("MOZ_PANGO", "pango >= 1.22.0", when=toolkit_gtk)
|
|
|
|
# Fontconfig
|
|
# ==============================================================
|
|
fontconfig_info = pkg_check_modules(
|
|
"_FONTCONFIG", "fontconfig >= 2.7.0", when=fc_freetype
|
|
)
|
|
|
|
|
|
@depends(fc_freetype)
|
|
def check_for_freetype2(fc_freetype):
|
|
if fc_freetype:
|
|
return True
|
|
|
|
|
|
# Check for freetype2. Flags are combined with fontconfig flags.
|
|
freetype2_info = pkg_check_modules(
|
|
"_FT2", "freetype2 >= 9.10.3", when=check_for_freetype2
|
|
)
|
|
|
|
|
|
@depends(fontconfig_info, freetype2_info)
|
|
def freetype2_combined_info(fontconfig_info, freetype2_info):
|
|
if not freetype2_info:
|
|
return
|
|
if not fontconfig_info:
|
|
return freetype2_info
|
|
return namespace(
|
|
cflags=freetype2_info.cflags + fontconfig_info.cflags,
|
|
libs=freetype2_info.libs + fontconfig_info.libs,
|
|
)
|
|
|
|
|
|
set_define("MOZ_HAVE_FREETYPE2", depends_if(freetype2_info)(lambda _: True))
|
|
|
|
|
|
# Apple platform decoder support
|
|
# ==============================================================
|
|
@depends(toolkit)
|
|
def applemedia(toolkit):
|
|
if toolkit in ("cocoa", "uikit"):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_APPLEMEDIA", applemedia)
|
|
set_define("MOZ_APPLEMEDIA", applemedia)
|
|
|
|
# Windows Media Foundation support
|
|
# ==============================================================
|
|
option("--disable-wmf", help="Disable support for Windows Media Foundation")
|
|
|
|
|
|
@depends("--disable-wmf", target, "--help")
|
|
def wmf(value, target, _):
|
|
enabled = bool(value)
|
|
if value.origin == "default":
|
|
# Enable Windows Media Foundation support by default.
|
|
# Note our minimum SDK version is Windows 7 SDK, so we are (currently)
|
|
# guaranteed to have a recent-enough SDK to build WMF.
|
|
enabled = target.os == "WINNT"
|
|
if enabled and target.os != "WINNT":
|
|
die("Cannot enable Windows Media Foundation support on %s", target.os)
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
@depends(artifact_builds, c_compiler, when=wmf)
|
|
def wmfmediaengine(artifact_builds, c_compiler):
|
|
if c_compiler:
|
|
return c_compiler.type == "clang-cl"
|
|
return bool(artifact_builds)
|
|
|
|
|
|
set_config("MOZ_WMF", wmf)
|
|
set_define("MOZ_WMF", wmf)
|
|
|
|
set_config("MOZ_WMF_MEDIA_ENGINE", True, when=wmfmediaengine)
|
|
set_define("MOZ_WMF_MEDIA_ENGINE", True, when=wmfmediaengine)
|
|
|
|
# FFmpeg H264/AAC Decoding Support
|
|
# ==============================================================
|
|
option("--disable-ffmpeg", help="Disable FFmpeg for fragmented H264/AAC decoding")
|
|
|
|
|
|
@depends("--disable-ffmpeg", target)
|
|
def ffmpeg(value, target):
|
|
enabled = bool(value)
|
|
if value.origin == "default":
|
|
enabled = target.os not in ("Android", "WINNT")
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_FFMPEG", ffmpeg)
|
|
set_define("MOZ_FFMPEG", ffmpeg)
|
|
|
|
# AV1 Video Codec Support
|
|
# ==============================================================
|
|
option("--disable-av1", help="Disable av1 video support")
|
|
|
|
|
|
@depends("--enable-av1")
|
|
def av1(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
@depends(target, when=av1 & compile_environment)
|
|
def dav1d_asm(target):
|
|
if target.cpu in ("arm", "aarch64", "x86", "x86_64"):
|
|
return True
|
|
|
|
|
|
@depends(target, when=av1 & compile_environment)
|
|
def dav1d_nasm(target):
|
|
if target.cpu in ("x86", "x86_64"):
|
|
return namespace(version="2.14", what="AV1")
|
|
|
|
|
|
set_config("MOZ_DAV1D_ASM", dav1d_asm)
|
|
set_define("MOZ_DAV1D_ASM", dav1d_asm)
|
|
set_config("MOZ_AV1", av1)
|
|
set_define("MOZ_AV1", av1)
|
|
|
|
# JXL Image Codec Support
|
|
# ==============================================================
|
|
option("--disable-jxl", help="Disable jxl image support")
|
|
|
|
|
|
@depends("--disable-jxl", milestone.is_nightly)
|
|
def jxl(value, is_nightly):
|
|
if is_nightly and value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_JXL", jxl)
|
|
set_define("MOZ_JXL", jxl)
|
|
|
|
set_config("MOZ_SAMPLE_TYPE_FLOAT32", True)
|
|
set_define("MOZ_SAMPLE_TYPE_FLOAT32", True)
|
|
|
|
set_define("MOZ_VORBIS", True)
|
|
set_config("MOZ_VORBIS", True)
|
|
|
|
option(
|
|
"--disable-real-time-tracing",
|
|
help="Disable tracing of real-time audio callbacks",
|
|
)
|
|
|
|
set_config("MOZ_REAL_TIME_TRACING", True, when="--enable-real-time-tracing")
|
|
set_define("MOZ_REAL_TIME_TRACING", True, when="--enable-real-time-tracing")
|
|
|
|
# OpenMAX IL Decoding Support
|
|
# ==============================================================
|
|
option("--enable-openmax", help="Enable OpenMAX IL for video/audio decoding")
|
|
|
|
|
|
@depends("--enable-openmax")
|
|
def openmax(value):
|
|
enabled = bool(value)
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_OMX", openmax)
|
|
set_define("MOZ_OMX", openmax)
|
|
|
|
|
|
# EME Support
|
|
# ==============================================================
|
|
@depends(target, wmf)
|
|
def eme_choices(target, wmf):
|
|
if (
|
|
target.kernel in ("WINNT", "Linux")
|
|
and target.os != "Android"
|
|
and target.cpu in ("x86", "x86_64")
|
|
):
|
|
if wmf:
|
|
return ("widevine", "wmfcdm")
|
|
return ("widevine",)
|
|
if target.kernel == "WINNT" and target.cpu == "aarch64":
|
|
return ("widevine",)
|
|
if target.os in ("OSX"):
|
|
return ("widevine",)
|
|
|
|
|
|
# Widevine is enabled by default in desktop browser builds.
|
|
@depends(build_project, eme_choices)
|
|
def eme_default(build_project, choices):
|
|
if build_project == "browser":
|
|
return choices
|
|
|
|
|
|
option(
|
|
"--enable-eme",
|
|
nargs="+",
|
|
choices=eme_choices,
|
|
default=eme_default,
|
|
when=eme_choices,
|
|
help="{Enable|Disable} support for Encrypted Media Extensions",
|
|
)
|
|
|
|
|
|
@depends("--enable-eme", when=eme_choices)
|
|
def eme_modules(value):
|
|
return value
|
|
|
|
|
|
# Fallback to an empty list when eme_choices is empty, setting eme_modules to
|
|
# None.
|
|
set_config("MOZ_EME_MODULES", eme_modules | dependable([]))
|
|
|
|
|
|
# Media Foundation CDM support
|
|
# ==============================================================
|
|
@depends(eme_modules, when=wmfmediaengine)
|
|
def wmfcdm(modules):
|
|
if "wmfcdm" in modules:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_WMF_CDM", True, when=wmfcdm)
|
|
set_define("MOZ_WMF_CDM", True, when=wmfcdm)
|
|
|
|
|
|
option(
|
|
name="--enable-chrome-format",
|
|
help="Select FORMAT of chrome files during packaging.",
|
|
nargs=1,
|
|
choices=("omni", "jar", "flat"),
|
|
default="omni",
|
|
)
|
|
|
|
|
|
@depends("--enable-chrome-format")
|
|
def packager_format(value):
|
|
return value[0]
|
|
|
|
|
|
set_config("MOZ_PACKAGER_FORMAT", packager_format)
|
|
|
|
# The packager minifies two different types of files: non-JS (mostly property
|
|
# files for l10n), and JS. Setting MOZ_PACKAGER_MINIFY only minifies the
|
|
# former. Firefox doesn't yet minify JS, due to concerns about debuggability.
|
|
#
|
|
# Also, the JS minification setup really only works correctly on Android:
|
|
# we need extra setup to use the newly-built shell for Linux and Windows,
|
|
# and cross-compilation for macOS requires some extra care.
|
|
|
|
|
|
@depends(target_is_android, "--enable-debug", milestone.is_nightly)
|
|
def enable_minify_default(is_android, debug, is_nightly):
|
|
if is_android and not debug and not is_nightly:
|
|
return ("properties", "js")
|
|
return ("properties",)
|
|
|
|
|
|
option(
|
|
name="--enable-minify",
|
|
help="Select types of files to minify during packaging.",
|
|
nargs="*",
|
|
choices=("properties", "js"),
|
|
default=enable_minify_default,
|
|
)
|
|
|
|
|
|
@depends("--enable-minify")
|
|
def enable_minify(value):
|
|
if "js" in value and "properties" not in value:
|
|
die("--enable-minify=js requires --enable-minify=properties.")
|
|
return namespace(
|
|
properties="properties" in value,
|
|
js="js" in value,
|
|
)
|
|
|
|
|
|
set_config("MOZ_PACKAGER_MINIFY", True, when=enable_minify.properties)
|
|
set_config("MOZ_PACKAGER_MINIFY_JS", True, when=enable_minify.js)
|
|
|
|
|
|
@depends(host, build_project)
|
|
def jar_maker_format(host, build_project):
|
|
# Multilocales for mobile/android use the same mergedirs for all locales,
|
|
# so we can't use symlinks for those builds.
|
|
if host.os == "WINNT" or build_project == "mobile/android":
|
|
return "flat"
|
|
return "symlink"
|
|
|
|
|
|
set_config("MOZ_JAR_MAKER_FILE_FORMAT", jar_maker_format)
|
|
|
|
|
|
@depends(toolkit)
|
|
def omnijar_name(toolkit):
|
|
# Fennec's static resources live in the assets/ folder of the
|
|
# APK. Adding a path to the name here works because we only
|
|
# have one omnijar file in the final package (which is not the
|
|
# case on desktop).
|
|
return "assets/omni.ja" if toolkit == "android" else "omni.ja"
|
|
|
|
|
|
set_config("OMNIJAR_NAME", omnijar_name)
|
|
|
|
project_flag("MOZ_PLACES", help="Build Places if required", set_as_define=True)
|
|
|
|
project_flag(
|
|
"MOZ_SERVICES_HEALTHREPORT",
|
|
help="Build Firefox Health Reporter Service",
|
|
set_as_define=True,
|
|
)
|
|
|
|
project_flag(
|
|
"MOZ_NORMANDY",
|
|
help="Enable Normandy recipe runner",
|
|
set_as_define=True,
|
|
)
|
|
|
|
project_flag("MOZ_SERVICES_SYNC", help="Build Sync Services if required")
|
|
|
|
project_flag(
|
|
"MOZ_GECKOVIEW_HISTORY",
|
|
help="Enable Geckoview History instead of Places",
|
|
set_as_define=True,
|
|
)
|
|
|
|
|
|
# Child Process Name for IPC
|
|
# ==============================================================
|
|
@depends(toolkit, bin_suffix(target))
|
|
def moz_child_process_name(toolkit, bin_suffix):
|
|
if toolkit != "android":
|
|
return f"plugin-container{bin_suffix}"
|
|
else:
|
|
# We want to let Android unpack the file at install time, but it only
|
|
# does so if the file is named libsomething.so. The lib/ path is also
|
|
# required because the unpacked file will be under the lib/ subdirectory
|
|
# and will need to be executed from that path.
|
|
return "libplugin-container.so"
|
|
|
|
|
|
set_config("MOZ_CHILD_PROCESS_NAME", moz_child_process_name)
|
|
|
|
with only_when(target_is_osx):
|
|
set_config("MOZ_CHILD_PROCESS_BUNDLE", "plugin-container.app/Contents/MacOS/")
|
|
set_config(
|
|
"MOZ_CHILD_PROCESS_BUNDLEID",
|
|
depends("--with-distribution-id")(lambda v: f"{v[0]}.plugincontainer"),
|
|
)
|
|
set_config("MOZ_CHILD_PROCESS_BUNDLENAME", "plugin-container.app")
|
|
|
|
# Profile Management
|
|
# ==============================================================
|
|
# Selectable profiles are temporarily gated behind a build flag
|
|
# while we build and stabilize the backend (bug 1893315).
|
|
|
|
option(
|
|
env="MOZ_SELECTABLE_PROFILES",
|
|
help="Enable experimental and unstable profile groups",
|
|
)
|
|
|
|
set_define("MOZ_SELECTABLE_PROFILES", True, when="MOZ_SELECTABLE_PROFILES")
|
|
set_config("MOZ_SELECTABLE_PROFILES", True, when="MOZ_SELECTABLE_PROFILES")
|
|
|
|
project_flag(
|
|
"MOZ_DEDICATED_PROFILES",
|
|
help="Enable dedicated profiles per install",
|
|
set_as_define=True,
|
|
)
|
|
|
|
project_flag(
|
|
"MOZ_BLOCK_PROFILE_DOWNGRADE",
|
|
help="Block users from starting profiles last used by a newer build",
|
|
set_as_define=True,
|
|
)
|
|
|
|
|
|
@depends("MOZ_PLACES", "MOZ_GECKOVIEW_HISTORY")
|
|
def check_places_and_geckoview_history(places, geckoview_history):
|
|
if places and geckoview_history:
|
|
die("Cannot use MOZ_GECKOVIEW_HISTORY alongside MOZ_PLACES.")
|
|
if not places and not geckoview_history:
|
|
die("One of MOZ_GECKOVIEW_HISTORY or MOZ_PLACES must be set.")
|
|
|
|
|
|
option(
|
|
env="MOZ_TELEMETRY_REPORTING",
|
|
default=mozilla_official,
|
|
help="Enable telemetry reporting",
|
|
)
|
|
|
|
set_define("MOZ_TELEMETRY_REPORTING", True, when="MOZ_TELEMETRY_REPORTING")
|
|
|
|
|
|
@depends("MOZ_TELEMETRY_REPORTING", milestone.is_nightly)
|
|
def telemetry_on_by_default(reporting, is_nightly):
|
|
return reporting and is_nightly
|
|
|
|
|
|
set_define("MOZ_TELEMETRY_ON_BY_DEFAULT", True, when=telemetry_on_by_default)
|
|
|
|
|
|
# Miscellaneous programs
|
|
# ==============================================================
|
|
|
|
check_prog("TAR", ("gnutar", "gtar", "tar"))
|
|
check_prog("UNZIP", ("unzip",))
|
|
|
|
# Key files
|
|
# ==============================================================
|
|
include("../build/moz.configure/keyfiles.configure")
|
|
|
|
simple_keyfile("Mozilla API")
|
|
|
|
simple_keyfile("Google Location Service API")
|
|
|
|
simple_keyfile("Google Safebrowsing API")
|
|
|
|
id_and_secret_keyfile("Bing API")
|
|
|
|
simple_keyfile("Adjust SDK")
|
|
|
|
id_and_secret_keyfile("Leanplum SDK")
|
|
|
|
simple_keyfile("Pocket API")
|
|
|
|
|
|
# WebRender Debugger integration
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--enable-webrender-debugger", help="Build the websocket debug server in WebRender"
|
|
)
|
|
|
|
set_config(
|
|
"MOZ_WEBRENDER_DEBUGGER", depends_if("--enable-webrender-debugger")(lambda _: True)
|
|
)
|
|
|
|
# Additional system headers defined at the application level
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--enable-app-system-headers",
|
|
env="MOZ_APP_SYSTEM_HEADERS",
|
|
help="Use additional system headers defined in $MOZ_BUILD_APP/app-system-headers.mozbuild",
|
|
)
|
|
|
|
|
|
@depends("--enable-app-system-headers")
|
|
def app_system_headers(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_APP_SYSTEM_HEADERS", app_system_headers)
|
|
set_define("MOZ_APP_SYSTEM_HEADERS", app_system_headers)
|
|
|
|
|
|
# Printing
|
|
# ==============================================================
|
|
@depends(target)
|
|
def printing_default(target):
|
|
return target.os != "iOS"
|
|
|
|
|
|
option(
|
|
"--disable-printing",
|
|
default=printing_default,
|
|
help="{Enable|Disable} printing support",
|
|
)
|
|
|
|
|
|
@depends("--disable-printing")
|
|
def printing(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("NS_PRINTING", printing)
|
|
set_define("NS_PRINTING", printing)
|
|
set_define("NS_PRINT_PREVIEW", printing)
|
|
|
|
|
|
# Speech-dispatcher support
|
|
# ==============================================================
|
|
@depends(toolkit)
|
|
def no_speechd_on_non_gtk(toolkit):
|
|
if toolkit != "gtk":
|
|
return False
|
|
|
|
|
|
imply_option(
|
|
"--enable-synth-speechd", no_speechd_on_non_gtk, reason="--enable-default-toolkit"
|
|
)
|
|
|
|
option("--disable-synth-speechd", help="Disable speech-dispatcher support")
|
|
|
|
set_config("MOZ_SYNTH_SPEECHD", depends_if("--disable-synth-speechd")(lambda _: True))
|
|
|
|
# Speech API
|
|
# ==============================================================
|
|
option("--disable-webspeech", help="Disable support for HTML Speech API")
|
|
|
|
|
|
@depends("--disable-webspeech")
|
|
def webspeech(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_WEBSPEECH", webspeech)
|
|
set_define("MOZ_WEBSPEECH", webspeech)
|
|
|
|
# Speech API test backend
|
|
# ==============================================================
|
|
option(
|
|
"--enable-webspeechtestbackend",
|
|
default=webspeech,
|
|
help="{Enable|Disable} support for HTML Speech API Test Backend",
|
|
)
|
|
|
|
|
|
@depends_if("--enable-webspeechtestbackend")
|
|
def webspeech_test_backend(value):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_WEBSPEECH_TEST_BACKEND", webspeech_test_backend)
|
|
set_define("MOZ_WEBSPEECH_TEST_BACKEND", webspeech_test_backend)
|
|
|
|
|
|
# Graphics
|
|
# ==============================================================
|
|
@depends(target, milestone)
|
|
def skia_pdf_default(target, milestone):
|
|
return milestone.is_nightly and target.os != "WINNT"
|
|
|
|
|
|
option("--enable-skia-pdf", default=skia_pdf_default, help="{Enable|Disable} Skia PDF")
|
|
|
|
set_config("MOZ_ENABLE_SKIA_PDF", True, when="--enable-skia-pdf")
|
|
set_define("MOZ_ENABLE_SKIA_PDF", True, when="--enable-skia-pdf")
|
|
|
|
set_config(
|
|
"SKIA_INCLUDES",
|
|
[
|
|
"/gfx/skia",
|
|
"/gfx/skia/skia",
|
|
],
|
|
)
|
|
|
|
system_lib_option(
|
|
"--with-system-webp",
|
|
help="Use system libwebp (located with pkgconfig)",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
system_webp = pkg_check_modules(
|
|
"MOZ_WEBP", "libwebp >= 1.0.2 libwebpdemux >= 1.0.2", when="--with-system-webp"
|
|
)
|
|
|
|
set_config("MOZ_SYSTEM_WEBP", depends(when=system_webp)(lambda: True))
|
|
|
|
|
|
# Build Freetype in the tree
|
|
# ==============================================================
|
|
@depends(target, "--enable-skia-pdf")
|
|
def tree_freetype(target, skia_pdf):
|
|
if target.os == "Android" or (skia_pdf and target.os == "WINNT"):
|
|
return True
|
|
|
|
|
|
set_define("MOZ_TREE_FREETYPE", tree_freetype)
|
|
set_config("MOZ_TREE_FREETYPE", tree_freetype)
|
|
|
|
set_define("HAVE_FT_BITMAP_SIZE_Y_PPEM", tree_freetype)
|
|
set_define("HAVE_FT_GLYPHSLOT_EMBOLDEN", tree_freetype)
|
|
set_define("HAVE_FT_LOAD_SFNT_TABLE", tree_freetype)
|
|
|
|
|
|
@depends(freetype2_combined_info, tree_freetype, build_environment)
|
|
def ft2_info(freetype2_combined_info, tree_freetype, build_env):
|
|
if tree_freetype:
|
|
return namespace(
|
|
cflags=("-I%s/modules/freetype2/include" % build_env.topsrcdir,), libs=()
|
|
)
|
|
if freetype2_combined_info:
|
|
return freetype2_combined_info
|
|
|
|
|
|
set_config("FT2_LIBS", ft2_info.libs)
|
|
|
|
|
|
@depends(target, tree_freetype, freetype2_info)
|
|
def enable_cairo_ft(target, tree_freetype, freetype2_info):
|
|
# Avoid defining MOZ_ENABLE_CAIRO_FT on Windows platforms because
|
|
# "cairo-ft-font.c" includes <dlfcn.h>, which only exists on posix platforms
|
|
return freetype2_info or (tree_freetype and target.os != "WINNT")
|
|
|
|
|
|
set_config("MOZ_ENABLE_CAIRO_FT", True, when=enable_cairo_ft)
|
|
set_config("CAIRO_FT_CFLAGS", ft2_info.cflags, when=enable_cairo_ft)
|
|
|
|
|
|
# WebDriver (HTTP / BiDi)
|
|
# ==============================================================
|
|
#
|
|
# WebDriver is a remote control interface that enables introspection and
|
|
# control of user agents. It provides a platform- and language-neutral wire
|
|
# protocol as a way for out-of-process programs to remotely instruct the
|
|
# behavior of web browsers.
|
|
#
|
|
# The Gecko implementation is backed by Marionette and Remote Agent.
|
|
# Both protocols are not really toolkit features, as much as Gecko engine
|
|
# features. But they are enabled based on the toolkit, so here it lives.
|
|
#
|
|
# Marionette remote protocol
|
|
# -----------------------------------------------------------
|
|
#
|
|
# Marionette is the Gecko remote protocol used for various remote control,
|
|
# automation, and testing purposes throughout Gecko-based applications like
|
|
# Firefox, Thunderbird, and any mobile browser built upon GeckoView.
|
|
#
|
|
# It also backs ../testing/geckodriver, which is Mozilla's WebDriver
|
|
# implementation.
|
|
#
|
|
# The source of Marionette lives in ../remote/marionette.
|
|
#
|
|
# For more information, see:
|
|
# https://firefox-source-docs.mozilla.org/testing/marionette/index.html
|
|
#
|
|
# Remote Agent (WebDriver BiDi / partial CDP)
|
|
# -----------------------------------------------------------
|
|
#
|
|
# The primary purpose is the implementation of the WebDriver BiDi specification.
|
|
# But it also complements the existing Firefox Developer Tools Remote Debugging
|
|
# Protocol (RDP) by implementing a subset of the Chrome DevTools Protocol (CDP).
|
|
#
|
|
# The source of Remote Agent lives in ../remote.
|
|
#
|
|
# For more information, see:
|
|
# https://firefox-source-docs.mozilla.org/remote/index.html
|
|
|
|
|
|
option(
|
|
"--disable-webdriver",
|
|
help="Disable support for WebDriver remote protocols",
|
|
)
|
|
|
|
|
|
@depends("--disable-webdriver")
|
|
def webdriver(enabled):
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("ENABLE_WEBDRIVER", webdriver)
|
|
set_define("ENABLE_WEBDRIVER", webdriver)
|
|
|
|
|
|
# geckodriver WebDriver implementation
|
|
# ==============================================================
|
|
#
|
|
# Turn off geckodriver for build configs we don't handle yet,
|
|
# but allow --enable-geckodriver to override when compile environment is available.
|
|
# --disable-tests implies disabling geckodriver.
|
|
# Disable building in CI
|
|
|
|
|
|
@depends(
|
|
"--enable-tests", target, cross_compiling, hazard_analysis, asan, "MOZ_AUTOMATION"
|
|
)
|
|
def geckodriver_default(enable_tests, target, cross_compile, hazard, asan, automation):
|
|
if not enable_tests:
|
|
return False
|
|
if hazard or target.os == "Android" or (asan and cross_compile):
|
|
return False
|
|
if automation:
|
|
return False
|
|
return True
|
|
|
|
|
|
option(
|
|
"--enable-geckodriver",
|
|
default=geckodriver_default,
|
|
when="--enable-compile-environment",
|
|
help="{Build|Do not build} geckodriver",
|
|
)
|
|
|
|
|
|
@depends("--enable-geckodriver", when="--enable-compile-environment")
|
|
def geckodriver(enabled):
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_GECKODRIVER", geckodriver)
|
|
|
|
|
|
# WebRTC
|
|
# ========================================================
|
|
@depends(target)
|
|
def webrtc_default(target):
|
|
# Turn off webrtc for OS's we don't handle yet, but allow
|
|
# --enable-webrtc to override.
|
|
os_match = target.kernel in (
|
|
"Linux",
|
|
"WINNT",
|
|
"DragonFly",
|
|
"FreeBSD",
|
|
"kFreeBSD",
|
|
"NetBSD",
|
|
"OpenBSD",
|
|
)
|
|
|
|
if not os_match:
|
|
os_match = target.os in ("OSX",)
|
|
|
|
cpu_match = target.cpu in (
|
|
"x86_64",
|
|
"arm",
|
|
"aarch64",
|
|
"x86",
|
|
"ia64",
|
|
"mips32",
|
|
"mips64",
|
|
"ppc",
|
|
"ppc64",
|
|
"riscv64",
|
|
)
|
|
|
|
return os_match and cpu_match and target.endianness == "little"
|
|
|
|
|
|
option(
|
|
"--disable-webrtc",
|
|
default=webrtc_default,
|
|
help="{Enable|Disable} support for WebRTC",
|
|
)
|
|
|
|
|
|
@depends("--disable-webrtc")
|
|
def webrtc(enabled):
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_WEBRTC", webrtc)
|
|
set_define("MOZ_WEBRTC", webrtc)
|
|
set_config("MOZ_SCTP", webrtc)
|
|
set_define("MOZ_SCTP", webrtc)
|
|
set_config("MOZ_SRTP", webrtc)
|
|
set_define("MOZ_SRTP", webrtc)
|
|
set_config("MOZ_WEBRTC_SIGNALING", webrtc)
|
|
set_define("MOZ_WEBRTC_SIGNALING", webrtc)
|
|
set_config("MOZ_PEERCONNECTION", webrtc)
|
|
set_define("MOZ_PEERCONNECTION", webrtc)
|
|
# MOZ_WEBRTC_ASSERT_ALWAYS turns on a number of safety asserts in
|
|
# opt/production builds (via MOZ_CRASH())
|
|
set_config("MOZ_WEBRTC_ASSERT_ALWAYS", webrtc)
|
|
set_define("MOZ_WEBRTC_ASSERT_ALWAYS", webrtc)
|
|
|
|
# RAW media
|
|
# ==============================================================
|
|
|
|
|
|
@depends(target, webrtc)
|
|
def raw_media_default(target, webrtc):
|
|
if target.os == "Android":
|
|
return True
|
|
if webrtc:
|
|
return True
|
|
|
|
|
|
option(
|
|
"--enable-raw",
|
|
default=raw_media_default,
|
|
help="{Enable|Disable} support for RAW media",
|
|
)
|
|
|
|
set_define("MOZ_RAW", depends_if("--enable-raw")(lambda _: True))
|
|
|
|
|
|
# X11
|
|
# ==============================================================
|
|
@depends(webrtc, when=toolkit_gtk)
|
|
def x11_libs(webrtc):
|
|
libs = [
|
|
"x11",
|
|
"xcb",
|
|
"xcb-shm",
|
|
"x11-xcb",
|
|
"xext",
|
|
"xrandr >= 1.4.0",
|
|
]
|
|
if webrtc:
|
|
# third_party/libwebrtc/webrtc/webrtc_gn/moz.build adds those
|
|
# manually, ensure they're available.
|
|
libs += [
|
|
"xcomposite",
|
|
"xcursor",
|
|
"xdamage",
|
|
"xfixes",
|
|
"xi",
|
|
]
|
|
return libs
|
|
|
|
|
|
x11 = pkg_check_modules(
|
|
"MOZ_X11",
|
|
x11_libs,
|
|
allow_missing=toolkit_gtk_x11_optional,
|
|
when=toolkit_gtk_x11,
|
|
config=False, # set after the OpenBSD hook below
|
|
)
|
|
|
|
|
|
@depends(x11, target_is_openbsd)
|
|
def moz_x11_libs(x11, target_is_openbsd):
|
|
if not x11:
|
|
return []
|
|
if target_is_openbsd:
|
|
rpath = tuple(
|
|
f"-Wl,-rpath-link,{flag[2:]}" for flag in x11.libs if flag.startswith("-L")
|
|
)
|
|
else:
|
|
rpath = ()
|
|
return x11.libs + rpath
|
|
|
|
|
|
set_config("MOZ_X11_CFLAGS", x11.cflags)
|
|
set_config("MOZ_X11_LIBS", moz_x11_libs)
|
|
set_config("MOZ_X11", True, when=x11)
|
|
set_define("MOZ_X11", True, when=x11)
|
|
|
|
pkg_check_modules(
|
|
"MOZ_X11_SM",
|
|
["ice", "sm"],
|
|
cflags_only=True,
|
|
allow_missing=toolkit_gtk_x11_optional,
|
|
when=toolkit_gtk_x11,
|
|
)
|
|
|
|
|
|
# ASan Reporter Addon
|
|
# ==============================================================
|
|
option(
|
|
"--enable-address-sanitizer-reporter",
|
|
help="Enable Address Sanitizer Reporter Extension",
|
|
)
|
|
|
|
|
|
@depends("--enable-address-sanitizer-reporter")
|
|
def enable_asan_reporter(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_ASAN_REPORTER", enable_asan_reporter)
|
|
set_define("MOZ_ASAN_REPORTER", enable_asan_reporter)
|
|
|
|
# Checks for library functions
|
|
# ==============================================================
|
|
with only_when(compile_environment & depends(target.os)(lambda os: os != "WINNT")):
|
|
set_define("HAVE_STAT64", check_symbol("stat64"))
|
|
set_define("HAVE_LSTAT64", check_symbol("lstat64"))
|
|
set_define("HAVE_TRUNCATE64", check_symbol("truncate64"))
|
|
set_define("HAVE_STATVFS64", check_symbol("statvfs64"))
|
|
set_define("HAVE_STATVFS", check_symbol("statvfs"))
|
|
set_define("HAVE_STATFS64", check_symbol("statfs64"))
|
|
set_define("HAVE_STATFS", check_symbol("statfs"))
|
|
set_define("HAVE_LUTIMES", check_symbol("lutimes"))
|
|
set_define("HAVE_POSIX_FADVISE", check_symbol("posix_fadvise"))
|
|
set_define("HAVE_POSIX_FALLOCATE", check_symbol("posix_fallocate"))
|
|
set_define("HAVE_EVENTFD", check_symbol("eventfd"))
|
|
|
|
have_arc4random = check_symbol("arc4random")
|
|
set_define("HAVE_ARC4RANDOM", have_arc4random)
|
|
set_define("HAVE_ARC4RANDOM_BUF", check_symbol("arc4random_buf"))
|
|
set_define("HAVE_MALLINFO", check_symbol("mallinfo"))
|
|
|
|
# Checks for headers
|
|
# ==============================================================
|
|
with only_when(compile_environment & depends(target.os)(lambda os: os != "WINNT")):
|
|
set_define("HAVE_SYSIOCCOM_H", check_header("sys/ioccom.h"))
|
|
|
|
# Elfhack
|
|
# ==============================================================
|
|
with only_when("--enable-compile-environment"):
|
|
|
|
@depends(host, target)
|
|
def has_elfhack(host, target):
|
|
return (
|
|
target.kernel == "Linux"
|
|
and host.kernel == "Linux"
|
|
and target.cpu in ("arm", "aarch64", "x86", "x86_64")
|
|
)
|
|
|
|
option(
|
|
"--disable-elf-hack",
|
|
nargs="?",
|
|
choices=("legacy", "relr"),
|
|
help="{Enable|Disable} elf hacks",
|
|
when=has_elfhack,
|
|
)
|
|
|
|
@depends("--enable-elf-hack", when=has_elfhack)
|
|
def may_enable_legacy_elfhack(enable):
|
|
if enable and enable != ("relr",):
|
|
return enable
|
|
|
|
@depends("--enable-elf-hack", when=has_elfhack)
|
|
def may_enable_relrhack(enable):
|
|
if enable and enable != ("legacy",):
|
|
return enable
|
|
|
|
@depends(
|
|
have_arc4random,
|
|
android_version,
|
|
when=target_has_linux_kernel,
|
|
)
|
|
def may_use_pack_relative_relocs(have_arc4random, android_version):
|
|
# Packed relative relocations are only supported on Android since
|
|
# version 11 (API 30), and in glibc since version 2.36.
|
|
# glibc 2.36 also added the arc4random function, which is our proxy
|
|
# to detect this (or newer) version being used.
|
|
# When targetting those newer versions, we allow ourselves to use
|
|
# packed relative relocations rather than elfhack.
|
|
if android_version:
|
|
return android_version >= 30
|
|
return have_arc4random
|
|
|
|
@depends(
|
|
c_compiler,
|
|
extra_toolchain_flags,
|
|
linker_ldflags,
|
|
readelf,
|
|
when=may_use_pack_relative_relocs | may_enable_relrhack,
|
|
)
|
|
@checking("for -z pack-relative-relocs option to ld", bool)
|
|
@imports(_from="__builtin__", _import="FileNotFoundError")
|
|
@imports("os")
|
|
@imports("textwrap")
|
|
def has_pack_relative_relocs(
|
|
c_compiler,
|
|
extra_toolchain_flags,
|
|
linker_ldflags,
|
|
readelf,
|
|
):
|
|
with create_temporary_file(suffix=".out") as path:
|
|
pack_rel_relocs = ["-Wl,-z,pack-relative-relocs"]
|
|
if (
|
|
try_invoke_compiler(
|
|
# No configure_cache because it would not create the
|
|
# expected output file.
|
|
None,
|
|
[c_compiler.compiler] + c_compiler.flags,
|
|
c_compiler.language,
|
|
# The resulting binary is expected to have relative
|
|
# relocations, the `ptr` variable attempts to ensure
|
|
# there is at least one. This requires the executable
|
|
# being built as position independent.
|
|
"int main() { return 0; }\nint (*ptr)() = main;",
|
|
pack_rel_relocs
|
|
+ ["-pie", "-o", path]
|
|
+ (extra_toolchain_flags or [])
|
|
+ linker_ldflags,
|
|
wrapper=c_compiler.wrapper,
|
|
onerror=lambda: None,
|
|
)
|
|
is not None
|
|
):
|
|
# BFD ld ignores options it doesn't understand. So check
|
|
# that we did get packed relative relocations (DT_RELR).
|
|
env = os.environ.copy()
|
|
env["LANG"] = "C"
|
|
dyn = check_cmd_output(readelf, "-d", path, env=env).splitlines()
|
|
tags = [
|
|
int(l.split()[0], 16) for l in dyn if l.strip().startswith("0x")
|
|
]
|
|
# Older versions of readelf don't know about DT_RELR but will
|
|
# still display the tag number.
|
|
if 0x23 in tags:
|
|
needed = [l for l in dyn if l.split()[1:2] == ["(NEEDED)"]]
|
|
is_glibc = any(l.endswith("[libc.so.6]") for l in needed)
|
|
# The mold linker doesn't add a GLIBC_ABI_DT_RELR version
|
|
# dependency, which ld.so doesn't like.
|
|
# https://github.com/rui314/mold/issues/653#issuecomment-1670274638
|
|
if is_glibc:
|
|
versions = check_cmd_output(readelf, "-V", path, env=env)
|
|
if "GLIBC_ABI_DT_RELR" in versions.split():
|
|
return pack_rel_relocs
|
|
else:
|
|
return pack_rel_relocs
|
|
|
|
@depends(
|
|
has_pack_relative_relocs,
|
|
may_enable_legacy_elfhack,
|
|
may_enable_relrhack,
|
|
may_use_pack_relative_relocs,
|
|
when=has_pack_relative_relocs,
|
|
)
|
|
def pack_relative_relocs_flags(
|
|
flags,
|
|
may_enable_legacy_elfhack,
|
|
may_enable_relrhack,
|
|
may_use_pack_relative_relocs,
|
|
):
|
|
# When relrhack is enabled, we don't pass the flag to the linker because
|
|
# relrhack will take care of it.
|
|
if may_enable_relrhack and may_enable_relrhack.origin != "default":
|
|
return None
|
|
# if elfhack is explicitly enabled instead of relrhack, we prioritize it
|
|
# over packed relative relocs.
|
|
if may_enable_legacy_elfhack and may_enable_legacy_elfhack.origin != "default":
|
|
return None
|
|
if may_use_pack_relative_relocs:
|
|
return flags
|
|
|
|
@depends(
|
|
select_linker,
|
|
pack_relative_relocs_flags,
|
|
has_pack_relative_relocs,
|
|
may_enable_legacy_elfhack,
|
|
may_enable_relrhack,
|
|
when=has_elfhack,
|
|
)
|
|
def which_elf_hack(
|
|
linker,
|
|
pack_relative_relocs_flags,
|
|
has_pack_relative_relocs,
|
|
may_enable_legacy_elfhack,
|
|
may_enable_relrhack,
|
|
):
|
|
if pack_relative_relocs_flags:
|
|
return
|
|
if may_enable_relrhack:
|
|
if has_pack_relative_relocs:
|
|
return "relr"
|
|
elif (
|
|
may_enable_relrhack.origin != "default"
|
|
and not may_enable_legacy_elfhack
|
|
):
|
|
die(
|
|
"Cannot enable relrhack without linker support for -z pack-relative-relocs"
|
|
)
|
|
if may_enable_legacy_elfhack:
|
|
if linker and linker.KIND in ("lld", "mold"):
|
|
if may_enable_legacy_elfhack.origin != "default":
|
|
die(
|
|
f"Cannot enable elfhack with {linker.KIND}."
|
|
" Use --enable-linker=bfd, --enable-linker=gold, or --disable-elf-hack"
|
|
)
|
|
else:
|
|
return "legacy"
|
|
|
|
set_config(
|
|
"USE_ELF_HACK", True, when=depends(which_elf_hack)(lambda x: x == "legacy")
|
|
)
|
|
|
|
use_relrhack = depends(which_elf_hack)(lambda x: x == "relr")
|
|
set_config("RELRHACK", True, when=use_relrhack)
|
|
|
|
@depends(c_compiler, linker_ldflags, when=use_relrhack)
|
|
def relrhack_real_linker(c_compiler, linker_ldflags):
|
|
ld = "ld"
|
|
for flag in linker_ldflags:
|
|
if flag.startswith("-fuse-ld="):
|
|
ld = "ld." + flag[len("-fuse-ld=") :]
|
|
ld = check_cmd_output(
|
|
c_compiler.compiler, f"--print-prog-name={ld}", *c_compiler.flags
|
|
)
|
|
return ld.rstrip()
|
|
|
|
@depends(relrhack_real_linker, when=use_relrhack)
|
|
def relrhack_linker(ld):
|
|
return os.path.basename(ld)
|
|
|
|
set_config("RELRHACK_LINKER", relrhack_linker)
|
|
|
|
std_filesystem = host_cxx_compiler.try_run(
|
|
header="#include <filesystem>",
|
|
body='auto foo = std::filesystem::absolute("");',
|
|
flags=host_linker_ldflags,
|
|
when=use_relrhack,
|
|
onerror=lambda: None,
|
|
)
|
|
|
|
stdcxxfs = host_cxx_compiler.try_run(
|
|
header="#include <filesystem>",
|
|
body='auto foo = std::filesystem::absolute("");',
|
|
flags=depends(host_linker_ldflags)(
|
|
lambda flags: (flags or []) + ["-lstdc++fs"]
|
|
),
|
|
check_msg="whether std::filesystem requires -lstdc++fs",
|
|
when=use_relrhack & depends(std_filesystem)(lambda x: not x),
|
|
onerror=lambda: None,
|
|
)
|
|
|
|
set_config("RELRHACK_LIBS", ["stdc++fs"], when=stdcxxfs)
|
|
|
|
@depends(build_environment, relrhack_real_linker, when=use_relrhack)
|
|
def relrhack_ldflags(build_env, ld):
|
|
flags = [
|
|
"-B",
|
|
os.path.join(build_env.topobjdir, "build", "unix", "elfhack"),
|
|
]
|
|
if os.path.basename(ld) != ld:
|
|
flags.append(f"-Wl,--real-linker,{ld}")
|
|
return flags
|
|
|
|
set_config("RELRHACK_LDFLAGS", relrhack_ldflags)
|
|
|
|
|
|
@depends(build_environment)
|
|
def idl_roots(build_env):
|
|
return namespace(
|
|
ipdl_root=os.path.join(build_env.topobjdir, "ipc", "ipdl"),
|
|
webidl_root=os.path.join(build_env.topobjdir, "dom", "bindings"),
|
|
xpcom_root=os.path.join(build_env.topobjdir, "xpcom", "components"),
|
|
)
|
|
|
|
|
|
set_config("WEBIDL_ROOT", idl_roots.webidl_root)
|
|
set_config("IPDL_ROOT", idl_roots.ipdl_root)
|
|
set_config("XPCOM_ROOT", idl_roots.xpcom_root)
|
|
|
|
# Proxy bypass protection
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--enable-proxy-bypass-protection",
|
|
help="Prevent suspected or confirmed proxy bypasses",
|
|
)
|
|
|
|
|
|
@depends_if("--enable-proxy-bypass-protection")
|
|
def proxy_bypass_protection(_):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_PROXY_BYPASS_PROTECTION", proxy_bypass_protection)
|
|
set_define("MOZ_PROXY_BYPASS_PROTECTION", proxy_bypass_protection)
|
|
|
|
# Proxy direct failover
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--disable-proxy-direct-failover",
|
|
help="Disable direct failover for system requests",
|
|
)
|
|
|
|
|
|
@depends_if("--disable-proxy-direct-failover")
|
|
def proxy_direct_failover(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_PROXY_DIRECT_FAILOVER", proxy_direct_failover)
|
|
set_define("MOZ_PROXY_DIRECT_FAILOVER", proxy_direct_failover)
|
|
|
|
# MIDL
|
|
# ==============================================================
|
|
|
|
|
|
@depends(c_compiler, toolchain_prefix)
|
|
def midl_names(c_compiler, toolchain_prefix):
|
|
if c_compiler and c_compiler.type in ["gcc", "clang"]:
|
|
# mingw
|
|
widl = ("widl",)
|
|
if toolchain_prefix:
|
|
prefixed = tuple("%s%s" % (p, "widl") for p in toolchain_prefix)
|
|
widl = prefixed + widl
|
|
return widl
|
|
|
|
return ("midl.exe",)
|
|
|
|
|
|
@depends(target, "--enable-compile-environment")
|
|
def check_for_midl(target, compile_environment):
|
|
if target.os != "WINNT":
|
|
return
|
|
|
|
if compile_environment:
|
|
return True
|
|
|
|
|
|
midl = check_prog(
|
|
"MIDL",
|
|
midl_names,
|
|
when=check_for_midl,
|
|
allow_missing=True,
|
|
paths=sdk_bin_path,
|
|
# MIDL being used from a python wrapper script, we can live with it
|
|
# having spaces.
|
|
allow_spaces=True,
|
|
)
|
|
|
|
option(env="MIDL_FLAGS", nargs=1, help="Extra flags to pass to MIDL")
|
|
|
|
|
|
@depends(
|
|
"MIDL_FLAGS",
|
|
target,
|
|
midl,
|
|
when=depends(midl, target)(lambda m, t: m and t.kernel == "WINNT"),
|
|
)
|
|
def midl_flags(flags, target, midl):
|
|
if flags:
|
|
flags = flags[0].split()
|
|
else:
|
|
flags = []
|
|
|
|
if not midl.endswith("widl"):
|
|
env = {
|
|
"x86": "win32",
|
|
"x86_64": "x64",
|
|
"aarch64": "arm64",
|
|
}[target.cpu]
|
|
return flags + ["-nologo", "-no_cpp", "-env", env]
|
|
|
|
# widl
|
|
return (
|
|
flags
|
|
+ {
|
|
"x86": ["--win32", "-m32"],
|
|
"x86_64": ["--win64", "-m64"],
|
|
}[target.cpu]
|
|
)
|
|
|
|
|
|
set_config("MIDL_FLAGS", midl_flags)
|
|
|
|
# Accessibility
|
|
# ==============================================================
|
|
|
|
option("--disable-accessibility", help="Disable accessibility support")
|
|
|
|
|
|
@depends("--enable-accessibility", check_for_midl, midl, c_compiler)
|
|
def accessibility(value, check_for_midl, midl, c_compiler):
|
|
enabled = bool(value)
|
|
|
|
if not enabled:
|
|
return
|
|
|
|
if check_for_midl and not midl:
|
|
if c_compiler and c_compiler.type in ("gcc", "clang"):
|
|
die(
|
|
"You have accessibility enabled, but widl could not be found. "
|
|
"Add --disable-accessibility to your mozconfig or install widl. "
|
|
"See https://developer.mozilla.org/en-US/docs/Cross_Compile_Mozilla_for_Mingw32 for details."
|
|
)
|
|
else:
|
|
die(
|
|
"MIDL could not be found. "
|
|
"Building accessibility without MIDL is not supported."
|
|
)
|
|
|
|
return enabled
|
|
|
|
|
|
set_config("ACCESSIBILITY", accessibility)
|
|
set_define("ACCESSIBILITY", accessibility)
|
|
|
|
|
|
@depends(moz_debug, developer_options)
|
|
def a11y_log(debug, developer_options):
|
|
return debug or developer_options
|
|
|
|
|
|
set_config("A11Y_LOG", True, when=a11y_log)
|
|
set_define("A11Y_LOG", True, when=a11y_log)
|
|
|
|
|
|
# Addon signing
|
|
# ==============================================================
|
|
@depends(milestone)
|
|
def require_signing(milestone):
|
|
return milestone.is_release_or_beta and not milestone.is_esr
|
|
|
|
|
|
option(
|
|
env="MOZ_REQUIRE_SIGNING",
|
|
default=require_signing,
|
|
help="Enforce that add-ons are signed by the trusted root",
|
|
)
|
|
|
|
set_config("MOZ_REQUIRE_SIGNING", True, when="MOZ_REQUIRE_SIGNING")
|
|
set_define("MOZ_REQUIRE_SIGNING", True, when="MOZ_REQUIRE_SIGNING")
|
|
|
|
option(
|
|
"--with-unsigned-addon-scopes",
|
|
nargs="+",
|
|
choices=("app", "system"),
|
|
help="Addon scopes where signature is not required",
|
|
)
|
|
|
|
|
|
@depends("--with-unsigned-addon-scopes")
|
|
def unsigned_addon_scopes(scopes):
|
|
return namespace(
|
|
app="app" in scopes or None,
|
|
system="system" in scopes or None,
|
|
)
|
|
|
|
|
|
set_config("MOZ_UNSIGNED_APP_SCOPE", unsigned_addon_scopes.app)
|
|
set_config("MOZ_UNSIGNED_SYSTEM_SCOPE", unsigned_addon_scopes.system)
|
|
|
|
|
|
# Addon sideloading
|
|
# ==============================================================
|
|
option(
|
|
"--allow-addon-sideload",
|
|
default=milestone.is_esr,
|
|
help="Addon sideloading is allowed",
|
|
)
|
|
|
|
|
|
set_config("MOZ_ALLOW_ADDON_SIDELOAD", True, when="--allow-addon-sideload")
|
|
|
|
# WebExtensions API WebIDL bindings
|
|
# ==============================================================
|
|
|
|
|
|
@depends(milestone)
|
|
def extensions_webidl_bindings_default(milestone):
|
|
# Only enable the webidl bindings for the WebExtensions APIs
|
|
# in Nightly.
|
|
return milestone.is_nightly
|
|
|
|
|
|
option(
|
|
"--enable-extensions-webidl-bindings",
|
|
default=extensions_webidl_bindings_default,
|
|
help="{Enable|Disable} building experimental WebExtensions WebIDL bindings",
|
|
)
|
|
|
|
|
|
@depends("--enable-extensions-webidl-bindings")
|
|
def extensions_webidl_enabled(value):
|
|
return bool(value)
|
|
|
|
|
|
set_config("MOZ_WEBEXT_WEBIDL_ENABLED", extensions_webidl_enabled)
|
|
|
|
# Launcher process (Windows only)
|
|
# ==============================================================
|
|
|
|
|
|
@depends(target)
|
|
def launcher_process_default(target):
|
|
return target.os == "WINNT"
|
|
|
|
|
|
option(
|
|
"--enable-launcher-process",
|
|
default=launcher_process_default,
|
|
help="{Enable|Disable} launcher process by default",
|
|
)
|
|
|
|
|
|
@depends("--enable-launcher-process", target)
|
|
def launcher(value, target):
|
|
enabled = bool(value)
|
|
if enabled and target.os != "WINNT":
|
|
die("Cannot enable launcher process on %s", target.os)
|
|
if enabled:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_LAUNCHER_PROCESS", launcher)
|
|
set_define("MOZ_LAUNCHER_PROCESS", launcher)
|
|
|
|
# llvm-dlltool (Windows only)
|
|
# ==============================================================
|
|
|
|
|
|
@depends(build_project, target, "--enable-compile-environment")
|
|
def check_for_llvm_dlltool(build_project, target, compile_environment):
|
|
if build_project != "browser":
|
|
return
|
|
|
|
if target.os != "WINNT":
|
|
return
|
|
|
|
return compile_environment
|
|
|
|
|
|
llvm_dlltool = check_prog(
|
|
"LLVM_DLLTOOL",
|
|
("llvm-dlltool",),
|
|
what="llvm-dlltool",
|
|
when=check_for_llvm_dlltool,
|
|
paths=clang_search_path,
|
|
)
|
|
|
|
|
|
@depends(target, when=llvm_dlltool)
|
|
def llvm_dlltool_flags(target):
|
|
arch = {
|
|
"x86": "i386",
|
|
"x86_64": "i386:x86-64",
|
|
"aarch64": "arm64",
|
|
}[target.cpu]
|
|
|
|
return ["-m", arch]
|
|
|
|
|
|
set_config("LLVM_DLLTOOL_FLAGS", llvm_dlltool_flags)
|
|
|
|
# BITS download (Windows only)
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--enable-bits-download",
|
|
when=target_is_windows,
|
|
default=target_is_windows,
|
|
help="{Enable|Disable} building BITS download support",
|
|
)
|
|
|
|
set_define(
|
|
"MOZ_BITS_DOWNLOAD",
|
|
depends_if("--enable-bits-download", when=target_is_windows)(lambda _: True),
|
|
)
|
|
set_config(
|
|
"MOZ_BITS_DOWNLOAD",
|
|
depends_if("--enable-bits-download", when=target_is_windows)(lambda _: True),
|
|
)
|
|
|
|
# Bundled fonts on desktop platform
|
|
# ==============================================================
|
|
|
|
|
|
@depends(target)
|
|
def bundled_fonts_default(target):
|
|
return target.os == "WINNT" or target.kernel == "Linux"
|
|
|
|
|
|
@depends(build_project)
|
|
def allow_bundled_fonts(project):
|
|
return project == "browser" or project == "comm/mail"
|
|
|
|
|
|
option(
|
|
"--enable-bundled-fonts",
|
|
default=bundled_fonts_default,
|
|
when=allow_bundled_fonts,
|
|
help="{Enable|Disable} support for bundled fonts on desktop platforms",
|
|
)
|
|
|
|
set_define(
|
|
"MOZ_BUNDLED_FONTS",
|
|
depends_if("--enable-bundled-fonts", when=allow_bundled_fonts)(lambda _: True),
|
|
)
|
|
|
|
# Reflow counting
|
|
# ==============================================================
|
|
|
|
|
|
@depends(moz_debug)
|
|
def reflow_perf(debug):
|
|
if debug:
|
|
return True
|
|
|
|
|
|
option(
|
|
"--enable-reflow-perf",
|
|
default=reflow_perf,
|
|
help="{Enable|Disable} reflow performance tracing",
|
|
)
|
|
|
|
# The difference in conditions here comes from the initial implementation
|
|
# in old-configure, which was unexplained there as well.
|
|
set_define("MOZ_REFLOW_PERF", depends_if("--enable-reflow-perf")(lambda _: True))
|
|
set_define("MOZ_REFLOW_PERF_DSP", reflow_perf)
|
|
|
|
# Layout debugger
|
|
# ==============================================================
|
|
|
|
|
|
@depends(moz_debug)
|
|
def layout_debugger(debug):
|
|
if debug:
|
|
return True
|
|
|
|
|
|
option(
|
|
"--enable-layout-debugger",
|
|
default=layout_debugger,
|
|
help="{Enable|Disable} layout debugger",
|
|
)
|
|
|
|
set_config("MOZ_LAYOUT_DEBUGGER", True, when="--enable-layout-debugger")
|
|
set_define("MOZ_LAYOUT_DEBUGGER", True, when="--enable-layout-debugger")
|
|
|
|
|
|
# Shader Compiler for Windows (and MinGW Cross Compile)
|
|
# ==============================================================
|
|
|
|
with only_when(compile_environment):
|
|
fxc = check_prog(
|
|
"FXC",
|
|
("fxc.exe", "fxc2.exe"),
|
|
when=depends(target)(lambda t: t.kernel == "WINNT"),
|
|
paths=sdk_bin_path,
|
|
# FXC being used from a python wrapper script, we can live with it
|
|
# having spaces.
|
|
allow_spaces=True,
|
|
)
|
|
|
|
|
|
# VPX
|
|
# ===
|
|
|
|
with only_when(compile_environment):
|
|
system_lib_option(
|
|
"--with-system-libvpx",
|
|
help="Use system libvpx (located with pkgconfig)",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
@depends("--with-system-libvpx", when=use_pkg_config)
|
|
def with_system_libvpx_option(with_system_libvpx):
|
|
return with_system_libvpx
|
|
|
|
with only_when("--with-system-libvpx"):
|
|
vpx = pkg_check_modules("MOZ_LIBVPX", "vpx >= 1.10.0")
|
|
|
|
check_header(
|
|
"vpx/vpx_decoder.h",
|
|
flags=vpx.cflags,
|
|
onerror=lambda: die(
|
|
"Couldn't find vpx/vpx_decoder.h, which is required to build "
|
|
"with system libvpx. Use --without-system-libvpx to build "
|
|
"with in-tree libvpx."
|
|
),
|
|
)
|
|
|
|
check_symbol(
|
|
"vpx_codec_dec_init_ver",
|
|
flags=vpx.libs,
|
|
onerror=lambda: die(
|
|
"--with-system-libvpx requested but symbol vpx_codec_dec_init_ver "
|
|
"not found"
|
|
),
|
|
)
|
|
|
|
set_config("MOZ_SYSTEM_LIBVPX", True)
|
|
|
|
@depends(with_system_libvpx_option, target)
|
|
def in_tree_vpx(system_libvpx, target):
|
|
if system_libvpx:
|
|
return
|
|
|
|
arm_asm = (target.cpu == "arm") or None
|
|
return namespace(arm_asm=arm_asm)
|
|
|
|
@depends(target, when=in_tree_vpx)
|
|
def vpx_nasm(target):
|
|
if target.cpu in ("x86", "x86_64"):
|
|
if target.kernel == "WINNT":
|
|
# Version 2.03 is needed for automatic safeseh support.
|
|
return namespace(version="2.03", what="VPX")
|
|
return namespace(what="VPX")
|
|
|
|
@depends(in_tree_vpx, vpx_nasm, target, neon_flags)
|
|
def vpx_as_flags(vpx, vpx_nasm, target, neon_flags):
|
|
if vpx and vpx.arm_asm:
|
|
# These flags are a lie; they're just used to enable the requisite
|
|
# opcodes; actual arch detection is done at runtime.
|
|
return neon_flags
|
|
elif vpx and vpx_nasm and target.os != "WINNT" and target.cpu != "x86_64":
|
|
return ("-DPIC",)
|
|
|
|
set_config("VPX_USE_NASM", True, when=vpx_nasm)
|
|
set_config("VPX_ASFLAGS", vpx_as_flags)
|
|
|
|
|
|
# JPEG
|
|
# ====
|
|
|
|
with only_when(compile_environment):
|
|
system_lib_option(
|
|
"--with-system-jpeg",
|
|
nargs="?",
|
|
help="Use system libjpeg (installed at given prefix)",
|
|
)
|
|
|
|
@depends_if("--with-system-jpeg")
|
|
def jpeg_flags(value):
|
|
if len(value):
|
|
return namespace(
|
|
cflags=("-I%s/include" % value[0],),
|
|
ldflags=("-L%s/lib" % value[0], "-ljpeg"),
|
|
)
|
|
return namespace(
|
|
ldflags=("-ljpeg",),
|
|
)
|
|
|
|
with only_when("--with-system-jpeg"):
|
|
check_symbol(
|
|
"jpeg_destroy_compress",
|
|
flags=jpeg_flags.ldflags,
|
|
onerror=lambda: die(
|
|
"--with-system-jpeg requested but symbol "
|
|
"jpeg_destroy_compress not found."
|
|
),
|
|
)
|
|
|
|
c_compiler.try_compile(
|
|
includes=[
|
|
"stdio.h",
|
|
"sys/types.h",
|
|
"jpeglib.h",
|
|
],
|
|
body="""
|
|
#if JPEG_LIB_VERSION < 62
|
|
#error Insufficient JPEG library version
|
|
#endif
|
|
""",
|
|
flags=jpeg_flags.cflags,
|
|
check_msg="for sufficient jpeg library version",
|
|
onerror=lambda: die(
|
|
"Insufficient JPEG library version for "
|
|
"--with-system-jpeg (62 required)"
|
|
),
|
|
)
|
|
|
|
c_compiler.try_compile(
|
|
includes=[
|
|
"stdio.h",
|
|
"sys/types.h",
|
|
"jpeglib.h",
|
|
],
|
|
body="""
|
|
#ifndef JCS_EXTENSIONS
|
|
#error libjpeg-turbo JCS_EXTENSIONS required
|
|
#endif
|
|
""",
|
|
flags=jpeg_flags.cflags,
|
|
check_msg="for sufficient libjpeg-turbo JCS_EXTENSIONS",
|
|
onerror=lambda: die(
|
|
"libjpeg-turbo JCS_EXTENSIONS required for " "--with-system-jpeg"
|
|
),
|
|
)
|
|
|
|
set_config("MOZ_JPEG_CFLAGS", jpeg_flags.cflags)
|
|
set_config("MOZ_JPEG_LIBS", jpeg_flags.ldflags)
|
|
|
|
@depends("--with-system-jpeg", target, neon_flags)
|
|
def in_tree_jpeg_arm(system_jpeg, target, neon_flags):
|
|
if system_jpeg:
|
|
return
|
|
|
|
if target.cpu == "arm":
|
|
return neon_flags
|
|
elif target.cpu == "aarch64":
|
|
return ("-march=armv8-a",)
|
|
|
|
@depends("--with-system-jpeg", target)
|
|
def in_tree_jpeg_mips64(system_jpeg, target):
|
|
if system_jpeg:
|
|
return
|
|
|
|
if target.cpu == "mips64":
|
|
return ("-Wa,-mloongson-mmi", "-mloongson-ext")
|
|
|
|
# Compiler check from https://github.com/libjpeg-turbo/libjpeg-turbo/blob/57ba02a408a9a55ccff25aae8b164632a3a4f177/simd/CMakeLists.txt#L419
|
|
jpeg_mips64_mmi = c_compiler.try_compile(
|
|
body='int c = 0, a = 0, b = 0; asm("paddb %0, %1, %2" : "=f" (c) : "f" (a), "f" (b));',
|
|
check_msg="for loongson mmi support",
|
|
flags=in_tree_jpeg_mips64,
|
|
when=in_tree_jpeg_mips64,
|
|
)
|
|
|
|
@depends(
|
|
"--with-system-jpeg",
|
|
target,
|
|
in_tree_jpeg_arm,
|
|
in_tree_jpeg_mips64,
|
|
jpeg_mips64_mmi,
|
|
)
|
|
def in_tree_jpeg(
|
|
system_jpeg, target, in_tree_jpeg_arm, in_tree_jpeg_mips64, jpeg_mips64_mmi
|
|
):
|
|
if system_jpeg:
|
|
return
|
|
|
|
if target.cpu in ("arm", "aarch64"):
|
|
return in_tree_jpeg_arm
|
|
elif target.kernel == "Darwin":
|
|
if target.cpu == "x86":
|
|
return ("-DPIC", "-DMACHO")
|
|
elif target.cpu == "x86_64":
|
|
return ("-D__x86_64__", "-DPIC", "-DMACHO")
|
|
elif target.kernel == "WINNT":
|
|
if target.cpu == "x86":
|
|
return ("-DPIC", "-DWIN32")
|
|
elif target.cpu == "x86_64":
|
|
return ("-D__x86_64__", "-DPIC", "-DWIN64", "-DMSVC")
|
|
elif target.cpu == "mips32":
|
|
return ("-mdspr2",)
|
|
elif target.cpu == "mips64" and jpeg_mips64_mmi:
|
|
return in_tree_jpeg_mips64
|
|
elif target.cpu == "x86":
|
|
return ("-DPIC", "-DELF")
|
|
elif target.cpu == "x86_64":
|
|
return ("-D__x86_64__", "-DPIC", "-DELF")
|
|
|
|
@depends(target, when=depends("--with-system-jpeg")(lambda x: not x))
|
|
def jpeg_nasm(target):
|
|
if target.cpu in ("x86", "x86_64"):
|
|
# libjpeg-turbo 2.0.6 requires nasm 2.10.
|
|
return namespace(version="2.10", what="JPEG")
|
|
|
|
# Compiler checks from https://github.com/libjpeg-turbo/libjpeg-turbo/blob/57ba02a408a9a55ccff25aae8b164632a3a4f177/simd/CMakeLists.txt#L258
|
|
jpeg_arm_neon_vld1_s16_x3 = c_compiler.try_compile(
|
|
includes=["arm_neon.h"],
|
|
body="int16_t input[12] = {}; int16x4x3_t output = vld1_s16_x3(input);",
|
|
check_msg="for vld1_s16_x3 in arm_neon.h",
|
|
flags=in_tree_jpeg_arm,
|
|
when=in_tree_jpeg_arm,
|
|
)
|
|
|
|
jpeg_arm_neon_vld1_u16_x2 = c_compiler.try_compile(
|
|
includes=["arm_neon.h"],
|
|
body="uint16_t input[8] = {}; uint16x4x2_t output = vld1_u16_x2(input);",
|
|
check_msg="for vld1_u16_x2 in arm_neon.h",
|
|
flags=in_tree_jpeg_arm,
|
|
when=in_tree_jpeg_arm,
|
|
)
|
|
|
|
jpeg_arm_neon_vld1q_u8_x4 = c_compiler.try_compile(
|
|
includes=["arm_neon.h"],
|
|
body="uint8_t input[64] = {}; uint8x16x4_t output = vld1q_u8_x4(input);",
|
|
check_msg="for vld1q_u8_x4 in arm_neon.h",
|
|
flags=in_tree_jpeg_arm,
|
|
when=in_tree_jpeg_arm,
|
|
)
|
|
|
|
set_config("LIBJPEG_TURBO_USE_NASM", True, when=jpeg_nasm)
|
|
set_config("LIBJPEG_TURBO_SIMD_FLAGS", in_tree_jpeg)
|
|
set_config("LIBJPEG_TURBO_HAVE_VLD1_S16_X3", jpeg_arm_neon_vld1_s16_x3)
|
|
set_config("LIBJPEG_TURBO_HAVE_VLD1_U16_X2", jpeg_arm_neon_vld1_u16_x2)
|
|
set_config("LIBJPEG_TURBO_HAVE_VLD1Q_U8_X4", jpeg_arm_neon_vld1q_u8_x4)
|
|
set_config(
|
|
"LIBJPEG_TURBO_NEON_INTRINSICS",
|
|
jpeg_arm_neon_vld1_s16_x3
|
|
& jpeg_arm_neon_vld1_u16_x2
|
|
& jpeg_arm_neon_vld1q_u8_x4,
|
|
)
|
|
|
|
set_config("MOZ_SYSTEM_JPEG", True, when="--with-system-jpeg")
|
|
|
|
|
|
# PNG
|
|
# ===
|
|
with only_when(compile_environment):
|
|
system_lib_option(
|
|
"--with-system-png",
|
|
nargs="?",
|
|
help="Use system libpng",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
@depends("--with-system-png", when=use_pkg_config)
|
|
def deprecated_system_png_path(value):
|
|
if len(value) == 1:
|
|
die(
|
|
"--with-system-png=PATH is not supported anymore. Please use "
|
|
"--with-system-png and set any necessary pkg-config environment variable."
|
|
)
|
|
|
|
png = pkg_check_modules("MOZ_PNG", "libpng >= 1.6.35", when="--with-system-png")
|
|
|
|
check_symbol(
|
|
"png_get_acTL",
|
|
flags=png.libs,
|
|
onerror=lambda: die(
|
|
"--with-system-png won't work because the system's libpng doesn't have APNG support"
|
|
),
|
|
when="--with-system-png",
|
|
)
|
|
|
|
set_config("MOZ_SYSTEM_PNG", True, when="--with-system-png")
|
|
|
|
|
|
# FFmpeg's ffvpx configuration
|
|
# ==============================================================
|
|
|
|
|
|
@depends(target)
|
|
def ffvpx(target):
|
|
use_nasm = True
|
|
audio_only = False
|
|
flags = []
|
|
|
|
# This enables audio and video codecs paths on Windows x86 and x86_64,
|
|
# macOS (all arch), and Linux x86_64. On other arch / OS combinations,
|
|
# only audio codecs are enabled.
|
|
if target.kernel == "WINNT":
|
|
if target.cpu == "x86":
|
|
# 32-bit windows need to prefix symbols with an underscore.
|
|
flags = ["-DPIC", "-DWIN32", "-DPREFIX", "-Pconfig_win32.asm"]
|
|
elif target.cpu == "x86_64":
|
|
flags = [
|
|
"-D__x86_64__",
|
|
"-DPIC",
|
|
"-DWIN64",
|
|
"-DMSVC",
|
|
"-Pconfig_win64.asm",
|
|
]
|
|
elif target.cpu == "aarch64":
|
|
flags = ["-DPIC", "-DWIN64"]
|
|
use_nasm = False
|
|
elif target.kernel == "Darwin":
|
|
# 32/64-bit macosx assemblers need to prefix symbols with an
|
|
# underscore.
|
|
flags = ["-DPIC", "-DMACHO", "-DPREFIX"]
|
|
if target.cpu == "x86_64":
|
|
flags += [
|
|
"-D__x86_64__",
|
|
"-Pconfig_darwin64.asm",
|
|
]
|
|
elif target.cpu == "aarch64":
|
|
use_nasm = False
|
|
elif target.cpu == "x86_64":
|
|
flags = ["-D__x86_64__", "-DPIC", "-DELF", "-Pconfig_unix64.asm"]
|
|
else:
|
|
audio_only = True
|
|
|
|
if audio_only:
|
|
use_nasm = False
|
|
|
|
return namespace(
|
|
use_nasm=use_nasm,
|
|
audio_only=audio_only,
|
|
flags=flags,
|
|
)
|
|
|
|
|
|
@depends(when=ffvpx.use_nasm)
|
|
def ffvpx_nasm():
|
|
# nasm 2.10 for AVX-2 support.
|
|
return namespace(version="2.10", what="FFVPX")
|
|
|
|
|
|
# ffvpx_nasm can't indirectly depend on vpx_as_flags, because it depends
|
|
# on a compiler test, so we have to do a little bit of dance here.
|
|
@depends(ffvpx, vpx_as_flags, target)
|
|
def ffvpx(ffvpx, vpx_as_flags, target):
|
|
if ffvpx and vpx_as_flags and target.cpu in ("arm", "aarch64"):
|
|
ffvpx.flags.extend(vpx_as_flags)
|
|
return ffvpx
|
|
|
|
|
|
set_config("MOZ_FFVPX_AUDIOONLY", True, when=ffvpx.audio_only)
|
|
set_define("MOZ_FFVPX_AUDIOONLY", True, when=ffvpx.audio_only)
|
|
set_config("FFVPX_ASFLAGS", ffvpx.flags)
|
|
set_config("FFVPX_USE_NASM", True, when=ffvpx.use_nasm)
|
|
|
|
|
|
# nasm detection
|
|
# ==============================================================
|
|
@depends(dav1d_nasm, vpx_nasm, jpeg_nasm, ffvpx_nasm, when=compile_environment)
|
|
def need_nasm(*requirements):
|
|
requires = {
|
|
x.what: x.version if hasattr(x, "version") else True for x in requirements if x
|
|
}
|
|
if requires:
|
|
items = sorted(requires.keys())
|
|
if len(items) > 1:
|
|
what = " and ".join((", ".join(items[:-1]), items[-1]))
|
|
else:
|
|
what = items[0]
|
|
versioned = {k: v for (k, v) in requires.items() if v is not True}
|
|
return namespace(what=what, versioned=versioned)
|
|
|
|
|
|
nasm = check_prog(
|
|
"NASM",
|
|
["nasm"],
|
|
allow_missing=True,
|
|
bootstrap="nasm",
|
|
when=need_nasm,
|
|
)
|
|
|
|
|
|
@depends(nasm, need_nasm.what)
|
|
def check_nasm(nasm, what):
|
|
if not nasm and what:
|
|
die("Nasm is required to build with %s, but it was not found." % what)
|
|
return nasm
|
|
|
|
|
|
@depends_if(check_nasm)
|
|
@checking("nasm version")
|
|
def nasm_version(nasm):
|
|
version = (
|
|
check_cmd_output(nasm, "-v", onerror=lambda: die("Failed to get nasm version."))
|
|
.splitlines()[0]
|
|
.split()[2]
|
|
)
|
|
return Version(version)
|
|
|
|
|
|
@depends(nasm_version, need_nasm.versioned, when=need_nasm.versioned)
|
|
def check_nasm_version(nasm_version, versioned):
|
|
by_version = sorted(versioned.items(), key=lambda x: x[1])
|
|
what, version = by_version[-1]
|
|
if nasm_version < version:
|
|
die(
|
|
"Nasm version %s or greater is required to build with %s." % (version, what)
|
|
)
|
|
return nasm_version
|
|
|
|
|
|
@depends(target, when=check_nasm_version)
|
|
def nasm_asflags(target):
|
|
asflags = {
|
|
("Darwin", "x86"): ["-f", "macho32"],
|
|
("Darwin", "x86_64"): ["-f", "macho64"],
|
|
("WINNT", "x86"): ["-f", "win32"],
|
|
("WINNT", "x86_64"): ["-f", "win64"],
|
|
}.get((target.kernel, target.cpu), None)
|
|
if asflags is None:
|
|
# We're assuming every x86 platform we support that's
|
|
# not Windows or Mac is ELF.
|
|
if target.cpu == "x86":
|
|
asflags = ["-f", "elf32"]
|
|
elif target.cpu == "x86_64":
|
|
asflags = ["-f", "elf64"]
|
|
return asflags
|
|
|
|
|
|
set_config("NASM_ASFLAGS", nasm_asflags)
|
|
|
|
|
|
# ANGLE OpenGL->D3D translator for WebGL
|
|
# ==============================================================
|
|
|
|
with only_when(compile_environment & target_is_windows):
|
|
set_config("MOZ_ANGLE_RENDERER", True)
|
|
|
|
# Remoting protocol support
|
|
# ==============================================================
|
|
|
|
|
|
@depends(toolkit)
|
|
def has_remote(toolkit):
|
|
if toolkit in ("gtk", "windows", "cocoa"):
|
|
return True
|
|
|
|
|
|
set_config("MOZ_HAS_REMOTE", has_remote)
|
|
set_define("MOZ_HAS_REMOTE", has_remote)
|
|
|
|
# RLBox Library Sandboxing wasm support
|
|
# ==============================================================
|
|
|
|
|
|
def wasm_sandboxing_libraries():
|
|
return (
|
|
"graphite",
|
|
"ogg",
|
|
"hunspell",
|
|
"expat",
|
|
"woff2",
|
|
"soundtouch",
|
|
)
|
|
|
|
|
|
@depends(dependable(wasm_sandboxing_libraries), build_project)
|
|
def default_wasm_sandboxing_libraries(libraries, build_project):
|
|
if build_project != "tools/rusttests":
|
|
non_default_libs = {}
|
|
|
|
return tuple(l for l in libraries if l not in non_default_libs)
|
|
|
|
|
|
option(
|
|
"--with-wasm-sandboxed-libraries",
|
|
env="WASM_SANDBOXED_LIBRARIES",
|
|
help="{Enable wasm sandboxing for the selected libraries|Disable wasm sandboxing}",
|
|
nargs="+",
|
|
choices=dependable(wasm_sandboxing_libraries),
|
|
default=default_wasm_sandboxing_libraries,
|
|
)
|
|
|
|
|
|
@depends("--with-wasm-sandboxed-libraries")
|
|
def requires_wasm_sandboxing(libraries):
|
|
if libraries:
|
|
return True
|
|
|
|
|
|
set_config("MOZ_USING_WASM_SANDBOXING", requires_wasm_sandboxing)
|
|
set_define("MOZ_USING_WASM_SANDBOXING", requires_wasm_sandboxing)
|
|
|
|
with only_when(requires_wasm_sandboxing & compile_environment):
|
|
option(
|
|
"--with-wasi-sysroot",
|
|
env="WASI_SYSROOT",
|
|
nargs=1,
|
|
help="Path to wasi sysroot for wasm sandboxing",
|
|
)
|
|
|
|
@depends("--with-wasi-sysroot", requires_wasm_sandboxing)
|
|
def bootstrap_wasi_sysroot(wasi_sysroot, requires_wasm_sandboxing):
|
|
return requires_wasm_sandboxing and not wasi_sysroot
|
|
|
|
@depends(
|
|
"--with-wasi-sysroot",
|
|
bootstrap_path("sysroot-wasm32-wasi", when=bootstrap_wasi_sysroot),
|
|
)
|
|
@imports("os")
|
|
def wasi_sysroot(wasi_sysroot, bootstrapped_sysroot):
|
|
if not wasi_sysroot:
|
|
return bootstrapped_sysroot
|
|
|
|
wasi_sysroot = wasi_sysroot[0]
|
|
if not os.path.isdir(wasi_sysroot):
|
|
die("Argument to --with-wasi-sysroot must be a directory")
|
|
if not os.path.isabs(wasi_sysroot):
|
|
die("Argument to --with-wasi-sysroot must be an absolute path")
|
|
|
|
return wasi_sysroot
|
|
|
|
@depends(wasi_sysroot)
|
|
def wasi_sysroot_flags(wasi_sysroot):
|
|
if wasi_sysroot:
|
|
log.info("Using wasi sysroot in %s", wasi_sysroot)
|
|
return ["--sysroot=%s" % wasi_sysroot]
|
|
return []
|
|
|
|
set_config("WASI_SYSROOT", wasi_sysroot)
|
|
|
|
def wasm_compiler_with_flags(compiler, sysroot_flags):
|
|
if compiler:
|
|
return (
|
|
compiler.wrapper + [compiler.compiler] + compiler.flags + sysroot_flags
|
|
)
|
|
|
|
@template
|
|
def wasm_compiler_error(msg):
|
|
@depends("--with-wasm-sandboxed-libraries")
|
|
def wasm_compiler_error(sandboxed_libs):
|
|
suggest_disable = ""
|
|
if sandboxed_libs.origin == "default":
|
|
suggest_disable = " Or build with --without-wasm-sandboxed-libraries."
|
|
return lambda: die(msg + suggest_disable)
|
|
|
|
return wasm_compiler_error
|
|
|
|
@template
|
|
def check_wasm_compiler(compiler, language):
|
|
compiler.try_compile(
|
|
includes=["cstring" if language == "C++" else "string.h"],
|
|
flags=wasi_sysroot_flags,
|
|
check_msg="the wasm %s compiler can find wasi headers" % language,
|
|
onerror=wasm_compiler_error(
|
|
"Cannot find wasi headers or problem with the wasm compiler. "
|
|
"Please fix the problem."
|
|
),
|
|
)
|
|
|
|
compiler.try_run(
|
|
flags=wasi_sysroot_flags,
|
|
check_msg="the wasm %s linker can find wasi libraries" % language,
|
|
onerror=wasm_compiler_error(
|
|
"Cannot find wasi libraries or problem with the wasm linker. "
|
|
"Please fix the problem."
|
|
),
|
|
)
|
|
|
|
wasm_cc = compiler("C", wasm, other_compiler=c_compiler)
|
|
check_wasm_compiler(wasm_cc, "C")
|
|
|
|
@depends(wasm_cc, wasi_sysroot_flags)
|
|
def wasm_cc_with_flags(wasm_cc, wasi_sysroot_flags):
|
|
return wasm_compiler_with_flags(wasm_cc, wasi_sysroot_flags)
|
|
|
|
set_config("WASM_CC", wasm_cc_with_flags)
|
|
|
|
wasm_cxx = compiler(
|
|
"C++",
|
|
wasm,
|
|
c_compiler=wasm_cc,
|
|
other_compiler=cxx_compiler,
|
|
other_c_compiler=c_compiler,
|
|
)
|
|
check_wasm_compiler(wasm_cxx, "C++")
|
|
|
|
@depends(wasm_cxx, wasi_sysroot_flags)
|
|
def wasm_cxx_with_flags(wasm_cxx, wasi_sysroot_flags):
|
|
return wasm_compiler_with_flags(wasm_cxx, wasi_sysroot_flags)
|
|
|
|
set_config("WASM_CXX", wasm_cxx_with_flags)
|
|
|
|
wasm_compile_flags = dependable(["-fno-exceptions", "-fno-strict-aliasing"])
|
|
option(env="WASM_CFLAGS", nargs=1, help="Options to pass to WASM_CC")
|
|
|
|
@depends("WASM_CFLAGS", wasm_compile_flags)
|
|
def wasm_cflags(value, wasm_compile_flags):
|
|
if value:
|
|
return wasm_compile_flags + value
|
|
else:
|
|
return wasm_compile_flags
|
|
|
|
set_config("WASM_CFLAGS", wasm_cflags)
|
|
|
|
option(env="WASM_CXXFLAGS", nargs=1, help="Options to pass to WASM_CXX")
|
|
|
|
@depends("WASM_CXXFLAGS", wasm_compile_flags)
|
|
def wasm_cxxflags(value, wasm_compile_flags):
|
|
if value:
|
|
return wasm_compile_flags + value
|
|
else:
|
|
return wasm_compile_flags
|
|
|
|
set_config("WASM_CXXFLAGS", wasm_cxxflags)
|
|
|
|
|
|
@depends("--with-wasm-sandboxed-libraries")
|
|
def wasm_sandboxing(libraries):
|
|
if not libraries:
|
|
return
|
|
|
|
return namespace(**{name: True for name in libraries})
|
|
|
|
|
|
@template
|
|
def wasm_sandboxing_config_defines():
|
|
for lib in wasm_sandboxing_libraries():
|
|
set_config(
|
|
"MOZ_WASM_SANDBOXING_%s" % lib.upper(), getattr(wasm_sandboxing, lib)
|
|
)
|
|
set_define(
|
|
"MOZ_WASM_SANDBOXING_%s" % lib.upper(), getattr(wasm_sandboxing, lib)
|
|
)
|
|
|
|
|
|
wasm_sandboxing_config_defines()
|
|
|
|
|
|
with only_when(compile_environment & wasm_sandboxing.hunspell):
|
|
clock_in_wasi_sysroot = wasm_cc.try_run(
|
|
header="#include <time.h>",
|
|
body="clock();",
|
|
check_msg="for clock() in wasi sysroot",
|
|
flags=depends(wasi_sysroot_flags)(
|
|
lambda sysroot_flags: ["-Werror"] + sysroot_flags
|
|
),
|
|
)
|
|
|
|
wasi_emulated_clock = wasm_cc.try_run(
|
|
header="#include <time.h>",
|
|
body="clock();",
|
|
check_msg="for emulated clock() in wasi sysroot",
|
|
flags=depends(wasi_sysroot_flags)(
|
|
lambda sysroot_flags: [
|
|
"-Werror",
|
|
"-D_WASI_EMULATED_PROCESS_CLOCKS",
|
|
"-lwasi-emulated-process-clocks",
|
|
]
|
|
+ sysroot_flags
|
|
),
|
|
when=depends(clock_in_wasi_sysroot)(lambda x: not x),
|
|
onerror=lambda: die("Can't find clock() in wasi sysroot."),
|
|
)
|
|
|
|
set_config("MOZ_WASI_EMULATED_CLOCK", True, when=wasi_emulated_clock)
|
|
|
|
|
|
# Auxiliary files persistence on application close
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--enable-disk-remnant-avoidance",
|
|
help="Prevent persistence of auxiliary files on application close",
|
|
)
|
|
|
|
|
|
set_config(
|
|
"MOZ_AVOID_DISK_REMNANT_ON_CLOSE",
|
|
True,
|
|
when="--enable-disk-remnant-avoidance",
|
|
)
|
|
|
|
|
|
# Glean SDK Integration Crate
|
|
# ==============================================================
|
|
|
|
|
|
@depends(target)
|
|
def glean_android(target):
|
|
return target.os == "Android"
|
|
|
|
|
|
set_config("MOZ_GLEAN_ANDROID", True, when=glean_android)
|
|
set_define("MOZ_GLEAN_ANDROID", True, when=glean_android)
|
|
|
|
|
|
# dump_syms
|
|
# ==============================================================
|
|
|
|
check_prog(
|
|
"DUMP_SYMS",
|
|
["dump_syms"],
|
|
allow_missing=True,
|
|
bootstrap="dump_syms",
|
|
when=compile_environment,
|
|
)
|
|
|
|
|
|
@depends(valid_windows_sdk_dir, host)
|
|
@imports(_from="os", _import="environ")
|
|
def pdbstr_paths(valid_windows_sdk_dir, host):
|
|
if not valid_windows_sdk_dir:
|
|
return
|
|
|
|
vc_host = {
|
|
"x86": "x86",
|
|
"x86_64": "x64",
|
|
"aarch64": "arm64",
|
|
}.get(host.cpu)
|
|
|
|
return [
|
|
environ["PATH"],
|
|
os.path.join(valid_windows_sdk_dir.path, "Debuggers", vc_host, "srcsrv"),
|
|
]
|
|
|
|
|
|
@depends("MOZ_AUTOMATION", c_compiler)
|
|
def allow_missing_wintools(automation, c_compiler):
|
|
if not automation:
|
|
return True
|
|
if c_compiler and c_compiler.type != "clang-cl":
|
|
return True
|
|
|
|
|
|
check_prog(
|
|
"PDBSTR",
|
|
["pdbstr.exe"],
|
|
allow_missing=allow_missing_wintools,
|
|
when=compile_environment & target_is_windows,
|
|
paths=pdbstr_paths,
|
|
allow_spaces=True,
|
|
)
|
|
|
|
|
|
check_prog(
|
|
"WINCHECKSEC",
|
|
["winchecksec.exe", "winchecksec"],
|
|
bootstrap="winchecksec",
|
|
allow_missing=allow_missing_wintools,
|
|
when=compile_environment & target_is_windows,
|
|
)
|
|
|
|
|
|
# Fork server
|
|
@depends(target, build_project)
|
|
def forkserver_default(target, build_project):
|
|
return build_project == "browser" and (
|
|
(target.os == "GNU" and target.kernel == "Linux")
|
|
or target.os == "FreeBSD"
|
|
or target.os == "OpenBSD"
|
|
)
|
|
|
|
|
|
option(
|
|
"--enable-forkserver",
|
|
default=forkserver_default,
|
|
env="MOZ_ENABLE_FORKSERVER",
|
|
help="{Enable|Disable} fork server",
|
|
)
|
|
|
|
|
|
@depends("--enable-forkserver", target)
|
|
def forkserver_flag(value, target):
|
|
if (
|
|
target.os == "Android"
|
|
or (target.os == "GNU" and target.kernel == "Linux")
|
|
or target.os == "FreeBSD"
|
|
or target.os == "OpenBSD"
|
|
):
|
|
return bool(value)
|
|
pass
|
|
|
|
|
|
set_config("MOZ_ENABLE_FORKSERVER", forkserver_flag)
|
|
set_define("MOZ_ENABLE_FORKSERVER", forkserver_flag, forkserver_flag)
|
|
|
|
# Crash Reporter
|
|
# ==============================================================
|
|
|
|
with only_when(compile_environment & target_has_linux_kernel):
|
|
# Check if we need to use the breakpad_getcontext fallback.
|
|
getcontext = check_symbol("getcontext")
|
|
set_config("HAVE_GETCONTEXT", getcontext)
|
|
set_define("HAVE_GETCONTEXT", getcontext)
|
|
|
|
# NSS
|
|
# ==============================================================
|
|
include("../build/moz.configure/nss.configure")
|
|
|
|
|
|
# Enable or disable running in background task mode: headless for
|
|
# periodic, short-lived, maintenance tasks.
|
|
# ==============================================================================
|
|
option(
|
|
"--disable-backgroundtasks",
|
|
help="Disable running in background task mode",
|
|
)
|
|
set_config("MOZ_BACKGROUNDTASKS", True, when="--enable-backgroundtasks")
|
|
set_define("MOZ_BACKGROUNDTASKS", True, when="--enable-backgroundtasks")
|
|
|
|
|
|
# Update-related programs: updater, maintenance service, update agent,
|
|
# default browser agent.
|
|
# ==============================================================
|
|
include("../build/moz.configure/update-programs.configure")
|
|
|
|
|
|
# Mobile optimizations
|
|
# ==============================================================
|
|
option(
|
|
"--enable-mobile-optimize",
|
|
default=target_is_android,
|
|
help="{Enable|Disable} mobile optimizations",
|
|
)
|
|
|
|
set_define("MOZ_GFX_OPTIMIZE_MOBILE", True, when="--enable-mobile-optimize")
|
|
# We ignore "paint will resample" on mobile for performance.
|
|
# We may want to revisit this later.
|
|
set_define("MOZ_IGNORE_PAINT_WILL_RESAMPLE", True, when="--enable-mobile-optimize")
|
|
|
|
# Pref extensions
|
|
# ==============================================================
|
|
option("--disable-pref-extensions", help="Disable pref extensions such as autoconfig")
|
|
set_config("MOZ_PREF_EXTENSIONS", True, when="--enable-pref-extensions")
|
|
|
|
# Offer a way to disable the startup cache
|
|
# ==============================================================
|
|
option("--disable-startupcache", help="Disable startup cache")
|
|
|
|
|
|
@depends("--enable-startupcache")
|
|
def enable_startupcache(value):
|
|
if value:
|
|
return True
|
|
|
|
|
|
set_define(
|
|
"MOZ_DISABLE_STARTUPCACHE", True, when=depends(enable_startupcache)(lambda x: not x)
|
|
)
|
|
|
|
|
|
# Branding
|
|
# ==============================================================
|
|
option(
|
|
env="MOZ_APP_REMOTINGNAME",
|
|
nargs=1,
|
|
help="Used for the internal program name, which affects profile name "
|
|
"and remoting. If not set, defaults to MOZ_APP_NAME if the update channel "
|
|
"is release, and MOZ_APP_NAME-MOZ_UPDATE_CHANNEL otherwise.",
|
|
)
|
|
|
|
|
|
@depends("MOZ_APP_REMOTINGNAME", moz_app_name, update_channel)
|
|
def moz_app_remotingname(value, moz_app_name, update_channel):
|
|
if value:
|
|
return value[0]
|
|
if update_channel == "release":
|
|
return moz_app_name
|
|
return moz_app_name + "-" + update_channel
|
|
|
|
|
|
set_config("MOZ_APP_REMOTINGNAME", moz_app_remotingname)
|
|
|
|
option(
|
|
env="ANDROID_PACKAGE_NAME",
|
|
nargs=1,
|
|
help="Name of the Android package (default org.mozilla.$MOZ_APP_NAME)",
|
|
)
|
|
|
|
|
|
@depends("ANDROID_PACKAGE_NAME", moz_app_name)
|
|
def android_package_name(value, moz_app_name):
|
|
if value:
|
|
return value[0]
|
|
if moz_app_name == "fennec":
|
|
return "org.mozilla.fennec_aurora"
|
|
return "org.mozilla.%s" % moz_app_name
|
|
|
|
|
|
set_config("ANDROID_PACKAGE_NAME", android_package_name)
|
|
|
|
|
|
# Miscellaneous options
|
|
# ==============================================================
|
|
option(env="MOZ_WINCONSOLE", nargs="?", help="Whether we can create a console window.")
|
|
set_define("MOZ_WINCONSOLE", True, when=depends("MOZ_WINCONSOLE")(lambda x: x))
|
|
|
|
|
|
# Alternative Crashreporter setting
|
|
option(
|
|
"--with-crashreporter-url",
|
|
env="MOZ_CRASHREPORTER_URL",
|
|
default="https://crash-reports.mozilla.com/",
|
|
nargs=1,
|
|
help="Set an alternative crashreporter url",
|
|
)
|
|
|
|
set_config(
|
|
"MOZ_CRASHREPORTER_URL",
|
|
depends("--with-crashreporter-url")(lambda x: x[0].rstrip("/")),
|
|
)
|
|
|
|
|
|
# Crash reporter options
|
|
# ==============================================================
|
|
@depends(target)
|
|
def oxidized_breakpad(target):
|
|
if target.kernel == "Linux":
|
|
return target.cpu in ("aarch64", "arm", "x86", "x86_64")
|
|
return False
|
|
|
|
|
|
set_config("MOZ_OXIDIZED_BREAKPAD", True, when=oxidized_breakpad)
|
|
set_define("MOZ_OXIDIZED_BREAKPAD", True, when=oxidized_breakpad)
|
|
|
|
# Environment variable to mock the crashreporter for testing
|
|
option(env="MOZ_CRASHREPORTER_MOCK", help="Mock the crashreporter to test native GUIs")
|
|
set_config("MOZ_CRASHREPORTER_MOCK", True, when="MOZ_CRASHREPORTER_MOCK")
|
|
|
|
|
|
# Wine
|
|
# ==============================================================
|
|
@depends(target, host)
|
|
def want_wine(target, host):
|
|
return target.kernel == "WINNT" and host.kernel != "WINNT"
|
|
|
|
|
|
wine = check_prog(
|
|
"WINE",
|
|
["wine64", "wine"],
|
|
when=want_wine,
|
|
bootstrap="wine/bin",
|
|
)
|
|
|
|
# DOM Streams
|
|
# ==============================================================
|
|
# Set this to true so the JS engine knows we're doing a browser build.
|
|
set_config("MOZ_DOM_STREAMS", True)
|
|
set_define("MOZ_DOM_STREAMS", True)
|
|
|
|
# libevent
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
system_lib_option(
|
|
"--with-system-libevent",
|
|
nargs="?",
|
|
help="Use system libevent",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
@depends("--with-system-libevent", when=use_pkg_config)
|
|
def deprecated_system_libevent_path(value):
|
|
if len(value) == 1:
|
|
die(
|
|
"--with-system-libevent=PATH is not supported anymore. Please use "
|
|
"--with-system-libevent and set any necessary pkg-config environment variable."
|
|
)
|
|
|
|
pkg_check_modules("MOZ_LIBEVENT", "libevent", when="--with-system-libevent")
|
|
|
|
set_config("MOZ_SYSTEM_LIBEVENT", True, when="--with-system-libevent")
|
|
|
|
|
|
# Crash reporting
|
|
# ==============================================================
|
|
@depends(target, developer_options, artifact_builds)
|
|
def crashreporter_default(target, developer_options, artifacts):
|
|
if target.os in ("WINNT", "OSX"):
|
|
return True
|
|
if target.kernel == "Linux" and target.cpu in ("x86", "x86_64", "arm", "aarch64"):
|
|
# The crash reporter prevents crash stacktraces to be logged in the
|
|
# logs on Android, so we leave it out by default in developer builds.
|
|
return target.os != "Android" or not developer_options or artifacts
|
|
|
|
|
|
option(
|
|
"--enable-crashreporter",
|
|
default=crashreporter_default,
|
|
help="{Enable|Disable} crash reporting",
|
|
)
|
|
|
|
|
|
set_config("MOZ_CRASHREPORTER", True, when="--enable-crashreporter")
|
|
set_define("MOZ_CRASHREPORTER", True, when="--enable-crashreporter")
|
|
|
|
with only_when(compile_environment):
|
|
with only_when("--enable-crashreporter"):
|
|
pkg_check_modules(
|
|
"MOZ_GTHREAD",
|
|
"gthread-2.0",
|
|
when=depends(target)(lambda t: t.os == "GNU" and t.kernel == "Linux"),
|
|
)
|
|
|
|
|
|
# If we have any service that uploads data (and requires data submission
|
|
# policy alert), set MOZ_DATA_REPORTING.
|
|
# ==============================================================
|
|
@depends(
|
|
"MOZ_TELEMETRY_REPORTING",
|
|
"MOZ_SERVICES_HEALTHREPORT",
|
|
"--enable-crashreporter",
|
|
"MOZ_NORMANDY",
|
|
)
|
|
def data_reporting(telemetry, healthreport, crashreporter, normandy):
|
|
return telemetry or healthreport or crashreporter or normandy
|
|
|
|
|
|
set_config("MOZ_DATA_REPORTING", True, when=data_reporting)
|
|
set_define("MOZ_DATA_REPORTING", True, when=data_reporting)
|
|
|
|
|
|
# Gtk+
|
|
# ==============================================================
|
|
with only_when(toolkit_gtk):
|
|
pkg_check_modules(
|
|
"MOZ_GTK3",
|
|
"gtk+-3.0 >= 3.14.0 gtk+-unix-print-3.0 glib-2.0 gobject-2.0 gio-unix-2.0",
|
|
)
|
|
|
|
set_define("GDK_VERSION_MIN_REQUIRED", "GDK_VERSION_3_14")
|
|
set_define("GDK_VERSION_MAX_ALLOWED", "GDK_VERSION_3_14")
|
|
|
|
pkg_check_modules("GLIB", "glib-2.0 >= 2.42 gobject-2.0")
|
|
|
|
set_define("GLIB_VERSION_MIN_REQUIRED", "GLIB_VERSION_2_42")
|
|
set_define("GLIB_VERSION_MAX_ALLOWED", "GLIB_VERSION_2_42")
|
|
|
|
set_define("MOZ_ACCESSIBILITY_ATK", True, when=accessibility)
|
|
|
|
# DBus
|
|
# ==============================================================
|
|
with only_when(toolkit_gtk):
|
|
option("--disable-dbus", help="Disable dbus support", when=use_pkg_config)
|
|
|
|
@depends("--enable-dbus", when=use_pkg_config)
|
|
def enable_dbus_option(enable_dbus):
|
|
return enable_dbus
|
|
|
|
with only_when(enable_dbus_option):
|
|
pkg_check_modules("MOZ_DBUS", "dbus-1 >= 0.60")
|
|
|
|
set_config("MOZ_ENABLE_DBUS", True)
|
|
set_define("MOZ_ENABLE_DBUS", True)
|
|
|
|
|
|
# Necko's wifi scanner
|
|
# ==============================================================
|
|
@depends(target)
|
|
def necko_wifi_when(target):
|
|
return target.os in ("WINNT", "OSX", "DragonFly", "FreeBSD") or (
|
|
target.kernel == "Linux" and target.os == "GNU"
|
|
)
|
|
|
|
|
|
option("--disable-necko-wifi", help="Disable necko wifi scanner", when=necko_wifi_when)
|
|
|
|
set_config("NECKO_WIFI", True, when="--enable-necko-wifi")
|
|
set_define("NECKO_WIFI", True, when="--enable-necko-wifi")
|
|
|
|
|
|
@depends(
|
|
depends("--enable-necko-wifi", when=necko_wifi_when)(lambda x: x),
|
|
depends(enable_dbus_option, when=toolkit_gtk)(lambda x: x),
|
|
when=use_pkg_config
|
|
& depends(target)(lambda t: t.os == "GNU" and t.kernel == "Linux"),
|
|
)
|
|
def necko_wifi_dbus(necko_wifi, dbus):
|
|
if necko_wifi and not dbus:
|
|
die(
|
|
"Necko WiFi scanning needs DBus on your platform, remove --disable-dbus"
|
|
" or use --disable-necko-wifi"
|
|
)
|
|
return necko_wifi and dbus
|
|
|
|
|
|
set_config("NECKO_WIFI_DBUS", True, when=necko_wifi_dbus)
|
|
set_define("NECKO_WIFI_DBUS", True, when=necko_wifi_dbus)
|
|
|
|
|
|
# Frontend JS debug mode
|
|
# ==============================================================
|
|
option("--enable-debug-js-modules", help="Enable debug mode for frontend JS libraries")
|
|
|
|
set_config("DEBUG_JS_MODULES", True, when="--enable-debug-js-modules")
|
|
|
|
|
|
# moz_dump_painting
|
|
# ==============================================================
|
|
option("--enable-dump-painting", help="Enable paint debugging")
|
|
|
|
set_define(
|
|
"MOZ_DUMP_PAINTING",
|
|
True,
|
|
when=depends("--enable-dump-painting", "--enable-debug")(
|
|
lambda painting, debug: painting or debug
|
|
),
|
|
)
|
|
set_define("MOZ_LAYERS_HAVE_LOG", True, when="--enable-dump-painting")
|
|
|
|
|
|
# libproxy support
|
|
# ==============================================================
|
|
with only_when(toolkit_gtk):
|
|
system_lib_option(
|
|
"--enable-libproxy",
|
|
help="Enable libproxy support",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
with only_when("--enable-libproxy"):
|
|
pkg_check_modules("MOZ_LIBPROXY", "libproxy-1.0")
|
|
|
|
set_config("MOZ_ENABLE_LIBPROXY", True)
|
|
set_define("MOZ_ENABLE_LIBPROXY", True)
|
|
|
|
|
|
# Enable runtime logging
|
|
# ==============================================================
|
|
set_define("MOZ_LOGGING", True)
|
|
set_define("FORCE_PR_LOG", True)
|
|
|
|
# This will enable logging of addref, release, ctor, dtor.
|
|
# ==============================================================
|
|
option(
|
|
"--enable-logrefcnt",
|
|
default=moz_debug,
|
|
help="{Enable|Disable} logging of refcounts",
|
|
)
|
|
|
|
set_define("NS_BUILD_REFCNT_LOGGING", True, when="--enable-logrefcnt")
|
|
|
|
|
|
# NegotiateAuth
|
|
# ==============================================================
|
|
option("--disable-negotiateauth", help="Disable GSS-API negotiation")
|
|
|
|
set_config("MOZ_AUTH_EXTENSION", True, when="--enable-negotiateauth")
|
|
set_define("MOZ_AUTH_EXTENSION", True, when="--enable-negotiateauth")
|
|
|
|
|
|
# Parental control
|
|
# ==============================================================
|
|
option("--disable-parental-controls", help="Do not build parental controls")
|
|
|
|
set_config(
|
|
"MOZ_DISABLE_PARENTAL_CONTROLS",
|
|
True,
|
|
when=depends("--enable-parental-controls")(lambda x: not x),
|
|
)
|
|
set_define(
|
|
"MOZ_DISABLE_PARENTAL_CONTROLS",
|
|
True,
|
|
when=depends("--enable-parental-controls")(lambda x: not x),
|
|
)
|
|
|
|
# Automation renaming
|
|
# ==============================================================
|
|
|
|
with only_when("MOZ_AUTOMATION"):
|
|
option(env="MOZ_SIMPLE_PACKAGE_NAME", nargs=1, help="Package name override")
|
|
set_config(
|
|
"MOZ_SIMPLE_PACKAGE_NAME", depends_if("MOZ_SIMPLE_PACKAGE_NAME")(lambda x: x[0])
|
|
)
|
|
option(env="MOZ_PKG_SPECIAL", nargs=1, help="Name of special moz flavor")
|
|
set_config("MOZ_PKG_SPECIAL", depends_if("MOZ_PKG_SPECIAL")(lambda x: x[0]))
|
|
|
|
|
|
# OSX Packaging
|
|
# ==============================================================
|
|
|
|
with only_when(target_is_osx):
|
|
option(
|
|
"--with-macbundlename-prefix",
|
|
nargs=1,
|
|
help="prefix for the mac bundle name",
|
|
)
|
|
|
|
@depends_if("--with-macbundlename-prefix")
|
|
def mac_bundle_name(value):
|
|
return value[0]
|
|
|
|
add_old_configure_assignment("MOZ_MACBUNDLE_NAME_PREFIX", mac_bundle_name)
|
|
|
|
option(env="DMG_TOOL", nargs=1, help="Path to the dmg tool")
|
|
set_config("DMG_TOOL", depends_if("DMG_TOOL")(lambda x: x[0]))
|
|
|
|
|
|
# JS Packaging
|
|
# ==============================================================
|
|
|
|
option(
|
|
env="MOZ_PACKAGE_JSSHELL",
|
|
help="whether the installer bundles the JS shell",
|
|
)
|
|
set_config("MOZ_PACKAGE_JSSHELL", depends_if("MOZ_PACKAGE_JSSHELL")(lambda x: bool(x)))
|
|
|
|
|
|
# Sandboxing support
|
|
# ==============================================================
|
|
@depends(target, tsan, asan)
|
|
def sandbox_default(target, tsan, asan):
|
|
# Only enable the sandbox by default on Linux, OpenBSD, macOS, and Windows
|
|
if target.kernel == "Linux" and target.os == "GNU":
|
|
# Bug 1182565: TSan conflicts with sandboxing on Linux.
|
|
# Bug 1287971: LSan also conflicts with sandboxing on Linux.
|
|
if tsan or asan:
|
|
return False
|
|
# Linux sandbox is only available on x86{,_64} and arm{,64}.
|
|
return target.cpu in ("x86", "x86_64", "arm", "aarch64")
|
|
return target.kernel in ("WINNT", "Darwin", "OpenBSD")
|
|
|
|
|
|
option(
|
|
"--enable-sandbox",
|
|
default=sandbox_default,
|
|
help="{Enable|Disable} sandboxing support",
|
|
)
|
|
|
|
set_config("MOZ_SANDBOX", True, when="--enable-sandbox")
|
|
set_define("MOZ_SANDBOX", True, when="--enable-sandbox")
|
|
|
|
# Searching of system directories for extensions.
|
|
# ==============================================================
|
|
# Note: this switch is meant to be used for test builds whose behavior should
|
|
# not depend on what happens to be installed on the local machine.
|
|
option(
|
|
"--disable-system-extension-dirs",
|
|
help="Disable searching system- and account-global directories for extensions"
|
|
" of any kind; use only profile-specific extension directories",
|
|
)
|
|
|
|
set_define("ENABLE_SYSTEM_EXTENSION_DIRS", True, when="--enable-system-extension-dirs")
|
|
|
|
|
|
# Pixman
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
system_lib_option(
|
|
"--enable-system-pixman",
|
|
help="Use system pixman (located with pkgconfig)",
|
|
when=use_pkg_config,
|
|
)
|
|
|
|
@depends("--enable-system-pixman", when=use_pkg_config)
|
|
def enable_system_pixman_option(enable_system_pixman):
|
|
return enable_system_pixman
|
|
|
|
@depends(enable_system_pixman_option)
|
|
def in_tree_pixman(pixman):
|
|
return not pixman
|
|
|
|
set_config("MOZ_TREE_PIXMAN", True, when=in_tree_pixman)
|
|
set_define("MOZ_TREE_PIXMAN", True, when=in_tree_pixman)
|
|
|
|
pkg_check_modules("MOZ_PIXMAN", "pixman-1 >= 0.40.0", when="--enable-system-pixman")
|
|
# Set MOZ_PIXMAN_CFLAGS to an explicit empty value when --enable-system-pixman is *not* used,
|
|
# for layout/style/extra-bindgen-flags
|
|
set_config("MOZ_PIXMAN_CFLAGS", [], when=in_tree_pixman)
|
|
|
|
|
|
# Universalchardet
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
option("--disable-universalchardet", help="Disable universal encoding detection")
|
|
|
|
set_config("MOZ_UNIVERSALCHARDET", True, when="--enable-universalchardet")
|
|
|
|
|
|
# Disable zipwriter
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
option("--disable-zipwriter", help="Disable zipwriter component")
|
|
|
|
set_config("MOZ_ZIPWRITER", True, when="--enable-zipwriter")
|
|
|
|
|
|
# Location of the mozilla user directory
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
|
|
@depends(target)
|
|
def default_user_appdir(target):
|
|
if target.kernel in ("WINNT", "Darwin"):
|
|
return "Mozilla"
|
|
return ".mozilla"
|
|
|
|
option(
|
|
"--with-user-appdir",
|
|
nargs=1,
|
|
default=default_user_appdir,
|
|
help="Set user-specific appdir",
|
|
)
|
|
|
|
@depends("--with-user-appdir")
|
|
def user_appdir(appdir):
|
|
if not appdir:
|
|
die("--without-user-appdir is not a valid option.")
|
|
if "/" in appdir[0]:
|
|
die("--with-user-appdir must be a single relative path.")
|
|
return '"{}"'.format(appdir[0])
|
|
|
|
set_define("MOZ_USER_DIR", user_appdir)
|
|
|
|
|
|
# Check for sin_len and sin6_len - used by SCTP; only appears in Mac/*BSD generally
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
have_sin_len = c_compiler.try_compile(
|
|
includes=["netinet/in.h"],
|
|
body="struct sockaddr_in x; void *foo = (void*) &x.sin_len;",
|
|
check_msg="for sin_len in struct sockaddr_in",
|
|
)
|
|
have_sin6_len = c_compiler.try_compile(
|
|
includes=["netinet/in.h"],
|
|
body="struct sockaddr_in6 x; void *foo = (void*) &x.sin6_len;",
|
|
check_msg="for sin_len6 in struct sockaddr_in6",
|
|
)
|
|
set_define("HAVE_SIN_LEN", have_sin_len)
|
|
set_define("HAVE_SIN6_LEN", have_sin6_len)
|
|
# HAVE_CONN_LEN must be the same as HAVE_SIN_LEN and HAVE_SIN6_LEN
|
|
set_define("HAVE_SCONN_LEN", have_sin_len & have_sin6_len)
|
|
set_define(
|
|
"HAVE_SA_LEN",
|
|
c_compiler.try_compile(
|
|
includes=["netinet/in.h"],
|
|
body="struct sockaddr x; void *foo = (void*) &x.sa_len;",
|
|
check_msg="for sa_len in struct sockaddr",
|
|
),
|
|
)
|
|
|
|
|
|
# Check for pthread_cond_timedwait_monotonic_np
|
|
# ==============================================================
|
|
with only_when(compile_environment):
|
|
set_define(
|
|
"HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC",
|
|
c_compiler.try_compile(
|
|
includes=["pthread.h"],
|
|
body="pthread_cond_timedwait_monotonic_np(0, 0, 0);",
|
|
# -Werror to catch any "implicit declaration" warning that means the function
|
|
# is not supported.
|
|
flags=["-Werror=implicit-function-declaration"],
|
|
check_msg="for pthread_cond_timedwait_monotonic_np",
|
|
),
|
|
)
|
|
|
|
|
|
# Custom dynamic linker for Android
|
|
# ==============================================================
|
|
with only_when(target_has_linux_kernel & compile_environment):
|
|
option(
|
|
env="MOZ_LINKER",
|
|
default=depends(target.os, when="--enable-jemalloc")(
|
|
lambda os: os == "Android"
|
|
),
|
|
help="{Enable|Disable} custom dynamic linker",
|
|
)
|
|
|
|
set_config("MOZ_LINKER", True, when="MOZ_LINKER")
|
|
set_define("MOZ_LINKER", True, when="MOZ_LINKER")
|
|
|
|
# gold emits wrong sysv-style elf hash tables when building both sysv and
|
|
# GNU style tables. https://sourceware.org/bugzilla/show_bug.cgi?id=13597
|
|
# Since the linker only understands the sysv ones, no need to build the
|
|
# GNU style tables anyways.
|
|
check_and_add_linker_flag("-Wl,--hash-style=sysv", when="MOZ_LINKER")
|
|
|
|
|
|
# 32-bits ethtool_cmd.speed
|
|
# ==============================================================
|
|
with only_when(target_has_linux_kernel & compile_environment):
|
|
set_config(
|
|
"MOZ_WEBRTC_HAVE_ETHTOOL_SPEED_HI",
|
|
c_compiler.try_compile(
|
|
includes=["linux/ethtool.h"],
|
|
body="struct ethtool_cmd cmd; cmd.speed_hi = 0;",
|
|
check_msg="for 32-bits ethtool_cmd.speed",
|
|
),
|
|
)
|
|
|
|
# Gamepad support
|
|
# ==============================================================
|
|
check_header(
|
|
"linux/joystick.h",
|
|
onerror=lambda: die(
|
|
"Can't find header linux/joystick.h, needed for gamepad support."
|
|
" Please install Linux kernel headers."
|
|
),
|
|
when=target_has_linux_kernel & compile_environment,
|
|
)
|
|
|
|
|
|
# Smart card support
|
|
# ==============================================================
|
|
@depends(build_project)
|
|
def disable_smart_cards(build_project):
|
|
return build_project == "mobile/android"
|
|
|
|
|
|
set_config("MOZ_NO_SMART_CARDS", True, when=disable_smart_cards)
|
|
set_define("MOZ_NO_SMART_CARDS", True, when=disable_smart_cards)
|
|
|
|
# Enable UniFFI fixtures
|
|
# ==============================================================
|
|
# These are used to test the uniffi-bindgen-gecko-js code generation. They
|
|
# should not be enabled in release builds.
|
|
|
|
option(
|
|
"--enable-uniffi-fixtures",
|
|
help="Enable UniFFI Fixtures/Examples",
|
|
)
|
|
|
|
set_config("MOZ_UNIFFI_FIXTURES", True, when="--enable-uniffi-fixtures")
|
|
|
|
# System policies
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--disable-system-policies",
|
|
help="Disable reading policies from Windows registry, macOS's file system attributes, and /etc/firefox",
|
|
)
|
|
|
|
set_config("MOZ_SYSTEM_POLICIES", True, when="--enable-system-policies")
|
|
|
|
# Allow disabling the creation a legacy profile
|
|
# ==============================================================
|
|
|
|
option(
|
|
"--disable-legacy-profile-creation",
|
|
help="Disable the creation a legacy profile, to be used by old versions "
|
|
"of Firefox, when no profiles exist.",
|
|
)
|
|
|
|
set_config("MOZ_CREATE_LEGACY_PROFILE", True, when="--enable-legacy-profile-creation")
|
|
|
|
|
|
# STL wrapping
|
|
# ==============================================================
|
|
set_config("WRAP_STL_INCLUDES", True)
|
|
set_config(
|
|
"STL_FLAGS",
|
|
depends(build_environment.dist)(lambda dist: [f"-I{dist}/stl_wrappers"]),
|
|
)
|
|
|
|
|
|
# Perl detection
|
|
# ==============================================================
|
|
@depends(target)
|
|
def need_perl(target):
|
|
# Ideally, we'd also depend on gnu_as here, but that adds complications.
|
|
return target.cpu == "arm"
|
|
|
|
|
|
perl = check_prog("PERL", ("perl5", "perl"), when=need_perl)
|
|
|
|
|
|
@template
|
|
def perl_version_check(min_version):
|
|
@depends(perl)
|
|
@checking("for minimum required perl version >= %s" % min_version)
|
|
def get_perl_version(perl):
|
|
return Version(
|
|
check_cmd_output(
|
|
perl,
|
|
"-e",
|
|
"print $]",
|
|
onerror=lambda: die("Failed to get perl version."),
|
|
)
|
|
)
|
|
|
|
@depends(get_perl_version)
|
|
def check_perl_version(version):
|
|
if version < min_version:
|
|
die("Perl %s or higher is required.", min_version)
|
|
|
|
@depends(perl)
|
|
@checking("for full perl installation")
|
|
@imports("subprocess")
|
|
def has_full_perl_installation(perl):
|
|
ret = subprocess.call([perl, "-e", "use Config; exit(!-d $Config{archlib})"])
|
|
return ret == 0
|
|
|
|
@depends(has_full_perl_installation)
|
|
def require_full_perl_installation(has_full_perl_installation):
|
|
if not has_full_perl_installation:
|
|
die(
|
|
"Cannot find Config.pm or $Config{archlib}. "
|
|
"A full perl installation is required."
|
|
)
|
|
|
|
|
|
with only_when(need_perl):
|
|
perl_version_check("5.006")
|
|
|
|
|
|
# windows-rs as bootstrappable toolchain
|
|
# ==============================================================
|
|
# The in-tree windows crate's purpose is to avoid vendoring the
|
|
# original windows crate, which is too large.
|
|
# The ideal solution would be for cargo to allow exceptions to
|
|
# vendoring, but it doesn't.
|
|
# The adopted solution is to somehow use the crate contents from
|
|
# a directory given via the mozbuild config, or bootstrapped.
|
|
#
|
|
# Unfortunately, doing `include!(mozbuild::windows_rs_path!("src/lib.rs"))`
|
|
# in the crate's lib.rs, where `mozbuild::windows_rs_path!()` builds
|
|
# a path relative to MOZ_WINDOWS_RS_DIR defined below, doesn't work
|
|
# because of https://github.com/rust-lang/rust/issues/66920.
|
|
#
|
|
# Previous versions of the windows crate had submodules declared
|
|
# directly in lib.rs. Annotating each of them with
|
|
# `#[path = concat!(mozbuild::windows_rs_path!("path/to/mod.rs"))]`
|
|
# unfortunately also didn't work, because of
|
|
# https://github.com/rust-lang/rust/issues/48250.
|
|
#
|
|
# Thankfully, newer versions of the windows crate now only have an
|
|
# `include!` at the end of lib.rs, so we can get away with simply
|
|
# replacing it with an `include!` that uses `mozbuild::windows_rs_path!`.
|
|
#
|
|
# Well, that was only true up to a certain point, and even newer versions
|
|
# are back to using a submodule declared directly in lib.rs.
|
|
# To work around that, we use a macro in the mozbuild crate that
|
|
# expands to
|
|
# ```
|
|
# #[path = "/full/path/to/windows-rs/src/lib.rs"]
|
|
# mod lib;
|
|
# pub use lib::*;
|
|
# ```
|
|
# where the path is generated at build time instead of relying on more
|
|
# macros. This creates a submodule and re-exports everything it contains,
|
|
# making the crate appear as the original crate to its users.
|
|
#
|
|
# We ensure that the in-tree contents match what we expect based on
|
|
# the original crate.
|
|
# The expectations are as such:
|
|
# - Cargo.toml is identical to the original one with the addition of the
|
|
# following two lines at the end (after an empty line):
|
|
# [dependencies.mozbuild]
|
|
# version = "0.1"
|
|
with only_when(target_is_windows & compile_environment):
|
|
option(
|
|
env="MOZ_WINDOWS_RS_DIR",
|
|
nargs=1,
|
|
help="Path to the source of the 'windows' Rust crate",
|
|
)
|
|
|
|
@depends(
|
|
"MOZ_WINDOWS_RS_DIR",
|
|
bootstrap_path(
|
|
"windows-rs",
|
|
when=depends("MOZ_WINDOWS_RS_DIR")(lambda x: not x),
|
|
),
|
|
build_environment.topsrcdir,
|
|
)
|
|
@checking("for the windows rust crate source")
|
|
@imports(_from="__builtin__", _import="open")
|
|
@imports("re")
|
|
@imports("toml")
|
|
def windows_rs_dir(dir, bootstrapped, topsrcdir):
|
|
if bootstrapped:
|
|
dir = bootstrapped
|
|
elif dir:
|
|
dir = dir[0]
|
|
|
|
raw_cargo_toml = open(
|
|
os.path.join(topsrcdir, "build/rust/windows/Cargo.toml")
|
|
).read()
|
|
cargo_toml = toml.loads(raw_cargo_toml)
|
|
expected_version = cargo_toml["package"]["version"]
|
|
|
|
if not dir:
|
|
raise FatalCheckError(
|
|
"Cannot find the windows rust crate source.\n"
|
|
f"Try downloading it with `cargo download -x windows={expected_version}`\n"
|
|
"(you may need to `cargo install cargo-download` first)\n"
|
|
f"and set `MOZ_WINDOWS_RS_DIR` to location of the `windows-{expected_version}`"
|
|
" directory"
|
|
)
|
|
|
|
raw_cargo_toml_orig = open(os.path.join(dir, "Cargo.toml")).read()
|
|
cargo_toml = toml.loads(raw_cargo_toml_orig)
|
|
version = cargo_toml["package"]["version"]
|
|
if version != expected_version:
|
|
raise FatalCheckError(
|
|
f"The windows rust crate source in {dir} contains version "
|
|
f"{version}, but expected {expected_version}."
|
|
)
|
|
# Now that we've done the basic sanity check, let's go deeper.
|
|
DEPENDENCIES = '\n[dependencies.mozbuild]\nversion = "0.1"\n'
|
|
if not raw_cargo_toml.endswith(DEPENDENCIES):
|
|
configure_error("In-tree windows crate is missing dependency on mozbuild")
|
|
if raw_cargo_toml[: -len(DEPENDENCIES)] != raw_cargo_toml_orig:
|
|
configure_error("In-tree windows crate Cargo.toml doesn't match original")
|
|
|
|
return dir
|
|
|
|
set_config("MOZ_WINDOWS_RS_DIR", windows_rs_dir)
|