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 get_vs_header_paths(fips_dir, proj_dir, cfg):
'''hacky way to find the header search path in the latest installed
Windows 10 Kit and Visual Studio instance
'''
if util.get_host_platform() != 'win':
return []
# Windows system headers are in 2 locations, first find the latest Windows Kit
result = []
kits = glob.glob('C:/Program Files (x86)/Windows Kits/10/Include/*/')
if kits:
latest = max(kits).replace('\\', '/')
subdirs = glob.glob(latest + '/*/')
for d in subdirs:
result.append(d.replace('\\', '/'))
# next get the used active Visual Studio instance from the cmake cache
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
outp = subprocess.check_output(['cmake', '-LA', '.'],
cwd=build_dir).decode("utf-8")
for line in outp.splitlines():
if line.startswith('CMAKE_LINKER:FILEPATH='):
bin_index = line.find('/bin/')
if bin_index > 0:
result.append(line[22:bin_index + 1] + 'include')
return result
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 configure(fips_dir, proj_dir, cfg_name):
"""run ccmake or cmake-gui on the provided project and config
:param fips_dir: absolute fips path
:param proj_dir: absolute project dir
:cfg_name: build config name
"""
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 configs, if more then one, only use first one
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs:
cfg = configs[0]
log.colored(log.YELLOW, '=== configuring: {}'.format(cfg['name']))
# generate build files
if not gen_project(fips_dir, proj_dir, cfg, True):
log.error("Failed to generate '{}' of project '{}'".format(
cfg['name'], proj_name))
# run ccmake or cmake-gui
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
if ccmake.check_exists(fips_dir):
ccmake.run(build_dir)
elif cmake_gui.check_exists(fips_dir):
cmake_gui.run(build_dir)
else:
log.error(
"Neither 'ccmake' nor 'cmake-gui' found (run 'fips diag')")
else:
log.error("No configs found for '{}'".format(cfg_name))
def configure(fips_dir, proj_dir, cfg_name) :
"""run ccmake or cmake-gui on the provided project and config
:param fips_dir: absolute fips path
:param proj_dir: absolute project dir
:cfg_name: build config name
"""
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 configs, if more then one, only use first one
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs :
cfg = configs[0]
log.colored(log.YELLOW, '=== configuring: {}'.format(cfg['name']))
# generate build files
if not gen_project(fips_dir, proj_dir, cfg, True) :
log.error("Failed to generate '{}' of project '{}'".format(cfg['name'], proj_name))
# run ccmake or cmake-gui
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
if ccmake.check_exists(fips_dir) :
ccmake.run(build_dir)
elif cmake_gui.check_exists(fips_dir) :
cmake_gui.run(build_dir)
else :
log.error("Neither 'ccmake' nor 'cmake-gui' found (run 'fips diag')")
else :
log.error("No configs found for '{}'".format(cfg_name))
def get_vs_header_paths(fips_dir, proj_dir, cfg):
'''hacky way to find the header search path in the latest installed
Windows 10 Kit and Visual Studio instance
'''
if util.get_host_platform() != 'win':
return []
# Windows system headers are in 2 locations, first find the latest Windows Kit
result = []
kits = glob.glob('C:/Program Files (x86)/Windows Kits/10/Include/*/')
if kits:
latest = max(kits).replace('\\','/')
subdirs = glob.glob(latest + '/*/')
for d in subdirs:
result.append(d.replace('\\','/'))
# next get the used active Visual Studio instance from the cmake cache
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
outp = subprocess.check_output(['cmake', '-LA', '.'], cwd=build_dir).decode("utf-8")
for line in outp.splitlines():
if line.startswith('CMAKE_LINKER:FILEPATH='):
bin_index = line.find('/bin/')
if bin_index > 0:
result.append(line[22:bin_index+1]+'include')
return result
def clean(fips_dir, proj_dir, cfg_name):
"""clean build files
:param fips_dir: absolute path of fips
:param proj_dir: absolute project path
:param cfg_name: config name (or pattern)
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs:
num_cleaned_configs = 0
for cfg in configs:
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
build_dir_exists = os.path.isdir(build_dir)
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name'])
deploy_dir_exists = os.path.isdir(deploy_dir)
if build_dir_exists or deploy_dir_exists:
log.colored(log.YELLOW, "=== clean: {}".format(cfg['name']))
num_cleaned_configs += 1
if build_dir_exists:
shutil.rmtree(build_dir)
log.info(" deleted '{}'".format(build_dir))
if deploy_dir_exists:
shutil.rmtree(deploy_dir)
log.info(" deleted '{}'".format(deploy_dir))
if num_cleaned_configs == 0:
log.colored(log.YELLOW,
"=== clean: nothing to clean for {}".format(cfg_name))
else:
log.error("No valid configs found for '{}'".format(cfg_name))
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 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 write_cmake_tools_settings(fips_dir, proj_dir, vscode_dir, cfg):
'''write a settings.json for CMakeTools plugin settings'''
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
settings = {
'cmake.buildDirectory': build_dir,
'cmake.configureSettings': {
'FIPS_CONFIG:': cfg['name']
}
}
with open(vscode_dir + '/settings.json', 'w') as f:
json.dump(settings, f, indent=1, separators=(',',':'))
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 make_clean(fips_dir, proj_dir, cfg_name):
"""perform a 'make clean' on the project
:param fips_dir: absolute path of fips
:param proj_dir: absolute path of project dir
:param cfg_name: config name or pattern
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
num_valid_configs = 0
if configs:
for cfg in configs:
config_valid, _ = config.check_config_valid(fips_dir,
proj_dir,
cfg,
print_errors=True)
if config_valid:
log.colored(log.YELLOW, "=== cleaning: {}".format(cfg['name']))
build_dir = util.get_build_dir(fips_dir, proj_name,
cfg['name'])
result = False
if cfg['build_tool'] == make.name:
result = make.run_clean(fips_dir, build_dir)
elif cfg['build_tool'] == ninja.name:
result = ninja.run_clean(fips_dir, build_dir)
elif cfg['build_tool'] == xcodebuild.name:
result = xcodebuild.run_clean(fips_dir, build_dir)
else:
result = cmake.run_clean(fips_dir, build_dir)
if result:
num_valid_configs += 1
else:
log.error(
"Failed to clean 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 cleaned'.format(num_valid_configs))
return True
def write_cmake_tools_settings(fips_dir, proj_dir, vscode_dir, cfg):
'''write a settings.json for CMakeTools plugin settings'''
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
settings = {
'cmake.buildDirectory': build_dir,
'cmake.configureSettings': {
'FIPS_CONFIG:': cfg['name']
}
}
settings_path = vscode_dir + '/settings.json'
log.info(' writing {}'.format(settings_path))
with open(settings_path, 'w') as f:
json.dump(settings, f, indent=1, separators=(',',':'))
def write_c_cpp_properties_json(fips_dir, proj_dir, impex, cfg):
'''write the .vscode/c_cpp_properties.json files for main project
and all dependent projects
'''
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
inc_paths = read_cmake_headerdirs(fips_dir, proj_dir, cfg)
defines = read_cmake_defines(fips_dir, proj_dir, cfg)
props = {'configurations': [], 'version': 3}
for config_name in ['Mac', 'Linux', 'Win32']:
c = {
'name': config_name,
'browse': {
'limitSymbolsToIncludeHeaders': True,
'databaseFilename': '{}/browse.VS.code'.format(build_dir)
}
}
config_incl_paths = []
intellisense_mode = 'clang-x64'
if config_name == 'Mac':
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG', '__GNUC__', '__APPLE__', '__clang__']
elif config_name == 'Linux':
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG', '__GNUC__']
else:
intellisense_mode = 'msvc-x64'
config_incl_paths = get_vs_header_paths(fips_dir, proj_dir, cfg)
config_defines = ['_DEBUG', '_WIN32']
config_incl_paths.extend(inc_paths)
config_defines.extend(defines)
c['includePath'] = config_incl_paths
c['defines'] = config_defines
c['browse']['path'] = config_incl_paths
c['intelliSenseMode'] = intellisense_mode
props['configurations'].append(c)
# add dependencies in reverse order, so that main project is first
for dep_proj_name in reversed(impex):
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
vscode_dir = dep_proj_dir + '/.vscode'
if not os.path.isdir(vscode_dir):
os.makedirs(vscode_dir)
prop_path = vscode_dir + '/c_cpp_properties.json'
log.info(' writing {}'.format(prop_path))
with open(prop_path, 'w') as f:
json.dump(props, f, indent=1, separators=(',', ':'))
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 make_clean(fips_dir, proj_dir, cfg_name) :
"""perform a 'make clean' on the project
:param fips_dir: absolute path of fips
:param proj_dir: absolute path of project dir
:param cfg_name: config name or pattern
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
num_valid_configs = 0
if configs :
for cfg in configs :
config_valid, _ = config.check_config_valid(fips_dir, cfg, print_errors=True)
if config_valid :
log.colored(log.YELLOW, "=== cleaning: {}".format(cfg['name']))
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
result = False
if cfg['build_tool'] == make.name :
result = make.run_clean(fips_dir, build_dir)
elif cfg['build_tool'] == ninja.name :
result = ninja.run_clean(fips_dir, build_dir)
elif cfg['build_tool'] == xcodebuild.name :
result = xcodebuild.run_clean(fips_dir, build_dir)
else :
result = cmake.run_clean(fips_dir, build_dir)
if result :
num_valid_configs += 1
else :
log.error("Failed to clean 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 cleaned'.format(num_valid_configs))
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 write_c_cpp_properties_json(fips_dir, proj_dir, vscode_dir, cfg):
'''write the .vscode/c_cpp_properties.json file'''
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
inc_paths = read_cmake_headerdirs(fips_dir, proj_dir, cfg)
defines = read_cmake_defines(fips_dir, proj_dir, cfg)
props = {
'configurations': [],
'version': 3
}
for config_name in ['Mac','Linux','Win32']:
c = {
'name': config_name,
'browse': {
'limitSymbolsToIncludeHeaders': True,
'databaseFilename': '{}/browse.VS.code'.format(build_dir)
}
}
config_incl_paths = []
intellisense_mode = 'clang-x64'
if config_name == 'Mac':
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG','__GNUC__','__APPLE__','__clang__']
elif config_name == 'Linux':
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG','__GNUC__']
else:
intellisense_mode = 'msvc-x64'
config_incl_paths = get_vs_header_paths(fips_dir, proj_dir, cfg)
config_defines = ['_DEBUG','_WIN32']
config_incl_paths.extend(inc_paths)
config_defines.extend(defines)
c['includePath'] = config_incl_paths
c['defines'] = config_defines
c['browse']['path'] = config_incl_paths
c['intelliSenseMode'] = intellisense_mode
props['configurations'].append(c)
with open(vscode_dir + '/c_cpp_properties.json', 'w') as f:
json.dump(props, f, indent=1, separators=(',',':'))
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 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 get_target_list(fips_dir, proj_dir, cfg_name):
"""get project targets config name, only works
if a cmake run was performed before
:param fips_dir: absolute path to fips
:param proj_dir: absolute project path
:param cfg_name: the config name
:returns: (success, targets)
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs:
cfg = configs[0]
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
targets_path = build_dir + '/fips_targets.yml'
if os.path.isfile(targets_path):
targets = []
with open(targets_path) as f:
targets = yaml.load(f)
return True, targets
else:
return False, []
else:
log.error("No valid configs found for '{}'".format(cfg_name))
def get_target_list(fips_dir, proj_dir, cfg_name) :
"""get project targets config name, only works
if a cmake run was performed before
:param fips_dir: absolute path to fips
:param proj_dir: absolute project path
:param cfg_name: the config name
:returns: (success, targets)
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs :
cfg = configs[0]
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
targets_path = build_dir + '/fips_targets.yml'
if os.path.isfile(targets_path) :
targets = []
with open(targets_path) as f :
targets = yaml.load(f)
return True, targets
else :
return False, []
else :
log.error("No valid configs found for '{}'".format(cfg_name))
def clean(fips_dir, proj_dir, cfg_name) :
"""clean build files
:param fips_dir: absolute path of fips
:param proj_dir: absolute project path
:param cfg_name: config name (or pattern)
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs :
for cfg in configs :
log.colored(log.YELLOW, "=== clean: {}".format(cfg['name']))
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
if os.path.isdir(build_dir) :
shutil.rmtree(build_dir)
log.info(" deleted '{}'".format(build_dir))
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg)
if os.path.isdir(deploy_dir) :
shutil.rmtree(deploy_dir)
log.info(" deleted '{}'".format(deploy_dir))
else :
log.error("No valid configs found for '{}'".format(cfg_name))
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 clean(fips_dir, proj_dir, cfg_name):
"""clean build files
:param fips_dir: absolute path of fips
:param proj_dir: absolute project path
:param cfg_name: config name (or pattern)
"""
proj_name = util.get_project_name_from_dir(proj_dir)
configs = config.load(fips_dir, proj_dir, cfg_name)
if configs:
for cfg in configs:
log.colored(log.YELLOW, "=== clean: {}".format(cfg['name']))
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
if os.path.isdir(build_dir):
shutil.rmtree(build_dir)
log.info(" deleted '{}'".format(build_dir))
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg)
if os.path.isdir(deploy_dir):
shutil.rmtree(deploy_dir)
log.info(" deleted '{}'".format(deploy_dir))
else:
log.error("No valid configs found for '{}'".format(cfg_name))
def write_c_cpp_properties_json(fips_dir, proj_dir, impex, cfg):
'''write the .vscode/c_cpp_properties.json files for main project
and all dependent projects
'''
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
defines = read_cmake_defines(fips_dir, proj_dir, cfg)
compile_commands_path = build_dir + '/compile_commands.json'
has_compile_command_json = os.path.isfile(compile_commands_path)
inc_paths = None
if not has_compile_command_json:
inc_paths = read_cmake_headerdirs(fips_dir, proj_dir, cfg)
props = {
'configurations': [],
'version': 3
}
for config_name in ['Mac','Linux','Win32']:
c = {
'name': config_name,
'browse': {
'limitSymbolsToIncludedHeaders': True,
'databaseFilename': '{}/browse.VS.code'.format(build_dir)
}
}
config_incl_paths = None
compiler_path = None
intellisense_mode = 'clang-x64'
if config_name == 'Mac':
if not has_compile_command_json:
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG','__GNUC__','__APPLE__','__clang__']
compiler_path = '/usr/bin/c++'
elif config_name == 'Linux':
if not has_compile_command_json:
config_incl_paths = get_cc_header_paths()
config_defines = ['_DEBUG','__GNUC__']
compiler_path = '/usr/bin/c++'
else:
if not has_compile_command_json:
config_incl_paths = get_vs_header_paths(fips_dir, proj_dir, cfg)
intellisense_mode = 'msvc-x64'
config_defines = ['_DEBUG','_WIN32']
if inc_paths:
config_incl_paths.extend(inc_paths)
config_defines.extend(defines)
if compiler_path:
c['compilerPath'] = compiler_path
if has_compile_command_json:
c['compileCommands'] = compile_commands_path
if config_incl_paths:
c['includePath'] = config_incl_paths
c['defines'] = config_defines
if config_incl_paths:
c['browse']['path'] = config_incl_paths
c['intelliSenseMode'] = intellisense_mode
props['configurations'].append(c)
# add dependencies in reverse order, so that main project is first
for dep_proj_name in reversed(impex):
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
vscode_dir = dep_proj_dir + '/.vscode'
if not os.path.isdir(vscode_dir):
os.makedirs(vscode_dir)
prop_path = vscode_dir + '/c_cpp_properties.json'
log.info(' writing {}'.format(prop_path))
with open(prop_path, 'w') as f:
json.dump(props, f, indent=1, separators=(',',':'))
def write_workspace_settings(fips_dir, proj_dir, cfg):
'''write the VSCode launch.json, tasks.json and
c_cpp_properties.json files from cmake output files
'''
proj_name = util.get_project_name_from_dir(proj_dir)
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
vscode_dir = proj_dir + '/.vscode'
if not os.path.isdir(vscode_dir):
os.makedirs(vscode_dir)
exe_targets = read_cmake_targets(fips_dir, proj_dir, cfg, ['app'])
all_targets = read_cmake_targets(fips_dir, proj_dir, cfg, None)
inc_paths = read_cmake_headerdirs(fips_dir, proj_dir, cfg)
if util.get_host_platform() == 'win':
fips_cmd = 'fips'
else:
fips_cmd = './fips'
# write a tasks.json file
tasks = {
'version': '0.1.0',
'command': fips_cmd,
'isShellCommand': True,
'showOutput': 'silent',
'suppressTaskName': True,
'echoCommand': True,
'tasks': []
}
for tgt in all_targets:
tasks['tasks'].append({
'taskName': tgt,
'args': ['make', tgt],
'problemMatcher': problem_matcher(),
})
tasks['tasks'].append({
'isBuildCommand': True,
'taskName': 'ALL',
'args': ['build'],
'problemMatcher': problem_matcher()
})
with open(vscode_dir + '/tasks.json', 'w') as f:
json.dump(tasks, f, indent=1, separators=(',', ':'))
# write a launch.json with 1 config per build target
launch = {'version': '0.2.0', 'configurations': []}
for tgt in exe_targets:
path = deploy_dir + '/' + tgt
if util.get_host_platform() == 'win':
path += '.exe'
cwd = os.path.dirname(path)
osx_path = path + '.app/Contents/MacOS/' + tgt
osx_cwd = os.path.dirname(osx_path)
if os.path.isdir(osx_cwd):
path = osx_path
cwd = osx_cwd
if util.get_host_platform() == 'win':
c = {
'name': tgt,
'type': 'cppvsdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': True,
'cwd': cwd,
'environment': [],
'externalConsole': False
}
elif util.get_host_platform() == 'linux':
c = {
'name': tgt,
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': True,
'cwd': cwd,
'externalConsole': False,
'MIMode': 'gdb'
}
else:
c = {
'name': tgt,
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': True,
'cwd': cwd,
'externalConsole': False,
'MIMode': 'lldb'
}
launch['configurations'].append(c)
# add a python code-generator debug config
c = {
'name':
'fips codegen',
'type':
'python',
'request':
'launch',
'stopOnEntry':
True,
'pythonPath':
'${config:python.pythonPath}',
'program':
proj_dir + '/.fips-gen.py',
'args': [build_dir + '/fips_codegen.yml'],
"cwd":
proj_dir,
"debugOptions":
["WaitOnAbnormalExit", "WaitOnNormalExit", "RedirectOutput"]
}
launch['configurations'].append(c)
# add a python debug config for each fips verb
for verb_name, verb_mod in verb.verbs.items():
# ignore standard verbs
if fips_dir not in inspect.getfile(verb_mod):
c = {
'name':
'fips {}'.format(verb_name),
'type':
'python',
'request':
'launch',
'stopOnEntry':
True,
'pythonPath':
'${config:python.pythonPath}',
'program':
proj_dir + '/fips',
'args': [verb_name],
'cwd':
proj_dir,
"debugOptions":
["WaitOnAbnormalExit", "WaitOnNormalExit", "RedirectOutput"]
}
launch['configurations'].append(c)
with open(vscode_dir + '/launch.json', 'w') as f:
json.dump(launch, f, indent=1, separators=(',', ':'))
# write a c_cpp_properties.json file with header-search paths
props = {'configurations': []}
for config_name in ['Mac', 'Linux', 'Win32']:
c = {
'name': config_name,
'browse': {
'limitSymbolsToIncludeHeaders': True,
'databaseFilename': '{}/browse.VS.code'.format(build_dir)
}
}
config_incl_paths = []
if config_name == 'Mac':
config_incl_paths = [
'/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1',
'/usr/local/include',
'/applications/xcode.app/contents/developer/toolchains/xcodedefault.xctoolchain/usr/lib/clang/8.1.0/include',
'/applications/xcode.app/contents/developer/toolchains/xcodedefault.xctoolchain/usr/include',
'/usr/include'
]
elif config_name == 'Linux':
config_incl_paths = ['/usr/include', '/usr/local/include']
else:
config_incl_paths = [
# FIXME
'C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include/*'
]
for inc_path in inc_paths:
config_incl_paths.append(inc_path)
c['includePath'] = config_incl_paths
c['browse']['path'] = config_incl_paths
props['configurations'].append(c)
with open(vscode_dir + '/c_cpp_properties.json', 'w') as f:
json.dump(props, f, indent=1, separators=(',', ':'))
def write_launch_json(fips_dir, proj_dir, vscode_dir, cfg):
'''write the .vscode/launch.json file'''
proj_name = util.get_project_name_from_dir(proj_dir)
exe_targets = read_cmake_targets(fips_dir, proj_dir, cfg, ['app'])
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name'])
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
pre_launch_build_options = [('', True), (' [Skip Build]', False)]
stop_at_entry_options = [('', False), (' [Stop At Entry]', True)]
launch = {
'version': '0.2.0',
'configurations': []
}
for tgt in exe_targets:
for pre_launch_build in pre_launch_build_options:
for stop_at_entry in stop_at_entry_options:
path = deploy_dir + '/' + tgt
if util.get_host_platform() == 'win':
path += '.exe'
cwd = os.path.dirname(path)
osx_path = path + '.app/Contents/MacOS/' + tgt
osx_cwd = os.path.dirname(osx_path)
if os.path.isdir(osx_cwd):
path = osx_path
cwd = osx_cwd
if util.get_host_platform() == 'win':
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppvsdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'environment': [],
'externalConsole': False,
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
elif util.get_host_platform() == 'linux':
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'externalConsole': False,
'MIMode': 'gdb',
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
else:
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'externalConsole': False,
'MIMode': 'lldb',
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
launch['configurations'].append(c)
# add a python code-generator debug config
c = {
'name': 'fips codegen',
'type': 'python',
'request': 'launch',
'stopOnEntry': True,
'pythonPath': '${config:python.pythonPath}',
'program': build_dir + '/fips-gen.py',
'args': [ build_dir + '/fips_codegen.yml' ],
"cwd": proj_dir,
"debugOptions": [
"WaitOnAbnormalExit",
"WaitOnNormalExit",
"RedirectOutput"
]
}
launch['configurations'].append(c)
# add a python debug config for each fips verb
for verb_name, verb_mod in verb.verbs.items() :
# ignore standard verbs
if fips_dir not in inspect.getfile(verb_mod):
c = {
'name': 'fips {}'.format(verb_name),
'type': 'python',
'request': 'launch',
'stopOnEntry': True,
'pythonPath': '${config:python.pythonPath}',
'program': proj_dir + '/fips',
'args': [ verb_name ],
'cwd': proj_dir,
"debugOptions": [
"WaitOnAbnormalExit",
"WaitOnNormalExit",
"RedirectOutput"
]
}
launch['configurations'].append(c)
launch_path = vscode_dir + '/launch.json'
log.info(' writing {}'.format(launch_path))
with open(launch_path, 'w') as f:
json.dump(launch, f, indent=1, separators=(',',':'))
def write_workspace_settings(fips_dir, proj_dir, cfg):
'''write the VSCode launch.json, tasks.json and
c_cpp_properties.json files from cmake output files
'''
proj_name = util.get_project_name_from_dir(proj_dir)
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg)
vscode_dir = proj_dir + '/.vscode'
if not os.path.isdir(vscode_dir):
os.makedirs(vscode_dir)
exe_targets = read_cmake_targets(fips_dir, proj_dir, cfg, ['app'])
all_targets = read_cmake_targets(fips_dir, proj_dir, cfg, None)
inc_paths = read_cmake_headerdirs(fips_dir, proj_dir, cfg)
if util.get_host_platform() == 'win':
fips_cmd = 'fips'
else:
fips_cmd = './fips'
# write a tasks.json file
tasks = {
'version': '0.1.0',
'command': fips_cmd,
'isShellCommand': True,
'showOutput': 'silent',
'suppressTaskName': True,
'echoCommand': True,
'tasks': []
}
for tgt in all_targets:
tasks['tasks'].append({
'taskName': tgt,
'args': ['make', tgt],
'problemMatcher': problem_matcher(),
})
tasks['tasks'].append({
'isBuildCommand': True,
'taskName': 'ALL',
'args': ['build'],
'problemMatcher': problem_matcher()
})
with open(vscode_dir + '/tasks.json', 'w') as f:
json.dump(tasks, f, indent=1, separators=(',', ':'))
# write a launch.json with 1 config per build target
launch = {'version': '0.2.0', 'configurations': []}
for tgt in exe_targets:
path = deploy_dir + '/' + tgt
if util.get_host_platform() == 'win':
path += '.exe'
cwd = os.path.dirname(path)
osx_path = path + '.app/Contents/MacOS/' + tgt
osx_cwd = os.path.dirname(osx_path)
if os.path.isdir(osx_cwd):
path = osx_path
cwd = osx_cwd
if util.get_host_platform() == 'win':
c = {
'name': tgt,
'type': 'cppvsdbg',
'request': 'launch',
'program': path,
'stopAtEntry': True,
'cwd': cwd,
'environment': [],
'externalConsole': False
}
else:
c = {
'name': tgt,
'type': 'cppdbg',
'request': 'launch',
'program': path,
'stopAtEntry': True,
'cwd': cwd,
'externalConsole': False,
'linux': {
'MIMode':
'gdb',
'setupCommands': [{
'description': 'Enable pretty-printing for gdb',
'text': '--enable-pretty-printing',
'ignoreFailures': True
}]
},
'osx': {
'MIMode': 'lldb'
}
}
launch['configurations'].append(c)
# add a python code-generator debug config
c = {
'name':
'fips codegen',
'type':
'python',
'request':
'launch',
'stopOnEntry':
True,
'pythonPath':
'${config.python.pythonPath}',
'program':
proj_dir + '/.fips-gen.py',
'args': [build_dir + '/fips_codegen.yml'],
"cwd":
proj_dir,
"debugOptions":
["WaitOnAbnormalExit", "WaitOnNormalExit", "RedirectOutput"]
}
launch['configurations'].append(c)
# TODO: add entries for local fips verbs?
with open(vscode_dir + '/launch.json', 'w') as f:
json.dump(launch, f, indent=1, separators=(',', ':'))
# write a c_cpp_properties.json file with header-search paths
props = {'configurations': []}
for config_name in ['Mac', 'Linux', 'Win32']:
c = {
'name': config_name,
'browse': {
'limitSymbolsToIncludeHeaders': True,
'databaseFilename': ''
}
}
if config_name in ['Mac', 'Linux']:
c['includePath'] = ['/usr/include', '/usr/local/include']
else:
c['includePath'] = [
# FIXME
'C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include/*'
]
for inc_path in inc_paths:
c['includePath'].append(inc_path)
props['configurations'].append(c)
with open(vscode_dir + '/c_cpp_properties.json', 'w') as f:
json.dump(props, f, indent=1, separators=(',', ':'))
def write_launch_json(fips_dir, proj_dir, vscode_dir, cfg):
'''write the .vscode/launch.json file'''
proj_name = util.get_project_name_from_dir(proj_dir)
exe_targets = read_cmake_targets(fips_dir, proj_dir, cfg, ['app'])
deploy_dir = util.get_deploy_dir(fips_dir, proj_name, cfg['name'])
build_dir = util.get_build_dir(fips_dir, proj_name, cfg['name'])
pre_launch_build_options = [('', True), (' [Skip Build]', False)]
stop_at_entry_options = [('', False), (' [Stop At Entry]', True)]
launch = {'version': '0.2.0', 'configurations': []}
for tgt in exe_targets:
for pre_launch_build in pre_launch_build_options:
for stop_at_entry in stop_at_entry_options:
path = deploy_dir + '/' + tgt
if util.get_host_platform() == 'win':
path += '.exe'
cwd = os.path.dirname(path)
osx_path = path + '.app/Contents/MacOS/' + tgt
osx_cwd = os.path.dirname(osx_path)
if os.path.isdir(osx_cwd):
path = osx_path
cwd = osx_cwd
if util.get_host_platform() == 'win':
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppvsdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'environment': [],
'externalConsole': False,
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
elif util.get_host_platform() == 'linux':
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'externalConsole': False,
'MIMode': 'gdb',
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
else:
c = {
'name': tgt + pre_launch_build[0] + stop_at_entry[0],
'type': 'cppdbg',
'request': 'launch',
'program': path,
'args': [],
'stopAtEntry': stop_at_entry[1],
'cwd': cwd,
'externalConsole': False,
'MIMode': 'lldb',
'preLaunchTask': tgt if pre_launch_build[1] else ''
}
launch['configurations'].append(c)
# add a python code-generator debug config
c = {
'name':
'fips codegen',
'type':
'python',
'request':
'launch',
'stopOnEntry':
True,
'pythonPath':
'${config:python.pythonPath}',
'program':
build_dir + '/fips-gen.py',
'args': [build_dir + '/fips_codegen.yml'],
"cwd":
proj_dir,
"debugOptions":
["WaitOnAbnormalExit", "WaitOnNormalExit", "RedirectOutput"]
}
launch['configurations'].append(c)
# add a python debug config for each fips verb
for verb_name, verb_mod in verb.verbs.items():
# ignore standard verbs
if fips_dir not in inspect.getfile(verb_mod):
c = {
'name':
'fips {}'.format(verb_name),
'type':
'python',
'request':
'launch',
'stopOnEntry':
True,
'pythonPath':
'${config:python.pythonPath}',
'program':
proj_dir + '/fips',
'args': [verb_name],
'cwd':
proj_dir,
"debugOptions":
["WaitOnAbnormalExit", "WaitOnNormalExit", "RedirectOutput"]
}
launch['configurations'].append(c)
launch_path = vscode_dir + '/launch.json'
log.info(' writing {}'.format(launch_path))
with open(launch_path, 'w') as f:
json.dump(launch, f, indent=1, separators=(',', ':'))
def write_imports(fips_dir, proj_dir, cfg_name, imported) :
"""write the big imports map created with 'gather_imports'
to a .fips-imports.cmake file in the current project
:params fips_dir: absolute path to fips
:params proj_dir: absolute path to current project
:params imported: the imports dictionary created with 'gather_imports'
"""
if imported :
unique_hdrdirs = []
unique_libdirs = []
unique_defines = {}
unique_modules = {}
# write a temporary .fips-imports.cmake.tmp file,
# this will replace the old file, but only if the
# content is different, this will prevent an unnecessary
# cmake run if the imports haven't changed
import_filename = proj_dir + '/.fips-imports.cmake'
import_tmp_filename = import_filename + '.tmp'
with open(import_tmp_filename, 'w') as f :
f.write("#\n# generated by 'fips gen', don't edit, don't add to version control!\n#\n")
for imp_proj_name in imported :
imp_proj_dir = util.get_project_dir(fips_dir, imp_proj_name)
if imported[imp_proj_name]['cond']:
f.write('if ({})\n'.format(imported[imp_proj_name]['cond']))
# add include and lib search paths
if imp_proj_dir != proj_dir :
f.write('if (EXISTS "{}/fips-include.cmake")\n'.format(imp_proj_dir))
f.write(' include("{}/fips-include.cmake")\n'.format(imp_proj_dir))
f.write('elseif (EXISTS "{}/fips-files/include.cmake")\n'.format(imp_proj_dir))
f.write(' include ("{}/fips-files/include.cmake")\n'.format(imp_proj_dir))
f.write('endif()\n')
f.write('if (EXISTS "{}/lib/${{FIPS_PLATFORM_NAME}}")\n'.format(imp_proj_dir))
f.write(' link_directories("{}/lib/${{FIPS_PLATFORM_NAME}}")\n'.format(imp_proj_dir))
f.write('endif()\n')
# add header search paths
for hdrdir in imported[imp_proj_name]['hdrdirs'] :
if hdrdir not in unique_hdrdirs :
f.write('include_directories("{}")\n'.format(hdrdir))
unique_hdrdirs.append(hdrdir)
# add lib search paths
for libdir in imported[imp_proj_name]['libdirs'] :
if libdir not in unique_libdirs :
f.write('link_directories("{}")\n'.format(libdir))
unique_libdirs.append(libdir)
# add defines
for define in imported[imp_proj_name]['defines'] :
value = imported[imp_proj_name]['defines'][define]
if define not in unique_defines :
unique_defines[define] = value
if type(value) is str :
f.write('add_definitions(-D{}="{}")\n'.format(define, value))
else :
f.write('add_definitions(-D{}={})\n'.format(define, value))
# add import modules
if len(imported[imp_proj_name]['modules']) > 0 :
import_functions = []
# first add all module import functions
for module in imported[imp_proj_name]['modules'] :
module_path = imported[imp_proj_name]['modules'][module]
if module not in unique_modules :
unique_modules[module] = module_path
import_func = 'fips_import_{}'.format(module_path).replace('-','_')
import_functions.append(import_func)
f.write('macro({})\n'.format(import_func))
f.write(' set(FIPS_IMPORT 1)\n')
f.write(' add_subdirectory("{}" "{}")\n'.format(module, module_path))
f.write(' set(FIPS_IMPORT)\n')
f.write('endmacro()\n')
# if auto-import is enabled, also actually import all modules
f.write('if (FIPS_AUTO_IMPORT)\n')
group = "Imports"
if imported[imp_proj_name]['group'] :
group += "/" + imported[imp_proj_name]['group']
if len(imported[imp_proj_name]['modules']) > 3 :
group += "/" + imp_proj_name
f.write(' fips_ide_group("{}")\n'.format(group))
for import_func in import_functions :
f.write(' {}()\n'.format(import_func))
f.write(' fips_ide_group("")\n')
f.write('endif()\n')
if imported[imp_proj_name]['cond']:
f.write('endif()\n')
# check content of old and new file, only replace if changed
imports_dirty = True
if os.path.isfile(import_filename) :
if filecmp.cmp(import_filename, import_tmp_filename, shallow=False) :
imports_dirty = False
if imports_dirty :
if os.path.isfile(import_filename) :
os.remove(import_filename)
os.rename(import_tmp_filename, import_filename)
else :
os.remove(import_tmp_filename)
# write the .fips-imports.py file (copy from template)
gen_search_paths = '"{}","{}/generators",\n'.format(fips_dir, fips_dir)
proj_gen_dir = util.get_generators_dir(proj_dir)
if proj_gen_dir:
gen_search_paths += '"{}","{}",\n'.format(proj_dir, proj_gen_dir)
for imp_proj_name in imported :
gen_dir = util.get_generators_dir(util.get_project_dir(fips_dir, imp_proj_name))
if gen_dir:
gen_search_paths += '"' + gen_dir + '",\n'
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg_name);
if not os.path.isdir(build_dir):
os.makedirs(build_dir)
template.copy_template_file(fips_dir, build_dir, 'fips-gen.py', { 'genpaths': gen_search_paths}, True)
def write_imports(fips_dir, proj_dir, cfg_name, imported) :
"""write the big imports map created with 'gather_imports'
to a .fips-imports.cmake file in the current project
:params fips_dir: absolute path to fips
:params proj_dir: absolute path to current project
:params imported: the imports dictionary created with 'gather_imports'
"""
if imported is not None:
unique_hdrdirs = []
unique_condhdrdirs = {}
unique_libdirs = []
unique_defines = {}
unique_modules = {}
# write a temporary .fips-imports.cmake.tmp file,
# this will replace the old file, but only if the
# content is different, this will prevent an unnecessary
# cmake run if the imports haven't changed
import_filename = proj_dir + '/.fips-imports.cmake'
import_tmp_filename = import_filename + '.tmp'
with open(import_tmp_filename, 'w') as f :
f.write("#\n# generated by 'fips gen', don't edit, don't add to version control!\n#\n")
for imp_proj_name in imported :
imp_proj_dir = util.get_project_dir(fips_dir, imp_proj_name)
if imported[imp_proj_name]['cond']:
f.write('if ({})\n'.format(imported[imp_proj_name]['cond']))
# add include and lib search paths
if imp_proj_dir != proj_dir :
f.write('if (EXISTS "{}/fips-include.cmake")\n'.format(imp_proj_dir))
f.write(' include("{}/fips-include.cmake")\n'.format(imp_proj_dir))
f.write('elseif (EXISTS "{}/fips-files/include.cmake")\n'.format(imp_proj_dir))
f.write(' include ("{}/fips-files/include.cmake")\n'.format(imp_proj_dir))
f.write('endif()\n')
f.write('if (EXISTS "{}/lib/${{FIPS_PLATFORM_NAME}}")\n'.format(imp_proj_dir))
f.write(' link_directories("{}/lib/${{FIPS_PLATFORM_NAME}}")\n'.format(imp_proj_dir))
f.write('endif()\n')
# add header search paths
for hdrdir in imported[imp_proj_name]['hdrdirs'] :
if hdrdir not in unique_hdrdirs :
f.write('include_directories("{}")\n'.format(hdrdir))
unique_hdrdirs.append(hdrdir)
# add conditional header search paths
for hdrdir in imported[imp_proj_name]['condhdrdirs'] :
value = imported[imp_proj_name]['condhdrdirs'][hdrdir]
if hdrdir not in unique_condhdrdirs :
unique_condhdrdirs[hdrdir] = value
f.write('if ({})\n'.format(value))
f.write(' include_directories("{}")\n'.format(hdrdir))
f.write('endif()\n')
# add lib search paths
for libdir in imported[imp_proj_name]['libdirs'] :
if libdir not in unique_libdirs :
f.write('link_directories("{}")\n'.format(libdir))
unique_libdirs.append(libdir)
# add defines
for define in imported[imp_proj_name]['defines'] :
value = imported[imp_proj_name]['defines'][define]
if define not in unique_defines :
unique_defines[define] = value
if type(value) is str :
f.write('add_definitions(-D{}="{}")\n'.format(define, value))
else :
f.write('add_definitions(-D{}={})\n'.format(define, value))
# add import modules
if len(imported[imp_proj_name]['modules']) > 0 :
import_functions = []
# first add all module import functions
for module in imported[imp_proj_name]['modules'] :
module_path = imported[imp_proj_name]['modules'][module]
if module not in unique_modules :
unique_modules[module] = module_path
import_func = 'fips_import_{}'.format(module_path).replace('-','_')
import_functions.append(import_func)
f.write('macro({})\n'.format(import_func))
f.write(' set(FIPS_IMPORT 1)\n')
f.write(' add_subdirectory("{}" "{}")\n'.format(module, module_path))
f.write(' set(FIPS_IMPORT)\n')
f.write('endmacro()\n')
# if auto-import is enabled, also actually import all modules
f.write('if (FIPS_AUTO_IMPORT)\n')
group = "Imports"
if imported[imp_proj_name]['group'] :
group += "/" + imported[imp_proj_name]['group']
if len(imported[imp_proj_name]['modules']) > 3 :
group += "/" + imp_proj_name
f.write(' fips_ide_group("{}")\n'.format(group))
for import_func in import_functions :
f.write(' {}()\n'.format(import_func))
f.write(' fips_ide_group("")\n')
f.write('endif()\n')
if imported[imp_proj_name]['cond']:
f.write('endif()\n')
# check content of old and new file, only replace if changed
imports_dirty = True
if os.path.isfile(import_filename) :
if filecmp.cmp(import_filename, import_tmp_filename, shallow=False) :
imports_dirty = False
if imports_dirty :
if os.path.isfile(import_filename) :
os.remove(import_filename)
os.rename(import_tmp_filename, import_filename)
else :
os.remove(import_tmp_filename)
# write the .fips-imports.py file (copy from template)
gen_search_paths = '"{}","{}/generators",\n'.format(fips_dir, fips_dir)
proj_gen_dir = util.get_generators_dir(proj_dir)
if proj_gen_dir:
gen_search_paths += '"{}","{}",\n'.format(proj_dir, proj_gen_dir)
for imp_proj_name in imported :
gen_dir = util.get_generators_dir(util.get_project_dir(fips_dir, imp_proj_name))
if gen_dir:
gen_search_paths += '"' + gen_dir + '",\n'
proj_name = util.get_project_name_from_dir(proj_dir)
build_dir = util.get_build_dir(fips_dir, proj_name, cfg_name);
if not os.path.isdir(build_dir):
os.makedirs(build_dir)
template.copy_template_file(fips_dir, build_dir, 'fips-gen.py', { 'genpaths': gen_search_paths}, True)
