def build(self):
if (self.settings.build_type != "Release"):
raise errors.ConanInvalidConfiguration(
"Only Release builds are supported.")
if (self.settings.arch == "x86" or self.settings.arch == "x86_64"):
# match the arch naming convention used in AppImageKit
appimagetool_arch_name = "i386" if self.settings.arch == "x86" else self.settings.arch
tools.download(
"https://github.com/AppImage/AppImageUpdate/releases/download/%s/appimageupdatetool-%s.AppImage"
% (self.version, appimagetool_arch_name),
"appimageupdatetool-%s.AppImage" % appimagetool_arch_name)
else:
raise errors.ConanInvalidConfiguration("Unsuported arch: %s" %
self.settings.arch)
self.run(
"chmod +x appimageupdatetool-%s.AppImage && ./appimageupdatetool-%s.AppImage --appimage-extract"
% (appimagetool_arch_name, appimagetool_arch_name),
run_environment=True)
tools.download(
"https://raw.githubusercontent.com/AppImage/AppImageUpdate/continuous/include/appimage/update.h",
"update.h")
def _cmake(self):
python = Python(self.options.python_executable, self.settings)
if str(self.options.python_version) != python.version:
raise errors.ConanInvalidConfiguration(
"python_version option not compatible with python_executable:"
"{} != {}".format(str(self.options.python_version),
python.version))
if self.options.python_debug != python.debug:
raise errors.ConanInvalidConfiguration(
"python_debug option not compatible with python_executable.")
if self.settings.os == "Windows":
if python.debug and self.settings.build_type != "Debug":
raise errors.ConanInvalidConfiguration(
"Can't build non-debug Lass with debug Python on Windows.")
cmake = CMake(self)
defs = {
"BUILD_TESTING":
self.develop and not self.in_local_cache,
"BUILD_SIMD_ALIGNED":
bool(self.options.simd_aligned),
"BUILD_WITHOUT_ITERATOR_DEBUGGING":
bool(self.options.without_iterator_debugging),
"Lass_PYTHON_VERSION":
python.version,
"Python_EXECUTABLE":
python.executable,
"Python_LIBRARY_RELEASE":
python.library,
"Python_LIBRARY_DEBUG":
python.library,
}
cmake.configure(source_folder=".", defs=defs)
return cmake
def configure(self):
if not str(self.settings.compiler.libcxx) == "libstdc++11":
self.output.warn("!!!compiler.libcxx is not set to libstdc++11!!!")
if self.settings.os == "Windows":
raise errors.ConanInvalidConfiguration(
"swf-raspi-tutorial is only supported for Linux")
def __init__(self, executable, settings):
self._executable = tools.which(str(executable))
self._os = settings.os
if not self._executable:
raise errors.ConanInvalidConfiguration(
"Python executable cannot be found: {!s}".format(
self._executable))
def build(self):
if self.settings.os == "Windows":
if self.settings.compiler == "Visual Studio" and self.settings.compiler.version == "15": # and (not self.settings.compiler.toolset or self.settings.compiler.toolset == "v141"):
pass
elif self.settings.compiler == "Visual Studio" and self.settings.compiler.version == "16" and self.settings.compiler.toolset == "v141":
pass
else:
raise errors.ConanInvalidConfiguration(
"Compiler is not supported.")
with tools.chdir(
os.path.join("Python-%s" % self.version, "PCBuild")):
if self.options.with_tkinter:
self.run("get_externals.bat --tkinter-src")
else:
self.run("get_externals.bat")
if self.options.with_tkinter:
with tools.chdir(
os.path.join("Python-%s" % self.version, "externals")):
for filename in glob.glob(os.path.join("**", "X.h"),
recursive=True):
tools.replace_in_file(
filename, '''#ifndef X_H''', '''
#ifdef _WIN32
#define None Windows_h_None
#define ControlMask Windows_h_ControlMask
#include <windows.h>
#undef None
#undef ControlMask
#endif
#ifndef X_H''')
env_build = VisualStudioBuildEnvironment(self)
with tools.environment_append(env_build.vars):
with tools.chdir(
os.path.join("Python-%s" % self.version, "PCBuild")):
with tools.vcvars(self.settings):
if self.options.with_tkinter:
self.run("prepare_tcltk.bat")
self.run("build.bat -p x64 -d")
self.run("build.bat -p x64")
else:
import stat
with tools.chdir("Python-%s" % self.version):
os.chmod(
"configure", stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
| stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP | stat.S_IROTH
| stat.S_IXOTH)
atools = AutoToolsBuildEnvironment(self)
args = [] # ["--enable-shared"] if self.options.shared else []
atools.configure(args=args)
atools.make()
atools.install()
def build(self):
cmake = CMake(self)
if self.settings.compiler == "gcc":
cmake = CMake(self, generator="Unix Makefiles")
conan_project_defines = [
str('-D__APP_VERSION__=\\\"') + str(self.version) + str('\\\"')
]
if float(str(self.settings.compiler.version)) >= 5:
conan_project_defines.append("-DUSE_CPP14_FEATURES")
cmake.definitions["CONAN_PROJECT_DEFINES"] = ";".join(
conan_project_defines)
# Changes required for cross compilation
if self.settings.os == "Linux" and self.settings.arch == "armv7":
for name in self.deps_cpp_info.deps:
print("#########################################" + name)
if "arm-linux-gnueabihf" in self.deps_cpp_info.deps:
# The toolchain version 8.3.0 has to be in /opt/cross-pi-gcc, since this version not location independent.
if self.settings.compiler.version == "8.3":
if not os.path.isdir(os.path.join("/opt", "cross-pi-gcc")):
os.mkdir(os.path.join("/opt", "cross-pi-gcc"))
old_cwd = os.getcwd()
os.chdir(os.path.join("/opt", "cross-pi-gcc"))
print(
"Installing tool chain to /opt/cross-pi-gcc/ directory..."
)
os.system(
"conan install arm-linux-gnueabihf/8.3.0@raspi/stable -pr swf_linux_to_arm_raspi -s compiler.version="
+ str(self.settings.compiler.version))
print("Installing tool chain done!")
os.chdir(old_cwd)
# Setting environment variables while will be used to get the tool chain.
os.environ[
"RASPBERRYPI_TOOLCHAIN_PATH"] = self.raspberrypi_toolchain_path = os.path.join(
"/opt", "cross-pi-gcc"
) if self.settings.compiler.version == "8.3" else str(
self.deps_cpp_info["arm-linux-gnueabihf"].rootpath)
os.environ[
"RASPBERRYPI_TARGET_HOST"] = self.raspberrypi_target_host = "arm-linux-gnueabihf"
else:
raise errors.ConanInvalidConfiguration(
"Raspberry Pi tool chain package not found in the dependencies list, which is required to proceed with the build!"
)
cmake.verbose = True
cmake.configure(source_folder=".")
cmake.build()
def get_gn_option_value(self, option_name, build_dir, cwd):
buf = StringIO()
self.run('gn args %s --list=%s --short' % (build_dir, option_name), output=buf, cwd=cwd)
output = buf.getvalue()
self.output.info("output - %s" %(output))
pattern = r'%s = (.*)' % (option_name)
for str in re.findall(pattern,output):
self.output.info("str - %s" %(str))
if str == 'true':
return True
elif str == 'false':
return False
raise errors.ConanInvalidConfiguration("Could not parse gn configuration options because option {} not found in {} due to match {}".format(option_name, output, match))
def configure(self):
if self.options.skia_use_metal:
if not self.settings.os == "iOS" and not self.settings.os == "Macos":
raise errors.ConanInvalidConfiguration("Metal is only supported on darwin platforms: %s" % self.settings.os)
if self.settings.os == "iOS":
self.options.skia_use_fonthost_mac = False
self.options.skia_use_system_expat = False
self.options.skia_use_system_expat = False
self.options.skia_use_system_harfbuzz = False
self.options.skia_use_system_icu = False
self.options.skia_use_system_libjpeg_turbo = False
self.options.skia_use_system_libpng = False
self.options.skia_use_system_libwebp = False
self.options.skia_use_system_zlib = False
def get_skia_option_value(self, option_name):
buf = StringIO()
self.run('bin/gn args out/conan-build --list=%s --short' % (option_name), output=buf, cwd='skia')
output = buf.getvalue()
pattern = r'%s = (.*)' % (option_name)
match = re.match(pattern, output)
if match:
if match.group(1) == 'true':
return True
elif match.group(1) == 'false':
return False
raise errors.ConanInvalidConfiguration("Could not parse gn comfiguration options")
def validate(self):
if self.settings.compiler.get_safe("cppstd"):
tools.check_min_cppstd(self, self._minimum_cpp_standard)
min_version = self._minimum_compilers_version.get(
str(self.settings.compiler))
if not min_version:
self.output.warn(
"{} recipe lacks information about the {} compiler support.".
format(self.name, self.settings.compiler))
else:
if tools.Version(self.settings.compiler.version) < min_version:
raise errors.ConanInvalidConfiguration(
"{} requires C++{} support. The current compiler {} {} does not support it."
.format(self.name, self._minimum_cpp_standard,
self.settings.compiler,
self.settings.compiler.version))
def build(self):
flags = []
for k,v in self.deps_cpp_info.dependencies:
self.output.info("Adding dependency: %s - %s" %(k, v.rootpath))
flags += ['\\"-I%s/include\\"' % (v.rootpath), '\\"-I%s/include/%s\\"' % (v.rootpath, k)]
flag_str = 'extra_cflags_cc=[%s]' % ",".join(flags)
opts = [flag_str]
for k,v in self.options.items():
if k in self.skia_options:
opts += [("%s=%s" % (k,v)).lower()]
if self.settings.build_type == "Debug":
opts += ["is_debug=true"]
else:
opts += ["is_debug=false"]
if self.settings.os == "iOS":
opts += ['target_os=\\"ios\\"']
if self.settings.arch == "armv8":
opts += ['target_cpu=\\"arm64\\"']
else:
opts += ['target_cpu=\\"x86_64\\"']
if len(opts) > 0:
opts = '"--args=%s"' % " ".join(opts)
else:
opts = ""
self.output.info("gn options: %s" % (opts))
self.run('bin/gn gen out/conan-build %s ' %(opts), cwd="skia")
failed = False
for k,v in self.options.items():
if k in self.skia_options:
actual = self.get_skia_option_value(k)
if not ("%s" % actual) == ("%s" % v):
failed = True
self.output.warn("Mismatch in %s: %s => %s" % ( k, v, actual ))
if failed:
raise errors.ConanInvalidConfiguration("Final gn configuration did not match requested config")
self.run('ninja -C out/conan-build', cwd="skia")
def configure(self):
if self.settings.compiler.get_safe("cppstd"):
tools.check_min_cppstd(self, "14")
minimum_version = {
"clang": "3.9",
"gcc": "6",
"Visual Studio": "15.0",
}.get(str(self.settings.compiler))
if not minimum_version:
self.output.warn(
"Unknown compiler {} {}. Assuming compiler supports C++14."
.format(self.settings.compiler, self.settings.compiler.version))
else:
version = tools.Version(self.settings.compiler.version)
if version < minimum_version:
raise errors.ConanInvalidConfiguration(
"The compiler {} {} does not support C++14."
.format(self.settings.compiler, self.settings.compiler.version))
def build(self):
flags = []
# TODO
#for k,v in self.deps_cpp_info.dependencies:
# self.output.info("Adding dependency: %s - %s" %(k, v.rootpath))
# flags += ['\\"-I%s/include\\"' % (v.rootpath), '\\"-I%s/include/%s\\"' % (v.rootpath, k)]
# FIX: buildtools/android-unwinding/libunwindstack/DwarfOp.cpp:1439:5: error: array designators are a C99 extension [-Werror,-Wc99-designator]
cflags = 'extra_cflags=\\"-Wno-c99-designator -Wno-error %s\\"' % (os.environ["CFLAGS"] if "CFLAGS" in os.environ else "")
cxxflags = 'extra_cxxflags=\\"%s\\"' % (os.environ["CXXFLAGS"] if "CXXFLAGS" in os.environ else "")
ldflags = 'extra_ldflags=\\"%s\\"' % (os.environ["LDFLAGS"] if "LDFLAGS" in os.environ else "")
opts = []
for k,v in self.options.items():
if k in self.perfetto_options:
opts += [("%s=%s" % (k,v)).lower()]
# TODO
#compiler_command = os.environ.get('CXX', None)
#cc = "gcc"
#cxx = "g++"
if self.settings.build_type == "Debug":
opts += ["is_debug=true"]
else:
opts += ["is_debug=false"]
self.output.info("self.settings.compiler: %s" % (self.settings.compiler))
if not self.options.use_bundled_compiler:
if self.settings.compiler == "apple-clang" or self.settings.compiler == "clang" or self.settings.compiler == "clang-cl":
opts += ["is_clang=true"]
else:
opts += ["is_clang=false"]
self.output.info("self.settings.os: %s" % (self.settings.os))
if self.settings.os == "Linux":
opts += ['target_os=\\"linux\\"']
if self.settings.arch == "x86_64":
opts += ['target_cpu=\\"x64\\"']
else:
opts += ['target_cpu=\\"x86\\"']
# NOTE: requires patch with PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN
if self.settings.os == "Windows":
opts += ['target_os=\\"windows\\"']
if self.settings.arch == "x86_64":
opts += ['target_cpu=\\"x64\\"']
else:
opts += ['target_cpu=\\"x86\\"']
if self.settings.os == "Macos":
opts += ['target_os=\\"mac\\"']
if self.settings.arch == "x86_64":
opts += ['target_cpu=\\"x64\\"']
else:
opts += ['target_cpu=\\"x86\\"']
# NOTE: requires patch with PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM
if self.settings.os == "Emscripten" or self.settings.arch == "wasm":
opts += ['target_os=\\"wasm\\"']
if self.settings.arch == "x86_64":
opts += ['target_cpu=\\"x64\\"']
else:
opts += ['target_cpu=\\"x86\\"']
if self.settings.os == "iOS":
opts += ['target_os=\\"ios\\"']
if self.settings.arch == "armv8":
opts += ['target_cpu=\\"arm64\\"']
else:
opts += ['target_cpu=\\"x64\\"']
if self.settings.os == "Android":
opts += ['target_os=\\"android\\"']
if self.settings.arch == "armv8":
opts += ['target_cpu=\\"arm64\\"']
else:
opts += ['target_cpu=\\"x64\\"']
opts = '"--args=%s %s %s %s"' % (cflags, cxxflags, ldflags, " ".join(opts))
self.output.info("gn options: %s" % (opts))
# Checks that conan options match gn options
self.run('gn gen out/conan-build %s ' %(opts), cwd=self._source_subfolder)
failed = False
failed_options = []
for k,v in self.options.items():
if k in self.perfetto_options:
actual = self.get_gn_option_value(option_name=k, build_dir="out/conan-build", cwd=self._source_subfolder)
if not ("%s" % actual) == ("%s" % v):
failed = True
failed_options.append("in %s: %s => %s" % ( k, v, actual ))
self.output.warn("Mismatch in %s: %s => %s" % ( k, v, actual ))
if failed:
raise errors.ConanInvalidConfiguration("Final gn configuration did not match requested config for options {}".format(str(failed_options)))
self.run('ninja -C out/conan-build', cwd=self._source_subfolder)
# ProtoZero is a zero-copy zero-alloc zero-syscall protobuf serialization libary purposefully built for Perfetto's tracing use cases.
self.run('ninja -C out/conan-build protozero_plugin protoc', cwd=self._source_subfolder)
def validate(self):
if self.settings.compiler.value in {"gcc", "clang"}:
if self.settings.compiler.libcxx in {"libstdc++"}:
raise errors.ConanInvalidConfiguration(
"gcc and clang require C++11 compatible libcxx")
