#!/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()