| #!/usr/bin/env python |
| # |
| # Copyright (C) 2005-2019 Intel Corporation |
| # |
| # SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause |
| # |
| |
| from __future__ import print_function |
| import os |
| import sys |
| import shutil |
| import fnmatch |
| import subprocess |
| |
| |
| def run_shell(cmd): |
| print("\n>>", cmd) |
| code = os.system(cmd) |
| if code != 0: |
| sys.exit(">> failed to run shell command: %s" % 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': |
| path, err = subprocess.Popen( |
| "which cmake", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() |
| if not path.strip(): |
| path, err = subprocess.Popen( |
| "which xcrun", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() |
| if not path.strip(): |
| print("No cmake and no XCode found...") |
| return None |
| return 'xcrun cmake' |
| 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( |
| "--force_bits", choices=["32", "64"], help="specify bit version for the target") |
| if sys.platform == 'win32' and 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() |
| |
| if args.force_bits: |
| target_bits = [args.force_bits] |
| else: |
| target_bits = ['64'] |
| if (sys.platform != 'darwin'): # on MAC OSX we produce FAT library including both 32 and 64 bits |
| target_bits.append('32') |
| |
| print("target_bits", target_bits) |
| 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) |
| for bits in target_bits: |
| work_folder = os.path.join( |
| work_dir, "build_" + (sys.platform.replace('32', "")), bits) |
| already_there = os.path.exists(work_folder) |
| if already_there and args.clean: |
| shutil.rmtree(work_folder) |
| already_there = False |
| if not already_there: |
| os.makedirs(work_folder) |
| print("work_folder: ", work_folder) |
| os.chdir(work_folder) |
| if args.clean: |
| continue |
| |
| cmake = detect_cmake() |
| if not cmake: |
| print("Error: cmake is not found") |
| return |
| |
| if sys.platform == 'win32': |
| # ninja does not support platform bit specification |
| use_ninja = args.cmake_gen == 'ninja' and bits =='64' |
| if vs_versions and not use_ninja: |
| generator = 'Visual Studio {}'.format(args.vs) |
| generator_args = '-A {}'.format('x64' if bits == |
| '64' else 'Win32') |
| else: |
| generator = 'Ninja' |
| generator_args = '' |
| else: |
| generator = 'Unix Makefiles' |
| generator_args = '' |
| |
| run_shell('%s "%s" -G"%s" %s %s' % (cmake, work_dir, generator, generator_args, " ".join([ |
| ("-DFORCE_32=ON" if bits == '32' else ""), |
| ("-DCMAKE_BUILD_TYPE=Debug" if args.debug else ""), |
| ('-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON' if args.verbose else ''), |
| ("-DITT_API_IPT_SUPPORT=1" if args.ptmark else ""), |
| ("-DITT_API_FORTRAN_SUPPORT=1" if args.fortran else "") |
| ]))) |
| |
| if sys.platform == 'win32': |
| target_project = 'ALL_BUILD' if not use_ninja else 'all' |
| run_shell('%s --build . --config %s --target %s' % |
| (cmake, ('Debug' if args.debug else 'Release'), target_project)) |
| else: |
| import glob |
| run_shell('%s --build . --config %s' % |
| (cmake, ('Debug' if args.debug else 'Release'))) |
| |
| |
| if __name__ == "__main__": |
| main() |
