buildall.py

#!/usr/bin/env python
#
# Copyright (C) 2005-2026 Intel Corporation
#
# SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
#

import os
import sys
import shutil
import subprocess


def run_shell(cmd):
    print(f"\n>> {cmd}")
    try:
        subprocess.run(cmd, shell=True, check=True)
    except subprocess.CalledProcessError:
        sys.exit(f">> failed to run shell command: {cmd}")


if sys.platform == 'win32':
    def read_registry(path, depth=0xFFFFFFFF, statics={}):
        try:
            import _winreg
        except ImportError:
            import winreg as _winreg
        parts = path.split('\\')
        hub = parts[0]
        path = '\\'.join(parts[1:])
        if not statics:
            statics['hubs'] = {
                'HKLM': _winreg.HKEY_LOCAL_MACHINE, 'HKCL': _winreg.HKEY_CLASSES_ROOT}

        def enum_nodes(curpath, level):
            if level < 1:
                return {}
            res = {}
            try:
                aKey = _winreg.OpenKey(
                    statics['hubs'][hub], curpath, 0, _winreg.KEY_READ | _winreg.KEY_WOW64_64KEY)
            except WindowsError:
                return res

            try:
                i = 0
                while True:
                    name, value, _ = _winreg.EnumValue(aKey, i)
                    i += 1
                    res[name] = value
            except WindowsError:
                pass

            keys = []
            try:
                i = 0
                while True:
                    key = _winreg.EnumKey(aKey, i)
                    i += 1
                    keys.append(key)
            except WindowsError:
                pass

            _winreg.CloseKey(aKey)

            for key in keys:
                res[key] = enum_nodes(curpath + '\\' + key, level - 1)

            return res

        return enum_nodes(path, depth)


def get_vs_versions():  # https://www.mztools.com/articles/2008/MZ2008003.aspx
    if sys.platform != 'win32':
        return []
    versions = []

    hkcl = read_registry(r'HKCL', 1)
    for key in hkcl:
        if 'VisualStudio.DTE.' in key:
            version = key.split('.')[2]
            if int(version) >= 12:
                versions.append(version)

    if not versions:
        print("No Visual Studio version found")
    return sorted(versions)


def detect_cmake():
    if sys.platform == 'darwin':
        cmake_path = shutil.which('cmake')
        if cmake_path:
            return 'cmake'
        xcrun_path = shutil.which('xcrun')
        if xcrun_path:
            return 'xcrun cmake'
        print("No cmake and no XCode found...")
        return None
    return 'cmake'


def main():
    import argparse
    parser = argparse.ArgumentParser()
    vs_versions = get_vs_versions()
    parser.add_argument(
        "-d", "--debug", help="specify debug build configuration (release by default)", action="store_true")
    parser.add_argument(
        "-c", "--clean", help="delete any intermediate and output files", action="store_true")
    parser.add_argument(
        "-v", "--verbose", help="enable verbose output from build process", action="store_true")
    parser.add_argument(
        "-pt", "--ptmark", help="enable anomaly detection support", action="store_true")
    parser.add_argument(
        "-ft", "--fortran", help="enable fortran support", action="store_true")
    parser.add_argument(
        "-cpp", "--cpp", help="enable C++ wrapper support", action="store_true")
    parser.add_argument(
        "--refcol", help="enable reference collector build", action="store_true")
    if sys.platform == 'win32':
        if vs_versions:
            parser.add_argument(
                "--vs", help="specify visual studio version {default}", choices=vs_versions, default=vs_versions[0])
        parser.add_argument(
            "--cmake_gen", choices=["vs", "ninja"], help="specify cmake build generator")
    args = parser.parse_args()

    work_dir = os.getcwd()
    if args.clean:
        bin_dir = os.path.join(work_dir, 'bin')
        if os.path.exists(bin_dir):
            shutil.rmtree(bin_dir)
        work_folder = os.path.join(
            work_dir, "build_" + sys.platform.replace('32', ""))
        if os.path.exists(work_folder):
            shutil.rmtree(work_folder)
        return

    # Build folder: build_linux, build_win, build_darwin
    work_folder = os.path.join(
        work_dir, "build_" + sys.platform.replace('32', ""))
    if not os.path.exists(work_folder):
        os.makedirs(work_folder)
    print("work_folder: ", work_folder)
    os.chdir(work_folder)

    cmake = detect_cmake()
    if not cmake:
        print("Error: cmake is not found")
        return

    if sys.platform == 'win32':
        vs_year = {
            '12': '2013', '14': '2015', '15': '2017',
            '16': '2019', '17': '2022', '18': '2025',
        }
        use_ninja = getattr(args, 'cmake_gen', None) == 'ninja'
        if vs_versions and not use_ninja:
            year = vs_year.get(args.vs, '')
            generator = f'Visual Studio {args.vs} {year}'.strip()
            generator_args = '-A x64'
        else:
            generator = 'Ninja'
            generator_args = ''
    else:
        generator = 'Unix Makefiles'
        generator_args = ''

    cmake_options = [f'-G"{generator}"', generator_args]
    if args.debug:
        cmake_options.append('-DCMAKE_BUILD_TYPE=Debug')
    if args.verbose:
        cmake_options.append('-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON')
    if args.ptmark:
        cmake_options.append('-DITT_API_IPT_SUPPORT=1')
    if args.fortran:
        cmake_options.append('-DITT_API_FORTRAN_SUPPORT=1')
    if args.cpp:
        cmake_options.append('-DITT_API_CPP_SUPPORT=ON')
    if args.refcol:
        cmake_options.append('-DITT_API_REFERENCE_COLLECTOR=ON')

    run_shell(f'{cmake} "{work_dir}" {" ".join(opt for opt in cmake_options if opt)}')

    if sys.platform == 'win32':
        target = 'ALL_BUILD' if not use_ninja else 'all'
        config = 'Debug' if args.debug else 'Release'
        run_shell(f'{cmake} --build . --config {config} --target {target}')
    else:
        config = 'Debug' if args.debug else 'Release'
        run_shell(f'{cmake} --build . --config {config}')


if __name__ == "__main__":
    main()