Bazel to CMake: extract pure conversion
Refactors bazel_to_cmake to extract a pure conversion function that just returns the converted CMakeLists.txt content string. This separates concerns between directory traversal and conversion and will allow us to integrate bazel_to_cmake as a Bazel test which will aid in upstream enforcement for keeping CMakeLists.txt files up to date.
This includes differentiating between log messages and output text by sending the former to stderr and removing an extra newline in preview mode.
Tested:
1. Ran bazel_to_cmake.py in strict mode and confirmed no diffs.
2. Ran bazel_to_cmake.py on all directories under iree/ with a BUILD file and confirmed no diffs with the generated output except where a file has "bazel_to_cmake: DO NOT EDIT" or strict mode conversion fails:
```
$ for l in $(cat ~/tmp/filenames.txt); do \
./build_tools/bazel_to_cmake/bazel_to_cmake.py \
--dir "${l?}" --preview --strict 2>/dev/null > \
"${l?}/CMakeLists2.txt" \
&& [[ -s "${l?}/CMakeLists.txt" ]] \
&& [[ -s "${l?}/CMakeLists2.txt" ]] \
&& diff -q "${l?}/CMakeLists.txt" "${l?}/CMakeLists2.txt"; \
done
```
3. Checked for diffs in the output of strict mode. Had to make some local edits to get deterministic order from os.walk, which would cause a performance hit, so I don't think we want them. The only difference is that there's no longer a newline after the forced preview of iree/test/models/CMakeLists.txt
PiperOrigin-RevId: 304034136
diff --git a/build_tools/bazel_to_cmake/bazel_to_cmake.py b/build_tools/bazel_to_cmake/bazel_to_cmake.py
index acde314..213df33 100755
--- a/build_tools/bazel_to_cmake/bazel_to_cmake.py
+++ b/build_tools/bazel_to_cmake/bazel_to_cmake.py
@@ -12,33 +12,28 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
+"""This script assists with converting from Bazel BUILD files to CMakeLists.txt.
-# This script assists with converting from Bazel BUILD files to CMakeLists.txt.
-#
-# Bazel BUILD files should, where possible, be written to use simple features
-# that can be directly evaluated and avoid more advanced features like
-# variables, list comprehensions, etc.
-#
-# Generated CMake files will be similar in structure to their source BUILD
-# files by using the functions in build_tools/cmake/ that imitate corresponding
-# Bazel rules (e.g. cc_library -> iree_cc_library.cmake).
-#
-# For usage, see:
-# python3 build_tools/bazel_to_cmake/bazel_to_cmake.py --help
+Bazel BUILD files should, where possible, be written to use simple features
+that can be directly evaluated and avoid more advanced features like
+variables, list comprehensions, etc.
+Generated CMake files will be similar in structure to their source BUILD
+files by using the functions in build_tools/cmake/ that imitate corresponding
+Bazel rules (e.g. cc_library -> iree_cc_library.cmake).
+
+For usage, see:
+ python3 build_tools/bazel_to_cmake/bazel_to_cmake.py --help
+"""
# pylint: disable=missing-docstring
-# pylint: disable=invalid-name
-# pylint: disable=unused-argument
-# pylint: disable=exec-used
import argparse
import datetime
-import itertools
import os
import re
-import textwrap
+import sys
-import bazel_to_cmake_targets
+import bazel_to_cmake_converter
repo_root = None
@@ -97,543 +92,12 @@
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-class BuildFileFunctions(object):
- """Object passed to `exec` that has handlers for BUILD file functions."""
-
- def __init__(self, converter):
- self.converter = converter
- # TODO(gcmn): Do this in a less hard-coded way
- self.PLATFORM_VULKAN_DEPS = []
- self.PLATFORM_VULKAN_TEST_DEPS = ["//iree/testing:gtest_main"]
- self.FLATBUFFER_SUPPORTS_REFLECTIONS = False
- self.PLATFORM_VULKAN_LOADER_COPTS = []
- self.IREE_DRIVER_MODULES = [
- # TODO(b/142004903): enable when Dawn HAL implementation is functional
- # "//iree/hal/dawn:dawn_driver_module",
- "//iree/hal/vmla:vmla_driver_module",
- "//iree/hal/vulkan:vulkan_driver_module",
- "//iree/hal/llvmjit:llvmjit_driver_module",
- ]
-
- # ------------------------------------------------------------------------- #
- # Conversion utilities, written to reduce boilerplate and allow for reuse #
- # between similar rule conversions (e.g. cc_library and cc_binary). #
- # ------------------------------------------------------------------------- #
-
- def _convert_name_block(self, name):
- # NAME
- # rule_name
- return f" NAME\n {name}\n"
-
- def _convert_out_block(self, out):
- # OUT
- # out_name
- return f" OUT\n {out}\n"
-
- def _convert_cc_namespace_block(self, cc_namespace):
- # CC_NAMESPACE
- # "cc_namespace"
- if not cc_namespace:
- return ""
- return f' CC_NAMESPACE\n "{cc_namespace}"\n'
-
- def _convert_cpp_namespace_block(self, cpp_namespace):
- # CPP_NAMESPACE
- # "cpp_namespace"
- if not cpp_namespace:
- return ""
- return f' CPP_NAMESPACE\n "{cpp_namespace}"\n'
-
- def _convert_string_list_block(self, name, values):
- # Note this deliberately distinguishes between an empty list (argument
- # explicitly specified) and None (argument left as default).
- if values is None:
- return ""
- values_list = "\n".join([f' "{v}"' for v in values])
- return f" {name}\n{values_list}\n"
-
- def _convert_flags_block(self, flags):
- return self._convert_string_list_block("FLAGS", flags)
-
- def _convert_translate_tool_block(self, translate_tool):
- if translate_tool and translate_tool != "//iree/tools:iree-translate":
- # Bazel `//iree/base` -> CMake `iree::base`
- # Bazel `//iree/base:api` -> CMake `iree::base::api`
- translate_tool = translate_tool.replace("//iree", "iree") # iree/base:api
- translate_tool = translate_tool.replace(":", "_") # iree/base::api
- translate_tool = translate_tool.replace("/", "_") # iree::base::api
- return f" TRANSLATE_TOOL\n {translate_tool}\n"
- else:
- return ""
-
- def _convert_option_block(self, option, option_value):
- if option_value:
- # Note: this is a truthiness check as well as an existence check, i.e.
- # Bazel `testonly = False` will be handled correctly by this condition.
- return f" {option}\n"
- else:
- return ""
-
- def _convert_alwayslink_block(self, alwayslink):
- return self._convert_option_block("ALWAYSLINK", alwayslink)
-
- def _convert_testonly_block(self, testonly):
- return self._convert_option_block("TESTONLY", testonly)
-
- def _convert_flatten_block(self, flatten):
- return self._convert_option_block("FLATTEN", flatten)
-
- def _convert_file_list_block(self, list_name, files):
- # list_name
- # "file_1.h"
- # "file_2.h"
- # "file_3.h"
- if not files:
- return ""
- files_list = "\n".join([f' "{file}"' for file in files])
- return f" {list_name}\n{files_list}\n"
-
- def _convert_hdrs_block(self, hdrs):
- return self._convert_file_list_block("HDRS", hdrs)
-
- def _convert_textual_hdrs_block(self, textual_hdrs):
- return self._convert_file_list_block("TEXTUAL_HDRS", textual_hdrs)
-
- def _convert_srcs_block(self, srcs):
- return self._convert_file_list_block("SRCS", srcs)
-
- def _convert_src_block(self, src):
- return f' SRC\n "{src}"\n'
-
- def _convert_cc_file_output_block(self, cc_file_output):
- return f' CC_FILE_OUTPUT\n "{cc_file_output}"\n'
-
- def _convert_h_file_output_block(self, h_file_output):
- return f' H_FILE_OUTPUT\n "{h_file_output}"\n'
-
- def _convert_td_file_block(self, td_file):
- if td_file.startswith("//iree"):
- # Bazel `//iree/dir/td_file.td`
- # -> CMake `${IREE_ROOT_DIR}/iree/dir/td_file.td
- # Bazel `//iree/dir/IR:td_file.td`
- # -> CMake `${IREE_ROOT_DIR}/iree/dir/IR/td_file.td
- td_file = td_file.replace("//iree", "${IREE_ROOT_DIR}/iree")
- td_file = td_file.replace(":", "/")
- return f' TD_FILE\n "{td_file}"\n'
-
- def _convert_tbl_outs_block(self, tbl_outs):
- outs_list = "\n".join([f" {flag} {value}" for flag, value in tbl_outs])
- return f" OUTS\n{outs_list}\n"
-
- def _convert_tblgen_block(self, tblgen):
- if tblgen.endswith("iree-tblgen"):
- return " TBLGEN\n IREE\n"
- else:
- return ""
-
- def _convert_target(self, target):
- if target.startswith(":") and target.endswith(("_gen", "Gen")):
- # Files created by gentbl have to be included as source and header files
- # and not as a dependency. Adding these targets to the dependencies list,
- # results in linkage failures if the library including the gentbl dep is
- # marked as ALWAYSLINK.
- # This drops deps in the local namespace ending with '_gen' and 'Gen'
- target = [""]
- elif not target.startswith(("//iree", ":")):
- # External target, call helper method for special case handling.
- target = bazel_to_cmake_targets.convert_external_target(target)
- else:
- # Bazel `:api` -> CMake `::api`
- # Bazel `//iree/base` -> CMake `iree::base`
- # Bazel `//iree/base:api` -> CMake `iree::base::api`
- target = target.replace("//iree", "iree") # iree/base:api
- target = target.replace(":", "::") # iree/base::api or ::api
- target = target.replace("/", "::") # iree::base::api
- target = [target]
- return target
-
- def _convert_target_list_block(self, list_name, targets):
- if not targets:
- return ""
-
- # DEPS
- # package1::target1
- # package1::target2
- # package2::target
- targets = [self._convert_target(t) for t in targets]
- # Flatten lists
- targets = list(itertools.chain.from_iterable(targets))
- # Remove duplicates
- targets = set(targets)
- # Remove Falsey (None and empty string) values
- targets = filter(None, targets)
- # Sort the targets and convert to a list
- targets = sorted(targets)
- target_list_string = "\n".join([f" {target}" for target in targets])
- return f" {list_name}\n{target_list_string}\n"
-
- def _convert_data_block(self, data):
- return self._convert_target_list_block("DATA", data)
-
- def _convert_deps_block(self, deps):
- return self._convert_target_list_block("DEPS", deps)
-
- def _convert_flatc_args_block(self, flatc_args):
- if not flatc_args:
- return ""
- flatc_args = "\n".join([f' "{flatc_arg}"' for flatc_arg in flatc_args])
- return f" FLATC_ARGS\n{flatc_args}\n"
-
- def _convert_unimplemented_function(self, function, details=""):
- message = f"Unimplemented {function}: {details}"
- if not self.converter.first_error:
- self.converter.first_error = NotImplementedError(message)
- # Avoid submitting the raw results from non-strict runs. These are still
- # useful but are generally not safe to submit as-is. An upstream check
- # prevents changes with this phrase from being submitted.
- # Written as separate literals to avoid the check triggering here.
- submit_blocker = "DO" + " NOT" + " SUBMIT."
- self.converter.body += f"# {submit_blocker} {message}\n"
-
- # ------------------------------------------------------------------------- #
- # Function handlers that convert BUILD definitions to CMake definitions. #
- # #
- # Names and signatures must match 1:1 with those expected in BUILD files. #
- # Each function that may be found in a BUILD file must be listed here. #
- # ------------------------------------------------------------------------- #
-
- def load(self, *args):
- # No mapping to CMake, ignore.
- pass
-
- def package(self, **kwargs):
- # No mapping to CMake, ignore.
- pass
-
- def iree_build_test(self, **kwargs):
- pass
-
- def filegroup(self, name, **kwargs):
- # Not implemented yet. Might be a no-op, or may want to evaluate the srcs
- # attribute and pass them along to any targets that depend on the filegroup.
- # Cross-package dependencies and complicated globs could be hard to handle.
-
- # We have a bunch of filegroups that just contain TD files. CMake doesn't
- # model this at all, so we'll just hardcode this special case.
- # TODO(gcmn): Handle this robustly
- if name == "td_files":
- return
-
- self._convert_unimplemented_function("filegroup", name)
-
- def sh_binary(self, name, **kwargs):
- self._convert_unimplemented_function("sh_binary", name)
-
- def exports_files(self, *args, **kwargs):
- # No mapping to CMake, ignore.
- pass
-
- def glob(self, include, exclude=None, exclude_directories=1):
- if exclude_directories != 1:
- self._convert_unimplemented_function("glob", "with exclude_directories")
- if exclude:
- self._convert_unimplemented_function("glob", "with exclude")
-
- glob_vars = []
- for pattern in include:
- if "**" in pattern:
- # bazel's glob has some specific restrictions about crossing package
- # boundaries. We have no uses of recursive globs. Rather than try to
- # emulate them or silently give different behavior, just error out.
- # See https://docs.bazel.build/versions/master/be/functions.html#glob
- raise NotImplementedError("Recursive globs not supported")
- # Bazel `*.mlir` glob -> CMake Variable `_GLOB_X_MLIR`
- var = "_GLOB_" + pattern.replace("*", "X").replace(".", "_").upper()
- glob_vars.append(f"${{{var}}}") # {{ / }} are the escapes for { / }
- self.converter.body += f"file(GLOB {var} CONFIGURE_DEPENDS {pattern})\n"
- return glob_vars
-
- # TODO(gcmn) implement these types of functions in a less hard-coded way
- def platform_trampoline_deps(self, basename, path="base"):
- return [f"//iree/{path}/internal:{basename}_internal"]
-
- def select(self, d):
- self._convert_unimplemented_function("select", str(d))
- return d["//conditions:default"]
-
- def config_setting(self, **kwargs):
- # No mapping to CMake, ignore.
- pass
-
- def cc_library(self,
- name,
- hdrs=None,
- textual_hdrs=None,
- srcs=None,
- data=None,
- deps=None,
- alwayslink=False,
- testonly=False,
- linkopts=None,
- **kwargs):
- if linkopts:
- self._convert_unimplemented_function("linkopts")
- name_block = self._convert_name_block(name)
- hdrs_block = self._convert_hdrs_block(hdrs)
- textual_hdrs_block = self._convert_textual_hdrs_block(textual_hdrs)
- srcs_block = self._convert_srcs_block(srcs)
- data_block = self._convert_data_block(data)
- deps_block = self._convert_deps_block(deps)
- alwayslink_block = self._convert_alwayslink_block(alwayslink)
- testonly_block = self._convert_testonly_block(testonly)
-
- self.converter.body += (f"iree_cc_library(\n"
- f"{name_block}"
- f"{hdrs_block}"
- f"{textual_hdrs_block}"
- f"{srcs_block}"
- f"{data_block}"
- f"{deps_block}"
- f"{alwayslink_block}"
- f"{testonly_block}"
- f" PUBLIC\n)\n\n")
-
- def cc_test(self, name, hdrs=None, srcs=None, data=None, deps=None, **kwargs):
- name_block = self._convert_name_block(name)
- hdrs_block = self._convert_hdrs_block(hdrs)
- srcs_block = self._convert_srcs_block(srcs)
- data_block = self._convert_data_block(data)
- deps_block = self._convert_deps_block(deps)
-
- self.converter.body += (f"iree_cc_test(\n"
- f"{name_block}"
- f"{hdrs_block}"
- f"{srcs_block}"
- f"{data_block}"
- f"{deps_block}"
- f")\n\n")
-
- def cc_binary(self,
- name,
- srcs=None,
- data=None,
- deps=None,
- linkopts=None,
- testonly=False,
- **kwargs):
- if linkopts:
- self._convert_unimplemented_function("linkopts")
- name_block = self._convert_name_block(name)
- out_block = self._convert_out_block(name)
- srcs_block = self._convert_srcs_block(srcs)
- data_block = self._convert_data_block(data)
- deps_block = self._convert_deps_block(deps)
- testonly_block = self._convert_testonly_block(testonly)
-
- self.converter.body += (f"iree_cc_binary(\n"
- f"{name_block}"
- f"{out_block}"
- f"{srcs_block}"
- f"{data_block}"
- f"{deps_block}"
- f"{testonly_block}"
- f")\n\n")
-
- def cc_embed_data(self,
- name,
- srcs,
- cc_file_output,
- h_file_output,
- cpp_namespace=None,
- strip_prefix=None,
- flatten=False,
- identifier=None,
- **kwargs):
- if identifier:
- self._convert_unimplemented_function("cc_embed_data",
- name + " has identifier")
- name_block = self._convert_name_block(name)
- srcs_block = self._convert_srcs_block(srcs)
- cc_file_output_block = self._convert_cc_file_output_block(cc_file_output)
- h_file_output_block = self._convert_h_file_output_block(h_file_output)
- namespace_block = self._convert_cpp_namespace_block(cpp_namespace)
- flatten_block = self._convert_flatten_block(flatten)
-
- self.converter.body += (f"iree_cc_embed_data(\n"
- f"{name_block}"
- f"{srcs_block}"
- f"{cc_file_output_block}"
- f"{h_file_output_block}"
- f"{namespace_block}"
- f"{flatten_block}"
- f" PUBLIC\n)\n\n")
-
- def spirv_kernel_cc_library(self, name, srcs):
- name_block = self._convert_name_block(name)
- srcs_block = self._convert_srcs_block(srcs)
-
- self.converter.body += (f"iree_spirv_kernel_cc_library(\n"
- f"{name_block}"
- f"{srcs_block}"
- f")\n\n")
-
- def iree_bytecode_module(self,
- name,
- src,
- flags=["-iree-mlir-to-vm-bytecode-module"],
- translate_tool="//iree/tools:iree-translate",
- cc_namespace=None):
- name_block = self._convert_name_block(name)
- src_block = self._convert_src_block(src)
- namespace_block = self._convert_cc_namespace_block(cc_namespace)
- translate_tool_block = self._convert_translate_tool_block(translate_tool)
- flags_block = self._convert_flags_block(flags)
-
- self.converter.body += (f"iree_bytecode_module(\n"
- f"{name_block}"
- f"{src_block}"
- f"{namespace_block}"
- f"{translate_tool_block}"
- f"{flags_block}"
- f" PUBLIC\n)\n\n")
-
- def iree_flatbuffer_cc_library(self, name, srcs, flatc_args=None):
- name_block = self._convert_name_block(name)
- srcs_block = self._convert_srcs_block(srcs)
- flatc_args_block = self._convert_flatc_args_block(flatc_args)
-
- self.converter.body += (f"flatbuffer_cc_library(\n"
- f"{name_block}"
- f"{srcs_block}"
- f"{flatc_args_block}"
- f" PUBLIC\n)\n\n")
-
- def gentbl(self,
- name,
- tblgen,
- td_file,
- tbl_outs,
- td_srcs=None,
- td_includes=None,
- strip_include_prefix=None,
- test=False):
- name_block = self._convert_name_block(name)
- tblgen_block = self._convert_tblgen_block(tblgen)
- td_file_block = self._convert_td_file_block(td_file)
- outs_block = self._convert_tbl_outs_block(tbl_outs)
-
- self.converter.body += (f"iree_tablegen_library(\n"
- f"{name_block}"
- f"{td_file_block}"
- f"{outs_block}"
- f"{tblgen_block}"
- f")\n\n")
-
- def iree_tablegen_doc(self,
- name,
- tblgen,
- td_file,
- tbl_outs,
- td_srcs=None,
- td_includes=None,
- strip_include_prefix=None):
- name_block = self._convert_name_block(name)
- tblgen_block = self._convert_tblgen_block(tblgen)
- td_file_block = self._convert_td_file_block(td_file)
- outs_block = self._convert_tbl_outs_block(tbl_outs)
-
- self.converter.body += (f"iree_tablegen_doc(\n"
- f"{name_block}"
- f"{td_file_block}"
- f"{outs_block}"
- f"{tblgen_block}"
- f")\n\n")
-
- def iree_lit_test_suite(self, name, srcs, data, **kwargs):
- name_block = self._convert_name_block(name)
- srcs_block = self._convert_srcs_block(srcs)
- data_block = self._convert_data_block(data)
-
- self.converter.body += (f"iree_lit_test_suite(\n"
- f"{name_block}"
- f"{srcs_block}"
- f"{data_block}"
- f")\n\n")
-
- def iree_check_test_suite(self,
- name,
- srcs=None,
- target_backends_and_drivers=None,
- args=None,
- **kwargs):
- name_block = self._convert_name_block(name)
- srcs_block = self._convert_srcs_block(srcs)
- target_backends = None
- drivers = None
- if target_backends_and_drivers is not None:
- target_backends = [it[0] for it in target_backends_and_drivers]
- drivers = [it[1] for it in target_backends_and_drivers]
- target_backends_block = self._convert_string_list_block(
- "TARGET_BACKENDS", target_backends)
- drivers_block = self._convert_string_list_block("DRIVERS", drivers)
- args_block = self._convert_string_list_block("ARGS", args)
-
- self.converter.body += (f"iree_check_test_suite(\n"
- f"{name_block}"
- f"{srcs_block}"
- f"{target_backends_block}"
- f"{drivers_block}"
- f"{args_block}"
- f")\n\n")
-
-
-class Converter(object):
- """Conversion state tracking and full file template substitution."""
-
- def __init__(self, directory_path, rel_build_file_path):
- self.body = ""
- self.directory_path = directory_path
- self.rel_build_file_path = rel_build_file_path
- self.first_error = None
-
- def convert(self, copyright_line):
- converted_file = (f"{copyright_line}\n"
- f"{self.apache_license}\n\n"
- f"iree_add_all_subdirs()\n\n"
- f"{self.body}")
-
- # Cleanup newline characters. This is more convenient than ensuring all
- # conversions are careful with where they insert newlines.
- converted_file = converted_file.replace("\n\n\n", "\n")
- converted_file = converted_file.rstrip() + "\n"
-
- return converted_file
-
- apache_license = textwrap.dedent("""\
- #
- # 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
- #
- # https://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.""")
-
-
-def GetDict(obj):
- ret = {}
- for k in dir(obj):
- if not k.startswith("_"):
- ret[k] = getattr(obj, k)
- return ret
+def log(*args, **kwargs):
+ print(*args, **kwargs, file=sys.stderr)
def convert_directory_tree(root_directory_path, write_files, strict):
- print(f"convert_directory_tree: {root_directory_path}")
+ log(f"convert_directory_tree: {root_directory_path}")
for root, _, _ in os.walk(root_directory_path):
convert_directory(root, write_files, strict)
@@ -652,7 +116,7 @@
global repo_root
rel_build_file_path = os.path.relpath(build_file_path, repo_root)
rel_cmakelists_file_path = os.path.relpath(cmakelists_file_path, repo_root)
- print(f"Converting {rel_build_file_path} to {rel_cmakelists_file_path}")
+ log(f"Converting {rel_build_file_path} to {rel_cmakelists_file_path}")
cmake_file_exists = os.path.isfile(cmakelists_file_path)
copyright_line = f"# Copyright {datetime.date.today().year} Google LLC"
@@ -663,41 +127,38 @@
if line.startswith("# Copyright"):
copyright_line = line.rstrip()
if EDIT_BLOCKING_PATTERN.search(line):
- print(f" {rel_cmakelists_file_path} already exists, and "
- f"line {i + 1}: '{line.strip()}' prevents edits. "
- "Falling back to preview")
+ log(f" {rel_cmakelists_file_path} already exists, and "
+ f"line {i + 1}: '{line.strip()}' prevents edits. "
+ f"Falling back to preview")
write_allowed = False
if write_allowed:
# TODO(scotttodd): Attempt to merge instead of overwrite?
# Existing CMakeLists.txt may have special logic that should be preserved
if cmake_file_exists:
- print(f" {rel_cmakelists_file_path} already exists; overwriting")
+ log(f" {rel_cmakelists_file_path} already exists; overwriting")
else:
- print(f" {rel_cmakelists_file_path} does not exist yet; creating")
- print("")
+ log(f" {rel_cmakelists_file_path} does not exist yet; creating")
+ log("")
with open(build_file_path, "rt") as build_file:
build_file_code = compile(build_file.read(), build_file_path, "exec")
- converter = Converter(directory_path, rel_build_file_path)
try:
- exec(build_file_code, GetDict(BuildFileFunctions(converter)))
- converted_text = converter.convert(copyright_line)
- if strict and converter.first_error:
- raise converter.first_error # pylint: disable=raising-bad-type
+ converted_text = bazel_to_cmake_converter.convert_build_file(
+ build_file_code, copyright_line, strict=strict)
if write_allowed:
with open(cmakelists_file_path, "wt") as cmakelists_file:
cmakelists_file.write(converted_text)
else:
- print(converted_text)
+ print(converted_text, end="")
except (NameError, NotImplementedError) as e:
- print(f"Failed to convert {rel_build_file_path}.", end=" ")
- print("Missing a rule handler in bazel_to_cmake.py?")
- print(f" Reason: `{type(e).__name__}: {e}`")
+ log(f"Failed to convert {rel_build_file_path}.", end=" ")
+ log("Missing a rule handler in bazel_to_cmake.py?")
+ log(f" Reason: `{type(e).__name__}: {e}`")
except KeyError as e:
- print(f"Failed to convert {rel_build_file_path}.", end=" ")
- print("Missing a conversion in bazel_to_cmake_targets.py?")
- print(f" Reason: `{type(e).__name__}: {e}`")
+ log(f"Failed to convert {rel_build_file_path}.", end=" ")
+ log("Missing a conversion in bazel_to_cmake_targets.py?")
+ log(f" Reason: `{type(e).__name__}: {e}`")
def main(args):
