# @generated
# Copyright 2016 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Repository rule to generate host xcode_config and xcode_version targets.
The xcode_config and xcode_version targets are configured for xcodes/SDKs
installed on the local host.
"""
def _search_string(fullstring, prefix, suffix):
"""Returns the substring between two given substrings of a larger string.
Args:
fullstring: The larger string to search.
prefix: The substring that should occur directly before the returned string.
suffix: The substring that should occur directly after the returned string.
Returns:
A string occurring in fullstring exactly prefixed by prefix, and exactly
terminated by suffix. For example, ("hello goodbye", "lo ", " bye") will
return "good". If there is no such string, returns the empty string.
"""
prefix_index = fullstring.find(prefix)
if (prefix_index < 0):
return ""
result_start_index = prefix_index + len(prefix)
suffix_index = fullstring.find(suffix, result_start_index)
if (suffix_index < 0):
return ""
return fullstring[result_start_index:suffix_index]
def _search_sdk_output(output, sdkname):
"""Returns the sdk version given xcodebuild stdout and an sdkname."""
return _search_string(output, "(%s" % sdkname, ")")
def _xcode_version_output(repository_ctx, name, version, aliases, developer_dir):
"""Returns a string containing an xcode_version build target."""
build_contents = ""
decorated_aliases = []
error_msg = ""
for alias in aliases:
decorated_aliases.append("'%s'" % alias)
xcodebuild_result = repository_ctx.execute(["xcrun", "xcodebuild", "-version", "-sdk"], 30,
{"DEVELOPER_DIR": developer_dir})
if (xcodebuild_result.return_code != 0):
error_msg = (
"Invoking xcodebuild failed, developer dir: {devdir} ," +
"return code {code}, stderr: {err}, stdout: {out}").format(
devdir=developer_dir,
code=xcodebuild_result.return_code,
err=xcodebuild_result.stderr,
out=xcodebuild_result.stdout)
ios_sdk_version = _search_sdk_output(xcodebuild_result.stdout, "iphoneos")
tvos_sdk_version = _search_sdk_output(xcodebuild_result.stdout, "appletvos")
macos_sdk_version = _search_sdk_output(xcodebuild_result.stdout, "macosx")
watchos_sdk_version = _search_sdk_output(xcodebuild_result.stdout, "watchos")
build_contents += "xcode_version(\n name = '%s'," % name
build_contents += "\n version = '%s'," % version
if aliases:
build_contents += "\n aliases = [%s]," % " ,".join(decorated_aliases)
if ios_sdk_version:
build_contents += "\n default_ios_sdk_version = '%s'," % ios_sdk_version
if tvos_sdk_version:
build_contents += "\n default_tvos_sdk_version = '%s'," % tvos_sdk_version
if macos_sdk_version:
build_contents += "\n default_macos_sdk_version = '%s'," % macos_sdk_version
if watchos_sdk_version:
build_contents += "\n default_watchos_sdk_version = '%s'," % watchos_sdk_version
build_contents += "\n)\n"
if error_msg:
build_contents += "\n# Error: " + error_msg.replace("\n", " ") + "\n"
print(error_msg)
return build_contents
VERSION_CONFIG_STUB = "xcode_config(name = 'host_xcodes')"
def run_xcode_locator(repository_ctx, xcode_locator_src_label):
"""Generates xcode-locator from source and runs it.
Builds xcode-locator in the current repository directory.
Returns the standard output of running xcode-locator with -v, which will
return information about locally installed Xcode toolchains and the versions
they are associated with.
This should only be invoked on a darwin OS, as xcode-locator cannot be built
otherwise.
Args:
repository_ctx: The repository context.
xcode_locator_src_label: The label of the source file for xcode-locator.
Returns:
A 2-tuple containing:
output: A list representing installed xcode toolchain information. Each
element of the list is a struct containing information for one installed
toolchain. This is an empty list if there was an error building or
running xcode-locator.
err: An error string describing the error that occurred when attempting
to build and run xcode-locator, or None if the run was successful.
"""
xcodeloc_src_path = str(repository_ctx.path(xcode_locator_src_label))
xcrun_result = repository_ctx.execute(["env", "-i", "xcrun", "clang", "-fobjc-arc", "-framework",
"CoreServices", "-framework", "Foundation", "-o",
"xcode-locator-bin", xcodeloc_src_path], 30)
if (xcrun_result.return_code != 0):
suggestion = ""
if "Agreeing to the Xcode/iOS license" in xcrun_result.stderr:
suggestion = ("(You may need to sign the xcode license." +
" Try running 'sudo xcodebuild -license')")
error_msg = (
"Generating xcode-locator-bin failed. {suggestion} " +
"return code {code}, stderr: {err}, stdout: {out}").format(
suggestion=suggestion,
code=xcrun_result.return_code,
err=xcrun_result.stderr,
out=xcrun_result.stdout)
return ([], error_msg.replace("\n", " "))
xcode_locator_result = repository_ctx.execute(["./xcode-locator-bin", "-v"], 30)
if (xcode_locator_result.return_code != 0):
error_msg = (
"Invoking xcode-locator failed, " +
"return code {code}, stderr: {err}, stdout: {out}").format(
code=xcode_locator_result.return_code,
err=xcode_locator_result.stderr,
out=xcode_locator_result.stdout)
return ([], error_msg.replace("\n", " "))
xcode_toolchains = []
# xcode_dump is comprised of newlines with different installed xcode versions,
# each line of the form <version>:<comma_separated_aliases>:<developer_dir>.
xcode_dump = xcode_locator_result.stdout
for xcodeversion in xcode_dump.split("\n"):
if ":" in xcodeversion:
infosplit = xcodeversion.split(":")
toolchain = struct(
version = infosplit[0],
aliases = infosplit[1].split(","),
developer_dir = infosplit[2]
)
xcode_toolchains.append(toolchain)
return (xcode_toolchains, None)
def _darwin_build_file(repository_ctx):
"""Evaluates local system state to create xcode_config and xcode_version targets."""
xcodebuild_result = repository_ctx.execute(["env", "-i", "xcrun", "xcodebuild", "-version"], 30)
# "xcodebuild -version" failing may be indicative of no versions of xcode
# installed, which is an acceptable machine configuration to have for using
# bazel. Thus no print warning should be emitted here.
if (xcodebuild_result.return_code != 0):
error_msg = (
"Running xcodebuild -version failed, " +
"return code {code}, stderr: {err}, stdout: {out}").format(
code=xcodebuild_result.return_code,
err=xcodebuild_result.stderr,
out=xcodebuild_result.stdout)
return VERSION_CONFIG_STUB + "\n# Error: " + error_msg.replace("\n", " ") + "\n"
(toolchains, xcodeloc_err) = run_xcode_locator(repository_ctx,
Label(repository_ctx.attr.xcode_locator))
if xcodeloc_err:
return VERSION_CONFIG_STUB + "\n# Error: " + xcodeloc_err + "\n"
default_xcode_version = _search_string(xcodebuild_result.stdout, "Xcode ", "\n")
default_xcode_target = ""
target_names = []
buildcontents = ""
for toolchain in toolchains:
version = toolchain.version
aliases = toolchain.aliases
developer_dir = toolchain.developer_dir
target_name = "version%s" % version.replace(".", "_")
buildcontents += _xcode_version_output(repository_ctx, target_name, version, aliases, developer_dir)
target_names.append("':%s'" % target_name)
if (version == default_xcode_version or default_xcode_version in aliases):
default_xcode_target = target_name
buildcontents += "xcode_config(name = 'host_xcodes',"
if target_names:
buildcontents += "\n versions = [%s]," % ", ".join(target_names)
if default_xcode_target:
buildcontents += "\n default = ':%s'," % default_xcode_target
buildcontents += "\n)\n"
return buildcontents
def _impl(repository_ctx):
"""Implementation for the local_config_xcode repository rule.
Generates a BUILD file containing a root xcode_config target named 'host_xcodes',
which points to an xcode_version target for each version of xcode installed on
the local host machine. If no versions of xcode are present on the machine
(for instance, if this is a non-darwin OS), creates a stub target.
Args:
repository_ctx: The repository context.
"""
os_name = repository_ctx.os.name.lower()
build_contents = "package(default_visibility = ['//visibility:public'])\n\n"
if (os_name.startswith("mac os")):
build_contents += _darwin_build_file(repository_ctx)
else:
build_contents += VERSION_CONFIG_STUB
repository_ctx.file("BUILD", build_contents)
xcode_autoconf = repository_rule(
implementation=_impl,
local=True,
attrs={
"xcode_locator": attr.string(),
}
)
def xcode_configure(xcode_locator_label):
"""Generates a repository containing host xcode version information."""
xcode_autoconf(
name="local_config_xcode",
xcode_locator=xcode_locator_label
)