def deploy_webpage(fips_dir, proj_dir, webpage_dir) :
"""builds the final webpage under under fips-deploy/oryol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
deploy_dir = '{}/fips-deploy/yakc/yakc-emsc-make-release/'.format(ws_dir)
# webpage files
copy_tree(proj_dir+'/web/_site', webpage_dir)
# copy the application files
for name in ['yakcapp.js'] :
log.info('> copy file: {}'.format(name))
shutil.copy(deploy_dir + name, webpage_dir + '/' + name)
# copy kcc and tap files
for fname in glob.glob(proj_dir + '/files/*') :
log.info('> copy file: {}'.format(fname))
shutil.copy(fname, webpage_dir + '/' + os.path.basename(fname))
# if the virtualkc directory exists, copy everything there
# so that a simple git push is enough to upload
# the webpage
vkc_dir = '{}/virtualkc'.format(ws_dir)
if os.path.isdir(vkc_dir) :
log.info(">>> updating virtualkc repository")
copy_tree(webpage_dir, vkc_dir)
def build_deploy_webpage(fips_dir, proj_dir, rebuild):
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-webpage'.format(ws_dir)
if rebuild:
if os.path.isdir(webpage_dir):
shutil.rmtree(webpage_dir)
if not os.path.isdir(webpage_dir):
os.makedirs(webpage_dir)
# compile samples
if BuildEmscripten and emscripten.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, EmscConfig)
project.build(fips_dir, proj_dir, EmscConfig)
if BuildWasm and emscripten.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, WasmConfig)
project.build(fips_dir, proj_dir, WasmConfig)
# export sample assets
if ExportAssets:
export_assets(fips_dir, proj_dir, webpage_dir)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN,
'Generated Samples web page under {}.'.format(webpage_dir))
def _rec_update_imports(fips_dir, proj_dir, handled) :
"""same as _rec_fetch_imports() but for updating the imported projects
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled :
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW, "=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if os.path.isdir(dep_proj_dir) :
# directory did not exist, do a fresh git clone
dep = imports[dep_proj_name]
git_commit = None if 'rev' not in dep else dep['rev']
if git.has_local_changes(dep_proj_dir) :
log.warn(" '{}' has local changes, skipping...".format(dep_proj_dir))
else :
log.colored(log.BLUE, " updating '{}'...".format(dep_proj_dir))
git.update(dep_proj_dir)
if git_commit:
log.colored(log.YELLOW, "=== revision: '{}':".format(git_commit))
dep_ok = git.checkout(dep_proj_dir, git_commit)
else:
dep_ok = True
else :
log.warn(" '{}' does not exist, please run 'fips fetch'".format(dep_proj_dir))
# recuse
if dep_ok :
handled = _rec_update_imports(fips_dir, dep_proj_dir, handled)
# done, return the new handled array
return handled
def build_deploy_webpage(fips_dir, proj_dir):
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-webpage'.format(ws_dir)
if os.path.isdir(webpage_dir):
shutil.rmtree(webpage_dir)
os.makedirs(webpage_dir)
# compile emscripten, pnacl and android samples
if BuildEmscripten and emscripten.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, 'emsc-make-release')
project.build(fips_dir, proj_dir, 'emsc-make-release')
if BuildPNaCl and nacl.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, 'pnacl-make-release')
project.build(fips_dir, proj_dir, 'pnacl-make-release')
if BuildAndroid and android.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, 'android-make-release')
project.build(fips_dir, proj_dir, 'android-make-release')
# export sample assets
export_assets(fips_dir, proj_dir, webpage_dir)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN,
'Generated Samples web page under {}.'.format(webpage_dir))
def serve_webpage(fips_dir, proj_dir):
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/{}'.format(ws_dir, WebpageDeployDir)
p = util.get_host_platform()
if p == 'osx':
try:
subprocess.call('http-server -c-1 -g -o'.format(fips_dir),
cwd=webpage_dir,
shell=True)
except KeyboardInterrupt:
pass
elif p == 'win':
try:
subprocess.call('http-server -c-1 -g -o'.format(fips_dir),
cwd=webpage_dir,
shell=True)
except KeyboardInterrupt:
pass
elif p == 'linux':
try:
subprocess.call('http-server -c-1 -g -o'.format(fips_dir),
cwd=webpage_dir,
shell=True)
except KeyboardInterrupt:
pass
def serve_webpage(fips_dir, proj_dir) :
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/sokol-webpage'.format(ws_dir)
p = util.get_host_platform()
if p == 'osx' :
try :
subprocess.call(
'open http://localhost:8000 ; python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt :
pass
elif p == 'win':
try:
subprocess.call(
'cmd /c start http://localhost:8000 && python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt:
pass
elif p == 'linux':
try:
subprocess.call(
'xdg-open http://localhost:8000; python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt:
pass
def build_deploy_webpage(fips_dir, proj_dir) :
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-webpage'.format(ws_dir)
if os.path.isdir(webpage_dir) :
shutil.rmtree(webpage_dir)
os.makedirs(webpage_dir)
# compile emscripten, pnacl and android samples
if BuildEmscripten and emscripten.check_exists(fips_dir) :
project.gen(fips_dir, proj_dir, 'emsc-ninja-release')
project.build(fips_dir, proj_dir, 'emsc-ninja-release')
if BuildWasm and emscripten.check_exists(fips_dir) :
project.gen(fips_dir, proj_dir, 'wasm-ninja-release')
project.build(fips_dir, proj_dir, 'wasm-ninja-release')
if BuildPNaCl and nacl.check_exists(fips_dir) :
project.gen(fips_dir, proj_dir, 'pnacl-ninja-release')
project.build(fips_dir, proj_dir, 'pnacl-ninja-release')
# export sample assets
export_assets(fips_dir, proj_dir, webpage_dir)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Generated Samples web page under {}.'.format(webpage_dir))
def serve_webpage(fips_dir, proj_dir) :
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-webpage'.format(ws_dir)
p = util.get_host_platform()
if p == 'osx' :
try :
subprocess.call(
'open http://localhost:8000 ; python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt :
pass
elif p == 'win':
try:
subprocess.call(
'cmd /c start http://localhost:8000 && python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt:
pass
elif p == 'linux':
try:
subprocess.call(
'xdg-open http://localhost:8000; python {}/mod/httpserver.py'.format(fips_dir),
cwd = webpage_dir, shell=True)
except KeyboardInterrupt:
pass
def _rec_update_imports(fips_dir, proj_dir, handled) :
"""same as _rec_fetch_imports() but for updating the imported projects
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled :
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW, "=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if os.path.isdir(dep_proj_dir) :
# directory did not exist, do a fresh git clone
dep = imports[dep_proj_name]
git_commit = None if 'rev' not in dep else dep['rev']
if git.has_local_changes(dep_proj_dir) :
log.warn(" '{}' has local changes, skipping...".format(dep_proj_dir))
else :
log.colored(log.BLUE, " updating '{}'...".format(dep_proj_dir))
git.update(dep_proj_dir)
if git_commit:
log.colored(log.YELLOW, "=== revision: '{}':".format(git_commit))
dep_ok = git.checkout(dep_proj_dir, git_commit)
else:
dep_ok = True
else :
log.warn(" '{}' does not exist, please run 'fips fetch'".format(dep_proj_dir))
# recuse
if dep_ok :
handled = _rec_update_imports(fips_dir, dep_proj_dir, handled)
# done, return the new handled array
return handled
def deploy_webpage(fips_dir, proj_dir, webpage_dir):
"""builds the final webpage under under fips-deploy/oryol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
asmjs_dir = '{}/fips-deploy/yakc/yakc-emsc-make-release/'.format(ws_dir)
wasm_dir = '{}/fips-deploy/yakc/yakc-wasm-make-release/'.format(ws_dir)
# webpage files
copy_tree(proj_dir + '/web/_site', webpage_dir)
# copy the application files
shutil.copy(asmjs_dir + 'yakcapp.js', webpage_dir + '/yakcapp.js')
shutil.copy(wasm_dir + 'yakcapp.js', webpage_dir + '/yakcapp.wasm.js')
shutil.copy(wasm_dir + 'yakcapp.wasm', webpage_dir + '/yakcapp.wasm.txt')
# copy game/rom image files
for fname in glob.glob(proj_dir + '/files/*'):
if os.path.isfile(fname):
shutil.copy(fname, webpage_dir + '/' + os.path.basename(fname))
# if the virtualkc directory exists, copy everything there
# so that a simple git push is enough to upload
# the webpage
vkc_dir = '{}/virtualkc'.format(ws_dir)
if os.path.isdir(vkc_dir):
log.info(">>> updating virtualkc repository")
copy_tree(webpage_dir, vkc_dir)
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 copy_build_files(fips_dir, proj_dir, webpage_dir) :
# copy all files from the deploy dir to the webpage_dir
ws_dir = util.get_workspace_dir(fips_dir)
src_dir = '{}/fips-deploy/oryol-samples/wasmasmjs-make-release'.format(ws_dir)
dst_dir = webpage_dir
copy_tree(src_dir, dst_dir)
shutil.copy('{}/web/wasmsuite-readme.md'.format(proj_dir), '{}/README.md'.format(dst_dir))
shutil.copy('{}/LICENSE'.format(proj_dir), '{}/LICENSE'.format(dst_dir))
def _rec_get_all_imports_exports(fips_dir, proj_dir, result):
"""recursively get all imported projects, their exported and
imported modules in a dictionary object:
project-1:
url: git-url (not valid for first, top-level project)
exports:
header-dirs: [ ]
conditional-header-dirs:
dir: cmake-if condition string
lib-dirs: [ ]
defines:
def-key: def-val
...
modules :
mod: dir
mod: dir
...
imports:
name:
git: [git-url]
branch: [optional: branch or tag]
cond: [optional: cmake-if condition string conditionally including the dependency]
name:
...
...
...
:param fips_dir: absolute fips directory
:param proj_dir: absolute project directory
:param result: in/out current result
:returns: bool success, and modified result dictionary
"""
success = True
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in result:
imports = get_imports(fips_dir, proj_dir)
exports = get_exports(proj_dir)
for dep_proj_name in imports:
if dep_proj_name not in result:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
dep_url = imports[dep_proj_name]['git']
success, result = _rec_get_all_imports_exports(
fips_dir, dep_proj_dir, result)
# break recursion on error
if not success:
return success, result
result[proj_name] = {}
result[proj_name]['proj_dir'] = proj_dir
result[proj_name]['imports'] = imports
result[proj_name]['exports'] = exports
# done
return success, result
def _rec_get_all_imports_exports(fips_dir, proj_dir, result) :
"""recursively get all imported projects, their exported and
imported modules in a dictionary object:
project-1:
url: git-url (not valid for first, top-level project)
exports:
header-dirs: [ ]
lib-dirs: [ ]
defines:
def-key: def-val
...
modules :
mod: dir
mod: dir
...
imports:
name:
git: [git-url]
branch: [optional: branch or tag]
cond: [optional: cmake-if condition string conditionally including the dependency]
name:
...
...
...
:param fips_dir: absolute fips directory
:param proj_dir: absolute project directory
:param result: in/out current result
:returns: bool success, and modified result dictionary
"""
success = True
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in result :
imports = get_imports(fips_dir, proj_dir)
exports = get_exports(proj_dir)
for dep_proj_name in imports :
if dep_proj_name not in result :
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
dep_url = imports[dep_proj_name]['git']
success, result = _rec_get_all_imports_exports(fips_dir, dep_proj_dir, result)
# break recursion on error
if not success :
return success, result
result[proj_name] = {}
result[proj_name]['proj_dir'] = proj_dir
result[proj_name]['imports'] = imports
result[proj_name]['exports'] = exports
# done
return success, result
def view(fips_dir, proj_dir):
proj_name = util.get_project_name_from_dir(proj_dir)
out_dir = util.get_workspace_dir(fips_dir)+'/fips-deploy/'+proj_name+'-markdeep'
if os.path.isfile(out_dir+'/index.html'):
p = util.get_host_platform()
if p == 'osx':
subprocess.call('open index.html', cwd=out_dir, shell=True)
elif p == 'win':
subprocess.call('start index.html', cwd=out_dir, shell=True)
elif p == 'linux':
subprocess.call('xdg-open index.html', cwd=out_dir, shell=True)
else:
log.error('no generated index.html found: {}'.format(out_dir+'/index.html'))
def view(fips_dir, proj_dir):
proj_name = util.get_project_name_from_dir(proj_dir)
out_dir = util.get_workspace_dir(fips_dir)+'/fips-deploy/'+proj_name+'-markdeep'
if os.path.isfile(out_dir+'/index.html'):
p = util.get_host_platform()
if p == 'osx':
subprocess.call('open index.html', cwd=out_dir, shell=True)
elif p == 'win':
subprocess.call('start index.html', cwd=out_dir, shell=True)
elif p == 'linux':
subprocess.call('xdg-open index.html', cwd=out_dir, shell=True)
else:
log.error('no generated index.html found: {}'.format(out_dir+'/index.html'))
def _rec_fetch_imports(fips_dir, proj_dir, handled) :
"""internal recursive function to fetch project imports,
keeps an array of already handled dirs to break cyclic dependencies
:param proj_dir: current project directory
:param handled: array of already handled dirs
:returns: updated array of handled dirs
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled :
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW, "=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if not os.path.isdir(dep_proj_dir) :
# directory did not exist, do a fresh git clone
dep = imports[dep_proj_name]
git_commit = None if 'rev' not in dep else dep['rev']
if git_commit :
if 'depth' in dep :
# when using rev, we may not want depth because the revision may not be reachable
log.colored(log.YELLOW, "=== 'depth' was ignored because parameter 'rev' is specified.")
dep['depth'] = None
git_depth = git.clone_depth if not git_commit and 'depth' not in dep else dep['depth']
git_url = dep['git']
git_branch = dep['branch']
if git.clone(git_url, git_branch, git_depth, dep_proj_name, ws_dir) :
if git_commit :
log.colored(log.YELLOW, "=== revision: '{}':".format(git_commit))
dep_ok = git.checkout(dep_proj_dir, git_commit)
else :
dep_ok = True
else :
log.error('failed to git clone {} into {}'.format(git_url, dep_proj_dir))
else :
# directory already exists
log.info("dir '{}' exists".format(dep_proj_dir))
dep_ok = True
# recuse
if dep_ok :
handled = _rec_fetch_imports(fips_dir, dep_proj_dir, handled)
# done, return the new handled array
return handled
def _rec_fetch_imports(fips_dir, proj_dir, handled) :
"""internal recursive function to fetch project imports,
keeps an array of already handled dirs to break cyclic dependencies
:param proj_dir: current project directory
:param handled: array of already handled dirs
:returns: updated array of handled dirs
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled :
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW, "=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if not os.path.isdir(dep_proj_dir) :
# directory did not exist, do a fresh git clone
dep = imports[dep_proj_name]
git_commit = None if 'rev' not in dep else dep['rev']
if git_commit :
if 'depth' in dep :
# when using rev, we may not want depth because the revision may not be reachable
log.colored(log.YELLOW, "=== 'depth' was ignored because parameter 'rev' is specified.")
dep['depth'] = None
git_depth = git.clone_depth if not git_commit and 'depth' not in dep else dep['depth']
git_url = dep['git']
git_branch = dep['branch']
if git.clone(git_url, git_branch, git_depth, dep_proj_name, ws_dir) :
if git_commit :
log.colored(log.YELLOW, "=== revision: '{}':".format(git_commit))
dep_ok = git.checkout(dep_proj_dir, git_commit)
else :
dep_ok = True
else :
log.error('failed to git clone {} into {}'.format(git_url, dep_proj_dir))
else :
# directory already exists
log.info("dir '{}' exists".format(dep_proj_dir))
dep_ok = True
# recuse
if dep_ok :
handled = _rec_fetch_imports(fips_dir, dep_proj_dir, handled)
# done, return the new handled array
return handled
def build_deploy_webpage(fips_dir, proj_dir) :
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-wasm-buildsuite'.format(ws_dir)
if not os.path.exists(webpage_dir) :
os.makedirs(webpage_dir)
config = 'wasmasmjs-make-release'
project.clean(fips_dir, proj_dir, config)
project.gen(fips_dir, proj_dir, config)
for target in Samples :
project.build(fips_dir, proj_dir, config, target)
copy_build_files(fips_dir, proj_dir, webpage_dir)
if ExportAssets :
export_assets(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Done. ({})'.format(webpage_dir))
def build_deploy_webpage(fips_dir, proj_dir):
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/v6502r-webpage'.format(ws_dir)
if not os.path.isdir(webpage_dir):
os.makedirs(webpage_dir)
project.gen(fips_dir, proj_dir, BuildConfig)
project.build(fips_dir, proj_dir, BuildConfig)
src_dir = '{}/fips-deploy/v6502r/{}'.format(ws_dir, BuildConfig)
dst_dir = webpage_dir
shutil.copy(src_dir + '/v6502r.html', dst_dir + '/index.html')
shutil.copy(src_dir + '/v6502r.wasm', dst_dir + '/v6502r.wasm')
shutil.copy(src_dir + '/v6502r.js', dst_dir + '/v6502r.js')
log.colored(log.GREEN,
'Generated Samples web page under {}.'.format(webpage_dir))
def build_deploy_webpage(fips_dir, proj_dir, rebuild) :
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/chips-webpage'.format(ws_dir)
if rebuild :
if os.path.isdir(webpage_dir) :
shutil.rmtree(webpage_dir)
if not os.path.isdir(webpage_dir) :
os.makedirs(webpage_dir)
# compile samples
project.gen(fips_dir, proj_dir, BuildConfig)
project.build(fips_dir, proj_dir, BuildConfig)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Generated Samples web page under {}.'.format(webpage_dir))
def build_deploy_webpage(fips_dir, proj_dir, chip):
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/{}-webpage'.format(ws_dir, chip)
if not os.path.isdir(webpage_dir):
os.makedirs(webpage_dir)
project.gen(fips_dir, proj_dir, BuildConfig)
project.build(fips_dir, proj_dir, BuildConfig)
proj_name = util.get_project_name_from_dir(proj_dir)
util.ensure_valid_project_dir(proj_dir)
src_dir = '{}/fips-deploy/NextSim/{}'.format(ws_dir, BuildConfig)
dst_dir = webpage_dir
#This area can be cleaned up sometime
ns = "NextSim"
shutil.copy(src_dir + '/' + ns + '.html', dst_dir + '/index.html')
shutil.copy(src_dir + '/' + ns + '.wasm', dst_dir + '/' + ns + '.wasm')
shutil.copy(src_dir + '/' + ns + '.js', dst_dir + '/' + ns + '.js')
shutil.copy(proj_dir + '/src/res/favicon.png', dst_dir + '/favicon.png')
log.colored(log.GREEN,
'Generated Samples web page under {}.'.format(webpage_dir))
def _rec_fetch_imports(fips_dir, proj_dir, handled):
"""internal recursive function to fetch project imports,
keeps an array of already handled dirs to break cyclic dependencies
:param proj_dir: current project directory
:param handled: array of already handled dirs
:returns: updated array of handled dirs
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled:
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW,
"=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if not os.path.isdir(dep_proj_dir):
# directory did not exist, do a fresh git clone
git_url = imports[dep_proj_name]['git']
git_branch = imports[dep_proj_name]['branch']
if git.clone(git_url, git_branch, dep_proj_name, ws_dir):
dep_ok = True
else:
log.error('failed to git clone {} into {}'.format(
git_url, dep_proj_dir))
else:
# directory already exists
log.info("dir '{}' exists".format(dep_proj_dir))
dep_ok = True
# recuse
if dep_ok:
handled = _rec_fetch_imports(fips_dir, dep_proj_dir,
handled)
# done, return the new handled array
return handled
def build_deploy_webpage(fips_dir, proj_dir) :
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/yakc-webpage/virtualkc'.format(ws_dir)
if os.path.isdir(webpage_dir) :
shutil.rmtree(webpage_dir)
os.makedirs(webpage_dir)
# compile emscripten, pnacl and android samples
if emscripten.check_exists(fips_dir) :
project.gen(fips_dir, proj_dir, 'yakc-emsc-make-release')
project.build(fips_dir, proj_dir, 'yakc-emsc-make-release')
# build the webpage via jekyll
subprocess.call('jekyll build', cwd=proj_dir+'/web', shell=True)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Generated web page under {}.'.format(webpage_dir))
def build_deploy_webpage(fips_dir, proj_dir) :
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/oryol-samples-webpage'.format(ws_dir)
if os.path.isdir(webpage_dir) :
shutil.rmtree(webpage_dir)
os.makedirs(webpage_dir)
if emscripten.check_exists(fips_dir) :
project.gen(fips_dir, proj_dir, BuildConfig)
project.build(fips_dir, proj_dir, BuildConfig)
# export sample assets
if ExportAssets :
export_assets(fips_dir, proj_dir, webpage_dir)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Generated Samples web page under {}.'.format(webpage_dir))
def init(fips_dir, proj_name):
"""initialize an existing project directory as a fips directory by
copying essential files and creating or updating .gitignore
:param fips_dir: absolute path to fips
:param proj_name: project directory name (dir must exist)
:returns: True if the project was successfully initialized
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_dir = util.get_project_dir(fips_dir, proj_name)
if os.path.isdir(proj_dir):
templ_values = {'project': proj_name}
for f in ['CMakeLists.txt', 'fips', 'fips.cmd', 'fips.yml']:
template.copy_template_file(fips_dir, proj_dir, f, templ_values)
os.chmod(proj_dir + '/fips', 0o744)
gitignore_entries = ['.fips-*', '*.pyc', '.vscode/', '.idea/']
template.write_git_ignore(proj_dir, gitignore_entries)
else:
log.error("project dir '{}' does not exist".format(proj_dir))
return False
def _rec_fetch_imports(fips_dir, proj_dir, handled) :
"""internal recursive function to fetch project imports,
keeps an array of already handled dirs to break cyclic dependencies
:param proj_dir: current project directory
:param handled: array of already handled dirs
:returns: updated array of handled dirs
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_dir(proj_dir)
if proj_name not in handled :
handled.append(proj_name)
imports = get_imports(fips_dir, proj_dir)
for dep in imports:
dep_proj_name = dep
if dep not in handled:
dep_proj_dir = util.get_project_dir(fips_dir, dep_proj_name)
log.colored(log.YELLOW, "=== dependency: '{}':".format(dep_proj_name))
dep_ok = False
if not os.path.isdir(dep_proj_dir) :
# directory did not exist, do a fresh git clone
git_url = imports[dep_proj_name]['git']
git_branch = imports[dep_proj_name]['branch']
if git.clone(git_url, git_branch, dep_proj_name, ws_dir) :
dep_ok = True
else :
log.error('failed to git clone {} into {}'.format(git_url, dep_proj_dir))
else :
# directory already exists
log.info("dir '{}' exists".format(dep_proj_dir))
dep_ok = True
# recuse
if dep_ok :
handled = _rec_fetch_imports(fips_dir, dep_proj_dir, handled)
# done, return the new handled array
return handled
def build_deploy_webpage(fips_dir, proj_dir):
# if webpage dir exists, clear it first
ws_dir = util.get_workspace_dir(fips_dir)
webpage_dir = '{}/fips-deploy/yakc-webpage/virtualkc'.format(ws_dir)
if os.path.isdir(webpage_dir):
shutil.rmtree(webpage_dir)
os.makedirs(webpage_dir)
# compile
if emscripten.check_exists(fips_dir):
project.gen(fips_dir, proj_dir, 'yakc-emsc-make-release')
project.build(fips_dir, proj_dir, 'yakc-emsc-make-release')
project.gen(fips_dir, proj_dir, 'yakc-wasm-make-release')
project.build(fips_dir, proj_dir, 'yakc-wasm-make-release')
# build the webpage via jekyll
subprocess.call('jekyll build', cwd=proj_dir + '/web', shell=True)
# deploy the webpage
deploy_webpage(fips_dir, proj_dir, webpage_dir)
log.colored(log.GREEN, 'Generated web page under {}.'.format(webpage_dir))
def init(fips_dir, proj_name) :
"""initialize an existing project directory as a fips directory by
copying essential files and creating or updating .gitignore
:param fips_dir: absolute path to fips
:param proj_name: project directory name (dir must exist)
:returns: True if the project was successfully initialized
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_dir = util.get_project_dir(fips_dir, proj_name)
if os.path.isdir(proj_dir) :
templ_values = {
'project': proj_name
}
for f in ['CMakeLists.txt', 'fips', 'fips.cmd', 'fips.yml'] :
template.copy_template_file(fips_dir, proj_dir, f, templ_values)
os.chmod(proj_dir + '/fips', 0o744)
gitignore_entries = ['.fips-*', '*.pyc']
template.write_git_ignore(proj_dir, gitignore_entries)
else :
log.error("project dir '{}' does not exist".format(proj_dir))
return False
def deploy_webpage(fips_dir, proj_dir, webpage_dir) :
"""builds the final webpage under under fips-deploy/voxel-test-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# copy other required files
for name in ['style.css', 'emsc.js', 'favicon.png'] :
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/web/' + name, webpage_dir + '/' + name)
# generate emscripten HTML page
if emscripten.check_exists(fips_dir) :
emsc_deploy_dir = '{}/fips-deploy/voxel-test/emsc-ninja-release'.format(ws_dir)
name = 'VoxelTest'
log.info('> generate emscripten HTML page: {}'.format(name))
for ext in ['js', 'html.mem'] :
src_path = '{}/{}.{}'.format(emsc_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, webpage_dir)
with open(proj_dir + '/web/emsc.html', 'r') as f :
templ = Template(f.read())
html = templ.safe_substitute(name=name)
with open('{}/index.html'.format(webpage_dir), 'w') as f :
f.write(html)
def clone(fips_dir, url) :
"""clone an existing fips project with git, do NOT fetch dependencies
:param fips_dir: absolute path to fips
:param url: git url to clone from (may contain branch name separated by '#')
:return: True if project was successfully cloned
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_url(url)
proj_dir = util.get_project_dir(fips_dir, proj_name)
if not os.path.isdir(proj_dir) :
git_url = util.get_giturl_from_url(url)
git_branch = util.get_gitbranch_from_url(url)
if git.clone(git_url, git_branch, git.clone_depth, proj_name, ws_dir) :
# fetch imports
dep.fetch_imports(fips_dir, proj_dir)
return True
else :
log.error("failed to 'git clone {}' into '{}'".format(url, proj_dir))
return False
else :
log.error("project dir '{}' already exists".format(proj_dir))
return False
def clone(fips_dir, url) :
"""clone an existing fips project with git, do NOT fetch dependencies
:param fips_dir: absolute path to fips
:param url: git url to clone from (may contain branch name separated by '#')
:return: True if project was successfully cloned
"""
ws_dir = util.get_workspace_dir(fips_dir)
proj_name = util.get_project_name_from_url(url)
proj_dir = util.get_project_dir(fips_dir, proj_name)
if not os.path.isdir(proj_dir) :
git_url = util.get_giturl_from_url(url)
git_branch = util.get_gitbranch_from_url(url)
if git.clone(git_url, git_branch, proj_name, ws_dir) :
# fetch imports
dep.fetch_imports(fips_dir, proj_dir)
return True
else :
log.error("failed to 'git clone {}' into '{}'".format(url, proj_dir))
return False
else :
log.error("project dir '{}' already exists".format(proj_dir))
return False
def deploy_webpage(fips_dir, proj_dir, webpage_dir):
"""builds the final webpage under under fips-deploy/oryol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# load the websamples.yml file, should have been created during the last build
with open(webpage_dir + '/websamples.yml', 'r') as f:
samples = yaml.load(f.read())
# build the thumbnail gallery
content = ''
for sample in samples:
if sample['name'] != '__end__':
name = sample['name']
imgPath = sample['image']
types = sample['type']
desc = sample['desc']
head, tail = os.path.split(imgPath)
if tail == 'none':
imgFileName = 'dummy.jpg'
else:
imgFileName = tail
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(name)
content += ' <div class="img-frame"><a href="{}.html"><img class="image" src="{}" title="{}"></img></a></div>\n'.format(
name, imgFileName, desc)
content += ' <div class="thumb-bar">\n'
content += ' <ul class="thumb-list">\n'
if 'emscripten' in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}.html">emsc</a></li>\n'.format(
name)
if 'pnacl' in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}_pnacl.html">pnacl</a></li>\n'.format(
name)
if 'android' in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}-debug.apk">apk</a></li>\n'.format(
name)
content += ' </ul>\n'
content += ' </div>\n'
content += '</div>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/web/index.html', 'r') as f:
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + '/index.html', 'w') as f:
f.write(html)
# copy other required files
for name in [
'style.css', 'dummy.jpg', 'emsc.js', 'pnacl.js', 'about.html',
'favicon.png'
]:
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/web/' + name, webpage_dir + '/' + name)
# generate emscripten HTML pages
if BuildEmscripten and emscripten.check_exists(fips_dir):
emsc_deploy_dir = '{}/fips-deploy/oryol/emsc-make-release'.format(
ws_dir)
for sample in samples:
name = sample['name']
if name != '__end__' and 'emscripten' in sample['type']:
log.info('> generate emscripten HTML page: {}'.format(name))
for ext in ['js', 'html.mem']:
src_path = '{}/{}.{}'.format(emsc_deploy_dir, name, ext)
if os.path.isfile(src_path):
shutil.copy(src_path, webpage_dir)
with open(proj_dir + '/web/emsc.html', 'r') as f:
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src']
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/{}.html'.format(webpage_dir, name), 'w') as f:
f.write(html)
# copy PNaCl HTML pages
if BuildPNaCl and nacl.check_exists(fips_dir):
pnacl_deploy_dir = '{}/fips-deploy/oryol/pnacl-make-release'.format(
ws_dir)
for sample in samples:
name = sample['name']
if name != '__end__' and 'pnacl' in sample['type']:
log.info('> generate PNaCl HTML page: {}'.format(name))
for ext in ['nmf', 'pexe']:
shutil.copy('{}/{}.{}'.format(pnacl_deploy_dir, name, ext),
webpage_dir)
with open(proj_dir + '/web/pnacl.html', 'r') as f:
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src']
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/{}_pnacl.html'.format(webpage_dir, name),
'w') as f:
f.write(html)
# copy the screenshots
for sample in samples:
if sample['name'] != '__end__':
img_path = sample['image']
head, tail = os.path.split(img_path)
if tail != 'none':
log.info('> copy screenshot: {}'.format(tail))
shutil.copy(img_path, webpage_dir + '/' + tail)
# copy the Android sample files over
if BuildAndroid and android.check_exists(fips_dir):
android_deploy_dir = '{}/fips-deploy/oryol/android-make-release'.format(
ws_dir)
for sample in samples:
if sample['name'] != '__end__' and 'android' in sample['type']:
log.info('> copy android sample files: {}'.format(
sample['name']))
shutil.copy(
'{}/{}-debug.apk'.format(android_deploy_dir,
sample['name']), webpage_dir)
def build(fips_dir, proj_dir):
# target directory will be 'fips-deploy/[proj]-markdeep
proj_name = util.get_project_name_from_dir(proj_dir)
out_dir = util.get_workspace_dir(
fips_dir) + '/fips-deploy/' + proj_name + '-markdeep'
log.info('building to: {}...'.format(out_dir))
if os.path.isdir(out_dir):
shutil.rmtree(out_dir)
os.makedirs(out_dir)
# check all .h files for embedded documentation
hdrs = []
for root, dirnames, filenames in os.walk(proj_dir):
for filename in fnmatch.filter(filenames, '*.h'):
hdrs.append(os.path.join(root, filename).replace('\\', '/'))
markdeep_files = []
capture_begin = re.compile(r'/\*#\s')
for hdr in hdrs:
log.info(' parsing {}'.format(hdr))
capturing = False
markdeep_lines = []
with open(hdr, 'r') as src:
lines = src.readlines()
for line in lines:
if "#*/" in line and capturing:
capturing = False
if capturing:
# remove trailing tab
if line.startswith(' '):
line = line[4:]
elif line.startswith('\t'):
line = line[1:]
markdeep_lines.append(line)
if capture_begin.match(line) and not capturing:
capturing = True
if markdeep_lines:
markdeep_files.append(hdr)
dst_path = out_dir + '/' + os.path.relpath(hdr, proj_dir) + '.html'
log.info(
' markdeep block(s) found, writing: {}'.format(dst_path))
dst_dir = os.path.dirname(dst_path)
if not os.path.isdir(dst_dir):
os.makedirs(dst_dir)
with open(dst_path, 'w') as dst:
dst.write(
"<meta charset='utf-8' emacsmode='-*- markdown -*-'>\n")
dst.write(
"<link rel='stylesheet' href='https://casual-effects.com/markdeep/latest/apidoc.css?'>\n"
)
for line in markdeep_lines:
dst.write(line)
dst.write(
"<script>markdeepOptions={tocStyle:'medium'};</script>")
dst.write(
"<!-- Markdeep: --><script src='https://casual-effects.com/markdeep/latest/markdeep.min.js?'></script>"
)
# write a toplevel index.html
if markdeep_files:
markdeep_files = sorted(markdeep_files)
dst_path = out_dir + '/index.html'
log.info('writing toc file: {}'.format(dst_path))
with open(dst_path, 'w') as dst:
dst.write("<meta charset='utf-8' emacsmode='-*- markdown -*-'>\n")
dst.write(
"<link rel='stylesheet' href='https://casual-effects.com/markdeep/latest/apidoc.css?'>\n"
)
dst.write('# {}\n'.format(proj_name))
for hdr in markdeep_files:
rel_path = os.path.relpath(hdr, proj_dir)
dst.write('- [{}]({})\n'.format(rel_path, rel_path + '.html'))
dst.write("<script>markdeepOptions={tocStyle:'medium'};</script>")
dst.write(
"<!-- Markdeep: --><script src='https://casual-effects.com/markdeep/latest/markdeep.min.js?'></script>"
)
else:
log.error("no headers with embedded markdeep found in '{}'!".format(
proj_dir))
def deploy_webpage(fips_dir, proj_dir, webpage_dir) :
"""builds the final webpage under under fips-deploy/oryol-samples-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# load the websamples.yml file, should have been created during the last build
with open(webpage_dir + '/websamples.yml', 'r') as f :
samples = yaml.load(f.read())
# create directories
for platform in ['wasm'] :
platform_dir = '{}/{}'.format(webpage_dir, platform)
if not os.path.isdir(platform_dir) :
os.makedirs(platform_dir)
# link to the Core Samples
content = '<div class="thumb">\n'
content += ' <div class="thumb-title">To Core Samples...</div>\n'
content += ' <div class="img-frame"><a href="http://floooh.github.com/oryol/index.html"><img class="image" src="core_samples.jpg"></img></a></div>\n'
content += '</div>\n'
# build the thumbnail gallery
for sample in samples :
if sample['name'] != '__end__' :
name = sample['name']
imgPath = sample['image']
types = sample['type']
desc = sample['desc']
head, tail = os.path.split(imgPath)
if tail == 'none' :
imgFileName = 'dummy.jpg'
else :
imgFileName = tail
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(name)
content += ' <div class="img-frame"><a href="wasm/{}.html"><img class="image" src="{}" title="{}"></img></a></div>\n'.format(name,imgFileName,desc)
content += '</div>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/web/index.html', 'r') as f :
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + '/index.html', 'w') as f :
f.write(html)
# copy other required files
for name in ['style.css', 'dummy.jpg', 'emsc.js', 'favicon.png', 'core_samples.jpg'] :
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/web/' + name, webpage_dir + '/' + name)
# generate WebAssembly HTML pages
if emscripten.check_exists(fips_dir) :
wasm_deploy_dir = '{}/fips-deploy/oryol-samples/{}'.format(ws_dir, BuildConfig)
for sample in samples :
name = sample['name']
if name != '__end__' and 'emscripten' in sample['type'] :
log.info('> generate wasm HTML page: {}'.format(name))
for ext in ['js', 'wasm'] :
src_path = '{}/{}.{}'.format(wasm_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/wasm/'.format(webpage_dir))
with open(proj_dir + '/web/wasm.html', 'r') as f :
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src'];
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/wasm/{}.html'.format(webpage_dir, name), 'w') as f :
f.write(html)
# copy the screenshots
for sample in samples :
if sample['name'] != '__end__' :
img_path = sample['image']
head, tail = os.path.split(img_path)
if tail != 'none' :
log.info('> copy screenshot: {}'.format(tail))
shutil.copy(img_path, webpage_dir + '/' + tail)
def get_sdk_dir(fips_dir) :
return util.get_workspace_dir(fips_dir) + '/fips-sdks/' + util.get_host_platform()
def get_sdk_dir(fips_dir) :
"""return the platform-specific SDK dir"""
return util.get_workspace_dir(fips_dir) + '/fips-sdks/' + util.get_host_platform()
def deploy_webpage(fips_dir, proj_dir, webpage_dir):
"""builds the final webpage under under fips-deploy/chips-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# build the thumbnail gallery
content = ''
for item in items:
title = item['title']
system = item['system']
url = item['url']
image = item['img']
note = item['note']
log.info('> adding thumbnail for {}'.format(url))
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(title)
content += ' <div class="img-frame"><a href="{}"><img class="image" src="{}"></img></a></div>\n'.format(
url, image)
content += ' <div class="thumb-bar">{}</div>\n'.format(note)
content += '</div>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/webpage/index.html', 'r') as f:
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + '/index.html', 'w') as f:
f.write(html)
# and the same with the CSS template
with open(proj_dir + '/webpage/style.css', 'r') as f:
templ = Template(f.read())
css = templ.safe_substitute()
with open(webpage_dir + '/style.css', 'w') as f:
f.write(css)
# copy other required files
for name in ['emsc.js', 'favicon.png', 'help.html']:
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/webpage/' + name, webpage_dir + '/' + name)
# generate emu HTML pages
emsc_deploy_dir = '{}/fips-deploy/chips-test/{}'.format(
ws_dir, BuildConfig)
for item in items:
if item['type'] != 'emu':
continue
name = os.path.splitext(item['url'])[0]
title = item['title']
log.info('> generate emscripten HTML page: {}'.format(name))
for ext in ['wasm', 'js']:
src_path = '{}/{}.{}'.format(emsc_deploy_dir, name, ext)
if os.path.isfile(src_path):
shutil.copy(src_path, '{}/'.format(webpage_dir))
with open(proj_dir + '/webpage/emsc.html', 'r') as f:
templ = Template(f.read())
src_url = GitHubSamplesURL + name
html = templ.safe_substitute(name=title, prog=name, source=src_url)
with open('{}/{}.html'.format(webpage_dir, name), 'w') as f:
f.write(html)
# copy data files and images
for system in systems:
src_dir = proj_dir + '/webpage/' + system
if os.path.exists(src_dir):
dst_dir = webpage_dir + '/' + system
if os.path.isdir(dst_dir):
shutil.rmtree(dst_dir)
shutil.copytree(src_dir, dst_dir)
def get_sdk_dir(fips_dir) :
return util.get_workspace_dir(fips_dir) + '/fips-sdks/android'
def deploy_webpage(fips_dir, proj_dir, webpage_dir) :
"""builds the final webpage under under fips-deploy/oryol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# load the websamples.yml file, should have been created during the last build
with open(webpage_dir + '/websamples.yml', 'r') as f :
samples = yaml.load(f.read())
# create directories
for platform in ['asmjs', 'wasm', 'pnacl'] :
platform_dir = '{}/{}'.format(webpage_dir, platform)
if not os.path.isdir(platform_dir) :
os.makedirs(platform_dir)
# build the thumbnail gallery
content = ''
for sample in samples :
if sample['name'] != '__end__' :
name = sample['name']
imgPath = sample['image']
types = sample['type']
desc = sample['desc']
head, tail = os.path.split(imgPath)
if tail == 'none' :
imgFileName = 'dummy.jpg'
else :
imgFileName = tail
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(name)
content += ' <div class="img-frame"><a href="asmjs/{}.html"><img class="image" src="{}" title="{}"></img></a></div>\n'.format(name,imgFileName,desc)
content += ' <div class="thumb-bar">\n'
content += ' <ul class="thumb-list">\n'
if 'emscripten' in types :
content += ' <li class="thumb-item"><a class="thumb-link" href="asmjs/{}.html">asm.js</a></li>\n'.format(name)
if 'pnacl' in types :
content += ' <li class="thumb-item"><a class="thumb-link" href="pnacl/{}.html">pnacl</a></li>\n'.format(name)
if 'emscripten' in types :
content += ' <li class="thumb-item"><a class="thumb-link" href="wasm/{}.html">wasm</a></li>\n'.format(name)
content += ' </ul>\n'
content += ' </div>\n'
content += '</div>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/web/index.html', 'r') as f :
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + '/index.html', 'w') as f :
f.write(html)
# copy other required files
for name in ['style.css', 'dummy.jpg', 'emsc.js', 'pnacl.js', 'wasm.js', 'about.html', 'favicon.png'] :
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/web/' + name, webpage_dir + '/' + name)
# generate emscripten HTML pages
if BuildEmscripten and emscripten.check_exists(fips_dir) :
emsc_deploy_dir = '{}/fips-deploy/oryol/emsc-ninja-release'.format(ws_dir)
for sample in samples :
name = sample['name']
if name != '__end__' and 'emscripten' in sample['type'] :
log.info('> generate emscripten HTML page: {}'.format(name))
for ext in ['js', 'html.mem'] :
src_path = '{}/{}.{}'.format(emsc_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/asmjs/'.format(webpage_dir))
with open(proj_dir + '/web/emsc.html', 'r') as f :
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src'];
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/asmjs/{}.html'.format(webpage_dir, name, name), 'w') as f :
f.write(html)
# generate WebAssembly HTML pages
if BuildWasm and emscripten.check_exists(fips_dir) :
wasm_deploy_dir = '{}/fips-deploy/oryol/wasm-ninja-release'.format(ws_dir)
for sample in samples :
name = sample['name']
if name != '__end__' and 'emscripten' in sample['type'] :
log.info('> generate wasm HTML page: {}'.format(name))
for ext in ['js', 'wasm.mappedGlobals'] :
src_path = '{}/{}.{}'.format(wasm_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/wasm/'.format(webpage_dir))
for ext in ['html.mem', 'wasm'] :
src_path = '{}/{}.{}'.format(wasm_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/wasm/{}.{}.txt'.format(webpage_dir, name, ext))
with open(proj_dir + '/web/wasm.html', 'r') as f :
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src'];
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/wasm/{}.html'.format(webpage_dir, name), 'w') as f :
f.write(html)
# generate PNaCl HTML pages
if BuildPNaCl and nacl.check_exists(fips_dir) :
pnacl_deploy_dir = '{}/fips-deploy/oryol/pnacl-ninja-release'.format(ws_dir)
for sample in samples :
name = sample['name']
if name != '__end__' and 'pnacl' in sample['type'] :
log.info('> generate PNaCl HTML page: {}'.format(name))
for ext in ['nmf', 'pexe'] :
src_path = '{}/{}.{}'.format(pnacl_deploy_dir, name, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/pnacl/'.format(webpage_dir))
with open(proj_dir + '/web/pnacl.html', 'r') as f :
templ = Template(f.read())
src_url = GitHubSamplesURL + sample['src'];
html = templ.safe_substitute(name=name, source=src_url)
with open('{}/pnacl/{}.html'.format(webpage_dir, name), 'w') as f :
f.write(html)
# copy the screenshots
for sample in samples :
if sample['name'] != '__end__' :
img_path = sample['image']
head, tail = os.path.split(img_path)
if tail != 'none' :
log.info('> copy screenshot: {}'.format(tail))
shutil.copy(img_path, webpage_dir + '/' + tail)
def deploy_webpage(fips_dir, proj_dir, webpage_dir):
"""builds the final webpage under under fips-deploy/oryol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
# load the websamples.yml file, should have been created during the last build
with open(webpage_dir + "/websamples.yml", "r") as f:
samples = yaml.load(f.read())
# build the thumbnail gallery
content = ""
for sample in samples:
if sample["name"] != "__end__":
name = sample["name"]
imgPath = sample["image"]
types = sample["type"]
desc = sample["desc"]
head, tail = os.path.split(imgPath)
if tail == "none":
imgFileName = "dummy.jpg"
else:
imgFileName = tail
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(name)
content += ' <div class="img-frame"><a href="{}.html"><img class="image" src="{}" title="{}"></img></a></div>\n'.format(
name, imgFileName, desc
)
content += ' <div class="thumb-bar">\n'
content += ' <ul class="thumb-list">\n'
if "emscripten" in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}.html">emsc</a></li>\n'.format(
name
)
if "pnacl" in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}_pnacl.html">pnacl</a></li>\n'.format(
name
)
if "android" in types:
content += ' <li class="thumb-item"><a class="thumb-link" href="{}-debug.apk">apk</a></li>\n'.format(
name
)
content += " </ul>\n"
content += " </div>\n"
content += "</div>\n"
# populate the html template, and write to the build directory
with open(proj_dir + "/web/index.html", "r") as f:
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + "/index.html", "w") as f:
f.write(html)
# copy other required files
for name in ["style.css", "dummy.jpg", "emsc.js", "pnacl.js", "about.html", "favicon.png"]:
log.info("> copy file: {}".format(name))
shutil.copy(proj_dir + "/web/" + name, webpage_dir + "/" + name)
# generate emscripten HTML pages
if BuildEmscripten and emscripten.check_exists(fips_dir):
emsc_deploy_dir = "{}/fips-deploy/oryol/emsc-ninja-release".format(ws_dir)
for sample in samples:
name = sample["name"]
if name != "__end__" and "emscripten" in sample["type"]:
log.info("> generate emscripten HTML page: {}".format(name))
for ext in ["js", "html.mem"]:
src_path = "{}/{}.{}".format(emsc_deploy_dir, name, ext)
if os.path.isfile(src_path):
shutil.copy(src_path, webpage_dir)
with open(proj_dir + "/web/emsc.html", "r") as f:
templ = Template(f.read())
src_url = GitHubSamplesURL + sample["src"]
html = templ.safe_substitute(name=name, source=src_url)
with open("{}/{}.html".format(webpage_dir, name), "w") as f:
f.write(html)
# copy PNaCl HTML pages
if BuildPNaCl and nacl.check_exists(fips_dir):
pnacl_deploy_dir = "{}/fips-deploy/oryol/pnacl-ninja-release".format(ws_dir)
for sample in samples:
name = sample["name"]
if name != "__end__" and "pnacl" in sample["type"]:
log.info("> generate PNaCl HTML page: {}".format(name))
for ext in ["nmf", "pexe"]:
shutil.copy("{}/{}.{}".format(pnacl_deploy_dir, name, ext), webpage_dir)
with open(proj_dir + "/web/pnacl.html", "r") as f:
templ = Template(f.read())
src_url = GitHubSamplesURL + sample["src"]
html = templ.safe_substitute(name=name, source=src_url)
with open("{}/{}_pnacl.html".format(webpage_dir, name), "w") as f:
f.write(html)
# copy the screenshots
for sample in samples:
if sample["name"] != "__end__":
img_path = sample["image"]
head, tail = os.path.split(img_path)
if tail != "none":
log.info("> copy screenshot: {}".format(tail))
shutil.copy(img_path, webpage_dir + "/" + tail)
# copy the Android sample files over
if BuildAndroid and android.check_exists(fips_dir):
android_deploy_dir = "{}/fips-deploy/oryol/android-ninja-release".format(ws_dir)
for sample in samples:
if sample["name"] != "__end__" and "android" in sample["type"]:
log.info("> copy android sample files: {}".format(sample["name"]))
shutil.copy("{}/{}-debug.apk".format(android_deploy_dir, sample["name"]), webpage_dir)
def deploy_webpage(fips_dir, proj_dir, webpage_dir) :
"""builds the final webpage under under fips-deploy/sokol-webpage"""
ws_dir = util.get_workspace_dir(fips_dir)
wasm_deploy_dir = '{}/fips-deploy/sokol-samples/{}'.format(ws_dir, BuildConfig)
# create directories
for platform in ['wasm'] :
platform_dir = '{}/{}'.format(webpage_dir, platform)
if not os.path.isdir(platform_dir) :
os.makedirs(platform_dir)
# build the thumbnail gallery
content = ''
for sample in samples :
name = sample[0]
log.info('> adding thumbnail for {}'.format(name))
url = "wasm/{}-sapp.html".format(name)
ui_url = "wasm/{}-sapp-ui.html".format(name)
img_name = name + '.jpg'
img_path = proj_dir + '/webpage/' + img_name
if not os.path.exists(img_path):
img_name = 'dummy.jpg'
img_path = proj_dir + 'webpage/dummy.jpg'
content += '<div class="thumb">\n'
content += ' <div class="thumb-title">{}</div>\n'.format(name)
if os.path.exists(wasm_deploy_dir + '/' + name + '-sapp-ui.js'):
content += '<a class="img-btn-link" href="{}"><div class="img-btn">UI</div></a>'.format(ui_url)
content += ' <div class="img-frame"><a href="{}"><img class="image" src="{}"></img></a></div>\n'.format(url,img_name)
content += '</div>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/webpage/index.html', 'r') as f :
templ = Template(f.read())
html = templ.safe_substitute(samples=content)
with open(webpage_dir + '/index.html', 'w') as f :
f.write(html)
# copy other required files
for name in ['dummy.jpg', 'favicon.png'] :
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/webpage/' + name, webpage_dir + '/' + name)
# generate WebAssembly HTML pages
if emscripten.check_exists(fips_dir) :
for sample in samples :
name = sample[0]
source = sample[1]
log.info('> generate wasm HTML page: {}'.format(name))
for postfix in ['sapp', 'sapp-ui']:
for ext in ['wasm', 'js'] :
src_path = '{}/{}-{}.{}'.format(wasm_deploy_dir, name, postfix, ext)
if os.path.isfile(src_path) :
shutil.copy(src_path, '{}/wasm/'.format(webpage_dir))
with open(proj_dir + '/webpage/wasm.html', 'r') as f :
templ = Template(f.read())
src_url = GitHubSamplesURL + source
html = templ.safe_substitute(name=name, prog=name+'-'+postfix, source=src_url)
with open('{}/wasm/{}-{}.html'.format(webpage_dir, name, postfix), 'w') as f :
f.write(html)
# copy the screenshots
for sample in samples :
img_name = sample[0] + '.jpg'
img_path = proj_dir + '/webpage/' + img_name
if os.path.exists(img_path):
log.info('> copy screenshot: {}'.format(img_name))
shutil.copy(img_path, webpage_dir + '/' + img_name)
def get_sdk_dir(fips_dir) :
"""return the platform-specific SDK dir"""
return util.get_workspace_dir(fips_dir) + '/fips-sdks/' + util.get_host_platform()
def deploy_webpage(fips_dir, proj_dir, webpage_dir):
"""builds the final webpage under under fips-deploy/learnopengl-examples"""
ws_dir = util.get_workspace_dir(fips_dir)
wasm_deploy_dir = '{}/fips-deploy/learnopengl-examples/{}'.format(
ws_dir, BuildConfig)
# create directories
if not os.path.exists(webpage_dir):
os.makedirs(webpage_dir)
# build the thumbnail gallery
content = ''
for chapter in items:
chapter_title = chapter[0]
lessons = chapter[1]
content += '<h2>{}</i></h2>\n'.format(chapter_title)
for lesson in lessons:
lesson_title = lesson[0]
lesson_link = lesson[1]
examples = lesson[3]
content += '<article>\n'
content += '<section class="header"><h3><a href="{}">{} <i class="icon-link-ext"></i></a></h3></section>\n'.format(
lesson_link, lesson_title)
content += '<section class="group examples">\n'
for example in examples:
name = example[0]
filename = example[1]
log.info('> adding thumbnail for {}'.format(filename))
url = "{}.html".format(filename)
img_name = filename + '.jpg'
img_path = proj_dir + '/webpage/' + img_name
if not os.path.exists(img_path):
img_name = 'dummy.jpg'
img_path = proj_dir + 'webpage/dummy.jpg'
content += '<figure class="col-15">\n'
content += '<figcaption><h4>{}</h4></figcaption>\n'.format(
name)
content += '<div><img class="responsive" src="{}" alt=""></div>\n'.format(
img_name)
content += '<a href="{}">Read More</a>\n'.format(url)
content += '</figure>\n'
content += '</section>\n'
content += '</article>\n'
content += '<hr>\n'
# populate the html template, and write to the build directory
with open(proj_dir + '/webpage/index.html', 'r') as f:
templ = Template(f.read())
html = templ.safe_substitute(
samples=content, date=datetime.date.today().strftime("%B %d %Y"))
with open(webpage_dir + '/index.html', 'w') as f:
f.write(html)
# copy other required files
for name in [
'dummy.jpg', 'favicon.png', 'fontello.woff', 'fontello.woff2'
]:
log.info('> copy file: {}'.format(name))
shutil.copy(proj_dir + '/webpage/' + name, webpage_dir + '/' + name)
# generate WebAssembly HTML pages
if emscripten.check_exists(fips_dir):
for chapter in items:
lessons = chapter[1]
for lesson in lessons:
dir = lesson[2]
examples = lesson[3]
for example in examples:
filename = example[1]
source = example[2]
glsl = example[3]
log.info('> generate wasm HTML page: {}'.format(filename))
for ext in ['wasm', 'js']:
src_path = '{}/{}.{}'.format(wasm_deploy_dir, filename,
ext)
if os.path.isfile(src_path):
shutil.copy(src_path, '{}/'.format(webpage_dir))
with open(proj_dir + '/webpage/wasm.html', 'r') as f:
templ = Template(f.read())
src_url = '{}/{}/{}'.format(GitHubExamplesURL, dir,
source)
if glsl is None:
glsl_url = "."
glsl_hidden = "hidden"
else:
glsl_url = '{}/{}/{}'.format(
GitHubExamplesURL, dir, glsl)
glsl_hidden = ""
html = templ.safe_substitute(name=filename,
prog=filename,
source=src_url,
glsl=glsl_url,
hidden=glsl_hidden)
with open('{}/{}.html'.format(webpage_dir, filename),
'w') as f:
f.write(html)
# copy assets from deploy directory
for asset in assets:
log.info('> copy asset file: {}'.format(asset))
src_path = '{}/{}'.format(wasm_deploy_dir, asset)
if os.path.isfile(src_path):
shutil.copy(src_path, webpage_dir)
# copy the screenshots
for chapter in items:
lessons = chapter[1]
for lesson in lessons:
examples = lesson[3]
for example in examples:
img_name = example[1] + '.jpg'
img_path = proj_dir + '/webpage/' + img_name
if os.path.exists(img_path):
log.info('> copy screenshot: {}'.format(img_name))
shutil.copy(img_path, webpage_dir + '/' + img_name)
def gather_imports(fips_dir, proj_dir) :
"""resolve imports of proj_dir and returns a big dictionary
with all imported data, which can then be written with write_imports()
:param fips_dir: absolute fips directory
:param proj_dir: absolute project directory
:param dry_run: if true perform a dry run (used by 'fips diag')
:returns: a big dictionary which can be written with write_imports()
or None on error
"""
imported = OrderedDict()
ws_dir = util.get_workspace_dir(fips_dir)
success, deps = get_all_imports_exports(fips_dir, proj_dir)
unique_defines = {}
unique_modules = {}
if success :
# for each project:
for proj_name in deps :
imports = deps[proj_name]['imports']
exports = deps[proj_name]['exports']
# for each imported project:
for imp_proj_name in imports :
imported[imp_proj_name] = {}
imported[imp_proj_name]['modules'] = OrderedDict()
imported[imp_proj_name]['hdrdirs'] = []
imported[imp_proj_name]['libdirs'] = []
imported[imp_proj_name]['defines'] = {}
# add header search paths
for imp_hdr in deps[imp_proj_name]['exports']['header-dirs'] :
hdr_path = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_hdr)
if not os.path.isdir(hdr_path) :
log.warn("header search path '{}' not found in project '{}'".format(hdr_path, imp_proj_name))
imported[imp_proj_name]['hdrdirs'].append(hdr_path)
# add lib search paths
for imp_lib in deps[imp_proj_name]['exports']['lib-dirs'] :
lib_path = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_lib)
if not os.path.isdir(lib_path) :
log.warn("lib search path '{}' not found in project '{}'".format(lib_path, imp_proj_name))
imported[imp_proj_name]['libdirs'].append(lib_path)
# add defines
for imp_def in deps[imp_proj_name]['exports']['defines'] :
# hmm, no check whether this define collides with an earlier define...
value = deps[imp_proj_name]['exports']['defines'][imp_def]
imported[imp_proj_name]['defines'][imp_def] = value
if imp_def in unique_defines :
if unique_defines[imp_def] != value :
log.warn("C define collision: '{}={}' in '{}' collides with '{}={}' in earlier import".format(
imp_def, value, imp_proj_name, imp_def, unique_defines[define]))
unique_defines[imp_def] = value
# for each imported module:
for imp_mod in deps[imp_proj_name]['exports']['modules'] :
imp_mod_src = deps[imp_proj_name]['exports']['modules'][imp_mod]
# import module source directory (where module's CMakeLists.txt is)
src_dir = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_mod_src)
# cmake build subdirectory
build_dir = '{}_{}'.format(imp_proj_name, imp_mod)
imported[imp_proj_name]['modules'][src_dir] = build_dir
if imp_mod in unique_modules :
if unique_modules[imp_mod] != src_dir :
log.warn("Import module '{}=>{}' in '{}' collides with '{}=>{}' in earlier import".format(
imp_mod, src_dir, imp_proj_name, imp_mod, unique_modules[imp_mod]))
unique_modules[imp_mod] = src_dir
# NOTE: return the imports in reversed order, so that for instance header paths
# are defined before the modules that need the header paths
reverseImported = OrderedDict()
for entry in reversed(imported) :
reverseImported[entry] = imported[entry]
return reverseImported
else :
log.warn("imports are incomplete, please run 'fips fetch'")
return None
def gather_imports(fips_dir, proj_dir) :
"""resolve imports of proj_dir and returns a big dictionary
with all imported data, which can then be written with write_imports()
:param fips_dir: absolute fips directory
:param proj_dir: absolute project directory
:param dry_run: if true perform a dry run (used by 'fips diag')
:returns: a big dictionary which can be written with write_imports()
or None on error
"""
imported = OrderedDict()
ws_dir = util.get_workspace_dir(fips_dir)
success, deps = get_all_imports_exports(fips_dir, proj_dir)
unique_defines = {}
unique_modules = {}
if success :
# for each project:
for proj_name in deps :
imports = deps[proj_name]['imports']
exports = deps[proj_name]['exports']
# for each imported project:
for imp_proj_name in sorted(imports) :
imported[imp_proj_name] = {}
imported[imp_proj_name]['modules'] = OrderedDict()
imported[imp_proj_name]['hdrdirs'] = []
imported[imp_proj_name]['condhdrdirs'] = {}
imported[imp_proj_name]['libdirs'] = []
imported[imp_proj_name]['defines'] = {}
imported[imp_proj_name]['cond'] = imports[imp_proj_name]['cond']
imported[imp_proj_name]['group'] = imports[imp_proj_name]['group']
# add header search paths
for imp_hdr in deps[imp_proj_name]['exports']['header-dirs'] :
hdr_path = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_hdr)
hdr_path = os.path.normpath(hdr_path).replace('\\', '/')
if not os.path.isdir(hdr_path) :
log.warn("header search path '{}' not found in project '{}'".format(hdr_path, imp_proj_name))
imported[imp_proj_name]['hdrdirs'].append(hdr_path)
# add conditional header search paths
for imp_hdr in deps[imp_proj_name]['exports']['conditional-header-dirs'] :
if not 'path' in imp_hdr :
log.warn("no 'path' key in conditional-header-dirs in project {}".format(imp_proj_name))
elif not 'cond' in imp_hdr :
log.warn("no 'cond' key in conditional-header-dirs in project {}".format(imp_proj_name))
else :
hdr_path = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_hdr['path'])
hdr_path = os.path.normpath(hdr_path).replace('\\', '/')
if not os.path.isdir(hdr_path) :
log.warn("conditional header search path '{}' not found in project '{}'".format(hdr_path, imp_proj_name))
value = imp_hdr['cond']
imported[imp_proj_name]['condhdrdirs'][hdr_path] = value
# add lib search paths
for imp_lib in deps[imp_proj_name]['exports']['lib-dirs'] :
lib_path = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_lib)
lib_path = os.path.normpath(lib_path).replace('\\', '/')
if not os.path.isdir(lib_path) :
log.warn("lib search path '{}' not found in project '{}'".format(lib_path, imp_proj_name))
imported[imp_proj_name]['libdirs'].append(lib_path)
# add defines
for imp_def in deps[imp_proj_name]['exports']['defines'] :
# hmm, no check whether this define collides with an earlier define...
value = deps[imp_proj_name]['exports']['defines'][imp_def]
imported[imp_proj_name]['defines'][imp_def] = value
if imp_def in unique_defines :
if unique_defines[imp_def] != value :
log.warn("C define collision: '{}={}' in '{}' collides with '{}={}' in earlier import".format(
imp_def, value, imp_proj_name, imp_def, unique_defines[define]))
unique_defines[imp_def] = value
# for each imported module:
for imp_mod in deps[imp_proj_name]['exports']['modules'] :
imp_mod_src = deps[imp_proj_name]['exports']['modules'][imp_mod]
# import module source directory (where module's CMakeLists.txt is)
src_dir = '{}/{}/{}'.format(ws_dir, imp_proj_name, imp_mod_src)
# cmake build subdirectory
build_dir = '{}_{}'.format(imp_proj_name, imp_mod)
imported[imp_proj_name]['modules'][src_dir] = build_dir
if imp_mod in unique_modules :
if unique_modules[imp_mod] != src_dir :
log.warn("Import module '{}=>{}' in '{}' collides with '{}=>{}' in earlier import".format(
imp_mod, src_dir, imp_proj_name, imp_mod, unique_modules[imp_mod]))
unique_modules[imp_mod] = src_dir
return imported
else :
log.warn("imports are incomplete, please run 'fips fetch'")
return None
def get_sdkroot_dir(fips_dir):
return util.get_workspace_dir(fips_dir) + '/fips-sdks'
def get_sdk_dir(fips_dir):
return util.get_workspace_dir(fips_dir) + '/fips-sdks/wasisdk'
def build(fips_dir, proj_dir):
# target directory will be 'fips-deploy/[proj]-markdeep
proj_name = util.get_project_name_from_dir(proj_dir)
out_dir = util.get_workspace_dir(fips_dir)+'/fips-deploy/'+proj_name+'-markdeep'
log.info('building to: {}...'.format(out_dir))
if os.path.isdir(out_dir):
shutil.rmtree(out_dir)
os.makedirs(out_dir)
# check all .h files for embedded documentation
hdrs = []
for root, dirnames, filenames in os.walk(proj_dir):
for filename in fnmatch.filter(filenames, '*.h'):
hdrs.append(os.path.join(root, filename).replace('\\','/'))
markdeep_files = []
capture_begin = re.compile(r'/\*#\s')
for hdr in hdrs:
log.info(' parsing {}'.format(hdr))
capturing = False
markdeep_lines = []
with open(hdr, 'r') as src:
lines = src.readlines()
for line in lines:
if "#*/" in line and capturing:
capturing = False
if capturing:
# remove trailing tab
if line.startswith(' '):
line = line[4:]
elif line.startswith('\t'):
line = line[1:]
markdeep_lines.append(line)
if capture_begin.match(line) and not capturing:
capturing = True
if markdeep_lines:
markdeep_files.append(hdr)
dst_path = out_dir + '/' + os.path.relpath(hdr,proj_dir) + '.html'
log.info(' markdeep block(s) found, writing: {}'.format(dst_path))
dst_dir = os.path.dirname(dst_path)
if not os.path.isdir(dst_dir):
os.makedirs(dst_dir)
with open(dst_path, 'w') as dst:
dst.write("<meta charset='utf-8' emacsmode='-*- markdown -*-'>\n")
dst.write("<link rel='stylesheet' href='https://casual-effects.com/markdeep/latest/apidoc.css?'>\n")
for line in markdeep_lines:
dst.write(line)
dst.write("<script>markdeepOptions={tocStyle:'medium'};</script>")
dst.write("<!-- Markdeep: --><script src='https://casual-effects.com/markdeep/latest/markdeep.min.js?'></script>")
# write a toplevel index.html
if markdeep_files:
markdeep_files = sorted(markdeep_files)
dst_path = out_dir + '/index.html'
log.info('writing toc file: {}'.format(dst_path))
with open(dst_path, 'w') as dst:
dst.write("<meta charset='utf-8' emacsmode='-*- markdown -*-'>\n")
dst.write("<link rel='stylesheet' href='https://casual-effects.com/markdeep/latest/apidoc.css?'>\n")
dst.write('# {}\n'.format(proj_name))
for hdr in markdeep_files:
rel_path = os.path.relpath(hdr,proj_dir)
dst.write('- [{}]({})\n'.format(rel_path, rel_path+'.html'))
dst.write("<script>markdeepOptions={tocStyle:'medium'};</script>")
dst.write("<!-- Markdeep: --><script src='https://casual-effects.com/markdeep/latest/markdeep.min.js?'></script>")
else:
log.error("no headers with embedded markdeep found in '{}'!".format(proj_dir))
