gn: add initial gn recipe

recipes/gn/all/conandata.yml

@@ -0,0 +1,3 @@
+sources:
+  "cci.20210429":
+    url: "https://gn.googlesource.com/gn/+archive/6771ce569fb4803dad7a427aa2e2c23e960b917e.tar.gz"

recipes/gn/all/conanfile.py

@@ -0,0 +1,122 @@
+from conans import ConanFile, tools
+from conans.errors import ConanInvalidConfiguration
+from contextlib import contextmanager
+import os
+import textwrap
+import time
+
+required_conan_version = ">=1.33.0"
+
+
+class GnConan(ConanFile):
+    name = "gn"
+    description = "GN is a meta-build system that generates build files for Ninja."
+    url = "https://github.com/conan-io/conan-center-index"
+    topics = ("gn", "build", "system", "ninja")
+    license = ("LGPL-3.0", "GPL-2.0")
+    homepage = "https://gn.googlesource.com/"
+    settings = "os", "arch", "compiler", "build_type"
+
+    @property
+    def _source_subfolder(self):
+        return "source_subfolder"
+
+    @property
+    def _minimum_compiler_version_supporting_cxx17(self):
+        return {
+            "Visual Studio": 15,
+            "gcc": 7,
+            "clang": 4,
+            "apple-clang": 10,
+        }.get(str(self.settings.compiler))
+
+    def configure(self):
+        if self.settings.compiler.cppstd:
+            tools.check_min_cppstd(self, 17)
+        else:
+            if self._minimum_compiler_version_supporting_cxx17:
+                if tools.Version(self.settings.compiler.version) < self._minimum_compiler_version_supporting_cxx17:
+                    raise ConanInvalidConfiguration("gn requires a compiler supporting c++17")
+            else:
+                self.output.warn("gn recipe does not recognize the compiler. gn requires a compiler supporting c++17. Assuming it does.")
+
+    def package_id(self):
+        del self.info.settings.compiler
+
+    def source(self):
+        tools.get(**self.conan_data["sources"][self.version], destination=self._source_subfolder)
+
+    def build_requirements(self):
+        self.build_requires("ninja/1.10.2")
+
+    @contextmanager
+    def _build_context(self):
+        if self.settings.compiler == "Visual Studio":
+            with tools.vcvars(self.settings):
+                yield
+        else:
+            compiler_defaults = {}
+            if self.settings.compiler == "gcc":
+                compiler_defaults = {
+                    "CC": "gcc",
+                    "CXX": "g++",
+                    "AR": "ar",
+                    "LD": "g++",
+                }
+            elif self.settings.compiler == "clang":
+                compiler_defaults = {
+                    "CC": "clang",
+                    "CXX": "clang++",
+                    "AR": "ar",
+                    "LD": "clang++",
+                }
+            env = {}
+            for k in ("CC", "CXX", "AR", "LD"):
+                v = tools.get_env(k, compiler_defaults.get(k, None))
+                if v:
+                    env[k] = v
+            with tools.environment_append(env):
+                yield
+
+    @staticmethod
+    def _to_gn_platform(os_, compiler):
+        if tools.is_apple_os(os_):
+            return "darwin"
+        if compiler == "Visual Studio":
+            return "msvc"
+        # Assume gn knows about the os
+        return str(os_).lower()
+
+    def build(self):
+        with tools.chdir(self._source_subfolder):
+            with self._build_context():
+                tools.save(os.path.join("src", "gn", "last_commit_position.h"),
+                           textwrap.dedent("""\
+                                #pragma once
+                                #define LAST_COMMIT_POSITION "1"
+                                #define LAST_COMMIT_POSITION_NUM 1
+                                """))
+                conf_args = [
+                    "--no-last-commit-position",
+                    "--host={}".format(self._to_gn_platform(self.settings.os, self.settings.compiler)),
+                ]
+                if self.settings.build_type == "Debug":
+                    conf_args.append("-d")
+                self.run("python build/gen.py {}".format(" ".join(conf_args)), run_environment=True)
+                # Try sleeping one second to avoid time skew of the generated ninja.build file (and having to re-run build/gen.py)
+                time.sleep(1)
+                build_args = [
+                    "-C", "out",
+                    "-j{}".format(tools.cpu_count()),
+                ]
+                self.run("ninja {}".format(" ".join(build_args)), run_environment=True)
+
+    def package(self):
+        self.copy("LICENSE", src=self._source_subfolder, dst="licenses")
+        self.copy("gn", src=os.path.join(self._source_subfolder, "out"), dst="bin")
+        self.copy("gn.exe", src=os.path.join(self._source_subfolder, "out"), dst="bin")
+
+    def package_info(self):
+        bin_path = os.path.join(self.package_folder, "bin")
+        self.output.info("Appending PATH environment variable: {}".format(bin_path))
+        self.env_info.PATH.append(bin_path)

recipes/gn/all/test_package/.gn

@@ -0,0 +1,2 @@
+# The location of the build configuration file.
+buildconfig = "//config/BUILDCONFIG.gn"

recipes/gn/all/test_package/BUILD.gn

@@ -0,0 +1,22 @@
+
+executable("test_package") {
+    sources = ["test_package.cpp"]
+
+    deps = [
+        ":test_shared",
+        ":test_static",
+    ]
+}
+
+shared_library("test_shared") {
+    defines = ["TEST_SHARED_BUILD"]
+    sources = [
+        "test_shared.cpp",
+    ]
+}
+
+static_library("test_static") {
+    sources = [
+        "test_static.cpp",
+    ]
+}

recipes/gn/all/test_package/conanfile.py

@@ -0,0 +1,69 @@
+from conans import ConanFile, CMake, tools
+from contextlib import contextmanager
+import os
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+
+    def build_requirements(self):
+        self.build_requires("ninja/1.10.2")
+
+    @contextmanager
+    def _build_context(self):
+        if self.settings.compiler == "Visual Studio":
+            with tools.vcvars(self.settings):
+                yield
+        else:
+            compiler_defaults = {}
+            if self.settings.compiler == "gcc":
+                compiler_defaults = {
+                    "CC": "gcc",
+                    "CXX": "g++",
+                    "AR": "ar",
+                    "LD": "g++",
+                }
+            elif self.settings.compiler in ("apple-clang", "clang"):
+                compiler_defaults = {
+                    "CC": "clang",
+                    "CXX": "clang++",
+                    "AR": "ar",
+                    "LD": "clang++",
+                }
+            env = {}
+            for k in ("CC", "CXX", "AR", "LD"):
+                v = tools.get_env(k, compiler_defaults.get(k, None))
+                if v:
+                    env[k] = v
+            with tools.environment_append(env):
+                yield
+
+    @property
+    def _target_os(self):
+        if tools.is_apple_os(self.settings.os):
+            return "mac"
+        # Assume gn knows about the os
+        return {
+            "Windows": "win",
+        }.get(str(self.settings.os), str(self.settings.os).lower())
+
+    @property
+    def _target_cpu(self):
+        return {
+            "x86_64": "x64",
+        }.get(str(self.settings.arch), str(self.settings.arch))
+
+    def build(self):
+        if not tools.cross_building(self.settings):
+            with tools.chdir(self.source_folder):
+                gn_args = [
+                    os.path.relpath(os.path.join(self.build_folder, "bin"), os.getcwd()).replace("\\", "/"),
+                    "--args=\"target_os=\\\"{os_}\\\" target_cpu=\\\"{cpu}\\\"\"".format(os_=self._target_os, cpu=self._target_cpu),
+                ]
+                self.run("gn gen {}".format(" ".join(gn_args)), run_environment=True)
+            with self._build_context():
+                self.run("ninja -v -j{} -C bin".format(tools.cpu_count()), run_environment=True)
+
+    def test(self):
+        if not tools.cross_building(self.settings):
+            self.run(os.path.join("bin", "test_package"), run_environment=True)

recipes/gn/all/test_package/config/BUILD.gn

@@ -0,0 +1,24 @@
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+config("compiler_defaults") {
+  if (current_os == "linux") {
+    cflags = [
+      "-fPIC",
+      "-pthread",
+    ]
+  }
+  if (current_os == "windows") {
+    cflags_cc = [
+      "-EHsc",
+    ]
+  }
+}
+config("executable_ldconfig") {
+  if (!is_mac && current_os != "windows") {
+    ldflags = [
+      "-Wl,-rpath=\$ORIGIN/",
+      "-Wl,-rpath-link=",
+    ]
+  }
+}

recipes/gn/all/test_package/config/BUILDCONFIG.gn

@@ -0,0 +1,48 @@
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+if (target_os == "") {
+  target_os = host_os
+}
+if (target_cpu == "") {
+  target_cpu = host_cpu
+}
+if (current_cpu == "") {
+  current_cpu = target_cpu
+}
+if (current_os == "") {
+  current_os = target_os
+}
+is_windows = host_os == "win" && current_os == "win" && target_os == "win"
+is_linux = host_os == "linux" && current_os == "linux" && target_os == "linux"
+is_mac = host_os == "mac" && current_os == "mac" && target_os == "mac"
+# All binary targets will get this list of configs by default.
+_shared_binary_target_configs = [ "//config:compiler_defaults" ]
+# Apply that default list to the binary target types.
+set_defaults("executable") {
+  configs = _shared_binary_target_configs
+  # Executables get this additional configuration.
+  configs += [ "//config:executable_ldconfig" ]
+}
+set_defaults("static_library") {
+  configs = _shared_binary_target_configs
+}
+set_defaults("shared_library") {
+  configs = _shared_binary_target_configs
+}
+set_defaults("source_set") {
+  configs = _shared_binary_target_configs
+}
+if (is_windows) {
+  set_default_toolchain("//config/toolchain:msvc")
+} else {
+  set_default_toolchain("//config/toolchain:gcc")
+}
+
+print("current_os:", current_os)
+print("current_cpu:", current_cpu)
+print("host_os:", host_os)
+print("host_cpu:", host_cpu)
+print("target_os:", target_os)
+print("target_cpu:", target_os)