File Explorer

1# Copyright (c) 2013 Google Inc. All rights reserved.2# Use of this source code is governed by a BSD-style license that can be3# found in the LICENSE file.4 5# Notes:6#7# This is all roughly based on the Makefile system used by the Linux8# kernel, but is a non-recursive make -- we put the entire dependency9# graph in front of make and let it figure it out.10#11# The code below generates a separate .mk file for each target, but12# all are sourced by the top-level Makefile.  This means that all13# variables in .mk-files clobber one another.  Be careful to use :=14# where appropriate for immediate evaluation, and similarly to watch15# that you're not relying on a variable value to last between different16# .mk files.17#18# TODOs:19#20# Global settings and utility functions are currently stuffed in the21# toplevel Makefile.  It may make sense to generate some .mk files on22# the side to keep the files readable.23 24 25import hashlib26import os27import re28import subprocess29import sys30 31import gyp32import gyp.common33import gyp.xcode_emulation34from gyp.common import GetEnvironFallback35 36generator_default_variables = {37    "EXECUTABLE_PREFIX": "",38    "EXECUTABLE_SUFFIX": "",39    "STATIC_LIB_PREFIX": "lib",40    "SHARED_LIB_PREFIX": "lib",41    "STATIC_LIB_SUFFIX": ".a",42    "INTERMEDIATE_DIR": "$(obj).$(TOOLSET)/$(TARGET)/geni",43    "SHARED_INTERMEDIATE_DIR": "$(obj)/gen",44    "PRODUCT_DIR": "$(builddir)",45    "RULE_INPUT_ROOT": "%(INPUT_ROOT)s",  # This gets expanded by Python.46    "RULE_INPUT_DIRNAME": "%(INPUT_DIRNAME)s",  # This gets expanded by Python.47    "RULE_INPUT_PATH": "$(abspath $<)",48    "RULE_INPUT_EXT": "$(suffix $<)",49    "RULE_INPUT_NAME": "$(notdir $<)",50    "CONFIGURATION_NAME": "$(BUILDTYPE)",51}52 53# Make supports multiple toolsets54generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()55 56# Request sorted dependencies in the order from dependents to dependencies.57generator_wants_sorted_dependencies = False58 59# Placates pylint.60generator_additional_non_configuration_keys = []61generator_additional_path_sections = []62generator_extra_sources_for_rules = []63generator_filelist_paths = None64 65 66def CalculateVariables(default_variables, params):67    """Calculate additional variables for use in the build (called by gyp)."""68    flavor = gyp.common.GetFlavor(params)69    if flavor == "mac":70        default_variables.setdefault("OS", "mac")71        default_variables.setdefault("SHARED_LIB_SUFFIX", ".dylib")72        default_variables.setdefault(73            "SHARED_LIB_DIR", generator_default_variables["PRODUCT_DIR"]74        )75        default_variables.setdefault(76            "LIB_DIR", generator_default_variables["PRODUCT_DIR"]77        )78 79        # Copy additional generator configuration data from Xcode, which is shared80        # by the Mac Make generator.81        import gyp.generator.xcode as xcode_generator  # noqa: PLC041582 83        global generator_additional_non_configuration_keys84        generator_additional_non_configuration_keys = getattr(85            xcode_generator, "generator_additional_non_configuration_keys", []86        )87        global generator_additional_path_sections88        generator_additional_path_sections = getattr(89            xcode_generator, "generator_additional_path_sections", []90        )91        global generator_extra_sources_for_rules92        generator_extra_sources_for_rules = getattr(93            xcode_generator, "generator_extra_sources_for_rules", []94        )95        COMPILABLE_EXTENSIONS.update({".m": "objc", ".mm": "objcxx"})96    else:97        operating_system = flavor98        if flavor == "android":99            operating_system = "linux"  # Keep this legacy behavior for now.100        default_variables.setdefault("OS", operating_system)101        if flavor == "aix":102            default_variables.setdefault("SHARED_LIB_SUFFIX", ".a")103        elif flavor == "zos":104            default_variables.setdefault("SHARED_LIB_SUFFIX", ".x")105            COMPILABLE_EXTENSIONS.update({".pli": "pli"})106        else:107            default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")108        default_variables.setdefault("SHARED_LIB_DIR", "$(builddir)/lib.$(TOOLSET)")109        default_variables.setdefault("LIB_DIR", "$(obj).$(TOOLSET)")110 111 112def CalculateGeneratorInputInfo(params):113    """Calculate the generator specific info that gets fed to input (called by114    gyp)."""115    generator_flags = params.get("generator_flags", {})116    android_ndk_version = generator_flags.get("android_ndk_version", None)117    # Android NDK requires a strict link order.118    if android_ndk_version:119        global generator_wants_sorted_dependencies120        generator_wants_sorted_dependencies = True121 122    output_dir = params["options"].generator_output or params["options"].toplevel_dir123    builddir_name = generator_flags.get("output_dir", "out")124    qualified_out_dir = os.path.normpath(125        os.path.join(output_dir, builddir_name, "gypfiles")126    )127 128    global generator_filelist_paths129    generator_filelist_paths = {130        "toplevel": params["options"].toplevel_dir,131        "qualified_out_dir": qualified_out_dir,132    }133 134 135# The .d checking code below uses these functions:136# wildcard, sort, foreach, shell, wordlist137# wildcard can handle spaces, the rest can't.138# Since I could find no way to make foreach work with spaces in filenames139# correctly, the .d files have spaces replaced with another character. The .d140# file for141#     Chromium\ Framework.framework/foo142# is for example143#     out/Release/.deps/out/Release/Chromium?Framework.framework/foo144# This is the replacement character.145SPACE_REPLACEMENT = "?"146 147 148LINK_COMMANDS_LINUX = """\149quiet_cmd_alink = AR($(TOOLSET)) $@150cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)151 152quiet_cmd_alink_thin = AR($(TOOLSET)) $@153cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)154 155# Due to circular dependencies between libraries :(, we wrap the156# special "figure out circular dependencies" flags around the entire157# input list during linking.158quiet_cmd_link = LINK($(TOOLSET)) $@159cmd_link = $(LINK.$(TOOLSET)) -o $@ $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,--start-group $(LD_INPUTS) $(LIBS) -Wl,--end-group160 161# Note: this does not handle spaces in paths162define xargs163  $(1) $(word 1,$(2))164$(if $(word 2,$(2)),$(call xargs,$(1),$(wordlist 2,$(words $(2)),$(2))))165endef166 167define write-to-file168  @: >$(1)169$(call xargs,@printf "%s\\n" >>$(1),$(2))170endef171 172OBJ_FILE_LIST := ar-file-list173 174define create_archive175        rm -f $(1) $(1).$(OBJ_FILE_LIST); mkdir -p `dirname $(1)`176        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))177        $(AR.$(TOOLSET)) crs $(1) @$(1).$(OBJ_FILE_LIST)178endef179 180define create_thin_archive181        rm -f $(1) $(OBJ_FILE_LIST); mkdir -p `dirname $(1)`182        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))183        $(AR.$(TOOLSET)) crsT $(1) @$(1).$(OBJ_FILE_LIST)184endef185 186# We support two kinds of shared objects (.so):187# 1) shared_library, which is just bundling together many dependent libraries188# into a link line.189# 2) loadable_module, which is generating a module intended for dlopen().190#191# They differ only slightly:192# In the former case, we want to package all dependent code into the .so.193# In the latter case, we want to package just the API exposed by the194# outermost module.195# This means shared_library uses --whole-archive, while loadable_module doesn't.196# (Note that --whole-archive is incompatible with the --start-group used in197# normal linking.)198 199# Other shared-object link notes:200# - Set SONAME to the library filename so our binaries don't reference201# the local, absolute paths used on the link command-line.202quiet_cmd_solink = SOLINK($(TOOLSET)) $@203cmd_solink = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)204 205quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@206cmd_solink_module = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)207"""  # noqa: E501208 209LINK_COMMANDS_MAC = """\210quiet_cmd_alink = LIBTOOL-STATIC $@211cmd_alink = rm -f $@ && %(python)s gyp-mac-tool filter-libtool libtool $(GYP_LIBTOOLFLAGS) -static -o $@ $(filter %%.o,$^)212 213quiet_cmd_link = LINK($(TOOLSET)) $@214cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)215 216quiet_cmd_solink = SOLINK($(TOOLSET)) $@217cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)218 219quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@220cmd_solink_module = $(LINK.$(TOOLSET)) -bundle $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)221""" % {"python": sys.executable}  # noqa: E501222 223LINK_COMMANDS_ANDROID = """\224quiet_cmd_alink = AR($(TOOLSET)) $@225cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)226 227quiet_cmd_alink_thin = AR($(TOOLSET)) $@228cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)229 230# Note: this does not handle spaces in paths231define xargs232  $(1) $(word 1,$(2))233$(if $(word 2,$(2)),$(call xargs,$(1),$(wordlist 2,$(words $(2)),$(2))))234endef235 236define write-to-file237  @: >$(1)238$(call xargs,@printf "%s\\n" >>$(1),$(2))239endef240 241OBJ_FILE_LIST := ar-file-list242 243define create_archive244        rm -f $(1) $(1).$(OBJ_FILE_LIST); mkdir -p `dirname $(1)`245        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))246        $(AR.$(TOOLSET)) crs $(1) @$(1).$(OBJ_FILE_LIST)247endef248 249define create_thin_archive250        rm -f $(1) $(OBJ_FILE_LIST); mkdir -p `dirname $(1)`251        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))252        $(AR.$(TOOLSET)) crsT $(1) @$(1).$(OBJ_FILE_LIST)253endef254 255# Due to circular dependencies between libraries :(, we wrap the256# special "figure out circular dependencies" flags around the entire257# input list during linking.258quiet_cmd_link = LINK($(TOOLSET)) $@259quiet_cmd_link_host = LINK($(TOOLSET)) $@260cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)261cmd_link_host = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)262 263# Other shared-object link notes:264# - Set SONAME to the library filename so our binaries don't reference265# the local, absolute paths used on the link command-line.266quiet_cmd_solink = SOLINK($(TOOLSET)) $@267cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)268 269quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@270cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)271quiet_cmd_solink_module_host = SOLINK_MODULE($(TOOLSET)) $@272cmd_solink_module_host = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)273"""  # noqa: E501274 275 276LINK_COMMANDS_AIX = """\277quiet_cmd_alink = AR($(TOOLSET)) $@278cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) -X32_64 crs $@ $(filter %.o,$^)279 280quiet_cmd_alink_thin = AR($(TOOLSET)) $@281cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) -X32_64 crs $@ $(filter %.o,$^)282 283quiet_cmd_link = LINK($(TOOLSET)) $@284cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)285 286quiet_cmd_solink = SOLINK($(TOOLSET)) $@287cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)288 289quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@290cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)291"""  # noqa: E501292 293 294LINK_COMMANDS_OS400 = """\295quiet_cmd_alink = AR($(TOOLSET)) $@296cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) -X64 crs $@ $(filter %.o,$^)297 298quiet_cmd_alink_thin = AR($(TOOLSET)) $@299cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) -X64 crs $@ $(filter %.o,$^)300 301quiet_cmd_link = LINK($(TOOLSET)) $@302cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)303 304quiet_cmd_solink = SOLINK($(TOOLSET)) $@305cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)306 307quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@308cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)309"""  # noqa: E501310 311 312LINK_COMMANDS_OS390 = """\313quiet_cmd_alink = AR($(TOOLSET)) $@314cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)315 316quiet_cmd_alink_thin = AR($(TOOLSET)) $@317cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)318 319quiet_cmd_link = LINK($(TOOLSET)) $@320cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)321 322quiet_cmd_solink = SOLINK($(TOOLSET)) $@323cmd_solink = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)324 325quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@326cmd_solink_module = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)327"""  # noqa: E501328 329 330# Header of toplevel Makefile.331# This should go into the build tree, but it's easier to keep it here for now.332SHARED_HEADER = (333    """\334# We borrow heavily from the kernel build setup, though we are simpler since335# we don't have Kconfig tweaking settings on us.336 337# The implicit make rules have it looking for RCS files, among other things.338# We instead explicitly write all the rules we care about.339# It's even quicker (saves ~200ms) to pass -r on the command line.340MAKEFLAGS=-r341 342# The source directory tree.343srcdir := %(srcdir)s344abs_srcdir := $(abspath $(srcdir))345 346# The name of the builddir.347builddir_name ?= %(builddir)s348 349# The V=1 flag on command line makes us verbosely print command lines.350ifdef V351  quiet=352else353  quiet=quiet_354endif355 356# Specify BUILDTYPE=Release on the command line for a release build.357BUILDTYPE ?= %(default_configuration)s358 359# Directory all our build output goes into.360# Note that this must be two directories beneath src/ for unit tests to pass,361# as they reach into the src/ directory for data with relative paths.362builddir ?= $(builddir_name)/$(BUILDTYPE)363abs_builddir := $(abspath $(builddir))364depsdir := $(builddir)/.deps365 366# Object output directory.367obj := $(builddir)/obj368abs_obj := $(abspath $(obj))369 370# We build up a list of every single one of the targets so we can slurp in the371# generated dependency rule Makefiles in one pass.372all_deps :=373 374%(make_global_settings)s375 376CC.target ?= %(CC.target)s377CFLAGS.target ?= $(CPPFLAGS) $(CFLAGS)378CXX.target ?= %(CXX.target)s379CXXFLAGS.target ?= $(CPPFLAGS) $(CXXFLAGS)380LINK.target ?= %(LINK.target)s381LDFLAGS.target ?= $(LDFLAGS)382AR.target ?= %(AR.target)s383PLI.target ?= %(PLI.target)s384 385# C++ apps need to be linked with g++.386LINK ?= $(CXX.target)387 388# TODO(evan): move all cross-compilation logic to gyp-time so we don't need389# to replicate this environment fallback in make as well.390CC.host ?= %(CC.host)s391CFLAGS.host ?= $(CPPFLAGS_host) $(CFLAGS_host)392CXX.host ?= %(CXX.host)s393CXXFLAGS.host ?= $(CPPFLAGS_host) $(CXXFLAGS_host)394LINK.host ?= %(LINK.host)s395LDFLAGS.host ?= $(LDFLAGS_host)396AR.host ?= %(AR.host)s397PLI.host ?= %(PLI.host)s398 399# Define a dir function that can handle spaces.400# http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions401# "leading spaces cannot appear in the text of the first argument as written.402# These characters can be put into the argument value by variable substitution."403empty :=404space := $(empty) $(empty)405 406# http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces407replace_spaces = $(subst $(space),"""408    + SPACE_REPLACEMENT409    + """,$1)410unreplace_spaces = $(subst """411    + SPACE_REPLACEMENT412    + """,$(space),$1)413dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1)))414 415# Flags to make gcc output dependency info.  Note that you need to be416# careful here to use the flags that ccache and distcc can understand.417# We write to a dep file on the side first and then rename at the end418# so we can't end up with a broken dep file.419depfile = $(depsdir)/$(call replace_spaces,$@).d420DEPFLAGS = %(makedep_args)s -MF $(depfile).raw421 422# We have to fixup the deps output in a few ways.423# (1) the file output should mention the proper .o file.424# ccache or distcc lose the path to the target, so we convert a rule of425# the form:426#   foobar.o: DEP1 DEP2427# into428#   path/to/foobar.o: DEP1 DEP2429# (2) we want missing files not to cause us to fail to build.430# We want to rewrite431#   foobar.o: DEP1 DEP2 \\432#               DEP3433# to434#   DEP1:435#   DEP2:436#   DEP3:437# so if the files are missing, they're just considered phony rules.438# We have to do some pretty insane escaping to get those backslashes439# and dollar signs past make, the shell, and sed at the same time.440# Doesn't work with spaces, but that's fine: .d files have spaces in441# their names replaced with other characters."""442    r"""443define fixup_dep444# The depfile may not exist if the input file didn't have any #includes.445touch $(depfile).raw446# Fixup path as in (1)."""447    + (448        r"""449sed -e "s|^$(notdir $@)|$@|" -re 's/\\\\([^$$])/\/\1/g' $(depfile).raw >> $(depfile)"""450        if sys.platform == "win32"451        else r"""452sed -e "s|^$(notdir $@)|$@|" $(depfile).raw >> $(depfile)"""453    )454    + r"""455# Add extra rules as in (2).456# We remove slashes and replace spaces with new lines;457# remove blank lines;458# delete the first line and append a colon to the remaining lines."""459    + (460        """461sed -e 's/\\\\\\\\$$//' -e 's/\\\\\\\\/\\//g' -e 'y| |\\n|' $(depfile).raw |\\"""462        if sys.platform == "win32"463        else """464sed -e 's|\\\\||' -e 'y| |\\n|' $(depfile).raw |\\"""465    )466    + r"""467  grep -v '^$$'                             |\468  sed -e 1d -e 's|$$|:|'                     \469    >> $(depfile)470rm $(depfile).raw471endef472"""473    """474# Command definitions:475# - cmd_foo is the actual command to run;476# - quiet_cmd_foo is the brief-output summary of the command.477 478quiet_cmd_cc = CC($(TOOLSET)) $@479cmd_cc = $(CC.$(TOOLSET)) -o $@ $< $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c480 481quiet_cmd_cxx = CXX($(TOOLSET)) $@482cmd_cxx = $(CXX.$(TOOLSET)) -o $@ $< $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c483%(extra_commands)s484quiet_cmd_touch = TOUCH $@485cmd_touch = touch $@486 487quiet_cmd_copy = COPY $@488# send stderr to /dev/null to ignore messages when linking directories.489cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp %(copy_archive_args)s "$<" "$@")490 491quiet_cmd_symlink = SYMLINK $@492cmd_symlink = ln -sf "$<" "$@"493 494%(link_commands)s495"""  # noqa: E501496    r"""497# Define an escape_quotes function to escape single quotes.498# This allows us to handle quotes properly as long as we always use499# use single quotes and escape_quotes.500escape_quotes = $(subst ','\'',$(1))501# This comment is here just to include a ' to unconfuse syntax highlighting.502# Define an escape_vars function to escape '$' variable syntax.503# This allows us to read/write command lines with shell variables (e.g.504# $LD_LIBRARY_PATH), without triggering make substitution.505escape_vars = $(subst $$,$$$$,$(1))506# Helper that expands to a shell command to echo a string exactly as it is in507# make. This uses printf instead of echo because printf's behaviour with respect508# to escape sequences is more portable than echo's across different shells509# (e.g., dash, bash).510exact_echo = printf '%%s\n' '$(call escape_quotes,$(1))'511"""512    """513# Helper to compare the command we're about to run against the command514# we logged the last time we ran the command.  Produces an empty515# string (false) when the commands match.516# Tricky point: Make has no string-equality test function.517# The kernel uses the following, but it seems like it would have false518# positives, where one string reordered its arguments.519#   arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \\520#                       $(filter-out $(cmd_$@), $(cmd_$(1))))521# We instead substitute each for the empty string into the other, and522# say they're equal if both substitutions produce the empty string.523# .d files contain """524    + SPACE_REPLACEMENT525    + """ instead of spaces, take that into account.526command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\\527                       $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))528 529# Helper that is non-empty when a prerequisite changes.530# Normally make does this implicitly, but we force rules to always run531# so we can check their command lines.532#   $? -- new prerequisites533#   $| -- order-only dependencies534prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?))535 536# Helper that executes all postbuilds until one fails.537define do_postbuilds538  @E=0;\\539  for p in $(POSTBUILDS); do\\540    eval $$p;\\541    E=$$?;\\542    if [ $$E -ne 0 ]; then\\543      break;\\544    fi;\\545  done;\\546  if [ $$E -ne 0 ]; then\\547    rm -rf "$@";\\548    exit $$E;\\549  fi550endef551 552# do_cmd: run a command via the above cmd_foo names, if necessary.553# Should always run for a given target to handle command-line changes.554# Second argument, if non-zero, makes it do asm/C/C++ dependency munging.555# Third argument, if non-zero, makes it do POSTBUILDS processing.556# Note: We intentionally do NOT call dirx for depfile, since it contains """557    + SPACE_REPLACEMENT558    + """ for559# spaces already and dirx strips the """560    + SPACE_REPLACEMENT561    + """ characters.562define do_cmd563$(if $(or $(command_changed),$(prereq_changed)),564  @$(call exact_echo,  $($(quiet)cmd_$(1)))565  @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))"566  $(if $(findstring flock,$(word %(flock_index)d,$(cmd_$1))),567    @$(cmd_$(1))568    @echo "  $(quiet_cmd_$(1)): Finished",569    @$(cmd_$(1))570  )571  @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile)572  @$(if $(2),$(fixup_dep))573  $(if $(and $(3), $(POSTBUILDS)),574    $(call do_postbuilds)575  )576)577endef578 579# Declare the "%(default_target)s" target first so it is the default,580# even though we don't have the deps yet.581.PHONY: %(default_target)s582%(default_target)s:583 584# make looks for ways to re-generate included makefiles, but in our case, we585# don't have a direct way. Explicitly telling make that it has nothing to do586# for them makes it go faster.587%%.d: ;588 589# Use FORCE_DO_CMD to force a target to run.  Should be coupled with590# do_cmd.591.PHONY: FORCE_DO_CMD592FORCE_DO_CMD:593 594"""  # noqa: E501595)596 597SHARED_HEADER_MAC_COMMANDS = """598quiet_cmd_objc = CXX($(TOOLSET)) $@599cmd_objc = $(CC.$(TOOLSET)) $(GYP_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<600 601quiet_cmd_objcxx = CXX($(TOOLSET)) $@602cmd_objcxx = $(CXX.$(TOOLSET)) $(GYP_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<603 604# Commands for precompiled header files.605quiet_cmd_pch_c = CXX($(TOOLSET)) $@606cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<607quiet_cmd_pch_cc = CXX($(TOOLSET)) $@608cmd_pch_cc = $(CC.$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<609quiet_cmd_pch_m = CXX($(TOOLSET)) $@610cmd_pch_m = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<611quiet_cmd_pch_mm = CXX($(TOOLSET)) $@612cmd_pch_mm = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<613 614# gyp-mac-tool is written next to the root Makefile by gyp.615# Use $(4) for the command, since $(2) and $(3) are used as flag by do_cmd616# already.617quiet_cmd_mac_tool = MACTOOL $(4) $<618cmd_mac_tool = %(python)s gyp-mac-tool $(4) $< "$@"619 620quiet_cmd_mac_package_framework = PACKAGE FRAMEWORK $@621cmd_mac_package_framework = %(python)s gyp-mac-tool package-framework "$@" $(4)622 623quiet_cmd_infoplist = INFOPLIST $@624cmd_infoplist = $(CC.$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"625""" % {"python": sys.executable}  # noqa: E501626 627 628def WriteRootHeaderSuffixRules(writer):629    extensions = sorted(COMPILABLE_EXTENSIONS.keys(), key=str.lower)630 631    writer.write("# Suffix rules, putting all outputs into $(obj).\n")632    for ext in extensions:633        writer.write("$(obj).$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD\n" % ext)634        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])635 636    writer.write("\n# Try building from generated source, too.\n")637    for ext in extensions:638        writer.write(639            "$(obj).$(TOOLSET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD\n" % ext640        )641        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])642    writer.write("\n")643    for ext in extensions:644        writer.write("$(obj).$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD\n" % ext)645        writer.write("\t@$(call do_cmd,%s,1)\n" % COMPILABLE_EXTENSIONS[ext])646    writer.write("\n")647 648 649SHARED_HEADER_OS390_COMMANDS = """650PLIFLAGS.target ?= -qlp=64 -qlimits=extname=31  $(PLIFLAGS)651PLIFLAGS.host ?= -qlp=64 -qlimits=extname=31 $(PLIFLAGS)652 653quiet_cmd_pli = PLI($(TOOLSET)) $@654cmd_pli = $(PLI.$(TOOLSET)) $(GYP_PLIFLAGS) $(PLIFLAGS.$(TOOLSET)) -c $< && \655          if [ -f $(notdir $@) ]; then /bin/cp $(notdir $@) $@; else true; fi656"""657 658SHARED_HEADER_SUFFIX_RULES_COMMENT1 = """\659# Suffix rules, putting all outputs into $(obj).660"""661 662 663SHARED_HEADER_SUFFIX_RULES_COMMENT2 = """\664# Try building from generated source, too.665"""666 667 668SHARED_FOOTER = """\669# "all" is a concatenation of the "all" targets from all the included670# sub-makefiles. This is just here to clarify.671all:672 673# Add in dependency-tracking rules.  $(all_deps) is the list of every single674# target in our tree. Only consider the ones with .d (dependency) info:675d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d))676ifneq ($(d_files),)677  include $(d_files)678endif679"""680 681header = """\682# This file is generated by gyp; do not edit.683 684"""685 686# Maps every compilable file extension to the do_cmd that compiles it.687COMPILABLE_EXTENSIONS = {688    ".c": "cc",689    ".cc": "cxx",690    ".cpp": "cxx",691    ".cxx": "cxx",692    ".s": "cc",693    ".S": "cc",694}695 696 697def Compilable(filename):698    """Return true if the file is compilable (should be in OBJS)."""699    return any(res for res in (filename.endswith(e) for e in COMPILABLE_EXTENSIONS))700 701 702def Linkable(filename):703    """Return true if the file is linkable (should be on the link line)."""704    return filename.endswith(".o")705 706 707def Target(filename):708    """Translate a compilable filename to its .o target."""709    return os.path.splitext(filename)[0] + ".o"710 711 712def EscapeShellArgument(s):713    """Quotes an argument so that it will be interpreted literally by a POSIX714    shell. Taken from715    http://stackoverflow.com/questions/35817/whats-the-best-way-to-escape-ossystem-calls-in-python716    """717    return "'" + s.replace("'", "'\\''") + "'"718 719 720def EscapeMakeVariableExpansion(s):721    """Make has its own variable expansion syntax using $. We must escape it for722    string to be interpreted literally."""723    return s.replace("$", "$$")724 725 726def EscapeCppDefine(s):727    """Escapes a CPP define so that it will reach the compiler unaltered."""728    s = EscapeShellArgument(s)729    s = EscapeMakeVariableExpansion(s)730    # '#' characters must be escaped even embedded in a string, else Make will731    # treat it as the start of a comment.732    return s.replace("#", r"\#")733 734 735def QuoteIfNecessary(string):736    """TODO: Should this ideally be replaced with one or more of the above737    functions?"""738    if '"' in string:739        string = '"' + string.replace('"', '\\"') + '"'740    return string741 742 743def replace_sep(string):744    if sys.platform == "win32":745        string = string.replace("\\\\", "/").replace("\\", "/")746    return string747 748 749def StringToMakefileVariable(string):750    """Convert a string to a value that is acceptable as a make variable name."""751    return re.sub("[^a-zA-Z0-9_]", "_", string)752 753 754srcdir_prefix = ""755 756 757def Sourceify(path):758    """Convert a path to its source directory form."""759    if "$(" in path:760        return path761    if os.path.isabs(path):762        return path763    return srcdir_prefix + path764 765 766def QuoteSpaces(s, quote=r"\ "):767    return s.replace(" ", quote)768 769 770def SourceifyAndQuoteSpaces(path):771    """Convert a path to its source directory form and quote spaces."""772    return QuoteSpaces(Sourceify(path))773 774 775# Map from qualified target to path to output.776target_outputs = {}777# Map from qualified target to any linkable output.  A subset778# of target_outputs.  E.g. when mybinary depends on liba, we want to779# include liba in the linker line; when otherbinary depends on780# mybinary, we just want to build mybinary first.781target_link_deps = {}782 783 784class MakefileWriter:785    """MakefileWriter packages up the writing of one target-specific foobar.mk.786 787    Its only real entry point is Write(), and is mostly used for namespacing.788    """789 790    def __init__(self, generator_flags, flavor):791        self.generator_flags = generator_flags792        self.flavor = flavor793 794        self.suffix_rules_srcdir = {}795        self.suffix_rules_objdir1 = {}796        self.suffix_rules_objdir2 = {}797 798        # Generate suffix rules for all compilable extensions.799        for ext, value in COMPILABLE_EXTENSIONS.items():800            # Suffix rules for source folder.801            self.suffix_rules_srcdir.update(802                {803                    ext: (804                        """\805$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD806\t@$(call do_cmd,%s,1)807"""808                        % (ext, value)809                    )810                }811            )812 813            # Suffix rules for generated source files.814            self.suffix_rules_objdir1.update(815                {816                    ext: (817                        """\818$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD819\t@$(call do_cmd,%s,1)820"""821                        % (ext, value)822                    )823                }824            )825            self.suffix_rules_objdir2.update(826                {827                    ext: (828                        """\829$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD830\t@$(call do_cmd,%s,1)831"""832                        % (ext, value)833                    )834                }835            )836 837    def Write(838        self, qualified_target, base_path, output_filename, spec, configs, part_of_all839    ):840        """The main entry point: writes a .mk file for a single target.841 842        Arguments:843          qualified_target: target we're generating844          base_path: path relative to source root we're building in, used to resolve845                     target-relative paths846          output_filename: output .mk file name to write847          spec, configs: gyp info848          part_of_all: flag indicating this target is part of 'all'849        """850        gyp.common.EnsureDirExists(output_filename)851 852        self.fp = open(output_filename, "w")853 854        self.fp.write(header)855 856        self.qualified_target = qualified_target857        self.path = base_path858        self.target = spec["target_name"]859        self.type = spec["type"]860        self.toolset = spec["toolset"]861 862        self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)863        if self.flavor == "mac":864            self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)865        else:866            self.xcode_settings = None867 868        deps, link_deps = self.ComputeDeps(spec)869 870        # Some of the generation below can add extra output, sources, or871        # link dependencies.  All of the out params of the functions that872        # follow use names like extra_foo.873        extra_outputs = []874        extra_sources = []875        extra_link_deps = []876        extra_mac_bundle_resources = []877        mac_bundle_deps = []878 879        if self.is_mac_bundle:880            self.output = self.ComputeMacBundleOutput(spec)881            self.output_binary = self.ComputeMacBundleBinaryOutput(spec)882        else:883            self.output = self.output_binary = replace_sep(self.ComputeOutput(spec))884 885        self.is_standalone_static_library = bool(886            spec.get("standalone_static_library", 0)887        )888        self._INSTALLABLE_TARGETS = ("executable", "loadable_module", "shared_library")889        if self.is_standalone_static_library or self.type in self._INSTALLABLE_TARGETS:890            self.alias = os.path.basename(self.output)891            install_path = self._InstallableTargetInstallPath()892        else:893            self.alias = self.output894            install_path = self.output895 896        self.WriteLn("TOOLSET := " + self.toolset)897        self.WriteLn("TARGET := " + self.target)898 899        # Actions must come first, since they can generate more OBJs for use below.900        if "actions" in spec:901            self.WriteActions(902                spec["actions"],903                extra_sources,904                extra_outputs,905                extra_mac_bundle_resources,906                part_of_all,907            )908 909        # Rules must be early like actions.910        if "rules" in spec:911            self.WriteRules(912                spec["rules"],913                extra_sources,914                extra_outputs,915                extra_mac_bundle_resources,916                part_of_all,917            )918 919        if "copies" in spec:920            self.WriteCopies(spec["copies"], extra_outputs, part_of_all)921 922        # Bundle resources.923        if self.is_mac_bundle:924            all_mac_bundle_resources = (925                spec.get("mac_bundle_resources", []) + extra_mac_bundle_resources926            )927            self.WriteMacBundleResources(all_mac_bundle_resources, mac_bundle_deps)928            self.WriteMacInfoPlist(mac_bundle_deps)929 930        # Sources.931        all_sources = spec.get("sources", []) + extra_sources932        if all_sources:933            self.WriteSources(934                configs,935                deps,936                all_sources,937                extra_outputs,938                extra_link_deps,939                part_of_all,940                gyp.xcode_emulation.MacPrefixHeader(941                    self.xcode_settings,942                    lambda p: Sourceify(self.Absolutify(p)),943                    self.Pchify,944                ),945            )946            sources = [x for x in all_sources if Compilable(x)]947            if sources:948                self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT1)949                extensions = {os.path.splitext(s)[1] for s in sources}950                for ext in extensions:951                    if ext in self.suffix_rules_srcdir:952                        self.WriteLn(self.suffix_rules_srcdir[ext])953                self.WriteLn(SHARED_HEADER_SUFFIX_RULES_COMMENT2)954                for ext in extensions:955                    if ext in self.suffix_rules_objdir1:956                        self.WriteLn(self.suffix_rules_objdir1[ext])957                for ext in extensions:958                    if ext in self.suffix_rules_objdir2:959                        self.WriteLn(self.suffix_rules_objdir2[ext])960                self.WriteLn("# End of this set of suffix rules")961 962                # Add dependency from bundle to bundle binary.963                if self.is_mac_bundle:964                    mac_bundle_deps.append(self.output_binary)965 966        self.WriteTarget(967            spec,968            configs,969            deps,970            extra_link_deps + link_deps,971            mac_bundle_deps,972            extra_outputs,973            part_of_all,974        )975 976        # Update global list of target outputs, used in dependency tracking.977        target_outputs[qualified_target] = install_path978 979        # Update global list of link dependencies.980        if self.type in ("static_library", "shared_library"):981            target_link_deps[qualified_target] = self.output_binary982 983        # Currently any versions have the same effect, but in future the behavior984        # could be different.985        if self.generator_flags.get("android_ndk_version", None):986            self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)987 988        self.fp.close()989 990    def WriteSubMake(self, output_filename, makefile_path, targets, build_dir):991        """Write a "sub-project" Makefile.992 993        This is a small, wrapper Makefile that calls the top-level Makefile to build994        the targets from a single gyp file (i.e. a sub-project).995 996        Arguments:997          output_filename: sub-project Makefile name to write998          makefile_path: path to the top-level Makefile999          targets: list of "all" targets for this sub-project1000          build_dir: build output directory, relative to the sub-project1001        """1002        gyp.common.EnsureDirExists(output_filename)1003        self.fp = open(output_filename, "w")1004        self.fp.write(header)1005        # For consistency with other builders, put sub-project build output in the1006        # sub-project dir (see test/subdirectory/gyptest-subdir-all.py).1007        self.WriteLn(1008            "export builddir_name ?= %s"1009            % replace_sep(os.path.join(os.path.dirname(output_filename), build_dir))1010        )1011        self.WriteLn(".PHONY: all")1012        self.WriteLn("all:")1013        if makefile_path:1014            makefile_path = " -C " + makefile_path1015        self.WriteLn("\t$(MAKE){} {}".format(makefile_path, " ".join(targets)))1016        self.fp.close()1017 1018    def WriteActions(1019        self,1020        actions,1021        extra_sources,1022        extra_outputs,1023        extra_mac_bundle_resources,1024        part_of_all,1025    ):1026        """Write Makefile code for any 'actions' from the gyp input.1027 1028        extra_sources: a list that will be filled in with newly generated source1029                       files, if any1030        extra_outputs: a list that will be filled in with any outputs of these1031                       actions (used to make other pieces dependent on these1032                       actions)1033        part_of_all: flag indicating this target is part of 'all'1034        """1035        env = self.GetSortedXcodeEnv()1036        for action in actions:1037            name = StringToMakefileVariable(1038                "{}_{}".format(self.qualified_target, action["action_name"])1039            )1040            self.WriteLn('### Rules for action "%s":' % action["action_name"])1041            inputs = action["inputs"]1042            outputs = action["outputs"]1043 1044            # Build up a list of outputs.1045            # Collect the output dirs we'll need.1046            dirs = set()1047            for out in outputs:1048                dir = os.path.split(out)[0]1049                if dir:1050                    dirs.add(dir)1051            if int(action.get("process_outputs_as_sources", False)):1052                extra_sources += outputs1053            if int(action.get("process_outputs_as_mac_bundle_resources", False)):1054                extra_mac_bundle_resources += outputs1055 1056            # Write the actual command.1057            action_commands = action["action"]1058            if self.flavor == "mac":1059                action_commands = [1060                    gyp.xcode_emulation.ExpandEnvVars(command, env)1061                    for command in action_commands1062                ]1063            command = gyp.common.EncodePOSIXShellList(action_commands)1064            if "message" in action:1065                self.WriteLn(1066                    "quiet_cmd_{} = ACTION {} $@".format(name, action["message"])1067                )1068            else:1069                self.WriteLn(f"quiet_cmd_{name} = ACTION {name} $@")1070            if len(dirs) > 0:1071                command = "mkdir -p %s" % " ".join(dirs) + "; " + command1072 1073            cd_action = "cd %s; " % Sourceify(self.path or ".")1074 1075            # command and cd_action get written to a toplevel variable called1076            # cmd_foo. Toplevel variables can't handle things that change per1077            # makefile like $(TARGET), so hardcode the target.1078            command = command.replace("$(TARGET)", self.target)1079            cd_action = cd_action.replace("$(TARGET)", self.target)1080 1081            # Set LD_LIBRARY_PATH in case the action runs an executable from this1082            # build which links to shared libs from this build.1083            # actions run on the host, so they should in theory only use host1084            # libraries, but until everything is made cross-compile safe, also use1085            # target libraries.1086            # TODO(piman): when everything is cross-compile safe, remove lib.target1087            if self.flavor in {"zos", "aix"}:1088                self.WriteLn(1089                    "cmd_%s = LIBPATH=$(builddir)/lib.host:"1090                    "$(builddir)/lib.target:$$LIBPATH; "1091                    "export LIBPATH; "1092                    "%s%s" % (name, cd_action, command)1093                )1094            else:1095                self.WriteLn(1096                    "cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:"1097                    "$(builddir)/lib.target:$$LD_LIBRARY_PATH; "1098                    "export LD_LIBRARY_PATH; "1099                    "%s%s" % (name, cd_action, command)1100                )1101            self.WriteLn()1102            outputs = [self.Absolutify(o) for o in outputs]1103            # The makefile rules are all relative to the top dir, but the gyp actions1104            # are defined relative to their containing dir.  This replaces the obj1105            # variable for the action rule with an absolute version so that the output1106            # goes in the right place.1107            # Only write the 'obj' and 'builddir' rules for the "primary" output (:1);1108            # it's superfluous for the "extra outputs", and this avoids accidentally1109            # writing duplicate dummy rules for those outputs.1110            # Same for environment.1111            self.WriteLn("%s: obj := $(abs_obj)" % QuoteSpaces(outputs[0]))1112            self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(outputs[0]))1113            self.WriteSortedXcodeEnv(outputs[0], self.GetSortedXcodeEnv())1114 1115            for input in inputs:1116                assert " " not in input, (1117                    "Spaces in action input filenames not supported (%s)" % input1118                )1119            for output in outputs:1120                assert " " not in output, (1121                    "Spaces in action output filenames not supported (%s)" % output1122                )1123 1124            # See the comment in WriteCopies about expanding env vars.1125            outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]1126            inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]1127 1128            self.WriteDoCmd(1129                outputs,1130                [Sourceify(self.Absolutify(i)) for i in inputs],1131                part_of_all=part_of_all,1132                command=name,1133            )1134 1135            # Stuff the outputs in a variable so we can refer to them later.1136            outputs_variable = "action_%s_outputs" % name1137            self.WriteLn("{} := {}".format(outputs_variable, " ".join(outputs)))1138            extra_outputs.append("$(%s)" % outputs_variable)1139            self.WriteLn()1140 1141        self.WriteLn()1142 1143    def WriteRules(1144        self,1145        rules,1146        extra_sources,1147        extra_outputs,1148        extra_mac_bundle_resources,1149        part_of_all,1150    ):1151        """Write Makefile code for any 'rules' from the gyp input.1152 1153        extra_sources: a list that will be filled in with newly generated source1154                       files, if any1155        extra_outputs: a list that will be filled in with any outputs of these1156                       rules (used to make other pieces dependent on these rules)1157        part_of_all: flag indicating this target is part of 'all'1158        """1159        env = self.GetSortedXcodeEnv()1160        for rule in rules:1161            name = StringToMakefileVariable(1162                "{}_{}".format(self.qualified_target, rule["rule_name"])1163            )1164            count = 01165            self.WriteLn("### Generated for rule %s:" % name)1166 1167            all_outputs = []1168 1169            for rule_source in rule.get("rule_sources", []):1170                dirs = set()1171                (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)1172                (rule_source_root, _rule_source_ext) = os.path.splitext(1173                    rule_source_basename1174                )1175 1176                outputs = [1177                    self.ExpandInputRoot(out, rule_source_root, rule_source_dirname)1178                    for out in rule["outputs"]1179                ]1180 1181                for out in outputs:1182                    dir = os.path.dirname(out)1183                    if dir:1184                        dirs.add(dir)1185                if int(rule.get("process_outputs_as_sources", False)):1186                    extra_sources += outputs1187                if int(rule.get("process_outputs_as_mac_bundle_resources", False)):1188                    extra_mac_bundle_resources += outputs1189                inputs = [1190                    Sourceify(self.Absolutify(i))1191                    for i in [rule_source] + rule.get("inputs", [])1192                ]1193                actions = ["$(call do_cmd,%s_%d)" % (name, count)]1194 1195                if name == "resources_grit":1196                    # HACK: This is ugly.  Grit intentionally doesn't touch the1197                    # timestamp of its output file when the file doesn't change,1198                    # which is fine in hash-based dependency systems like scons1199                    # and forge, but not kosher in the make world.  After some1200                    # discussion, hacking around it here seems like the least1201                    # amount of pain.1202                    actions += ["@touch --no-create $@"]1203 1204                # See the comment in WriteCopies about expanding env vars.1205                outputs = [gyp.xcode_emulation.ExpandEnvVars(o, env) for o in outputs]1206                inputs = [gyp.xcode_emulation.ExpandEnvVars(i, env) for i in inputs]1207 1208                outputs = [self.Absolutify(o) for o in outputs]1209                all_outputs += outputs1210                # Only write the 'obj' and 'builddir' rules for the "primary" output1211                # (:1); it's superfluous for the "extra outputs", and this avoids1212                # accidentally writing duplicate dummy rules for those outputs.1213                self.WriteLn("%s: obj := $(abs_obj)" % outputs[0])1214                self.WriteLn("%s: builddir := $(abs_builddir)" % outputs[0])1215                self.WriteMakeRule(1216                    outputs, inputs, actions, command="%s_%d" % (name, count)1217                )1218                # Spaces in rule filenames are not supported, but rule variables have1219                # spaces in them (e.g. RULE_INPUT_PATH expands to '$(abspath $<)').1220                # The spaces within the variables are valid, so remove the variables1221                # before checking.1222                variables_with_spaces = re.compile(r"\$\([^ ]* \$<\)")1223                for output in outputs:1224                    output = re.sub(variables_with_spaces, "", output)1225                    assert " " not in output, (1226                        "Spaces in rule filenames not yet supported (%s)" % output1227                    )1228                self.WriteLn("all_deps += %s" % " ".join(outputs))1229 1230                action = [1231                    self.ExpandInputRoot(ac, rule_source_root, rule_source_dirname)1232                    for ac in rule["action"]1233                ]1234                mkdirs = ""1235                if len(dirs) > 0:1236                    mkdirs = "mkdir -p %s; " % " ".join(dirs)1237                cd_action = "cd %s; " % Sourceify(self.path or ".")1238 1239                # action, cd_action, and mkdirs get written to a toplevel variable1240                # called cmd_foo. Toplevel variables can't handle things that change1241                # per makefile like $(TARGET), so hardcode the target.1242                if self.flavor == "mac":1243                    action = [1244                        gyp.xcode_emulation.ExpandEnvVars(command, env)1245                        for command in action1246                    ]1247                action = gyp.common.EncodePOSIXShellList(action)1248                action = action.replace("$(TARGET)", self.target)1249                cd_action = cd_action.replace("$(TARGET)", self.target)1250                mkdirs = mkdirs.replace("$(TARGET)", self.target)1251 1252                # Set LD_LIBRARY_PATH in case the rule runs an executable from this1253                # build which links to shared libs from this build.1254                # rules run on the host, so they should in theory only use host1255                # libraries, but until everything is made cross-compile safe, also use1256                # target libraries.1257                # TODO(piman): when everything is cross-compile safe, remove lib.target1258                self.WriteLn(1259                    "cmd_%(name)s_%(count)d = LD_LIBRARY_PATH="1260                    "$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; "1261                    "export LD_LIBRARY_PATH; "1262                    "%(cd_action)s%(mkdirs)s%(action)s"1263                    % {1264                        "action": action,1265                        "cd_action": cd_action,1266                        "count": count,1267                        "mkdirs": mkdirs,1268                        "name": name,1269                    }1270                )1271                self.WriteLn(1272                    "quiet_cmd_%(name)s_%(count)d = RULE %(name)s_%(count)d $@"1273                    % {"count": count, "name": name}1274                )1275                self.WriteLn()1276                count += 11277 1278            outputs_variable = "rule_%s_outputs" % name1279            self.WriteList(all_outputs, outputs_variable)1280            extra_outputs.append("$(%s)" % outputs_variable)1281 1282            self.WriteLn("### Finished generating for rule: %s" % name)1283            self.WriteLn()1284        self.WriteLn("### Finished generating for all rules")1285        self.WriteLn("")1286 1287    def WriteCopies(self, copies, extra_outputs, part_of_all):1288        """Write Makefile code for any 'copies' from the gyp input.1289 1290        extra_outputs: a list that will be filled in with any outputs of this action1291                       (used to make other pieces dependent on this action)1292        part_of_all: flag indicating this target is part of 'all'1293        """1294        self.WriteLn("### Generated for copy rule.")1295 1296        variable = StringToMakefileVariable(self.qualified_target + "_copies")1297        outputs = []1298        for copy in copies:1299            for path in copy["files"]:1300                # Absolutify() may call normpath, and will strip trailing slashes.1301                path = Sourceify(self.Absolutify(path))1302                filename = os.path.split(path)[1]1303                output = Sourceify(1304                    self.Absolutify(os.path.join(copy["destination"], filename))1305                )1306 1307                # If the output path has variables in it, which happens in practice for1308                # 'copies', writing the environment as target-local doesn't work,1309                # because the variables are already needed for the target name.1310                # Copying the environment variables into global make variables doesn't1311                # work either, because then the .d files will potentially contain spaces1312                # after variable expansion, and .d file handling cannot handle spaces.1313                # As a workaround, manually expand variables at gyp time. Since 'copies'1314                # can't run scripts, there's no need to write the env then.1315                # WriteDoCmd() will escape spaces for .d files.1316                env = self.GetSortedXcodeEnv()1317                output = gyp.xcode_emulation.ExpandEnvVars(output, env)1318                path = gyp.xcode_emulation.ExpandEnvVars(path, env)1319                self.WriteDoCmd([output], [path], "copy", part_of_all)1320                outputs.append(output)1321        self.WriteLn(1322            "{} = {}".format(variable, " ".join(QuoteSpaces(o) for o in outputs))1323        )1324        extra_outputs.append("$(%s)" % variable)1325        self.WriteLn()1326 1327    def WriteMacBundleResources(self, resources, bundle_deps):1328        """Writes Makefile code for 'mac_bundle_resources'."""1329        self.WriteLn("### Generated for mac_bundle_resources")1330 1331        for output, res in gyp.xcode_emulation.GetMacBundleResources(1332            generator_default_variables["PRODUCT_DIR"],1333            self.xcode_settings,1334            [Sourceify(self.Absolutify(r)) for r in resources],1335        ):1336            _, ext = os.path.splitext(output)1337            if ext != ".xcassets":1338                # Make does not supports '.xcassets' emulation.1339                self.WriteDoCmd(1340                    [output], [res], "mac_tool,,,copy-bundle-resource", part_of_all=True1341                )1342                bundle_deps.append(output)1343 1344    def WriteMacInfoPlist(self, bundle_deps):1345        """Write Makefile code for bundle Info.plist files."""1346        info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(1347            generator_default_variables["PRODUCT_DIR"],1348            self.xcode_settings,1349            lambda p: Sourceify(self.Absolutify(p)),1350        )1351        if not info_plist:1352            return1353        if defines:1354            # Create an intermediate file to store preprocessed results.1355            intermediate_plist = "$(obj).$(TOOLSET)/$(TARGET)/" + os.path.basename(1356                info_plist1357            )1358            self.WriteList(1359                defines,1360                intermediate_plist + ": INFOPLIST_DEFINES",1361                "-D",1362                quoter=EscapeCppDefine,1363            )1364            self.WriteMakeRule(1365                [intermediate_plist],1366                [info_plist],1367                [1368                    "$(call do_cmd,infoplist)",1369                    # "Convert" the plist so that any weird whitespace changes from the1370                    # preprocessor do not affect the XML parser in mac_tool.1371                    "@plutil -convert xml1 $@ $@",1372                ],1373            )1374            info_plist = intermediate_plist1375        # plists can contain envvars and substitute them into the file.1376        self.WriteSortedXcodeEnv(1377            out, self.GetSortedXcodeEnv(additional_settings=extra_env)1378        )1379        self.WriteDoCmd(1380            [out], [info_plist], "mac_tool,,,copy-info-plist", part_of_all=True1381        )1382        bundle_deps.append(out)1383 1384    def WriteSources(1385        self,1386        configs,1387        deps,1388        sources,1389        extra_outputs,1390        extra_link_deps,1391        part_of_all,1392        precompiled_header,1393    ):1394        """Write Makefile code for any 'sources' from the gyp input.1395        These are source files necessary to build the current target.1396 1397        configs, deps, sources: input from gyp.1398        extra_outputs: a list of extra outputs this action should be dependent on;1399                       used to serialize action/rules before compilation1400        extra_link_deps: a list that will be filled in with any outputs of1401                         compilation (to be used in link lines)1402        part_of_all: flag indicating this target is part of 'all'1403        """1404 1405        # Write configuration-specific variables for CFLAGS, etc.1406        for configname in sorted(configs.keys()):1407            config = configs[configname]1408            self.WriteList(1409                config.get("defines"),1410                "DEFS_%s" % configname,1411                prefix="-D",1412                quoter=EscapeCppDefine,1413            )1414 1415            if self.flavor == "mac":1416                cflags = self.xcode_settings.GetCflags(1417                    configname, arch=config.get("xcode_configuration_platform")1418                )1419                cflags_c = self.xcode_settings.GetCflagsC(configname)1420                cflags_cc = self.xcode_settings.GetCflagsCC(configname)1421                cflags_objc = self.xcode_settings.GetCflagsObjC(configname)1422                cflags_objcc = self.xcode_settings.GetCflagsObjCC(configname)1423            else:1424                cflags = config.get("cflags")1425                cflags_c = config.get("cflags_c")1426                cflags_cc = config.get("cflags_cc")1427 1428            self.WriteLn("# Flags passed to all source files.")1429            self.WriteList(cflags, "CFLAGS_%s" % configname)1430            self.WriteLn("# Flags passed to only C files.")1431            self.WriteList(cflags_c, "CFLAGS_C_%s" % configname)1432            self.WriteLn("# Flags passed to only C++ files.")1433            self.WriteList(cflags_cc, "CFLAGS_CC_%s" % configname)1434            if self.flavor == "mac":1435                self.WriteLn("# Flags passed to only ObjC files.")1436                self.WriteList(cflags_objc, "CFLAGS_OBJC_%s" % configname)1437                self.WriteLn("# Flags passed to only ObjC++ files.")1438                self.WriteList(cflags_objcc, "CFLAGS_OBJCC_%s" % configname)1439            includes = config.get("include_dirs")1440            if includes:1441                includes = [Sourceify(self.Absolutify(i)) for i in includes]1442            self.WriteList(includes, "INCS_%s" % configname, prefix="-I")1443 1444        compilable = list(filter(Compilable, sources))1445        objs = [self.Objectify(self.Absolutify(Target(c))) for c in compilable]1446        self.WriteList(objs, "OBJS")1447 1448        for obj in objs:1449            assert " " not in obj, "Spaces in object filenames not supported (%s)" % obj1450        self.WriteLn("# Add to the list of files we specially track dependencies for.")1451        self.WriteLn("all_deps += $(OBJS)")1452        self.WriteLn()1453 1454        # Make sure our dependencies are built first.1455        if deps:1456            self.WriteMakeRule(1457                ["$(OBJS)"],1458                deps,1459                comment="Make sure our dependencies are built before any of us.",1460                order_only=True,1461            )1462 1463        # Make sure the actions and rules run first.1464        # If they generate any extra headers etc., the per-.o file dep tracking1465        # will catch the proper rebuilds, so order only is still ok here.1466        if extra_outputs:1467            self.WriteMakeRule(1468                ["$(OBJS)"],1469                extra_outputs,1470                comment="Make sure our actions/rules run before any of us.",1471                order_only=True,1472            )1473 1474        if pchdeps := precompiled_header.GetObjDependencies(compilable, objs):1475            self.WriteLn("# Dependencies from obj files to their precompiled headers")1476            for source, obj, gch in pchdeps:1477                self.WriteLn(f"{obj}: {gch}")1478            self.WriteLn("# End precompiled header dependencies")1479 1480        if objs:1481            extra_link_deps.append("$(OBJS)")1482            self.WriteLn(1483                """\1484# CFLAGS et al overrides must be target-local.1485# See "Target-specific Variable Values" in the GNU Make manual."""1486            )1487            self.WriteLn("$(OBJS): TOOLSET := $(TOOLSET)")1488            self.WriteLn(1489                "$(OBJS): GYP_CFLAGS := "1490                "$(DEFS_$(BUILDTYPE)) "1491                "$(INCS_$(BUILDTYPE)) "1492                "%s " % precompiled_header.GetInclude("c") + "$(CFLAGS_$(BUILDTYPE)) "1493                "$(CFLAGS_C_$(BUILDTYPE))"1494            )1495            self.WriteLn(1496                "$(OBJS): GYP_CXXFLAGS := "1497                "$(DEFS_$(BUILDTYPE)) "1498                "$(INCS_$(BUILDTYPE)) "1499                "%s " % precompiled_header.GetInclude("cc") + "$(CFLAGS_$(BUILDTYPE)) "1500                "$(CFLAGS_CC_$(BUILDTYPE))"1501            )1502            if self.flavor == "mac":1503                self.WriteLn(1504                    "$(OBJS): GYP_OBJCFLAGS := "1505                    "$(DEFS_$(BUILDTYPE)) "1506                    "$(INCS_$(BUILDTYPE)) "1507                    "%s "1508                    % precompiled_header.GetInclude("m")1509                    + "$(CFLAGS_$(BUILDTYPE)) "1510                    "$(CFLAGS_C_$(BUILDTYPE)) "1511                    "$(CFLAGS_OBJC_$(BUILDTYPE))"1512                )1513                self.WriteLn(1514                    "$(OBJS): GYP_OBJCXXFLAGS := "1515                    "$(DEFS_$(BUILDTYPE)) "1516                    "$(INCS_$(BUILDTYPE)) "1517                    "%s "1518                    % precompiled_header.GetInclude("mm")1519                    + "$(CFLAGS_$(BUILDTYPE)) "1520                    "$(CFLAGS_CC_$(BUILDTYPE)) "1521                    "$(CFLAGS_OBJCC_$(BUILDTYPE))"1522                )1523 1524        self.WritePchTargets(precompiled_header.GetPchBuildCommands())1525 1526        # If there are any object files in our input file list, link them into our1527        # output.1528        extra_link_deps += [source for source in sources if Linkable(source)]1529 1530        self.WriteLn()1531 1532    def WritePchTargets(self, pch_commands):1533        """Writes make rules to compile prefix headers."""1534        if not pch_commands:1535            return1536 1537        for gch, lang_flag, lang, input in pch_commands:1538            extra_flags = {1539                "c": "$(CFLAGS_C_$(BUILDTYPE))",1540                "cc": "$(CFLAGS_CC_$(BUILDTYPE))",1541                "m": "$(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))",1542                "mm": "$(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))",1543            }[lang]1544            var_name = {1545                "c": "GYP_PCH_CFLAGS",1546                "cc": "GYP_PCH_CXXFLAGS",1547                "m": "GYP_PCH_OBJCFLAGS",1548                "mm": "GYP_PCH_OBJCXXFLAGS",1549            }[lang]1550            self.WriteLn(1551                f"{gch}: {var_name} := {lang_flag} " + "$(DEFS_$(BUILDTYPE)) "1552                "$(INCS_$(BUILDTYPE)) "1553                "$(CFLAGS_$(BUILDTYPE)) " + extra_flags1554            )1555 1556            self.WriteLn(f"{gch}: {input} FORCE_DO_CMD")1557            self.WriteLn("\t@$(call do_cmd,pch_%s,1)" % lang)1558            self.WriteLn("")1559            assert " " not in gch, "Spaces in gch filenames not supported (%s)" % gch1560            self.WriteLn("all_deps += %s" % gch)1561            self.WriteLn("")1562 1563    def ComputeOutputBasename(self, spec):1564        """Return the 'output basename' of a gyp spec.1565 1566        E.g., the loadable module 'foobar' in directory 'baz' will produce1567          'libfoobar.so'1568        """1569        assert not self.is_mac_bundle1570 1571        if self.flavor == "mac" and self.type in (1572            "static_library",1573            "executable",1574            "shared_library",1575            "loadable_module",1576        ):1577            return self.xcode_settings.GetExecutablePath()1578 1579        target = spec["target_name"]1580        target_prefix = ""1581        target_ext = ""1582        if self.type == "static_library":1583            if target[:3] == "lib":1584                target = target[3:]1585            target_prefix = "lib"1586            target_ext = ".a"1587        elif self.type in ("loadable_module", "shared_library"):1588            if target[:3] == "lib":1589                target = target[3:]1590            target_prefix = "lib"1591            if self.flavor == "aix":1592                target_ext = ".a"1593            elif self.flavor == "zos":1594                target_ext = ".x"1595            else:1596                target_ext = ".so"1597        elif self.type == "none":1598            target = "%s.stamp" % target1599        elif self.type != "executable":1600            print(1601                "ERROR: What output file should be generated?",1602                "type",1603                self.type,1604                "target",1605                target,1606            )1607 1608        target_prefix = spec.get("product_prefix", target_prefix)1609        target = spec.get("product_name", target)1610        if product_ext := spec.get("product_extension"):1611            target_ext = "." + product_ext1612 1613        return target_prefix + target + target_ext1614 1615    def _InstallImmediately(self):1616        return (1617            self.toolset == "target"1618            and self.flavor == "mac"1619            and self.type1620            in ("static_library", "executable", "shared_library", "loadable_module")1621        )1622 1623    def ComputeOutput(self, spec):1624        """Return the 'output' (full output path) of a gyp spec.1625 1626        E.g., the loadable module 'foobar' in directory 'baz' will produce1627          '$(obj)/baz/libfoobar.so'1628        """1629        assert not self.is_mac_bundle1630 1631        path = os.path.join("$(obj)." + self.toolset, self.path)1632        if self.type == "executable" or self._InstallImmediately():1633            path = "$(builddir)"1634        path = spec.get("product_dir", path)1635        return os.path.join(path, self.ComputeOutputBasename(spec))1636 1637    def ComputeMacBundleOutput(self, spec):1638        """Return the 'output' (full output path) to a bundle output directory."""1639        assert self.is_mac_bundle1640        path = generator_default_variables["PRODUCT_DIR"]1641        return os.path.join(path, self.xcode_settings.GetWrapperName())1642 1643    def ComputeMacBundleBinaryOutput(self, spec):1644        """Return the 'output' (full output path) to the binary in a bundle."""1645        path = generator_default_variables["PRODUCT_DIR"]1646        return os.path.join(path, self.xcode_settings.GetExecutablePath())1647 1648    def ComputeDeps(self, spec):1649        """Compute the dependencies of a gyp spec.1650 1651        Returns a tuple (deps, link_deps), where each is a list of1652        filenames that will need to be put in front of make for either1653        building (deps) or linking (link_deps).1654        """1655        deps = []1656        link_deps = []1657        if "dependencies" in spec:1658            deps.extend(1659                [1660                    target_outputs[dep]1661                    for dep in spec["dependencies"]1662                    if target_outputs[dep]1663                ]1664            )1665            for dep in spec["dependencies"]:1666                if dep in target_link_deps:1667                    link_deps.append(target_link_deps[dep])1668            deps.extend(link_deps)1669            # TODO: It seems we need to transitively link in libraries (e.g. -lfoo)?1670            # This hack makes it work:1671            # link_deps.extend(spec.get('libraries', []))1672        return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))1673 1674    def GetSharedObjectFromSidedeck(self, sidedeck):1675        """Return the shared object files based on sidedeck"""1676        return re.sub(r"\.x$", ".so", sidedeck)1677 1678    def GetUnversionedSidedeckFromSidedeck(self, sidedeck):1679        """Return the shared object files based on sidedeck"""1680        return re.sub(r"\.\d+\.x$", ".x", sidedeck)1681 1682    def WriteDependencyOnExtraOutputs(self, target, extra_outputs):1683        self.WriteMakeRule(1684            [self.output_binary],1685            extra_outputs,1686            comment="Build our special outputs first.",1687            order_only=True,1688        )1689 1690    def WriteTarget(1691        self, spec, configs, deps, link_deps, bundle_deps, extra_outputs, part_of_all1692    ):1693        """Write Makefile code to produce the final target of the gyp spec.1694 1695        spec, configs: input from gyp.1696        deps, link_deps: dependency lists; see ComputeDeps()1697        extra_outputs: any extra outputs that our target should depend on1698        part_of_all: flag indicating this target is part of 'all'1699        """1700 1701        self.WriteLn("### Rules for final target.")1702 1703        if extra_outputs:1704            self.WriteDependencyOnExtraOutputs(self.output_binary, extra_outputs)1705            self.WriteMakeRule(1706                extra_outputs,1707                deps,1708                comment=("Preserve order dependency of special output on deps."),1709                order_only=True,1710            )1711 1712        target_postbuilds = {}1713        if self.type != "none":1714            for configname in sorted(configs.keys()):1715                config = configs[configname]1716                if self.flavor == "mac":1717                    ldflags = self.xcode_settings.GetLdflags(1718                        configname,1719                        generator_default_variables["PRODUCT_DIR"],1720                        lambda p: Sourceify(self.Absolutify(p)),1721                        arch=config.get("xcode_configuration_platform"),1722                    )1723 1724                    # TARGET_POSTBUILDS_$(BUILDTYPE) is added to postbuilds later on.1725                    gyp_to_build = gyp.common.InvertRelativePath(self.path)1726                    target_postbuild = self.xcode_settings.AddImplicitPostbuilds(1727                        configname,1728                        QuoteSpaces(1729                            os.path.normpath(os.path.join(gyp_to_build, self.output))1730                        ),1731                        QuoteSpaces(1732                            os.path.normpath(1733                                os.path.join(gyp_to_build, self.output_binary)1734                            )1735                        ),1736                    )1737                    if target_postbuild:1738                        target_postbuilds[configname] = target_postbuild1739                else:1740                    ldflags = config.get("ldflags", [])1741                    # Compute an rpath for this output if needed.1742                    if any(dep.endswith(".so") or ".so." in dep for dep in deps):1743                        # We want to get the literal string "$ORIGIN"1744                        # into the link command, so we need lots of escaping.1745                        ldflags.append(r"-Wl,-rpath=\$$ORIGIN/")1746                        ldflags.append(r"-Wl,-rpath-link=\$(builddir)/")1747                if library_dirs := config.get("library_dirs", []):1748                    library_dirs = [Sourceify(self.Absolutify(i)) for i in library_dirs]1749                ldflags += [("-L%s" % library_dir) for library_dir in library_dirs]1750                self.WriteList(ldflags, "LDFLAGS_%s" % configname)1751                if self.flavor == "mac":1752                    self.WriteList(1753                        self.xcode_settings.GetLibtoolflags(configname),1754                        "LIBTOOLFLAGS_%s" % configname,1755                    )1756            libraries = spec.get("libraries")1757            if libraries:1758                # Remove duplicate entries1759                libraries = gyp.common.uniquer(libraries)1760                if self.flavor == "mac":1761                    libraries = self.xcode_settings.AdjustLibraries(libraries)1762            self.WriteList(libraries, "LIBS")1763            self.WriteLn(1764                "%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))"1765                % QuoteSpaces(self.output_binary)1766            )1767            self.WriteLn("%s: LIBS := $(LIBS)" % QuoteSpaces(self.output_binary))1768 1769            if self.flavor == "mac":1770                self.WriteLn(1771                    "%s: GYP_LIBTOOLFLAGS := $(LIBTOOLFLAGS_$(BUILDTYPE))"1772                    % QuoteSpaces(self.output_binary)1773                )1774 1775        # Postbuild actions. Like actions, but implicitly depend on the target's1776        # output.1777        postbuilds = []1778        if self.flavor == "mac":1779            if target_postbuilds:1780                postbuilds.append("$(TARGET_POSTBUILDS_$(BUILDTYPE))")1781            postbuilds.extend(gyp.xcode_emulation.GetSpecPostbuildCommands(spec))1782 1783        if postbuilds:1784            # Envvars may be referenced by TARGET_POSTBUILDS_$(BUILDTYPE),1785            # so we must output its definition first, since we declare variables1786            # using ":=".1787            self.WriteSortedXcodeEnv(self.output, self.GetSortedXcodePostbuildEnv())1788 1789            for configname, value in target_postbuilds.items():1790                self.WriteLn(1791                    "%s: TARGET_POSTBUILDS_%s := %s"1792                    % (1793                        QuoteSpaces(self.output),1794                        configname,1795                        gyp.common.EncodePOSIXShellList(value),1796                    )1797                )1798 1799            # Postbuilds expect to be run in the gyp file's directory, so insert an1800            # implicit postbuild to cd to there.1801            postbuilds.insert(0, gyp.common.EncodePOSIXShellList(["cd", self.path]))1802            for i, postbuild in enumerate(postbuilds):1803                if not postbuild.startswith("$"):1804                    postbuilds[i] = EscapeShellArgument(postbuild)1805            self.WriteLn("%s: builddir := $(abs_builddir)" % QuoteSpaces(self.output))1806            self.WriteLn(1807                "%s: POSTBUILDS := %s"1808                % (QuoteSpaces(self.output), " ".join(postbuilds))1809            )1810 1811        # A bundle directory depends on its dependencies such as bundle resources1812        # and bundle binary. When all dependencies have been built, the bundle1813        # needs to be packaged.1814        if self.is_mac_bundle:1815            # If the framework doesn't contain a binary, then nothing depends1816            # on the actions -- make the framework depend on them directly too.1817            self.WriteDependencyOnExtraOutputs(self.output, extra_outputs)1818 1819            # Bundle dependencies. Note that the code below adds actions to this1820            # target, so if you move these two lines, move the lines below as well.1821            self.WriteList([QuoteSpaces(dep) for dep in bundle_deps], "BUNDLE_DEPS")1822            self.WriteLn("%s: $(BUNDLE_DEPS)" % QuoteSpaces(self.output))1823 1824            # After the framework is built, package it. Needs to happen before1825            # postbuilds, since postbuilds depend on this.1826            if self.type in ("shared_library", "loadable_module"):1827                self.WriteLn(1828                    "\t@$(call do_cmd,mac_package_framework,,,%s)"1829                    % self.xcode_settings.GetFrameworkVersion()1830                )1831 1832            # Bundle postbuilds can depend on the whole bundle, so run them after1833            # the bundle is packaged, not already after the bundle binary is done.1834            if postbuilds:1835                self.WriteLn("\t@$(call do_postbuilds)")1836            postbuilds = []  # Don't write postbuilds for target's output.1837 1838            # Needed by test/mac/gyptest-rebuild.py.1839            self.WriteLn("\t@true  # No-op, used by tests")1840 1841            # Since this target depends on binary and resources which are in1842            # nested subfolders, the framework directory will be older than1843            # its dependencies usually. To prevent this rule from executing1844            # on every build (expensive, especially with postbuilds), explicitly1845            # update the time on the framework directory.1846            self.WriteLn("\t@touch -c %s" % QuoteSpaces(self.output))1847 1848        if postbuilds:1849            assert not self.is_mac_bundle, (1850                "Postbuilds for bundles should be done "1851                "on the bundle, not the binary (target '%s')" % self.target1852            )1853            assert "product_dir" not in spec, (1854                "Postbuilds do not work with custom product_dir"1855            )1856 1857        if self.type == "executable":1858            self.WriteLn(1859                "%s: LD_INPUTS := %s"1860                % (1861                    QuoteSpaces(self.output_binary),1862                    " ".join(QuoteSpaces(dep) for dep in link_deps),1863                )1864            )1865            if self.toolset == "host" and self.flavor == "android":1866                self.WriteDoCmd(1867                    [self.output_binary],1868                    link_deps,1869                    "link_host",1870                    part_of_all,1871                    postbuilds=postbuilds,1872                )1873            else:1874                self.WriteDoCmd(1875                    [self.output_binary],1876                    link_deps,1877                    "link",1878                    part_of_all,1879                    postbuilds=postbuilds,1880                )1881 1882        elif self.type == "static_library":1883            for link_dep in link_deps:1884                assert " " not in link_dep, (1885                    "Spaces in alink input filenames not supported (%s)" % link_dep1886                )1887            if (1888                self.flavor not in ("mac", "openbsd", "netbsd", "win")1889                and not self.is_standalone_static_library1890            ):1891                if self.flavor in ("linux", "android", "openharmony"):1892                    self.WriteMakeRule(1893                        [self.output_binary],1894                        link_deps,1895                        actions=["$(call create_thin_archive,$@,$^)"],1896                    )1897                else:1898                    self.WriteDoCmd(1899                        [self.output_binary],1900                        link_deps,1901                        "alink_thin",1902                        part_of_all,1903                        postbuilds=postbuilds,1904                    )1905            elif self.flavor in ("linux", "android", "openharmony"):1906                self.WriteMakeRule(1907                    [self.output_binary],1908                    link_deps,1909                    actions=["$(call create_archive,$@,$^)"],1910                )1911            else:1912                self.WriteDoCmd(1913                    [self.output_binary],1914                    link_deps,1915                    "alink",1916                    part_of_all,1917                    postbuilds=postbuilds,1918                )1919        elif self.type == "shared_library":1920            self.WriteLn(1921                "%s: LD_INPUTS := %s"1922                % (1923                    QuoteSpaces(self.output_binary),1924                    " ".join(QuoteSpaces(dep) for dep in link_deps),1925                )1926            )1927            self.WriteDoCmd(1928                [self.output_binary],1929                link_deps,1930                "solink",1931                part_of_all,1932                postbuilds=postbuilds,1933            )1934            # z/OS has a .so target as well as a sidedeck .x target1935            if self.flavor == "zos":1936                self.WriteLn(1937                    "%s: %s"1938                    % (1939                        QuoteSpaces(1940                            self.GetSharedObjectFromSidedeck(self.output_binary)1941                        ),1942                        QuoteSpaces(self.output_binary),1943                    )1944                )1945        elif self.type == "loadable_module":1946            for link_dep in link_deps:1947                assert " " not in link_dep, (1948                    "Spaces in module input filenames not supported (%s)" % link_dep1949                )1950            if self.toolset == "host" and self.flavor == "android":1951                self.WriteDoCmd(1952                    [self.output_binary],1953                    link_deps,1954                    "solink_module_host",1955                    part_of_all,1956                    postbuilds=postbuilds,1957                )1958            else:1959                self.WriteDoCmd(1960                    [self.output_binary],1961                    link_deps,1962                    "solink_module",1963                    part_of_all,1964                    postbuilds=postbuilds,1965                )1966        elif self.type == "none":1967            # Write a stamp line.1968            self.WriteDoCmd(1969                [self.output_binary], deps, "touch", part_of_all, postbuilds=postbuilds1970            )1971        else:1972            print("WARNING: no output for", self.type, self.target)1973 1974        # Add an alias for each target (if there are any outputs).1975        # Installable target aliases are created below.1976        if (self.output and self.output != self.target) and (1977            self.type not in self._INSTALLABLE_TARGETS1978        ):1979            self.WriteMakeRule(1980                [self.target], [self.output], comment="Add target alias", phony=True1981            )1982            if part_of_all:1983                self.WriteMakeRule(1984                    ["all"],1985                    [self.target],1986                    comment='Add target alias to "all" target.',1987                    phony=True,1988                )1989 1990        # Add special-case rules for our installable targets.1991        # 1) They need to install to the build dir or "product" dir.1992        # 2) They get shortcuts for building (e.g. "make chrome").1993        # 3) They are part of "make all".1994        if self.type in self._INSTALLABLE_TARGETS or self.is_standalone_static_library:1995            if self.type == "shared_library":1996                file_desc = "shared library"1997            elif self.type == "static_library":1998                file_desc = "static library"1999            else:2000                file_desc = "executable"2001            install_path = self._InstallableTargetInstallPath()2002            installable_deps = []2003            if self.flavor != "zos":2004                installable_deps.append(self.output)2005            if (2006                self.flavor == "mac"2007                and "product_dir" not in spec2008                and self.toolset == "target"2009            ):2010                # On mac, products are created in install_path immediately.2011                assert install_path == self.output, f"{install_path} != {self.output}"2012 2013            # Point the target alias to the final binary output.2014            self.WriteMakeRule(2015                [self.target], [install_path], comment="Add target alias", phony=True2016            )2017            if install_path != self.output:2018                assert not self.is_mac_bundle  # See comment a few lines above.2019                self.WriteDoCmd(2020                    [install_path],2021                    [self.output],2022                    "copy",2023                    comment="Copy this to the %s output path." % file_desc,2024                    part_of_all=part_of_all,2025                )2026                if self.flavor != "zos":2027                    installable_deps.append(install_path)2028            if self.flavor == "zos" and self.type == "shared_library":2029                # lib.target/libnode.so has a dependency on $(obj).target/libnode.so2030                self.WriteDoCmd(2031                    [self.GetSharedObjectFromSidedeck(install_path)],2032                    [self.GetSharedObjectFromSidedeck(self.output)],2033                    "copy",2034                    comment="Copy this to the %s output path." % file_desc,2035                    part_of_all=part_of_all,2036                )2037                # Create a symlink of libnode.x to libnode.version.x2038                self.WriteDoCmd(2039                    [self.GetUnversionedSidedeckFromSidedeck(install_path)],2040                    [install_path],2041                    "symlink",2042                    comment="Symlnk this to the %s output path." % file_desc,2043                    part_of_all=part_of_all,2044                )2045                # Place libnode.version.so and libnode.x symlink in lib.target dir2046                installable_deps.append(self.GetSharedObjectFromSidedeck(install_path))2047                installable_deps.append(2048                    self.GetUnversionedSidedeckFromSidedeck(install_path)2049                )2050            if self.alias not in (self.output, self.target):2051                self.WriteMakeRule(2052                    [self.alias],2053                    installable_deps,2054                    comment="Short alias for building this %s." % file_desc,2055                    phony=True,2056                )2057            if self.flavor == "zos" and self.type == "shared_library":2058                # Make sure that .x symlink target is run2059                self.WriteMakeRule(2060                    ["all"],2061                    [2062                        self.GetUnversionedSidedeckFromSidedeck(install_path),2063                        self.GetSharedObjectFromSidedeck(install_path),2064                    ],2065                    comment='Add %s to "all" target.' % file_desc,2066                    phony=True,2067                )2068            elif part_of_all:2069                self.WriteMakeRule(2070                    ["all"],2071                    [install_path],2072                    comment='Add %s to "all" target.' % file_desc,2073                    phony=True,2074                )2075 2076    def WriteList(self, value_list, variable=None, prefix="", quoter=QuoteIfNecessary):2077        """Write a variable definition that is a list of values.2078 2079        E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out2080             foo = blaha blahb2081        but in a pretty-printed style.2082        """2083        values = ""2084        if value_list:2085            value_list = [replace_sep(quoter(prefix + value)) for value in value_list]2086            values = " \\\n\t" + " \\\n\t".join(value_list)2087        self.fp.write(f"{variable} :={values}\n\n")2088 2089    def WriteDoCmd(2090        self, outputs, inputs, command, part_of_all, comment=None, postbuilds=False2091    ):2092        """Write a Makefile rule that uses do_cmd.2093 2094        This makes the outputs dependent on the command line that was run,2095        as well as support the V= make command line flag.2096        """2097        suffix = ""2098        if postbuilds:2099            assert "," not in command2100            suffix = ",,1"  # Tell do_cmd to honor $POSTBUILDS2101        self.WriteMakeRule(2102            outputs,2103            inputs,2104            actions=[f"$(call do_cmd,{command}{suffix})"],2105            comment=comment,2106            command=command,2107            force=True,2108        )2109        # Add our outputs to the list of targets we read depfiles from.2110        # all_deps is only used for deps file reading, and for deps files we replace2111        # spaces with ? because escaping doesn't work with make's $(sort) and2112        # other functions.2113        outputs = [QuoteSpaces(o, SPACE_REPLACEMENT) for o in outputs]2114        self.WriteLn("all_deps += %s" % " ".join(outputs))2115 2116    def WriteMakeRule(2117        self,2118        outputs,2119        inputs,2120        actions=None,2121        comment=None,2122        order_only=False,2123        force=False,2124        phony=False,2125        command=None,2126    ):2127        """Write a Makefile rule, with some extra tricks.2128 2129        outputs: a list of outputs for the rule (note: this is not directly2130                 supported by make; see comments below)2131        inputs: a list of inputs for the rule2132        actions: a list of shell commands to run for the rule2133        comment: a comment to put in the Makefile above the rule (also useful2134                 for making this Python script's code self-documenting)2135        order_only: if true, makes the dependency order-only2136        force: if true, include FORCE_DO_CMD as an order-only dep2137        phony: if true, the rule does not actually generate the named output, the2138               output is just a name to run the rule2139        command: (optional) command name to generate unambiguous labels2140        """2141        outputs = [QuoteSpaces(o) for o in outputs]2142        inputs = [QuoteSpaces(i) for i in inputs]2143 2144        if comment:2145            self.WriteLn("# " + comment)2146        if phony:2147            self.WriteLn(".PHONY: " + " ".join(outputs))2148        if actions:2149            self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])2150        force_append = " FORCE_DO_CMD" if force else ""2151 2152        if order_only:2153            # Order only rule: Just write a simple rule.2154            # TODO(evanm): just make order_only a list of deps instead of this hack.2155            self.WriteLn(2156                "{}: | {}{}".format(" ".join(outputs), " ".join(inputs), force_append)2157            )2158        elif len(outputs) == 1:2159            # Regular rule, one output: Just write a simple rule.2160            self.WriteLn("{}: {}{}".format(outputs[0], " ".join(inputs), force_append))2161        else:2162            # Regular rule, more than one output: Multiple outputs are tricky in2163            # make. We will write three rules:2164            # - All outputs depend on an intermediate file.2165            # - Make .INTERMEDIATE depend on the intermediate.2166            # - The intermediate file depends on the inputs and executes the2167            #   actual command.2168            # - The intermediate recipe will 'touch' the intermediate file.2169            # - The multi-output rule will have an do-nothing recipe.2170 2171            # Hash the target name to avoid generating overlong filenames.2172            cmddigest = hashlib.sha256(2173                (command or self.target).encode("utf-8")2174            ).hexdigest()2175            intermediate = "%s.intermediate" % cmddigest2176            self.WriteLn("{}: {}".format(" ".join(outputs), intermediate))2177            self.WriteLn("\t%s" % "@:")2178            self.WriteLn("{}: {}".format(".INTERMEDIATE", intermediate))2179            self.WriteLn(2180                "{}: {}{}".format(intermediate, " ".join(inputs), force_append)2181            )2182            actions.insert(0, "$(call do_cmd,touch)")2183 2184        if actions:2185            for action in actions:2186                self.WriteLn("\t%s" % action)2187        self.WriteLn()2188 2189    def WriteAndroidNdkModuleRule(self, module_name, all_sources, link_deps):2190        """Write a set of LOCAL_XXX definitions for Android NDK.2191 2192        These variable definitions will be used by Android NDK but do nothing for2193        non-Android applications.2194 2195        Arguments:2196          module_name: Android NDK module name, which must be unique among all2197              module names.2198          all_sources: A list of source files (will be filtered by Compilable).2199          link_deps: A list of link dependencies, which must be sorted in2200              the order from dependencies to dependents.2201        """2202        if self.type not in ("executable", "shared_library", "static_library"):2203            return2204 2205        self.WriteLn("# Variable definitions for Android applications")2206        self.WriteLn("include $(CLEAR_VARS)")2207        self.WriteLn("LOCAL_MODULE := " + module_name)2208        self.WriteLn(2209            "LOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) "2210            "$(DEFS_$(BUILDTYPE)) "2211            # LOCAL_CFLAGS is applied to both of C and C++.  There is2212            # no way to specify $(CFLAGS_C_$(BUILDTYPE)) only for C2213            # sources.2214            "$(CFLAGS_C_$(BUILDTYPE)) "2215            # $(INCS_$(BUILDTYPE)) includes the prefix '-I' while2216            # LOCAL_C_INCLUDES does not expect it.  So put it in2217            # LOCAL_CFLAGS.2218            "$(INCS_$(BUILDTYPE))"2219        )2220        # LOCAL_CXXFLAGS is obsolete and LOCAL_CPPFLAGS is preferred.2221        self.WriteLn("LOCAL_CPPFLAGS := $(CFLAGS_CC_$(BUILDTYPE))")2222        self.WriteLn("LOCAL_C_INCLUDES :=")2223        self.WriteLn("LOCAL_LDLIBS := $(LDFLAGS_$(BUILDTYPE)) $(LIBS)")2224 2225        # Detect the C++ extension.2226        cpp_ext = {".cc": 0, ".cpp": 0, ".cxx": 0}2227        default_cpp_ext = ".cpp"2228        for filename in all_sources:2229            ext = os.path.splitext(filename)[1]2230            if ext in cpp_ext:2231                cpp_ext[ext] += 12232                if cpp_ext[ext] > cpp_ext[default_cpp_ext]:2233                    default_cpp_ext = ext2234        self.WriteLn("LOCAL_CPP_EXTENSION := " + default_cpp_ext)2235 2236        self.WriteList(2237            list(map(self.Absolutify, filter(Compilable, all_sources))),2238            "LOCAL_SRC_FILES",2239        )2240 2241        # Filter out those which do not match prefix and suffix and produce2242        # the resulting list without prefix and suffix.2243        def DepsToModules(deps, prefix, suffix):2244            modules = []2245            for filepath in deps:2246                filename = os.path.basename(filepath)2247                if filename.startswith(prefix) and filename.endswith(suffix):2248                    modules.append(filename[len(prefix) : -len(suffix)])2249            return modules2250 2251        # Retrieve the default value of 'SHARED_LIB_SUFFIX'2252        params = {"flavor": "linux"}2253        default_variables = {}2254        CalculateVariables(default_variables, params)2255 2256        self.WriteList(2257            DepsToModules(2258                link_deps,2259                generator_default_variables["SHARED_LIB_PREFIX"],2260                default_variables["SHARED_LIB_SUFFIX"],2261            ),2262            "LOCAL_SHARED_LIBRARIES",2263        )2264        self.WriteList(2265            DepsToModules(2266                link_deps,2267                generator_default_variables["STATIC_LIB_PREFIX"],2268                generator_default_variables["STATIC_LIB_SUFFIX"],2269            ),2270            "LOCAL_STATIC_LIBRARIES",2271        )2272 2273        if self.type == "executable":2274            self.WriteLn("include $(BUILD_EXECUTABLE)")2275        elif self.type == "shared_library":2276            self.WriteLn("include $(BUILD_SHARED_LIBRARY)")2277        elif self.type == "static_library":2278            self.WriteLn("include $(BUILD_STATIC_LIBRARY)")2279        self.WriteLn()2280 2281    def WriteLn(self, text=""):2282        self.fp.write(text + "\n")2283 2284    def GetSortedXcodeEnv(self, additional_settings=None):2285        return gyp.xcode_emulation.GetSortedXcodeEnv(2286            self.xcode_settings,2287            "$(abs_builddir)",2288            os.path.join("$(abs_srcdir)", self.path),2289            "$(BUILDTYPE)",2290            additional_settings,2291        )2292 2293    def GetSortedXcodePostbuildEnv(self):2294        # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.2295        # TODO(thakis): It would be nice to have some general mechanism instead.2296        strip_save_file = self.xcode_settings.GetPerTargetSetting(2297            "CHROMIUM_STRIP_SAVE_FILE", ""2298        )2299        # Even if strip_save_file is empty, explicitly write it. Else a postbuild2300        # might pick up an export from an earlier target.2301        return self.GetSortedXcodeEnv(2302            additional_settings={"CHROMIUM_STRIP_SAVE_FILE": strip_save_file}2303        )2304 2305    def WriteSortedXcodeEnv(self, target, env):2306        for k, v in env:2307            # For2308            #  foo := a\ b2309            # the escaped space does the right thing. For2310            #  export foo := a\ b2311            # it does not -- the backslash is written to the env as literal character.2312            # So don't escape spaces in |env[k]|.2313            self.WriteLn(f"{QuoteSpaces(target)}: export {k} := {v}")2314 2315    def Objectify(self, path):2316        """Convert a path to its output directory form."""2317        if "$(" in path:2318            path = path.replace("$(obj)/", "$(obj).%s/$(TARGET)/" % self.toolset)2319        if "$(obj)" not in path:2320            path = f"$(obj).{self.toolset}/$(TARGET)/{path}"2321        return path2322 2323    def Pchify(self, path, lang):2324        """Convert a prefix header path to its output directory form."""2325        path = self.Absolutify(path)2326        if "$(" in path:2327            path = path.replace(2328                "$(obj)/", f"$(obj).{self.toolset}/$(TARGET)/pch-{lang}"2329            )2330            return path2331        return f"$(obj).{self.toolset}/$(TARGET)/pch-{lang}/{path}"2332 2333    def Absolutify(self, path):2334        """Convert a subdirectory-relative path into a base-relative path.2335        Skips over paths that contain variables."""2336        if "$(" in path:2337            # Don't call normpath in this case, as it might collapse the2338            # path too aggressively if it features '..'. However it's still2339            # important to strip trailing slashes.2340            return path.rstrip("/")2341        return os.path.normpath(os.path.join(self.path, path))2342 2343    def ExpandInputRoot(self, template, expansion, dirname):2344        if "%(INPUT_ROOT)s" not in template and "%(INPUT_DIRNAME)s" not in template:2345            return template2346        path = template % {2347            "INPUT_ROOT": expansion,2348            "INPUT_DIRNAME": dirname,2349        }2350        return path2351 2352    def _InstallableTargetInstallPath(self):2353        """Returns the location of the final output for an installable target."""2354        # Functionality removed for all platforms to match Xcode and hoist2355        # shared libraries into PRODUCT_DIR for users:2356        # Xcode puts shared_library results into PRODUCT_DIR, and some gyp files2357        # rely on this. Emulate this behavior for mac.2358        # if self.type == "shared_library" and (2359        #     self.flavor != "mac" or self.toolset != "target"2360        # ):2361        #    # Install all shared libs into a common directory (per toolset) for2362        #    # convenient access with LD_LIBRARY_PATH.2363        #    return "$(builddir)/lib.%s/%s" % (self.toolset, self.alias)2364        if self.flavor == "zos" and self.type == "shared_library":2365            return "$(builddir)/lib.%s/%s" % (self.toolset, self.alias)2366 2367        return "$(builddir)/" + self.alias2368 2369 2370def WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files):2371    """Write the target to regenerate the Makefile."""2372    options = params["options"]2373    build_files_args = [2374        gyp.common.RelativePath(filename, options.toplevel_dir)2375        for filename in params["build_files_arg"]2376    ]2377 2378    gyp_binary = gyp.common.FixIfRelativePath(2379        params["gyp_binary"], options.toplevel_dir2380    )2381    if not gyp_binary.startswith(os.sep):2382        gyp_binary = os.path.join(".", gyp_binary)2383 2384    root_makefile.write(2385        "quiet_cmd_regen_makefile = ACTION Regenerating $@\n"2386        "cmd_regen_makefile = cd $(srcdir); %(cmd)s\n"2387        "%(makefile_name)s: %(deps)s\n"2388        "\t$(call do_cmd,regen_makefile)\n\n"2389        % {2390            "makefile_name": makefile_name,2391            "deps": replace_sep(2392                " ".join(sorted(SourceifyAndQuoteSpaces(bf) for bf in build_files))2393            ),2394            "cmd": replace_sep(2395                gyp.common.EncodePOSIXShellList(2396                    [gyp_binary, "-fmake"]2397                    + gyp.RegenerateFlags(options)2398                    + build_files_args2399                )2400            ),2401        }2402    )2403 2404 2405def PerformBuild(data, configurations, params):2406    options = params["options"]2407    for config in configurations:2408        arguments = ["make"]2409        if options.toplevel_dir and options.toplevel_dir != ".":2410            arguments += "-C", options.toplevel_dir2411        arguments.append("BUILDTYPE=" + config)2412        print(f"Building [{config}]: {arguments}")2413        subprocess.check_call(arguments)2414 2415 2416def GenerateOutput(target_list, target_dicts, data, params):2417    options = params["options"]2418    flavor = gyp.common.GetFlavor(params)2419    generator_flags = params.get("generator_flags", {})2420    builddir_name = generator_flags.get("output_dir", "out")2421    android_ndk_version = generator_flags.get("android_ndk_version", None)2422    default_target = generator_flags.get("default_target", "all")2423 2424    def CalculateMakefilePath(build_file, base_name):2425        """Determine where to write a Makefile for a given gyp file."""2426        # Paths in gyp files are relative to the .gyp file, but we want2427        # paths relative to the source root for the master makefile.  Grab2428        # the path of the .gyp file as the base to relativize against.2429        # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".2430        base_path = gyp.common.RelativePath(os.path.dirname(build_file), options.depth)2431        # We write the file in the base_path directory.2432        output_file = os.path.join(options.depth, base_path, base_name)2433        if options.generator_output:2434            output_file = os.path.join(2435                options.depth, options.generator_output, base_path, base_name2436            )2437        base_path = gyp.common.RelativePath(2438            os.path.dirname(build_file), options.toplevel_dir2439        )2440        return base_path, output_file2441 2442    # TODO:  search for the first non-'Default' target.  This can go2443    # away when we add verification that all targets have the2444    # necessary configurations.2445    default_configuration = None2446    toolsets = {target_dicts[target]["toolset"] for target in target_list}2447    for target in target_list:2448        spec = target_dicts[target]2449        if spec["default_configuration"] != "Default":2450            default_configuration = spec["default_configuration"]2451            break2452    if not default_configuration:2453        default_configuration = "Default"2454 2455    srcdir = "."2456    makefile_name = "Makefile" + options.suffix2457    makefile_path = os.path.join(options.toplevel_dir, makefile_name)2458    if options.generator_output:2459        global srcdir_prefix2460        makefile_path = os.path.join(2461            options.toplevel_dir, options.generator_output, makefile_name2462        )2463        srcdir = replace_sep(gyp.common.RelativePath(srcdir, options.generator_output))2464        srcdir_prefix = "$(srcdir)/"2465 2466    flock_command = "flock"2467    copy_archive_arguments = "-af"2468    makedep_arguments = "-MMD"2469 2470    # wasm-ld doesn't support --start-group/--end-group2471    link_commands = LINK_COMMANDS_LINUX2472    if flavor in ["wasi", "wasm"]:2473        link_commands = link_commands.replace(" -Wl,--start-group", "").replace(2474            " -Wl,--end-group", ""2475        )2476 2477    CC_target = replace_sep(GetEnvironFallback(("CC_target", "CC"), "$(CC)"))2478    AR_target = replace_sep(GetEnvironFallback(("AR_target", "AR"), "$(AR)"))2479    CXX_target = replace_sep(GetEnvironFallback(("CXX_target", "CXX"), "$(CXX)"))2480    LINK_target = replace_sep(GetEnvironFallback(("LINK_target", "LINK"), "$(LINK)"))2481    PLI_target = replace_sep(GetEnvironFallback(("PLI_target", "PLI"), "pli"))2482    CC_host = replace_sep(GetEnvironFallback(("CC_host", "CC"), "gcc"))2483    AR_host = replace_sep(GetEnvironFallback(("AR_host", "AR"), "ar"))2484    CXX_host = replace_sep(GetEnvironFallback(("CXX_host", "CXX"), "g++"))2485    LINK_host = replace_sep(GetEnvironFallback(("LINK_host", "LINK"), "$(CXX.host)"))2486    PLI_host = replace_sep(GetEnvironFallback(("PLI_host", "PLI"), "pli"))2487 2488    header_params = {2489        "default_target": default_target,2490        "builddir": builddir_name,2491        "default_configuration": default_configuration,2492        "flock": flock_command,2493        "flock_index": 1,2494        "link_commands": link_commands,2495        "extra_commands": "",2496        "srcdir": srcdir,2497        "copy_archive_args": copy_archive_arguments,2498        "makedep_args": makedep_arguments,2499        "CC.target": CC_target,2500        "AR.target": AR_target,2501        "CXX.target": CXX_target,2502        "LINK.target": LINK_target,2503        "PLI.target": PLI_target,2504        "CC.host": CC_host,2505        "AR.host": AR_host,2506        "CXX.host": CXX_host,2507        "LINK.host": LINK_host,2508        "PLI.host": PLI_host,2509    }2510    if flavor == "mac":2511        flock_command = "%s gyp-mac-tool flock" % sys.executable2512        header_params.update(2513            {2514                "flock": flock_command,2515                "flock_index": 2,2516                "link_commands": LINK_COMMANDS_MAC,2517                "extra_commands": SHARED_HEADER_MAC_COMMANDS,2518            }2519        )2520    elif flavor == "android":2521        header_params.update({"link_commands": LINK_COMMANDS_ANDROID})2522    elif flavor == "zos":2523        copy_archive_arguments = "-fPR"2524        CC_target = GetEnvironFallback(("CC_target", "CC"), "njsc")2525        makedep_arguments = "-MMD"2526        if CC_target == "clang":2527            CC_host = GetEnvironFallback(("CC_host", "CC"), "clang")2528            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "clang++")2529            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "clang++")2530        elif CC_target == "ibm-clang64":2531            CC_host = GetEnvironFallback(("CC_host", "CC"), "ibm-clang64")2532            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "ibm-clang++64")2533            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "ibm-clang++64")2534        elif CC_target == "ibm-clang":2535            CC_host = GetEnvironFallback(("CC_host", "CC"), "ibm-clang")2536            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "ibm-clang++")2537            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "ibm-clang++")2538        else:2539            # Node.js versions prior to v18:2540            makedep_arguments = "-qmakedep=gcc"2541            CC_host = GetEnvironFallback(("CC_host", "CC"), "njsc")2542            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "njsc++")2543            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "njsc++")2544        header_params.update(2545            {2546                "copy_archive_args": copy_archive_arguments,2547                "makedep_args": makedep_arguments,2548                "link_commands": LINK_COMMANDS_OS390,2549                "extra_commands": SHARED_HEADER_OS390_COMMANDS,2550                "CC.target": CC_target,2551                "CXX.target": CXX_target,2552                "CC.host": CC_host,2553                "CXX.host": CXX_host,2554            }2555        )2556    elif flavor == "solaris":2557        copy_archive_arguments = "-pPRf@"2558        header_params.update(2559            {2560                "copy_archive_args": copy_archive_arguments,2561                "flock": "%s gyp-flock-tool flock" % sys.executable,2562                "flock_index": 2,2563            }2564        )2565    elif flavor == "freebsd":2566        # Note: OpenBSD has sysutils/flock. lockf seems to be FreeBSD specific.2567        header_params.update({"flock": "lockf"})2568    elif flavor == "openbsd":2569        copy_archive_arguments = "-pPRf"2570        header_params.update({"copy_archive_args": copy_archive_arguments})2571    elif flavor == "aix":2572        copy_archive_arguments = "-pPRf"2573        header_params.update(2574            {2575                "copy_archive_args": copy_archive_arguments,2576                "link_commands": LINK_COMMANDS_AIX,2577                "flock": "%s gyp-flock-tool flock" % sys.executable,2578                "flock_index": 2,2579            }2580        )2581    elif flavor == "os400":2582        copy_archive_arguments = "-pPRf"2583        header_params.update(2584            {2585                "copy_archive_args": copy_archive_arguments,2586                "link_commands": LINK_COMMANDS_OS400,2587                "flock": "%s gyp-flock-tool flock" % sys.executable,2588                "flock_index": 2,2589            }2590        )2591 2592    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])2593    make_global_settings_array = data[build_file].get("make_global_settings", [])2594    wrappers = {}2595    for key, value in make_global_settings_array:2596        if key.endswith("_wrapper"):2597            wrappers[key[: -len("_wrapper")]] = "$(abspath %s)" % value2598    make_global_settings = ""2599    for key, value in make_global_settings_array:2600        if re.match(".*_wrapper", key):2601            continue2602        if value[0] != "$":2603            value = "$(abspath %s)" % value2604        wrapper = wrappers.get(key)2605        if wrapper:2606            value = f"{wrapper} {value}"2607            del wrappers[key]2608        if key in ("CC", "CC.host", "CXX", "CXX.host"):2609            make_global_settings += (2610                "ifneq (,$(filter $(origin %s), undefined default))\n" % key2611            )2612            # Let gyp-time envvars win over global settings.2613            env_key = key.replace(".", "_")  # CC.host -> CC_host2614            if env_key in os.environ:2615                value = os.environ[env_key]2616            make_global_settings += f"  {key} = {value}\n"2617            make_global_settings += "endif\n"2618        else:2619            make_global_settings += f"{key} ?= {value}\n"2620    # TODO(ukai): define cmd when only wrapper is specified in2621    # make_global_settings.2622 2623    header_params["make_global_settings"] = make_global_settings2624 2625    gyp.common.EnsureDirExists(makefile_path)2626    root_makefile = open(makefile_path, "w")2627    root_makefile.write(SHARED_HEADER % header_params)2628    # Currently any versions have the same effect, but in future the behavior2629    # could be different.2630    if android_ndk_version:2631        root_makefile.write(2632            "# Define LOCAL_PATH for build of Android applications.\n"2633            "LOCAL_PATH := $(call my-dir)\n"2634            "\n"2635        )2636    for toolset in toolsets:2637        root_makefile.write("TOOLSET := %s\n" % toolset)2638        WriteRootHeaderSuffixRules(root_makefile)2639 2640    # Put build-time support tools next to the root Makefile.2641    dest_path = os.path.dirname(makefile_path)2642    gyp.common.CopyTool(flavor, dest_path)2643 2644    # Find the list of targets that derive from the gyp file(s) being built.2645    needed_targets = set()2646    for build_file in params["build_files"]:2647        for target in gyp.common.AllTargets(target_list, target_dicts, build_file):2648            needed_targets.add(target)2649 2650    build_files = set()2651    include_list = set()2652    for qualified_target in target_list:2653        build_file, target, toolset = gyp.common.ParseQualifiedTarget(qualified_target)2654 2655        this_make_global_settings = data[build_file].get("make_global_settings", [])2656        assert make_global_settings_array == this_make_global_settings, (2657            "make_global_settings needs to be the same for all targets "2658            f"{this_make_global_settings} vs. {make_global_settings}"2659        )2660 2661        build_files.add(gyp.common.RelativePath(build_file, options.toplevel_dir))2662        included_files = data[build_file]["included_files"]2663        for included_file in included_files:2664            # The included_files entries are relative to the dir of the build file2665            # that included them, so we have to undo that and then make them relative2666            # to the root dir.2667            relative_include_file = gyp.common.RelativePath(2668                gyp.common.UnrelativePath(included_file, build_file),2669                options.toplevel_dir,2670            )2671            abs_include_file = os.path.abspath(relative_include_file)2672            # If the include file is from the ~/.gyp dir, we should use absolute path2673            # so that relocating the src dir doesn't break the path.2674            if params["home_dot_gyp"] and abs_include_file.startswith(2675                params["home_dot_gyp"]2676            ):2677                build_files.add(abs_include_file)2678            else:2679                build_files.add(relative_include_file)2680 2681        base_path, output_file = CalculateMakefilePath(2682            build_file, target + "." + toolset + options.suffix + ".mk"2683        )2684 2685        spec = target_dicts[qualified_target]2686        configs = spec["configurations"]2687 2688        if flavor == "mac":2689            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)2690 2691        writer = MakefileWriter(generator_flags, flavor)2692        writer.Write(2693            qualified_target,2694            base_path,2695            output_file,2696            spec,2697            configs,2698            part_of_all=qualified_target in needed_targets,2699        )2700 2701        # Our root_makefile lives at the source root.  Compute the relative path2702        # from there to the output_file for including.2703        mkfile_rel_path = gyp.common.RelativePath(2704            output_file, os.path.dirname(makefile_path)2705        )2706        include_list.add(mkfile_rel_path)2707 2708    # Write out per-gyp (sub-project) Makefiles.2709    depth_rel_path = gyp.common.RelativePath(options.depth, os.getcwd())2710    for build_file in build_files:2711        # The paths in build_files were relativized above, so undo that before2712        # testing against the non-relativized items in target_list and before2713        # calculating the Makefile path.2714        build_file = os.path.join(depth_rel_path, build_file)2715        gyp_targets = [2716            target_dicts[qualified_target]["target_name"]2717            for qualified_target in target_list2718            if qualified_target.startswith(build_file)2719            and qualified_target in needed_targets2720        ]2721        # Only generate Makefiles for gyp files with targets.2722        if not gyp_targets:2723            continue2724        base_path, output_file = CalculateMakefilePath(2725            build_file, os.path.splitext(os.path.basename(build_file))[0] + ".Makefile"2726        )2727        makefile_rel_path = gyp.common.RelativePath(2728            os.path.dirname(makefile_path), os.path.dirname(output_file)2729        )2730        writer.WriteSubMake(output_file, makefile_rel_path, gyp_targets, builddir_name)2731 2732    # Write out the sorted list of includes.2733    root_makefile.write("\n")2734    for include_file in sorted(include_list):2735        # We wrap each .mk include in an if statement so users can tell make to2736        # not load a file by setting NO_LOAD.  The below make code says, only2737        # load the .mk file if the .mk filename doesn't start with a token in2738        # NO_LOAD.2739        root_makefile.write(2740            "ifeq ($(strip $(foreach prefix,$(NO_LOAD),\\\n"2741            "    $(findstring $(join ^,$(prefix)),\\\n"2742            "                 $(join ^," + include_file + ")))),)\n"2743        )2744        root_makefile.write("  include " + include_file + "\n")2745        root_makefile.write("endif\n")2746    root_makefile.write("\n")2747 2748    if not generator_flags.get("standalone") and generator_flags.get(2749        "auto_regeneration", True2750    ):2751        WriteAutoRegenerationRule(params, root_makefile, makefile_name, build_files)2752 2753    root_makefile.write(SHARED_FOOTER)2754 2755    root_makefile.close()2756