From 3878b8da71863831ecd0cb51605477d23199e673 Mon Sep 17 00:00:00 2001 From: Martin Valgur Date: Thu, 20 Jul 2023 14:42:35 +0300 Subject: [PATCH] cc65: migrate to Conan v2 --- recipes/cc65/all/conandata.yml | 4 - recipes/cc65/all/conanfile.py | 210 +++++++++--------- recipes/cc65/all/test_package/conanfile.py | 42 ++-- recipes/cc65/all/test_v1_package/conanfile.py | 33 +++ 4 files changed, 164 insertions(+), 125 deletions(-) create mode 100644 recipes/cc65/all/test_v1_package/conanfile.py diff --git a/recipes/cc65/all/conandata.yml b/recipes/cc65/all/conandata.yml index 0c7a25432a0837..720b04e88ab106 100644 --- a/recipes/cc65/all/conandata.yml +++ b/recipes/cc65/all/conandata.yml @@ -8,11 +8,7 @@ sources: patches: "2.18": - patch_file: "patches/2.18-0001-no-embedded-paths-makefile.patch" - base_path: "source_subfolder" - patch_file: "patches/2.18-0002-libsrc-use-extension.patch" - base_path: "source_subfolder" "2.19": - patch_file: "patches/2.19-0001-no-embedded-paths-makefile.patch" - base_path: "source_subfolder" - patch_file: "patches/2.19-0002-libsrc-use-extension.patch" - base_path: "source_subfolder" diff --git a/recipes/cc65/all/conanfile.py b/recipes/cc65/all/conanfile.py index 242c1cf9eee442..381c8c94dc9946 100644 --- a/recipes/cc65/all/conanfile.py +++ b/recipes/cc65/all/conanfile.py @@ -1,163 +1,167 @@ -from conans import AutoToolsBuildEnvironment, ConanFile, MSBuild, tools -from conans.errors import ConanInvalidConfiguration import os +from conan import ConanFile +from conan.errors import ConanInvalidConfiguration +from conan.tools.files import apply_conandata_patches, chdir, copy, export_conandata_patches, get, replace_in_file, rmdir +from conan.tools.gnu import Autotools, AutotoolsToolchain +from conan.tools.layout import basic_layout +from conan.tools.microsoft import MSBuild, is_msvc, msvs_toolset + +required_conan_version = ">=1.47.0" + class Cc65Conan(ConanFile): name = "cc65" - url = "https://github.com/conan-io/conan-center-index" - homepage = "https://cc65.github.io/" description = "A freeware C compiler for 6502 based systems" license = "Zlib" - topics = ("conan", "cc65", "compiler", "cmos", "6502", "8bit") - exports_sources = "patches/**" + url = "https://github.com/conan-io/conan-center-index" + homepage = "https://cc65.github.io/" + topics = ("compiler", "cmos", "6502", "8bit") + package_type = "application" settings = "os", "arch", "compiler", "build_type" - _autotools = None - _source_subfolder = "source_subfolder" + def export_sources(self): + export_conandata_patches(self) def configure(self): - del self.settings.compiler.libcxx - del self.settings.compiler.cppstd - if self.settings.compiler == "Visual Studio": + self.settings.rm_safe("compiler.libcxx") + self.settings.rm_safe("compiler.cppstd") + if is_msvc(self): if self.settings.arch not in ("x86", "x86_64"): raise ConanInvalidConfiguration("Invalid arch") if self.settings.arch == "x86_64": self.output.info("This recipe will build x86 instead of x86_64 (the binaries are compatible)") - def build_requirements(self): - if self.settings.compiler == "Visual Studio" and not tools.which("make"): - self.build_requires("make/4.2.1") + def layout(self): + basic_layout(self, src_folder="src") - def source(self): - tools.get(**self.conan_data["sources"][self.version]) - extracted_dir = self.name + "-" + self.version - os.rename(extracted_dir, self._source_subfolder) + def package_id(self): + if str(self.info.settings.compiler) in ["msvc", "Visual Studio"]: + if self.settings.arch == "x86_64": + self.info.settings.arch = "x86" + del self.info.settings.compiler - @property - def _datadir(self): - return os.path.join(self.package_folder, "bin", "share", "cc65") + def build_requirements(self): + if is_msvc(self): + self.tool_requires("make/4.3") - @property - def _samplesdir(self): - return os.path.join(self.package_folder, "samples") + def source(self): + get(self, **self.conan_data["sources"][self.version], strip_root=True) + + def generate(self): + tc = AutotoolsToolchain(self) + tc.make_args += [ + f"PREFIX=/", + f"datadir=/bin/share/cc65", + f"samplesdir=/samples", + ] + if self.settings.os == "Windows": + tc.make_args.append("EXE_SUFFIX=.exe") + tc.generate() def _build_msvc(self): msbuild = MSBuild(self) - msvc_platforms = { - "x86": "Win32", - } - arch = str(self.settings.arch) - if arch != "x86": - self.output.warn("{} detected: building x86 instead".format(self.settings.arch)) - arch = "x86" - - msbuild.build(os.path.join(self._source_subfolder, "src", "cc65.sln"), - build_type="Debug" if self.settings.build_type == "Debug" else "Release", - arch=arch, platforms=msvc_platforms) - autotools = self._configure_autotools() - with tools.chdir(os.path.join(self._source_subfolder, "libsrc")): + msbuild.build(sln=os.path.join(self.source_folder, "src", "cc65.sln")) + with chdir(self, os.path.join(self.source_folder, "libsrc")): + autotools = Autotools(self) + autotools.configure() autotools.make() - def _configure_autotools(self): - if self._autotools: - return self._autotools - self._autotools = AutoToolsBuildEnvironment(self) - return self._autotools - - @property - def _make_args(self): - datadir = self._datadir - prefix = self.package_folder - samplesdir = self._samplesdir - if tools.os_info.is_windows: - datadir = tools.unix_path(datadir) - prefix = tools.unix_path(prefix) - samplesdir = tools.unix_path(samplesdir) - args = [ - "PREFIX={}".format(prefix), - "datadir={}".format(datadir), - "samplesdir={}".format(samplesdir), - ] - if self.settings.os == "Windows": - args.append("EXE_SUFFIX=.exe") - return args - def _build_autotools(self): - autotools = self._configure_autotools() - with tools.chdir(os.path.join(self._source_subfolder)): - autotools.make(args=self._make_args) + with chdir(self, self.source_folder): + autotools = Autotools(self) + autotools.make() def _patch_sources(self): - for patch in self.conan_data["patches"][self.version]: - tools.patch(**patch) - if self.settings.compiler == "Visual Studio": - with tools.chdir(os.path.join(self._source_subfolder, "src")): + apply_conandata_patches(self) + if is_msvc(self): + with chdir(self, os.path.join(self.source_folder, "src")): for fn in os.listdir("."): if not fn.endswith(".vcxproj"): continue - tools.replace_in_file(fn, "v141", tools.msvs_toolset(self)) - tools.replace_in_file(fn, "10.0.16299.0", "") + replace_in_file(self, fn, "v141", msvs_toolset(self)) + replace_in_file(self, fn, + ("" + "10.0.16299.0" + ""), + "") if self.settings.os == "Windows": # Add ".exe" suffix to calls from cl65 to other utilities - for fn, var in (("cc65", "CC65"), ("ca65", "CA65"), ("co65", "CO65"), ("ld65", "LD65"), ("grc65", "GRC")): - v = "{},".format(var).ljust(5) - tools.replace_in_file(os.path.join(self._source_subfolder, "src", "cl65", "main.c"), - "CmdInit (&{v} CmdPath, \"{n}\");".format(v=v, n=fn), - "CmdInit (&{v} CmdPath, \"{n}.exe\");".format(v=v, n=fn)) + for fn, var in [ + ("cc65", "CC65"), + ("ca65", "CA65"), + ("co65", "CO65"), + ("ld65", "LD65"), + ("grc65", "GRC"), + ]: + v = f"{var},".ljust(5) + replace_in_file(self, os.path.join(self.source_folder, "src", "cl65", "main.c"), + f'CmdInit (&{v} CmdPath, "{fn}");', + f'CmdInit (&{v} CmdPath, "{fn}.exe");') def build(self): self._patch_sources() - if self.settings.compiler == "Visual Studio": + if is_msvc(self): self._build_msvc() else: self._build_autotools() def _package_msvc(self): - self.copy("*.exe", src=os.path.join(self._source_subfolder, "bin"), dst=os.path.join(self.package_folder, "bin"), keep_path=False) + copy(self, "*.exe", + dst=os.path.join(self.package_folder, "bin"), + src=os.path.join(self.source_folder, "bin"), + keep_path=False) for dir in ("asminc", "cfg", "include", "lib", "target"): - self.copy("*", src=os.path.join(self._source_subfolder, dir), dst=os.path.join(self._datadir, dir)) + copy(self, "*", + dst=os.path.join(self.package_folder, "bin", "share", "cc65", dir), + src=os.path.join(self.source_folder, dir)) def _package_autotools(self): - autotools = self._configure_autotools() - with tools.chdir(os.path.join(self.build_folder, self._source_subfolder)): - autotools.install(args=self._make_args) - - tools.rmdir(self._samplesdir) - tools.rmdir(os.path.join(self.package_folder, "share")) + with chdir(self, os.path.join(self.source_folder)): + autotools = Autotools(self) + autotools.install() + rmdir(self, os.path.join(self.package_path, "samples")) + rmdir(self, os.path.join(self.package_folder, "share")) def package(self): - self.copy(pattern="LICENSE", dst="licenses", src=self._source_subfolder) - if self.settings.compiler == "Visual Studio": + copy(self, "LICENSE", + dst=os.path.join(self.package_folder, "licenses"), + src=self.source_folder) + if is_msvc(self): self._package_msvc() else: self._package_autotools() - def package_id(self): - del self.info.settings.compiler - if self.settings.compiler == "Visual Studio": - if self.settings.arch == "x86_64": - self.info.settings.arch = "x86" - def package_info(self): - bindir = os.path.join(self.package_folder, "bin") - self.output.info("Appending PATH environment variable: %s" % bindir) - self.env_info.PATH.append(bindir) - - self.output.info("Seting CC65_HOME environment variable: %s" % self._datadir) - self.env_info.CC65_HOME = self._datadir + self.cpp_info.frameworkdirs = [] + self.cpp_info.libdirs = [] + self.cpp_info.resdirs = [] + self.cpp_info.includedirs = [] bin_ext = ".exe" if self.settings.os == "Windows" else "" + bindir = os.path.join(self.package_folder, "bin") + datadir = os.path.join(self.package_folder, "bin", "share", "cc65") + + self.output.info(f"Setting CC65_HOME environment variable: {datadir}") + self.buildenv_info.define_path("CC65_HOME", datadir) cc65_cc = os.path.join(bindir, "cc65" + bin_ext) - self.output.info("Seting CC65 environment variable: {}".format(cc65_cc)) - self.env_info.CC65 = cc65_cc + self.output.info(f"Setting CC65 environment variable: {cc65_cc}") + self.buildenv_info.define_path("CC65", cc65_cc) cc65_as = os.path.join(bindir, "ca65" + bin_ext) - self.output.info("Seting AS65 environment variable: {}".format(cc65_as)) - self.env_info.AS65 = cc65_as + self.output.info(f"Setting AS65 environment variable: {cc65_as}") + self.buildenv_info.define_path("AS65", cc65_as) cc65_ld = os.path.join(bindir, "cl65" + bin_ext) - self.output.info("Seting LD65 environment variable: {}".format(cc65_ld)) + self.output.info(f"Setting LD65 environment variable: {cc65_ld}") + self.buildenv_info.define_path("LD65", cc65_ld) + + # TODO: Legacy, to be removed on Conan 2.0 + self.output.info(f"Appending PATH environment variable: {bindir}") + self.env_info.PATH.append(bindir) + self.env_info.CC65_HOME = datadir + self.env_info.CC65 = cc65_cc + self.env_info.AS65 = cc65_as self.env_info.LD65 = cc65_ld diff --git a/recipes/cc65/all/test_package/conanfile.py b/recipes/cc65/all/test_package/conanfile.py index b930a6b2cce7f9..6579b3d301b9c0 100644 --- a/recipes/cc65/all/test_package/conanfile.py +++ b/recipes/cc65/all/test_package/conanfile.py @@ -1,33 +1,39 @@ -from conans import ConanFile, tools import os import shutil +from conan import ConanFile +from conan.tools.build import can_run +from conan.tools.files import copy, mkdir, rm +from conan.tools.layout import basic_layout + class TestPackageConan(ConanFile): settings = "os", "arch", "compiler", "build_type" - - exports_sources = "hello.c", "text.s" + generators = "VirtualRunEnv" + test_type = "explicit" _targets = ("c64", "apple2") + def build_requirements(self): + self.tool_requires(self.tested_reference_str) + + def layout(self): + basic_layout(self) + def build(self): - if not tools.cross_building(self.settings): - for src in self.exports_sources: + if can_run(self): + for src in ["hello.c", "text.s"]: shutil.copy(os.path.join(self.source_folder, src), os.path.join(self.build_folder, src)) for target in self._targets: - output = "hello_{}".format(target) - tools.mkdir(target) - try: - # Try removing the output file to give confidence it is created by cc65 - os.unlink(output) - except FileNotFoundError: - pass - self.run("{p} -O -t {t} hello.c -o {t}/hello.s".format(p=os.environ["CC65"], t=target)) - self.run("{p} -t {t} {t}/hello.s -o {t}/hello.o".format(p=os.environ["AS65"], t=target)) - self.run("{p} -t {t} text.s -o {t}/text.o".format(p=os.environ["AS65"], t=target)) - self.run("{p} -o {o} -t {t} {t}/hello.o {t}/text.o {t}.lib".format(o=output, p=os.environ["LD65"], t=target)) + output = f"hello_{target}" + mkdir(self, target) + rm(self, output, self.build_folder) + self.run(f"cc65 -O -t {target} hello.c -o {target}/hello.s") + self.run(f"ca65 -t {target} {target}/hello.s -o {target}/hello.o") + self.run(f"ca65 -t {target} text.s -o {target}/text.o") + self.run(f"ld65 -o {output} -t {target} {target}/hello.o {target}/text.o {target}.lib") def test(self): - if not tools.cross_building(self.settings): + if can_run(self): for target in self._targets: - assert os.path.isfile("hello_{}".format(target)) + assert os.path.isfile(f"hello_{target}") diff --git a/recipes/cc65/all/test_v1_package/conanfile.py b/recipes/cc65/all/test_v1_package/conanfile.py new file mode 100644 index 00000000000000..b930a6b2cce7f9 --- /dev/null +++ b/recipes/cc65/all/test_v1_package/conanfile.py @@ -0,0 +1,33 @@ +from conans import ConanFile, tools +import os +import shutil + + +class TestPackageConan(ConanFile): + settings = "os", "arch", "compiler", "build_type" + + exports_sources = "hello.c", "text.s" + + _targets = ("c64", "apple2") + + def build(self): + if not tools.cross_building(self.settings): + for src in self.exports_sources: + shutil.copy(os.path.join(self.source_folder, src), os.path.join(self.build_folder, src)) + for target in self._targets: + output = "hello_{}".format(target) + tools.mkdir(target) + try: + # Try removing the output file to give confidence it is created by cc65 + os.unlink(output) + except FileNotFoundError: + pass + self.run("{p} -O -t {t} hello.c -o {t}/hello.s".format(p=os.environ["CC65"], t=target)) + self.run("{p} -t {t} {t}/hello.s -o {t}/hello.o".format(p=os.environ["AS65"], t=target)) + self.run("{p} -t {t} text.s -o {t}/text.o".format(p=os.environ["AS65"], t=target)) + self.run("{p} -o {o} -t {t} {t}/hello.o {t}/text.o {t}.lib".format(o=output, p=os.environ["LD65"], t=target)) + + def test(self): + if not tools.cross_building(self.settings): + for target in self._targets: + assert os.path.isfile("hello_{}".format(target))