def gen_project(fips_dir, proj_dir, cfg, force) : """private: generate build files for one config""" proj_name = util.get_project_name_from_dir(proj_dir) build_dir = util.get_build_dir(fips_dir, proj_name, cfg) defines = {} defines['FIPS_USE_CCACHE'] = 'ON' if settings.get(proj_dir, 'ccache') else 'OFF' defines['FIPS_AUTO_IMPORT'] = 'OFF' if dep.get_policy(proj_dir, 'no_auto_import') else 'ON' if cfg['platform'] == 'ios': ios_team_id = settings.get(proj_dir, 'iosteam') if ios_team_id: defines['FIPS_IOS_TEAMID'] = ios_team_id do_it = force if not os.path.isdir(build_dir) : os.makedirs(build_dir) do_it = True if do_it : # if Ninja build tool and on Windows, need to copy # the precompiled ninja.exe to the build dir log.colored(log.YELLOW, "=== generating: {}".format(cfg['name'])) log.info("config file: {}".format(cfg['path'])) toolchain_path = config.get_toolchain(fips_dir, proj_dir, cfg) if toolchain_path : log.info("Using Toolchain File: {}".format(toolchain_path)) if cfg['build_tool'] == 'ninja' : ninja.prepare_ninja_tool(fips_dir, build_dir) cmake_result = cmake.run_gen(cfg, fips_dir, proj_dir, build_dir, toolchain_path, defines) if cfg['build_tool'] == 'vscode_cmake': vscode.write_workspace_settings(fips_dir, proj_dir, cfg) return cmake_result else : return True
def gen_project(fips_dir, proj_dir, cfg, force): """private: generate build files for one config""" proj_name = util.get_project_name_from_dir(proj_dir) deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name']) build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name']) defines = {} defines['FIPS_USE_CCACHE'] = 'ON' if settings.get(proj_dir, 'ccache') else 'OFF' defines['FIPS_AUTO_IMPORT'] = 'OFF' if dep.get_policy( proj_dir, 'no_auto_import') else 'ON' if cfg['generator'] in ['Ninja', 'Unix Makefiles']: defines['CMAKE_EXPORT_COMPILE_COMMANDS'] = 'ON' if cfg['platform'] == 'ios': defines['CMAKE_OSX_SYSROOT'] = xcrun.get_ios_sdk_sysroot() ios_team_id = settings.get(proj_dir, 'iosteam') if ios_team_id: defines['FIPS_IOS_TEAMID'] = ios_team_id if cfg['platform'] == 'osx': defines['CMAKE_OSX_SYSROOT'] = xcrun.get_macos_sdk_sysroot() if cfg['platform'] == 'emscripten': defines['EMSCRIPTEN_ROOT'] = emsdk.get_emscripten_root(fips_dir) if cfg['platform'] == 'wasisdk': defines['WASISDK_ROOT'] = wasisdk.get_wasisdk_root(fips_dir) do_it = force if not os.path.isdir(build_dir): os.makedirs(build_dir) if not os.path.isfile(build_dir + '/CMakeCache.txt'): do_it = True if do_it: # if Ninja build tool and on Windows, need to copy # the precompiled ninja.exe to the build dir log.colored(log.YELLOW, "=== generating: {}".format(cfg['name'])) log.info("config file: {}".format(cfg['path'])) toolchain_path = config.get_toolchain(fips_dir, proj_dir, cfg) if toolchain_path: log.info("Using Toolchain File: {}".format(toolchain_path)) is_local_build = settings.get(proj_dir, 'local') cmake_result = cmake.run_gen(cfg, fips_dir, proj_dir, build_dir, is_local_build, toolchain_path, defines) if vscode.match(cfg['build_tool']): vscode.write_workspace_settings( fips_dir, proj_dir, cfg, settings.get_all_settings(proj_dir)) if clion.match(cfg['build_tool']): clion.write_workspace_settings(fips_dir, proj_dir, cfg) return cmake_result else: return True
def list_targets(fips_dir, proj_dir, args): log.colored(log.YELLOW, "=== targets:") if util.is_valid_project_dir(proj_dir): # get config name if len(args) == 0: cfg_name = settings.get(proj_dir, 'config') else: cfg_name = args[0] log.info('{} config:{} {}'.format(log.BLUE, log.DEF, cfg_name)) # get the target list success, targets = project.get_target_list(fips_dir, proj_dir, cfg_name) if success: # split targets by type for type in ['lib', 'module', 'sharedlib', 'app']: type_targets = [tgt for tgt in targets if targets[tgt] == type] if len(type_targets) > 0: log.colored(log.BLUE, ' {}:'.format(type)) for tgt in type_targets: log.info(' ' + tgt) else: log.info( " can't fetch project target list, please run 'fips gen' first!" ) else: log.info(' currently not in a valid project directory')
def gen_project(fips_dir, proj_dir, cfg, force): """private: generate build files for one config""" proj_name = util.get_project_name_from_dir(proj_dir) build_dir = util.get_build_dir(fips_dir, proj_name, cfg) defines = {} defines['FIPS_USE_CCACHE'] = 'ON' if settings.get(proj_dir, 'ccache') else 'OFF' do_it = force if not os.path.isdir(build_dir): os.makedirs(build_dir) do_it = True if do_it: # if Ninja build tool and on Windows, need to copy # the precompiled ninja.exe to the build dir if cfg['build_tool'] == 'ninja': ninja.prepare_ninja_tool(fips_dir, build_dir) log.colored(log.YELLOW, "=== generating: {}".format(cfg['name'])) toolchain_path = config.get_toolchain(fips_dir, proj_dir, cfg) if toolchain_path: log.info("Using Toolchain File: {}".format(toolchain_path)) return cmake.run_gen(cfg, fips_dir, proj_dir, build_dir, toolchain_path, defines) else: return True
def run(fips_dir, proj_dir, args): """run the 'physx' verb""" if len(args) > 0: noun = args[0] if noun == 'build': # FIXME all of this only works on windows at the moment and is super hacky if len(args) != 2: log.error("expected compiler target (win-vs15, win-vs16)") preset = util.fix_path(os.path.dirname(os.path.abspath( __file__))) + "/physx-presets/" + "fips" + args[1] + ".xml" if not os.path.isfile(preset): log.error("unrecognized compiler target") shutil.copy2(preset, proj_dir + "/../physx/physx/buildtools/presets/") subprocess.call(proj_dir + "/../physx/physx/generate_projects.bat fips" + args[1]) # figure out a version number for vswhere version = args[1][6:] version_next = str(int(version) + 1) version = version + ".0," + version_next + ".0" #use vswhere to figure out where vs is devenvPath = subprocess.check_output( proj_dir + "/../physx/externals/vswhere/vswhere -version [" + version + "] -property productPath").decode("utf-8").rstrip() devenvPath = util.fix_path(devenvPath) if not os.path.isfile(devenvPath): log.error("could not detect visual studio installation") log.info("Using Visual Studio from" + devenvPath) log.info("Compiling PhysX, this might take a while") log.info("Building debug version") subprocess.call(devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/PhysXSDK.sln /Build debug /Project INSTALL") log.info("Building release version") subprocess.call(devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/PhysXSDK.sln /Build release /Project INSTALL") if noun == 'deploy': ps_deploy = util.get_workspace_dir( fips_dir) + "/fips-deploy/physx/bin/" cur_cfg = settings.get(proj_dir, "config") cfg = config.load(fips_dir, proj_dir, cur_cfg)[0] px_target = cfg['defines']['PX_TARGET'] target_dir = util.get_deploy_dir( fips_dir, util.get_project_name_from_dir(proj_dir), cur_cfg) for dll in glob.glob(ps_deploy + px_target + "/debug/*.dll"): shutil.copy2(dll, target_dir) for dll in glob.glob(ps_deploy + px_target + "/release/*.dll"): shutil.copy2(dll, target_dir) else: def run(fips_dir, proj_dir, args): log.error("Not supported")
def build(fips_dir, proj_dir, cfg_name, target=None, build_tool_args=None): """perform a build of config(s) in project :param fips_dir: absolute path of fips :param proj_dir: absolute path of project dir :param cfg_name: config name or pattern :param target: optional target name (build all if None) :param build_tool_args: optional string array of cmdline args forwarded to the build tool :returns: True if build was successful """ # prepare dep.fetch_imports(fips_dir, proj_dir) proj_name = util.get_project_name_from_dir(proj_dir) util.ensure_valid_project_dir(proj_dir) dep.gather_and_write_imports(fips_dir, proj_dir, cfg_name) # load the config(s) configs = config.load(fips_dir, proj_dir, cfg_name) num_valid_configs = 0 if configs: for cfg in configs: # check if config is valid config_valid, _ = config.check_config_valid(fips_dir, proj_dir, cfg, print_errors=True) if config_valid: log.colored(log.YELLOW, "=== building: {}".format(cfg['name'])) if not gen_project(fips_dir, proj_dir, cfg, False): log.error("Failed to generate '{}' of project '{}'".format( cfg['name'], proj_name)) # select and run build tool build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name']) num_jobs = settings.get(proj_dir, 'jobs') result = cmake.run_build(fips_dir, target, cfg['build_type'], build_dir, num_jobs, build_tool_args) if result: num_valid_configs += 1 else: log.error( "Failed to build config '{}' of project '{}'".format( cfg['name'], proj_name)) else: log.error("Config '{}' not valid in this environment".format( cfg['name'])) else: log.error("No valid configs found for '{}'".format(cfg_name)) if num_valid_configs != len(configs): log.error('{} out of {} configs failed!'.format( len(configs) - num_valid_configs, len(configs))) return False else: log.colored(log.GREEN, '{} configs built'.format(num_valid_configs)) return True
def get_deploy_root_dir(fips_dir, proj_name): """get absolute path to the build root directory""" from mod import settings proj_dir = get_project_dir(fips_dir, proj_name) if settings.get(proj_dir, 'local'): return '{}/fips-files/deploy'.format(proj_dir) else: return '{}/fips-deploy'.format(get_workspace_dir(fips_dir))
def run(fips_dir, proj_dir, args): """build a single target""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') tgt_name = None cfg_name = None if len(args) > 0: tgt_name = args[0] if len(args) > 1: cfg_name = args[1] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') if not tgt_name: tgt_name = settings.get(proj_dir, 'target') if tgt_name == 'clean': project.make_clean(fips_dir, proj_dir, cfg_name) else: project.build(fips_dir, proj_dir, cfg_name, tgt_name)
def run(fips_dir, proj_dir, args): """build a single target""" if not util.is_valid_project_dir(proj_dir): log.error("must be run in a project directory") tgt_name = None cfg_name = None if len(args) > 0: tgt_name = args[0] if len(args) > 1: cfg_name = args[1] if not cfg_name: cfg_name = settings.get(proj_dir, "config") if not tgt_name: tgt_name = settings.get(proj_dir, "target") if tgt_name == "clean": project.make_clean(fips_dir, proj_dir, cfg_name) else: project.build(fips_dir, proj_dir, cfg_name, tgt_name)
def run(fips_dir, proj_dir, args): if util.is_valid_project_dir(proj_dir): cfg_name = settings.get(proj_dir, 'config') cfg = config.load(fips_dir, proj_dir, cfg_name)[0] res = cmake.get_codemodel(fips_dir, proj_dir, cfg) if res is not None: print(json.dumps(res, indent=2, separators=(',', ':'))) else: log.error("must be run from a project directory")
def build(fips_dir, proj_dir, cfg_name, target=None) : """perform a build of config(s) in project :param fips_dir: absolute path of fips :param proj_dir: absolute path of project dir :param cfg_name: config name or pattern :param target: optional target name (build all if None) :returns: True if build was successful """ # prepare dep.fetch_imports(fips_dir, proj_dir) proj_name = util.get_project_name_from_dir(proj_dir) util.ensure_valid_project_dir(proj_dir) dep.gather_and_write_imports(fips_dir, proj_dir) # load the config(s) configs = config.load(fips_dir, proj_dir, cfg_name) num_valid_configs = 0 if configs : for cfg in configs : # check if config is valid config_valid, _ = config.check_config_valid(fips_dir, cfg, print_errors=True) if config_valid : log.colored(log.YELLOW, "=== building: {}".format(cfg['name'])) if not gen_project(fips_dir, proj_dir, cfg, False) : log.error("Failed to generate '{}' of project '{}'".format(cfg['name'], proj_name)) # select and run build tool build_dir = util.get_build_dir(fips_dir, proj_name, cfg) num_jobs = settings.get(proj_dir, 'jobs') result = False if cfg['build_tool'] == make.name : result = make.run_build(fips_dir, target, build_dir, num_jobs) elif cfg['build_tool'] == ninja.name : result = ninja.run_build(fips_dir, target, build_dir, num_jobs) elif cfg['build_tool'] == xcodebuild.name : result = xcodebuild.run_build(fips_dir, target, cfg['build_type'], build_dir, num_jobs) else : result = cmake.run_build(fips_dir, target, cfg['build_type'], build_dir) if result : num_valid_configs += 1 else : log.error("Failed to build config '{}' of project '{}'".format(cfg['name'], proj_name)) else : log.error("Config '{}' not valid in this environment".format(cfg['name'])) else : log.error("No valid configs found for '{}'".format(cfg_name)) if num_valid_configs != len(configs) : log.error('{} out of {} configs failed!'.format(len(configs) - num_valid_configs, len(configs))) return False else : log.colored(log.GREEN, '{} configs built'.format(num_valid_configs)) return True
def run(fips_dir, proj_dir, args): """run the 'open' verb (opens project in IDE)""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') proj_name = util.get_project_name_from_dir(proj_dir) cfg_name = None if len(args) > 0: cfg_name = args[0] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') # check the cmake generator of this config configs = config.load(fips_dir, proj_dir, cfg_name) if configs: # hmm, only look at first match, 'open' doesn't # make sense with config-patterns cfg = configs[0] # find build dir, if it doesn't exist, generate it build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name']) if not os.path.isdir(build_dir): log.warn("build dir not found, generating...") project.gen(fips_dir, proj_dir, cfg['name']) # first check if this is a VSCode project if cfg['build_tool'] == 'vscode_cmake': vscode.run(proj_dir) return # check if this is a CLion project if cfg['build_tool'] == 'clion': clion.run(proj_dir) return # try to open as Xcode project proj = glob.glob(build_dir + '/*.xcodeproj') if proj: subprocess.call('open "{}"'.format(proj[0]), shell=True) return # try to open as VS project proj = glob.glob(build_dir + '/*.sln') if proj: subprocess.call('cmd /c start {}'.format(proj[0]), shell=True) return # try to open as eclipse project proj = glob.glob(build_dir + '/.cproject') if proj: subprocess.call( 'eclipse -nosplash --launcher.timeout 60 -application org.eclipse.cdt.managedbuilder.core.headlessbuild -import "{}"' .format(build_dir), shell=True) subprocess.call('eclipse', shell=True) return log.error("don't know how to open a '{}' project in {}".format( cfg['generator'], build_dir)) else: log.error("config '{}' not found".format(cfg_name))
def run(fips_dir, proj_dir, args): """run fips project build targets""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') cfg_name = settings.get(proj_dir, 'config') target_name = settings.get(proj_dir, 'target') target_args = [] if '--' in args: idx = args.index('--') target_args = args[(idx + 1):] args = args[:idx] if len(args) > 0: target_name = args[0] if len(args) > 1: cfg_name = args[1] if target_name: project.run(fips_dir, proj_dir, cfg_name, target_name, target_args) else: log.error('no target provided')
def run(fips_dir, proj_dir, args) : """build fips project""" if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') cfg_name = None if len(args) > 0 : cfg_name = args[0] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') project.build(fips_dir, proj_dir, cfg_name)
def run(fips_dir, proj_dir, args): """configure fips project""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') cfg_name = None if len(args) > 0: cfg_name = args[0] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') project.configure(fips_dir, proj_dir, cfg_name)
def run(fips_dir, proj_dir, args) : """clean generated files""" if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') cfg_name = None if len(args) > 0 : cfg_name = args[0] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') if cfg_name == 'all' : cfg_name = '*' project.clean(fips_dir, proj_dir, cfg_name)
def run(fips_dir, proj_dir, args): """clean generated files""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') cfg_name = None if len(args) > 0: cfg_name = args[0] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') if cfg_name == 'all': cfg_name = '*' project.clean(fips_dir, proj_dir, cfg_name)
def list_settings(proj_dir) : """list settings file content""" log.colored(log.YELLOW, '=== settings:') if util.is_valid_project_dir(proj_dir) : for key in ['config', 'target', 'jobs', 'ccache'] : value = settings.get(proj_dir, key) if type(value) is bool : value = 'on' if value else 'off' default = ' (default value)' if value == settings.get_default(key) else '' log.info(' {}{}:{} {}{}'.format(log.BLUE, key, log.DEF, value, default)) else : log.info(' currently not in a valid project directory')
def run(fips_dir, proj_dir, args): """run fips project build targets""" if not util.is_valid_project_dir(proj_dir): log.error("must be run in a project directory") cfg_name = settings.get(proj_dir, "config") target_name = settings.get(proj_dir, "target") target_args = [] if "--" in args: idx = args.index("--") target_args = args[(idx + 1) :] args = args[:idx] if len(args) > 0: target_name = args[0] if len(args) > 1: cfg_name = args[1] if target_name: target_cwd = util.lookup_target_cwd(proj_dir, target_name) retcode = project.run(fips_dir, proj_dir, cfg_name, target_name, target_args, target_cwd) sys.exit(retcode) else: log.error("no target provided")
def run(fips_dir, proj_dir, args) : """run the 'open' verb (opens project in IDE)""" if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') proj_name = util.get_project_name_from_dir(proj_dir) cfg_name = None if len(args) > 0 : cfg_name = args[0] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') # check the cmake generator of this config configs = config.load(fips_dir, proj_dir, cfg_name) if configs : # hmm, only look at first match, 'open' doesn't # make sense with config-patterns cfg = configs[0] # find build dir, if it doesn't exist, generate it build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name']) if not os.path.isdir(build_dir) : log.warn("build dir not found, generating...") project.gen(fips_dir, proj_dir, cfg['name']) # first check if this is a VSCode project if cfg['build_tool'] == 'vscode_cmake': vscode.run(proj_dir) return # check if this is a CLion project if cfg['build_tool'] == 'clion': clion.run(proj_dir) return # try to open as Xcode project proj = glob.glob(build_dir + '/*.xcodeproj') if proj : subprocess.call('open "{}"'.format(proj[0]), shell=True) return # try to open as VS project proj = glob.glob(build_dir + '/*.sln') if proj : subprocess.call('cmd /c start {}'.format(proj[0]), shell=True) return # try to open as eclipse project proj = glob.glob(build_dir + '/.cproject') if proj : subprocess.call('eclipse -nosplash --launcher.timeout 60 -application org.eclipse.cdt.managedbuilder.core.headlessbuild -import "{}"'.format(build_dir), shell=True) subprocess.call('eclipse', shell=True) return log.error("don't know how to open a '{}' project in {}".format(cfg['generator'], build_dir)) else : log.error("config '{}' not found".format(cfg_name))
def run(fips_dir, proj_dir, args) : """debug a single target with valgrind""" if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') tgt_name = None cfg_name = None tgt_args = [] if '--' in args : idx = args.index('--') tgt_args = args[(idx + 1):] args = args[:idx] if len(args) > 0 : tgt_name = args[0] if len(args) > 1 : cfg_name = args[1] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') if not tgt_name : tgt_name = settings.get(proj_dir, 'target') if not tgt_name : log.error('no target specified') valgrind(fips_dir, proj_dir, cfg_name, tgt_name, tgt_args)
def run(fips_dir, proj_dir, args): """build fips project""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') cfg_name = None build_tool_args = None if '--' in args: idx = args.index('--') build_tool_args = args[(idx + 1):] args = args[:idx] if len(args) > 0: cfg_name = args[0] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') if cfg_name == 'clean': if len(args) > 1: cfg_name = args[1] else: cfg_name = settings.get(proj_dir, 'config') project.make_clean(fips_dir, proj_dir, cfg_name) else: project.build(fips_dir, proj_dir, cfg_name, None, build_tool_args)
def run(fips_dir, proj_dir, args): """debug a single target with valgrind""" if not util.is_valid_project_dir(proj_dir): log.error("must be run in a project directory") tgt_name = None cfg_name = None tgt_args = [] if "--" in args: idx = args.index("--") tgt_args = args[(idx + 1) :] args = args[:idx] if len(args) > 0: tgt_name = args[0] if len(args) > 1: cfg_name = args[1] if not cfg_name: cfg_name = settings.get(proj_dir, "config") if not tgt_name: tgt_name = settings.get(proj_dir, "target") if not tgt_name: log.error("no target specified") valgrind(fips_dir, proj_dir, cfg_name, tgt_name, tgt_args)
def list_settings(proj_dir): """list settings file content""" log.colored(log.YELLOW, '=== settings:') if util.is_valid_project_dir(proj_dir): for key in ['config', 'target', 'jobs', 'ccache', 'iosteam']: value = settings.get(proj_dir, key) if type(value) is bool: value = 'on' if value else 'off' default = ' (default value)' if value == settings.get_default( key) else '' log.info(' {}{}:{} {}{}'.format(log.BLUE, key, log.DEF, value, default)) else: log.info(' currently not in a valid project directory')
def valgrind(fips_dir, proj_dir, cfg_name, target, target_args): """debug a single target with valgrind""" # prepare proj_name = util.get_project_name_from_dir(proj_dir) util.ensure_valid_project_dir(proj_dir) # load the config(s) configs = config.load(fips_dir, proj_dir, cfg_name) if configs: for cfg in configs: # check if config is valid config_valid, _ = config.check_config_valid(fips_dir, proj_dir, cfg, print_errors=True) if config_valid: deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name']) valgrind_bin = settings.get(proj_dir, 'valgrind') if not valgrind_bin: valgrind_bin = 'valgrind' log.colored( log.YELLOW, "=== valgrind: {} ({})".format(cfg['name'], valgrind_bin)) cmd_line = valgrind_bin if target_args: cmd_line += ' ' + ' '.join(target_args) else: cmd_line += ' ' + '--leak-check=no' cmd_line += ' ' + '--show-reachable=yes' cmd_line += ' ' + '--track-fds=yes' cmd_line += ' ' + '--run-libc-freeres=no' cmd_line += ' ' + "--log-file={}/valgrind-{}.log".format( proj_dir, target) cmd_line += ' ' + "./{}".format(target) #log.colored(log.GREEN, "cmdline: {}".format(cmd_line)) subprocess.call(args=cmd_line, cwd=deploy_dir, shell=True) else: log.error("Config '{}' not valid in this environment".format( cfg['name'])) else: log.error("No valid configs found for '{}'".format(cfg_name)) return True
def gen_project(fips_dir, proj_dir, cfg, force) : """private: generate build files for one config""" proj_name = util.get_project_name_from_dir(proj_dir) build_dir = util.get_build_dir(fips_dir, proj_name, cfg) defines = {} defines['FIPS_USE_CCACHE'] = 'ON' if settings.get(proj_dir, 'ccache') else 'OFF' do_it = force if not os.path.isdir(build_dir) : os.makedirs(build_dir) do_it = True if do_it : # if Ninja build tool and on Windows, need to copy # the precompiled ninja.exe to the build dir if cfg['build_tool'] == 'ninja' : ninja.prepare_ninja_tool(fips_dir, build_dir) log.colored(log.YELLOW, "=== generating: {}".format(cfg['name'])) toolchain_path = config.get_toolchain_for_platform(fips_dir, cfg['platform']) return cmake.run_gen(cfg, proj_dir, build_dir, toolchain_path, defines) else : return True
def run(fips_dir, proj_dir, args): """run the 'nebula' verb""" if len(args) > 0: noun = args[0] if noun == 'set': if len(args) > 2: setKey(args[1], args[2]) else: log.error("Expected setting and value") elif noun == 'get': if len(args) > 1: key = argToKey(args[1]) if key != "": reg_key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, base_reg, 0, _winreg.KEY_READ) keyval, regtype = _winreg.QueryValueEx(reg_key, key) _winreg.CloseKey(reg_key) log.info(keyval) else: log.error("Invalid setting") else: log.error("Expected setting name") elif noun == 'cleannidl': proj = util.get_project_name_from_dir(proj_dir) cfg = settings.get(proj_dir, 'config') path = util.get_build_dir(fips_dir, proj, cfg) + "/nidl" shutil.rmtree(path, True) else: try: reg_key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, base_reg, 0, _winreg.KEY_READ) workval, regtype = _winreg.QueryValueEx(reg_key, "workdir") rootval, regtype = _winreg.QueryValueEx(reg_key, "path") _winreg.CloseKey(reg_key) log.colored(log.YELLOW, "Current settings") log.optional("Project directory", workval) log.optional("Nebula root director", rootval) except WindowsError: log.colored(log.YELLOW, "No Nebula settings in registry\n")
def run(fips_dir, proj_dir, args) : """run the 'open' verb (opens project in IDE)""" if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') proj_name = util.get_project_name_from_dir(proj_dir) cfg_name = None if len(args) > 0 : cfg_name = args[0] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') # check the cmake generator of this config configs = config.load(fips_dir, proj_dir, cfg_name) if configs : # hmm, only look at first match, 'open' doesn't # make sense with config-patterns cfg = configs[0] # find build dir, if it doesn't exist, generate it build_dir = util.get_build_dir(fips_dir, proj_name, cfg) if not os.path.isdir(build_dir) : log.warn("build dir not found, generating...") project.gen(fips_dir, proj_dir, cfg['name']) # try to open as Xcode project proj = glob.glob(build_dir + '/*.xcodeproj') if proj : subprocess.call('open {}'.format(proj[0]), shell=True) else : # try to open as VS project proj = glob.glob(build_dir + '/*.sln') if proj : subprocess.call('cmd /c start {}'.format(proj[0]), shell=True) else : log.error("don't know how to open a '{}' project".format(cfg['generator'])) else : log.error("config '{}' not found".format(cfg_name))
def run(fips_dir, proj_dir, args): """run the 'open' verb (opens project in IDE)""" if not util.is_valid_project_dir(proj_dir): log.error('must be run in a project directory') proj_name = util.get_project_name_from_dir(proj_dir) cfg_name = None if len(args) > 0: cfg_name = args[0] if not cfg_name: cfg_name = settings.get(proj_dir, 'config') # check the cmake generator of this config configs = config.load(fips_dir, proj_dir, cfg_name) if configs: # hmm, only look at first match, 'open' doesn't # make sense with config-patterns cfg = configs[0] # find build dir, if it doesn't exist, generate it build_dir = util.get_build_dir(fips_dir, proj_name, cfg) if not os.path.isdir(build_dir): log.warn("build dir not found, generating...") project.gen(fips_dir, proj_dir, cfg['name']) if 'Xcode' in cfg['generator']: # find the Xcode project proj = glob.glob(build_dir + '/*.xcodeproj') subprocess.call(['open', proj[0]]) elif 'Visual Studio' in cfg['generator']: # find the VisualStudio project file proj = glob.glob(build_dir + '/*.sln') subprocess.call(['cmd', '/c', 'start', proj[0]]) else: log.error("don't know how to open a '{}' project".format( cfg['generator'])) else: log.error("config '{}' not found".format(cfg_name))
def valgrind(fips_dir, proj_dir, cfg_name, target, target_args) : """debug a single target with valgrind""" # prepare proj_name = util.get_project_name_from_dir(proj_dir) util.ensure_valid_project_dir(proj_dir) # load the config(s) configs = config.load(fips_dir, proj_dir, cfg_name) if configs : for cfg in configs : # check if config is valid config_valid, _ = config.check_config_valid(fips_dir, proj_dir, cfg, print_errors = True) if config_valid : deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name']) valgrind_bin = settings.get(proj_dir, 'valgrind') if not valgrind_bin : valgrind_bin = 'valgrind' log.colored(log.YELLOW, "=== valgrind: {} ({})".format(cfg['name'], valgrind_bin)) cmd_line = valgrind_bin if target_args : cmd_line += ' ' + ' '.join(target_args) else : cmd_line += ' ' + '--leak-check=no' cmd_line += ' ' + '--show-reachable=yes' cmd_line += ' ' + '--track-fds=yes' cmd_line += ' ' + '--run-libc-freeres=no' cmd_line += ' ' + "--log-file={}/valgrind-{}.log".format(proj_dir, target) cmd_line += ' ' + "./{}".format(target) #log.colored(log.GREEN, "cmdline: {}".format(cmd_line)) subprocess.call(args = cmd_line, cwd = deploy_dir, shell = True) else : log.error("Config '{}' not valid in this environment".format(cfg['name'])) else : log.error("No valid configs found for '{}'".format(cfg_name)) return True
def list_targets(fips_dir, proj_dir, args) : log.colored(log.YELLOW, "=== targets:") if util.is_valid_project_dir(proj_dir) : # get config name if len(args) == 0 : cfg_name = settings.get(proj_dir, 'config') else : cfg_name = args[0] log.info('{} config:{} {}'.format(log.BLUE, log.DEF, cfg_name)) # get the target list success, targets = project.get_target_list(fips_dir, proj_dir, cfg_name) if success : # split targets by type for type in ['lib', 'module', 'sharedlib', 'app'] : type_targets = [tgt for tgt in targets if targets[tgt] == type] if len(type_targets) > 0 : log.colored(log.BLUE, ' {}:'.format(type)) for tgt in type_targets : log.info(' ' + tgt) else : log.info(" can't fetch project target list, please run 'fips gen' first!") else : log.info(' currently not in a valid project directory')
def run(fips_dir, proj_dir, args) : if not util.is_valid_project_dir(proj_dir) : log.error('must be run in a project directory') proj_name = util.get_project_name_from_dir(proj_dir) cfg_name = None if len(args) > 0 : cfg_name = args[0] if not cfg_name : cfg_name = settings.get(proj_dir, 'config') build_dir = util.get_build_dir(fips_dir, proj_name, cfg_name) cache_file = build_dir + '/CMakeCache.txt' if not os.path.isfile(cache_file) : log.error('generate project first!') if sys.platform == "win32" : os.startfile(cache_file) else : opener ="open" if sys.platform == "darwin" else "xdg-open" subprocess.call([opener, cache_file])
def run(fips_dir, proj_dir, args): """run the 'physx' verb""" if len(args) > 0: noun = args[0] if noun == 'build': if sys.platform == "win32": # FIXME all of this only works on windows at the moment and is super hacky if len(args) != 2: log.error("expected compiler target (win-vs15, win-vs16)") preset = util.fix_path( os.path.dirname(os.path.abspath(__file__)) ) + "/physx-presets/" + "fips" + args[1] + ".xml" if not os.path.isfile(preset): log.error("Unrecognized compiler target") shutil.copy2(preset, proj_dir + "/../physx/physx/buildtools/presets/") subprocess.call(proj_dir + "/../physx/physx/generate_projects.bat fips" + args[1]) # figure out a version number for vswhere version = args[1][6:] version_next = str(int(version) + 1) version = version + ".0," + version_next + ".0" #use vswhere to figure out where vs is devenvPath = subprocess.check_output( proj_dir + "/../physx/externals/vswhere/vswhere -version [" + version + "] -property productPath").decode("utf-8").rstrip() devenvPath = util.fix_path(devenvPath) if not os.path.isfile(devenvPath): #try to find msbuild log.info( "Could not find Visual Studio, trying to find lastest version of MSBuild..." + devenvPath) devenvPath = subprocess.check_output( proj_dir + "/../physx/externals/vswhere/vswhere -version [" + version + "] -products * -requires Microsoft.Component.MSBuild -property installationPath" ).decode("utf-8").rstrip() devenvPath = util.fix_path( devenvPath + "/MSBuild/Current/Bin/MSBuild.exe") if not os.path.isfile(devenvPath): log.error( "Could not detect Visual Studio installation.") log.optional("Using MSBuild from", devenvPath) log.info("Compiling PhysX, this might take a while.") log.info("Building debug version...") #-noConsoleLogger retcode = subprocess.call( devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/INSTALL.vcxproj /verbosity:quiet /noLogo /noConsoleLogger /property:Configuration=Debug" ) if retcode == 0: log.colored(log.GREEN, "PhysX debug build completed.") else: log.colored(log.RED, "PhysX debug build failed!") log.info("Building release version...") retcode = subprocess.call( devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/INSTALL.vcxproj /verbosity:quiet /noLogo /noConsoleLogger /property:Configuration=Release" ) if retcode == 0: log.colored(log.GREEN, "PhysX release build completed.") else: log.colored(log.RED, "PhysX release build failed!") else: log.optional("Using Visual Studio from", devenvPath) log.info("Compiling PhysX, this might take a while...") log.info("Building debug version...") retcode = subprocess.call( devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/PhysXSDK.sln /Build debug /Project INSTALL") if retcode == 0: log.colored(log.GREEN, "PhysX debug build completed.") else: log.colored(log.RED, "PhysX debug build failed!") log.info("Building release version...") retcode = subprocess.call( devenvPath + " " + proj_dir + "/../physx/physx/compiler/fips" + args[1] + "/PhysXSDK.sln /Build release /Project INSTALL") if retcode == 0: log.colored(log.GREEN, "PhysX release build completed.") else: log.colored(log.RED, "PhysX release build failed!") else: preset = util.fix_path( os.path.dirname(os.path.abspath( __file__))) + "/physx-presets/fipslinux.xml" shutil.copy2(preset, proj_dir + "/../physx/physx/buildtools/presets/") subprocess.run([ proj_dir + "/../physx/physx/generate_projects.sh", "fipslinux" ]) subprocess.run(["make", "-j", "10"], cwd=proj_dir + "/../physx/physx/compiler/fipslinux-checked") subprocess.run(["make", "install"], cwd=proj_dir + "/../physx/physx/compiler/fipslinux-checked") if noun == 'deploy': if sys.platform == "win32": cur_cfg = None if len(args) > 1: cur_cfg = args[1] if not cur_cfg: cur_cfg = settings.get(proj_dir, 'config') ps_deploy = util.get_workspace_dir( fips_dir) + "/fips-deploy/physx/bin/" cfg = config.load(fips_dir, proj_dir, cur_cfg)[0] px_target = cfg['defines']['PX_TARGET'] target_dir = util.get_deploy_dir( fips_dir, util.get_project_name_from_dir(proj_dir), cur_cfg) dllFiles = glob.glob(ps_deploy + px_target + "/debug/*.dll") log.info("Looking for PhysX dlls in '{}/'".format(ps_deploy + px_target)) if not dllFiles: log.error( "PhysX debug dlls not found! Have you built them? (fips physx build [compiler target])" ) else: for dll in dllFiles: shutil.copy2(dll, target_dir) log.colored( log.GREEN, "Deployed PhysX debug binaries to '{}'".format( target_dir)) dllFiles = glob.glob(ps_deploy + px_target + "/release/*.dll") if not dllFiles: log.error( "PhysX release dlls not found! Have you built them? (fips physx build [compiler target])" ) else: for dll in dllFiles: shutil.copy2(dll, target_dir) log.colored( log.GREEN, "Deployed PhysX release binaries to '{}'".format( target_dir)) else: def run(fips_dir, proj_dir, args): log.error("Not supported")