blob: 1c2d48971c0efaaf3ba1bdf796075f3333d618b1 [file] [log] [blame]
#!/usr/bin/env fuchsia-vendored-python
#
# Copyright 2016 Google Inc.
#
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Usage: gn_to_cmake.py <json_file_name>
gn gen out/config --ide=json --json-ide-script=../../gn/gn_to_cmake.py
or
gn gen out/config --ide=json
python gn/gn_to_cmake.py out/config/project.json
The first is recommended, as it will auto-update.
"""
import itertools
import functools
import json
import posixpath
import os
import string
import sys
def CMakeStringEscape(a):
"""Escapes the string 'a' for use inside a CMake string.
This means escaping
'\' otherwise it may be seen as modifying the next character
'"' otherwise it will end the string
';' otherwise the string becomes a list
The following do not need to be escaped
'#' when the lexer is in string state, this does not start a comment
"""
return a.replace("\\", "\\\\").replace(";", "\\;").replace('"', '\\"')
def CMakeTargetEscape(a):
"""Escapes the string 'a' for use as a CMake target name.
CMP0037 in CMake 3.0 restricts target names to "^[A-Za-z0-9_.:+-]+$"
The ':' is only allowed for imported targets.
"""
def Escape(c):
if c in string.ascii_letters or c in string.digits or c in "_.+-":
return c
else:
return "__"
return "".join(map(Escape, a))
def SetVariable(out, variable_name, value):
"""Sets a CMake variable."""
out.write('set("')
out.write(CMakeStringEscape(variable_name))
out.write('" "')
out.write(CMakeStringEscape(value))
out.write('")\n')
def SetVariableList(out, variable_name, values):
"""Sets a CMake variable to a list."""
if not values:
return SetVariable(out, variable_name, "")
if len(values) == 1:
return SetVariable(out, variable_name, values[0])
out.write('list(APPEND "')
out.write(CMakeStringEscape(variable_name))
out.write('"\n "')
out.write('"\n "'.join([CMakeStringEscape(value) for value in values]))
out.write('")\n')
def SetFilesProperty(output, variable, property_name, values, sep):
"""Given a set of source files, sets the given property on them."""
output.write("set_source_files_properties(")
WriteVariable(output, variable)
output.write(" PROPERTIES ")
output.write(property_name)
output.write(' "')
for value in values:
output.write(CMakeStringEscape(value))
output.write(sep)
output.write('")\n')
def SetCurrentTargetProperty(out, property_name, values, sep=""):
"""Given a target, sets the given property."""
out.write('set_target_properties("${target}" PROPERTIES ')
out.write(property_name)
out.write(' "')
for value in values:
out.write(CMakeStringEscape(value))
out.write(sep)
out.write('")\n')
def WriteVariable(output, variable_name, prepend=None):
if prepend:
output.write(prepend)
output.write("${")
output.write(variable_name)
output.write("}")
# See GetSourceFileType in gn
source_file_types = {
".cc": "cxx",
".cpp": "cxx",
".cxx": "cxx",
".c": "c",
".s": "asm",
".S": "asm",
".asm": "asm",
".o": "obj",
".obj": "obj",
}
class CMakeTargetType(object):
def __init__(self, command, modifier, property_modifier, is_linkable):
self.command = command
self.modifier = modifier
self.property_modifier = property_modifier
self.is_linkable = is_linkable
CMakeTargetType.custom = CMakeTargetType(
"add_custom_target", "SOURCES", None, False
)
# See GetStringForOutputType in gn
cmake_target_types = {
"unknown": CMakeTargetType.custom,
"group": CMakeTargetType.custom,
"executable": CMakeTargetType("add_executable", None, "RUNTIME", True),
"loadable_module": CMakeTargetType(
"add_library", "MODULE", "LIBRARY", True
),
"shared_library": CMakeTargetType("add_library", "SHARED", "LIBRARY", True),
"static_library": CMakeTargetType(
"add_library", "STATIC", "ARCHIVE", False
),
"source_set": CMakeTargetType("add_library", "OBJECT", None, False),
"copy": CMakeTargetType.custom,
"action": CMakeTargetType.custom,
"action_foreach": CMakeTargetType.custom,
"bundle_data": CMakeTargetType.custom,
"create_bundle": CMakeTargetType.custom,
}
def FindFirstOf(s, a):
return min(s.find(i) for i in a if i in s)
class Project(object):
def __init__(self, project_json):
self.targets = project_json["targets"]
build_settings = project_json["build_settings"]
self.root_path = build_settings["root_path"]
self.build_path = posixpath.join(
self.root_path, build_settings["build_dir"][2:]
)
def GetAbsolutePath(self, path):
if path.startswith("//"):
return self.root_path + "/" + path[2:]
else:
return path
def GetObjectSourceDependencies(self, gn_target_name, object_dependencies):
"""All OBJECT libraries whose sources have not been absorbed."""
dependencies = self.targets[gn_target_name].get("deps", [])
for dependency in dependencies:
dependency_type = self.targets[dependency].get("type", None)
if dependency_type == "source_set":
object_dependencies.add(dependency)
if dependency_type not in gn_target_types_that_absorb_objects:
self.GetObjectSourceDependencies(
dependency, object_dependencies
)
def GetObjectLibraryDependencies(self, gn_target_name, object_dependencies):
"""All OBJECT libraries whose libraries have not been absorbed."""
dependencies = self.targets[gn_target_name].get("deps", [])
for dependency in dependencies:
dependency_type = self.targets[dependency].get("type", None)
if dependency_type == "source_set":
object_dependencies.add(dependency)
self.GetObjectLibraryDependencies(
dependency, object_dependencies
)
def GetCMakeTargetName(self, gn_target_name):
# See <chromium>/src/tools/gn/label.cc#Resolve
# //base/test:test_support(//build/toolchain/win:msvc)
path_separator = FindFirstOf(gn_target_name, (":", "("))
location = None
name = None
toolchain = None
if not path_separator:
location = gn_target_name[2:]
else:
location = gn_target_name[2:path_separator]
toolchain_separator = gn_target_name.find("(", path_separator)
if toolchain_separator == -1:
name = gn_target_name[path_separator + 1 :]
else:
if toolchain_separator > path_separator:
name = gn_target_name[
path_separator + 1 : toolchain_separator
]
assert gn_target_name.endswith(")")
toolchain = gn_target_name[toolchain_separator + 1 : -1]
assert location or name
cmake_target_name = None
if location.endswith("/" + name):
cmake_target_name = location
elif location:
cmake_target_name = location + "_" + name
else:
cmake_target_name = name
if toolchain:
cmake_target_name += "--" + toolchain
return CMakeTargetEscape(cmake_target_name)
class Target(object):
def __init__(self, gn_target_name, project):
self.gn_name = gn_target_name
self.properties = project.targets[self.gn_name]
self.cmake_name = project.GetCMakeTargetName(self.gn_name)
self.gn_type = self.properties.get("type", None)
self.cmake_type = cmake_target_types.get(self.gn_type, None)
def WriteAction(out, target, project, sources, synthetic_dependencies):
outputs = []
output_directories = set()
for output in target.properties.get("outputs", []):
output_abs_path = project.GetAbsolutePath(output)
outputs.append(output_abs_path)
output_directory = posixpath.dirname(output_abs_path)
if output_directory:
output_directories.add(output_directory)
outputs_name = "${target}__output"
SetVariableList(out, outputs_name, outputs)
out.write("add_custom_command(OUTPUT ")
WriteVariable(out, outputs_name)
out.write("\n")
if output_directories:
out.write(' COMMAND ${CMAKE_COMMAND} -E make_directory "')
out.write('" "'.join(map(CMakeStringEscape, output_directories)))
out.write('"\n')
script = target.properties["script"]
arguments = target.properties["args"]
out.write(' COMMAND python "')
out.write(CMakeStringEscape(project.GetAbsolutePath(script)))
out.write('"')
if arguments:
out.write('\n "')
out.write('"\n "'.join(map(CMakeStringEscape, arguments)))
out.write('"')
out.write("\n")
out.write(" DEPENDS ")
for sources_type_name in sources.values():
WriteVariable(out, sources_type_name, " ")
out.write("\n")
# TODO: CMake 3.7 is introducing DEPFILE
out.write(' WORKING_DIRECTORY "')
out.write(CMakeStringEscape(project.build_path))
out.write('"\n')
out.write(' COMMENT "Action: ${target}"\n')
out.write(" VERBATIM)\n")
synthetic_dependencies.add(outputs_name)
def ExpandPlaceholders(source, a):
source_dir, source_file_part = posixpath.split(source)
source_name_part, _ = posixpath.splitext(source_file_part)
# TODO: {{source_gen_dir}}, {{source_out_dir}}, {{response_file_name}}
return (
a.replace("{{source}}", source)
.replace("{{source_file_part}}", source_file_part)
.replace("{{source_name_part}}", source_name_part)
.replace("{{source_dir}}", source_dir)
.replace("{{source_root_relative_dir}}", source_dir)
)
def WriteActionForEach(out, target, project, sources, synthetic_dependencies):
all_outputs = target.properties.get("outputs", [])
inputs = target.properties.get("sources", [])
# TODO: consider expanding 'output_patterns' instead.
outputs_per_input = len(all_outputs) / len(inputs)
for count, source in enumerate(inputs):
source_abs_path = project.GetAbsolutePath(source)
outputs = []
output_directories = set()
for output in all_outputs[
outputs_per_input * count : outputs_per_input * (count + 1)
]:
output_abs_path = project.GetAbsolutePath(output)
outputs.append(output_abs_path)
output_directory = posixpath.dirname(output_abs_path)
if output_directory:
output_directories.add(output_directory)
outputs_name = "${target}__output_" + str(count)
SetVariableList(out, outputs_name, outputs)
out.write("add_custom_command(OUTPUT ")
WriteVariable(out, outputs_name)
out.write("\n")
if output_directories:
out.write(' COMMAND ${CMAKE_COMMAND} -E make_directory "')
out.write('" "'.join(map(CMakeStringEscape, output_directories)))
out.write('"\n')
script = target.properties["script"]
# TODO: need to expand {{xxx}} in arguments
arguments = target.properties["args"]
out.write(' COMMAND python "')
out.write(CMakeStringEscape(project.GetAbsolutePath(script)))
out.write('"')
if arguments:
out.write('\n "')
expand = functools.partial(ExpandPlaceholders, source_abs_path)
out.write(
'"\n "'.join(map(CMakeStringEscape, map(expand, arguments)))
)
out.write('"')
out.write("\n")
out.write(" DEPENDS")
if "input" in sources:
WriteVariable(out, sources["input"], " ")
out.write(' "')
out.write(CMakeStringEscape(source_abs_path))
out.write('"\n')
# TODO: CMake 3.7 is introducing DEPFILE
out.write(' WORKING_DIRECTORY "')
out.write(CMakeStringEscape(project.build_path))
out.write('"\n')
out.write(' COMMENT "Action ${target} on ')
out.write(CMakeStringEscape(source_abs_path))
out.write('"\n')
out.write(" VERBATIM)\n")
synthetic_dependencies.add(outputs_name)
def WriteCopy(out, target, project, sources, synthetic_dependencies):
inputs = target.properties.get("sources", [])
raw_outputs = target.properties.get("outputs", [])
# TODO: consider expanding 'output_patterns' instead.
outputs = []
for output in raw_outputs:
output_abs_path = project.GetAbsolutePath(output)
outputs.append(output_abs_path)
outputs_name = "${target}__output"
SetVariableList(out, outputs_name, outputs)
out.write("add_custom_command(OUTPUT ")
WriteVariable(out, outputs_name)
out.write("\n")
for src, dst in zip(inputs, outputs):
out.write(' COMMAND ${CMAKE_COMMAND} -E copy "')
out.write(CMakeStringEscape(project.GetAbsolutePath(src)))
out.write('" "')
out.write(CMakeStringEscape(dst))
out.write('"\n')
out.write(" DEPENDS ")
for sources_type_name in sources.values():
WriteVariable(out, sources_type_name, " ")
out.write("\n")
out.write(' WORKING_DIRECTORY "')
out.write(CMakeStringEscape(project.build_path))
out.write('"\n')
out.write(' COMMENT "Copy ${target}"\n')
out.write(" VERBATIM)\n")
synthetic_dependencies.add(outputs_name)
def WriteCompilerFlags(out, target, project, sources):
# Hack, set linker language to c if no c or cxx files present.
if not "c" in sources and not "cxx" in sources:
SetCurrentTargetProperty(out, "LINKER_LANGUAGE", ["C"])
# Mark uncompiled sources as uncompiled.
if "input" in sources:
SetFilesProperty(
out, sources["input"], "HEADER_FILE_ONLY", ("True",), ""
)
if "other" in sources:
SetFilesProperty(
out, sources["other"], "HEADER_FILE_ONLY", ("True",), ""
)
# Mark object sources as linkable.
if "obj" in sources:
SetFilesProperty(out, sources["obj"], "EXTERNAL_OBJECT", ("True",), "")
# TODO: 'output_name', 'output_dir', 'output_extension'
# This includes using 'source_outputs' to direct compiler output.
# Includes
includes = target.properties.get("include_dirs", [])
if includes:
out.write('set_property(TARGET "${target}" ')
out.write("APPEND PROPERTY INCLUDE_DIRECTORIES")
for include_dir in includes:
out.write('\n "')
out.write(project.GetAbsolutePath(include_dir))
out.write('"')
out.write(")\n")
# Defines
defines = target.properties.get("defines", [])
if defines:
SetCurrentTargetProperty(out, "COMPILE_DEFINITIONS", defines, ";")
# Compile flags
# "arflags", "asmflags", "cflags",
# "cflags_c", "clfags_cc", "cflags_objc", "clfags_objcc"
# CMake does not have per target lang compile flags.
# TODO: $<$<COMPILE_LANGUAGE:CXX>:cflags_cc style generator expression.
# http://public.kitware.com/Bug/view.php?id=14857
flags = []
flags.extend(target.properties.get("cflags", []))
cflags_asm = target.properties.get("asmflags", [])
cflags_c = target.properties.get("cflags_c", [])
cflags_cxx = target.properties.get("cflags_cc", [])
if "c" in sources and not any(k in sources for k in ("asm", "cxx")):
flags.extend(cflags_c)
elif "cxx" in sources and not any(k in sources for k in ("asm", "c")):
flags.extend(cflags_cxx)
else:
# TODO: This is broken, one cannot generally set properties on files,
# as other targets may require different properties on the same files.
if "asm" in sources and cflags_asm:
SetFilesProperty(
out, sources["asm"], "COMPILE_FLAGS", cflags_asm, " "
)
if "c" in sources and cflags_c:
SetFilesProperty(out, sources["c"], "COMPILE_FLAGS", cflags_c, " ")
if "cxx" in sources and cflags_cxx:
SetFilesProperty(
out, sources["cxx"], "COMPILE_FLAGS", cflags_cxx, " "
)
if flags:
SetCurrentTargetProperty(out, "COMPILE_FLAGS", flags, " ")
# Linker flags
ldflags = target.properties.get("ldflags", [])
if ldflags:
SetCurrentTargetProperty(out, "LINK_FLAGS", ldflags, " ")
gn_target_types_that_absorb_objects = (
"executable",
"loadable_module",
"shared_library",
"static_library",
)
def WriteSourceVariables(out, target, project):
# gn separates the sheep from the goats based on file extensions.
# A full separation is done here because of flag handing (see Compile flags).
source_types = {
"cxx": [],
"c": [],
"asm": [],
"obj": [],
"obj_target": [],
"input": [],
"other": [],
}
all_sources = target.properties.get("sources", [])
# As of cmake 3.11 add_library must have sources. If there are
# no sources, add empty.cpp as the file to compile.
if len(all_sources) == 0:
all_sources.append(posixpath.join(project.build_path, "empty.cpp"))
# TODO .def files on Windows
for source in all_sources:
_, ext = posixpath.splitext(source)
source_abs_path = project.GetAbsolutePath(source)
source_types[source_file_types.get(ext, "other")].append(
source_abs_path
)
for input_path in target.properties.get("inputs", []):
input_abs_path = project.GetAbsolutePath(input_path)
source_types["input"].append(input_abs_path)
# OBJECT library dependencies need to be listed as sources.
# Only executables and non-OBJECT libraries may reference an OBJECT library.
# https://gitlab.kitware.com/cmake/cmake/issues/14778
if target.gn_type in gn_target_types_that_absorb_objects:
object_dependencies = set()
project.GetObjectSourceDependencies(target.gn_name, object_dependencies)
for dependency in object_dependencies:
cmake_dependency_name = project.GetCMakeTargetName(dependency)
obj_target_sources = (
"$<TARGET_OBJECTS:" + cmake_dependency_name + ">"
)
source_types["obj_target"].append(obj_target_sources)
sources = {}
for source_type, sources_of_type in source_types.items():
if sources_of_type:
sources[source_type] = "${target}__" + source_type + "_srcs"
SetVariableList(out, sources[source_type], sources_of_type)
return sources
def WriteTarget(out, target, project):
out.write("\n#")
out.write(target.gn_name)
out.write("\n")
if target.cmake_type is None:
print(
"Target %s has unknown target type %s, skipping."
% (target.gn_name, target.gn_type)
)
return
SetVariable(out, "target", target.cmake_name)
sources = WriteSourceVariables(out, target, project)
synthetic_dependencies = set()
if target.gn_type == "action":
WriteAction(out, target, project, sources, synthetic_dependencies)
if target.gn_type == "action_foreach":
WriteActionForEach(
out, target, project, sources, synthetic_dependencies
)
if target.gn_type == "copy":
WriteCopy(out, target, project, sources, synthetic_dependencies)
out.write(target.cmake_type.command)
out.write('("${target}"')
if target.cmake_type.modifier is not None:
out.write(" ")
out.write(target.cmake_type.modifier)
for sources_type_name in sources.values():
WriteVariable(out, sources_type_name, " ")
if synthetic_dependencies:
out.write(" DEPENDS")
for synthetic_dependencie in synthetic_dependencies:
WriteVariable(out, synthetic_dependencie, " ")
out.write(")\n")
if target.cmake_type.command != "add_custom_target":
WriteCompilerFlags(out, target, project, sources)
libraries = set()
nonlibraries = set()
dependencies = set(target.properties.get("deps", []))
# Transitive OBJECT libraries are in sources.
# Those sources are dependent on the OBJECT library dependencies.
# Those sources cannot bring in library dependencies.
object_dependencies = set()
if target.gn_type != "source_set":
project.GetObjectLibraryDependencies(
target.gn_name, object_dependencies
)
for object_dependency in object_dependencies:
dependencies.update(
project.targets.get(object_dependency).get("deps", [])
)
for dependency in dependencies:
gn_dependency_type = project.targets.get(dependency, {}).get(
"type", None
)
cmake_dependency_type = cmake_target_types.get(gn_dependency_type, None)
cmake_dependency_name = project.GetCMakeTargetName(dependency)
if cmake_dependency_type.command != "add_library":
nonlibraries.add(cmake_dependency_name)
elif cmake_dependency_type.modifier != "OBJECT":
if target.cmake_type.is_linkable:
libraries.add(cmake_dependency_name)
else:
nonlibraries.add(cmake_dependency_name)
# Non-library dependencies.
if nonlibraries:
out.write('add_dependencies("${target}"')
for nonlibrary in nonlibraries:
out.write('\n "')
out.write(nonlibrary)
out.write('"')
out.write(")\n")
# Non-OBJECT library dependencies.
external_libraries = target.properties.get("libs", [])
if target.cmake_type.is_linkable and (external_libraries or libraries):
library_dirs = target.properties.get("lib_dirs", [])
if library_dirs:
SetVariableList(out, "${target}__library_directories", library_dirs)
system_libraries = []
for external_library in external_libraries:
if "/" in external_library:
libraries.add(project.GetAbsolutePath(external_library))
else:
if external_library.endswith(".framework"):
external_library = external_library[: -len(".framework")]
system_library = "library__" + external_library
if library_dirs:
system_library = system_library + "__for_${target}"
out.write('find_library("')
out.write(CMakeStringEscape(system_library))
out.write('" "')
out.write(CMakeStringEscape(external_library))
out.write('"')
if library_dirs:
out.write(' PATHS "')
WriteVariable(out, "${target}__library_directories")
out.write('"')
out.write(")\n")
system_libraries.append(system_library)
out.write('target_link_libraries("${target}"')
for library in libraries:
out.write('\n "')
out.write(CMakeStringEscape(library))
out.write('"')
for system_library in system_libraries:
WriteVariable(out, system_library, '\n "')
out.write('"')
out.write(")\n")
def WriteProject(project):
out = open(posixpath.join(project.build_path, "CMakeLists.txt"), "w+")
extName = posixpath.join(project.build_path, "CMakeLists.ext")
out.write("# Generated by %s.\n" % os.path.basename(__file__))
out.write("cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n")
out.write("cmake_policy(VERSION 2.8.8)\n\n")
out.write('file(WRITE "')
out.write(
CMakeStringEscape(posixpath.join(project.build_path, "empty.cpp"))
)
out.write('")\n')
# Update the gn generated ninja build.
# If a build file has changed, this will update CMakeLists.ext if
# gn gen out/config --ide=json --json-ide-script=../../gn/gn_to_cmake.py
# style was used to create this config.
out.write("execute_process(COMMAND\n")
out.write(' ninja -C "')
out.write(CMakeStringEscape(project.build_path))
out.write('" build.ninja\n')
out.write(" RESULT_VARIABLE ninja_result)\n")
out.write("if (ninja_result)\n")
out.write(" message(WARNING ")
out.write('"Regeneration failed running ninja: ${ninja_result}")\n')
out.write("endif()\n")
out.write('include("')
out.write(CMakeStringEscape(extName))
out.write('")\n')
out.close()
out = open(extName, "w+")
out.write("# Generated by %s.\n", os.path.basename(__file__))
out.write("cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n")
out.write("cmake_policy(VERSION 2.8.8)\n")
# The following appears to be as-yet undocumented.
# http://public.kitware.com/Bug/view.php?id=8392
out.write("enable_language(ASM)\n\n")
# ASM-ATT does not support .S files.
# output.write('enable_language(ASM-ATT)\n')
# Current issues with automatic re-generation:
# The gn generated build.ninja target uses build.ninja.d
# but build.ninja.d does not contain the ide or gn.
# Currently the ide is not run if the project.json file is not changed
# but the ide needs to be run anyway if it has itself changed.
# This can be worked around by deleting the project.json file.
out.write('file(READ "')
gn_deps_file = posixpath.join(project.build_path, "build.ninja.d")
out.write(CMakeStringEscape(gn_deps_file))
out.write('" "gn_deps_string" OFFSET ')
out.write(str(len("build.ninja: ")))
out.write(")\n")
# One would think this would need to worry about escaped spaces
# but gn doesn't escape spaces here (it generates invalid .d files).
out.write('string(REPLACE " " ";" "gn_deps" ${gn_deps_string})\n')
out.write('foreach("gn_dep" ${gn_deps})\n')
out.write(' configure_file("')
out.write(CMakeStringEscape(project.build_path))
out.write('${gn_dep}" "CMakeLists.devnull" COPYONLY)\n')
out.write('endforeach("gn_dep")\n')
out.write('list(APPEND other_deps "')
out.write(CMakeStringEscape(os.path.abspath(__file__)))
out.write('")\n')
out.write('foreach("other_dep" ${other_deps})\n')
out.write(
' configure_file("${other_dep}" "CMakeLists.devnull" COPYONLY)\n'
)
out.write('endforeach("other_dep")\n')
for target_name in project.targets.keys():
out.write("\n")
WriteTarget(out, Target(target_name, project), project)
def main():
if len(sys.argv) != 2:
print("Usage: " + sys.argv[0] + " <json_file_name>")
exit(1)
json_path = sys.argv[1]
project = None
with open(json_path, "r") as json_file:
project = json.loads(json_file.read())
WriteProject(Project(project))
if __name__ == "__main__":
main()